Subversion Repositories SmartDukaan

Rev

Rev 7293 | Rev 7311 | Go to most recent revision | Details | Compare with Previous | Last modification | View Log | RSS feed

Rev Author Line No. Line
94 ashish 1 
#
3431 rajveer 2 
# Autogenerated by Thrift Compiler (0.7.0)
94 ashish 3 
#
4 
# DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
5 
#
6 
 
7 
from thrift.Thrift import *
3376 rajveer 8 
import shop2020.thriftpy.generic.GenericService
94 ashish 9 
from ttypes import *
10 
from thrift.Thrift import TProcessor
11 
from thrift.transport import TTransport
3431 rajveer 12 
from thrift.protocol import TBinaryProtocol, TProtocol
94 ashish 13 
try:
14 
  from thrift.protocol import fastbinary
15 
except:
16 
  fastbinary = None
17 
 
18 
 
3376 rajveer 19 
class Iface(shop2020.thriftpy.generic.GenericService.Iface):
94 ashish 20 
  def createTransaction(self, transaction):
21 
    """
22 
    Parameters:
23 
     - transaction
24 
    """
25 
    pass
26 
 
27 
  def getTransaction(self, id):
28 
    """
29 
    Parameters:
30 
     - id
31 
    """
32 
    pass
33 
 
34 
  def getTransactionsForCustomer(self, customerId, from_date, to_date, status):
35 
    """
36 
    Parameters:
37 
     - customerId
38 
     - from_date
39 
     - to_date
40 
     - status
41 
    """
42 
    pass
43 
 
132 ashish 44 
  def getTransactionsForShoppingCartId(self, shoppingCartId):
45 
    """
46 
    Parameters:
47 
     - shoppingCartId
48 
    """
49 
    pass
50 
 
94 ashish 51 
  def getTransactionStatus(self, transactionId):
52 
    """
53 
    Parameters:
54 
     - transactionId
55 
    """
56 
    pass
57 
 
7293 anupam.sin 58 
  def changeTransactionStatus(self, transactionId, status, description, pickUp, orderType, source):
94 ashish 59 
    """
60 
    Parameters:
61 
     - transactionId
62 
     - status
63 
     - description
5527 anupam.sin 64 
     - pickUp
65 
     - orderType
7293 anupam.sin 66 
     - source
94 ashish 67 
    """
68 
    pass
69 
 
1398 varun.gupt 70 
  def enqueueTransactionInfoEmail(self, transactionId):
1382 varun.gupt 71 
    """
72 
    Parameters:
73 
     - transactionId
74 
    """
75 
    pass
76 
 
4801 anupam.sin 77 
  def getAllOrders(self, statuses, from_date, to_date, warehouse_id):
94 ashish 78 
    """
79 
    Parameters:
4801 anupam.sin 80 
     - statuses
483 rajveer 81 
     - from_date
82 
     - to_date
83 
     - warehouse_id
94 ashish 84 
    """
85 
    pass
86 
 
4133 chandransh 87 
  def getOrdersInBatch(self, statuses, offset, limit, warehouse_id):
88 
    """
89 
    Returns at most 'limit' orders with the given statuses for the given warehouse starting from the given offset.
90 
    Pass the status as null and the limit as 0 to ignore them.
91 
 
92 
    Parameters:
93 
     - statuses
94 
     - offset
95 
     - limit
96 
     - warehouse_id
97 
    """
98 
    pass
99 
 
100 
  def getOrderCount(self, statuses, warehouseId):
101 
    """
102 
    Returns the count of orders with the given statuses assigned to the given warehouse.
103 
 
104 
    Parameters:
105 
     - statuses
106 
     - warehouseId
107 
    """
108 
    pass
109 
 
999 varun.gupt 110 
  def getOrdersByBillingDate(self, status, start_billing_date, end_billing_date, warehouse_id):
111 
    """
1132 chandransh 112 
    Returns orders within a range of their billing dates
3431 rajveer 113 
 
999 varun.gupt 114 
    Parameters:
115 
     - status
116 
     - start_billing_date
117 
     - end_billing_date
118 
     - warehouse_id
119 
    """
120 
    pass
121 
 
3451 chandransh 122 
  def getOrdersByShippingDate(self, fromShippingDate, toShippingDate, providerId, warehouseId, cod):
3427 chandransh 123 
    """
124 
    Returns orders for a particular provider and warehouse which were shipped between the given dates.
3451 chandransh 125 
    Returned orders comprise of COD orders if cod parameter is true. It comprises of prepaid orders otherwise.
126 
    Pass providerId and warehouseId as -1 to ignore both these parameters.
3431 rajveer 127 
 
3427 chandransh 128 
    Parameters:
129 
     - fromShippingDate
130 
     - toShippingDate
131 
     - providerId
132 
     - warehouseId
3451 chandransh 133 
     - cod
3427 chandransh 134 
    """
135 
    pass
136 
 
1382 varun.gupt 137 
  def getReturnableOrdersForCustomer(self, customer_id, limit):
138 
    """
139 
    Returns order ids for orders which can be returned
3431 rajveer 140 
 
1382 varun.gupt 141 
    Parameters:
142 
     - customer_id
143 
     - limit
144 
    """
145 
    pass
146 
 
147 
  def getCancellableOrdersForCustomer(self, customer_id, limit):
148 
    """
149 
    Returns order ids for orders which can be cancelled
3431 rajveer 150 
 
1382 varun.gupt 151 
    Parameters:
152 
     - customer_id
153 
     - limit
154 
    """
155 
    pass
156 
 
483 rajveer 157 
  def changeOrderStatus(self, orderId, status, description):
94 ashish 158 
    """
159 
    Parameters:
483 rajveer 160 
     - orderId
161 
     - status
162 
     - description
94 ashish 163 
    """
164 
    pass
165 
 
1528 ankur.sing 166 
  def getOrdersForTransaction(self, transactionId, customerId):
94 ashish 167 
    """
1528 ankur.sing 168 
    Returns list of orders for given transaction Id. Also filters based on customer Id so that
169 
    only user who owns the transaction can view its order details.
3431 rajveer 170 
 
94 ashish 171 
    Parameters:
172 
     - transactionId
1528 ankur.sing 173 
     - customerId
94 ashish 174 
    """
175 
    pass
176 
 
3014 chandransh 177 
  def getOrdersForCustomer(self, customerId, from_date, to_date, statuses):
94 ashish 178 
    """
3014 chandransh 179 
    Returns list of orders for the given customer created between the given dates and having the given statuses.
180 
    Pass and empty list to ignore filtering on statuses.
3431 rajveer 181 
 
94 ashish 182 
    Parameters:
483 rajveer 183 
     - customerId
184 
     - from_date
185 
     - to_date
3014 chandransh 186 
     - statuses
94 ashish 187 
    """
188 
    pass
189 
 
483 rajveer 190 
  def createOrder(self, order):
94 ashish 191 
    """
192 
    Parameters:
483 rajveer 193 
     - order
94 ashish 194 
    """
195 
    pass
196 
 
483 rajveer 197 
  def getOrder(self, id):
94 ashish 198 
    """
199 
    Parameters:
483 rajveer 200 
     - id
94 ashish 201 
    """
202 
    pass
203 
 
483 rajveer 204 
  def getLineItemsForOrder(self, orderId):
94 ashish 205 
    """
206 
    Parameters:
483 rajveer 207 
     - orderId
94 ashish 208 
    """
209 
    pass
210 
 
4999 phani.kuma 211 
  def getOrderList(self, order_ids):
212 
    """
213 
    Parameters:
214 
     - order_ids
215 
    """
216 
    pass
217 
 
5386 phani.kuma 218 
  def getOrderListForVendor(self, order_ids, vendorId):
219 
    """
220 
    Parameters:
221 
     - order_ids
222 
     - vendorId
223 
    """
224 
    pass
225 
 
1528 ankur.sing 226 
  def getOrderForCustomer(self, orderId, customerId):
227 
    """
228 
    Returns an order for the order Id. Also checks if the order belongs to the customer whose Id is passed.
229 
    Throws exception if either order Id is invalid or order does not below to the customer whose Id is passed.
3431 rajveer 230 
 
1528 ankur.sing 231 
    Parameters:
232 
     - orderId
233 
     - customerId
234 
    """
235 
    pass
236 
 
4444 rajveer 237 
  def getAlerts(self, type, warehouseId, status, timestamp):
3064 chandransh 238 
    """
239 
    Parameters:
4394 rajveer 240 
     - type
4444 rajveer 241 
     - warehouseId
4394 rajveer 242 
     - status
243 
     - timestamp
3064 chandransh 244 
    """
245 
    pass
246 
 
4444 rajveer 247 
  def addAlert(self, type, warehouseId, description):
3064 chandransh 248 
    """
249 
    Parameters:
250 
     - type
4444 rajveer 251 
     - warehouseId
4394 rajveer 252 
     - description
3064 chandransh 253 
    """
254 
    pass
255 
 
4444 rajveer 256 
  def markAlertsAsSeen(self, warehouseId):
257 
    """
258 
    Parameters:
259 
     - warehouseId
260 
    """
261 
    pass
262 
 
3064 chandransh 263 
  def getValidOrderCount(self, ):
264 
    """
265 
    Return the number of valid orders. (OrderStatus >= OrderStatus.SUBMITTED_FOR_PROCESSING)
266 
    """
267 
    pass
268 
 
269 
  def getNoOfCustomersWithSuccessfulTransaction(self, ):
270 
    """
271 
    Returns the number of distinct customers who have done successful transactions
272 
    """
273 
    pass
274 
 
275 
  def getValidOrdersAmountRange(self, ):
276 
    """
277 
    Returns the minimum and maximum amounts of a valid order. (OrderStatus >= OrderStatus.SUBMITTED_FOR_PROCESSING)
278 
    List contains two values, first minimum amount and second maximum amount.
279 
    """
280 
    pass
281 
 
5874 rajveer 282 
  def getValidOrders(self, limit, onlyStore):
3064 chandransh 283 
    """
284 
    Returns list of Orders in descending order by Order creation date. List is restricted to limit Orders.
285 
    If limit is passed as 0, then all valid Orders are returned.
3431 rajveer 286 
 
3064 chandransh 287 
    Parameters:
288 
     - limit
5874 rajveer 289 
     - onlyStore
3064 chandransh 290 
    """
291 
    pass
292 
 
1220 chandransh 293 
  def batchOrders(self, warehouseId):
294 
    """
295 
    Create a batch of all the pending orders for the given warehouse.
296 
    The returned list is orderd by created_timestamp.
297 
    If there are no pending orders, an empty list is returned.
3431 rajveer 298 
 
1220 chandransh 299 
    Parameters:
300 
     - warehouseId
301 
    """
302 
    pass
303 
 
1208 chandransh 304 
  def markOrderAsOutOfStock(self, orderId):
305 
    """
306 
    Mark the given order as out of stock. Throws an exception if the order with the given Id couldn't be found.
3431 rajveer 307 
 
1208 chandransh 308 
    Parameters:
309 
     - orderId
310 
    """
311 
    pass
312 
 
3064 chandransh 313 
  def verifyOrder(self, orderId):
759 chandransh 314 
    """
3064 chandransh 315 
    Marks the given order as SUBMITTED_FOR_PROCESSING and updates the verified
316 
    timestamp. It is intended to be used for COD orders but can be harmlessly
317 
    used for all other orders as well.
318 
    Throws an exception if no such order exists.
3431 rajveer 319 
 
759 chandransh 320 
    Parameters:
3064 chandransh 321 
     - orderId
322 
    """
323 
    pass
324 
 
325 
  def acceptOrder(self, orderId):
326 
    """
327 
    Marks the given order as ACCEPTED and updates the accepted timestamp. If the
328 
    given order is not a COD order, it also captures the payment if the same has
329 
    not been captured.
330 
    Throws an exception if no such order exists.
3431 rajveer 331 
 
3064 chandransh 332 
    Parameters:
333 
     - orderId
334 
    """
335 
    pass
336 
 
7190 amar.kumar 337 
  def addBillingDetails(self, orderId, invoice_number, serialNumber, itemNumber, freebieWarehouseId, billed_by, jacketNumber, billingType, fulfilmentWarehouseId, authorize):
3064 chandransh 338 
    """
339 
    Add billing details such as the bill number and the biller to the Order.
4658 mandeep.dh 340 
    Adds jacket number, item number and Serial no. to the order. Doesn't update
3064 chandransh 341 
    the IMEI no. if a -1 is supplied.
342 
    Also, it generates an invoice number for the order, marks the order as
343 
    BILLED and sets the billing timestamp.
344 
    Returns false if it doesn't find the order with the given ID.
3431 rajveer 345 
 
3064 chandransh 346 
    Parameters:
347 
     - orderId
4283 anupam.sin 348 
     - invoice_number
4658 mandeep.dh 349 
     - serialNumber
3064 chandransh 350 
     - itemNumber
7190 amar.kumar 351 
     - freebieWarehouseId
4283 anupam.sin 352 
     - billed_by
353 
     - jacketNumber
3064 chandransh 354 
     - billingType
5110 mandeep.dh 355 
     - fulfilmentWarehouseId
4763 rajveer 356 
     - authorize
3064 chandransh 357 
    """
358 
    pass
359 
 
6756 amar.kumar 360 
  def addInvoiceNumber(self, orderId, invoiceNumber, color, serialNumber, itemNumber):
4579 rajveer 361 
    """
362 
    Add the invoice number to the order.
363 
 
364 
    Parameters:
365 
     - orderId
366 
     - invoiceNumber
4763 rajveer 367 
     - color
6756 amar.kumar 368 
     - serialNumber
369 
     - itemNumber
4579 rajveer 370 
    """
371 
    pass
372 
 
4910 phani.kuma 373 
  def markOrdersAsShippedFromWarehouse(self, warehouseId, providerId, cod, orderIds):
3064 chandransh 374 
    """
375 
    Depending on the third parameter, marks either all prepaid or all cod orders BILLED by the
4910 phani.kuma 376 
    given warehouse and were picked up by the given provider as SHIPPED_FROM_WH.
4410 rajveer 377 
 
378 
    Parameters:
379 
     - warehouseId
380 
     - providerId
381 
     - cod
4910 phani.kuma 382 
     - orderIds
4410 rajveer 383 
    """
384 
    pass
385 
 
5713 rajveer 386 
  def markOrdersAsReturnedFromStore(self, providerId, orderIds, awbs):
5676 rajveer 387 
    """
388 
    Parameters:
389 
     - providerId
390 
     - orderIds
5713 rajveer 391 
     - awbs
5676 rajveer 392 
    """
393 
    pass
394 
 
4910 phani.kuma 395 
  def markOrdersAsPickedUp(self, providerId, pickupDetails):
4410 rajveer 396 
    """
4910 phani.kuma 397 
    Marks all SHIPPED_FROM_WH orders of the previous day for a provider as SHIPPED_TO_LOGISTICS.
398 
    Raises an exception if we encounter report for an AWB number that we did not ship.
3431 rajveer 399 
 
3064 chandransh 400 
    Parameters:
759 chandransh 401 
     - providerId
4910 phani.kuma 402 
     - pickupDetails
759 chandransh 403 
    """
404 
    pass
405 
 
4910 phani.kuma 406 
  def getOrdersNotPickedUp(self, providerId):
1113 chandransh 407 
    """
408 
    Returns a list of orders that were shipped from warehouse but did not appear in the pick-up report.
3431 rajveer 409 
 
1113 chandransh 410 
    Parameters:
411 
     - providerId
412 
    """
413 
    pass
414 
 
1132 chandransh 415 
  def markOrdersAsDelivered(self, providerId, deliveredOrders):
416 
    """
417 
    Marks all orders with AWBs in the given map as delivered. Also sets the delivery timestamp and
418 
    the name of the receiver.
419 
    Raises an exception if we encounter report for an AWB number that we did not ship.
3431 rajveer 420 
 
1132 chandransh 421 
    Parameters:
422 
     - providerId
423 
     - deliveredOrders
424 
    """
425 
    pass
426 
 
4910 phani.kuma 427 
  def markAsRTOrders(self, providerId, returnedOrders):
1135 chandransh 428 
    """
4910 phani.kuma 429 
    Mark all orders with AWBs in the given map as RTO. Also sets the delivery timestamp.
1135 chandransh 430 
    Raises an exception if we encounter report for an AWB number that we did not ship.
3431 rajveer 431 
 
1135 chandransh 432 
    Parameters:
433 
     - providerId
434 
     - returnedOrders
435 
    """
436 
    pass
437 
 
4910 phani.kuma 438 
  def getRTOrders(self, providerId):
439 
    """
440 
    Returns a list of orders that were returned by courier.
441 
 
442 
    Parameters:
443 
     - providerId
444 
    """
445 
    pass
446 
 
1246 chandransh 447 
  def updateNonDeliveryReason(self, providerId, undeliveredOrders):
448 
    """
449 
    Update the status description of orders whose AWB numbers are keys of the Map.
3431 rajveer 450 
 
1246 chandransh 451 
    Parameters:
452 
     - providerId
453 
     - undeliveredOrders
454 
    """
455 
    pass
456 
 
4910 phani.kuma 457 
  def getNonDeliveredOrdersbyCourier(self, providerId):
458 
    """
459 
    Returns a list of orders that were picked up or shipped four days ago but did not get delivered.
460 
 
461 
    Parameters:
462 
     - providerId
463 
    """
464 
    pass
465 
 
466 
  def markOrdersAsLocalConnected(self, providerId, local_connected_orders):
467 
    """
468 
    Mark all orders with AWBs in the given map as local connected. Also sets the local connected timestamp.
469 
 
470 
    Parameters:
471 
     - providerId
472 
     - local_connected_orders
473 
    """
474 
    pass
475 
 
476 
  def getOrdersNotLocalConnected(self, providerId):
477 
    """
478 
    Returns a list of orders that were picked up or shipped but pending local connection.
479 
 
480 
    Parameters:
481 
     - providerId
482 
    """
483 
    pass
484 
 
485 
  def markOrdersAsDestinationCityReached(self, providerId, destination_city_reached_orders):
486 
    """
487 
    Mark all orders with AWBs in the given map as reached destination city. Also sets the reached destination timestamp.
488 
 
489 
    Parameters:
490 
     - providerId
491 
     - destination_city_reached_orders
492 
    """
493 
    pass
494 
 
495 
  def markOrdersAsFirstDeliveryAttempted(self, providerId, first_atdl_orders):
496 
    """
497 
    Mark all orders with AWBs in the given map as first delivery attempt made. Also sets the first delivery attempted timestamp.
498 
 
499 
    Parameters:
500 
     - providerId
501 
     - first_atdl_orders
502 
    """
503 
    pass
504 
 
1408 ankur.sing 505 
  def getUndeliveredOrders(self, providerId, warehouseId):
506 
    """
507 
    Returns the list of orders whose delivery time has passed but have not been
508 
    delivered yet for the given provider and warehouse. To get a complete list of
509 
    undelivered orders, pass them as -1.
510 
    Returns an empty list if no such orders exist.
3431 rajveer 511 
 
1408 ankur.sing 512 
    Parameters:
513 
     - providerId
514 
     - warehouseId
515 
    """
516 
    pass
517 
 
4783 phani.kuma 518 
  def getUndeliveredOrdersExpectedDeliveryDateNotMet(self, ):
519 
    """
520 
    Returns the list of orders whose expected delivery date has passed but have not been
521 
    delivered yet.
522 
    Returns an empty list if no such orders exist.
523 
    """
524 
    pass
525 
 
2536 chandransh 526 
  def toggleDOAFlag(self, orderId):
527 
    """
528 
    Toggle the DOA flag of an order. This should be used to flag an order for follow-up and unflag it when the follow-up is complete.
529 
    Returns the final flag status.
530 
    Throws an exception if the order with the given id couldn't be found or if the order status is not DELVIERY_SUCCESS.
3431 rajveer 531 
 
2536 chandransh 532 
    Parameters:
533 
     - orderId
534 
    """
535 
    pass
1886 ankur.sing 536 
 
4712 rajveer 537 
  def markOrderAsDelivered(self, orderId, deliveryTimestamp, receiver):
538 
    """
539 
    Parameters:
540 
     - orderId
541 
     - deliveryTimestamp
542 
     - receiver
543 
    """
544 
    pass
545 
 
5553 rajveer 546 
  def markOrderAsReceivedAtStore(self, orderId, deliveryTimestamp):
547 
    """
548 
    Parameters:
549 
     - orderId
550 
     - deliveryTimestamp
551 
    """
552 
    pass
553 
 
4454 rajveer 554 
  def markOrderDoaRequestReceived(self, orderId):
555 
    """
556 
    Once user raise the request for a DOA, order status will be changed from DELVIERY_SUCCESS to DOA_REQUEST_RECEIVED
557 
 
558 
    Parameters:
559 
     - orderId
560 
    """
561 
    pass
562 
 
563 
  def markOrderDoaRequestAuthorized(self, orderId, isAuthorized):
564 
    """
565 
    CRM person can authorize or deny the request reised by customer. If he authorizes order will change from DOA_REQUEST_RECEIVED
566 
    to DOA_REQUEST_AUTHORIZED. If he denies, status will be changed back to DELVIERY_SUCCESS.
567 
 
568 
    Parameters:
569 
     - orderId
570 
     - isAuthorized
571 
    """
572 
    pass
573 
 
4488 rajveer 574 
  def markOrderReturnRequestReceived(self, orderId):
575 
    """
576 
    Once user raise the request for a RET, order status will be changed from DELVIERY_SUCCESS to RET_REQUEST_RECEIVED
577 
 
578 
    Parameters:
579 
     - orderId
580 
    """
581 
    pass
582 
 
583 
  def markOrderReturnRequestAuthorized(self, orderId, isAuthorized):
584 
    """
585 
    CRM person can authorize or deny the request reised by customer. If he authorizes order will change from RET_REQUEST_RECEIVED
586 
    to RET_REQUEST_AUTHORIZED. If he denies, status will be changed back to DELVIERY_SUCCESS.
587 
 
588 
    Parameters:
589 
     - orderId
590 
     - isAuthorized
591 
    """
592 
    pass
593 
 
4579 rajveer 594 
  def requestPickupNumber(self, orderId, providerId):
2536 chandransh 595 
    """
596 
    Sends out an email to the account manager of the original courier provider used to ship the order.
4452 rajveer 597 
    If the order status was DELIVERY_SUCCESS, it is changed to be DOA_PICKUP_REQUEST_RAISED.
598 
    If the order status was DOA_PICKUP_REQUEST_RAISED, it is left unchanged.
2536 chandransh 599 
    For any other status, it returns false.
600 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 601 
 
2536 chandransh 602 
    Parameters:
603 
     - orderId
4579 rajveer 604 
     - providerId
2536 chandransh 605 
    """
606 
    pass
607 
 
4602 rajveer 608 
  def authorizePickup(self, orderId, pickupNumber, providerId):
2536 chandransh 609 
    """
4452 rajveer 610 
    If the order status is DOA_PICKUP_REQUEST_RAISED, it does the following
2536 chandransh 611 
    	1. Sends out an email to the customer with the dispatch advice that he has to print as an attachment.
612 
    	2. Changes order status to be DOA_PICKUP_AUTHORIZED.
613 
    	3. Returns true
2591 chandransh 614 
    If the order is in any other status, it returns false.
2536 chandransh 615 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 616 
 
2536 chandransh 617 
    Parameters:
618 
     - orderId
619 
     - pickupNumber
4602 rajveer 620 
     - providerId
2536 chandransh 621 
    """
622 
    pass
623 
 
2764 chandransh 624 
  def markDoasAsPickedUp(self, providerId, pickupDetails):
625 
    """
626 
    Marks all DOA_PICKUP_AUTHORIZED orders of the previous day for a provider as DOA_RETURN_IN_TRANSIT.
3431 rajveer 627 
 
2764 chandransh 628 
    Parameters:
629 
     - providerId
630 
     - pickupDetails
631 
    """
632 
    pass
633 
 
4910 phani.kuma 634 
  def getDoasNotPickedUp(self, providerId):
635 
    """
636 
    Returns a list of orders that were authorized for pickup but did not appear in the pick-up report.
637 
 
638 
    Parameters:
639 
     - providerId
640 
    """
641 
    pass
642 
 
4741 phani.kuma 643 
  def markReturnOrdersAsPickedUp(self, providerId, pickupDetails):
644 
    """
645 
    Marks all RET_PICKUP_CONFIRMED orders of the previous day for a provider as RET_RETURN_IN_TRANSIT.
646 
 
647 
    Parameters:
648 
     - providerId
649 
     - pickupDetails
650 
    """
651 
    pass
652 
 
4910 phani.kuma 653 
  def getReturnOrdersNotPickedUp(self, providerId):
654 
    """
655 
    Returns a list of orders that were authorized for pickup but did not appear in the pick-up report.
656 
 
657 
    Parameters:
658 
     - providerId
659 
    """
660 
    pass
661 
 
4479 rajveer 662 
  def receiveReturn(self, orderId, receiveCondition):
2591 chandransh 663 
    """
4452 rajveer 664 
    If the order status is DOA_PICKUP_CONFIRMED or DOA_RETURN_IN_TRANSIT, marks the order status as DOA_RECEIVED_PRESTINE and returns true.
4484 rajveer 665 
    If the order status is RTO_IN_TRANSIT, marks the order status as RTO_RECEIVED_PRESTINE and returns true.
2591 chandransh 666 
    If the order is in any other state, it returns false.
667 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 668 
 
2591 chandransh 669 
    Parameters:
670 
     - orderId
4479 rajveer 671 
     - receiveCondition
2591 chandransh 672 
    """
673 
    pass
2536 chandransh 674 
 
2591 chandransh 675 
  def validateDoa(self, orderId, isValid):
676 
    """
4452 rajveer 677 
    Used to validate the DOA certificate for an order in the DOA_RECEIVED_PRESTINE state. If the certificate is valid,
2616 chandransh 678 
    the order state is changed to DOA_CERT_VALID. If the certificate is invalid, the order state is changed to DOA_CERT_INVALID.
2591 chandransh 679 
    If the order is in any other state, it returns false.
680 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 681 
 
2591 chandransh 682 
    Parameters:
683 
     - orderId
684 
     - isValid
685 
    """
686 
    pass
687 
 
4495 rajveer 688 
  def validateReturnProduct(self, orderId, isUsable):
689 
    """
690 
    Parameters:
691 
     - orderId
692 
     - isUsable
693 
    """
694 
    pass
695 
 
2616 chandransh 696 
  def reshipOrder(self, orderId):
697 
    """
4484 rajveer 698 
    If the order is in RTO_RECEIVED_PRESTINE or DOA_CERT_INVALID state, it does the following:
2616 chandransh 699 
    	1. Creates a new order for processing in the BILLED state. All billing information is saved.
4484 rajveer 700 
    	2. Marks the current order as one of the final states RTO_RESHIPPED and DOA_INVALID_RESHIPPED depending on what state the order started in.
2616 chandransh 701 
 
702 
    If the order is in DOA_CERT_VALID state, it does the following:
703 
    	1. Creates a new order for processing in the SUBMITTED_FOR_PROCESSING state.
704 
    	2. Creates a return order for the warehouse executive to return the DOA material.
4452 rajveer 705 
    	3. Marks the current order as the final DOA_VALID_RESHIPPED state.
3431 rajveer 706 
 
2616 chandransh 707 
    Returns the id of the newly created order.
3431 rajveer 708 
 
2616 chandransh 709 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 710 
 
2616 chandransh 711 
    Parameters:
712 
     - orderId
713 
    """
714 
    pass
2591 chandransh 715 
 
3226 chandransh 716 
  def refundOrder(self, orderId, refundedBy, reason):
2616 chandransh 717 
    """
4484 rajveer 718 
    If the order is in RTO_RECEIVED_PRESTINE, DOA_CERT_VALID or DOA_CERT_INVALID state, it does the following:
2616 chandransh 719 
    	1. Creates a refund request for batch processing.
720 
    	2. Creates a return order for the warehouse executive to return the shipped material.
4484 rajveer 721 
    	3. Marks the current order as RTO_REFUNDED, DOA_VALID_REFUNDED or DOA_INVALID_REFUNDED final states.
3431 rajveer 722 
 
2616 chandransh 723 
    If the order is in SUBMITTED_FOR_PROCESSING or INVENTORY_LOW state, it does the following:
724 
    	1. Creates a refund request for batch processing.
3226 chandransh 725 
    	2. Cancels the reservation of the item in the warehouse.
726 
    	3. Marks the current order as the REFUNDED final state.
3431 rajveer 727 
 
3226 chandransh 728 
    For all COD orders, if the order is in INIT, SUBMITTED_FOR_PROCESSING or INVENTORY_LOW state, it does the following:
729 
    	1. Cancels the reservation of the item in the warehouse.
730 
    	2. Marks the current order as CANCELED.
731 
 
732 
    In all cases, it updates the reason for cancellation or refund and the person who performed the action.
733 
 
2616 chandransh 734 
    Returns True if it is successful, False otherwise.
3431 rajveer 735 
 
2616 chandransh 736 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 737 
 
2616 chandransh 738 
    Parameters:
739 
     - orderId
3226 chandransh 740 
     - refundedBy
741 
     - reason
2616 chandransh 742 
    """
743 
    pass
744 
 
2690 chandransh 745 
  def getReturnOrders(self, warehouseId, fromDate, toDate):
746 
    """
747 
    Get all return orders created between the from and to dates for the given warehouse.
748 
    Ignores the warehouse if it is passed as -1.
3431 rajveer 749 
 
2690 chandransh 750 
    Parameters:
751 
     - warehouseId
752 
     - fromDate
753 
     - toDate
754 
    """
755 
    pass
2616 chandransh 756 
 
5481 phani.kuma 757 
  def getAllReturnOrders(self, onlyNotProcessed, fromDate, toDate):
758 
    """
759 
    Get all return orders created between the from and to dates.
760 
 
761 
    Parameters:
762 
     - onlyNotProcessed
763 
     - fromDate
764 
     - toDate
765 
    """
766 
    pass
767 
 
2700 chandransh 768 
  def getReturnOrder(self, id):
769 
    """
770 
    Returns the ReturnOrder corresponding to the given id.
771 
    Throws an exception if the return order with the given id couldn't be found.
3431 rajveer 772 
 
2700 chandransh 773 
    Parameters:
774 
     - id
775 
    """
776 
    pass
777 
 
2690 chandransh 778 
  def processReturn(self, returnOrderId):
779 
    """
780 
    Marks the return order with the given id as processed. Raises an exception if no such return order exists.
3431 rajveer 781 
 
2690 chandransh 782 
    Parameters:
783 
     - returnOrderId
784 
    """
785 
    pass
786 
 
3451 chandransh 787 
  def updateWeight(self, orderId, weight):
788 
    """
789 
    Set the weight of the given order to the provided value. Will attempt to update the weight of the item in the catalog as well.
2819 chandransh 790 
 
3451 chandransh 791 
    Parameters:
792 
     - orderId
793 
     - weight
794 
    """
795 
    pass
796 
 
3469 chandransh 797 
  def changeItem(self, orderId, itemId):
798 
    """
799 
    Change the item to be shipped for this order. Also adjusts the reservation in the inventory accordingly.
800 
    Currently, it also ensures that only a different color of the given item is shipped.
3451 chandransh 801 
 
3469 chandransh 802 
    Parameters:
803 
     - orderId
804 
     - itemId
805 
    """
806 
    pass
807 
 
808 
  def shiftToWarehouse(self, orderId, warehouseId):
809 
    """
810 
    Moves the given order to the given warehouse. Also adjusts the inventory reservations accordingly.
811 
 
812 
    Parameters:
813 
     - orderId
814 
     - warehouseId
815 
    """
816 
    pass
817 
 
4647 rajveer 818 
  def addDelayReason(self, orderId, delayReason, furtherDelay, delayReasonText):
3553 chandransh 819 
    """
820 
    Adds the given delay reason to the given order.
3986 chandransh 821 
    Increases the expected delivery time of the given order by the given no. of days.
3553 chandransh 822 
    Raises an exception if no order with the given id can be found.
3469 chandransh 823 
 
3553 chandransh 824 
    Parameters:
825 
     - orderId
826 
     - delayReason
3986 chandransh 827 
     - furtherDelay
4647 rajveer 828 
     - delayReasonText
3553 chandransh 829 
    """
830 
    pass
831 
 
3956 chandransh 832 
  def reconcileCodCollection(self, collectedAmountMap, xferBy, xferTxnId, xferDate):
833 
    """
834 
    Marks the COD orders with given AWB nos. as having been processed.
835 
    Updates the captured amount for the corresponding payment.
3553 chandransh 836 
 
3956 chandransh 837 
    Returns a map of AWBs which were not processed and the associated reason. An AWB is not processed if:
838 
    1. There is no order corresponding to an AWB number.
839 
    2. The captured amount for a payment exceeds the total payment.
840 
    3. The order corresponding to an AWB no. is in a state prior to DELIVERY_SUCCESS.
841 
 
842 
    Parameters:
843 
     - collectedAmountMap
844 
     - xferBy
845 
     - xferTxnId
846 
     - xferDate
847 
    """
848 
    pass
849 
 
4008 mandeep.dh 850 
  def getTransactionsRequiringExtraProcessing(self, category):
851 
    """
4065 mandeep.dh 852 
    Returns the list of transaction ids that require some extra processing and
4008 mandeep.dh 853 
    which belong to a particular category. This is currently used by CRM
4065 mandeep.dh 854 
    application. If no such transaction ids are present, it returns an empty list.
3956 chandransh 855 
 
4008 mandeep.dh 856 
    Parameters:
857 
     - category
858 
    """
859 
    pass
860 
 
861 
  def markTransactionAsProcessed(self, transactionId, category):
862 
    """
863 
    Marks a particular transaction as processed for a particular cateogory.
4065 mandeep.dh 864 
    It essentially deletes the transaction id record for a particular
865 
    processing type category (if present) from DB.
866 
    This is currently used by CRM application.
4008 mandeep.dh 867 
 
868 
    Parameters:
869 
     - transactionId
870 
     - category
871 
    """
872 
    pass
873 
 
4018 chandransh 874 
  def getItemWiseRiskyOrdersCount(self, ):
875 
    """
876 
    Returns a map containing the number of risky orders keyed by item id. A risky order
877 
    is defined as one whose shipping date is about to expire.
878 
    """
879 
    pass
4008 mandeep.dh 880 
 
4295 varun.gupt 881 
  def getOrdersForItemIds(self, itemIds):
882 
    """
883 
    Returns a list of all orders which have items with given id
884 
 
885 
    Parameters:
886 
     - itemIds
887 
    """
888 
    pass
889 
 
4247 rajveer 890 
  def markOrderCancellationRequestReceived(self, orderId):
891 
    """
892 
    Mark order as cancellation request received. If customer sends request of cancellation of
893 
    a particular order, this method will be called. It will just change status of the order
894 
    depending on its current status. It also records the previous status, so that we can move
895 
    back to that status if cancellation request is denied.
4018 chandransh 896 
 
4247 rajveer 897 
    Parameters:
898 
     - orderId
899 
    """
900 
    pass
901 
 
902 
  def markOrderCancellationRequestConfirmed(self, orderId):
903 
    """
904 
    If we decide to to cancel order, CRM will call this method to move the status of order to
905 
    cancellation request confirmed. After this OM will be able to cancel the order.
906 
 
907 
    Parameters:
908 
     - orderId
909 
    """
910 
    pass
911 
 
912 
  def markOrderCancellationRequestDenied(self, orderId):
913 
    """
914 
    If we decide to not to cancel order, we will move the order ro previous status.
915 
 
916 
    Parameters:
917 
     - orderId
918 
    """
919 
    pass
920 
 
4258 rajveer 921 
  def markTransactionAsPaymentFlagRemoved(self, transactionId):
4247 rajveer 922 
    """
4258 rajveer 923 
    If we and/or payment gateway has decided to accept the payment, this method needs to be called.
924 
    Changed transaction and all orders status to payment accepted.
4247 rajveer 925 
 
926 
    Parameters:
4258 rajveer 927 
     - transactionId
4247 rajveer 928 
    """
929 
    pass
930 
 
4259 anupam.sin 931 
  def refundTransaction(self, transactionId, refundedBy, reason):
932 
    """
933 
    This method is called when a flagged payment is deemed unserviceable and the corresponding orders
934 
    need to be cancelled
4247 rajveer 935 
 
4259 anupam.sin 936 
    Parameters:
937 
     - transactionId
938 
     - refundedBy
939 
     - reason
940 
    """
941 
    pass
942 
 
4324 mandeep.dh 943 
  def updateShipmentAddress(self, orderId, addressId):
944 
    """
945 
    Updates shipment address of an order. Delivery and shipping date estimates
946 
    etc. are also updated here.
947 
 
948 
    Throws TransactionServiceException in case address change is not
949 
    possible due to certain reasons such as new pincode in address is
950 
    not serviceable etc.
951 
 
952 
    Parameters:
953 
     - orderId
954 
     - addressId
955 
    """
956 
    pass
957 
 
4285 rajveer 958 
  def acceptOrdersForItemId(self, itemId, inventory):
959 
    """
960 
    Marks the orders as ACCEPTED for the given itemId and inventory. It also updates the accepted timestamp. If the
961 
    given order is not a COD order, it also captures the payment if the same has not been captured.
4259 anupam.sin 962 
 
4285 rajveer 963 
    Parameters:
964 
     - itemId
965 
     - inventory
966 
    """
967 
    pass
968 
 
4369 rajveer 969 
  def markOrdersAsPORaised(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 970 
    """
971 
    Parameters:
972 
     - vendorId
973 
     - itemId
974 
     - quantity
975 
     - estimate
4369 rajveer 976 
     - isReminder
4303 rajveer 977 
    """
978 
    pass
4285 rajveer 979 
 
4369 rajveer 980 
  def markOrdersAsReversalInitiated(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 981 
    """
982 
    Parameters:
983 
     - vendorId
984 
     - itemId
985 
     - quantity
986 
     - estimate
4369 rajveer 987 
     - isReminder
4303 rajveer 988 
    """
989 
    pass
990 
 
4369 rajveer 991 
  def markOrdersAsNotAvailabke(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 992 
    """
993 
    Parameters:
994 
     - vendorId
995 
     - itemId
996 
     - quantity
997 
     - estimate
4369 rajveer 998 
     - isReminder
4303 rajveer 999 
    """
1000 
    pass
1001 
 
4369 rajveer 1002 
  def markOrdersAsTimeout(self, vendorId):
1003 
    """
1004 
    Parameters:
1005 
     - vendorId
1006 
    """
1007 
    pass
4303 rajveer 1008 
 
4662 rajveer 1009 
  def markOrderAsLostInTransit(self, orderId):
1010 
    """
1011 
    Mark order as LOST_IN_TRANSIT
1012 
 
1013 
    Parameters:
1014 
     - orderId
1015 
    """
1016 
    pass
1017 
 
4386 anupam.sin 1018 
  def getOrderForAwb(self, awb):
1019 
    """
1020 
    Returns the order corresponding to an AWB number
4369 rajveer 1021 
 
4386 anupam.sin 1022 
    Parameters:
1023 
     - awb
1024 
    """
1025 
    pass
1026 
 
4910 phani.kuma 1027 
  def getOrdersForProviderForStatus(self, logistics_provider_id, order_status_list):
4506 phani.kuma 1028 
    """
4910 phani.kuma 1029 
    Returns the order corresponding to a logistics provider id for a given list of order status
4386 anupam.sin 1030 
 
4506 phani.kuma 1031 
    Parameters:
1032 
     - logistics_provider_id
4910 phani.kuma 1033 
     - order_status_list
4506 phani.kuma 1034 
    """
1035 
    pass
1036 
 
4600 varun.gupt 1037 
  def getBilledOrdersForVendor(self, vendorId, billingDateFrom, billingDateTo):
1038 
    """
1039 
    Returns list of orders fullfiled from a certain vendor and billed in a given date range
4506 phani.kuma 1040 
 
4600 varun.gupt 1041 
    Parameters:
1042 
     - vendorId
1043 
     - billingDateFrom
1044 
     - billingDateTo
1045 
    """
1046 
    pass
1047 
 
4607 rajveer 1048 
  def getSlippedSippingDateOrders(self, ):
1049 
    pass
1050 
 
4709 rajveer 1051 
  def getCancelledOrders(self, cancelDateFrom, cancelDateTo):
1052 
    """
1053 
    Parameters:
1054 
     - cancelDateFrom
1055 
     - cancelDateTo
1056 
    """
1057 
    pass
1058 
 
4600 varun.gupt 1059 
  def saveBluedartSettlements(self, mapAWBAndAmount):
1060 
    """
1061 
    Parameters:
1062 
     - mapAWBAndAmount
1063 
    """
1064 
    pass
1065 
 
4905 varun.gupt 1066 
  def savePaymentSettlements(self, settlementDate, paymentGatewayId, referenceId, serviceTax, otherCharges, netCollection):
4600 varun.gupt 1067 
    """
1068 
    Parameters:
1069 
     - settlementDate
1070 
     - paymentGatewayId
4905 varun.gupt 1071 
     - referenceId
4600 varun.gupt 1072 
     - serviceTax
1073 
     - otherCharges
1074 
     - netCollection
1075 
    """
1076 
    pass
1077 
 
1078 
  def saveEBSSettlementSummary(self, settlementId, settlementDate, transactionDateFrom, transactionDateTo, amount):
1079 
    """
1080 
    Parameters:
1081 
     - settlementId
1082 
     - settlementDate
1083 
     - transactionDateFrom
1084 
     - transactionDateTo
1085 
     - amount
1086 
    """
1087 
    pass
1088 
 
5386 phani.kuma 1089 
  def getSettlementForPrepaid(self, referenceId, isRefund):
4600 varun.gupt 1090 
    """
1091 
    Parameters:
5189 varun.gupt 1092 
     - referenceId
1093 
     - isRefund
4600 varun.gupt 1094 
    """
1095 
    pass
1096 
 
5386 phani.kuma 1097 
  def getSettlementForCod(self, orderId, isRefund):
1098 
    """
1099 
    Parameters:
1100 
     - orderId
1101 
     - isRefund
1102 
    """
1103 
    pass
1104 
 
4600 varun.gupt 1105 
  def getEBSSettlementSummaries(self, ):
1106 
    pass
1107 
 
1108 
  def markEBSSettlementUploaded(self, settlementId):
1109 
    """
1110 
    Parameters:
1111 
     - settlementId
1112 
    """
1113 
    pass
1114 
 
1115 
  def getEBSSettlementDate(self, settlementId):
1116 
    """
1117 
    Parameters:
1118 
     - settlementId
1119 
    """
1120 
    pass
1121 
 
4715 varun.gupt 1122 
  def getSettlementsByDate(self, settlementDateFrom, settlementDateTo, isRefund):
1123 
    """
1124 
    Parameters:
1125 
     - settlementDateFrom
1126 
     - settlementDateTo
1127 
     - isRefund
1128 
    """
1129 
    pass
4600 varun.gupt 1130 
 
4715 varun.gupt 1131 
  def getReshippedOrderIds(self, orderIds):
1132 
    """
1133 
    Returns list of Order Ids, which belong to reshiped orders, shortlisted from a given list of Order Ids
1134 
 
1135 
    Parameters:
1136 
     - orderIds
1137 
    """
1138 
    pass
1139 
 
5481 phani.kuma 1140 
  def getBilledOrders(self, vendorId, onlyVendorNotPaid, billingDateFrom, billingDateTo):
4875 varun.gupt 1141 
    """
1142 
    Parameters:
1143 
     - vendorId
5481 phani.kuma 1144 
     - onlyVendorNotPaid
1145 
     - billingDateFrom
1146 
     - billingDateTo
4875 varun.gupt 1147 
    """
1148 
    pass
4757 mandeep.dh 1149 
 
5031 varun.gupt 1150 
  def getStatusDistributionOfOrders(self, startDate, endDate):
1151 
    """
1152 
    Parameters:
1153 
     - startDate
1154 
     - endDate
1155 
    """
1156 
    pass
4875 varun.gupt 1157 
 
5067 varun.gupt 1158 
  def getOrderIdsForStatus(self, status, startDatetime, endDatetime):
1159 
    """
1160 
    Parameters:
1161 
     - status
1162 
     - startDatetime
1163 
     - endDatetime
1164 
    """
1165 
    pass
5031 varun.gupt 1166 
 
5348 anupam.sin 1167 
  def updateCODAgent(self, agent, orderId):
1168 
    """
1169 
    Updates the agent who handled the COD verification call
1170 
 
1171 
    Parameters:
1172 
     - agent
1173 
     - orderId
1174 
    """
1175 
    pass
1176 
 
5099 varun.gupt 1177 
  def updateOrderAsPaidToVendor(self, orderId):
1178 
    """
1179 
    Parameters:
1180 
     - orderId
1181 
    """
1182 
    pass
5067 varun.gupt 1183 
 
5386 phani.kuma 1184 
  def updateOrderOnlyAsPaidToVendor(self, orderId):
1185 
    """
1186 
    Parameters:
1187 
     - orderId
1188 
    """
1189 
    pass
1190 
 
5208 varun.gupt 1191 
  def getRefundedOrdersMarkedPaid(self, ):
1192 
    pass
5099 varun.gupt 1193 
 
5447 anupam.sin 1194 
  def getAllVerificationAgents(self, minOrderId, maxOrderId):
1195 
    """
1196 
    gets all COD Verification Agents for all orderIds from a minId to maxId
5208 varun.gupt 1197 
 
5447 anupam.sin 1198 
 
1199 
    Parameters:
1200 
     - minOrderId
1201 
     - maxOrderId
1202 
    """
1203 
    pass
1204 
 
5527 anupam.sin 1205 
  def getAllAttributesForOrderId(self, orderId):
1206 
    """
1207 
    gets all attributes for a given orderId
5447 anupam.sin 1208 
 
5527 anupam.sin 1209 
    Parameters:
1210 
     - orderId
1211 
    """
1212 
    pass
1213 
 
5676 rajveer 1214 
  def setOrderAttributes(self, orderId, attributes):
1215 
    """
1216 
    sets attributes for an order
1217 
 
1218 
    Parameters:
1219 
     - orderId
1220 
     - attributes
1221 
    """
1222 
    pass
1223 
 
5527 anupam.sin 1224 
  def setOrderAttributeForTransaction(self, transactionId, attribute):
1225 
    """
1226 
    sets attributes for all orders in a transaction
1227 
 
1228 
    Parameters:
1229 
     - transactionId
1230 
     - attribute
1231 
    """
1232 
    pass
1233 
 
5553 rajveer 1234 
  def getReceivePendingOrders(self, storeId):
1235 
    """
1236 
    Parameters:
1237 
     - storeId
1238 
    """
1239 
    pass
5527 anupam.sin 1240 
 
5553 rajveer 1241 
  def getReceivedAtStoreOrders(self, storeId):
1242 
    """
1243 
    Parameters:
1244 
     - storeId
1245 
    """
1246 
    pass
1247 
 
5713 rajveer 1248 
  def getOrdersCollectionAtStore(self, storeId, fromDate, toDate, onlyCod):
1249 
    """
1250 
    Parameters:
1251 
     - storeId
1252 
     - fromDate
1253 
     - toDate
1254 
     - onlyCod
1255 
    """
1256 
    pass
1257 
 
5833 rajveer 1258 
  def getOrderAttributeValue(self, orderId, attributeName):
1259 
    """
1260 
    Parameters:
1261 
     - orderId
1262 
     - attributeName
1263 
    """
1264 
    pass
1265 
 
6019 rajveer 1266 
  def changeJacketNumber(self, orderId, jacketNumber):
1267 
    """
1268 
    Parameters:
1269 
     - orderId
1270 
     - jacketNumber
1271 
    """
1272 
    pass
1273 
 
1274 
  def markOrderAsRtoInTransit(self, orderId):
1275 
    """
1276 
    Parameters:
1277 
     - orderId
1278 
    """
1279 
    pass
1280 
 
5593 mandeep.dh 1281 
  def acceptOrderForItem(self, itemId, quantity, fulfilmentWarehouseId, billingWarehouseId):
1282 
    """
1283 
    Accepts appropriate order for an item in a given billingWarehouse. Usually
1284 
    invoked while scanning IN of items.
5553 rajveer 1285 
 
5593 mandeep.dh 1286 
    Parameters:
1287 
     - itemId
1288 
     - quantity
1289 
     - fulfilmentWarehouseId
1290 
     - billingWarehouseId
1291 
    """
1292 
    pass
1293 
 
6000 mandeep.dh 1294 
  def createRechargeOrder(self, rechargeOrder):
1295 
    """
1296 
    Parameters:
1297 
     - rechargeOrder
1298 
    """
1299 
    pass
5593 mandeep.dh 1300 
 
6031 rajveer 1301 
  def getRechargeOrder(self, rechargeRrderId):
1302 
    """
1303 
    Parameters:
1304 
     - rechargeRrderId
1305 
    """
1306 
    pass
1307 
 
1308 
  def getRechargeOrders(self, userId):
1309 
    """
1310 
    Parameters:
1311 
     - userId
1312 
    """
1313 
    pass
1314 
 
6000 mandeep.dh 1315 
  def updateRechargeOrderStatus(self, rechargeOrderId, rechargeOrderStatus):
1316 
    """
1317 
    Parameters:
1318 
     - rechargeOrderId
1319 
     - rechargeOrderStatus
1320 
    """
1321 
    pass
1322 
 
6031 rajveer 1323 
  def activateRechargeTxn(self, rechargeOrderId):
6000 mandeep.dh 1324 
    """
1325 
    Parameters:
6031 rajveer 1326 
     - rechargeOrderId
6000 mandeep.dh 1327 
    """
1328 
    pass
1329 
 
6031 rajveer 1330 
  def getUserWallet(self, userId):
6000 mandeep.dh 1331 
    """
1332 
    Parameters:
6031 rajveer 1333 
     - userId
6000 mandeep.dh 1334 
    """
1335 
    pass
1336 
 
6031 rajveer 1337 
  def getUserWalletHistory(self, userId):
6000 mandeep.dh 1338 
    """
1339 
    Parameters:
6031 rajveer 1340 
     - userId
6000 mandeep.dh 1341 
    """
1342 
    pass
1343 
 
6050 anupam.sin 1344 
  def getRechargeOrdersForTransaction(self, txnId):
1345 
    """
1346 
    Returns a recharge order for a given transactionId
1347 
 
1348 
    Parameters:
1349 
     - txnId
1350 
    """
1351 
    pass
1352 
 
6206 rajveer 1353 
  def getServiceProviders(self, rechargeType, onlyActive):
6048 rajveer 1354 
    """
1355 
    Parameters:
1356 
     - rechargeType
6206 rajveer 1357 
     - onlyActive
6048 rajveer 1358 
    """
1359 
    pass
6000 mandeep.dh 1360 
 
6049 rajveer 1361 
  def getServiceProviderForDevice(self, rechargeType, deviceNumber):
6048 rajveer 1362 
    """
1363 
    Parameters:
6049 rajveer 1364 
     - rechargeType
6048 rajveer 1365 
     - deviceNumber
1366 
    """
1367 
    pass
1368 
 
6591 anupam.sin 1369 
  def validateRecharge(self, rechargeType, deviceNumber, userSelectedProviderId, clientAddress):
6269 rajveer 1370 
    """
1371 
    Parameters:
1372 
     - rechargeType
1373 
     - deviceNumber
6307 anupam.sin 1374 
     - userSelectedProviderId
6591 anupam.sin 1375 
     - clientAddress
6269 rajveer 1376 
    """
1377 
    pass
1378 
 
6094 rajveer 1379 
  def getRechargeOrdersForDevice(self, deviceNumber):
1380 
    """
1381 
    Parameters:
1382 
     - deviceNumber
1383 
    """
1384 
    pass
6048 rajveer 1385 
 
6094 rajveer 1386 
  def addAmountToWallet(self, userId, orderId, amount):
1387 
    """
1388 
    Parameters:
1389 
     - userId
1390 
     - orderId
1391 
     - amount
1392 
    """
1393 
    pass
1394 
 
6188 rajveer 1395 
  def getRechargeStatistics(self, ):
1396 
    pass
1397 
 
6154 rajveer 1398 
  def getRechargeOrdersForStatus(self, status):
1399 
    """
1400 
    Parameters:
1401 
     - status
1402 
    """
1403 
    pass
6094 rajveer 1404 
 
6159 rajveer 1405 
  def getPlansForOperator(self, operatorId):
1406 
    """
1407 
    Parameters:
1408 
     - operatorId
1409 
    """
1410 
    pass
6154 rajveer 1411 
 
6307 anupam.sin 1412 
  def getRechargeDenominations(self, operatorId, circleCode, denominationType):
6289 anupam.sin 1413 
    """
1414 
    Returns denominations for a given operator and circle
6159 rajveer 1415 
 
6289 anupam.sin 1416 
    Parameters:
1417 
     - operatorId
6307 anupam.sin 1418 
     - circleCode
6289 anupam.sin 1419 
     - denominationType
1420 
    """
1421 
    pass
1422 
 
6371 rajveer 1423 
  def updateAvailabilityStatus(self, operatorId, circleId, isAvailable):
1424 
    """
1425 
    Parameters:
1426 
     - operatorId
1427 
     - circleId
1428 
     - isAvailable
1429 
    """
1430 
    pass
6289 anupam.sin 1431 
 
6389 rajveer 1432 
  def getAvailableEmiSchemes(self, ):
1433 
    pass
6371 rajveer 1434 
 
6389 rajveer 1435 
  def getMiscCharges(self, transactionId):
1436 
    """
1437 
    Parameters:
1438 
     - transactionId
1439 
    """
1440 
    pass
1441 
 
6507 anupam.sin 1442 
  def refundRechargeOrder(self, rechargeOrderId):
1443 
    """
1444 
    Parameters:
1445 
     - rechargeOrderId
1446 
    """
1447 
    pass
6389 rajveer 1448 
 
6821 amar.kumar 1449 
  def getPhysicalOrders(self, fromDate, toDate):
1450 
    """
1451 
    Parameters:
1452 
     - fromDate
1453 
     - toDate
1454 
    """
1455 
    pass
6507 anupam.sin 1456 
 
6906 rajveer 1457 
  def getDocument(self, docType, docSource):
1458 
    """
1459 
    Parameters:
1460 
     - docType
1461 
     - docSource
1462 
    """
1463 
    pass
6821 amar.kumar 1464 
 
6985 anupam.sin 1465 
  def changeShippingAddress(self, orderId, line1, line2, city, state, pin):
1466 
    """
1467 
    Parameters:
1468 
     - orderId
1469 
     - line1
1470 
     - line2
1471 
     - city
1472 
     - state
1473 
     - pin
1474 
    """
1475 
    pass
6906 rajveer 1476 
 
7075 rajveer 1477 
  def retrieveInvoice(self, orderId, userId):
6988 rajveer 1478 
    """
1479 
    Parameters:
1480 
     - orderId
7075 rajveer 1481 
     - userId
6988 rajveer 1482 
    """
1483 
    pass
6985 anupam.sin 1484 
 
7026 rajveer 1485 
  def receiveUpdatesForRedExpress(self, awbNumber):
1486 
    """
1487 
    Parameters:
1488 
     - awbNumber
1489 
    """
1490 
    pass
6988 rajveer 1491 
 
7073 anupam.sin 1492 
  def createRechargeTransaction(self, thriftRechargeTransaction):
1493 
    """
1494 
    Parameters:
1495 
     - thriftRechargeTransaction
1496 
    """
1497 
    pass
7026 rajveer 1498 
 
7085 rajveer 1499 
  def getRechargeTransactions(self, storeId):
1500 
    """
1501 
    Parameters:
1502 
     - storeId
1503 
    """
1504 
    pass
1505 
 
7151 amit.gupta 1506 
  def getRechargeTrans(self, storeId, startDate, endDate, status):
1507 
    """
1508 
    Parameters:
1509 
     - storeId
1510 
     - startDate
1511 
     - endDate
1512 
     - status
1513 
    """
1514 
    pass
1515 
 
7080 anupam.sin 1516 
  def getRechargeTransaction(self, rechargeId):
1517 
    """
1518 
    Parameters:
1519 
     - rechargeId
1520 
    """
1521 
    pass
7073 anupam.sin 1522 
 
7080 anupam.sin 1523 
  def getFRCs(self, circleId, operatorId):
1524 
    """
1525 
    Parameters:
1526 
     - circleId
1527 
     - operatorId
1528 
    """
1529 
    pass
1530 
 
7096 anupam.sin 1531 
  def getHotspotStore(self, id, hotspotid):
1532 
    """
1533 
    Parameters:
1534 
     - id
1535 
     - hotspotid
1536 
    """
1537 
    pass
7080 anupam.sin 1538 
 
7096 anupam.sin 1539 
  def getTelecomCircle(self, id, code):
1540 
    """
1541 
    Parameters:
1542 
     - id
1543 
     - code
1544 
    """
1545 
    pass
1546 
 
7109 anupam.sin 1547 
  def retrieveHotspotRechargeInvoice(self, rechargeId):
1548 
    """
1549 
    Parameters:
1550 
     - rechargeId
1551 
    """
1552 
    pass
7096 anupam.sin 1553 
 
7190 amar.kumar 1554 
  def splitFreebieOrder(self, orderId, splitReason, shippingDate):
1555 
    """
1556 
    Parameters:
1557 
     - orderId
1558 
     - splitReason
1559 
     - shippingDate
1560 
    """
1561 
    pass
1562 
 
7172 anupam.sin 1563 
  def getRechargeTransactionsByNumber(self, number, storeId):
7169 anupam.sin 1564 
    """
1565 
    Parameters:
1566 
     - number
7172 anupam.sin 1567 
     - storeId
7169 anupam.sin 1568 
    """
1569 
    pass
7109 anupam.sin 1570 
 
7169 anupam.sin 1571 
  def updateHotspotStorePassword(self, storeId, password):
1572 
    """
1573 
    Parameters:
1574 
     - storeId
1575 
     - password
1576 
    """
1577 
    pass
1578 
 
7285 rajveer 1579 
  def topupCompanyWallet(self, companyId, amount):
7263 anupam.sin 1580 
    """
1581 
    Parameters:
7285 rajveer 1582 
     - companyId
1583 
     - amount
7263 anupam.sin 1584 
    """
1585 
    pass
7169 anupam.sin 1586 
 
7285 rajveer 1587 
  def getWalletBalanceForCompany(self, companyId):
1588 
    """
1589 
    Parameters:
1590 
     - companyId
1591 
    """
7267 anupam.sin 1592 
    pass
7263 anupam.sin 1593 
 
7285 rajveer 1594 
  def getSourceDetail(self, source):
7267 anupam.sin 1595 
    """
1596 
    Parameters:
7285 rajveer 1597 
     - source
7267 anupam.sin 1598 
    """
1599 
    pass
1600 
 
7308 rajveer 1601 
  def getAllCircles(self, ):
1602 
    pass
7267 anupam.sin 1603 
 
7308 rajveer 1604 
  def deleteFrcs(self, frcIdsToDelete):
1605 
    """
1606 
    Parameters:
1607 
     - frcIdsToDelete
1608 
    """
1609 
    pass
1610 
 
1611 
 
3376 rajveer 1612 
class Client(shop2020.thriftpy.generic.GenericService.Client, Iface):
94 ashish 1613 
  def __init__(self, iprot, oprot=None):
3376 rajveer 1614 
    shop2020.thriftpy.generic.GenericService.Client.__init__(self, iprot, oprot)
94 ashish 1615 
 
1616 
  def createTransaction(self, transaction):
1617 
    """
1618 
    Parameters:
1619 
     - transaction
1620 
    """
1621 
    self.send_createTransaction(transaction)
132 ashish 1622 
    return self.recv_createTransaction()
94 ashish 1623 
 
1624 
  def send_createTransaction(self, transaction):
1625 
    self._oprot.writeMessageBegin('createTransaction', TMessageType.CALL, self._seqid)
1626 
    args = createTransaction_args()
1627 
    args.transaction = transaction
1628 
    args.write(self._oprot)
1629 
    self._oprot.writeMessageEnd()
1630 
    self._oprot.trans.flush()
1631 
 
1632 
  def recv_createTransaction(self, ):
1633 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1634 
    if mtype == TMessageType.EXCEPTION:
1635 
      x = TApplicationException()
1636 
      x.read(self._iprot)
1637 
      self._iprot.readMessageEnd()
1638 
      raise x
1639 
    result = createTransaction_result()
1640 
    result.read(self._iprot)
1641 
    self._iprot.readMessageEnd()
3431 rajveer 1642 
    if result.success is not None:
132 ashish 1643 
      return result.success
3431 rajveer 1644 
    if result.ex is not None:
94 ashish 1645 
      raise result.ex
132 ashish 1646 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createTransaction failed: unknown result");
94 ashish 1647 
 
1648 
  def getTransaction(self, id):
1649 
    """
1650 
    Parameters:
1651 
     - id
1652 
    """
1653 
    self.send_getTransaction(id)
1654 
    return self.recv_getTransaction()
1655 
 
1656 
  def send_getTransaction(self, id):
1657 
    self._oprot.writeMessageBegin('getTransaction', TMessageType.CALL, self._seqid)
1658 
    args = getTransaction_args()
1659 
    args.id = id
1660 
    args.write(self._oprot)
1661 
    self._oprot.writeMessageEnd()
1662 
    self._oprot.trans.flush()
1663 
 
1664 
  def recv_getTransaction(self, ):
1665 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1666 
    if mtype == TMessageType.EXCEPTION:
1667 
      x = TApplicationException()
1668 
      x.read(self._iprot)
1669 
      self._iprot.readMessageEnd()
1670 
      raise x
1671 
    result = getTransaction_result()
1672 
    result.read(self._iprot)
1673 
    self._iprot.readMessageEnd()
3431 rajveer 1674 
    if result.success is not None:
94 ashish 1675 
      return result.success
3431 rajveer 1676 
    if result.ex is not None:
94 ashish 1677 
      raise result.ex
1678 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransaction failed: unknown result");
1679 
 
1680 
  def getTransactionsForCustomer(self, customerId, from_date, to_date, status):
1681 
    """
1682 
    Parameters:
1683 
     - customerId
1684 
     - from_date
1685 
     - to_date
1686 
     - status
1687 
    """
1688 
    self.send_getTransactionsForCustomer(customerId, from_date, to_date, status)
1689 
    return self.recv_getTransactionsForCustomer()
1690 
 
1691 
  def send_getTransactionsForCustomer(self, customerId, from_date, to_date, status):
1692 
    self._oprot.writeMessageBegin('getTransactionsForCustomer', TMessageType.CALL, self._seqid)
1693 
    args = getTransactionsForCustomer_args()
1694 
    args.customerId = customerId
1695 
    args.from_date = from_date
1696 
    args.to_date = to_date
1697 
    args.status = status
1698 
    args.write(self._oprot)
1699 
    self._oprot.writeMessageEnd()
1700 
    self._oprot.trans.flush()
1701 
 
1702 
  def recv_getTransactionsForCustomer(self, ):
1703 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1704 
    if mtype == TMessageType.EXCEPTION:
1705 
      x = TApplicationException()
1706 
      x.read(self._iprot)
1707 
      self._iprot.readMessageEnd()
1708 
      raise x
1709 
    result = getTransactionsForCustomer_result()
1710 
    result.read(self._iprot)
1711 
    self._iprot.readMessageEnd()
3431 rajveer 1712 
    if result.success is not None:
94 ashish 1713 
      return result.success
3431 rajveer 1714 
    if result.ex is not None:
94 ashish 1715 
      raise result.ex
1716 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransactionsForCustomer failed: unknown result");
1717 
 
132 ashish 1718 
  def getTransactionsForShoppingCartId(self, shoppingCartId):
1719 
    """
1720 
    Parameters:
1721 
     - shoppingCartId
1722 
    """
1723 
    self.send_getTransactionsForShoppingCartId(shoppingCartId)
1724 
    return self.recv_getTransactionsForShoppingCartId()
1725 
 
1726 
  def send_getTransactionsForShoppingCartId(self, shoppingCartId):
1727 
    self._oprot.writeMessageBegin('getTransactionsForShoppingCartId', TMessageType.CALL, self._seqid)
1728 
    args = getTransactionsForShoppingCartId_args()
1729 
    args.shoppingCartId = shoppingCartId
1730 
    args.write(self._oprot)
1731 
    self._oprot.writeMessageEnd()
1732 
    self._oprot.trans.flush()
1733 
 
1734 
  def recv_getTransactionsForShoppingCartId(self, ):
1735 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1736 
    if mtype == TMessageType.EXCEPTION:
1737 
      x = TApplicationException()
1738 
      x.read(self._iprot)
1739 
      self._iprot.readMessageEnd()
1740 
      raise x
1741 
    result = getTransactionsForShoppingCartId_result()
1742 
    result.read(self._iprot)
1743 
    self._iprot.readMessageEnd()
3431 rajveer 1744 
    if result.success is not None:
132 ashish 1745 
      return result.success
3431 rajveer 1746 
    if result.ex is not None:
132 ashish 1747 
      raise result.ex
1748 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransactionsForShoppingCartId failed: unknown result");
1749 
 
94 ashish 1750 
  def getTransactionStatus(self, transactionId):
1751 
    """
1752 
    Parameters:
1753 
     - transactionId
1754 
    """
1755 
    self.send_getTransactionStatus(transactionId)
1756 
    return self.recv_getTransactionStatus()
1757 
 
1758 
  def send_getTransactionStatus(self, transactionId):
1759 
    self._oprot.writeMessageBegin('getTransactionStatus', TMessageType.CALL, self._seqid)
1760 
    args = getTransactionStatus_args()
1761 
    args.transactionId = transactionId
1762 
    args.write(self._oprot)
1763 
    self._oprot.writeMessageEnd()
1764 
    self._oprot.trans.flush()
1765 
 
1766 
  def recv_getTransactionStatus(self, ):
1767 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1768 
    if mtype == TMessageType.EXCEPTION:
1769 
      x = TApplicationException()
1770 
      x.read(self._iprot)
1771 
      self._iprot.readMessageEnd()
1772 
      raise x
1773 
    result = getTransactionStatus_result()
1774 
    result.read(self._iprot)
1775 
    self._iprot.readMessageEnd()
3431 rajveer 1776 
    if result.success is not None:
94 ashish 1777 
      return result.success
3431 rajveer 1778 
    if result.ex is not None:
94 ashish 1779 
      raise result.ex
1780 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransactionStatus failed: unknown result");
1781 
 
7293 anupam.sin 1782 
  def changeTransactionStatus(self, transactionId, status, description, pickUp, orderType, source):
94 ashish 1783 
    """
1784 
    Parameters:
1785 
     - transactionId
1786 
     - status
1787 
     - description
5527 anupam.sin 1788 
     - pickUp
1789 
     - orderType
7293 anupam.sin 1790 
     - source
94 ashish 1791 
    """
7293 anupam.sin 1792 
    self.send_changeTransactionStatus(transactionId, status, description, pickUp, orderType, source)
94 ashish 1793 
    return self.recv_changeTransactionStatus()
1794 
 
7293 anupam.sin 1795 
  def send_changeTransactionStatus(self, transactionId, status, description, pickUp, orderType, source):
94 ashish 1796 
    self._oprot.writeMessageBegin('changeTransactionStatus', TMessageType.CALL, self._seqid)
1797 
    args = changeTransactionStatus_args()
1798 
    args.transactionId = transactionId
1799 
    args.status = status
1800 
    args.description = description
5527 anupam.sin 1801 
    args.pickUp = pickUp
1802 
    args.orderType = orderType
7293 anupam.sin 1803 
    args.source = source
94 ashish 1804 
    args.write(self._oprot)
1805 
    self._oprot.writeMessageEnd()
1806 
    self._oprot.trans.flush()
1807 
 
1808 
  def recv_changeTransactionStatus(self, ):
1809 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1810 
    if mtype == TMessageType.EXCEPTION:
1811 
      x = TApplicationException()
1812 
      x.read(self._iprot)
1813 
      self._iprot.readMessageEnd()
1814 
      raise x
1815 
    result = changeTransactionStatus_result()
1816 
    result.read(self._iprot)
1817 
    self._iprot.readMessageEnd()
3431 rajveer 1818 
    if result.success is not None:
94 ashish 1819 
      return result.success
3431 rajveer 1820 
    if result.ex is not None:
94 ashish 1821 
      raise result.ex
1822 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "changeTransactionStatus failed: unknown result");
1823 
 
1398 varun.gupt 1824 
  def enqueueTransactionInfoEmail(self, transactionId):
1382 varun.gupt 1825 
    """
1826 
    Parameters:
1827 
     - transactionId
1828 
    """
1398 varun.gupt 1829 
    self.send_enqueueTransactionInfoEmail(transactionId)
1830 
    return self.recv_enqueueTransactionInfoEmail()
1382 varun.gupt 1831 
 
1398 varun.gupt 1832 
  def send_enqueueTransactionInfoEmail(self, transactionId):
1833 
    self._oprot.writeMessageBegin('enqueueTransactionInfoEmail', TMessageType.CALL, self._seqid)
1834 
    args = enqueueTransactionInfoEmail_args()
1382 varun.gupt 1835 
    args.transactionId = transactionId
1836 
    args.write(self._oprot)
1837 
    self._oprot.writeMessageEnd()
1838 
    self._oprot.trans.flush()
1839 
 
1398 varun.gupt 1840 
  def recv_enqueueTransactionInfoEmail(self, ):
1382 varun.gupt 1841 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1842 
    if mtype == TMessageType.EXCEPTION:
1843 
      x = TApplicationException()
1844 
      x.read(self._iprot)
1845 
      self._iprot.readMessageEnd()
1846 
      raise x
1398 varun.gupt 1847 
    result = enqueueTransactionInfoEmail_result()
1382 varun.gupt 1848 
    result.read(self._iprot)
1849 
    self._iprot.readMessageEnd()
3431 rajveer 1850 
    if result.success is not None:
1382 varun.gupt 1851 
      return result.success
3431 rajveer 1852 
    if result.ex is not None:
1382 varun.gupt 1853 
      raise result.ex
1398 varun.gupt 1854 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "enqueueTransactionInfoEmail failed: unknown result");
1382 varun.gupt 1855 
 
4801 anupam.sin 1856 
  def getAllOrders(self, statuses, from_date, to_date, warehouse_id):
94 ashish 1857 
    """
1858 
    Parameters:
4801 anupam.sin 1859 
     - statuses
483 rajveer 1860 
     - from_date
1861 
     - to_date
1862 
     - warehouse_id
94 ashish 1863 
    """
4801 anupam.sin 1864 
    self.send_getAllOrders(statuses, from_date, to_date, warehouse_id)
483 rajveer 1865 
    return self.recv_getAllOrders()
94 ashish 1866 
 
4801 anupam.sin 1867 
  def send_getAllOrders(self, statuses, from_date, to_date, warehouse_id):
483 rajveer 1868 
    self._oprot.writeMessageBegin('getAllOrders', TMessageType.CALL, self._seqid)
1869 
    args = getAllOrders_args()
4801 anupam.sin 1870 
    args.statuses = statuses
483 rajveer 1871 
    args.from_date = from_date
1872 
    args.to_date = to_date
1873 
    args.warehouse_id = warehouse_id
94 ashish 1874 
    args.write(self._oprot)
1875 
    self._oprot.writeMessageEnd()
1876 
    self._oprot.trans.flush()
1877 
 
483 rajveer 1878 
  def recv_getAllOrders(self, ):
94 ashish 1879 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1880 
    if mtype == TMessageType.EXCEPTION:
1881 
      x = TApplicationException()
1882 
      x.read(self._iprot)
1883 
      self._iprot.readMessageEnd()
1884 
      raise x
483 rajveer 1885 
    result = getAllOrders_result()
94 ashish 1886 
    result.read(self._iprot)
1887 
    self._iprot.readMessageEnd()
3431 rajveer 1888 
    if result.success is not None:
94 ashish 1889 
      return result.success
3431 rajveer 1890 
    if result.ex is not None:
94 ashish 1891 
      raise result.ex
483 rajveer 1892 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllOrders failed: unknown result");
94 ashish 1893 
 
4133 chandransh 1894 
  def getOrdersInBatch(self, statuses, offset, limit, warehouse_id):
1895 
    """
1896 
    Returns at most 'limit' orders with the given statuses for the given warehouse starting from the given offset.
1897 
    Pass the status as null and the limit as 0 to ignore them.
1898 
 
1899 
    Parameters:
1900 
     - statuses
1901 
     - offset
1902 
     - limit
1903 
     - warehouse_id
1904 
    """
1905 
    self.send_getOrdersInBatch(statuses, offset, limit, warehouse_id)
1906 
    return self.recv_getOrdersInBatch()
1907 
 
1908 
  def send_getOrdersInBatch(self, statuses, offset, limit, warehouse_id):
1909 
    self._oprot.writeMessageBegin('getOrdersInBatch', TMessageType.CALL, self._seqid)
1910 
    args = getOrdersInBatch_args()
1911 
    args.statuses = statuses
1912 
    args.offset = offset
1913 
    args.limit = limit
1914 
    args.warehouse_id = warehouse_id
1915 
    args.write(self._oprot)
1916 
    self._oprot.writeMessageEnd()
1917 
    self._oprot.trans.flush()
1918 
 
1919 
  def recv_getOrdersInBatch(self, ):
1920 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1921 
    if mtype == TMessageType.EXCEPTION:
1922 
      x = TApplicationException()
1923 
      x.read(self._iprot)
1924 
      self._iprot.readMessageEnd()
1925 
      raise x
1926 
    result = getOrdersInBatch_result()
1927 
    result.read(self._iprot)
1928 
    self._iprot.readMessageEnd()
1929 
    if result.success is not None:
1930 
      return result.success
1931 
    if result.ex is not None:
1932 
      raise result.ex
1933 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersInBatch failed: unknown result");
1934 
 
1935 
  def getOrderCount(self, statuses, warehouseId):
1936 
    """
1937 
    Returns the count of orders with the given statuses assigned to the given warehouse.
1938 
 
1939 
    Parameters:
1940 
     - statuses
1941 
     - warehouseId
1942 
    """
1943 
    self.send_getOrderCount(statuses, warehouseId)
1944 
    return self.recv_getOrderCount()
1945 
 
1946 
  def send_getOrderCount(self, statuses, warehouseId):
1947 
    self._oprot.writeMessageBegin('getOrderCount', TMessageType.CALL, self._seqid)
1948 
    args = getOrderCount_args()
1949 
    args.statuses = statuses
1950 
    args.warehouseId = warehouseId
1951 
    args.write(self._oprot)
1952 
    self._oprot.writeMessageEnd()
1953 
    self._oprot.trans.flush()
1954 
 
1955 
  def recv_getOrderCount(self, ):
1956 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1957 
    if mtype == TMessageType.EXCEPTION:
1958 
      x = TApplicationException()
1959 
      x.read(self._iprot)
1960 
      self._iprot.readMessageEnd()
1961 
      raise x
1962 
    result = getOrderCount_result()
1963 
    result.read(self._iprot)
1964 
    self._iprot.readMessageEnd()
1965 
    if result.success is not None:
1966 
      return result.success
1967 
    if result.ex is not None:
1968 
      raise result.ex
1969 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderCount failed: unknown result");
1970 
 
999 varun.gupt 1971 
  def getOrdersByBillingDate(self, status, start_billing_date, end_billing_date, warehouse_id):
1972 
    """
1132 chandransh 1973 
    Returns orders within a range of their billing dates
3431 rajveer 1974 
 
999 varun.gupt 1975 
    Parameters:
1976 
     - status
1977 
     - start_billing_date
1978 
     - end_billing_date
1979 
     - warehouse_id
1980 
    """
1981 
    self.send_getOrdersByBillingDate(status, start_billing_date, end_billing_date, warehouse_id)
1982 
    return self.recv_getOrdersByBillingDate()
1983 
 
1984 
  def send_getOrdersByBillingDate(self, status, start_billing_date, end_billing_date, warehouse_id):
1985 
    self._oprot.writeMessageBegin('getOrdersByBillingDate', TMessageType.CALL, self._seqid)
1986 
    args = getOrdersByBillingDate_args()
1987 
    args.status = status
1988 
    args.start_billing_date = start_billing_date
1989 
    args.end_billing_date = end_billing_date
1990 
    args.warehouse_id = warehouse_id
1991 
    args.write(self._oprot)
1992 
    self._oprot.writeMessageEnd()
1993 
    self._oprot.trans.flush()
1994 
 
1995 
  def recv_getOrdersByBillingDate(self, ):
1996 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1997 
    if mtype == TMessageType.EXCEPTION:
1998 
      x = TApplicationException()
1999 
      x.read(self._iprot)
2000 
      self._iprot.readMessageEnd()
2001 
      raise x
2002 
    result = getOrdersByBillingDate_result()
2003 
    result.read(self._iprot)
2004 
    self._iprot.readMessageEnd()
3431 rajveer 2005 
    if result.success is not None:
999 varun.gupt 2006 
      return result.success
3431 rajveer 2007 
    if result.ex is not None:
999 varun.gupt 2008 
      raise result.ex
2009 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersByBillingDate failed: unknown result");
2010 
 
3451 chandransh 2011 
  def getOrdersByShippingDate(self, fromShippingDate, toShippingDate, providerId, warehouseId, cod):
3427 chandransh 2012 
    """
2013 
    Returns orders for a particular provider and warehouse which were shipped between the given dates.
3451 chandransh 2014 
    Returned orders comprise of COD orders if cod parameter is true. It comprises of prepaid orders otherwise.
2015 
    Pass providerId and warehouseId as -1 to ignore both these parameters.
3431 rajveer 2016 
 
3427 chandransh 2017 
    Parameters:
2018 
     - fromShippingDate
2019 
     - toShippingDate
2020 
     - providerId
2021 
     - warehouseId
3451 chandransh 2022 
     - cod
3427 chandransh 2023 
    """
3451 chandransh 2024 
    self.send_getOrdersByShippingDate(fromShippingDate, toShippingDate, providerId, warehouseId, cod)
3427 chandransh 2025 
    return self.recv_getOrdersByShippingDate()
2026 
 
3451 chandransh 2027 
  def send_getOrdersByShippingDate(self, fromShippingDate, toShippingDate, providerId, warehouseId, cod):
3427 chandransh 2028 
    self._oprot.writeMessageBegin('getOrdersByShippingDate', TMessageType.CALL, self._seqid)
2029 
    args = getOrdersByShippingDate_args()
2030 
    args.fromShippingDate = fromShippingDate
2031 
    args.toShippingDate = toShippingDate
2032 
    args.providerId = providerId
2033 
    args.warehouseId = warehouseId
3451 chandransh 2034 
    args.cod = cod
3427 chandransh 2035 
    args.write(self._oprot)
2036 
    self._oprot.writeMessageEnd()
2037 
    self._oprot.trans.flush()
2038 
 
2039 
  def recv_getOrdersByShippingDate(self, ):
2040 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2041 
    if mtype == TMessageType.EXCEPTION:
2042 
      x = TApplicationException()
2043 
      x.read(self._iprot)
2044 
      self._iprot.readMessageEnd()
2045 
      raise x
2046 
    result = getOrdersByShippingDate_result()
2047 
    result.read(self._iprot)
2048 
    self._iprot.readMessageEnd()
3431 rajveer 2049 
    if result.success is not None:
3427 chandransh 2050 
      return result.success
3431 rajveer 2051 
    if result.ex is not None:
3427 chandransh 2052 
      raise result.ex
2053 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersByShippingDate failed: unknown result");
2054 
 
1382 varun.gupt 2055 
  def getReturnableOrdersForCustomer(self, customer_id, limit):
2056 
    """
2057 
    Returns order ids for orders which can be returned
3431 rajveer 2058 
 
1382 varun.gupt 2059 
    Parameters:
2060 
     - customer_id
2061 
     - limit
2062 
    """
2063 
    self.send_getReturnableOrdersForCustomer(customer_id, limit)
2064 
    return self.recv_getReturnableOrdersForCustomer()
2065 
 
2066 
  def send_getReturnableOrdersForCustomer(self, customer_id, limit):
2067 
    self._oprot.writeMessageBegin('getReturnableOrdersForCustomer', TMessageType.CALL, self._seqid)
2068 
    args = getReturnableOrdersForCustomer_args()
2069 
    args.customer_id = customer_id
2070 
    args.limit = limit
2071 
    args.write(self._oprot)
2072 
    self._oprot.writeMessageEnd()
2073 
    self._oprot.trans.flush()
2074 
 
2075 
  def recv_getReturnableOrdersForCustomer(self, ):
2076 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2077 
    if mtype == TMessageType.EXCEPTION:
2078 
      x = TApplicationException()
2079 
      x.read(self._iprot)
2080 
      self._iprot.readMessageEnd()
2081 
      raise x
2082 
    result = getReturnableOrdersForCustomer_result()
2083 
    result.read(self._iprot)
2084 
    self._iprot.readMessageEnd()
3431 rajveer 2085 
    if result.success is not None:
1382 varun.gupt 2086 
      return result.success
3431 rajveer 2087 
    if result.ex is not None:
1382 varun.gupt 2088 
      raise result.ex
2089 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReturnableOrdersForCustomer failed: unknown result");
2090 
 
2091 
  def getCancellableOrdersForCustomer(self, customer_id, limit):
2092 
    """
2093 
    Returns order ids for orders which can be cancelled
3431 rajveer 2094 
 
1382 varun.gupt 2095 
    Parameters:
2096 
     - customer_id
2097 
     - limit
2098 
    """
2099 
    self.send_getCancellableOrdersForCustomer(customer_id, limit)
2100 
    return self.recv_getCancellableOrdersForCustomer()
2101 
 
2102 
  def send_getCancellableOrdersForCustomer(self, customer_id, limit):
2103 
    self._oprot.writeMessageBegin('getCancellableOrdersForCustomer', TMessageType.CALL, self._seqid)
2104 
    args = getCancellableOrdersForCustomer_args()
2105 
    args.customer_id = customer_id
2106 
    args.limit = limit
2107 
    args.write(self._oprot)
2108 
    self._oprot.writeMessageEnd()
2109 
    self._oprot.trans.flush()
2110 
 
2111 
  def recv_getCancellableOrdersForCustomer(self, ):
2112 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2113 
    if mtype == TMessageType.EXCEPTION:
2114 
      x = TApplicationException()
2115 
      x.read(self._iprot)
2116 
      self._iprot.readMessageEnd()
2117 
      raise x
2118 
    result = getCancellableOrdersForCustomer_result()
2119 
    result.read(self._iprot)
2120 
    self._iprot.readMessageEnd()
3431 rajveer 2121 
    if result.success is not None:
1382 varun.gupt 2122 
      return result.success
3431 rajveer 2123 
    if result.ex is not None:
1382 varun.gupt 2124 
      raise result.ex
2125 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCancellableOrdersForCustomer failed: unknown result");
2126 
 
483 rajveer 2127 
  def changeOrderStatus(self, orderId, status, description):
94 ashish 2128 
    """
2129 
    Parameters:
483 rajveer 2130 
     - orderId
2131 
     - status
2132 
     - description
94 ashish 2133 
    """
483 rajveer 2134 
    self.send_changeOrderStatus(orderId, status, description)
2135 
    return self.recv_changeOrderStatus()
94 ashish 2136 
 
483 rajveer 2137 
  def send_changeOrderStatus(self, orderId, status, description):
2138 
    self._oprot.writeMessageBegin('changeOrderStatus', TMessageType.CALL, self._seqid)
2139 
    args = changeOrderStatus_args()
2140 
    args.orderId = orderId
2141 
    args.status = status
2142 
    args.description = description
94 ashish 2143 
    args.write(self._oprot)
2144 
    self._oprot.writeMessageEnd()
2145 
    self._oprot.trans.flush()
2146 
 
483 rajveer 2147 
  def recv_changeOrderStatus(self, ):
94 ashish 2148 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2149 
    if mtype == TMessageType.EXCEPTION:
2150 
      x = TApplicationException()
2151 
      x.read(self._iprot)
2152 
      self._iprot.readMessageEnd()
2153 
      raise x
483 rajveer 2154 
    result = changeOrderStatus_result()
94 ashish 2155 
    result.read(self._iprot)
2156 
    self._iprot.readMessageEnd()
3431 rajveer 2157 
    if result.success is not None:
94 ashish 2158 
      return result.success
3431 rajveer 2159 
    if result.ex is not None:
94 ashish 2160 
      raise result.ex
483 rajveer 2161 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "changeOrderStatus failed: unknown result");
94 ashish 2162 
 
1528 ankur.sing 2163 
  def getOrdersForTransaction(self, transactionId, customerId):
94 ashish 2164 
    """
1528 ankur.sing 2165 
    Returns list of orders for given transaction Id. Also filters based on customer Id so that
2166 
    only user who owns the transaction can view its order details.
3431 rajveer 2167 
 
94 ashish 2168 
    Parameters:
2169 
     - transactionId
1528 ankur.sing 2170 
     - customerId
94 ashish 2171 
    """
1528 ankur.sing 2172 
    self.send_getOrdersForTransaction(transactionId, customerId)
483 rajveer 2173 
    return self.recv_getOrdersForTransaction()
94 ashish 2174 
 
1528 ankur.sing 2175 
  def send_getOrdersForTransaction(self, transactionId, customerId):
483 rajveer 2176 
    self._oprot.writeMessageBegin('getOrdersForTransaction', TMessageType.CALL, self._seqid)
2177 
    args = getOrdersForTransaction_args()
94 ashish 2178 
    args.transactionId = transactionId
1528 ankur.sing 2179 
    args.customerId = customerId
94 ashish 2180 
    args.write(self._oprot)
2181 
    self._oprot.writeMessageEnd()
2182 
    self._oprot.trans.flush()
2183 
 
483 rajveer 2184 
  def recv_getOrdersForTransaction(self, ):
94 ashish 2185 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2186 
    if mtype == TMessageType.EXCEPTION:
2187 
      x = TApplicationException()
2188 
      x.read(self._iprot)
2189 
      self._iprot.readMessageEnd()
2190 
      raise x
483 rajveer 2191 
    result = getOrdersForTransaction_result()
94 ashish 2192 
    result.read(self._iprot)
2193 
    self._iprot.readMessageEnd()
3431 rajveer 2194 
    if result.success is not None:
94 ashish 2195 
      return result.success
3431 rajveer 2196 
    if result.ex is not None:
94 ashish 2197 
      raise result.ex
483 rajveer 2198 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersForTransaction failed: unknown result");
94 ashish 2199 
 
3014 chandransh 2200 
  def getOrdersForCustomer(self, customerId, from_date, to_date, statuses):
94 ashish 2201 
    """
3014 chandransh 2202 
    Returns list of orders for the given customer created between the given dates and having the given statuses.
2203 
    Pass and empty list to ignore filtering on statuses.
3431 rajveer 2204 
 
94 ashish 2205 
    Parameters:
483 rajveer 2206 
     - customerId
2207 
     - from_date
2208 
     - to_date
3014 chandransh 2209 
     - statuses
94 ashish 2210 
    """
3014 chandransh 2211 
    self.send_getOrdersForCustomer(customerId, from_date, to_date, statuses)
483 rajveer 2212 
    return self.recv_getOrdersForCustomer()
94 ashish 2213 
 
3014 chandransh 2214 
  def send_getOrdersForCustomer(self, customerId, from_date, to_date, statuses):
483 rajveer 2215 
    self._oprot.writeMessageBegin('getOrdersForCustomer', TMessageType.CALL, self._seqid)
2216 
    args = getOrdersForCustomer_args()
2217 
    args.customerId = customerId
2218 
    args.from_date = from_date
2219 
    args.to_date = to_date
3014 chandransh 2220 
    args.statuses = statuses
94 ashish 2221 
    args.write(self._oprot)
2222 
    self._oprot.writeMessageEnd()
2223 
    self._oprot.trans.flush()
2224 
 
483 rajveer 2225 
  def recv_getOrdersForCustomer(self, ):
94 ashish 2226 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2227 
    if mtype == TMessageType.EXCEPTION:
2228 
      x = TApplicationException()
2229 
      x.read(self._iprot)
2230 
      self._iprot.readMessageEnd()
2231 
      raise x
483 rajveer 2232 
    result = getOrdersForCustomer_result()
94 ashish 2233 
    result.read(self._iprot)
2234 
    self._iprot.readMessageEnd()
3431 rajveer 2235 
    if result.success is not None:
94 ashish 2236 
      return result.success
3431 rajveer 2237 
    if result.ex is not None:
94 ashish 2238 
      raise result.ex
483 rajveer 2239 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersForCustomer failed: unknown result");
94 ashish 2240 
 
483 rajveer 2241 
  def createOrder(self, order):
94 ashish 2242 
    """
2243 
    Parameters:
483 rajveer 2244 
     - order
94 ashish 2245 
    """
483 rajveer 2246 
    self.send_createOrder(order)
2247 
    return self.recv_createOrder()
94 ashish 2248 
 
483 rajveer 2249 
  def send_createOrder(self, order):
2250 
    self._oprot.writeMessageBegin('createOrder', TMessageType.CALL, self._seqid)
2251 
    args = createOrder_args()
2252 
    args.order = order
94 ashish 2253 
    args.write(self._oprot)
2254 
    self._oprot.writeMessageEnd()
2255 
    self._oprot.trans.flush()
2256 
 
483 rajveer 2257 
  def recv_createOrder(self, ):
94 ashish 2258 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2259 
    if mtype == TMessageType.EXCEPTION:
2260 
      x = TApplicationException()
2261 
      x.read(self._iprot)
2262 
      self._iprot.readMessageEnd()
2263 
      raise x
483 rajveer 2264 
    result = createOrder_result()
94 ashish 2265 
    result.read(self._iprot)
2266 
    self._iprot.readMessageEnd()
3431 rajveer 2267 
    if result.success is not None:
94 ashish 2268 
      return result.success
3431 rajveer 2269 
    if result.ex is not None:
94 ashish 2270 
      raise result.ex
483 rajveer 2271 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createOrder failed: unknown result");
94 ashish 2272 
 
483 rajveer 2273 
  def getOrder(self, id):
94 ashish 2274 
    """
2275 
    Parameters:
483 rajveer 2276 
     - id
94 ashish 2277 
    """
483 rajveer 2278 
    self.send_getOrder(id)
2279 
    return self.recv_getOrder()
94 ashish 2280 
 
483 rajveer 2281 
  def send_getOrder(self, id):
2282 
    self._oprot.writeMessageBegin('getOrder', TMessageType.CALL, self._seqid)
2283 
    args = getOrder_args()
2284 
    args.id = id
94 ashish 2285 
    args.write(self._oprot)
2286 
    self._oprot.writeMessageEnd()
2287 
    self._oprot.trans.flush()
2288 
 
483 rajveer 2289 
  def recv_getOrder(self, ):
94 ashish 2290 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2291 
    if mtype == TMessageType.EXCEPTION:
2292 
      x = TApplicationException()
2293 
      x.read(self._iprot)
2294 
      self._iprot.readMessageEnd()
2295 
      raise x
483 rajveer 2296 
    result = getOrder_result()
94 ashish 2297 
    result.read(self._iprot)
2298 
    self._iprot.readMessageEnd()
3431 rajveer 2299 
    if result.success is not None:
94 ashish 2300 
      return result.success
3431 rajveer 2301 
    if result.ex is not None:
94 ashish 2302 
      raise result.ex
483 rajveer 2303 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrder failed: unknown result");
94 ashish 2304 
 
483 rajveer 2305 
  def getLineItemsForOrder(self, orderId):
94 ashish 2306 
    """
2307 
    Parameters:
483 rajveer 2308 
     - orderId
94 ashish 2309 
    """
483 rajveer 2310 
    self.send_getLineItemsForOrder(orderId)
2311 
    return self.recv_getLineItemsForOrder()
94 ashish 2312 
 
483 rajveer 2313 
  def send_getLineItemsForOrder(self, orderId):
2314 
    self._oprot.writeMessageBegin('getLineItemsForOrder', TMessageType.CALL, self._seqid)
2315 
    args = getLineItemsForOrder_args()
2316 
    args.orderId = orderId
94 ashish 2317 
    args.write(self._oprot)
2318 
    self._oprot.writeMessageEnd()
2319 
    self._oprot.trans.flush()
2320 
 
483 rajveer 2321 
  def recv_getLineItemsForOrder(self, ):
94 ashish 2322 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2323 
    if mtype == TMessageType.EXCEPTION:
2324 
      x = TApplicationException()
2325 
      x.read(self._iprot)
2326 
      self._iprot.readMessageEnd()
2327 
      raise x
483 rajveer 2328 
    result = getLineItemsForOrder_result()
94 ashish 2329 
    result.read(self._iprot)
2330 
    self._iprot.readMessageEnd()
3431 rajveer 2331 
    if result.success is not None:
94 ashish 2332 
      return result.success
3431 rajveer 2333 
    if result.ex is not None:
94 ashish 2334 
      raise result.ex
483 rajveer 2335 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getLineItemsForOrder failed: unknown result");
94 ashish 2336 
 
4999 phani.kuma 2337 
  def getOrderList(self, order_ids):
2338 
    """
2339 
    Parameters:
2340 
     - order_ids
2341 
    """
2342 
    self.send_getOrderList(order_ids)
2343 
    return self.recv_getOrderList()
2344 
 
2345 
  def send_getOrderList(self, order_ids):
2346 
    self._oprot.writeMessageBegin('getOrderList', TMessageType.CALL, self._seqid)
2347 
    args = getOrderList_args()
2348 
    args.order_ids = order_ids
2349 
    args.write(self._oprot)
2350 
    self._oprot.writeMessageEnd()
2351 
    self._oprot.trans.flush()
2352 
 
2353 
  def recv_getOrderList(self, ):
2354 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2355 
    if mtype == TMessageType.EXCEPTION:
2356 
      x = TApplicationException()
2357 
      x.read(self._iprot)
2358 
      self._iprot.readMessageEnd()
2359 
      raise x
2360 
    result = getOrderList_result()
2361 
    result.read(self._iprot)
2362 
    self._iprot.readMessageEnd()
2363 
    if result.success is not None:
2364 
      return result.success
2365 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderList failed: unknown result");
2366 
 
5386 phani.kuma 2367 
  def getOrderListForVendor(self, order_ids, vendorId):
2368 
    """
2369 
    Parameters:
2370 
     - order_ids
2371 
     - vendorId
2372 
    """
2373 
    self.send_getOrderListForVendor(order_ids, vendorId)
2374 
    return self.recv_getOrderListForVendor()
2375 
 
2376 
  def send_getOrderListForVendor(self, order_ids, vendorId):
2377 
    self._oprot.writeMessageBegin('getOrderListForVendor', TMessageType.CALL, self._seqid)
2378 
    args = getOrderListForVendor_args()
2379 
    args.order_ids = order_ids
2380 
    args.vendorId = vendorId
2381 
    args.write(self._oprot)
2382 
    self._oprot.writeMessageEnd()
2383 
    self._oprot.trans.flush()
2384 
 
2385 
  def recv_getOrderListForVendor(self, ):
2386 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2387 
    if mtype == TMessageType.EXCEPTION:
2388 
      x = TApplicationException()
2389 
      x.read(self._iprot)
2390 
      self._iprot.readMessageEnd()
2391 
      raise x
2392 
    result = getOrderListForVendor_result()
2393 
    result.read(self._iprot)
2394 
    self._iprot.readMessageEnd()
2395 
    if result.success is not None:
2396 
      return result.success
2397 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderListForVendor failed: unknown result");
2398 
 
1528 ankur.sing 2399 
  def getOrderForCustomer(self, orderId, customerId):
2400 
    """
2401 
    Returns an order for the order Id. Also checks if the order belongs to the customer whose Id is passed.
2402 
    Throws exception if either order Id is invalid or order does not below to the customer whose Id is passed.
3431 rajveer 2403 
 
1528 ankur.sing 2404 
    Parameters:
2405 
     - orderId
2406 
     - customerId
2407 
    """
2408 
    self.send_getOrderForCustomer(orderId, customerId)
2409 
    return self.recv_getOrderForCustomer()
2410 
 
2411 
  def send_getOrderForCustomer(self, orderId, customerId):
2412 
    self._oprot.writeMessageBegin('getOrderForCustomer', TMessageType.CALL, self._seqid)
2413 
    args = getOrderForCustomer_args()
2414 
    args.orderId = orderId
2415 
    args.customerId = customerId
2416 
    args.write(self._oprot)
2417 
    self._oprot.writeMessageEnd()
2418 
    self._oprot.trans.flush()
2419 
 
2420 
  def recv_getOrderForCustomer(self, ):
2421 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2422 
    if mtype == TMessageType.EXCEPTION:
2423 
      x = TApplicationException()
2424 
      x.read(self._iprot)
2425 
      self._iprot.readMessageEnd()
2426 
      raise x
2427 
    result = getOrderForCustomer_result()
2428 
    result.read(self._iprot)
2429 
    self._iprot.readMessageEnd()
3431 rajveer 2430 
    if result.success is not None:
1528 ankur.sing 2431 
      return result.success
3431 rajveer 2432 
    if result.ex is not None:
1528 ankur.sing 2433 
      raise result.ex
2434 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderForCustomer failed: unknown result");
2435 
 
4444 rajveer 2436 
  def getAlerts(self, type, warehouseId, status, timestamp):
3064 chandransh 2437 
    """
2438 
    Parameters:
4394 rajveer 2439 
     - type
4444 rajveer 2440 
     - warehouseId
4394 rajveer 2441 
     - status
2442 
     - timestamp
3064 chandransh 2443 
    """
4444 rajveer 2444 
    self.send_getAlerts(type, warehouseId, status, timestamp)
3064 chandransh 2445 
    return self.recv_getAlerts()
2446 
 
4444 rajveer 2447 
  def send_getAlerts(self, type, warehouseId, status, timestamp):
3064 chandransh 2448 
    self._oprot.writeMessageBegin('getAlerts', TMessageType.CALL, self._seqid)
2449 
    args = getAlerts_args()
4394 rajveer 2450 
    args.type = type
4444 rajveer 2451 
    args.warehouseId = warehouseId
4394 rajveer 2452 
    args.status = status
2453 
    args.timestamp = timestamp
3064 chandransh 2454 
    args.write(self._oprot)
2455 
    self._oprot.writeMessageEnd()
2456 
    self._oprot.trans.flush()
2457 
 
2458 
  def recv_getAlerts(self, ):
2459 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2460 
    if mtype == TMessageType.EXCEPTION:
2461 
      x = TApplicationException()
2462 
      x.read(self._iprot)
2463 
      self._iprot.readMessageEnd()
2464 
      raise x
2465 
    result = getAlerts_result()
2466 
    result.read(self._iprot)
2467 
    self._iprot.readMessageEnd()
3431 rajveer 2468 
    if result.success is not None:
3064 chandransh 2469 
      return result.success
2470 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAlerts failed: unknown result");
2471 
 
4444 rajveer 2472 
  def addAlert(self, type, warehouseId, description):
3064 chandransh 2473 
    """
2474 
    Parameters:
2475 
     - type
4444 rajveer 2476 
     - warehouseId
4394 rajveer 2477 
     - description
3064 chandransh 2478 
    """
4444 rajveer 2479 
    self.send_addAlert(type, warehouseId, description)
4394 rajveer 2480 
    self.recv_addAlert()
3064 chandransh 2481 
 
4444 rajveer 2482 
  def send_addAlert(self, type, warehouseId, description):
4394 rajveer 2483 
    self._oprot.writeMessageBegin('addAlert', TMessageType.CALL, self._seqid)
2484 
    args = addAlert_args()
3064 chandransh 2485 
    args.type = type
4444 rajveer 2486 
    args.warehouseId = warehouseId
4394 rajveer 2487 
    args.description = description
3064 chandransh 2488 
    args.write(self._oprot)
2489 
    self._oprot.writeMessageEnd()
2490 
    self._oprot.trans.flush()
2491 
 
4394 rajveer 2492 
  def recv_addAlert(self, ):
3064 chandransh 2493 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2494 
    if mtype == TMessageType.EXCEPTION:
2495 
      x = TApplicationException()
2496 
      x.read(self._iprot)
2497 
      self._iprot.readMessageEnd()
2498 
      raise x
4394 rajveer 2499 
    result = addAlert_result()
3064 chandransh 2500 
    result.read(self._iprot)
2501 
    self._iprot.readMessageEnd()
2502 
    return
2503 
 
4444 rajveer 2504 
  def markAlertsAsSeen(self, warehouseId):
2505 
    """
2506 
    Parameters:
2507 
     - warehouseId
2508 
    """
2509 
    self.send_markAlertsAsSeen(warehouseId)
2510 
    self.recv_markAlertsAsSeen()
2511 
 
2512 
  def send_markAlertsAsSeen(self, warehouseId):
2513 
    self._oprot.writeMessageBegin('markAlertsAsSeen', TMessageType.CALL, self._seqid)
2514 
    args = markAlertsAsSeen_args()
2515 
    args.warehouseId = warehouseId
2516 
    args.write(self._oprot)
2517 
    self._oprot.writeMessageEnd()
2518 
    self._oprot.trans.flush()
2519 
 
2520 
  def recv_markAlertsAsSeen(self, ):
2521 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2522 
    if mtype == TMessageType.EXCEPTION:
2523 
      x = TApplicationException()
2524 
      x.read(self._iprot)
2525 
      self._iprot.readMessageEnd()
2526 
      raise x
2527 
    result = markAlertsAsSeen_result()
2528 
    result.read(self._iprot)
2529 
    self._iprot.readMessageEnd()
2530 
    return
2531 
 
3064 chandransh 2532 
  def getValidOrderCount(self, ):
2533 
    """
2534 
    Return the number of valid orders. (OrderStatus >= OrderStatus.SUBMITTED_FOR_PROCESSING)
2535 
    """
2536 
    self.send_getValidOrderCount()
2537 
    return self.recv_getValidOrderCount()
2538 
 
2539 
  def send_getValidOrderCount(self, ):
2540 
    self._oprot.writeMessageBegin('getValidOrderCount', TMessageType.CALL, self._seqid)
2541 
    args = getValidOrderCount_args()
2542 
    args.write(self._oprot)
2543 
    self._oprot.writeMessageEnd()
2544 
    self._oprot.trans.flush()
2545 
 
2546 
  def recv_getValidOrderCount(self, ):
2547 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2548 
    if mtype == TMessageType.EXCEPTION:
2549 
      x = TApplicationException()
2550 
      x.read(self._iprot)
2551 
      self._iprot.readMessageEnd()
2552 
      raise x
2553 
    result = getValidOrderCount_result()
2554 
    result.read(self._iprot)
2555 
    self._iprot.readMessageEnd()
3431 rajveer 2556 
    if result.success is not None:
3064 chandransh 2557 
      return result.success
2558 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getValidOrderCount failed: unknown result");
2559 
 
2560 
  def getNoOfCustomersWithSuccessfulTransaction(self, ):
2561 
    """
2562 
    Returns the number of distinct customers who have done successful transactions
2563 
    """
2564 
    self.send_getNoOfCustomersWithSuccessfulTransaction()
2565 
    return self.recv_getNoOfCustomersWithSuccessfulTransaction()
2566 
 
2567 
  def send_getNoOfCustomersWithSuccessfulTransaction(self, ):
2568 
    self._oprot.writeMessageBegin('getNoOfCustomersWithSuccessfulTransaction', TMessageType.CALL, self._seqid)
2569 
    args = getNoOfCustomersWithSuccessfulTransaction_args()
2570 
    args.write(self._oprot)
2571 
    self._oprot.writeMessageEnd()
2572 
    self._oprot.trans.flush()
2573 
 
2574 
  def recv_getNoOfCustomersWithSuccessfulTransaction(self, ):
2575 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2576 
    if mtype == TMessageType.EXCEPTION:
2577 
      x = TApplicationException()
2578 
      x.read(self._iprot)
2579 
      self._iprot.readMessageEnd()
2580 
      raise x
2581 
    result = getNoOfCustomersWithSuccessfulTransaction_result()
2582 
    result.read(self._iprot)
2583 
    self._iprot.readMessageEnd()
3431 rajveer 2584 
    if result.success is not None:
3064 chandransh 2585 
      return result.success
2586 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getNoOfCustomersWithSuccessfulTransaction failed: unknown result");
2587 
 
2588 
  def getValidOrdersAmountRange(self, ):
2589 
    """
2590 
    Returns the minimum and maximum amounts of a valid order. (OrderStatus >= OrderStatus.SUBMITTED_FOR_PROCESSING)
2591 
    List contains two values, first minimum amount and second maximum amount.
2592 
    """
2593 
    self.send_getValidOrdersAmountRange()
2594 
    return self.recv_getValidOrdersAmountRange()
2595 
 
2596 
  def send_getValidOrdersAmountRange(self, ):
2597 
    self._oprot.writeMessageBegin('getValidOrdersAmountRange', TMessageType.CALL, self._seqid)
2598 
    args = getValidOrdersAmountRange_args()
2599 
    args.write(self._oprot)
2600 
    self._oprot.writeMessageEnd()
2601 
    self._oprot.trans.flush()
2602 
 
2603 
  def recv_getValidOrdersAmountRange(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 = getValidOrdersAmountRange_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, "getValidOrdersAmountRange failed: unknown result");
2616 
 
5874 rajveer 2617 
  def getValidOrders(self, limit, onlyStore):
3064 chandransh 2618 
    """
2619 
    Returns list of Orders in descending order by Order creation date. List is restricted to limit Orders.
2620 
    If limit is passed as 0, then all valid Orders are returned.
3431 rajveer 2621 
 
3064 chandransh 2622 
    Parameters:
2623 
     - limit
5874 rajveer 2624 
     - onlyStore
3064 chandransh 2625 
    """
5874 rajveer 2626 
    self.send_getValidOrders(limit, onlyStore)
3064 chandransh 2627 
    return self.recv_getValidOrders()
2628 
 
5874 rajveer 2629 
  def send_getValidOrders(self, limit, onlyStore):
3064 chandransh 2630 
    self._oprot.writeMessageBegin('getValidOrders', TMessageType.CALL, self._seqid)
2631 
    args = getValidOrders_args()
2632 
    args.limit = limit
5874 rajveer 2633 
    args.onlyStore = onlyStore
3064 chandransh 2634 
    args.write(self._oprot)
2635 
    self._oprot.writeMessageEnd()
2636 
    self._oprot.trans.flush()
2637 
 
2638 
  def recv_getValidOrders(self, ):
2639 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2640 
    if mtype == TMessageType.EXCEPTION:
2641 
      x = TApplicationException()
2642 
      x.read(self._iprot)
2643 
      self._iprot.readMessageEnd()
2644 
      raise x
2645 
    result = getValidOrders_result()
2646 
    result.read(self._iprot)
2647 
    self._iprot.readMessageEnd()
3431 rajveer 2648 
    if result.success is not None:
3064 chandransh 2649 
      return result.success
2650 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getValidOrders failed: unknown result");
2651 
 
1220 chandransh 2652 
  def batchOrders(self, warehouseId):
2653 
    """
2654 
    Create a batch of all the pending orders for the given warehouse.
2655 
    The returned list is orderd by created_timestamp.
2656 
    If there are no pending orders, an empty list is returned.
3431 rajveer 2657 
 
1220 chandransh 2658 
    Parameters:
2659 
     - warehouseId
2660 
    """
2661 
    self.send_batchOrders(warehouseId)
2662 
    return self.recv_batchOrders()
2663 
 
2664 
  def send_batchOrders(self, warehouseId):
2665 
    self._oprot.writeMessageBegin('batchOrders', TMessageType.CALL, self._seqid)
2666 
    args = batchOrders_args()
2667 
    args.warehouseId = warehouseId
2668 
    args.write(self._oprot)
2669 
    self._oprot.writeMessageEnd()
2670 
    self._oprot.trans.flush()
2671 
 
2672 
  def recv_batchOrders(self, ):
2673 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2674 
    if mtype == TMessageType.EXCEPTION:
2675 
      x = TApplicationException()
2676 
      x.read(self._iprot)
2677 
      self._iprot.readMessageEnd()
2678 
      raise x
2679 
    result = batchOrders_result()
2680 
    result.read(self._iprot)
2681 
    self._iprot.readMessageEnd()
3431 rajveer 2682 
    if result.success is not None:
1220 chandransh 2683 
      return result.success
3431 rajveer 2684 
    if result.ex is not None:
1220 chandransh 2685 
      raise result.ex
2686 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "batchOrders failed: unknown result");
2687 
 
1208 chandransh 2688 
  def markOrderAsOutOfStock(self, orderId):
2689 
    """
2690 
    Mark the given order as out of stock. Throws an exception if the order with the given Id couldn't be found.
3431 rajveer 2691 
 
1208 chandransh 2692 
    Parameters:
2693 
     - orderId
2694 
    """
2695 
    self.send_markOrderAsOutOfStock(orderId)
2696 
    return self.recv_markOrderAsOutOfStock()
2697 
 
2698 
  def send_markOrderAsOutOfStock(self, orderId):
2699 
    self._oprot.writeMessageBegin('markOrderAsOutOfStock', TMessageType.CALL, self._seqid)
2700 
    args = markOrderAsOutOfStock_args()
2701 
    args.orderId = orderId
2702 
    args.write(self._oprot)
2703 
    self._oprot.writeMessageEnd()
2704 
    self._oprot.trans.flush()
2705 
 
2706 
  def recv_markOrderAsOutOfStock(self, ):
2707 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2708 
    if mtype == TMessageType.EXCEPTION:
2709 
      x = TApplicationException()
2710 
      x.read(self._iprot)
2711 
      self._iprot.readMessageEnd()
2712 
      raise x
2713 
    result = markOrderAsOutOfStock_result()
2714 
    result.read(self._iprot)
2715 
    self._iprot.readMessageEnd()
3431 rajveer 2716 
    if result.success is not None:
1208 chandransh 2717 
      return result.success
3431 rajveer 2718 
    if result.ex is not None:
1208 chandransh 2719 
      raise result.ex
2720 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderAsOutOfStock failed: unknown result");
2721 
 
3064 chandransh 2722 
  def verifyOrder(self, orderId):
759 chandransh 2723 
    """
3064 chandransh 2724 
    Marks the given order as SUBMITTED_FOR_PROCESSING and updates the verified
2725 
    timestamp. It is intended to be used for COD orders but can be harmlessly
2726 
    used for all other orders as well.
2727 
    Throws an exception if no such order exists.
3431 rajveer 2728 
 
759 chandransh 2729 
    Parameters:
3064 chandransh 2730 
     - orderId
759 chandransh 2731 
    """
3064 chandransh 2732 
    self.send_verifyOrder(orderId)
2733 
    return self.recv_verifyOrder()
759 chandransh 2734 
 
3064 chandransh 2735 
  def send_verifyOrder(self, orderId):
2736 
    self._oprot.writeMessageBegin('verifyOrder', TMessageType.CALL, self._seqid)
2737 
    args = verifyOrder_args()
2738 
    args.orderId = orderId
759 chandransh 2739 
    args.write(self._oprot)
2740 
    self._oprot.writeMessageEnd()
2741 
    self._oprot.trans.flush()
2742 
 
3064 chandransh 2743 
  def recv_verifyOrder(self, ):
759 chandransh 2744 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2745 
    if mtype == TMessageType.EXCEPTION:
2746 
      x = TApplicationException()
2747 
      x.read(self._iprot)
2748 
      self._iprot.readMessageEnd()
2749 
      raise x
3064 chandransh 2750 
    result = verifyOrder_result()
759 chandransh 2751 
    result.read(self._iprot)
2752 
    self._iprot.readMessageEnd()
3431 rajveer 2753 
    if result.success is not None:
759 chandransh 2754 
      return result.success
3431 rajveer 2755 
    if result.ex is not None:
759 chandransh 2756 
      raise result.ex
3064 chandransh 2757 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "verifyOrder failed: unknown result");
759 chandransh 2758 
 
3064 chandransh 2759 
  def acceptOrder(self, orderId):
1113 chandransh 2760 
    """
3064 chandransh 2761 
    Marks the given order as ACCEPTED and updates the accepted timestamp. If the
2762 
    given order is not a COD order, it also captures the payment if the same has
2763 
    not been captured.
2764 
    Throws an exception if no such order exists.
3431 rajveer 2765 
 
1113 chandransh 2766 
    Parameters:
3064 chandransh 2767 
     - orderId
1113 chandransh 2768 
    """
3064 chandransh 2769 
    self.send_acceptOrder(orderId)
2770 
    return self.recv_acceptOrder()
1113 chandransh 2771 
 
3064 chandransh 2772 
  def send_acceptOrder(self, orderId):
2773 
    self._oprot.writeMessageBegin('acceptOrder', TMessageType.CALL, self._seqid)
2774 
    args = acceptOrder_args()
2775 
    args.orderId = orderId
1113 chandransh 2776 
    args.write(self._oprot)
2777 
    self._oprot.writeMessageEnd()
2778 
    self._oprot.trans.flush()
2779 
 
3064 chandransh 2780 
  def recv_acceptOrder(self, ):
1113 chandransh 2781 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2782 
    if mtype == TMessageType.EXCEPTION:
2783 
      x = TApplicationException()
2784 
      x.read(self._iprot)
2785 
      self._iprot.readMessageEnd()
2786 
      raise x
3064 chandransh 2787 
    result = acceptOrder_result()
1113 chandransh 2788 
    result.read(self._iprot)
2789 
    self._iprot.readMessageEnd()
3431 rajveer 2790 
    if result.success is not None:
1113 chandransh 2791 
      return result.success
3431 rajveer 2792 
    if result.ex is not None:
1113 chandransh 2793 
      raise result.ex
3064 chandransh 2794 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "acceptOrder failed: unknown result");
1113 chandransh 2795 
 
7190 amar.kumar 2796 
  def addBillingDetails(self, orderId, invoice_number, serialNumber, itemNumber, freebieWarehouseId, billed_by, jacketNumber, billingType, fulfilmentWarehouseId, authorize):
1132 chandransh 2797 
    """
3064 chandransh 2798 
    Add billing details such as the bill number and the biller to the Order.
4658 mandeep.dh 2799 
    Adds jacket number, item number and Serial no. to the order. Doesn't update
4283 anupam.sin 2800 
    the IMEI no. if a -1 is supplied.
2801 
    Also, it generates an invoice number for the order, marks the order as
2802 
    BILLED and sets the billing timestamp.
2803 
    Returns false if it doesn't find the order with the given ID.
3431 rajveer 2804 
 
1135 chandransh 2805 
    Parameters:
3064 chandransh 2806 
     - orderId
2807 
     - invoice_number
4658 mandeep.dh 2808 
     - serialNumber
4283 anupam.sin 2809 
     - itemNumber
7190 amar.kumar 2810 
     - freebieWarehouseId
3064 chandransh 2811 
     - billed_by
4264 rajveer 2812 
     - jacketNumber
4283 anupam.sin 2813 
     - billingType
5110 mandeep.dh 2814 
     - fulfilmentWarehouseId
4763 rajveer 2815 
     - authorize
1135 chandransh 2816 
    """
7190 amar.kumar 2817 
    self.send_addBillingDetails(orderId, invoice_number, serialNumber, itemNumber, freebieWarehouseId, billed_by, jacketNumber, billingType, fulfilmentWarehouseId, authorize)
3064 chandransh 2818 
    return self.recv_addBillingDetails()
1135 chandransh 2819 
 
7190 amar.kumar 2820 
  def send_addBillingDetails(self, orderId, invoice_number, serialNumber, itemNumber, freebieWarehouseId, billed_by, jacketNumber, billingType, fulfilmentWarehouseId, authorize):
3064 chandransh 2821 
    self._oprot.writeMessageBegin('addBillingDetails', TMessageType.CALL, self._seqid)
2822 
    args = addBillingDetails_args()
2823 
    args.orderId = orderId
2824 
    args.invoice_number = invoice_number
4658 mandeep.dh 2825 
    args.serialNumber = serialNumber
4283 anupam.sin 2826 
    args.itemNumber = itemNumber
7190 amar.kumar 2827 
    args.freebieWarehouseId = freebieWarehouseId
3064 chandransh 2828 
    args.billed_by = billed_by
4264 rajveer 2829 
    args.jacketNumber = jacketNumber
4283 anupam.sin 2830 
    args.billingType = billingType
5110 mandeep.dh 2831 
    args.fulfilmentWarehouseId = fulfilmentWarehouseId
4763 rajveer 2832 
    args.authorize = authorize
1135 chandransh 2833 
    args.write(self._oprot)
2834 
    self._oprot.writeMessageEnd()
2835 
    self._oprot.trans.flush()
2836 
 
3064 chandransh 2837 
  def recv_addBillingDetails(self, ):
1135 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 = addBillingDetails_result()
1135 chandransh 2845 
    result.read(self._iprot)
2846 
    self._iprot.readMessageEnd()
3431 rajveer 2847 
    if result.success is not None:
3064 chandransh 2848 
      return result.success
3431 rajveer 2849 
    if result.ex is not None:
1135 chandransh 2850 
      raise result.ex
3064 chandransh 2851 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addBillingDetails failed: unknown result");
1135 chandransh 2852 
 
6756 amar.kumar 2853 
  def addInvoiceNumber(self, orderId, invoiceNumber, color, serialNumber, itemNumber):
4579 rajveer 2854 
    """
2855 
    Add the invoice number to the order.
2856 
 
2857 
    Parameters:
2858 
     - orderId
2859 
     - invoiceNumber
4763 rajveer 2860 
     - color
6756 amar.kumar 2861 
     - serialNumber
2862 
     - itemNumber
4579 rajveer 2863 
    """
6756 amar.kumar 2864 
    self.send_addInvoiceNumber(orderId, invoiceNumber, color, serialNumber, itemNumber)
4579 rajveer 2865 
    self.recv_addInvoiceNumber()
2866 
 
6756 amar.kumar 2867 
  def send_addInvoiceNumber(self, orderId, invoiceNumber, color, serialNumber, itemNumber):
4579 rajveer 2868 
    self._oprot.writeMessageBegin('addInvoiceNumber', TMessageType.CALL, self._seqid)
2869 
    args = addInvoiceNumber_args()
2870 
    args.orderId = orderId
2871 
    args.invoiceNumber = invoiceNumber
4763 rajveer 2872 
    args.color = color
6756 amar.kumar 2873 
    args.serialNumber = serialNumber
2874 
    args.itemNumber = itemNumber
4579 rajveer 2875 
    args.write(self._oprot)
2876 
    self._oprot.writeMessageEnd()
2877 
    self._oprot.trans.flush()
2878 
 
2879 
  def recv_addInvoiceNumber(self, ):
2880 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2881 
    if mtype == TMessageType.EXCEPTION:
2882 
      x = TApplicationException()
2883 
      x.read(self._iprot)
2884 
      self._iprot.readMessageEnd()
2885 
      raise x
2886 
    result = addInvoiceNumber_result()
2887 
    result.read(self._iprot)
2888 
    self._iprot.readMessageEnd()
2889 
    if result.ex is not None:
2890 
      raise result.ex
2891 
    return
2892 
 
4910 phani.kuma 2893 
  def markOrdersAsShippedFromWarehouse(self, warehouseId, providerId, cod, orderIds):
1408 ankur.sing 2894 
    """
3064 chandransh 2895 
    Depending on the third parameter, marks either all prepaid or all cod orders BILLED by the
4910 phani.kuma 2896 
    given warehouse and were picked up by the given provider as SHIPPED_FROM_WH.
3431 rajveer 2897 
 
1408 ankur.sing 2898 
    Parameters:
3064 chandransh 2899 
     - warehouseId
1408 ankur.sing 2900 
     - providerId
3064 chandransh 2901 
     - cod
4910 phani.kuma 2902 
     - orderIds
1408 ankur.sing 2903 
    """
4910 phani.kuma 2904 
    self.send_markOrdersAsShippedFromWarehouse(warehouseId, providerId, cod, orderIds)
2905 
    return self.recv_markOrdersAsShippedFromWarehouse()
1408 ankur.sing 2906 
 
4910 phani.kuma 2907 
  def send_markOrdersAsShippedFromWarehouse(self, warehouseId, providerId, cod, orderIds):
2908 
    self._oprot.writeMessageBegin('markOrdersAsShippedFromWarehouse', TMessageType.CALL, self._seqid)
2909 
    args = markOrdersAsShippedFromWarehouse_args()
3064 chandransh 2910 
    args.warehouseId = warehouseId
1408 ankur.sing 2911 
    args.providerId = providerId
3064 chandransh 2912 
    args.cod = cod
4910 phani.kuma 2913 
    args.orderIds = orderIds
1408 ankur.sing 2914 
    args.write(self._oprot)
2915 
    self._oprot.writeMessageEnd()
2916 
    self._oprot.trans.flush()
2917 
 
4910 phani.kuma 2918 
  def recv_markOrdersAsShippedFromWarehouse(self, ):
1408 ankur.sing 2919 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2920 
    if mtype == TMessageType.EXCEPTION:
2921 
      x = TApplicationException()
2922 
      x.read(self._iprot)
2923 
      self._iprot.readMessageEnd()
2924 
      raise x
4910 phani.kuma 2925 
    result = markOrdersAsShippedFromWarehouse_result()
1408 ankur.sing 2926 
    result.read(self._iprot)
2927 
    self._iprot.readMessageEnd()
3431 rajveer 2928 
    if result.success is not None:
1408 ankur.sing 2929 
      return result.success
3431 rajveer 2930 
    if result.ex is not None:
3064 chandransh 2931 
      raise result.ex
4910 phani.kuma 2932 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrdersAsShippedFromWarehouse failed: unknown result");
1408 ankur.sing 2933 
 
5713 rajveer 2934 
  def markOrdersAsReturnedFromStore(self, providerId, orderIds, awbs):
5676 rajveer 2935 
    """
2936 
    Parameters:
2937 
     - providerId
2938 
     - orderIds
5713 rajveer 2939 
     - awbs
5676 rajveer 2940 
    """
5713 rajveer 2941 
    self.send_markOrdersAsReturnedFromStore(providerId, orderIds, awbs)
5676 rajveer 2942 
    return self.recv_markOrdersAsReturnedFromStore()
2943 
 
5713 rajveer 2944 
  def send_markOrdersAsReturnedFromStore(self, providerId, orderIds, awbs):
5676 rajveer 2945 
    self._oprot.writeMessageBegin('markOrdersAsReturnedFromStore', TMessageType.CALL, self._seqid)
2946 
    args = markOrdersAsReturnedFromStore_args()
2947 
    args.providerId = providerId
2948 
    args.orderIds = orderIds
5713 rajveer 2949 
    args.awbs = awbs
5676 rajveer 2950 
    args.write(self._oprot)
2951 
    self._oprot.writeMessageEnd()
2952 
    self._oprot.trans.flush()
2953 
 
2954 
  def recv_markOrdersAsReturnedFromStore(self, ):
2955 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2956 
    if mtype == TMessageType.EXCEPTION:
2957 
      x = TApplicationException()
2958 
      x.read(self._iprot)
2959 
      self._iprot.readMessageEnd()
2960 
      raise x
2961 
    result = markOrdersAsReturnedFromStore_result()
2962 
    result.read(self._iprot)
2963 
    self._iprot.readMessageEnd()
2964 
    if result.success is not None:
2965 
      return result.success
2966 
    if result.ex is not None:
2967 
      raise result.ex
2968 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrdersAsReturnedFromStore failed: unknown result");
2969 
 
4910 phani.kuma 2970 
  def markOrdersAsPickedUp(self, providerId, pickupDetails):
4410 rajveer 2971 
    """
4910 phani.kuma 2972 
    Marks all SHIPPED_FROM_WH orders of the previous day for a provider as SHIPPED_TO_LOGISTICS.
2973 
    Raises an exception if we encounter report for an AWB number that we did not ship.
4410 rajveer 2974 
 
2975 
    Parameters:
2976 
     - providerId
4910 phani.kuma 2977 
     - pickupDetails
4410 rajveer 2978 
    """
4910 phani.kuma 2979 
    self.send_markOrdersAsPickedUp(providerId, pickupDetails)
2980 
    self.recv_markOrdersAsPickedUp()
4410 rajveer 2981 
 
4910 phani.kuma 2982 
  def send_markOrdersAsPickedUp(self, providerId, pickupDetails):
2983 
    self._oprot.writeMessageBegin('markOrdersAsPickedUp', TMessageType.CALL, self._seqid)
2984 
    args = markOrdersAsPickedUp_args()
4410 rajveer 2985 
    args.providerId = providerId
4910 phani.kuma 2986 
    args.pickupDetails = pickupDetails
4410 rajveer 2987 
    args.write(self._oprot)
2988 
    self._oprot.writeMessageEnd()
2989 
    self._oprot.trans.flush()
2990 
 
4910 phani.kuma 2991 
  def recv_markOrdersAsPickedUp(self, ):
4410 rajveer 2992 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2993 
    if mtype == TMessageType.EXCEPTION:
2994 
      x = TApplicationException()
2995 
      x.read(self._iprot)
2996 
      self._iprot.readMessageEnd()
2997 
      raise x
4910 phani.kuma 2998 
    result = markOrdersAsPickedUp_result()
4410 rajveer 2999 
    result.read(self._iprot)
3000 
    self._iprot.readMessageEnd()
3001 
    if result.ex is not None:
3002 
      raise result.ex
4910 phani.kuma 3003 
    return
4410 rajveer 3004 
 
4910 phani.kuma 3005 
  def getOrdersNotPickedUp(self, providerId):
94 ashish 3006 
    """
3064 chandransh 3007 
    Returns a list of orders that were shipped from warehouse but did not appear in the pick-up report.
3431 rajveer 3008 
 
94 ashish 3009 
    Parameters:
3064 chandransh 3010 
     - providerId
304 ashish 3011 
    """
4910 phani.kuma 3012 
    self.send_getOrdersNotPickedUp(providerId)
3013 
    return self.recv_getOrdersNotPickedUp()
94 ashish 3014 
 
4910 phani.kuma 3015 
  def send_getOrdersNotPickedUp(self, providerId):
3016 
    self._oprot.writeMessageBegin('getOrdersNotPickedUp', TMessageType.CALL, self._seqid)
3017 
    args = getOrdersNotPickedUp_args()
3064 chandransh 3018 
    args.providerId = providerId
304 ashish 3019 
    args.write(self._oprot)
3020 
    self._oprot.writeMessageEnd()
3021 
    self._oprot.trans.flush()
3022 
 
4910 phani.kuma 3023 
  def recv_getOrdersNotPickedUp(self, ):
304 ashish 3024 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3025 
    if mtype == TMessageType.EXCEPTION:
3026 
      x = TApplicationException()
3027 
      x.read(self._iprot)
3028 
      self._iprot.readMessageEnd()
3029 
      raise x
4910 phani.kuma 3030 
    result = getOrdersNotPickedUp_result()
304 ashish 3031 
    result.read(self._iprot)
3032 
    self._iprot.readMessageEnd()
3431 rajveer 3033 
    if result.success is not None:
304 ashish 3034 
      return result.success
4910 phani.kuma 3035 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersNotPickedUp failed: unknown result");
304 ashish 3036 
 
3064 chandransh 3037 
  def markOrdersAsDelivered(self, providerId, deliveredOrders):
304 ashish 3038 
    """
3064 chandransh 3039 
    Marks all orders with AWBs in the given map as delivered. Also sets the delivery timestamp and
3040 
    the name of the receiver.
3041 
    Raises an exception if we encounter report for an AWB number that we did not ship.
3431 rajveer 3042 
 
304 ashish 3043 
    Parameters:
3064 chandransh 3044 
     - providerId
3045 
     - deliveredOrders
304 ashish 3046 
    """
3064 chandransh 3047 
    self.send_markOrdersAsDelivered(providerId, deliveredOrders)
3048 
    self.recv_markOrdersAsDelivered()
304 ashish 3049 
 
3064 chandransh 3050 
  def send_markOrdersAsDelivered(self, providerId, deliveredOrders):
3051 
    self._oprot.writeMessageBegin('markOrdersAsDelivered', TMessageType.CALL, self._seqid)
3052 
    args = markOrdersAsDelivered_args()
3053 
    args.providerId = providerId
3054 
    args.deliveredOrders = deliveredOrders
304 ashish 3055 
    args.write(self._oprot)
3056 
    self._oprot.writeMessageEnd()
3057 
    self._oprot.trans.flush()
3058 
 
3064 chandransh 3059 
  def recv_markOrdersAsDelivered(self, ):
304 ashish 3060 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3061 
    if mtype == TMessageType.EXCEPTION:
3062 
      x = TApplicationException()
3063 
      x.read(self._iprot)
3064 
      self._iprot.readMessageEnd()
3065 
      raise x
3064 chandransh 3066 
    result = markOrdersAsDelivered_result()
304 ashish 3067 
    result.read(self._iprot)
3068 
    self._iprot.readMessageEnd()
3431 rajveer 3069 
    if result.ex is not None:
3064 chandransh 3070 
      raise result.ex
304 ashish 3071 
    return
3072 
 
4910 phani.kuma 3073 
  def markAsRTOrders(self, providerId, returnedOrders):
1596 ankur.sing 3074 
    """
4910 phani.kuma 3075 
    Mark all orders with AWBs in the given map as RTO. Also sets the delivery timestamp.
3064 chandransh 3076 
    Raises an exception if we encounter report for an AWB number that we did not ship.
3431 rajveer 3077 
 
3064 chandransh 3078 
    Parameters:
3079 
     - providerId
3080 
     - returnedOrders
1596 ankur.sing 3081 
    """
4910 phani.kuma 3082 
    self.send_markAsRTOrders(providerId, returnedOrders)
3083 
    self.recv_markAsRTOrders()
304 ashish 3084 
 
4910 phani.kuma 3085 
  def send_markAsRTOrders(self, providerId, returnedOrders):
3086 
    self._oprot.writeMessageBegin('markAsRTOrders', TMessageType.CALL, self._seqid)
3087 
    args = markAsRTOrders_args()
3064 chandransh 3088 
    args.providerId = providerId
3089 
    args.returnedOrders = returnedOrders
1596 ankur.sing 3090 
    args.write(self._oprot)
3091 
    self._oprot.writeMessageEnd()
3092 
    self._oprot.trans.flush()
3093 
 
4910 phani.kuma 3094 
  def recv_markAsRTOrders(self, ):
1596 ankur.sing 3095 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3096 
    if mtype == TMessageType.EXCEPTION:
3097 
      x = TApplicationException()
3098 
      x.read(self._iprot)
3099 
      self._iprot.readMessageEnd()
3100 
      raise x
4910 phani.kuma 3101 
    result = markAsRTOrders_result()
1596 ankur.sing 3102 
    result.read(self._iprot)
3103 
    self._iprot.readMessageEnd()
3431 rajveer 3104 
    if result.ex is not None:
3064 chandransh 3105 
      raise result.ex
3106 
    return
1596 ankur.sing 3107 
 
4910 phani.kuma 3108 
  def getRTOrders(self, providerId):
3109 
    """
3110 
    Returns a list of orders that were returned by courier.
3111 
 
3112 
    Parameters:
3113 
     - providerId
3114 
    """
3115 
    self.send_getRTOrders(providerId)
3116 
    return self.recv_getRTOrders()
3117 
 
3118 
  def send_getRTOrders(self, providerId):
3119 
    self._oprot.writeMessageBegin('getRTOrders', TMessageType.CALL, self._seqid)
3120 
    args = getRTOrders_args()
3121 
    args.providerId = providerId
3122 
    args.write(self._oprot)
3123 
    self._oprot.writeMessageEnd()
3124 
    self._oprot.trans.flush()
3125 
 
3126 
  def recv_getRTOrders(self, ):
3127 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3128 
    if mtype == TMessageType.EXCEPTION:
3129 
      x = TApplicationException()
3130 
      x.read(self._iprot)
3131 
      self._iprot.readMessageEnd()
3132 
      raise x
3133 
    result = getRTOrders_result()
3134 
    result.read(self._iprot)
3135 
    self._iprot.readMessageEnd()
3136 
    if result.success is not None:
3137 
      return result.success
3138 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getRTOrders failed: unknown result");
3139 
 
3064 chandransh 3140 
  def updateNonDeliveryReason(self, providerId, undeliveredOrders):
1627 ankur.sing 3141 
    """
3064 chandransh 3142 
    Update the status description of orders whose AWB numbers are keys of the Map.
3431 rajveer 3143 
 
3064 chandransh 3144 
    Parameters:
3145 
     - providerId
3146 
     - undeliveredOrders
1627 ankur.sing 3147 
    """
3064 chandransh 3148 
    self.send_updateNonDeliveryReason(providerId, undeliveredOrders)
4910 phani.kuma 3149 
    self.recv_updateNonDeliveryReason()
1596 ankur.sing 3150 
 
3064 chandransh 3151 
  def send_updateNonDeliveryReason(self, providerId, undeliveredOrders):
3152 
    self._oprot.writeMessageBegin('updateNonDeliveryReason', TMessageType.CALL, self._seqid)
3153 
    args = updateNonDeliveryReason_args()
3154 
    args.providerId = providerId
3155 
    args.undeliveredOrders = undeliveredOrders
1627 ankur.sing 3156 
    args.write(self._oprot)
3157 
    self._oprot.writeMessageEnd()
3158 
    self._oprot.trans.flush()
3159 
 
3064 chandransh 3160 
  def recv_updateNonDeliveryReason(self, ):
1627 ankur.sing 3161 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3162 
    if mtype == TMessageType.EXCEPTION:
3163 
      x = TApplicationException()
3164 
      x.read(self._iprot)
3165 
      self._iprot.readMessageEnd()
3166 
      raise x
3064 chandransh 3167 
    result = updateNonDeliveryReason_result()
1627 ankur.sing 3168 
    result.read(self._iprot)
3169 
    self._iprot.readMessageEnd()
4910 phani.kuma 3170 
    if result.ex is not None:
3171 
      raise result.ex
3172 
    return
3173 
 
3174 
  def getNonDeliveredOrdersbyCourier(self, providerId):
3175 
    """
3176 
    Returns a list of orders that were picked up or shipped four days ago but did not get delivered.
3177 
 
3178 
    Parameters:
3179 
     - providerId
3180 
    """
3181 
    self.send_getNonDeliveredOrdersbyCourier(providerId)
3182 
    return self.recv_getNonDeliveredOrdersbyCourier()
3183 
 
3184 
  def send_getNonDeliveredOrdersbyCourier(self, providerId):
3185 
    self._oprot.writeMessageBegin('getNonDeliveredOrdersbyCourier', TMessageType.CALL, self._seqid)
3186 
    args = getNonDeliveredOrdersbyCourier_args()
3187 
    args.providerId = providerId
3188 
    args.write(self._oprot)
3189 
    self._oprot.writeMessageEnd()
3190 
    self._oprot.trans.flush()
3191 
 
3192 
  def recv_getNonDeliveredOrdersbyCourier(self, ):
3193 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3194 
    if mtype == TMessageType.EXCEPTION:
3195 
      x = TApplicationException()
3196 
      x.read(self._iprot)
3197 
      self._iprot.readMessageEnd()
3198 
      raise x
3199 
    result = getNonDeliveredOrdersbyCourier_result()
3200 
    result.read(self._iprot)
3201 
    self._iprot.readMessageEnd()
4581 phani.kuma 3202 
    if result.success is not None:
3203 
      return result.success
4910 phani.kuma 3204 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getNonDeliveredOrdersbyCourier failed: unknown result");
3205 
 
3206 
  def markOrdersAsLocalConnected(self, providerId, local_connected_orders):
3207 
    """
3208 
    Mark all orders with AWBs in the given map as local connected. Also sets the local connected timestamp.
3209 
 
3210 
    Parameters:
3211 
     - providerId
3212 
     - local_connected_orders
3213 
    """
3214 
    self.send_markOrdersAsLocalConnected(providerId, local_connected_orders)
3215 
    self.recv_markOrdersAsLocalConnected()
3216 
 
3217 
  def send_markOrdersAsLocalConnected(self, providerId, local_connected_orders):
3218 
    self._oprot.writeMessageBegin('markOrdersAsLocalConnected', TMessageType.CALL, self._seqid)
3219 
    args = markOrdersAsLocalConnected_args()
3220 
    args.providerId = providerId
3221 
    args.local_connected_orders = local_connected_orders
3222 
    args.write(self._oprot)
3223 
    self._oprot.writeMessageEnd()
3224 
    self._oprot.trans.flush()
3225 
 
3226 
  def recv_markOrdersAsLocalConnected(self, ):
3227 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3228 
    if mtype == TMessageType.EXCEPTION:
3229 
      x = TApplicationException()
3230 
      x.read(self._iprot)
3231 
      self._iprot.readMessageEnd()
3232 
      raise x
3233 
    result = markOrdersAsLocalConnected_result()
3234 
    result.read(self._iprot)
3235 
    self._iprot.readMessageEnd()
3431 rajveer 3236 
    if result.ex is not None:
3064 chandransh 3237 
      raise result.ex
4910 phani.kuma 3238 
    return
1627 ankur.sing 3239 
 
4910 phani.kuma 3240 
  def getOrdersNotLocalConnected(self, providerId):
3241 
    """
3242 
    Returns a list of orders that were picked up or shipped but pending local connection.
3243 
 
3244 
    Parameters:
3245 
     - providerId
3246 
    """
3247 
    self.send_getOrdersNotLocalConnected(providerId)
3248 
    return self.recv_getOrdersNotLocalConnected()
3249 
 
3250 
  def send_getOrdersNotLocalConnected(self, providerId):
3251 
    self._oprot.writeMessageBegin('getOrdersNotLocalConnected', TMessageType.CALL, self._seqid)
3252 
    args = getOrdersNotLocalConnected_args()
3253 
    args.providerId = providerId
3254 
    args.write(self._oprot)
3255 
    self._oprot.writeMessageEnd()
3256 
    self._oprot.trans.flush()
3257 
 
3258 
  def recv_getOrdersNotLocalConnected(self, ):
3259 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3260 
    if mtype == TMessageType.EXCEPTION:
3261 
      x = TApplicationException()
3262 
      x.read(self._iprot)
3263 
      self._iprot.readMessageEnd()
3264 
      raise x
3265 
    result = getOrdersNotLocalConnected_result()
3266 
    result.read(self._iprot)
3267 
    self._iprot.readMessageEnd()
3268 
    if result.success is not None:
3269 
      return result.success
3270 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersNotLocalConnected failed: unknown result");
3271 
 
3272 
  def markOrdersAsDestinationCityReached(self, providerId, destination_city_reached_orders):
3273 
    """
3274 
    Mark all orders with AWBs in the given map as reached destination city. Also sets the reached destination timestamp.
3275 
 
3276 
    Parameters:
3277 
     - providerId
3278 
     - destination_city_reached_orders
3279 
    """
3280 
    self.send_markOrdersAsDestinationCityReached(providerId, destination_city_reached_orders)
3281 
    self.recv_markOrdersAsDestinationCityReached()
3282 
 
3283 
  def send_markOrdersAsDestinationCityReached(self, providerId, destination_city_reached_orders):
3284 
    self._oprot.writeMessageBegin('markOrdersAsDestinationCityReached', TMessageType.CALL, self._seqid)
3285 
    args = markOrdersAsDestinationCityReached_args()
3286 
    args.providerId = providerId
3287 
    args.destination_city_reached_orders = destination_city_reached_orders
3288 
    args.write(self._oprot)
3289 
    self._oprot.writeMessageEnd()
3290 
    self._oprot.trans.flush()
3291 
 
3292 
  def recv_markOrdersAsDestinationCityReached(self, ):
3293 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3294 
    if mtype == TMessageType.EXCEPTION:
3295 
      x = TApplicationException()
3296 
      x.read(self._iprot)
3297 
      self._iprot.readMessageEnd()
3298 
      raise x
3299 
    result = markOrdersAsDestinationCityReached_result()
3300 
    result.read(self._iprot)
3301 
    self._iprot.readMessageEnd()
3302 
    if result.ex is not None:
3303 
      raise result.ex
3304 
    return
3305 
 
3306 
  def markOrdersAsFirstDeliveryAttempted(self, providerId, first_atdl_orders):
3307 
    """
3308 
    Mark all orders with AWBs in the given map as first delivery attempt made. Also sets the first delivery attempted timestamp.
3309 
 
3310 
    Parameters:
3311 
     - providerId
3312 
     - first_atdl_orders
3313 
    """
3314 
    self.send_markOrdersAsFirstDeliveryAttempted(providerId, first_atdl_orders)
3315 
    self.recv_markOrdersAsFirstDeliveryAttempted()
3316 
 
3317 
  def send_markOrdersAsFirstDeliveryAttempted(self, providerId, first_atdl_orders):
3318 
    self._oprot.writeMessageBegin('markOrdersAsFirstDeliveryAttempted', TMessageType.CALL, self._seqid)
3319 
    args = markOrdersAsFirstDeliveryAttempted_args()
3320 
    args.providerId = providerId
3321 
    args.first_atdl_orders = first_atdl_orders
3322 
    args.write(self._oprot)
3323 
    self._oprot.writeMessageEnd()
3324 
    self._oprot.trans.flush()
3325 
 
3326 
  def recv_markOrdersAsFirstDeliveryAttempted(self, ):
3327 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3328 
    if mtype == TMessageType.EXCEPTION:
3329 
      x = TApplicationException()
3330 
      x.read(self._iprot)
3331 
      self._iprot.readMessageEnd()
3332 
      raise x
3333 
    result = markOrdersAsFirstDeliveryAttempted_result()
3334 
    result.read(self._iprot)
3335 
    self._iprot.readMessageEnd()
3336 
    if result.ex is not None:
3337 
      raise result.ex
3338 
    return
3339 
 
3064 chandransh 3340 
  def getUndeliveredOrders(self, providerId, warehouseId):
1627 ankur.sing 3341 
    """
3064 chandransh 3342 
    Returns the list of orders whose delivery time has passed but have not been
3343 
    delivered yet for the given provider and warehouse. To get a complete list of
3344 
    undelivered orders, pass them as -1.
3345 
    Returns an empty list if no such orders exist.
3431 rajveer 3346 
 
1886 ankur.sing 3347 
    Parameters:
3064 chandransh 3348 
     - providerId
3349 
     - warehouseId
1886 ankur.sing 3350 
    """
3064 chandransh 3351 
    self.send_getUndeliveredOrders(providerId, warehouseId)
3352 
    return self.recv_getUndeliveredOrders()
1627 ankur.sing 3353 
 
3064 chandransh 3354 
  def send_getUndeliveredOrders(self, providerId, warehouseId):
3355 
    self._oprot.writeMessageBegin('getUndeliveredOrders', TMessageType.CALL, self._seqid)
3356 
    args = getUndeliveredOrders_args()
3357 
    args.providerId = providerId
3358 
    args.warehouseId = warehouseId
1886 ankur.sing 3359 
    args.write(self._oprot)
3360 
    self._oprot.writeMessageEnd()
3361 
    self._oprot.trans.flush()
3362 
 
3064 chandransh 3363 
  def recv_getUndeliveredOrders(self, ):
1886 ankur.sing 3364 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3365 
    if mtype == TMessageType.EXCEPTION:
3366 
      x = TApplicationException()
3367 
      x.read(self._iprot)
3368 
      self._iprot.readMessageEnd()
3369 
      raise x
3064 chandransh 3370 
    result = getUndeliveredOrders_result()
1886 ankur.sing 3371 
    result.read(self._iprot)
3372 
    self._iprot.readMessageEnd()
3431 rajveer 3373 
    if result.success is not None:
1886 ankur.sing 3374 
      return result.success
3064 chandransh 3375 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUndeliveredOrders failed: unknown result");
1886 ankur.sing 3376 
 
4783 phani.kuma 3377 
  def getUndeliveredOrdersExpectedDeliveryDateNotMet(self, ):
3378 
    """
3379 
    Returns the list of orders whose expected delivery date has passed but have not been
3380 
    delivered yet.
3381 
    Returns an empty list if no such orders exist.
3382 
    """
3383 
    self.send_getUndeliveredOrdersExpectedDeliveryDateNotMet()
3384 
    return self.recv_getUndeliveredOrdersExpectedDeliveryDateNotMet()
3385 
 
3386 
  def send_getUndeliveredOrdersExpectedDeliveryDateNotMet(self, ):
3387 
    self._oprot.writeMessageBegin('getUndeliveredOrdersExpectedDeliveryDateNotMet', TMessageType.CALL, self._seqid)
3388 
    args = getUndeliveredOrdersExpectedDeliveryDateNotMet_args()
3389 
    args.write(self._oprot)
3390 
    self._oprot.writeMessageEnd()
3391 
    self._oprot.trans.flush()
3392 
 
3393 
  def recv_getUndeliveredOrdersExpectedDeliveryDateNotMet(self, ):
3394 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3395 
    if mtype == TMessageType.EXCEPTION:
3396 
      x = TApplicationException()
3397 
      x.read(self._iprot)
3398 
      self._iprot.readMessageEnd()
3399 
      raise x
3400 
    result = getUndeliveredOrdersExpectedDeliveryDateNotMet_result()
3401 
    result.read(self._iprot)
3402 
    self._iprot.readMessageEnd()
3403 
    if result.success is not None:
3404 
      return result.success
3405 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUndeliveredOrdersExpectedDeliveryDateNotMet failed: unknown result");
3406 
 
2536 chandransh 3407 
  def toggleDOAFlag(self, orderId):
3408 
    """
3409 
    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.
3410 
    Returns the final flag status.
3411 
    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 3412 
 
2536 chandransh 3413 
    Parameters:
3414 
     - orderId
3415 
    """
3416 
    self.send_toggleDOAFlag(orderId)
3417 
    return self.recv_toggleDOAFlag()
1886 ankur.sing 3418 
 
2536 chandransh 3419 
  def send_toggleDOAFlag(self, orderId):
3420 
    self._oprot.writeMessageBegin('toggleDOAFlag', TMessageType.CALL, self._seqid)
3421 
    args = toggleDOAFlag_args()
3422 
    args.orderId = orderId
3423 
    args.write(self._oprot)
3424 
    self._oprot.writeMessageEnd()
3425 
    self._oprot.trans.flush()
3426 
 
3427 
  def recv_toggleDOAFlag(self, ):
3428 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3429 
    if mtype == TMessageType.EXCEPTION:
3430 
      x = TApplicationException()
3431 
      x.read(self._iprot)
3432 
      self._iprot.readMessageEnd()
3433 
      raise x
3434 
    result = toggleDOAFlag_result()
3435 
    result.read(self._iprot)
3436 
    self._iprot.readMessageEnd()
3431 rajveer 3437 
    if result.success is not None:
2536 chandransh 3438 
      return result.success
3431 rajveer 3439 
    if result.ex is not None:
2536 chandransh 3440 
      raise result.ex
3441 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "toggleDOAFlag failed: unknown result");
3442 
 
4712 rajveer 3443 
  def markOrderAsDelivered(self, orderId, deliveryTimestamp, receiver):
3444 
    """
3445 
    Parameters:
3446 
     - orderId
3447 
     - deliveryTimestamp
3448 
     - receiver
3449 
    """
3450 
    self.send_markOrderAsDelivered(orderId, deliveryTimestamp, receiver)
3451 
    self.recv_markOrderAsDelivered()
3452 
 
3453 
  def send_markOrderAsDelivered(self, orderId, deliveryTimestamp, receiver):
3454 
    self._oprot.writeMessageBegin('markOrderAsDelivered', TMessageType.CALL, self._seqid)
3455 
    args = markOrderAsDelivered_args()
3456 
    args.orderId = orderId
3457 
    args.deliveryTimestamp = deliveryTimestamp
3458 
    args.receiver = receiver
3459 
    args.write(self._oprot)
3460 
    self._oprot.writeMessageEnd()
3461 
    self._oprot.trans.flush()
3462 
 
3463 
  def recv_markOrderAsDelivered(self, ):
3464 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3465 
    if mtype == TMessageType.EXCEPTION:
3466 
      x = TApplicationException()
3467 
      x.read(self._iprot)
3468 
      self._iprot.readMessageEnd()
3469 
      raise x
3470 
    result = markOrderAsDelivered_result()
3471 
    result.read(self._iprot)
3472 
    self._iprot.readMessageEnd()
3473 
    if result.ex is not None:
3474 
      raise result.ex
3475 
    return
3476 
 
5553 rajveer 3477 
  def markOrderAsReceivedAtStore(self, orderId, deliveryTimestamp):
3478 
    """
3479 
    Parameters:
3480 
     - orderId
3481 
     - deliveryTimestamp
3482 
    """
3483 
    self.send_markOrderAsReceivedAtStore(orderId, deliveryTimestamp)
3484 
    self.recv_markOrderAsReceivedAtStore()
3485 
 
3486 
  def send_markOrderAsReceivedAtStore(self, orderId, deliveryTimestamp):
3487 
    self._oprot.writeMessageBegin('markOrderAsReceivedAtStore', TMessageType.CALL, self._seqid)
3488 
    args = markOrderAsReceivedAtStore_args()
3489 
    args.orderId = orderId
3490 
    args.deliveryTimestamp = deliveryTimestamp
3491 
    args.write(self._oprot)
3492 
    self._oprot.writeMessageEnd()
3493 
    self._oprot.trans.flush()
3494 
 
3495 
  def recv_markOrderAsReceivedAtStore(self, ):
3496 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3497 
    if mtype == TMessageType.EXCEPTION:
3498 
      x = TApplicationException()
3499 
      x.read(self._iprot)
3500 
      self._iprot.readMessageEnd()
3501 
      raise x
3502 
    result = markOrderAsReceivedAtStore_result()
3503 
    result.read(self._iprot)
3504 
    self._iprot.readMessageEnd()
3505 
    if result.ex is not None:
3506 
      raise result.ex
3507 
    return
3508 
 
4454 rajveer 3509 
  def markOrderDoaRequestReceived(self, orderId):
3510 
    """
3511 
    Once user raise the request for a DOA, order status will be changed from DELVIERY_SUCCESS to DOA_REQUEST_RECEIVED
3512 
 
3513 
    Parameters:
3514 
     - orderId
3515 
    """
3516 
    self.send_markOrderDoaRequestReceived(orderId)
3517 
    return self.recv_markOrderDoaRequestReceived()
3518 
 
3519 
  def send_markOrderDoaRequestReceived(self, orderId):
3520 
    self._oprot.writeMessageBegin('markOrderDoaRequestReceived', TMessageType.CALL, self._seqid)
3521 
    args = markOrderDoaRequestReceived_args()
3522 
    args.orderId = orderId
3523 
    args.write(self._oprot)
3524 
    self._oprot.writeMessageEnd()
3525 
    self._oprot.trans.flush()
3526 
 
3527 
  def recv_markOrderDoaRequestReceived(self, ):
3528 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3529 
    if mtype == TMessageType.EXCEPTION:
3530 
      x = TApplicationException()
3531 
      x.read(self._iprot)
3532 
      self._iprot.readMessageEnd()
3533 
      raise x
3534 
    result = markOrderDoaRequestReceived_result()
3535 
    result.read(self._iprot)
3536 
    self._iprot.readMessageEnd()
3537 
    if result.success is not None:
3538 
      return result.success
3539 
    if result.ex is not None:
3540 
      raise result.ex
3541 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderDoaRequestReceived failed: unknown result");
3542 
 
3543 
  def markOrderDoaRequestAuthorized(self, orderId, isAuthorized):
3544 
    """
3545 
    CRM person can authorize or deny the request reised by customer. If he authorizes order will change from DOA_REQUEST_RECEIVED
3546 
    to DOA_REQUEST_AUTHORIZED. If he denies, status will be changed back to DELVIERY_SUCCESS.
3547 
 
3548 
    Parameters:
3549 
     - orderId
3550 
     - isAuthorized
3551 
    """
3552 
    self.send_markOrderDoaRequestAuthorized(orderId, isAuthorized)
3553 
    return self.recv_markOrderDoaRequestAuthorized()
3554 
 
3555 
  def send_markOrderDoaRequestAuthorized(self, orderId, isAuthorized):
3556 
    self._oprot.writeMessageBegin('markOrderDoaRequestAuthorized', TMessageType.CALL, self._seqid)
3557 
    args = markOrderDoaRequestAuthorized_args()
3558 
    args.orderId = orderId
3559 
    args.isAuthorized = isAuthorized
3560 
    args.write(self._oprot)
3561 
    self._oprot.writeMessageEnd()
3562 
    self._oprot.trans.flush()
3563 
 
3564 
  def recv_markOrderDoaRequestAuthorized(self, ):
3565 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3566 
    if mtype == TMessageType.EXCEPTION:
3567 
      x = TApplicationException()
3568 
      x.read(self._iprot)
3569 
      self._iprot.readMessageEnd()
3570 
      raise x
3571 
    result = markOrderDoaRequestAuthorized_result()
3572 
    result.read(self._iprot)
3573 
    self._iprot.readMessageEnd()
3574 
    if result.success is not None:
3575 
      return result.success
3576 
    if result.ex is not None:
3577 
      raise result.ex
3578 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderDoaRequestAuthorized failed: unknown result");
3579 
 
4488 rajveer 3580 
  def markOrderReturnRequestReceived(self, orderId):
3581 
    """
3582 
    Once user raise the request for a RET, order status will be changed from DELVIERY_SUCCESS to RET_REQUEST_RECEIVED
3583 
 
3584 
    Parameters:
3585 
     - orderId
3586 
    """
3587 
    self.send_markOrderReturnRequestReceived(orderId)
3588 
    return self.recv_markOrderReturnRequestReceived()
3589 
 
3590 
  def send_markOrderReturnRequestReceived(self, orderId):
3591 
    self._oprot.writeMessageBegin('markOrderReturnRequestReceived', TMessageType.CALL, self._seqid)
3592 
    args = markOrderReturnRequestReceived_args()
3593 
    args.orderId = orderId
3594 
    args.write(self._oprot)
3595 
    self._oprot.writeMessageEnd()
3596 
    self._oprot.trans.flush()
3597 
 
3598 
  def recv_markOrderReturnRequestReceived(self, ):
3599 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3600 
    if mtype == TMessageType.EXCEPTION:
3601 
      x = TApplicationException()
3602 
      x.read(self._iprot)
3603 
      self._iprot.readMessageEnd()
3604 
      raise x
3605 
    result = markOrderReturnRequestReceived_result()
3606 
    result.read(self._iprot)
3607 
    self._iprot.readMessageEnd()
3608 
    if result.success is not None:
3609 
      return result.success
3610 
    if result.ex is not None:
3611 
      raise result.ex
3612 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderReturnRequestReceived failed: unknown result");
3613 
 
3614 
  def markOrderReturnRequestAuthorized(self, orderId, isAuthorized):
3615 
    """
3616 
    CRM person can authorize or deny the request reised by customer. If he authorizes order will change from RET_REQUEST_RECEIVED
3617 
    to RET_REQUEST_AUTHORIZED. If he denies, status will be changed back to DELVIERY_SUCCESS.
3618 
 
3619 
    Parameters:
3620 
     - orderId
3621 
     - isAuthorized
3622 
    """
3623 
    self.send_markOrderReturnRequestAuthorized(orderId, isAuthorized)
3624 
    return self.recv_markOrderReturnRequestAuthorized()
3625 
 
3626 
  def send_markOrderReturnRequestAuthorized(self, orderId, isAuthorized):
3627 
    self._oprot.writeMessageBegin('markOrderReturnRequestAuthorized', TMessageType.CALL, self._seqid)
3628 
    args = markOrderReturnRequestAuthorized_args()
3629 
    args.orderId = orderId
3630 
    args.isAuthorized = isAuthorized
3631 
    args.write(self._oprot)
3632 
    self._oprot.writeMessageEnd()
3633 
    self._oprot.trans.flush()
3634 
 
3635 
  def recv_markOrderReturnRequestAuthorized(self, ):
3636 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3637 
    if mtype == TMessageType.EXCEPTION:
3638 
      x = TApplicationException()
3639 
      x.read(self._iprot)
3640 
      self._iprot.readMessageEnd()
3641 
      raise x
3642 
    result = markOrderReturnRequestAuthorized_result()
3643 
    result.read(self._iprot)
3644 
    self._iprot.readMessageEnd()
3645 
    if result.success is not None:
3646 
      return result.success
3647 
    if result.ex is not None:
3648 
      raise result.ex
3649 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderReturnRequestAuthorized failed: unknown result");
3650 
 
4579 rajveer 3651 
  def requestPickupNumber(self, orderId, providerId):
2536 chandransh 3652 
    """
3653 
    Sends out an email to the account manager of the original courier provider used to ship the order.
4452 rajveer 3654 
    If the order status was DELIVERY_SUCCESS, it is changed to be DOA_PICKUP_REQUEST_RAISED.
3655 
    If the order status was DOA_PICKUP_REQUEST_RAISED, it is left unchanged.
2536 chandransh 3656 
    For any other status, it returns false.
3657 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 3658 
 
2536 chandransh 3659 
    Parameters:
3660 
     - orderId
4579 rajveer 3661 
     - providerId
2536 chandransh 3662 
    """
4579 rajveer 3663 
    self.send_requestPickupNumber(orderId, providerId)
2536 chandransh 3664 
    return self.recv_requestPickupNumber()
3665 
 
4579 rajveer 3666 
  def send_requestPickupNumber(self, orderId, providerId):
2536 chandransh 3667 
    self._oprot.writeMessageBegin('requestPickupNumber', TMessageType.CALL, self._seqid)
3668 
    args = requestPickupNumber_args()
3669 
    args.orderId = orderId
4579 rajveer 3670 
    args.providerId = providerId
2536 chandransh 3671 
    args.write(self._oprot)
3672 
    self._oprot.writeMessageEnd()
3673 
    self._oprot.trans.flush()
3674 
 
3675 
  def recv_requestPickupNumber(self, ):
3676 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3677 
    if mtype == TMessageType.EXCEPTION:
3678 
      x = TApplicationException()
3679 
      x.read(self._iprot)
3680 
      self._iprot.readMessageEnd()
3681 
      raise x
3682 
    result = requestPickupNumber_result()
3683 
    result.read(self._iprot)
3684 
    self._iprot.readMessageEnd()
3431 rajveer 3685 
    if result.success is not None:
2536 chandransh 3686 
      return result.success
3431 rajveer 3687 
    if result.ex is not None:
2536 chandransh 3688 
      raise result.ex
3689 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "requestPickupNumber failed: unknown result");
3690 
 
4602 rajveer 3691 
  def authorizePickup(self, orderId, pickupNumber, providerId):
2536 chandransh 3692 
    """
4452 rajveer 3693 
    If the order status is DOA_PICKUP_REQUEST_RAISED, it does the following
2536 chandransh 3694 
    	1. Sends out an email to the customer with the dispatch advice that he has to print as an attachment.
3695 
    	2. Changes order status to be DOA_PICKUP_AUTHORIZED.
3696 
    	3. Returns true
2591 chandransh 3697 
    If the order is in any other status, it returns false.
2536 chandransh 3698 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 3699 
 
2536 chandransh 3700 
    Parameters:
3701 
     - orderId
3702 
     - pickupNumber
4602 rajveer 3703 
     - providerId
2536 chandransh 3704 
    """
4602 rajveer 3705 
    self.send_authorizePickup(orderId, pickupNumber, providerId)
2536 chandransh 3706 
    return self.recv_authorizePickup()
3707 
 
4602 rajveer 3708 
  def send_authorizePickup(self, orderId, pickupNumber, providerId):
2536 chandransh 3709 
    self._oprot.writeMessageBegin('authorizePickup', TMessageType.CALL, self._seqid)
3710 
    args = authorizePickup_args()
3711 
    args.orderId = orderId
3712 
    args.pickupNumber = pickupNumber
4602 rajveer 3713 
    args.providerId = providerId
2536 chandransh 3714 
    args.write(self._oprot)
3715 
    self._oprot.writeMessageEnd()
3716 
    self._oprot.trans.flush()
3717 
 
3718 
  def recv_authorizePickup(self, ):
3719 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3720 
    if mtype == TMessageType.EXCEPTION:
3721 
      x = TApplicationException()
3722 
      x.read(self._iprot)
3723 
      self._iprot.readMessageEnd()
3724 
      raise x
3725 
    result = authorizePickup_result()
3726 
    result.read(self._iprot)
3727 
    self._iprot.readMessageEnd()
3431 rajveer 3728 
    if result.success is not None:
2536 chandransh 3729 
      return result.success
3431 rajveer 3730 
    if result.ex is not None:
2536 chandransh 3731 
      raise result.ex
3732 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "authorizePickup failed: unknown result");
3733 
 
2764 chandransh 3734 
  def markDoasAsPickedUp(self, providerId, pickupDetails):
3735 
    """
3736 
    Marks all DOA_PICKUP_AUTHORIZED orders of the previous day for a provider as DOA_RETURN_IN_TRANSIT.
3431 rajveer 3737 
 
2764 chandransh 3738 
    Parameters:
3739 
     - providerId
3740 
     - pickupDetails
3741 
    """
3742 
    self.send_markDoasAsPickedUp(providerId, pickupDetails)
4910 phani.kuma 3743 
    self.recv_markDoasAsPickedUp()
2764 chandransh 3744 
 
3745 
  def send_markDoasAsPickedUp(self, providerId, pickupDetails):
3746 
    self._oprot.writeMessageBegin('markDoasAsPickedUp', TMessageType.CALL, self._seqid)
3747 
    args = markDoasAsPickedUp_args()
3748 
    args.providerId = providerId
3749 
    args.pickupDetails = pickupDetails
3750 
    args.write(self._oprot)
3751 
    self._oprot.writeMessageEnd()
3752 
    self._oprot.trans.flush()
3753 
 
3754 
  def recv_markDoasAsPickedUp(self, ):
3755 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3756 
    if mtype == TMessageType.EXCEPTION:
3757 
      x = TApplicationException()
3758 
      x.read(self._iprot)
3759 
      self._iprot.readMessageEnd()
3760 
      raise x
3761 
    result = markDoasAsPickedUp_result()
3762 
    result.read(self._iprot)
3763 
    self._iprot.readMessageEnd()
4910 phani.kuma 3764 
    return
3765 
 
3766 
  def getDoasNotPickedUp(self, providerId):
3767 
    """
3768 
    Returns a list of orders that were authorized for pickup but did not appear in the pick-up report.
3769 
 
3770 
    Parameters:
3771 
     - providerId
3772 
    """
3773 
    self.send_getDoasNotPickedUp(providerId)
3774 
    return self.recv_getDoasNotPickedUp()
3775 
 
3776 
  def send_getDoasNotPickedUp(self, providerId):
3777 
    self._oprot.writeMessageBegin('getDoasNotPickedUp', TMessageType.CALL, self._seqid)
3778 
    args = getDoasNotPickedUp_args()
3779 
    args.providerId = providerId
3780 
    args.write(self._oprot)
3781 
    self._oprot.writeMessageEnd()
3782 
    self._oprot.trans.flush()
3783 
 
3784 
  def recv_getDoasNotPickedUp(self, ):
3785 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3786 
    if mtype == TMessageType.EXCEPTION:
3787 
      x = TApplicationException()
3788 
      x.read(self._iprot)
3789 
      self._iprot.readMessageEnd()
3790 
      raise x
3791 
    result = getDoasNotPickedUp_result()
3792 
    result.read(self._iprot)
3793 
    self._iprot.readMessageEnd()
3431 rajveer 3794 
    if result.success is not None:
2764 chandransh 3795 
      return result.success
4910 phani.kuma 3796 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getDoasNotPickedUp failed: unknown result");
2764 chandransh 3797 
 
4741 phani.kuma 3798 
  def markReturnOrdersAsPickedUp(self, providerId, pickupDetails):
3799 
    """
3800 
    Marks all RET_PICKUP_CONFIRMED orders of the previous day for a provider as RET_RETURN_IN_TRANSIT.
3801 
 
3802 
    Parameters:
3803 
     - providerId
3804 
     - pickupDetails
3805 
    """
3806 
    self.send_markReturnOrdersAsPickedUp(providerId, pickupDetails)
4910 phani.kuma 3807 
    self.recv_markReturnOrdersAsPickedUp()
4741 phani.kuma 3808 
 
3809 
  def send_markReturnOrdersAsPickedUp(self, providerId, pickupDetails):
3810 
    self._oprot.writeMessageBegin('markReturnOrdersAsPickedUp', TMessageType.CALL, self._seqid)
3811 
    args = markReturnOrdersAsPickedUp_args()
3812 
    args.providerId = providerId
3813 
    args.pickupDetails = pickupDetails
3814 
    args.write(self._oprot)
3815 
    self._oprot.writeMessageEnd()
3816 
    self._oprot.trans.flush()
3817 
 
3818 
  def recv_markReturnOrdersAsPickedUp(self, ):
3819 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3820 
    if mtype == TMessageType.EXCEPTION:
3821 
      x = TApplicationException()
3822 
      x.read(self._iprot)
3823 
      self._iprot.readMessageEnd()
3824 
      raise x
3825 
    result = markReturnOrdersAsPickedUp_result()
3826 
    result.read(self._iprot)
3827 
    self._iprot.readMessageEnd()
4910 phani.kuma 3828 
    return
3829 
 
3830 
  def getReturnOrdersNotPickedUp(self, providerId):
3831 
    """
3832 
    Returns a list of orders that were authorized for pickup but did not appear in the pick-up report.
3833 
 
3834 
    Parameters:
3835 
     - providerId
3836 
    """
3837 
    self.send_getReturnOrdersNotPickedUp(providerId)
3838 
    return self.recv_getReturnOrdersNotPickedUp()
3839 
 
3840 
  def send_getReturnOrdersNotPickedUp(self, providerId):
3841 
    self._oprot.writeMessageBegin('getReturnOrdersNotPickedUp', TMessageType.CALL, self._seqid)
3842 
    args = getReturnOrdersNotPickedUp_args()
3843 
    args.providerId = providerId
3844 
    args.write(self._oprot)
3845 
    self._oprot.writeMessageEnd()
3846 
    self._oprot.trans.flush()
3847 
 
3848 
  def recv_getReturnOrdersNotPickedUp(self, ):
3849 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3850 
    if mtype == TMessageType.EXCEPTION:
3851 
      x = TApplicationException()
3852 
      x.read(self._iprot)
3853 
      self._iprot.readMessageEnd()
3854 
      raise x
3855 
    result = getReturnOrdersNotPickedUp_result()
3856 
    result.read(self._iprot)
3857 
    self._iprot.readMessageEnd()
4741 phani.kuma 3858 
    if result.success is not None:
3859 
      return result.success
4910 phani.kuma 3860 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReturnOrdersNotPickedUp failed: unknown result");
4741 phani.kuma 3861 
 
4479 rajveer 3862 
  def receiveReturn(self, orderId, receiveCondition):
2591 chandransh 3863 
    """
4452 rajveer 3864 
    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 3865 
    If the order status is RTO_IN_TRANSIT, marks the order status as RTO_RECEIVED_PRESTINE and returns true.
2591 chandransh 3866 
    If the order is in any other state, it returns false.
3867 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 3868 
 
2591 chandransh 3869 
    Parameters:
3870 
     - orderId
4479 rajveer 3871 
     - receiveCondition
2591 chandransh 3872 
    """
4479 rajveer 3873 
    self.send_receiveReturn(orderId, receiveCondition)
2616 chandransh 3874 
    return self.recv_receiveReturn()
2536 chandransh 3875 
 
4479 rajveer 3876 
  def send_receiveReturn(self, orderId, receiveCondition):
2616 chandransh 3877 
    self._oprot.writeMessageBegin('receiveReturn', TMessageType.CALL, self._seqid)
3878 
    args = receiveReturn_args()
2591 chandransh 3879 
    args.orderId = orderId
4479 rajveer 3880 
    args.receiveCondition = receiveCondition
2591 chandransh 3881 
    args.write(self._oprot)
3882 
    self._oprot.writeMessageEnd()
3883 
    self._oprot.trans.flush()
3884 
 
2616 chandransh 3885 
  def recv_receiveReturn(self, ):
2591 chandransh 3886 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3887 
    if mtype == TMessageType.EXCEPTION:
3888 
      x = TApplicationException()
3889 
      x.read(self._iprot)
3890 
      self._iprot.readMessageEnd()
3891 
      raise x
2616 chandransh 3892 
    result = receiveReturn_result()
2591 chandransh 3893 
    result.read(self._iprot)
3894 
    self._iprot.readMessageEnd()
3431 rajveer 3895 
    if result.success is not None:
2591 chandransh 3896 
      return result.success
3431 rajveer 3897 
    if result.ex is not None:
2591 chandransh 3898 
      raise result.ex
2616 chandransh 3899 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "receiveReturn failed: unknown result");
2591 chandransh 3900 
 
3901 
  def validateDoa(self, orderId, isValid):
3902 
    """
4452 rajveer 3903 
    Used to validate the DOA certificate for an order in the DOA_RECEIVED_PRESTINE state. If the certificate is valid,
2616 chandransh 3904 
    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 3905 
    If the order is in any other state, it returns false.
3906 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 3907 
 
2591 chandransh 3908 
    Parameters:
3909 
     - orderId
3910 
     - isValid
3911 
    """
3912 
    self.send_validateDoa(orderId, isValid)
3913 
    return self.recv_validateDoa()
3914 
 
3915 
  def send_validateDoa(self, orderId, isValid):
3916 
    self._oprot.writeMessageBegin('validateDoa', TMessageType.CALL, self._seqid)
3917 
    args = validateDoa_args()
3918 
    args.orderId = orderId
3919 
    args.isValid = isValid
3920 
    args.write(self._oprot)
3921 
    self._oprot.writeMessageEnd()
3922 
    self._oprot.trans.flush()
3923 
 
3924 
  def recv_validateDoa(self, ):
3925 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3926 
    if mtype == TMessageType.EXCEPTION:
3927 
      x = TApplicationException()
3928 
      x.read(self._iprot)
3929 
      self._iprot.readMessageEnd()
3930 
      raise x
3931 
    result = validateDoa_result()
3932 
    result.read(self._iprot)
3933 
    self._iprot.readMessageEnd()
3431 rajveer 3934 
    if result.success is not None:
2591 chandransh 3935 
      return result.success
3431 rajveer 3936 
    if result.ex is not None:
2591 chandransh 3937 
      raise result.ex
3938 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "validateDoa failed: unknown result");
3939 
 
4495 rajveer 3940 
  def validateReturnProduct(self, orderId, isUsable):
3941 
    """
3942 
    Parameters:
3943 
     - orderId
3944 
     - isUsable
3945 
    """
3946 
    self.send_validateReturnProduct(orderId, isUsable)
3947 
    return self.recv_validateReturnProduct()
3948 
 
3949 
  def send_validateReturnProduct(self, orderId, isUsable):
3950 
    self._oprot.writeMessageBegin('validateReturnProduct', TMessageType.CALL, self._seqid)
3951 
    args = validateReturnProduct_args()
3952 
    args.orderId = orderId
3953 
    args.isUsable = isUsable
3954 
    args.write(self._oprot)
3955 
    self._oprot.writeMessageEnd()
3956 
    self._oprot.trans.flush()
3957 
 
3958 
  def recv_validateReturnProduct(self, ):
3959 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3960 
    if mtype == TMessageType.EXCEPTION:
3961 
      x = TApplicationException()
3962 
      x.read(self._iprot)
3963 
      self._iprot.readMessageEnd()
3964 
      raise x
3965 
    result = validateReturnProduct_result()
3966 
    result.read(self._iprot)
3967 
    self._iprot.readMessageEnd()
3968 
    if result.success is not None:
3969 
      return result.success
3970 
    if result.ex is not None:
3971 
      raise result.ex
3972 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "validateReturnProduct failed: unknown result");
3973 
 
2616 chandransh 3974 
  def reshipOrder(self, orderId):
3975 
    """
4484 rajveer 3976 
    If the order is in RTO_RECEIVED_PRESTINE or DOA_CERT_INVALID state, it does the following:
2616 chandransh 3977 
    	1. Creates a new order for processing in the BILLED state. All billing information is saved.
4484 rajveer 3978 
    	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 3979 
 
3980 
    If the order is in DOA_CERT_VALID state, it does the following:
3981 
    	1. Creates a new order for processing in the SUBMITTED_FOR_PROCESSING state.
3982 
    	2. Creates a return order for the warehouse executive to return the DOA material.
4452 rajveer 3983 
    	3. Marks the current order as the final DOA_VALID_RESHIPPED state.
3431 rajveer 3984 
 
2616 chandransh 3985 
    Returns the id of the newly created order.
3431 rajveer 3986 
 
2616 chandransh 3987 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 3988 
 
2616 chandransh 3989 
    Parameters:
3990 
     - orderId
3991 
    """
3992 
    self.send_reshipOrder(orderId)
3993 
    return self.recv_reshipOrder()
2591 chandransh 3994 
 
2616 chandransh 3995 
  def send_reshipOrder(self, orderId):
3996 
    self._oprot.writeMessageBegin('reshipOrder', TMessageType.CALL, self._seqid)
3997 
    args = reshipOrder_args()
3998 
    args.orderId = orderId
3999 
    args.write(self._oprot)
4000 
    self._oprot.writeMessageEnd()
4001 
    self._oprot.trans.flush()
4002 
 
4003 
  def recv_reshipOrder(self, ):
4004 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4005 
    if mtype == TMessageType.EXCEPTION:
4006 
      x = TApplicationException()
4007 
      x.read(self._iprot)
4008 
      self._iprot.readMessageEnd()
4009 
      raise x
4010 
    result = reshipOrder_result()
4011 
    result.read(self._iprot)
4012 
    self._iprot.readMessageEnd()
3431 rajveer 4013 
    if result.success is not None:
2616 chandransh 4014 
      return result.success
3431 rajveer 4015 
    if result.ex is not None:
2616 chandransh 4016 
      raise result.ex
4017 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "reshipOrder failed: unknown result");
4018 
 
3226 chandransh 4019 
  def refundOrder(self, orderId, refundedBy, reason):
2616 chandransh 4020 
    """
4484 rajveer 4021 
    If the order is in RTO_RECEIVED_PRESTINE, DOA_CERT_VALID or DOA_CERT_INVALID state, it does the following:
2616 chandransh 4022 
    	1. Creates a refund request for batch processing.
4023 
    	2. Creates a return order for the warehouse executive to return the shipped material.
4484 rajveer 4024 
    	3. Marks the current order as RTO_REFUNDED, DOA_VALID_REFUNDED or DOA_INVALID_REFUNDED final states.
3431 rajveer 4025 
 
2616 chandransh 4026 
    If the order is in SUBMITTED_FOR_PROCESSING or INVENTORY_LOW state, it does the following:
4027 
    	1. Creates a refund request for batch processing.
3226 chandransh 4028 
    	2. Cancels the reservation of the item in the warehouse.
4029 
    	3. Marks the current order as the REFUNDED final state.
3431 rajveer 4030 
 
3226 chandransh 4031 
    For all COD orders, if the order is in INIT, SUBMITTED_FOR_PROCESSING or INVENTORY_LOW state, it does the following:
4032 
    	1. Cancels the reservation of the item in the warehouse.
4033 
    	2. Marks the current order as CANCELED.
4034 
 
4035 
    In all cases, it updates the reason for cancellation or refund and the person who performed the action.
4036 
 
2616 chandransh 4037 
    Returns True if it is successful, False otherwise.
3431 rajveer 4038 
 
2616 chandransh 4039 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 4040 
 
2616 chandransh 4041 
    Parameters:
4042 
     - orderId
3226 chandransh 4043 
     - refundedBy
4044 
     - reason
2616 chandransh 4045 
    """
3226 chandransh 4046 
    self.send_refundOrder(orderId, refundedBy, reason)
2616 chandransh 4047 
    return self.recv_refundOrder()
4048 
 
3226 chandransh 4049 
  def send_refundOrder(self, orderId, refundedBy, reason):
2616 chandransh 4050 
    self._oprot.writeMessageBegin('refundOrder', TMessageType.CALL, self._seqid)
4051 
    args = refundOrder_args()
4052 
    args.orderId = orderId
3226 chandransh 4053 
    args.refundedBy = refundedBy
4054 
    args.reason = reason
2616 chandransh 4055 
    args.write(self._oprot)
4056 
    self._oprot.writeMessageEnd()
4057 
    self._oprot.trans.flush()
4058 
 
4059 
  def recv_refundOrder(self, ):
4060 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4061 
    if mtype == TMessageType.EXCEPTION:
4062 
      x = TApplicationException()
4063 
      x.read(self._iprot)
4064 
      self._iprot.readMessageEnd()
4065 
      raise x
4066 
    result = refundOrder_result()
4067 
    result.read(self._iprot)
4068 
    self._iprot.readMessageEnd()
3431 rajveer 4069 
    if result.success is not None:
2616 chandransh 4070 
      return result.success
3431 rajveer 4071 
    if result.ex is not None:
2616 chandransh 4072 
      raise result.ex
4073 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "refundOrder failed: unknown result");
4074 
 
2690 chandransh 4075 
  def getReturnOrders(self, warehouseId, fromDate, toDate):
4076 
    """
4077 
    Get all return orders created between the from and to dates for the given warehouse.
4078 
    Ignores the warehouse if it is passed as -1.
3431 rajveer 4079 
 
2690 chandransh 4080 
    Parameters:
4081 
     - warehouseId
4082 
     - fromDate
4083 
     - toDate
4084 
    """
4085 
    self.send_getReturnOrders(warehouseId, fromDate, toDate)
4086 
    return self.recv_getReturnOrders()
2616 chandransh 4087 
 
2690 chandransh 4088 
  def send_getReturnOrders(self, warehouseId, fromDate, toDate):
4089 
    self._oprot.writeMessageBegin('getReturnOrders', TMessageType.CALL, self._seqid)
4090 
    args = getReturnOrders_args()
4091 
    args.warehouseId = warehouseId
4092 
    args.fromDate = fromDate
4093 
    args.toDate = toDate
4094 
    args.write(self._oprot)
4095 
    self._oprot.writeMessageEnd()
4096 
    self._oprot.trans.flush()
4097 
 
4098 
  def recv_getReturnOrders(self, ):
4099 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4100 
    if mtype == TMessageType.EXCEPTION:
4101 
      x = TApplicationException()
4102 
      x.read(self._iprot)
4103 
      self._iprot.readMessageEnd()
4104 
      raise x
4105 
    result = getReturnOrders_result()
4106 
    result.read(self._iprot)
4107 
    self._iprot.readMessageEnd()
3431 rajveer 4108 
    if result.success is not None:
2690 chandransh 4109 
      return result.success
4110 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReturnOrders failed: unknown result");
4111 
 
5481 phani.kuma 4112 
  def getAllReturnOrders(self, onlyNotProcessed, fromDate, toDate):
4113 
    """
4114 
    Get all return orders created between the from and to dates.
4115 
 
4116 
    Parameters:
4117 
     - onlyNotProcessed
4118 
     - fromDate
4119 
     - toDate
4120 
    """
4121 
    self.send_getAllReturnOrders(onlyNotProcessed, fromDate, toDate)
4122 
    return self.recv_getAllReturnOrders()
4123 
 
4124 
  def send_getAllReturnOrders(self, onlyNotProcessed, fromDate, toDate):
4125 
    self._oprot.writeMessageBegin('getAllReturnOrders', TMessageType.CALL, self._seqid)
4126 
    args = getAllReturnOrders_args()
4127 
    args.onlyNotProcessed = onlyNotProcessed
4128 
    args.fromDate = fromDate
4129 
    args.toDate = toDate
4130 
    args.write(self._oprot)
4131 
    self._oprot.writeMessageEnd()
4132 
    self._oprot.trans.flush()
4133 
 
4134 
  def recv_getAllReturnOrders(self, ):
4135 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4136 
    if mtype == TMessageType.EXCEPTION:
4137 
      x = TApplicationException()
4138 
      x.read(self._iprot)
4139 
      self._iprot.readMessageEnd()
4140 
      raise x
4141 
    result = getAllReturnOrders_result()
4142 
    result.read(self._iprot)
4143 
    self._iprot.readMessageEnd()
4144 
    if result.success is not None:
4145 
      return result.success
4146 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllReturnOrders failed: unknown result");
4147 
 
2700 chandransh 4148 
  def getReturnOrder(self, id):
4149 
    """
4150 
    Returns the ReturnOrder corresponding to the given id.
4151 
    Throws an exception if the return order with the given id couldn't be found.
3431 rajveer 4152 
 
2700 chandransh 4153 
    Parameters:
4154 
     - id
4155 
    """
4156 
    self.send_getReturnOrder(id)
4157 
    return self.recv_getReturnOrder()
4158 
 
4159 
  def send_getReturnOrder(self, id):
4160 
    self._oprot.writeMessageBegin('getReturnOrder', TMessageType.CALL, self._seqid)
4161 
    args = getReturnOrder_args()
4162 
    args.id = id
4163 
    args.write(self._oprot)
4164 
    self._oprot.writeMessageEnd()
4165 
    self._oprot.trans.flush()
4166 
 
4167 
  def recv_getReturnOrder(self, ):
4168 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4169 
    if mtype == TMessageType.EXCEPTION:
4170 
      x = TApplicationException()
4171 
      x.read(self._iprot)
4172 
      self._iprot.readMessageEnd()
4173 
      raise x
4174 
    result = getReturnOrder_result()
4175 
    result.read(self._iprot)
4176 
    self._iprot.readMessageEnd()
3431 rajveer 4177 
    if result.success is not None:
2700 chandransh 4178 
      return result.success
3431 rajveer 4179 
    if result.ex is not None:
2700 chandransh 4180 
      raise result.ex
4181 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReturnOrder failed: unknown result");
4182 
 
2690 chandransh 4183 
  def processReturn(self, returnOrderId):
4184 
    """
4185 
    Marks the return order with the given id as processed. Raises an exception if no such return order exists.
3431 rajveer 4186 
 
2690 chandransh 4187 
    Parameters:
4188 
     - returnOrderId
4189 
    """
4190 
    self.send_processReturn(returnOrderId)
4191 
    self.recv_processReturn()
4192 
 
4193 
  def send_processReturn(self, returnOrderId):
4194 
    self._oprot.writeMessageBegin('processReturn', TMessageType.CALL, self._seqid)
4195 
    args = processReturn_args()
4196 
    args.returnOrderId = returnOrderId
4197 
    args.write(self._oprot)
4198 
    self._oprot.writeMessageEnd()
4199 
    self._oprot.trans.flush()
4200 
 
4201 
  def recv_processReturn(self, ):
4202 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4203 
    if mtype == TMessageType.EXCEPTION:
4204 
      x = TApplicationException()
4205 
      x.read(self._iprot)
4206 
      self._iprot.readMessageEnd()
4207 
      raise x
4208 
    result = processReturn_result()
4209 
    result.read(self._iprot)
4210 
    self._iprot.readMessageEnd()
3431 rajveer 4211 
    if result.ex is not None:
2690 chandransh 4212 
      raise result.ex
4213 
    return
4214 
 
3451 chandransh 4215 
  def updateWeight(self, orderId, weight):
4216 
    """
4217 
    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 4218 
 
3451 chandransh 4219 
    Parameters:
4220 
     - orderId
4221 
     - weight
4222 
    """
4223 
    self.send_updateWeight(orderId, weight)
4224 
    return self.recv_updateWeight()
4225 
 
4226 
  def send_updateWeight(self, orderId, weight):
4227 
    self._oprot.writeMessageBegin('updateWeight', TMessageType.CALL, self._seqid)
4228 
    args = updateWeight_args()
4229 
    args.orderId = orderId
4230 
    args.weight = weight
4231 
    args.write(self._oprot)
4232 
    self._oprot.writeMessageEnd()
4233 
    self._oprot.trans.flush()
4234 
 
4235 
  def recv_updateWeight(self, ):
4236 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4237 
    if mtype == TMessageType.EXCEPTION:
4238 
      x = TApplicationException()
4239 
      x.read(self._iprot)
4240 
      self._iprot.readMessageEnd()
4241 
      raise x
4242 
    result = updateWeight_result()
4243 
    result.read(self._iprot)
4244 
    self._iprot.readMessageEnd()
4245 
    if result.success is not None:
4246 
      return result.success
4247 
    if result.ex is not None:
4248 
      raise result.ex
4249 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updateWeight failed: unknown result");
4250 
 
3469 chandransh 4251 
  def changeItem(self, orderId, itemId):
4252 
    """
4253 
    Change the item to be shipped for this order. Also adjusts the reservation in the inventory accordingly.
4254 
    Currently, it also ensures that only a different color of the given item is shipped.
3451 chandransh 4255 
 
3469 chandransh 4256 
    Parameters:
4257 
     - orderId
4258 
     - itemId
4259 
    """
4260 
    self.send_changeItem(orderId, itemId)
4261 
    return self.recv_changeItem()
4262 
 
4263 
  def send_changeItem(self, orderId, itemId):
4264 
    self._oprot.writeMessageBegin('changeItem', TMessageType.CALL, self._seqid)
4265 
    args = changeItem_args()
4266 
    args.orderId = orderId
4267 
    args.itemId = itemId
4268 
    args.write(self._oprot)
4269 
    self._oprot.writeMessageEnd()
4270 
    self._oprot.trans.flush()
4271 
 
4272 
  def recv_changeItem(self, ):
4273 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4274 
    if mtype == TMessageType.EXCEPTION:
4275 
      x = TApplicationException()
4276 
      x.read(self._iprot)
4277 
      self._iprot.readMessageEnd()
4278 
      raise x
4279 
    result = changeItem_result()
4280 
    result.read(self._iprot)
4281 
    self._iprot.readMessageEnd()
4282 
    if result.success is not None:
4283 
      return result.success
4284 
    if result.ex is not None:
4285 
      raise result.ex
4286 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "changeItem failed: unknown result");
4287 
 
4288 
  def shiftToWarehouse(self, orderId, warehouseId):
4289 
    """
4290 
    Moves the given order to the given warehouse. Also adjusts the inventory reservations accordingly.
4291 
 
4292 
    Parameters:
4293 
     - orderId
4294 
     - warehouseId
4295 
    """
4296 
    self.send_shiftToWarehouse(orderId, warehouseId)
4297 
    return self.recv_shiftToWarehouse()
4298 
 
4299 
  def send_shiftToWarehouse(self, orderId, warehouseId):
4300 
    self._oprot.writeMessageBegin('shiftToWarehouse', TMessageType.CALL, self._seqid)
4301 
    args = shiftToWarehouse_args()
4302 
    args.orderId = orderId
4303 
    args.warehouseId = warehouseId
4304 
    args.write(self._oprot)
4305 
    self._oprot.writeMessageEnd()
4306 
    self._oprot.trans.flush()
4307 
 
4308 
  def recv_shiftToWarehouse(self, ):
4309 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4310 
    if mtype == TMessageType.EXCEPTION:
4311 
      x = TApplicationException()
4312 
      x.read(self._iprot)
4313 
      self._iprot.readMessageEnd()
4314 
      raise x
4315 
    result = shiftToWarehouse_result()
4316 
    result.read(self._iprot)
4317 
    self._iprot.readMessageEnd()
4318 
    if result.success is not None:
4319 
      return result.success
4320 
    if result.ex is not None:
4321 
      raise result.ex
4322 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "shiftToWarehouse failed: unknown result");
4323 
 
4647 rajveer 4324 
  def addDelayReason(self, orderId, delayReason, furtherDelay, delayReasonText):
3553 chandransh 4325 
    """
4326 
    Adds the given delay reason to the given order.
3986 chandransh 4327 
    Increases the expected delivery time of the given order by the given no. of days.
3553 chandransh 4328 
    Raises an exception if no order with the given id can be found.
3469 chandransh 4329 
 
3553 chandransh 4330 
    Parameters:
4331 
     - orderId
4332 
     - delayReason
3986 chandransh 4333 
     - furtherDelay
4647 rajveer 4334 
     - delayReasonText
3553 chandransh 4335 
    """
4647 rajveer 4336 
    self.send_addDelayReason(orderId, delayReason, furtherDelay, delayReasonText)
3553 chandransh 4337 
    return self.recv_addDelayReason()
4338 
 
4647 rajveer 4339 
  def send_addDelayReason(self, orderId, delayReason, furtherDelay, delayReasonText):
3553 chandransh 4340 
    self._oprot.writeMessageBegin('addDelayReason', TMessageType.CALL, self._seqid)
4341 
    args = addDelayReason_args()
4342 
    args.orderId = orderId
4343 
    args.delayReason = delayReason
3986 chandransh 4344 
    args.furtherDelay = furtherDelay
4647 rajveer 4345 
    args.delayReasonText = delayReasonText
3553 chandransh 4346 
    args.write(self._oprot)
4347 
    self._oprot.writeMessageEnd()
4348 
    self._oprot.trans.flush()
4349 
 
4350 
  def recv_addDelayReason(self, ):
4351 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4352 
    if mtype == TMessageType.EXCEPTION:
4353 
      x = TApplicationException()
4354 
      x.read(self._iprot)
4355 
      self._iprot.readMessageEnd()
4356 
      raise x
4357 
    result = addDelayReason_result()
4358 
    result.read(self._iprot)
4359 
    self._iprot.readMessageEnd()
4360 
    if result.success is not None:
4361 
      return result.success
4362 
    if result.ex is not None:
4363 
      raise result.ex
4364 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addDelayReason failed: unknown result");
4365 
 
3956 chandransh 4366 
  def reconcileCodCollection(self, collectedAmountMap, xferBy, xferTxnId, xferDate):
4367 
    """
4368 
    Marks the COD orders with given AWB nos. as having been processed.
4369 
    Updates the captured amount for the corresponding payment.
3553 chandransh 4370 
 
3956 chandransh 4371 
    Returns a map of AWBs which were not processed and the associated reason. An AWB is not processed if:
4372 
    1. There is no order corresponding to an AWB number.
4373 
    2. The captured amount for a payment exceeds the total payment.
4374 
    3. The order corresponding to an AWB no. is in a state prior to DELIVERY_SUCCESS.
4375 
 
4376 
    Parameters:
4377 
     - collectedAmountMap
4378 
     - xferBy
4379 
     - xferTxnId
4380 
     - xferDate
4381 
    """
4382 
    self.send_reconcileCodCollection(collectedAmountMap, xferBy, xferTxnId, xferDate)
4383 
    return self.recv_reconcileCodCollection()
4384 
 
4385 
  def send_reconcileCodCollection(self, collectedAmountMap, xferBy, xferTxnId, xferDate):
4386 
    self._oprot.writeMessageBegin('reconcileCodCollection', TMessageType.CALL, self._seqid)
4387 
    args = reconcileCodCollection_args()
4388 
    args.collectedAmountMap = collectedAmountMap
4389 
    args.xferBy = xferBy
4390 
    args.xferTxnId = xferTxnId
4391 
    args.xferDate = xferDate
4392 
    args.write(self._oprot)
4393 
    self._oprot.writeMessageEnd()
4394 
    self._oprot.trans.flush()
4395 
 
4396 
  def recv_reconcileCodCollection(self, ):
4397 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4398 
    if mtype == TMessageType.EXCEPTION:
4399 
      x = TApplicationException()
4400 
      x.read(self._iprot)
4401 
      self._iprot.readMessageEnd()
4402 
      raise x
4403 
    result = reconcileCodCollection_result()
4404 
    result.read(self._iprot)
4405 
    self._iprot.readMessageEnd()
4406 
    if result.success is not None:
4407 
      return result.success
4408 
    if result.ex is not None:
4409 
      raise result.ex
4410 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "reconcileCodCollection failed: unknown result");
4411 
 
4008 mandeep.dh 4412 
  def getTransactionsRequiringExtraProcessing(self, category):
4413 
    """
4065 mandeep.dh 4414 
    Returns the list of transaction ids that require some extra processing and
4008 mandeep.dh 4415 
    which belong to a particular category. This is currently used by CRM
4065 mandeep.dh 4416 
    application. If no such transaction ids are present, it returns an empty list.
3956 chandransh 4417 
 
4008 mandeep.dh 4418 
    Parameters:
4419 
     - category
4420 
    """
4421 
    self.send_getTransactionsRequiringExtraProcessing(category)
4422 
    return self.recv_getTransactionsRequiringExtraProcessing()
4423 
 
4424 
  def send_getTransactionsRequiringExtraProcessing(self, category):
4425 
    self._oprot.writeMessageBegin('getTransactionsRequiringExtraProcessing', TMessageType.CALL, self._seqid)
4426 
    args = getTransactionsRequiringExtraProcessing_args()
4427 
    args.category = category
4428 
    args.write(self._oprot)
4429 
    self._oprot.writeMessageEnd()
4430 
    self._oprot.trans.flush()
4431 
 
4432 
  def recv_getTransactionsRequiringExtraProcessing(self, ):
4433 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4434 
    if mtype == TMessageType.EXCEPTION:
4435 
      x = TApplicationException()
4436 
      x.read(self._iprot)
4437 
      self._iprot.readMessageEnd()
4438 
      raise x
4439 
    result = getTransactionsRequiringExtraProcessing_result()
4440 
    result.read(self._iprot)
4441 
    self._iprot.readMessageEnd()
4442 
    if result.success is not None:
4443 
      return result.success
4444 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransactionsRequiringExtraProcessing failed: unknown result");
4445 
 
4446 
  def markTransactionAsProcessed(self, transactionId, category):
4447 
    """
4448 
    Marks a particular transaction as processed for a particular cateogory.
4065 mandeep.dh 4449 
    It essentially deletes the transaction id record for a particular
4450 
    processing type category (if present) from DB.
4451 
    This is currently used by CRM application.
4008 mandeep.dh 4452 
 
4453 
    Parameters:
4454 
     - transactionId
4455 
     - category
4456 
    """
4457 
    self.send_markTransactionAsProcessed(transactionId, category)
4458 
    self.recv_markTransactionAsProcessed()
4459 
 
4460 
  def send_markTransactionAsProcessed(self, transactionId, category):
4461 
    self._oprot.writeMessageBegin('markTransactionAsProcessed', TMessageType.CALL, self._seqid)
4462 
    args = markTransactionAsProcessed_args()
4463 
    args.transactionId = transactionId
4464 
    args.category = category
4465 
    args.write(self._oprot)
4466 
    self._oprot.writeMessageEnd()
4467 
    self._oprot.trans.flush()
4468 
 
4469 
  def recv_markTransactionAsProcessed(self, ):
4470 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4471 
    if mtype == TMessageType.EXCEPTION:
4472 
      x = TApplicationException()
4473 
      x.read(self._iprot)
4474 
      self._iprot.readMessageEnd()
4475 
      raise x
4476 
    result = markTransactionAsProcessed_result()
4477 
    result.read(self._iprot)
4478 
    self._iprot.readMessageEnd()
4479 
    return
4480 
 
4018 chandransh 4481 
  def getItemWiseRiskyOrdersCount(self, ):
4482 
    """
4483 
    Returns a map containing the number of risky orders keyed by item id. A risky order
4484 
    is defined as one whose shipping date is about to expire.
4485 
    """
4486 
    self.send_getItemWiseRiskyOrdersCount()
4487 
    return self.recv_getItemWiseRiskyOrdersCount()
4008 mandeep.dh 4488 
 
4018 chandransh 4489 
  def send_getItemWiseRiskyOrdersCount(self, ):
4490 
    self._oprot.writeMessageBegin('getItemWiseRiskyOrdersCount', TMessageType.CALL, self._seqid)
4491 
    args = getItemWiseRiskyOrdersCount_args()
4492 
    args.write(self._oprot)
4493 
    self._oprot.writeMessageEnd()
4494 
    self._oprot.trans.flush()
4495 
 
4496 
  def recv_getItemWiseRiskyOrdersCount(self, ):
4497 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4498 
    if mtype == TMessageType.EXCEPTION:
4499 
      x = TApplicationException()
4500 
      x.read(self._iprot)
4501 
      self._iprot.readMessageEnd()
4502 
      raise x
4503 
    result = getItemWiseRiskyOrdersCount_result()
4504 
    result.read(self._iprot)
4505 
    self._iprot.readMessageEnd()
4506 
    if result.success is not None:
4507 
      return result.success
4508 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItemWiseRiskyOrdersCount failed: unknown result");
4509 
 
4295 varun.gupt 4510 
  def getOrdersForItemIds(self, itemIds):
4511 
    """
4512 
    Returns a list of all orders which have items with given id
4513 
 
4514 
    Parameters:
4515 
     - itemIds
4516 
    """
4517 
    self.send_getOrdersForItemIds(itemIds)
4518 
    return self.recv_getOrdersForItemIds()
4519 
 
4520 
  def send_getOrdersForItemIds(self, itemIds):
4521 
    self._oprot.writeMessageBegin('getOrdersForItemIds', TMessageType.CALL, self._seqid)
4522 
    args = getOrdersForItemIds_args()
4523 
    args.itemIds = itemIds
4524 
    args.write(self._oprot)
4525 
    self._oprot.writeMessageEnd()
4526 
    self._oprot.trans.flush()
4527 
 
4528 
  def recv_getOrdersForItemIds(self, ):
4529 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4530 
    if mtype == TMessageType.EXCEPTION:
4531 
      x = TApplicationException()
4532 
      x.read(self._iprot)
4533 
      self._iprot.readMessageEnd()
4534 
      raise x
4535 
    result = getOrdersForItemIds_result()
4536 
    result.read(self._iprot)
4537 
    self._iprot.readMessageEnd()
4538 
    if result.success is not None:
4539 
      return result.success
4540 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersForItemIds failed: unknown result");
4541 
 
4247 rajveer 4542 
  def markOrderCancellationRequestReceived(self, orderId):
4543 
    """
4544 
    Mark order as cancellation request received. If customer sends request of cancellation of
4545 
    a particular order, this method will be called. It will just change status of the order
4546 
    depending on its current status. It also records the previous status, so that we can move
4547 
    back to that status if cancellation request is denied.
4018 chandransh 4548 
 
4247 rajveer 4549 
    Parameters:
4550 
     - orderId
4551 
    """
4552 
    self.send_markOrderCancellationRequestReceived(orderId)
4553 
    self.recv_markOrderCancellationRequestReceived()
4554 
 
4555 
  def send_markOrderCancellationRequestReceived(self, orderId):
4556 
    self._oprot.writeMessageBegin('markOrderCancellationRequestReceived', TMessageType.CALL, self._seqid)
4557 
    args = markOrderCancellationRequestReceived_args()
4558 
    args.orderId = orderId
4559 
    args.write(self._oprot)
4560 
    self._oprot.writeMessageEnd()
4561 
    self._oprot.trans.flush()
4562 
 
4563 
  def recv_markOrderCancellationRequestReceived(self, ):
4564 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4565 
    if mtype == TMessageType.EXCEPTION:
4566 
      x = TApplicationException()
4567 
      x.read(self._iprot)
4568 
      self._iprot.readMessageEnd()
4569 
      raise x
4570 
    result = markOrderCancellationRequestReceived_result()
4571 
    result.read(self._iprot)
4572 
    self._iprot.readMessageEnd()
4573 
    if result.ex is not None:
4574 
      raise result.ex
4575 
    return
4576 
 
4577 
  def markOrderCancellationRequestConfirmed(self, orderId):
4578 
    """
4579 
    If we decide to to cancel order, CRM will call this method to move the status of order to
4580 
    cancellation request confirmed. After this OM will be able to cancel the order.
4581 
 
4582 
    Parameters:
4583 
     - orderId
4584 
    """
4585 
    self.send_markOrderCancellationRequestConfirmed(orderId)
4586 
    self.recv_markOrderCancellationRequestConfirmed()
4587 
 
4588 
  def send_markOrderCancellationRequestConfirmed(self, orderId):
4589 
    self._oprot.writeMessageBegin('markOrderCancellationRequestConfirmed', TMessageType.CALL, self._seqid)
4590 
    args = markOrderCancellationRequestConfirmed_args()
4591 
    args.orderId = orderId
4592 
    args.write(self._oprot)
4593 
    self._oprot.writeMessageEnd()
4594 
    self._oprot.trans.flush()
4595 
 
4596 
  def recv_markOrderCancellationRequestConfirmed(self, ):
4597 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4598 
    if mtype == TMessageType.EXCEPTION:
4599 
      x = TApplicationException()
4600 
      x.read(self._iprot)
4601 
      self._iprot.readMessageEnd()
4602 
      raise x
4603 
    result = markOrderCancellationRequestConfirmed_result()
4604 
    result.read(self._iprot)
4605 
    self._iprot.readMessageEnd()
4606 
    if result.ex is not None:
4607 
      raise result.ex
4608 
    return
4609 
 
4610 
  def markOrderCancellationRequestDenied(self, orderId):
4611 
    """
4612 
    If we decide to not to cancel order, we will move the order ro previous status.
4613 
 
4614 
    Parameters:
4615 
     - orderId
4616 
    """
4617 
    self.send_markOrderCancellationRequestDenied(orderId)
4618 
    self.recv_markOrderCancellationRequestDenied()
4619 
 
4620 
  def send_markOrderCancellationRequestDenied(self, orderId):
4621 
    self._oprot.writeMessageBegin('markOrderCancellationRequestDenied', TMessageType.CALL, self._seqid)
4622 
    args = markOrderCancellationRequestDenied_args()
4623 
    args.orderId = orderId
4624 
    args.write(self._oprot)
4625 
    self._oprot.writeMessageEnd()
4626 
    self._oprot.trans.flush()
4627 
 
4628 
  def recv_markOrderCancellationRequestDenied(self, ):
4629 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4630 
    if mtype == TMessageType.EXCEPTION:
4631 
      x = TApplicationException()
4632 
      x.read(self._iprot)
4633 
      self._iprot.readMessageEnd()
4634 
      raise x
4635 
    result = markOrderCancellationRequestDenied_result()
4636 
    result.read(self._iprot)
4637 
    self._iprot.readMessageEnd()
4638 
    if result.ex is not None:
4639 
      raise result.ex
4640 
    return
4641 
 
4258 rajveer 4642 
  def markTransactionAsPaymentFlagRemoved(self, transactionId):
4247 rajveer 4643 
    """
4258 rajveer 4644 
    If we and/or payment gateway has decided to accept the payment, this method needs to be called.
4645 
    Changed transaction and all orders status to payment accepted.
4247 rajveer 4646 
 
4647 
    Parameters:
4258 rajveer 4648 
     - transactionId
4247 rajveer 4649 
    """
4258 rajveer 4650 
    self.send_markTransactionAsPaymentFlagRemoved(transactionId)
4651 
    self.recv_markTransactionAsPaymentFlagRemoved()
4247 rajveer 4652 
 
4258 rajveer 4653 
  def send_markTransactionAsPaymentFlagRemoved(self, transactionId):
4654 
    self._oprot.writeMessageBegin('markTransactionAsPaymentFlagRemoved', TMessageType.CALL, self._seqid)
4655 
    args = markTransactionAsPaymentFlagRemoved_args()
4656 
    args.transactionId = transactionId
4247 rajveer 4657 
    args.write(self._oprot)
4658 
    self._oprot.writeMessageEnd()
4659 
    self._oprot.trans.flush()
4660 
 
4258 rajveer 4661 
  def recv_markTransactionAsPaymentFlagRemoved(self, ):
4247 rajveer 4662 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4663 
    if mtype == TMessageType.EXCEPTION:
4664 
      x = TApplicationException()
4665 
      x.read(self._iprot)
4666 
      self._iprot.readMessageEnd()
4667 
      raise x
4258 rajveer 4668 
    result = markTransactionAsPaymentFlagRemoved_result()
4247 rajveer 4669 
    result.read(self._iprot)
4670 
    self._iprot.readMessageEnd()
4671 
    if result.ex is not None:
4672 
      raise result.ex
4673 
    return
4674 
 
4259 anupam.sin 4675 
  def refundTransaction(self, transactionId, refundedBy, reason):
4676 
    """
4677 
    This method is called when a flagged payment is deemed unserviceable and the corresponding orders
4678 
    need to be cancelled
4247 rajveer 4679 
 
4259 anupam.sin 4680 
    Parameters:
4681 
     - transactionId
4682 
     - refundedBy
4683 
     - reason
4684 
    """
4685 
    self.send_refundTransaction(transactionId, refundedBy, reason)
4686 
    self.recv_refundTransaction()
4687 
 
4688 
  def send_refundTransaction(self, transactionId, refundedBy, reason):
4689 
    self._oprot.writeMessageBegin('refundTransaction', TMessageType.CALL, self._seqid)
4690 
    args = refundTransaction_args()
4691 
    args.transactionId = transactionId
4692 
    args.refundedBy = refundedBy
4693 
    args.reason = reason
4694 
    args.write(self._oprot)
4695 
    self._oprot.writeMessageEnd()
4696 
    self._oprot.trans.flush()
4697 
 
4698 
  def recv_refundTransaction(self, ):
4699 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4700 
    if mtype == TMessageType.EXCEPTION:
4701 
      x = TApplicationException()
4702 
      x.read(self._iprot)
4703 
      self._iprot.readMessageEnd()
4704 
      raise x
4705 
    result = refundTransaction_result()
4706 
    result.read(self._iprot)
4707 
    self._iprot.readMessageEnd()
4708 
    if result.ex is not None:
4709 
      raise result.ex
4710 
    return
4711 
 
4324 mandeep.dh 4712 
  def updateShipmentAddress(self, orderId, addressId):
4713 
    """
4714 
    Updates shipment address of an order. Delivery and shipping date estimates
4715 
    etc. are also updated here.
4716 
 
4717 
    Throws TransactionServiceException in case address change is not
4718 
    possible due to certain reasons such as new pincode in address is
4719 
    not serviceable etc.
4720 
 
4721 
    Parameters:
4722 
     - orderId
4723 
     - addressId
4724 
    """
4725 
    self.send_updateShipmentAddress(orderId, addressId)
4726 
    self.recv_updateShipmentAddress()
4727 
 
4728 
  def send_updateShipmentAddress(self, orderId, addressId):
4729 
    self._oprot.writeMessageBegin('updateShipmentAddress', TMessageType.CALL, self._seqid)
4730 
    args = updateShipmentAddress_args()
4731 
    args.orderId = orderId
4732 
    args.addressId = addressId
4733 
    args.write(self._oprot)
4734 
    self._oprot.writeMessageEnd()
4735 
    self._oprot.trans.flush()
4736 
 
4737 
  def recv_updateShipmentAddress(self, ):
4738 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4739 
    if mtype == TMessageType.EXCEPTION:
4740 
      x = TApplicationException()
4741 
      x.read(self._iprot)
4742 
      self._iprot.readMessageEnd()
4743 
      raise x
4744 
    result = updateShipmentAddress_result()
4745 
    result.read(self._iprot)
4746 
    self._iprot.readMessageEnd()
4747 
    if result.ex is not None:
4748 
      raise result.ex
4749 
    return
4750 
 
4285 rajveer 4751 
  def acceptOrdersForItemId(self, itemId, inventory):
4752 
    """
4753 
    Marks the orders as ACCEPTED for the given itemId and inventory. It also updates the accepted timestamp. If the
4754 
    given order is not a COD order, it also captures the payment if the same has not been captured.
4259 anupam.sin 4755 
 
4285 rajveer 4756 
    Parameters:
4757 
     - itemId
4758 
     - inventory
4759 
    """
4760 
    self.send_acceptOrdersForItemId(itemId, inventory)
4761 
    return self.recv_acceptOrdersForItemId()
4762 
 
4763 
  def send_acceptOrdersForItemId(self, itemId, inventory):
4764 
    self._oprot.writeMessageBegin('acceptOrdersForItemId', TMessageType.CALL, self._seqid)
4765 
    args = acceptOrdersForItemId_args()
4766 
    args.itemId = itemId
4767 
    args.inventory = inventory
4768 
    args.write(self._oprot)
4769 
    self._oprot.writeMessageEnd()
4770 
    self._oprot.trans.flush()
4771 
 
4772 
  def recv_acceptOrdersForItemId(self, ):
4773 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4774 
    if mtype == TMessageType.EXCEPTION:
4775 
      x = TApplicationException()
4776 
      x.read(self._iprot)
4777 
      self._iprot.readMessageEnd()
4778 
      raise x
4779 
    result = acceptOrdersForItemId_result()
4780 
    result.read(self._iprot)
4781 
    self._iprot.readMessageEnd()
4782 
    if result.success is not None:
4783 
      return result.success
4784 
    if result.ex is not None:
4785 
      raise result.ex
4786 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "acceptOrdersForItemId failed: unknown result");
4787 
 
4369 rajveer 4788 
  def markOrdersAsPORaised(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 4789 
    """
4790 
    Parameters:
4791 
     - vendorId
4792 
     - itemId
4793 
     - quantity
4794 
     - estimate
4369 rajveer 4795 
     - isReminder
4303 rajveer 4796 
    """
4369 rajveer 4797 
    self.send_markOrdersAsPORaised(vendorId, itemId, quantity, estimate, isReminder)
4303 rajveer 4798 
    self.recv_markOrdersAsPORaised()
4285 rajveer 4799 
 
4369 rajveer 4800 
  def send_markOrdersAsPORaised(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 4801 
    self._oprot.writeMessageBegin('markOrdersAsPORaised', TMessageType.CALL, self._seqid)
4802 
    args = markOrdersAsPORaised_args()
4803 
    args.vendorId = vendorId
4804 
    args.itemId = itemId
4805 
    args.quantity = quantity
4806 
    args.estimate = estimate
4369 rajveer 4807 
    args.isReminder = isReminder
4303 rajveer 4808 
    args.write(self._oprot)
4809 
    self._oprot.writeMessageEnd()
4810 
    self._oprot.trans.flush()
4811 
 
4812 
  def recv_markOrdersAsPORaised(self, ):
4813 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4814 
    if mtype == TMessageType.EXCEPTION:
4815 
      x = TApplicationException()
4816 
      x.read(self._iprot)
4817 
      self._iprot.readMessageEnd()
4818 
      raise x
4819 
    result = markOrdersAsPORaised_result()
4820 
    result.read(self._iprot)
4821 
    self._iprot.readMessageEnd()
4822 
    if result.ex is not None:
4823 
      raise result.ex
4824 
    return
4825 
 
4369 rajveer 4826 
  def markOrdersAsReversalInitiated(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 4827 
    """
4828 
    Parameters:
4829 
     - vendorId
4830 
     - itemId
4831 
     - quantity
4832 
     - estimate
4369 rajveer 4833 
     - isReminder
4303 rajveer 4834 
    """
4369 rajveer 4835 
    self.send_markOrdersAsReversalInitiated(vendorId, itemId, quantity, estimate, isReminder)
4303 rajveer 4836 
    self.recv_markOrdersAsReversalInitiated()
4837 
 
4369 rajveer 4838 
  def send_markOrdersAsReversalInitiated(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 4839 
    self._oprot.writeMessageBegin('markOrdersAsReversalInitiated', TMessageType.CALL, self._seqid)
4840 
    args = markOrdersAsReversalInitiated_args()
4841 
    args.vendorId = vendorId
4842 
    args.itemId = itemId
4843 
    args.quantity = quantity
4844 
    args.estimate = estimate
4369 rajveer 4845 
    args.isReminder = isReminder
4303 rajveer 4846 
    args.write(self._oprot)
4847 
    self._oprot.writeMessageEnd()
4848 
    self._oprot.trans.flush()
4849 
 
4850 
  def recv_markOrdersAsReversalInitiated(self, ):
4851 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4852 
    if mtype == TMessageType.EXCEPTION:
4853 
      x = TApplicationException()
4854 
      x.read(self._iprot)
4855 
      self._iprot.readMessageEnd()
4856 
      raise x
4857 
    result = markOrdersAsReversalInitiated_result()
4858 
    result.read(self._iprot)
4859 
    self._iprot.readMessageEnd()
4860 
    if result.ex is not None:
4861 
      raise result.ex
4862 
    return
4863 
 
4369 rajveer 4864 
  def markOrdersAsNotAvailabke(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 4865 
    """
4866 
    Parameters:
4867 
     - vendorId
4868 
     - itemId
4869 
     - quantity
4870 
     - estimate
4369 rajveer 4871 
     - isReminder
4303 rajveer 4872 
    """
4369 rajveer 4873 
    self.send_markOrdersAsNotAvailabke(vendorId, itemId, quantity, estimate, isReminder)
4303 rajveer 4874 
    self.recv_markOrdersAsNotAvailabke()
4875 
 
4369 rajveer 4876 
  def send_markOrdersAsNotAvailabke(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 4877 
    self._oprot.writeMessageBegin('markOrdersAsNotAvailabke', TMessageType.CALL, self._seqid)
4878 
    args = markOrdersAsNotAvailabke_args()
4879 
    args.vendorId = vendorId
4880 
    args.itemId = itemId
4881 
    args.quantity = quantity
4882 
    args.estimate = estimate
4369 rajveer 4883 
    args.isReminder = isReminder
4303 rajveer 4884 
    args.write(self._oprot)
4885 
    self._oprot.writeMessageEnd()
4886 
    self._oprot.trans.flush()
4887 
 
4888 
  def recv_markOrdersAsNotAvailabke(self, ):
4889 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4890 
    if mtype == TMessageType.EXCEPTION:
4891 
      x = TApplicationException()
4892 
      x.read(self._iprot)
4893 
      self._iprot.readMessageEnd()
4894 
      raise x
4895 
    result = markOrdersAsNotAvailabke_result()
4896 
    result.read(self._iprot)
4897 
    self._iprot.readMessageEnd()
4898 
    if result.ex is not None:
4899 
      raise result.ex
4900 
    return
4901 
 
4369 rajveer 4902 
  def markOrdersAsTimeout(self, vendorId):
4903 
    """
4904 
    Parameters:
4905 
     - vendorId
4906 
    """
4907 
    self.send_markOrdersAsTimeout(vendorId)
4908 
    return self.recv_markOrdersAsTimeout()
4303 rajveer 4909 
 
4369 rajveer 4910 
  def send_markOrdersAsTimeout(self, vendorId):
4911 
    self._oprot.writeMessageBegin('markOrdersAsTimeout', TMessageType.CALL, self._seqid)
4912 
    args = markOrdersAsTimeout_args()
4913 
    args.vendorId = vendorId
4914 
    args.write(self._oprot)
4915 
    self._oprot.writeMessageEnd()
4916 
    self._oprot.trans.flush()
4917 
 
4918 
  def recv_markOrdersAsTimeout(self, ):
4919 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4920 
    if mtype == TMessageType.EXCEPTION:
4921 
      x = TApplicationException()
4922 
      x.read(self._iprot)
4923 
      self._iprot.readMessageEnd()
4924 
      raise x
4925 
    result = markOrdersAsTimeout_result()
4926 
    result.read(self._iprot)
4927 
    self._iprot.readMessageEnd()
4928 
    if result.success is not None:
4929 
      return result.success
4930 
    if result.ex is not None:
4931 
      raise result.ex
4932 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrdersAsTimeout failed: unknown result");
4933 
 
4662 rajveer 4934 
  def markOrderAsLostInTransit(self, orderId):
4935 
    """
4936 
    Mark order as LOST_IN_TRANSIT
4937 
 
4938 
    Parameters:
4939 
     - orderId
4940 
    """
4941 
    self.send_markOrderAsLostInTransit(orderId)
4942 
    return self.recv_markOrderAsLostInTransit()
4943 
 
4944 
  def send_markOrderAsLostInTransit(self, orderId):
4945 
    self._oprot.writeMessageBegin('markOrderAsLostInTransit', TMessageType.CALL, self._seqid)
4946 
    args = markOrderAsLostInTransit_args()
4947 
    args.orderId = orderId
4948 
    args.write(self._oprot)
4949 
    self._oprot.writeMessageEnd()
4950 
    self._oprot.trans.flush()
4951 
 
4952 
  def recv_markOrderAsLostInTransit(self, ):
4953 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4954 
    if mtype == TMessageType.EXCEPTION:
4955 
      x = TApplicationException()
4956 
      x.read(self._iprot)
4957 
      self._iprot.readMessageEnd()
4958 
      raise x
4959 
    result = markOrderAsLostInTransit_result()
4960 
    result.read(self._iprot)
4961 
    self._iprot.readMessageEnd()
4962 
    if result.success is not None:
4963 
      return result.success
4964 
    if result.ex is not None:
4965 
      raise result.ex
4966 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderAsLostInTransit failed: unknown result");
4967 
 
4386 anupam.sin 4968 
  def getOrderForAwb(self, awb):
4969 
    """
4970 
    Returns the order corresponding to an AWB number
4369 rajveer 4971 
 
4386 anupam.sin 4972 
    Parameters:
4973 
     - awb
4974 
    """
4975 
    self.send_getOrderForAwb(awb)
4976 
    return self.recv_getOrderForAwb()
4977 
 
4978 
  def send_getOrderForAwb(self, awb):
4979 
    self._oprot.writeMessageBegin('getOrderForAwb', TMessageType.CALL, self._seqid)
4980 
    args = getOrderForAwb_args()
4981 
    args.awb = awb
4982 
    args.write(self._oprot)
4983 
    self._oprot.writeMessageEnd()
4984 
    self._oprot.trans.flush()
4985 
 
4986 
  def recv_getOrderForAwb(self, ):
4987 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4988 
    if mtype == TMessageType.EXCEPTION:
4989 
      x = TApplicationException()
4990 
      x.read(self._iprot)
4991 
      self._iprot.readMessageEnd()
4992 
      raise x
4993 
    result = getOrderForAwb_result()
4994 
    result.read(self._iprot)
4995 
    self._iprot.readMessageEnd()
4996 
    if result.success is not None:
4997 
      return result.success
4998 
    if result.ex is not None:
4999 
      raise result.ex
5000 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderForAwb failed: unknown result");
5001 
 
4910 phani.kuma 5002 
  def getOrdersForProviderForStatus(self, logistics_provider_id, order_status_list):
4506 phani.kuma 5003 
    """
4910 phani.kuma 5004 
    Returns the order corresponding to a logistics provider id for a given list of order status
4386 anupam.sin 5005 
 
4506 phani.kuma 5006 
    Parameters:
5007 
     - logistics_provider_id
4910 phani.kuma 5008 
     - order_status_list
4506 phani.kuma 5009 
    """
4910 phani.kuma 5010 
    self.send_getOrdersForProviderForStatus(logistics_provider_id, order_status_list)
4506 phani.kuma 5011 
    return self.recv_getOrdersForProviderForStatus()
5012 
 
4910 phani.kuma 5013 
  def send_getOrdersForProviderForStatus(self, logistics_provider_id, order_status_list):
4506 phani.kuma 5014 
    self._oprot.writeMessageBegin('getOrdersForProviderForStatus', TMessageType.CALL, self._seqid)
5015 
    args = getOrdersForProviderForStatus_args()
5016 
    args.logistics_provider_id = logistics_provider_id
4910 phani.kuma 5017 
    args.order_status_list = order_status_list
4506 phani.kuma 5018 
    args.write(self._oprot)
5019 
    self._oprot.writeMessageEnd()
5020 
    self._oprot.trans.flush()
5021 
 
5022 
  def recv_getOrdersForProviderForStatus(self, ):
5023 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5024 
    if mtype == TMessageType.EXCEPTION:
5025 
      x = TApplicationException()
5026 
      x.read(self._iprot)
5027 
      self._iprot.readMessageEnd()
5028 
      raise x
5029 
    result = getOrdersForProviderForStatus_result()
5030 
    result.read(self._iprot)
5031 
    self._iprot.readMessageEnd()
5032 
    if result.success is not None:
5033 
      return result.success
5034 
    if result.ex is not None:
5035 
      raise result.ex
5036 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersForProviderForStatus failed: unknown result");
5037 
 
4600 varun.gupt 5038 
  def getBilledOrdersForVendor(self, vendorId, billingDateFrom, billingDateTo):
5039 
    """
5040 
    Returns list of orders fullfiled from a certain vendor and billed in a given date range
4506 phani.kuma 5041 
 
4600 varun.gupt 5042 
    Parameters:
5043 
     - vendorId
5044 
     - billingDateFrom
5045 
     - billingDateTo
5046 
    """
5047 
    self.send_getBilledOrdersForVendor(vendorId, billingDateFrom, billingDateTo)
5048 
    return self.recv_getBilledOrdersForVendor()
5049 
 
5050 
  def send_getBilledOrdersForVendor(self, vendorId, billingDateFrom, billingDateTo):
5051 
    self._oprot.writeMessageBegin('getBilledOrdersForVendor', TMessageType.CALL, self._seqid)
5052 
    args = getBilledOrdersForVendor_args()
5053 
    args.vendorId = vendorId
5054 
    args.billingDateFrom = billingDateFrom
5055 
    args.billingDateTo = billingDateTo
5056 
    args.write(self._oprot)
5057 
    self._oprot.writeMessageEnd()
5058 
    self._oprot.trans.flush()
5059 
 
5060 
  def recv_getBilledOrdersForVendor(self, ):
5061 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5062 
    if mtype == TMessageType.EXCEPTION:
5063 
      x = TApplicationException()
5064 
      x.read(self._iprot)
5065 
      self._iprot.readMessageEnd()
5066 
      raise x
5067 
    result = getBilledOrdersForVendor_result()
5068 
    result.read(self._iprot)
5069 
    self._iprot.readMessageEnd()
5070 
    if result.success is not None:
5071 
      return result.success
5072 
    if result.ex is not None:
5073 
      raise result.ex
5074 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBilledOrdersForVendor failed: unknown result");
5075 
 
4607 rajveer 5076 
  def getSlippedSippingDateOrders(self, ):
5077 
    self.send_getSlippedSippingDateOrders()
5078 
    return self.recv_getSlippedSippingDateOrders()
5079 
 
5080 
  def send_getSlippedSippingDateOrders(self, ):
5081 
    self._oprot.writeMessageBegin('getSlippedSippingDateOrders', TMessageType.CALL, self._seqid)
5082 
    args = getSlippedSippingDateOrders_args()
5083 
    args.write(self._oprot)
5084 
    self._oprot.writeMessageEnd()
5085 
    self._oprot.trans.flush()
5086 
 
5087 
  def recv_getSlippedSippingDateOrders(self, ):
5088 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5089 
    if mtype == TMessageType.EXCEPTION:
5090 
      x = TApplicationException()
5091 
      x.read(self._iprot)
5092 
      self._iprot.readMessageEnd()
5093 
      raise x
5094 
    result = getSlippedSippingDateOrders_result()
5095 
    result.read(self._iprot)
5096 
    self._iprot.readMessageEnd()
5097 
    if result.success is not None:
5098 
      return result.success
5099 
    if result.ex is not None:
5100 
      raise result.ex
5101 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getSlippedSippingDateOrders failed: unknown result");
5102 
 
4709 rajveer 5103 
  def getCancelledOrders(self, cancelDateFrom, cancelDateTo):
5104 
    """
5105 
    Parameters:
5106 
     - cancelDateFrom
5107 
     - cancelDateTo
5108 
    """
5109 
    self.send_getCancelledOrders(cancelDateFrom, cancelDateTo)
5110 
    return self.recv_getCancelledOrders()
5111 
 
5112 
  def send_getCancelledOrders(self, cancelDateFrom, cancelDateTo):
5113 
    self._oprot.writeMessageBegin('getCancelledOrders', TMessageType.CALL, self._seqid)
5114 
    args = getCancelledOrders_args()
5115 
    args.cancelDateFrom = cancelDateFrom
5116 
    args.cancelDateTo = cancelDateTo
5117 
    args.write(self._oprot)
5118 
    self._oprot.writeMessageEnd()
5119 
    self._oprot.trans.flush()
5120 
 
5121 
  def recv_getCancelledOrders(self, ):
5122 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5123 
    if mtype == TMessageType.EXCEPTION:
5124 
      x = TApplicationException()
5125 
      x.read(self._iprot)
5126 
      self._iprot.readMessageEnd()
5127 
      raise x
5128 
    result = getCancelledOrders_result()
5129 
    result.read(self._iprot)
5130 
    self._iprot.readMessageEnd()
5131 
    if result.success is not None:
5132 
      return result.success
5133 
    if result.ex is not None:
5134 
      raise result.ex
5135 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCancelledOrders failed: unknown result");
5136 
 
4600 varun.gupt 5137 
  def saveBluedartSettlements(self, mapAWBAndAmount):
5138 
    """
5139 
    Parameters:
5140 
     - mapAWBAndAmount
5141 
    """
5142 
    self.send_saveBluedartSettlements(mapAWBAndAmount)
5143 
    self.recv_saveBluedartSettlements()
5144 
 
5145 
  def send_saveBluedartSettlements(self, mapAWBAndAmount):
5146 
    self._oprot.writeMessageBegin('saveBluedartSettlements', TMessageType.CALL, self._seqid)
5147 
    args = saveBluedartSettlements_args()
5148 
    args.mapAWBAndAmount = mapAWBAndAmount
5149 
    args.write(self._oprot)
5150 
    self._oprot.writeMessageEnd()
5151 
    self._oprot.trans.flush()
5152 
 
5153 
  def recv_saveBluedartSettlements(self, ):
5154 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5155 
    if mtype == TMessageType.EXCEPTION:
5156 
      x = TApplicationException()
5157 
      x.read(self._iprot)
5158 
      self._iprot.readMessageEnd()
5159 
      raise x
5160 
    result = saveBluedartSettlements_result()
5161 
    result.read(self._iprot)
5162 
    self._iprot.readMessageEnd()
5163 
    if result.ex is not None:
5164 
      raise result.ex
5165 
    return
5166 
 
4905 varun.gupt 5167 
  def savePaymentSettlements(self, settlementDate, paymentGatewayId, referenceId, serviceTax, otherCharges, netCollection):
4600 varun.gupt 5168 
    """
5169 
    Parameters:
5170 
     - settlementDate
5171 
     - paymentGatewayId
4905 varun.gupt 5172 
     - referenceId
4600 varun.gupt 5173 
     - serviceTax
5174 
     - otherCharges
5175 
     - netCollection
5176 
    """
4905 varun.gupt 5177 
    self.send_savePaymentSettlements(settlementDate, paymentGatewayId, referenceId, serviceTax, otherCharges, netCollection)
4600 varun.gupt 5178 
    self.recv_savePaymentSettlements()
5179 
 
4905 varun.gupt 5180 
  def send_savePaymentSettlements(self, settlementDate, paymentGatewayId, referenceId, serviceTax, otherCharges, netCollection):
4600 varun.gupt 5181 
    self._oprot.writeMessageBegin('savePaymentSettlements', TMessageType.CALL, self._seqid)
5182 
    args = savePaymentSettlements_args()
5183 
    args.settlementDate = settlementDate
5184 
    args.paymentGatewayId = paymentGatewayId
4905 varun.gupt 5185 
    args.referenceId = referenceId
4600 varun.gupt 5186 
    args.serviceTax = serviceTax
5187 
    args.otherCharges = otherCharges
5188 
    args.netCollection = netCollection
5189 
    args.write(self._oprot)
5190 
    self._oprot.writeMessageEnd()
5191 
    self._oprot.trans.flush()
5192 
 
5193 
  def recv_savePaymentSettlements(self, ):
5194 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5195 
    if mtype == TMessageType.EXCEPTION:
5196 
      x = TApplicationException()
5197 
      x.read(self._iprot)
5198 
      self._iprot.readMessageEnd()
5199 
      raise x
5200 
    result = savePaymentSettlements_result()
5201 
    result.read(self._iprot)
5202 
    self._iprot.readMessageEnd()
5203 
    if result.ex is not None:
5204 
      raise result.ex
5205 
    return
5206 
 
5207 
  def saveEBSSettlementSummary(self, settlementId, settlementDate, transactionDateFrom, transactionDateTo, amount):
5208 
    """
5209 
    Parameters:
5210 
     - settlementId
5211 
     - settlementDate
5212 
     - transactionDateFrom
5213 
     - transactionDateTo
5214 
     - amount
5215 
    """
5216 
    self.send_saveEBSSettlementSummary(settlementId, settlementDate, transactionDateFrom, transactionDateTo, amount)
5217 
    self.recv_saveEBSSettlementSummary()
5218 
 
5219 
  def send_saveEBSSettlementSummary(self, settlementId, settlementDate, transactionDateFrom, transactionDateTo, amount):
5220 
    self._oprot.writeMessageBegin('saveEBSSettlementSummary', TMessageType.CALL, self._seqid)
5221 
    args = saveEBSSettlementSummary_args()
5222 
    args.settlementId = settlementId
5223 
    args.settlementDate = settlementDate
5224 
    args.transactionDateFrom = transactionDateFrom
5225 
    args.transactionDateTo = transactionDateTo
5226 
    args.amount = amount
5227 
    args.write(self._oprot)
5228 
    self._oprot.writeMessageEnd()
5229 
    self._oprot.trans.flush()
5230 
 
5231 
  def recv_saveEBSSettlementSummary(self, ):
5232 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5233 
    if mtype == TMessageType.EXCEPTION:
5234 
      x = TApplicationException()
5235 
      x.read(self._iprot)
5236 
      self._iprot.readMessageEnd()
5237 
      raise x
5238 
    result = saveEBSSettlementSummary_result()
5239 
    result.read(self._iprot)
5240 
    self._iprot.readMessageEnd()
5241 
    if result.ex is not None:
5242 
      raise result.ex
5243 
    return
5244 
 
5386 phani.kuma 5245 
  def getSettlementForPrepaid(self, referenceId, isRefund):
4600 varun.gupt 5246 
    """
5247 
    Parameters:
5189 varun.gupt 5248 
     - referenceId
5249 
     - isRefund
4600 varun.gupt 5250 
    """
5386 phani.kuma 5251 
    self.send_getSettlementForPrepaid(referenceId, isRefund)
5252 
    return self.recv_getSettlementForPrepaid()
4600 varun.gupt 5253 
 
5386 phani.kuma 5254 
  def send_getSettlementForPrepaid(self, referenceId, isRefund):
5255 
    self._oprot.writeMessageBegin('getSettlementForPrepaid', TMessageType.CALL, self._seqid)
5256 
    args = getSettlementForPrepaid_args()
5189 varun.gupt 5257 
    args.referenceId = referenceId
5258 
    args.isRefund = isRefund
4600 varun.gupt 5259 
    args.write(self._oprot)
5260 
    self._oprot.writeMessageEnd()
5261 
    self._oprot.trans.flush()
5262 
 
5386 phani.kuma 5263 
  def recv_getSettlementForPrepaid(self, ):
4600 varun.gupt 5264 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5265 
    if mtype == TMessageType.EXCEPTION:
5266 
      x = TApplicationException()
5267 
      x.read(self._iprot)
5268 
      self._iprot.readMessageEnd()
5269 
      raise x
5386 phani.kuma 5270 
    result = getSettlementForPrepaid_result()
4600 varun.gupt 5271 
    result.read(self._iprot)
5272 
    self._iprot.readMessageEnd()
5273 
    if result.success is not None:
5274 
      return result.success
5275 
    if result.ex is not None:
5276 
      raise result.ex
5386 phani.kuma 5277 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getSettlementForPrepaid failed: unknown result");
4600 varun.gupt 5278 
 
5386 phani.kuma 5279 
  def getSettlementForCod(self, orderId, isRefund):
5280 
    """
5281 
    Parameters:
5282 
     - orderId
5283 
     - isRefund
5284 
    """
5285 
    self.send_getSettlementForCod(orderId, isRefund)
5286 
    return self.recv_getSettlementForCod()
5287 
 
5288 
  def send_getSettlementForCod(self, orderId, isRefund):
5289 
    self._oprot.writeMessageBegin('getSettlementForCod', TMessageType.CALL, self._seqid)
5290 
    args = getSettlementForCod_args()
5291 
    args.orderId = orderId
5292 
    args.isRefund = isRefund
5293 
    args.write(self._oprot)
5294 
    self._oprot.writeMessageEnd()
5295 
    self._oprot.trans.flush()
5296 
 
5297 
  def recv_getSettlementForCod(self, ):
5298 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5299 
    if mtype == TMessageType.EXCEPTION:
5300 
      x = TApplicationException()
5301 
      x.read(self._iprot)
5302 
      self._iprot.readMessageEnd()
5303 
      raise x
5304 
    result = getSettlementForCod_result()
5305 
    result.read(self._iprot)
5306 
    self._iprot.readMessageEnd()
5307 
    if result.success is not None:
5308 
      return result.success
5309 
    if result.ex is not None:
5310 
      raise result.ex
5311 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getSettlementForCod failed: unknown result");
5312 
 
4600 varun.gupt 5313 
  def getEBSSettlementSummaries(self, ):
5314 
    self.send_getEBSSettlementSummaries()
5315 
    return self.recv_getEBSSettlementSummaries()
5316 
 
5317 
  def send_getEBSSettlementSummaries(self, ):
5318 
    self._oprot.writeMessageBegin('getEBSSettlementSummaries', TMessageType.CALL, self._seqid)
5319 
    args = getEBSSettlementSummaries_args()
5320 
    args.write(self._oprot)
5321 
    self._oprot.writeMessageEnd()
5322 
    self._oprot.trans.flush()
5323 
 
5324 
  def recv_getEBSSettlementSummaries(self, ):
5325 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5326 
    if mtype == TMessageType.EXCEPTION:
5327 
      x = TApplicationException()
5328 
      x.read(self._iprot)
5329 
      self._iprot.readMessageEnd()
5330 
      raise x
5331 
    result = getEBSSettlementSummaries_result()
5332 
    result.read(self._iprot)
5333 
    self._iprot.readMessageEnd()
5334 
    if result.success is not None:
5335 
      return result.success
5336 
    if result.ex is not None:
5337 
      raise result.ex
5338 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getEBSSettlementSummaries failed: unknown result");
5339 
 
5340 
  def markEBSSettlementUploaded(self, settlementId):
5341 
    """
5342 
    Parameters:
5343 
     - settlementId
5344 
    """
5345 
    self.send_markEBSSettlementUploaded(settlementId)
5346 
    self.recv_markEBSSettlementUploaded()
5347 
 
5348 
  def send_markEBSSettlementUploaded(self, settlementId):
5349 
    self._oprot.writeMessageBegin('markEBSSettlementUploaded', TMessageType.CALL, self._seqid)
5350 
    args = markEBSSettlementUploaded_args()
5351 
    args.settlementId = settlementId
5352 
    args.write(self._oprot)
5353 
    self._oprot.writeMessageEnd()
5354 
    self._oprot.trans.flush()
5355 
 
5356 
  def recv_markEBSSettlementUploaded(self, ):
5357 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5358 
    if mtype == TMessageType.EXCEPTION:
5359 
      x = TApplicationException()
5360 
      x.read(self._iprot)
5361 
      self._iprot.readMessageEnd()
5362 
      raise x
5363 
    result = markEBSSettlementUploaded_result()
5364 
    result.read(self._iprot)
5365 
    self._iprot.readMessageEnd()
5366 
    if result.ex is not None:
5367 
      raise result.ex
5368 
    return
5369 
 
5370 
  def getEBSSettlementDate(self, settlementId):
5371 
    """
5372 
    Parameters:
5373 
     - settlementId
5374 
    """
5375 
    self.send_getEBSSettlementDate(settlementId)
5376 
    return self.recv_getEBSSettlementDate()
5377 
 
5378 
  def send_getEBSSettlementDate(self, settlementId):
5379 
    self._oprot.writeMessageBegin('getEBSSettlementDate', TMessageType.CALL, self._seqid)
5380 
    args = getEBSSettlementDate_args()
5381 
    args.settlementId = settlementId
5382 
    args.write(self._oprot)
5383 
    self._oprot.writeMessageEnd()
5384 
    self._oprot.trans.flush()
5385 
 
5386 
  def recv_getEBSSettlementDate(self, ):
5387 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5388 
    if mtype == TMessageType.EXCEPTION:
5389 
      x = TApplicationException()
5390 
      x.read(self._iprot)
5391 
      self._iprot.readMessageEnd()
5392 
      raise x
5393 
    result = getEBSSettlementDate_result()
5394 
    result.read(self._iprot)
5395 
    self._iprot.readMessageEnd()
5396 
    if result.success is not None:
5397 
      return result.success
5398 
    if result.ex is not None:
5399 
      raise result.ex
5400 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getEBSSettlementDate failed: unknown result");
5401 
 
4715 varun.gupt 5402 
  def getSettlementsByDate(self, settlementDateFrom, settlementDateTo, isRefund):
5403 
    """
5404 
    Parameters:
5405 
     - settlementDateFrom
5406 
     - settlementDateTo
5407 
     - isRefund
5408 
    """
5409 
    self.send_getSettlementsByDate(settlementDateFrom, settlementDateTo, isRefund)
5410 
    return self.recv_getSettlementsByDate()
4600 varun.gupt 5411 
 
4715 varun.gupt 5412 
  def send_getSettlementsByDate(self, settlementDateFrom, settlementDateTo, isRefund):
5413 
    self._oprot.writeMessageBegin('getSettlementsByDate', TMessageType.CALL, self._seqid)
5414 
    args = getSettlementsByDate_args()
5415 
    args.settlementDateFrom = settlementDateFrom
5416 
    args.settlementDateTo = settlementDateTo
5417 
    args.isRefund = isRefund
5418 
    args.write(self._oprot)
5419 
    self._oprot.writeMessageEnd()
5420 
    self._oprot.trans.flush()
5421 
 
5422 
  def recv_getSettlementsByDate(self, ):
5423 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5424 
    if mtype == TMessageType.EXCEPTION:
5425 
      x = TApplicationException()
5426 
      x.read(self._iprot)
5427 
      self._iprot.readMessageEnd()
5428 
      raise x
5429 
    result = getSettlementsByDate_result()
5430 
    result.read(self._iprot)
5431 
    self._iprot.readMessageEnd()
5432 
    if result.success is not None:
5433 
      return result.success
5434 
    if result.ex is not None:
5435 
      raise result.ex
5436 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getSettlementsByDate failed: unknown result");
5437 
 
5438 
  def getReshippedOrderIds(self, orderIds):
5439 
    """
5440 
    Returns list of Order Ids, which belong to reshiped orders, shortlisted from a given list of Order Ids
5441 
 
5442 
    Parameters:
5443 
     - orderIds
5444 
    """
5445 
    self.send_getReshippedOrderIds(orderIds)
5446 
    return self.recv_getReshippedOrderIds()
5447 
 
5448 
  def send_getReshippedOrderIds(self, orderIds):
5449 
    self._oprot.writeMessageBegin('getReshippedOrderIds', TMessageType.CALL, self._seqid)
5450 
    args = getReshippedOrderIds_args()
5451 
    args.orderIds = orderIds
5452 
    args.write(self._oprot)
5453 
    self._oprot.writeMessageEnd()
5454 
    self._oprot.trans.flush()
5455 
 
5456 
  def recv_getReshippedOrderIds(self, ):
5457 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5458 
    if mtype == TMessageType.EXCEPTION:
5459 
      x = TApplicationException()
5460 
      x.read(self._iprot)
5461 
      self._iprot.readMessageEnd()
5462 
      raise x
5463 
    result = getReshippedOrderIds_result()
5464 
    result.read(self._iprot)
5465 
    self._iprot.readMessageEnd()
5466 
    if result.success is not None:
5467 
      return result.success
5468 
    if result.ex is not None:
5469 
      raise result.ex
5470 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReshippedOrderIds failed: unknown result");
5471 
 
5481 phani.kuma 5472 
  def getBilledOrders(self, vendorId, onlyVendorNotPaid, billingDateFrom, billingDateTo):
4875 varun.gupt 5473 
    """
5474 
    Parameters:
5475 
     - vendorId
5481 phani.kuma 5476 
     - onlyVendorNotPaid
5477 
     - billingDateFrom
5478 
     - billingDateTo
4875 varun.gupt 5479 
    """
5481 phani.kuma 5480 
    self.send_getBilledOrders(vendorId, onlyVendorNotPaid, billingDateFrom, billingDateTo)
5481 
    return self.recv_getBilledOrders()
4757 mandeep.dh 5482 
 
5481 phani.kuma 5483 
  def send_getBilledOrders(self, vendorId, onlyVendorNotPaid, billingDateFrom, billingDateTo):
5484 
    self._oprot.writeMessageBegin('getBilledOrders', TMessageType.CALL, self._seqid)
5485 
    args = getBilledOrders_args()
4875 varun.gupt 5486 
    args.vendorId = vendorId
5481 phani.kuma 5487 
    args.onlyVendorNotPaid = onlyVendorNotPaid
5488 
    args.billingDateFrom = billingDateFrom
5489 
    args.billingDateTo = billingDateTo
4875 varun.gupt 5490 
    args.write(self._oprot)
5491 
    self._oprot.writeMessageEnd()
5492 
    self._oprot.trans.flush()
5493 
 
5481 phani.kuma 5494 
  def recv_getBilledOrders(self, ):
4875 varun.gupt 5495 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5496 
    if mtype == TMessageType.EXCEPTION:
5497 
      x = TApplicationException()
5498 
      x.read(self._iprot)
5499 
      self._iprot.readMessageEnd()
5500 
      raise x
5481 phani.kuma 5501 
    result = getBilledOrders_result()
4875 varun.gupt 5502 
    result.read(self._iprot)
5503 
    self._iprot.readMessageEnd()
5504 
    if result.success is not None:
5505 
      return result.success
5506 
    if result.ex is not None:
5507 
      raise result.ex
5481 phani.kuma 5508 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBilledOrders failed: unknown result");
4875 varun.gupt 5509 
 
5031 varun.gupt 5510 
  def getStatusDistributionOfOrders(self, startDate, endDate):
5511 
    """
5512 
    Parameters:
5513 
     - startDate
5514 
     - endDate
5515 
    """
5516 
    self.send_getStatusDistributionOfOrders(startDate, endDate)
5517 
    return self.recv_getStatusDistributionOfOrders()
4875 varun.gupt 5518 
 
5031 varun.gupt 5519 
  def send_getStatusDistributionOfOrders(self, startDate, endDate):
5520 
    self._oprot.writeMessageBegin('getStatusDistributionOfOrders', TMessageType.CALL, self._seqid)
5521 
    args = getStatusDistributionOfOrders_args()
5522 
    args.startDate = startDate
5523 
    args.endDate = endDate
5524 
    args.write(self._oprot)
5525 
    self._oprot.writeMessageEnd()
5526 
    self._oprot.trans.flush()
5527 
 
5528 
  def recv_getStatusDistributionOfOrders(self, ):
5529 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5530 
    if mtype == TMessageType.EXCEPTION:
5531 
      x = TApplicationException()
5532 
      x.read(self._iprot)
5533 
      self._iprot.readMessageEnd()
5534 
      raise x
5535 
    result = getStatusDistributionOfOrders_result()
5536 
    result.read(self._iprot)
5537 
    self._iprot.readMessageEnd()
5538 
    if result.success is not None:
5539 
      return result.success
5540 
    if result.ex is not None:
5541 
      raise result.ex
5542 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getStatusDistributionOfOrders failed: unknown result");
5543 
 
5067 varun.gupt 5544 
  def getOrderIdsForStatus(self, status, startDatetime, endDatetime):
5545 
    """
5546 
    Parameters:
5547 
     - status
5548 
     - startDatetime
5549 
     - endDatetime
5550 
    """
5551 
    self.send_getOrderIdsForStatus(status, startDatetime, endDatetime)
5552 
    return self.recv_getOrderIdsForStatus()
5031 varun.gupt 5553 
 
5067 varun.gupt 5554 
  def send_getOrderIdsForStatus(self, status, startDatetime, endDatetime):
5555 
    self._oprot.writeMessageBegin('getOrderIdsForStatus', TMessageType.CALL, self._seqid)
5556 
    args = getOrderIdsForStatus_args()
5557 
    args.status = status
5558 
    args.startDatetime = startDatetime
5559 
    args.endDatetime = endDatetime
5560 
    args.write(self._oprot)
5561 
    self._oprot.writeMessageEnd()
5562 
    self._oprot.trans.flush()
5563 
 
5564 
  def recv_getOrderIdsForStatus(self, ):
5565 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5566 
    if mtype == TMessageType.EXCEPTION:
5567 
      x = TApplicationException()
5568 
      x.read(self._iprot)
5569 
      self._iprot.readMessageEnd()
5570 
      raise x
5571 
    result = getOrderIdsForStatus_result()
5572 
    result.read(self._iprot)
5573 
    self._iprot.readMessageEnd()
5574 
    if result.success is not None:
5575 
      return result.success
5576 
    if result.ex is not None:
5577 
      raise result.ex
5578 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderIdsForStatus failed: unknown result");
5579 
 
5348 anupam.sin 5580 
  def updateCODAgent(self, agent, orderId):
5581 
    """
5582 
    Updates the agent who handled the COD verification call
5583 
 
5584 
    Parameters:
5585 
     - agent
5586 
     - orderId
5587 
    """
5588 
    self.send_updateCODAgent(agent, orderId)
5589 
    self.recv_updateCODAgent()
5590 
 
5591 
  def send_updateCODAgent(self, agent, orderId):
5592 
    self._oprot.writeMessageBegin('updateCODAgent', TMessageType.CALL, self._seqid)
5593 
    args = updateCODAgent_args()
5594 
    args.agent = agent
5595 
    args.orderId = orderId
5596 
    args.write(self._oprot)
5597 
    self._oprot.writeMessageEnd()
5598 
    self._oprot.trans.flush()
5599 
 
5600 
  def recv_updateCODAgent(self, ):
5601 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5602 
    if mtype == TMessageType.EXCEPTION:
5603 
      x = TApplicationException()
5604 
      x.read(self._iprot)
5605 
      self._iprot.readMessageEnd()
5606 
      raise x
5607 
    result = updateCODAgent_result()
5608 
    result.read(self._iprot)
5609 
    self._iprot.readMessageEnd()
5610 
    if result.ex is not None:
5611 
      raise result.ex
5612 
    return
5613 
 
5099 varun.gupt 5614 
  def updateOrderAsPaidToVendor(self, orderId):
5615 
    """
5616 
    Parameters:
5617 
     - orderId
5618 
    """
5619 
    self.send_updateOrderAsPaidToVendor(orderId)
5620 
    self.recv_updateOrderAsPaidToVendor()
5067 varun.gupt 5621 
 
5099 varun.gupt 5622 
  def send_updateOrderAsPaidToVendor(self, orderId):
5623 
    self._oprot.writeMessageBegin('updateOrderAsPaidToVendor', TMessageType.CALL, self._seqid)
5624 
    args = updateOrderAsPaidToVendor_args()
5625 
    args.orderId = orderId
5626 
    args.write(self._oprot)
5627 
    self._oprot.writeMessageEnd()
5628 
    self._oprot.trans.flush()
5629 
 
5630 
  def recv_updateOrderAsPaidToVendor(self, ):
5631 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5632 
    if mtype == TMessageType.EXCEPTION:
5633 
      x = TApplicationException()
5634 
      x.read(self._iprot)
5635 
      self._iprot.readMessageEnd()
5636 
      raise x
5637 
    result = updateOrderAsPaidToVendor_result()
5638 
    result.read(self._iprot)
5639 
    self._iprot.readMessageEnd()
5640 
    if result.ex is not None:
5641 
      raise result.ex
5642 
    return
5643 
 
5386 phani.kuma 5644 
  def updateOrderOnlyAsPaidToVendor(self, orderId):
5645 
    """
5646 
    Parameters:
5647 
     - orderId
5648 
    """
5649 
    self.send_updateOrderOnlyAsPaidToVendor(orderId)
5650 
    self.recv_updateOrderOnlyAsPaidToVendor()
5651 
 
5652 
  def send_updateOrderOnlyAsPaidToVendor(self, orderId):
5653 
    self._oprot.writeMessageBegin('updateOrderOnlyAsPaidToVendor', TMessageType.CALL, self._seqid)
5654 
    args = updateOrderOnlyAsPaidToVendor_args()
5655 
    args.orderId = orderId
5656 
    args.write(self._oprot)
5657 
    self._oprot.writeMessageEnd()
5658 
    self._oprot.trans.flush()
5659 
 
5660 
  def recv_updateOrderOnlyAsPaidToVendor(self, ):
5661 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5662 
    if mtype == TMessageType.EXCEPTION:
5663 
      x = TApplicationException()
5664 
      x.read(self._iprot)
5665 
      self._iprot.readMessageEnd()
5666 
      raise x
5667 
    result = updateOrderOnlyAsPaidToVendor_result()
5668 
    result.read(self._iprot)
5669 
    self._iprot.readMessageEnd()
5670 
    if result.ex is not None:
5671 
      raise result.ex
5672 
    return
5673 
 
5208 varun.gupt 5674 
  def getRefundedOrdersMarkedPaid(self, ):
5675 
    self.send_getRefundedOrdersMarkedPaid()
5676 
    return self.recv_getRefundedOrdersMarkedPaid()
5099 varun.gupt 5677 
 
5208 varun.gupt 5678 
  def send_getRefundedOrdersMarkedPaid(self, ):
5679 
    self._oprot.writeMessageBegin('getRefundedOrdersMarkedPaid', TMessageType.CALL, self._seqid)
5680 
    args = getRefundedOrdersMarkedPaid_args()
5681 
    args.write(self._oprot)
5682 
    self._oprot.writeMessageEnd()
5683 
    self._oprot.trans.flush()
5684 
 
5685 
  def recv_getRefundedOrdersMarkedPaid(self, ):
5686 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5687 
    if mtype == TMessageType.EXCEPTION:
5688 
      x = TApplicationException()
5689 
      x.read(self._iprot)
5690 
      self._iprot.readMessageEnd()
5691 
      raise x
5692 
    result = getRefundedOrdersMarkedPaid_result()
5693 
    result.read(self._iprot)
5694 
    self._iprot.readMessageEnd()
5695 
    if result.success is not None:
5696 
      return result.success
5697 
    if result.ex is not None:
5698 
      raise result.ex
5699 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getRefundedOrdersMarkedPaid failed: unknown result");
5700 
 
5447 anupam.sin 5701 
  def getAllVerificationAgents(self, minOrderId, maxOrderId):
5702 
    """
5703 
    gets all COD Verification Agents for all orderIds from a minId to maxId
5208 varun.gupt 5704 
 
5447 anupam.sin 5705 
 
5706 
    Parameters:
5707 
     - minOrderId
5708 
     - maxOrderId
5709 
    """
5710 
    self.send_getAllVerificationAgents(minOrderId, maxOrderId)
5711 
    return self.recv_getAllVerificationAgents()
5712 
 
5713 
  def send_getAllVerificationAgents(self, minOrderId, maxOrderId):
5714 
    self._oprot.writeMessageBegin('getAllVerificationAgents', TMessageType.CALL, self._seqid)
5715 
    args = getAllVerificationAgents_args()
5716 
    args.minOrderId = minOrderId
5717 
    args.maxOrderId = maxOrderId
5718 
    args.write(self._oprot)
5719 
    self._oprot.writeMessageEnd()
5720 
    self._oprot.trans.flush()
5721 
 
5722 
  def recv_getAllVerificationAgents(self, ):
5723 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5724 
    if mtype == TMessageType.EXCEPTION:
5725 
      x = TApplicationException()
5726 
      x.read(self._iprot)
5727 
      self._iprot.readMessageEnd()
5728 
      raise x
5729 
    result = getAllVerificationAgents_result()
5730 
    result.read(self._iprot)
5731 
    self._iprot.readMessageEnd()
5732 
    if result.success is not None:
5733 
      return result.success
5734 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllVerificationAgents failed: unknown result");
5735 
 
5527 anupam.sin 5736 
  def getAllAttributesForOrderId(self, orderId):
5737 
    """
5738 
    gets all attributes for a given orderId
5447 anupam.sin 5739 
 
5527 anupam.sin 5740 
    Parameters:
5741 
     - orderId
5742 
    """
5743 
    self.send_getAllAttributesForOrderId(orderId)
5744 
    return self.recv_getAllAttributesForOrderId()
5745 
 
5746 
  def send_getAllAttributesForOrderId(self, orderId):
5747 
    self._oprot.writeMessageBegin('getAllAttributesForOrderId', TMessageType.CALL, self._seqid)
5748 
    args = getAllAttributesForOrderId_args()
5749 
    args.orderId = orderId
5750 
    args.write(self._oprot)
5751 
    self._oprot.writeMessageEnd()
5752 
    self._oprot.trans.flush()
5753 
 
5754 
  def recv_getAllAttributesForOrderId(self, ):
5755 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5756 
    if mtype == TMessageType.EXCEPTION:
5757 
      x = TApplicationException()
5758 
      x.read(self._iprot)
5759 
      self._iprot.readMessageEnd()
5760 
      raise x
5761 
    result = getAllAttributesForOrderId_result()
5762 
    result.read(self._iprot)
5763 
    self._iprot.readMessageEnd()
5764 
    if result.success is not None:
5765 
      return result.success
5766 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllAttributesForOrderId failed: unknown result");
5767 
 
5676 rajveer 5768 
  def setOrderAttributes(self, orderId, attributes):
5769 
    """
5770 
    sets attributes for an order
5771 
 
5772 
    Parameters:
5773 
     - orderId
5774 
     - attributes
5775 
    """
5776 
    self.send_setOrderAttributes(orderId, attributes)
5777 
    self.recv_setOrderAttributes()
5778 
 
5779 
  def send_setOrderAttributes(self, orderId, attributes):
5780 
    self._oprot.writeMessageBegin('setOrderAttributes', TMessageType.CALL, self._seqid)
5781 
    args = setOrderAttributes_args()
5782 
    args.orderId = orderId
5783 
    args.attributes = attributes
5784 
    args.write(self._oprot)
5785 
    self._oprot.writeMessageEnd()
5786 
    self._oprot.trans.flush()
5787 
 
5788 
  def recv_setOrderAttributes(self, ):
5789 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5790 
    if mtype == TMessageType.EXCEPTION:
5791 
      x = TApplicationException()
5792 
      x.read(self._iprot)
5793 
      self._iprot.readMessageEnd()
5794 
      raise x
5795 
    result = setOrderAttributes_result()
5796 
    result.read(self._iprot)
5797 
    self._iprot.readMessageEnd()
5798 
    return
5799 
 
5527 anupam.sin 5800 
  def setOrderAttributeForTransaction(self, transactionId, attribute):
5801 
    """
5802 
    sets attributes for all orders in a transaction
5803 
 
5804 
    Parameters:
5805 
     - transactionId
5806 
     - attribute
5807 
    """
5808 
    self.send_setOrderAttributeForTransaction(transactionId, attribute)
5809 
    self.recv_setOrderAttributeForTransaction()
5810 
 
5811 
  def send_setOrderAttributeForTransaction(self, transactionId, attribute):
5812 
    self._oprot.writeMessageBegin('setOrderAttributeForTransaction', TMessageType.CALL, self._seqid)
5813 
    args = setOrderAttributeForTransaction_args()
5814 
    args.transactionId = transactionId
5815 
    args.attribute = attribute
5816 
    args.write(self._oprot)
5817 
    self._oprot.writeMessageEnd()
5818 
    self._oprot.trans.flush()
5819 
 
5820 
  def recv_setOrderAttributeForTransaction(self, ):
5821 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5822 
    if mtype == TMessageType.EXCEPTION:
5823 
      x = TApplicationException()
5824 
      x.read(self._iprot)
5825 
      self._iprot.readMessageEnd()
5826 
      raise x
5827 
    result = setOrderAttributeForTransaction_result()
5828 
    result.read(self._iprot)
5829 
    self._iprot.readMessageEnd()
5830 
    return
5831 
 
5553 rajveer 5832 
  def getReceivePendingOrders(self, storeId):
5833 
    """
5834 
    Parameters:
5835 
     - storeId
5836 
    """
5837 
    self.send_getReceivePendingOrders(storeId)
5838 
    return self.recv_getReceivePendingOrders()
5527 anupam.sin 5839 
 
5553 rajveer 5840 
  def send_getReceivePendingOrders(self, storeId):
5841 
    self._oprot.writeMessageBegin('getReceivePendingOrders', TMessageType.CALL, self._seqid)
5842 
    args = getReceivePendingOrders_args()
5843 
    args.storeId = storeId
5844 
    args.write(self._oprot)
5845 
    self._oprot.writeMessageEnd()
5846 
    self._oprot.trans.flush()
5847 
 
5848 
  def recv_getReceivePendingOrders(self, ):
5849 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5850 
    if mtype == TMessageType.EXCEPTION:
5851 
      x = TApplicationException()
5852 
      x.read(self._iprot)
5853 
      self._iprot.readMessageEnd()
5854 
      raise x
5855 
    result = getReceivePendingOrders_result()
5856 
    result.read(self._iprot)
5857 
    self._iprot.readMessageEnd()
5858 
    if result.success is not None:
5859 
      return result.success
5860 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReceivePendingOrders failed: unknown result");
5861 
 
5862 
  def getReceivedAtStoreOrders(self, storeId):
5863 
    """
5864 
    Parameters:
5865 
     - storeId
5866 
    """
5867 
    self.send_getReceivedAtStoreOrders(storeId)
5868 
    return self.recv_getReceivedAtStoreOrders()
5869 
 
5870 
  def send_getReceivedAtStoreOrders(self, storeId):
5871 
    self._oprot.writeMessageBegin('getReceivedAtStoreOrders', TMessageType.CALL, self._seqid)
5872 
    args = getReceivedAtStoreOrders_args()
5873 
    args.storeId = storeId
5874 
    args.write(self._oprot)
5875 
    self._oprot.writeMessageEnd()
5876 
    self._oprot.trans.flush()
5877 
 
5878 
  def recv_getReceivedAtStoreOrders(self, ):
5879 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5880 
    if mtype == TMessageType.EXCEPTION:
5881 
      x = TApplicationException()
5882 
      x.read(self._iprot)
5883 
      self._iprot.readMessageEnd()
5884 
      raise x
5885 
    result = getReceivedAtStoreOrders_result()
5886 
    result.read(self._iprot)
5887 
    self._iprot.readMessageEnd()
5888 
    if result.success is not None:
5889 
      return result.success
5890 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReceivedAtStoreOrders failed: unknown result");
5891 
 
5713 rajveer 5892 
  def getOrdersCollectionAtStore(self, storeId, fromDate, toDate, onlyCod):
5893 
    """
5894 
    Parameters:
5895 
     - storeId
5896 
     - fromDate
5897 
     - toDate
5898 
     - onlyCod
5899 
    """
5900 
    self.send_getOrdersCollectionAtStore(storeId, fromDate, toDate, onlyCod)
5901 
    return self.recv_getOrdersCollectionAtStore()
5902 
 
5903 
  def send_getOrdersCollectionAtStore(self, storeId, fromDate, toDate, onlyCod):
5904 
    self._oprot.writeMessageBegin('getOrdersCollectionAtStore', TMessageType.CALL, self._seqid)
5905 
    args = getOrdersCollectionAtStore_args()
5906 
    args.storeId = storeId
5907 
    args.fromDate = fromDate
5908 
    args.toDate = toDate
5909 
    args.onlyCod = onlyCod
5910 
    args.write(self._oprot)
5911 
    self._oprot.writeMessageEnd()
5912 
    self._oprot.trans.flush()
5913 
 
5914 
  def recv_getOrdersCollectionAtStore(self, ):
5915 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5916 
    if mtype == TMessageType.EXCEPTION:
5917 
      x = TApplicationException()
5918 
      x.read(self._iprot)
5919 
      self._iprot.readMessageEnd()
5920 
      raise x
5921 
    result = getOrdersCollectionAtStore_result()
5922 
    result.read(self._iprot)
5923 
    self._iprot.readMessageEnd()
5924 
    if result.success is not None:
5925 
      return result.success
5926 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersCollectionAtStore failed: unknown result");
5927 
 
5833 rajveer 5928 
  def getOrderAttributeValue(self, orderId, attributeName):
5929 
    """
5930 
    Parameters:
5931 
     - orderId
5932 
     - attributeName
5933 
    """
5934 
    self.send_getOrderAttributeValue(orderId, attributeName)
5935 
    return self.recv_getOrderAttributeValue()
5936 
 
5937 
  def send_getOrderAttributeValue(self, orderId, attributeName):
5938 
    self._oprot.writeMessageBegin('getOrderAttributeValue', TMessageType.CALL, self._seqid)
5939 
    args = getOrderAttributeValue_args()
5940 
    args.orderId = orderId
5941 
    args.attributeName = attributeName
5942 
    args.write(self._oprot)
5943 
    self._oprot.writeMessageEnd()
5944 
    self._oprot.trans.flush()
5945 
 
5946 
  def recv_getOrderAttributeValue(self, ):
5947 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5948 
    if mtype == TMessageType.EXCEPTION:
5949 
      x = TApplicationException()
5950 
      x.read(self._iprot)
5951 
      self._iprot.readMessageEnd()
5952 
      raise x
5953 
    result = getOrderAttributeValue_result()
5954 
    result.read(self._iprot)
5955 
    self._iprot.readMessageEnd()
5956 
    if result.success is not None:
5957 
      return result.success
5958 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderAttributeValue failed: unknown result");
5959 
 
6019 rajveer 5960 
  def changeJacketNumber(self, orderId, jacketNumber):
5961 
    """
5962 
    Parameters:
5963 
     - orderId
5964 
     - jacketNumber
5965 
    """
5966 
    self.send_changeJacketNumber(orderId, jacketNumber)
5967 
    return self.recv_changeJacketNumber()
5968 
 
5969 
  def send_changeJacketNumber(self, orderId, jacketNumber):
5970 
    self._oprot.writeMessageBegin('changeJacketNumber', TMessageType.CALL, self._seqid)
5971 
    args = changeJacketNumber_args()
5972 
    args.orderId = orderId
5973 
    args.jacketNumber = jacketNumber
5974 
    args.write(self._oprot)
5975 
    self._oprot.writeMessageEnd()
5976 
    self._oprot.trans.flush()
5977 
 
5978 
  def recv_changeJacketNumber(self, ):
5979 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5980 
    if mtype == TMessageType.EXCEPTION:
5981 
      x = TApplicationException()
5982 
      x.read(self._iprot)
5983 
      self._iprot.readMessageEnd()
5984 
      raise x
5985 
    result = changeJacketNumber_result()
5986 
    result.read(self._iprot)
5987 
    self._iprot.readMessageEnd()
5988 
    if result.success is not None:
5989 
      return result.success
5990 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "changeJacketNumber failed: unknown result");
5991 
 
5992 
  def markOrderAsRtoInTransit(self, orderId):
5993 
    """
5994 
    Parameters:
5995 
     - orderId
5996 
    """
5997 
    self.send_markOrderAsRtoInTransit(orderId)
5998 
    return self.recv_markOrderAsRtoInTransit()
5999 
 
6000 
  def send_markOrderAsRtoInTransit(self, orderId):
6001 
    self._oprot.writeMessageBegin('markOrderAsRtoInTransit', TMessageType.CALL, self._seqid)
6002 
    args = markOrderAsRtoInTransit_args()
6003 
    args.orderId = orderId
6004 
    args.write(self._oprot)
6005 
    self._oprot.writeMessageEnd()
6006 
    self._oprot.trans.flush()
6007 
 
6008 
  def recv_markOrderAsRtoInTransit(self, ):
6009 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6010 
    if mtype == TMessageType.EXCEPTION:
6011 
      x = TApplicationException()
6012 
      x.read(self._iprot)
6013 
      self._iprot.readMessageEnd()
6014 
      raise x
6015 
    result = markOrderAsRtoInTransit_result()
6016 
    result.read(self._iprot)
6017 
    self._iprot.readMessageEnd()
6018 
    if result.success is not None:
6019 
      return result.success
6020 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderAsRtoInTransit failed: unknown result");
6021 
 
5593 mandeep.dh 6022 
  def acceptOrderForItem(self, itemId, quantity, fulfilmentWarehouseId, billingWarehouseId):
6023 
    """
6024 
    Accepts appropriate order for an item in a given billingWarehouse. Usually
6025 
    invoked while scanning IN of items.
5553 rajveer 6026 
 
5593 mandeep.dh 6027 
    Parameters:
6028 
     - itemId
6029 
     - quantity
6030 
     - fulfilmentWarehouseId
6031 
     - billingWarehouseId
6032 
    """
6033 
    self.send_acceptOrderForItem(itemId, quantity, fulfilmentWarehouseId, billingWarehouseId)
6034 
    self.recv_acceptOrderForItem()
6035 
 
6036 
  def send_acceptOrderForItem(self, itemId, quantity, fulfilmentWarehouseId, billingWarehouseId):
6037 
    self._oprot.writeMessageBegin('acceptOrderForItem', TMessageType.CALL, self._seqid)
6038 
    args = acceptOrderForItem_args()
6039 
    args.itemId = itemId
6040 
    args.quantity = quantity
6041 
    args.fulfilmentWarehouseId = fulfilmentWarehouseId
6042 
    args.billingWarehouseId = billingWarehouseId
6043 
    args.write(self._oprot)
6044 
    self._oprot.writeMessageEnd()
6045 
    self._oprot.trans.flush()
6046 
 
6047 
  def recv_acceptOrderForItem(self, ):
6048 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6049 
    if mtype == TMessageType.EXCEPTION:
6050 
      x = TApplicationException()
6051 
      x.read(self._iprot)
6052 
      self._iprot.readMessageEnd()
6053 
      raise x
6054 
    result = acceptOrderForItem_result()
6055 
    result.read(self._iprot)
6056 
    self._iprot.readMessageEnd()
6057 
    return
6058 
 
6000 mandeep.dh 6059 
  def createRechargeOrder(self, rechargeOrder):
6060 
    """
6061 
    Parameters:
6062 
     - rechargeOrder
6063 
    """
6064 
    self.send_createRechargeOrder(rechargeOrder)
6065 
    return self.recv_createRechargeOrder()
5593 mandeep.dh 6066 
 
6000 mandeep.dh 6067 
  def send_createRechargeOrder(self, rechargeOrder):
6068 
    self._oprot.writeMessageBegin('createRechargeOrder', TMessageType.CALL, self._seqid)
6069 
    args = createRechargeOrder_args()
6070 
    args.rechargeOrder = rechargeOrder
6071 
    args.write(self._oprot)
6072 
    self._oprot.writeMessageEnd()
6073 
    self._oprot.trans.flush()
6074 
 
6075 
  def recv_createRechargeOrder(self, ):
6076 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6077 
    if mtype == TMessageType.EXCEPTION:
6078 
      x = TApplicationException()
6079 
      x.read(self._iprot)
6080 
      self._iprot.readMessageEnd()
6081 
      raise x
6082 
    result = createRechargeOrder_result()
6083 
    result.read(self._iprot)
6084 
    self._iprot.readMessageEnd()
6085 
    if result.success is not None:
6086 
      return result.success
6087 
    if result.ex is not None:
6088 
      raise result.ex
6089 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createRechargeOrder failed: unknown result");
6090 
 
6031 rajveer 6091 
  def getRechargeOrder(self, rechargeRrderId):
6092 
    """
6093 
    Parameters:
6094 
     - rechargeRrderId
6095 
    """
6096 
    self.send_getRechargeOrder(rechargeRrderId)
6097 
    return self.recv_getRechargeOrder()
6098 
 
6099 
  def send_getRechargeOrder(self, rechargeRrderId):
6100 
    self._oprot.writeMessageBegin('getRechargeOrder', TMessageType.CALL, self._seqid)
6101 
    args = getRechargeOrder_args()
6102 
    args.rechargeRrderId = rechargeRrderId
6103 
    args.write(self._oprot)
6104 
    self._oprot.writeMessageEnd()
6105 
    self._oprot.trans.flush()
6106 
 
6107 
  def recv_getRechargeOrder(self, ):
6108 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6109 
    if mtype == TMessageType.EXCEPTION:
6110 
      x = TApplicationException()
6111 
      x.read(self._iprot)
6112 
      self._iprot.readMessageEnd()
6113 
      raise x
6114 
    result = getRechargeOrder_result()
6115 
    result.read(self._iprot)
6116 
    self._iprot.readMessageEnd()
6117 
    if result.success is not None:
6118 
      return result.success
6119 
    if result.ex is not None:
6120 
      raise result.ex
6121 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getRechargeOrder failed: unknown result");
6122 
 
6123 
  def getRechargeOrders(self, userId):
6124 
    """
6125 
    Parameters:
6126 
     - userId
6127 
    """
6128 
    self.send_getRechargeOrders(userId)
6129 
    return self.recv_getRechargeOrders()
6130 
 
6131 
  def send_getRechargeOrders(self, userId):
6132 
    self._oprot.writeMessageBegin('getRechargeOrders', TMessageType.CALL, self._seqid)
6133 
    args = getRechargeOrders_args()
6134 
    args.userId = userId
6135 
    args.write(self._oprot)
6136 
    self._oprot.writeMessageEnd()
6137 
    self._oprot.trans.flush()
6138 
 
6139 
  def recv_getRechargeOrders(self, ):
6140 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6141 
    if mtype == TMessageType.EXCEPTION:
6142 
      x = TApplicationException()
6143 
      x.read(self._iprot)
6144 
      self._iprot.readMessageEnd()
6145 
      raise x
6146 
    result = getRechargeOrders_result()
6147 
    result.read(self._iprot)
6148 
    self._iprot.readMessageEnd()
6149 
    if result.success is not None:
6150 
      return result.success
6151 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getRechargeOrders failed: unknown result");
6152 
 
6000 mandeep.dh 6153 
  def updateRechargeOrderStatus(self, rechargeOrderId, rechargeOrderStatus):
6154 
    """
6155 
    Parameters:
6156 
     - rechargeOrderId
6157 
     - rechargeOrderStatus
6158 
    """
6159 
    self.send_updateRechargeOrderStatus(rechargeOrderId, rechargeOrderStatus)
6031 rajveer 6160 
    return self.recv_updateRechargeOrderStatus()
6000 mandeep.dh 6161 
 
6162 
  def send_updateRechargeOrderStatus(self, rechargeOrderId, rechargeOrderStatus):
6163 
    self._oprot.writeMessageBegin('updateRechargeOrderStatus', TMessageType.CALL, self._seqid)
6164 
    args = updateRechargeOrderStatus_args()
6165 
    args.rechargeOrderId = rechargeOrderId
6166 
    args.rechargeOrderStatus = rechargeOrderStatus
6167 
    args.write(self._oprot)
6168 
    self._oprot.writeMessageEnd()
6169 
    self._oprot.trans.flush()
6170 
 
6171 
  def recv_updateRechargeOrderStatus(self, ):
6172 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6173 
    if mtype == TMessageType.EXCEPTION:
6174 
      x = TApplicationException()
6175 
      x.read(self._iprot)
6176 
      self._iprot.readMessageEnd()
6177 
      raise x
6178 
    result = updateRechargeOrderStatus_result()
6179 
    result.read(self._iprot)
6180 
    self._iprot.readMessageEnd()
6031 rajveer 6181 
    if result.success is not None:
6182 
      return result.success
6000 mandeep.dh 6183 
    if result.ex is not None:
6184 
      raise result.ex
6031 rajveer 6185 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updateRechargeOrderStatus failed: unknown result");
6000 mandeep.dh 6186 
 
6031 rajveer 6187 
  def activateRechargeTxn(self, rechargeOrderId):
6000 mandeep.dh 6188 
    """
6189 
    Parameters:
6031 rajveer 6190 
     - rechargeOrderId
6000 mandeep.dh 6191 
    """
6031 rajveer 6192 
    self.send_activateRechargeTxn(rechargeOrderId)
6000 mandeep.dh 6193 
    return self.recv_activateRechargeTxn()
6194 
 
6031 rajveer 6195 
  def send_activateRechargeTxn(self, rechargeOrderId):
6000 mandeep.dh 6196 
    self._oprot.writeMessageBegin('activateRechargeTxn', TMessageType.CALL, self._seqid)
6197 
    args = activateRechargeTxn_args()
6031 rajveer 6198 
    args.rechargeOrderId = rechargeOrderId
6000 mandeep.dh 6199 
    args.write(self._oprot)
6200 
    self._oprot.writeMessageEnd()
6201 
    self._oprot.trans.flush()
6202 
 
6203 
  def recv_activateRechargeTxn(self, ):
6204 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6205 
    if mtype == TMessageType.EXCEPTION:
6206 
      x = TApplicationException()
6207 
      x.read(self._iprot)
6208 
      self._iprot.readMessageEnd()
6209 
      raise x
6210 
    result = activateRechargeTxn_result()
6211 
    result.read(self._iprot)
6212 
    self._iprot.readMessageEnd()
6213 
    if result.success is not None:
6214 
      return result.success
6215 
    if result.ex is not None:
6216 
      raise result.ex
6217 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "activateRechargeTxn failed: unknown result");
6218 
 
6031 rajveer 6219 
  def getUserWallet(self, userId):
6000 mandeep.dh 6220 
    """
6221 
    Parameters:
6031 rajveer 6222 
     - userId
6000 mandeep.dh 6223 
    """
6031 rajveer 6224 
    self.send_getUserWallet(userId)
6225 
    return self.recv_getUserWallet()
6000 mandeep.dh 6226 
 
6031 rajveer 6227 
  def send_getUserWallet(self, userId):
6228 
    self._oprot.writeMessageBegin('getUserWallet', TMessageType.CALL, self._seqid)
6229 
    args = getUserWallet_args()
6230 
    args.userId = userId
6000 mandeep.dh 6231 
    args.write(self._oprot)
6232 
    self._oprot.writeMessageEnd()
6233 
    self._oprot.trans.flush()
6234 
 
6031 rajveer 6235 
  def recv_getUserWallet(self, ):
6000 mandeep.dh 6236 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6237 
    if mtype == TMessageType.EXCEPTION:
6238 
      x = TApplicationException()
6239 
      x.read(self._iprot)
6240 
      self._iprot.readMessageEnd()
6241 
      raise x
6031 rajveer 6242 
    result = getUserWallet_result()
6000 mandeep.dh 6243 
    result.read(self._iprot)
6244 
    self._iprot.readMessageEnd()
6245 
    if result.success is not None:
6246 
      return result.success
6031 rajveer 6247 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUserWallet failed: unknown result");
6000 mandeep.dh 6248 
 
6031 rajveer 6249 
  def getUserWalletHistory(self, userId):
6000 mandeep.dh 6250 
    """
6251 
    Parameters:
6031 rajveer 6252 
     - userId
6000 mandeep.dh 6253 
    """
6031 rajveer 6254 
    self.send_getUserWalletHistory(userId)
6255 
    return self.recv_getUserWalletHistory()
6000 mandeep.dh 6256 
 
6031 rajveer 6257 
  def send_getUserWalletHistory(self, userId):
6258 
    self._oprot.writeMessageBegin('getUserWalletHistory', TMessageType.CALL, self._seqid)
6259 
    args = getUserWalletHistory_args()
6260 
    args.userId = userId
6000 mandeep.dh 6261 
    args.write(self._oprot)
6262 
    self._oprot.writeMessageEnd()
6263 
    self._oprot.trans.flush()
6264 
 
6031 rajveer 6265 
  def recv_getUserWalletHistory(self, ):
6000 mandeep.dh 6266 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6267 
    if mtype == TMessageType.EXCEPTION:
6268 
      x = TApplicationException()
6269 
      x.read(self._iprot)
6270 
      self._iprot.readMessageEnd()
6271 
      raise x
6031 rajveer 6272 
    result = getUserWalletHistory_result()
6000 mandeep.dh 6273 
    result.read(self._iprot)
6274 
    self._iprot.readMessageEnd()
6275 
    if result.success is not None:
6276 
      return result.success
6031 rajveer 6277 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUserWalletHistory failed: unknown result");
6000 mandeep.dh 6278 
 
6050 anupam.sin 6279 
  def getRechargeOrdersForTransaction(self, txnId):
6280 
    """
6281 
    Returns a recharge order for a given transactionId
6282 
 
6283 
    Parameters:
6284 
     - txnId
6285 
    """
6286 
    self.send_getRechargeOrdersForTransaction(txnId)
6287 
    return self.recv_getRechargeOrdersForTransaction()
6288 
 
6289 
  def send_getRechargeOrdersForTransaction(self, txnId):
6290 
    self._oprot.writeMessageBegin('getRechargeOrdersForTransaction', TMessageType.CALL, self._seqid)
6291 
    args = getRechargeOrdersForTransaction_args()
6292 
    args.txnId = txnId
6293 
    args.write(self._oprot)
6294 
    self._oprot.writeMessageEnd()
6295 
    self._oprot.trans.flush()
6296 
 
6297 
  def recv_getRechargeOrdersForTransaction(self, ):
6298 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6299 
    if mtype == TMessageType.EXCEPTION:
6300 
      x = TApplicationException()
6301 
      x.read(self._iprot)
6302 
      self._iprot.readMessageEnd()
6303 
      raise x
6304 
    result = getRechargeOrdersForTransaction_result()
6305 
    result.read(self._iprot)
6306 
    self._iprot.readMessageEnd()
6307 
    if result.success is not None:
6308 
      return result.success
6309 
    if result.ex is not None:
6310 
      raise result.ex
6311 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getRechargeOrdersForTransaction failed: unknown result");
6312 
 
6206 rajveer 6313 
  def getServiceProviders(self, rechargeType, onlyActive):
6048 rajveer 6314 
    """
6315 
    Parameters:
6316 
     - rechargeType
6206 rajveer 6317 
     - onlyActive
6048 rajveer 6318 
    """
6206 rajveer 6319 
    self.send_getServiceProviders(rechargeType, onlyActive)
6048 rajveer 6320 
    return self.recv_getServiceProviders()
6000 mandeep.dh 6321 
 
6206 rajveer 6322 
  def send_getServiceProviders(self, rechargeType, onlyActive):
6048 rajveer 6323 
    self._oprot.writeMessageBegin('getServiceProviders', TMessageType.CALL, self._seqid)
6324 
    args = getServiceProviders_args()
6325 
    args.rechargeType = rechargeType
6206 rajveer 6326 
    args.onlyActive = onlyActive
6048 rajveer 6327 
    args.write(self._oprot)
6328 
    self._oprot.writeMessageEnd()
6329 
    self._oprot.trans.flush()
6330 
 
6331 
  def recv_getServiceProviders(self, ):
6332 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6333 
    if mtype == TMessageType.EXCEPTION:
6334 
      x = TApplicationException()
6335 
      x.read(self._iprot)
6336 
      self._iprot.readMessageEnd()
6337 
      raise x
6338 
    result = getServiceProviders_result()
6339 
    result.read(self._iprot)
6340 
    self._iprot.readMessageEnd()
6341 
    if result.success is not None:
6342 
      return result.success
6343 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getServiceProviders failed: unknown result");
6344 
 
6049 rajveer 6345 
  def getServiceProviderForDevice(self, rechargeType, deviceNumber):
6048 rajveer 6346 
    """
6347 
    Parameters:
6049 rajveer 6348 
     - rechargeType
6048 rajveer 6349 
     - deviceNumber
6350 
    """
6049 rajveer 6351 
    self.send_getServiceProviderForDevice(rechargeType, deviceNumber)
6048 rajveer 6352 
    return self.recv_getServiceProviderForDevice()
6353 
 
6049 rajveer 6354 
  def send_getServiceProviderForDevice(self, rechargeType, deviceNumber):
6048 rajveer 6355 
    self._oprot.writeMessageBegin('getServiceProviderForDevice', TMessageType.CALL, self._seqid)
6356 
    args = getServiceProviderForDevice_args()
6049 rajveer 6357 
    args.rechargeType = rechargeType
6048 rajveer 6358 
    args.deviceNumber = deviceNumber
6359 
    args.write(self._oprot)
6360 
    self._oprot.writeMessageEnd()
6361 
    self._oprot.trans.flush()
6362 
 
6363 
  def recv_getServiceProviderForDevice(self, ):
6364 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6365 
    if mtype == TMessageType.EXCEPTION:
6366 
      x = TApplicationException()
6367 
      x.read(self._iprot)
6368 
      self._iprot.readMessageEnd()
6369 
      raise x
6370 
    result = getServiceProviderForDevice_result()
6371 
    result.read(self._iprot)
6372 
    self._iprot.readMessageEnd()
6373 
    if result.success is not None:
6374 
      return result.success
6375 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getServiceProviderForDevice failed: unknown result");
6376 
 
6591 anupam.sin 6377 
  def validateRecharge(self, rechargeType, deviceNumber, userSelectedProviderId, clientAddress):
6269 rajveer 6378 
    """
6379 
    Parameters:
6380 
     - rechargeType
6381 
     - deviceNumber
6307 anupam.sin 6382 
     - userSelectedProviderId
6591 anupam.sin 6383 
     - clientAddress
6269 rajveer 6384 
    """
6591 anupam.sin 6385 
    self.send_validateRecharge(rechargeType, deviceNumber, userSelectedProviderId, clientAddress)
6269 rajveer 6386 
    return self.recv_validateRecharge()
6387 
 
6591 anupam.sin 6388 
  def send_validateRecharge(self, rechargeType, deviceNumber, userSelectedProviderId, clientAddress):
6269 rajveer 6389 
    self._oprot.writeMessageBegin('validateRecharge', TMessageType.CALL, self._seqid)
6390 
    args = validateRecharge_args()
6391 
    args.rechargeType = rechargeType
6392 
    args.deviceNumber = deviceNumber
6307 anupam.sin 6393 
    args.userSelectedProviderId = userSelectedProviderId
6591 anupam.sin 6394 
    args.clientAddress = clientAddress
6269 rajveer 6395 
    args.write(self._oprot)
6396 
    self._oprot.writeMessageEnd()
6397 
    self._oprot.trans.flush()
6398 
 
6399 
  def recv_validateRecharge(self, ):
6400 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6401 
    if mtype == TMessageType.EXCEPTION:
6402 
      x = TApplicationException()
6403 
      x.read(self._iprot)
6404 
      self._iprot.readMessageEnd()
6405 
      raise x
6406 
    result = validateRecharge_result()
6407 
    result.read(self._iprot)
6408 
    self._iprot.readMessageEnd()
6409 
    if result.success is not None:
6410 
      return result.success
6411 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "validateRecharge failed: unknown result");
6412 
 
6094 rajveer 6413 
  def getRechargeOrdersForDevice(self, deviceNumber):
6414 
    """
6415 
    Parameters:
6416 
     - deviceNumber
6417 
    """
6418 
    self.send_getRechargeOrdersForDevice(deviceNumber)
6419 
    return self.recv_getRechargeOrdersForDevice()
6048 rajveer 6420 
 
6094 rajveer 6421 
  def send_getRechargeOrdersForDevice(self, deviceNumber):
6422 
    self._oprot.writeMessageBegin('getRechargeOrdersForDevice', TMessageType.CALL, self._seqid)
6423 
    args = getRechargeOrdersForDevice_args()
6424 
    args.deviceNumber = deviceNumber
6425 
    args.write(self._oprot)
6426 
    self._oprot.writeMessageEnd()
6427 
    self._oprot.trans.flush()
6428 
 
6429 
  def recv_getRechargeOrdersForDevice(self, ):
6430 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6431 
    if mtype == TMessageType.EXCEPTION:
6432 
      x = TApplicationException()
6433 
      x.read(self._iprot)
6434 
      self._iprot.readMessageEnd()
6435 
      raise x
6436 
    result = getRechargeOrdersForDevice_result()
6437 
    result.read(self._iprot)
6438 
    self._iprot.readMessageEnd()
6439 
    if result.success is not None:
6440 
      return result.success
6441 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getRechargeOrdersForDevice failed: unknown result");
6442 
 
6443 
  def addAmountToWallet(self, userId, orderId, amount):
6444 
    """
6445 
    Parameters:
6446 
     - userId
6447 
     - orderId
6448 
     - amount
6449 
    """
6450 
    self.send_addAmountToWallet(userId, orderId, amount)
6451 
    self.recv_addAmountToWallet()
6452 
 
6453 
  def send_addAmountToWallet(self, userId, orderId, amount):
6454 
    self._oprot.writeMessageBegin('addAmountToWallet', TMessageType.CALL, self._seqid)
6455 
    args = addAmountToWallet_args()
6456 
    args.userId = userId
6457 
    args.orderId = orderId
6458 
    args.amount = amount
6459 
    args.write(self._oprot)
6460 
    self._oprot.writeMessageEnd()
6461 
    self._oprot.trans.flush()
6462 
 
6463 
  def recv_addAmountToWallet(self, ):
6464 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6465 
    if mtype == TMessageType.EXCEPTION:
6466 
      x = TApplicationException()
6467 
      x.read(self._iprot)
6468 
      self._iprot.readMessageEnd()
6469 
      raise x
6470 
    result = addAmountToWallet_result()
6471 
    result.read(self._iprot)
6472 
    self._iprot.readMessageEnd()
6473 
    return
6474 
 
6188 rajveer 6475 
  def getRechargeStatistics(self, ):
6476 
    self.send_getRechargeStatistics()
6477 
    return self.recv_getRechargeStatistics()
6478 
 
6479 
  def send_getRechargeStatistics(self, ):
6480 
    self._oprot.writeMessageBegin('getRechargeStatistics', TMessageType.CALL, self._seqid)
6481 
    args = getRechargeStatistics_args()
6482 
    args.write(self._oprot)
6483 
    self._oprot.writeMessageEnd()
6484 
    self._oprot.trans.flush()
6485 
 
6486 
  def recv_getRechargeStatistics(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 = getRechargeStatistics_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, "getRechargeStatistics failed: unknown result");
6499 
 
6154 rajveer 6500 
  def getRechargeOrdersForStatus(self, status):
6501 
    """
6502 
    Parameters:
6503 
     - status
6504 
    """
6505 
    self.send_getRechargeOrdersForStatus(status)
6506 
    return self.recv_getRechargeOrdersForStatus()
6094 rajveer 6507 
 
6154 rajveer 6508 
  def send_getRechargeOrdersForStatus(self, status):
6509 
    self._oprot.writeMessageBegin('getRechargeOrdersForStatus', TMessageType.CALL, self._seqid)
6510 
    args = getRechargeOrdersForStatus_args()
6511 
    args.status = status
6512 
    args.write(self._oprot)
6513 
    self._oprot.writeMessageEnd()
6514 
    self._oprot.trans.flush()
6515 
 
6516 
  def recv_getRechargeOrdersForStatus(self, ):
6517 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6518 
    if mtype == TMessageType.EXCEPTION:
6519 
      x = TApplicationException()
6520 
      x.read(self._iprot)
6521 
      self._iprot.readMessageEnd()
6522 
      raise x
6523 
    result = getRechargeOrdersForStatus_result()
6524 
    result.read(self._iprot)
6525 
    self._iprot.readMessageEnd()
6526 
    if result.success is not None:
6527 
      return result.success
6528 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getRechargeOrdersForStatus failed: unknown result");
6529 
 
6159 rajveer 6530 
  def getPlansForOperator(self, operatorId):
6531 
    """
6532 
    Parameters:
6533 
     - operatorId
6534 
    """
6535 
    self.send_getPlansForOperator(operatorId)
6536 
    return self.recv_getPlansForOperator()
6154 rajveer 6537 
 
6159 rajveer 6538 
  def send_getPlansForOperator(self, operatorId):
6539 
    self._oprot.writeMessageBegin('getPlansForOperator', TMessageType.CALL, self._seqid)
6540 
    args = getPlansForOperator_args()
6541 
    args.operatorId = operatorId
6542 
    args.write(self._oprot)
6543 
    self._oprot.writeMessageEnd()
6544 
    self._oprot.trans.flush()
6545 
 
6546 
  def recv_getPlansForOperator(self, ):
6547 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6548 
    if mtype == TMessageType.EXCEPTION:
6549 
      x = TApplicationException()
6550 
      x.read(self._iprot)
6551 
      self._iprot.readMessageEnd()
6552 
      raise x
6553 
    result = getPlansForOperator_result()
6554 
    result.read(self._iprot)
6555 
    self._iprot.readMessageEnd()
6556 
    if result.success is not None:
6557 
      return result.success
6558 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getPlansForOperator failed: unknown result");
6559 
 
6307 anupam.sin 6560 
  def getRechargeDenominations(self, operatorId, circleCode, denominationType):
6289 anupam.sin 6561 
    """
6562 
    Returns denominations for a given operator and circle
6159 rajveer 6563 
 
6289 anupam.sin 6564 
    Parameters:
6565 
     - operatorId
6307 anupam.sin 6566 
     - circleCode
6289 anupam.sin 6567 
     - denominationType
6568 
    """
6307 anupam.sin 6569 
    self.send_getRechargeDenominations(operatorId, circleCode, denominationType)
6289 anupam.sin 6570 
    return self.recv_getRechargeDenominations()
6571 
 
6307 anupam.sin 6572 
  def send_getRechargeDenominations(self, operatorId, circleCode, denominationType):
6289 anupam.sin 6573 
    self._oprot.writeMessageBegin('getRechargeDenominations', TMessageType.CALL, self._seqid)
6574 
    args = getRechargeDenominations_args()
6575 
    args.operatorId = operatorId
6307 anupam.sin 6576 
    args.circleCode = circleCode
6289 anupam.sin 6577 
    args.denominationType = denominationType
6578 
    args.write(self._oprot)
6579 
    self._oprot.writeMessageEnd()
6580 
    self._oprot.trans.flush()
6581 
 
6582 
  def recv_getRechargeDenominations(self, ):
6583 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6584 
    if mtype == TMessageType.EXCEPTION:
6585 
      x = TApplicationException()
6586 
      x.read(self._iprot)
6587 
      self._iprot.readMessageEnd()
6588 
      raise x
6589 
    result = getRechargeDenominations_result()
6590 
    result.read(self._iprot)
6591 
    self._iprot.readMessageEnd()
6592 
    if result.success is not None:
6593 
      return result.success
6594 
    if result.ex is not None:
6595 
      raise result.ex
6596 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getRechargeDenominations failed: unknown result");
6597 
 
6371 rajveer 6598 
  def updateAvailabilityStatus(self, operatorId, circleId, isAvailable):
6599 
    """
6600 
    Parameters:
6601 
     - operatorId
6602 
     - circleId
6603 
     - isAvailable
6604 
    """
6605 
    self.send_updateAvailabilityStatus(operatorId, circleId, isAvailable)
6606 
    self.recv_updateAvailabilityStatus()
6289 anupam.sin 6607 
 
6371 rajveer 6608 
  def send_updateAvailabilityStatus(self, operatorId, circleId, isAvailable):
6609 
    self._oprot.writeMessageBegin('updateAvailabilityStatus', TMessageType.CALL, self._seqid)
6610 
    args = updateAvailabilityStatus_args()
6611 
    args.operatorId = operatorId
6612 
    args.circleId = circleId
6613 
    args.isAvailable = isAvailable
6614 
    args.write(self._oprot)
6615 
    self._oprot.writeMessageEnd()
6616 
    self._oprot.trans.flush()
6617 
 
6618 
  def recv_updateAvailabilityStatus(self, ):
6619 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6620 
    if mtype == TMessageType.EXCEPTION:
6621 
      x = TApplicationException()
6622 
      x.read(self._iprot)
6623 
      self._iprot.readMessageEnd()
6624 
      raise x
6625 
    result = updateAvailabilityStatus_result()
6626 
    result.read(self._iprot)
6627 
    self._iprot.readMessageEnd()
6628 
    return
6629 
 
6389 rajveer 6630 
  def getAvailableEmiSchemes(self, ):
6631 
    self.send_getAvailableEmiSchemes()
6632 
    return self.recv_getAvailableEmiSchemes()
6371 rajveer 6633 
 
6389 rajveer 6634 
  def send_getAvailableEmiSchemes(self, ):
6635 
    self._oprot.writeMessageBegin('getAvailableEmiSchemes', TMessageType.CALL, self._seqid)
6636 
    args = getAvailableEmiSchemes_args()
6637 
    args.write(self._oprot)
6638 
    self._oprot.writeMessageEnd()
6639 
    self._oprot.trans.flush()
6640 
 
6641 
  def recv_getAvailableEmiSchemes(self, ):
6642 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6643 
    if mtype == TMessageType.EXCEPTION:
6644 
      x = TApplicationException()
6645 
      x.read(self._iprot)
6646 
      self._iprot.readMessageEnd()
6647 
      raise x
6648 
    result = getAvailableEmiSchemes_result()
6649 
    result.read(self._iprot)
6650 
    self._iprot.readMessageEnd()
6651 
    if result.success is not None:
6652 
      return result.success
6653 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAvailableEmiSchemes failed: unknown result");
6654 
 
6655 
  def getMiscCharges(self, transactionId):
6656 
    """
6657 
    Parameters:
6658 
     - transactionId
6659 
    """
6660 
    self.send_getMiscCharges(transactionId)
6661 
    return self.recv_getMiscCharges()
6662 
 
6663 
  def send_getMiscCharges(self, transactionId):
6664 
    self._oprot.writeMessageBegin('getMiscCharges', TMessageType.CALL, self._seqid)
6665 
    args = getMiscCharges_args()
6666 
    args.transactionId = transactionId
6667 
    args.write(self._oprot)
6668 
    self._oprot.writeMessageEnd()
6669 
    self._oprot.trans.flush()
6670 
 
6671 
  def recv_getMiscCharges(self, ):
6672 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6673 
    if mtype == TMessageType.EXCEPTION:
6674 
      x = TApplicationException()
6675 
      x.read(self._iprot)
6676 
      self._iprot.readMessageEnd()
6677 
      raise x
6678 
    result = getMiscCharges_result()
6679 
    result.read(self._iprot)
6680 
    self._iprot.readMessageEnd()
6681 
    if result.success is not None:
6682 
      return result.success
6683 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getMiscCharges failed: unknown result");
6684 
 
6507 anupam.sin 6685 
  def refundRechargeOrder(self, rechargeOrderId):
6686 
    """
6687 
    Parameters:
6688 
     - rechargeOrderId
6689 
    """
6690 
    self.send_refundRechargeOrder(rechargeOrderId)
6691 
    return self.recv_refundRechargeOrder()
6389 rajveer 6692 
 
6507 anupam.sin 6693 
  def send_refundRechargeOrder(self, rechargeOrderId):
6694 
    self._oprot.writeMessageBegin('refundRechargeOrder', TMessageType.CALL, self._seqid)
6695 
    args = refundRechargeOrder_args()
6696 
    args.rechargeOrderId = rechargeOrderId
6697 
    args.write(self._oprot)
6698 
    self._oprot.writeMessageEnd()
6699 
    self._oprot.trans.flush()
6700 
 
6701 
  def recv_refundRechargeOrder(self, ):
6702 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6703 
    if mtype == TMessageType.EXCEPTION:
6704 
      x = TApplicationException()
6705 
      x.read(self._iprot)
6706 
      self._iprot.readMessageEnd()
6707 
      raise x
6708 
    result = refundRechargeOrder_result()
6709 
    result.read(self._iprot)
6710 
    self._iprot.readMessageEnd()
6711 
    if result.success is not None:
6712 
      return result.success
6713 
    if result.ex is not None:
6714 
      raise result.ex
6715 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "refundRechargeOrder failed: unknown result");
6716 
 
6821 amar.kumar 6717 
  def getPhysicalOrders(self, fromDate, toDate):
6718 
    """
6719 
    Parameters:
6720 
     - fromDate
6721 
     - toDate
6722 
    """
6723 
    self.send_getPhysicalOrders(fromDate, toDate)
6724 
    return self.recv_getPhysicalOrders()
6507 anupam.sin 6725 
 
6821 amar.kumar 6726 
  def send_getPhysicalOrders(self, fromDate, toDate):
6727 
    self._oprot.writeMessageBegin('getPhysicalOrders', TMessageType.CALL, self._seqid)
6728 
    args = getPhysicalOrders_args()
6729 
    args.fromDate = fromDate
6730 
    args.toDate = toDate
6731 
    args.write(self._oprot)
6732 
    self._oprot.writeMessageEnd()
6733 
    self._oprot.trans.flush()
6734 
 
6735 
  def recv_getPhysicalOrders(self, ):
6736 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6737 
    if mtype == TMessageType.EXCEPTION:
6738 
      x = TApplicationException()
6739 
      x.read(self._iprot)
6740 
      self._iprot.readMessageEnd()
6741 
      raise x
6742 
    result = getPhysicalOrders_result()
6743 
    result.read(self._iprot)
6744 
    self._iprot.readMessageEnd()
6745 
    if result.success is not None:
6746 
      return result.success
6747 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getPhysicalOrders failed: unknown result");
6748 
 
6906 rajveer 6749 
  def getDocument(self, docType, docSource):
6750 
    """
6751 
    Parameters:
6752 
     - docType
6753 
     - docSource
6754 
    """
6755 
    self.send_getDocument(docType, docSource)
6756 
    return self.recv_getDocument()
6821 amar.kumar 6757 
 
6906 rajveer 6758 
  def send_getDocument(self, docType, docSource):
6759 
    self._oprot.writeMessageBegin('getDocument', TMessageType.CALL, self._seqid)
6760 
    args = getDocument_args()
6761 
    args.docType = docType
6762 
    args.docSource = docSource
6763 
    args.write(self._oprot)
6764 
    self._oprot.writeMessageEnd()
6765 
    self._oprot.trans.flush()
6766 
 
6767 
  def recv_getDocument(self, ):
6768 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6769 
    if mtype == TMessageType.EXCEPTION:
6770 
      x = TApplicationException()
6771 
      x.read(self._iprot)
6772 
      self._iprot.readMessageEnd()
6773 
      raise x
6774 
    result = getDocument_result()
6775 
    result.read(self._iprot)
6776 
    self._iprot.readMessageEnd()
6777 
    if result.success is not None:
6778 
      return result.success
6779 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getDocument failed: unknown result");
6780 
 
6985 anupam.sin 6781 
  def changeShippingAddress(self, orderId, line1, line2, city, state, pin):
6782 
    """
6783 
    Parameters:
6784 
     - orderId
6785 
     - line1
6786 
     - line2
6787 
     - city
6788 
     - state
6789 
     - pin
6790 
    """
6791 
    self.send_changeShippingAddress(orderId, line1, line2, city, state, pin)
6792 
    return self.recv_changeShippingAddress()
6906 rajveer 6793 
 
6985 anupam.sin 6794 
  def send_changeShippingAddress(self, orderId, line1, line2, city, state, pin):
6795 
    self._oprot.writeMessageBegin('changeShippingAddress', TMessageType.CALL, self._seqid)
6796 
    args = changeShippingAddress_args()
6797 
    args.orderId = orderId
6798 
    args.line1 = line1
6799 
    args.line2 = line2
6800 
    args.city = city
6801 
    args.state = state
6802 
    args.pin = pin
6803 
    args.write(self._oprot)
6804 
    self._oprot.writeMessageEnd()
6805 
    self._oprot.trans.flush()
6806 
 
6807 
  def recv_changeShippingAddress(self, ):
6808 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6809 
    if mtype == TMessageType.EXCEPTION:
6810 
      x = TApplicationException()
6811 
      x.read(self._iprot)
6812 
      self._iprot.readMessageEnd()
6813 
      raise x
6814 
    result = changeShippingAddress_result()
6815 
    result.read(self._iprot)
6816 
    self._iprot.readMessageEnd()
6817 
    if result.success is not None:
6818 
      return result.success
6819 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "changeShippingAddress failed: unknown result");
6820 
 
7075 rajveer 6821 
  def retrieveInvoice(self, orderId, userId):
6988 rajveer 6822 
    """
6823 
    Parameters:
6824 
     - orderId
7075 rajveer 6825 
     - userId
6988 rajveer 6826 
    """
7075 rajveer 6827 
    self.send_retrieveInvoice(orderId, userId)
6988 rajveer 6828 
    return self.recv_retrieveInvoice()
6985 anupam.sin 6829 
 
7075 rajveer 6830 
  def send_retrieveInvoice(self, orderId, userId):
6988 rajveer 6831 
    self._oprot.writeMessageBegin('retrieveInvoice', TMessageType.CALL, self._seqid)
6832 
    args = retrieveInvoice_args()
6833 
    args.orderId = orderId
7075 rajveer 6834 
    args.userId = userId
6988 rajveer 6835 
    args.write(self._oprot)
6836 
    self._oprot.writeMessageEnd()
6837 
    self._oprot.trans.flush()
6838 
 
6839 
  def recv_retrieveInvoice(self, ):
6840 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6841 
    if mtype == TMessageType.EXCEPTION:
6842 
      x = TApplicationException()
6843 
      x.read(self._iprot)
6844 
      self._iprot.readMessageEnd()
6845 
      raise x
6846 
    result = retrieveInvoice_result()
6847 
    result.read(self._iprot)
6848 
    self._iprot.readMessageEnd()
6849 
    if result.success is not None:
6850 
      return result.success
6851 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "retrieveInvoice failed: unknown result");
6852 
 
7026 rajveer 6853 
  def receiveUpdatesForRedExpress(self, awbNumber):
6854 
    """
6855 
    Parameters:
6856 
     - awbNumber
6857 
    """
6858 
    self.send_receiveUpdatesForRedExpress(awbNumber)
6859 
    return self.recv_receiveUpdatesForRedExpress()
6988 rajveer 6860 
 
7026 rajveer 6861 
  def send_receiveUpdatesForRedExpress(self, awbNumber):
6862 
    self._oprot.writeMessageBegin('receiveUpdatesForRedExpress', TMessageType.CALL, self._seqid)
6863 
    args = receiveUpdatesForRedExpress_args()
6864 
    args.awbNumber = awbNumber
6865 
    args.write(self._oprot)
6866 
    self._oprot.writeMessageEnd()
6867 
    self._oprot.trans.flush()
6868 
 
6869 
  def recv_receiveUpdatesForRedExpress(self, ):
6870 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6871 
    if mtype == TMessageType.EXCEPTION:
6872 
      x = TApplicationException()
6873 
      x.read(self._iprot)
6874 
      self._iprot.readMessageEnd()
6875 
      raise x
6876 
    result = receiveUpdatesForRedExpress_result()
6877 
    result.read(self._iprot)
6878 
    self._iprot.readMessageEnd()
6879 
    if result.success is not None:
6880 
      return result.success
6881 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "receiveUpdatesForRedExpress failed: unknown result");
6882 
 
7073 anupam.sin 6883 
  def createRechargeTransaction(self, thriftRechargeTransaction):
6884 
    """
6885 
    Parameters:
6886 
     - thriftRechargeTransaction
6887 
    """
6888 
    self.send_createRechargeTransaction(thriftRechargeTransaction)
6889 
    return self.recv_createRechargeTransaction()
7026 rajveer 6890 
 
7073 anupam.sin 6891 
  def send_createRechargeTransaction(self, thriftRechargeTransaction):
6892 
    self._oprot.writeMessageBegin('createRechargeTransaction', TMessageType.CALL, self._seqid)
6893 
    args = createRechargeTransaction_args()
6894 
    args.thriftRechargeTransaction = thriftRechargeTransaction
6895 
    args.write(self._oprot)
6896 
    self._oprot.writeMessageEnd()
6897 
    self._oprot.trans.flush()
6898 
 
6899 
  def recv_createRechargeTransaction(self, ):
6900 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6901 
    if mtype == TMessageType.EXCEPTION:
6902 
      x = TApplicationException()
6903 
      x.read(self._iprot)
6904 
      self._iprot.readMessageEnd()
6905 
      raise x
6906 
    result = createRechargeTransaction_result()
6907 
    result.read(self._iprot)
6908 
    self._iprot.readMessageEnd()
6909 
    if result.success is not None:
6910 
      return result.success
6911 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createRechargeTransaction failed: unknown result");
6912 
 
7085 rajveer 6913 
  def getRechargeTransactions(self, storeId):
6914 
    """
6915 
    Parameters:
6916 
     - storeId
6917 
    """
6918 
    self.send_getRechargeTransactions(storeId)
6919 
    return self.recv_getRechargeTransactions()
6920 
 
6921 
  def send_getRechargeTransactions(self, storeId):
6922 
    self._oprot.writeMessageBegin('getRechargeTransactions', TMessageType.CALL, self._seqid)
6923 
    args = getRechargeTransactions_args()
6924 
    args.storeId = storeId
6925 
    args.write(self._oprot)
6926 
    self._oprot.writeMessageEnd()
6927 
    self._oprot.trans.flush()
6928 
 
6929 
  def recv_getRechargeTransactions(self, ):
6930 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6931 
    if mtype == TMessageType.EXCEPTION:
6932 
      x = TApplicationException()
6933 
      x.read(self._iprot)
6934 
      self._iprot.readMessageEnd()
6935 
      raise x
6936 
    result = getRechargeTransactions_result()
6937 
    result.read(self._iprot)
6938 
    self._iprot.readMessageEnd()
6939 
    if result.success is not None:
6940 
      return result.success
6941 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getRechargeTransactions failed: unknown result");
6942 
 
7151 amit.gupta 6943 
  def getRechargeTrans(self, storeId, startDate, endDate, status):
6944 
    """
6945 
    Parameters:
6946 
     - storeId
6947 
     - startDate
6948 
     - endDate
6949 
     - status
6950 
    """
6951 
    self.send_getRechargeTrans(storeId, startDate, endDate, status)
6952 
    return self.recv_getRechargeTrans()
6953 
 
6954 
  def send_getRechargeTrans(self, storeId, startDate, endDate, status):
6955 
    self._oprot.writeMessageBegin('getRechargeTrans', TMessageType.CALL, self._seqid)
6956 
    args = getRechargeTrans_args()
6957 
    args.storeId = storeId
6958 
    args.startDate = startDate
6959 
    args.endDate = endDate
6960 
    args.status = status
6961 
    args.write(self._oprot)
6962 
    self._oprot.writeMessageEnd()
6963 
    self._oprot.trans.flush()
6964 
 
6965 
  def recv_getRechargeTrans(self, ):
6966 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6967 
    if mtype == TMessageType.EXCEPTION:
6968 
      x = TApplicationException()
6969 
      x.read(self._iprot)
6970 
      self._iprot.readMessageEnd()
6971 
      raise x
6972 
    result = getRechargeTrans_result()
6973 
    result.read(self._iprot)
6974 
    self._iprot.readMessageEnd()
6975 
    if result.success is not None:
6976 
      return result.success
6977 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getRechargeTrans failed: unknown result");
6978 
 
7080 anupam.sin 6979 
  def getRechargeTransaction(self, rechargeId):
6980 
    """
6981 
    Parameters:
6982 
     - rechargeId
6983 
    """
6984 
    self.send_getRechargeTransaction(rechargeId)
6985 
    return self.recv_getRechargeTransaction()
7073 anupam.sin 6986 
 
7080 anupam.sin 6987 
  def send_getRechargeTransaction(self, rechargeId):
6988 
    self._oprot.writeMessageBegin('getRechargeTransaction', TMessageType.CALL, self._seqid)
6989 
    args = getRechargeTransaction_args()
6990 
    args.rechargeId = rechargeId
6991 
    args.write(self._oprot)
6992 
    self._oprot.writeMessageEnd()
6993 
    self._oprot.trans.flush()
6994 
 
6995 
  def recv_getRechargeTransaction(self, ):
6996 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6997 
    if mtype == TMessageType.EXCEPTION:
6998 
      x = TApplicationException()
6999 
      x.read(self._iprot)
7000 
      self._iprot.readMessageEnd()
7001 
      raise x
7002 
    result = getRechargeTransaction_result()
7003 
    result.read(self._iprot)
7004 
    self._iprot.readMessageEnd()
7005 
    if result.success is not None:
7006 
      return result.success
7007 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getRechargeTransaction failed: unknown result");
7008 
 
7009 
  def getFRCs(self, circleId, operatorId):
7010 
    """
7011 
    Parameters:
7012 
     - circleId
7013 
     - operatorId
7014 
    """
7015 
    self.send_getFRCs(circleId, operatorId)
7016 
    return self.recv_getFRCs()
7017 
 
7018 
  def send_getFRCs(self, circleId, operatorId):
7019 
    self._oprot.writeMessageBegin('getFRCs', TMessageType.CALL, self._seqid)
7020 
    args = getFRCs_args()
7021 
    args.circleId = circleId
7022 
    args.operatorId = operatorId
7023 
    args.write(self._oprot)
7024 
    self._oprot.writeMessageEnd()
7025 
    self._oprot.trans.flush()
7026 
 
7027 
  def recv_getFRCs(self, ):
7028 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
7029 
    if mtype == TMessageType.EXCEPTION:
7030 
      x = TApplicationException()
7031 
      x.read(self._iprot)
7032 
      self._iprot.readMessageEnd()
7033 
      raise x
7034 
    result = getFRCs_result()
7035 
    result.read(self._iprot)
7036 
    self._iprot.readMessageEnd()
7037 
    if result.success is not None:
7038 
      return result.success
7039 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getFRCs failed: unknown result");
7040 
 
7096 anupam.sin 7041 
  def getHotspotStore(self, id, hotspotid):
7042 
    """
7043 
    Parameters:
7044 
     - id
7045 
     - hotspotid
7046 
    """
7047 
    self.send_getHotspotStore(id, hotspotid)
7048 
    return self.recv_getHotspotStore()
7080 anupam.sin 7049 
 
7096 anupam.sin 7050 
  def send_getHotspotStore(self, id, hotspotid):
7051 
    self._oprot.writeMessageBegin('getHotspotStore', TMessageType.CALL, self._seqid)
7052 
    args = getHotspotStore_args()
7053 
    args.id = id
7054 
    args.hotspotid = hotspotid
7055 
    args.write(self._oprot)
7056 
    self._oprot.writeMessageEnd()
7057 
    self._oprot.trans.flush()
7058 
 
7059 
  def recv_getHotspotStore(self, ):
7060 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
7061 
    if mtype == TMessageType.EXCEPTION:
7062 
      x = TApplicationException()
7063 
      x.read(self._iprot)
7064 
      self._iprot.readMessageEnd()
7065 
      raise x
7066 
    result = getHotspotStore_result()
7067 
    result.read(self._iprot)
7068 
    self._iprot.readMessageEnd()
7069 
    if result.success is not None:
7070 
      return result.success
7071 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getHotspotStore failed: unknown result");
7072 
 
7073 
  def getTelecomCircle(self, id, code):
7074 
    """
7075 
    Parameters:
7076 
     - id
7077 
     - code
7078 
    """
7079 
    self.send_getTelecomCircle(id, code)
7080 
    return self.recv_getTelecomCircle()
7081 
 
7082 
  def send_getTelecomCircle(self, id, code):
7083 
    self._oprot.writeMessageBegin('getTelecomCircle', TMessageType.CALL, self._seqid)
7084 
    args = getTelecomCircle_args()
7085 
    args.id = id
7086 
    args.code = code
7087 
    args.write(self._oprot)
7088 
    self._oprot.writeMessageEnd()
7089 
    self._oprot.trans.flush()
7090 
 
7091 
  def recv_getTelecomCircle(self, ):
7092 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
7093 
    if mtype == TMessageType.EXCEPTION:
7094 
      x = TApplicationException()
7095 
      x.read(self._iprot)
7096 
      self._iprot.readMessageEnd()
7097 
      raise x
7098 
    result = getTelecomCircle_result()
7099 
    result.read(self._iprot)
7100 
    self._iprot.readMessageEnd()
7101 
    if result.success is not None:
7102 
      return result.success
7103 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTelecomCircle failed: unknown result");
7104 
 
7109 anupam.sin 7105 
  def retrieveHotspotRechargeInvoice(self, rechargeId):
7106 
    """
7107 
    Parameters:
7108 
     - rechargeId
7109 
    """
7110 
    self.send_retrieveHotspotRechargeInvoice(rechargeId)
7111 
    return self.recv_retrieveHotspotRechargeInvoice()
7096 anupam.sin 7112 
 
7109 anupam.sin 7113 
  def send_retrieveHotspotRechargeInvoice(self, rechargeId):
7114 
    self._oprot.writeMessageBegin('retrieveHotspotRechargeInvoice', TMessageType.CALL, self._seqid)
7115 
    args = retrieveHotspotRechargeInvoice_args()
7116 
    args.rechargeId = rechargeId
7117 
    args.write(self._oprot)
7118 
    self._oprot.writeMessageEnd()
7119 
    self._oprot.trans.flush()
7120 
 
7121 
  def recv_retrieveHotspotRechargeInvoice(self, ):
7122 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
7123 
    if mtype == TMessageType.EXCEPTION:
7124 
      x = TApplicationException()
7125 
      x.read(self._iprot)
7126 
      self._iprot.readMessageEnd()
7127 
      raise x
7128 
    result = retrieveHotspotRechargeInvoice_result()
7129 
    result.read(self._iprot)
7130 
    self._iprot.readMessageEnd()
7131 
    if result.success is not None:
7132 
      return result.success
7133 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "retrieveHotspotRechargeInvoice failed: unknown result");
7134 
 
7190 amar.kumar 7135 
  def splitFreebieOrder(self, orderId, splitReason, shippingDate):
7136 
    """
7137 
    Parameters:
7138 
     - orderId
7139 
     - splitReason
7140 
     - shippingDate
7141 
    """
7142 
    self.send_splitFreebieOrder(orderId, splitReason, shippingDate)
7143 
    return self.recv_splitFreebieOrder()
7144 
 
7145 
  def send_splitFreebieOrder(self, orderId, splitReason, shippingDate):
7146 
    self._oprot.writeMessageBegin('splitFreebieOrder', TMessageType.CALL, self._seqid)
7147 
    args = splitFreebieOrder_args()
7148 
    args.orderId = orderId
7149 
    args.splitReason = splitReason
7150 
    args.shippingDate = shippingDate
7151 
    args.write(self._oprot)
7152 
    self._oprot.writeMessageEnd()
7153 
    self._oprot.trans.flush()
7154 
 
7155 
  def recv_splitFreebieOrder(self, ):
7156 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
7157 
    if mtype == TMessageType.EXCEPTION:
7158 
      x = TApplicationException()
7159 
      x.read(self._iprot)
7160 
      self._iprot.readMessageEnd()
7161 
      raise x
7162 
    result = splitFreebieOrder_result()
7163 
    result.read(self._iprot)
7164 
    self._iprot.readMessageEnd()
7165 
    if result.success is not None:
7166 
      return result.success
7167 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "splitFreebieOrder failed: unknown result");
7168 
 
7172 anupam.sin 7169 
  def getRechargeTransactionsByNumber(self, number, storeId):
7169 anupam.sin 7170 
    """
7171 
    Parameters:
7172 
     - number
7172 anupam.sin 7173 
     - storeId
7169 anupam.sin 7174 
    """
7172 anupam.sin 7175 
    self.send_getRechargeTransactionsByNumber(number, storeId)
7169 anupam.sin 7176 
    return self.recv_getRechargeTransactionsByNumber()
7109 anupam.sin 7177 
 
7172 anupam.sin 7178 
  def send_getRechargeTransactionsByNumber(self, number, storeId):
7169 anupam.sin 7179 
    self._oprot.writeMessageBegin('getRechargeTransactionsByNumber', TMessageType.CALL, self._seqid)
7180 
    args = getRechargeTransactionsByNumber_args()
7181 
    args.number = number
7172 anupam.sin 7182 
    args.storeId = storeId
7169 anupam.sin 7183 
    args.write(self._oprot)
7184 
    self._oprot.writeMessageEnd()
7185 
    self._oprot.trans.flush()
7186 
 
7187 
  def recv_getRechargeTransactionsByNumber(self, ):
7188 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
7189 
    if mtype == TMessageType.EXCEPTION:
7190 
      x = TApplicationException()
7191 
      x.read(self._iprot)
7192 
      self._iprot.readMessageEnd()
7193 
      raise x
7194 
    result = getRechargeTransactionsByNumber_result()
7195 
    result.read(self._iprot)
7196 
    self._iprot.readMessageEnd()
7197 
    if result.success is not None:
7198 
      return result.success
7199 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getRechargeTransactionsByNumber failed: unknown result");
7200 
 
7201 
  def updateHotspotStorePassword(self, storeId, password):
7202 
    """
7203 
    Parameters:
7204 
     - storeId
7205 
     - password
7206 
    """
7207 
    self.send_updateHotspotStorePassword(storeId, password)
7208 
    return self.recv_updateHotspotStorePassword()
7209 
 
7210 
  def send_updateHotspotStorePassword(self, storeId, password):
7211 
    self._oprot.writeMessageBegin('updateHotspotStorePassword', TMessageType.CALL, self._seqid)
7212 
    args = updateHotspotStorePassword_args()
7213 
    args.storeId = storeId
7214 
    args.password = password
7215 
    args.write(self._oprot)
7216 
    self._oprot.writeMessageEnd()
7217 
    self._oprot.trans.flush()
7218 
 
7219 
  def recv_updateHotspotStorePassword(self, ):
7220 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
7221 
    if mtype == TMessageType.EXCEPTION:
7222 
      x = TApplicationException()
7223 
      x.read(self._iprot)
7224 
      self._iprot.readMessageEnd()
7225 
      raise x
7226 
    result = updateHotspotStorePassword_result()
7227 
    result.read(self._iprot)
7228 
    self._iprot.readMessageEnd()
7229 
    if result.success is not None:
7230 
      return result.success
7231 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updateHotspotStorePassword failed: unknown result");
7232 
 
7285 rajveer 7233 
  def topupCompanyWallet(self, companyId, amount):
7263 anupam.sin 7234 
    """
7235 
    Parameters:
7285 rajveer 7236 
     - companyId
7237 
     - amount
7263 anupam.sin 7238 
    """
7285 rajveer 7239 
    self.send_topupCompanyWallet(companyId, amount)
7240 
    return self.recv_topupCompanyWallet()
7169 anupam.sin 7241 
 
7285 rajveer 7242 
  def send_topupCompanyWallet(self, companyId, amount):
7243 
    self._oprot.writeMessageBegin('topupCompanyWallet', TMessageType.CALL, self._seqid)
7244 
    args = topupCompanyWallet_args()
7245 
    args.companyId = companyId
7246 
    args.amount = amount
7263 anupam.sin 7247 
    args.write(self._oprot)
7248 
    self._oprot.writeMessageEnd()
7249 
    self._oprot.trans.flush()
7250 
 
7285 rajveer 7251 
  def recv_topupCompanyWallet(self, ):
7263 anupam.sin 7252 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
7253 
    if mtype == TMessageType.EXCEPTION:
7254 
      x = TApplicationException()
7255 
      x.read(self._iprot)
7256 
      self._iprot.readMessageEnd()
7257 
      raise x
7285 rajveer 7258 
    result = topupCompanyWallet_result()
7263 anupam.sin 7259 
    result.read(self._iprot)
7260 
    self._iprot.readMessageEnd()
7261 
    if result.success is not None:
7262 
      return result.success
7285 rajveer 7263 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "topupCompanyWallet failed: unknown result");
7263 anupam.sin 7264 
 
7285 rajveer 7265 
  def getWalletBalanceForCompany(self, companyId):
7266 
    """
7267 
    Parameters:
7268 
     - companyId
7269 
    """
7270 
    self.send_getWalletBalanceForCompany(companyId)
7271 
    return self.recv_getWalletBalanceForCompany()
7263 anupam.sin 7272 
 
7285 rajveer 7273 
  def send_getWalletBalanceForCompany(self, companyId):
7274 
    self._oprot.writeMessageBegin('getWalletBalanceForCompany', TMessageType.CALL, self._seqid)
7275 
    args = getWalletBalanceForCompany_args()
7276 
    args.companyId = companyId
7267 anupam.sin 7277 
    args.write(self._oprot)
7278 
    self._oprot.writeMessageEnd()
7279 
    self._oprot.trans.flush()
7280 
 
7285 rajveer 7281 
  def recv_getWalletBalanceForCompany(self, ):
7267 anupam.sin 7282 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
7283 
    if mtype == TMessageType.EXCEPTION:
7284 
      x = TApplicationException()
7285 
      x.read(self._iprot)
7286 
      self._iprot.readMessageEnd()
7287 
      raise x
7285 rajveer 7288 
    result = getWalletBalanceForCompany_result()
7267 anupam.sin 7289 
    result.read(self._iprot)
7290 
    self._iprot.readMessageEnd()
7291 
    if result.success is not None:
7292 
      return result.success
7285 rajveer 7293 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getWalletBalanceForCompany failed: unknown result");
7267 anupam.sin 7294 
 
7285 rajveer 7295 
  def getSourceDetail(self, source):
7267 anupam.sin 7296 
    """
7297 
    Parameters:
7285 rajveer 7298 
     - source
7267 anupam.sin 7299 
    """
7285 rajveer 7300 
    self.send_getSourceDetail(source)
7301 
    return self.recv_getSourceDetail()
7267 anupam.sin 7302 
 
7285 rajveer 7303 
  def send_getSourceDetail(self, source):
7304 
    self._oprot.writeMessageBegin('getSourceDetail', TMessageType.CALL, self._seqid)
7305 
    args = getSourceDetail_args()
7306 
    args.source = source
7267 anupam.sin 7307 
    args.write(self._oprot)
7308 
    self._oprot.writeMessageEnd()
7309 
    self._oprot.trans.flush()
7310 
 
7285 rajveer 7311 
  def recv_getSourceDetail(self, ):
7267 anupam.sin 7312 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
7313 
    if mtype == TMessageType.EXCEPTION:
7314 
      x = TApplicationException()
7315 
      x.read(self._iprot)
7316 
      self._iprot.readMessageEnd()
7317 
      raise x
7285 rajveer 7318 
    result = getSourceDetail_result()
7267 anupam.sin 7319 
    result.read(self._iprot)
7320 
    self._iprot.readMessageEnd()
7321 
    if result.success is not None:
7322 
      return result.success
7285 rajveer 7323 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getSourceDetail failed: unknown result");
7267 anupam.sin 7324 
 
7308 rajveer 7325 
  def getAllCircles(self, ):
7326 
    self.send_getAllCircles()
7327 
    return self.recv_getAllCircles()
7267 anupam.sin 7328 
 
7308 rajveer 7329 
  def send_getAllCircles(self, ):
7330 
    self._oprot.writeMessageBegin('getAllCircles', TMessageType.CALL, self._seqid)
7331 
    args = getAllCircles_args()
7332 
    args.write(self._oprot)
7333 
    self._oprot.writeMessageEnd()
7334 
    self._oprot.trans.flush()
7335 
 
7336 
  def recv_getAllCircles(self, ):
7337 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
7338 
    if mtype == TMessageType.EXCEPTION:
7339 
      x = TApplicationException()
7340 
      x.read(self._iprot)
7341 
      self._iprot.readMessageEnd()
7342 
      raise x
7343 
    result = getAllCircles_result()
7344 
    result.read(self._iprot)
7345 
    self._iprot.readMessageEnd()
7346 
    if result.success is not None:
7347 
      return result.success
7348 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllCircles failed: unknown result");
7349 
 
7350 
  def deleteFrcs(self, frcIdsToDelete):
7351 
    """
7352 
    Parameters:
7353 
     - frcIdsToDelete
7354 
    """
7355 
    self.send_deleteFrcs(frcIdsToDelete)
7356 
    return self.recv_deleteFrcs()
7357 
 
7358 
  def send_deleteFrcs(self, frcIdsToDelete):
7359 
    self._oprot.writeMessageBegin('deleteFrcs', TMessageType.CALL, self._seqid)
7360 
    args = deleteFrcs_args()
7361 
    args.frcIdsToDelete = frcIdsToDelete
7362 
    args.write(self._oprot)
7363 
    self._oprot.writeMessageEnd()
7364 
    self._oprot.trans.flush()
7365 
 
7366 
  def recv_deleteFrcs(self, ):
7367 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
7368 
    if mtype == TMessageType.EXCEPTION:
7369 
      x = TApplicationException()
7370 
      x.read(self._iprot)
7371 
      self._iprot.readMessageEnd()
7372 
      raise x
7373 
    result = deleteFrcs_result()
7374 
    result.read(self._iprot)
7375 
    self._iprot.readMessageEnd()
7376 
    if result.success is not None:
7377 
      return result.success
7378 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "deleteFrcs failed: unknown result");
7379 
 
7380 
 
3376 rajveer 7381 
class Processor(shop2020.thriftpy.generic.GenericService.Processor, Iface, TProcessor):
94 ashish 7382 
  def __init__(self, handler):
3376 rajveer 7383 
    shop2020.thriftpy.generic.GenericService.Processor.__init__(self, handler)
94 ashish 7384 
    self._processMap["createTransaction"] = Processor.process_createTransaction
7385 
    self._processMap["getTransaction"] = Processor.process_getTransaction
7386 
    self._processMap["getTransactionsForCustomer"] = Processor.process_getTransactionsForCustomer
132 ashish 7387 
    self._processMap["getTransactionsForShoppingCartId"] = Processor.process_getTransactionsForShoppingCartId
94 ashish 7388 
    self._processMap["getTransactionStatus"] = Processor.process_getTransactionStatus
7389 
    self._processMap["changeTransactionStatus"] = Processor.process_changeTransactionStatus
1398 varun.gupt 7390 
    self._processMap["enqueueTransactionInfoEmail"] = Processor.process_enqueueTransactionInfoEmail
483 rajveer 7391 
    self._processMap["getAllOrders"] = Processor.process_getAllOrders
4133 chandransh 7392 
    self._processMap["getOrdersInBatch"] = Processor.process_getOrdersInBatch
7393 
    self._processMap["getOrderCount"] = Processor.process_getOrderCount
999 varun.gupt 7394 
    self._processMap["getOrdersByBillingDate"] = Processor.process_getOrdersByBillingDate
3427 chandransh 7395 
    self._processMap["getOrdersByShippingDate"] = Processor.process_getOrdersByShippingDate
1382 varun.gupt 7396 
    self._processMap["getReturnableOrdersForCustomer"] = Processor.process_getReturnableOrdersForCustomer
7397 
    self._processMap["getCancellableOrdersForCustomer"] = Processor.process_getCancellableOrdersForCustomer
483 rajveer 7398 
    self._processMap["changeOrderStatus"] = Processor.process_changeOrderStatus
7399 
    self._processMap["getOrdersForTransaction"] = Processor.process_getOrdersForTransaction
7400 
    self._processMap["getOrdersForCustomer"] = Processor.process_getOrdersForCustomer
7401 
    self._processMap["createOrder"] = Processor.process_createOrder
7402 
    self._processMap["getOrder"] = Processor.process_getOrder
7403 
    self._processMap["getLineItemsForOrder"] = Processor.process_getLineItemsForOrder
4999 phani.kuma 7404 
    self._processMap["getOrderList"] = Processor.process_getOrderList
5386 phani.kuma 7405 
    self._processMap["getOrderListForVendor"] = Processor.process_getOrderListForVendor
1528 ankur.sing 7406 
    self._processMap["getOrderForCustomer"] = Processor.process_getOrderForCustomer
3064 chandransh 7407 
    self._processMap["getAlerts"] = Processor.process_getAlerts
4394 rajveer 7408 
    self._processMap["addAlert"] = Processor.process_addAlert
4444 rajveer 7409 
    self._processMap["markAlertsAsSeen"] = Processor.process_markAlertsAsSeen
3064 chandransh 7410 
    self._processMap["getValidOrderCount"] = Processor.process_getValidOrderCount
7411 
    self._processMap["getNoOfCustomersWithSuccessfulTransaction"] = Processor.process_getNoOfCustomersWithSuccessfulTransaction
7412 
    self._processMap["getValidOrdersAmountRange"] = Processor.process_getValidOrdersAmountRange
7413 
    self._processMap["getValidOrders"] = Processor.process_getValidOrders
1220 chandransh 7414 
    self._processMap["batchOrders"] = Processor.process_batchOrders
1208 chandransh 7415 
    self._processMap["markOrderAsOutOfStock"] = Processor.process_markOrderAsOutOfStock
3064 chandransh 7416 
    self._processMap["verifyOrder"] = Processor.process_verifyOrder
7417 
    self._processMap["acceptOrder"] = Processor.process_acceptOrder
7418 
    self._processMap["addBillingDetails"] = Processor.process_addBillingDetails
4579 rajveer 7419 
    self._processMap["addInvoiceNumber"] = Processor.process_addInvoiceNumber
4410 rajveer 7420 
    self._processMap["markOrdersAsShippedFromWarehouse"] = Processor.process_markOrdersAsShippedFromWarehouse
5676 rajveer 7421 
    self._processMap["markOrdersAsReturnedFromStore"] = Processor.process_markOrdersAsReturnedFromStore
1113 chandransh 7422 
    self._processMap["markOrdersAsPickedUp"] = Processor.process_markOrdersAsPickedUp
4910 phani.kuma 7423 
    self._processMap["getOrdersNotPickedUp"] = Processor.process_getOrdersNotPickedUp
1132 chandransh 7424 
    self._processMap["markOrdersAsDelivered"] = Processor.process_markOrdersAsDelivered
4910 phani.kuma 7425 
    self._processMap["markAsRTOrders"] = Processor.process_markAsRTOrders
7426 
    self._processMap["getRTOrders"] = Processor.process_getRTOrders
1246 chandransh 7427 
    self._processMap["updateNonDeliveryReason"] = Processor.process_updateNonDeliveryReason
4910 phani.kuma 7428 
    self._processMap["getNonDeliveredOrdersbyCourier"] = Processor.process_getNonDeliveredOrdersbyCourier
7429 
    self._processMap["markOrdersAsLocalConnected"] = Processor.process_markOrdersAsLocalConnected
7430 
    self._processMap["getOrdersNotLocalConnected"] = Processor.process_getOrdersNotLocalConnected
7431 
    self._processMap["markOrdersAsDestinationCityReached"] = Processor.process_markOrdersAsDestinationCityReached
7432 
    self._processMap["markOrdersAsFirstDeliveryAttempted"] = Processor.process_markOrdersAsFirstDeliveryAttempted
1408 ankur.sing 7433 
    self._processMap["getUndeliveredOrders"] = Processor.process_getUndeliveredOrders
4783 phani.kuma 7434 
    self._processMap["getUndeliveredOrdersExpectedDeliveryDateNotMet"] = Processor.process_getUndeliveredOrdersExpectedDeliveryDateNotMet
2536 chandransh 7435 
    self._processMap["toggleDOAFlag"] = Processor.process_toggleDOAFlag
4712 rajveer 7436 
    self._processMap["markOrderAsDelivered"] = Processor.process_markOrderAsDelivered
5553 rajveer 7437 
    self._processMap["markOrderAsReceivedAtStore"] = Processor.process_markOrderAsReceivedAtStore
4454 rajveer 7438 
    self._processMap["markOrderDoaRequestReceived"] = Processor.process_markOrderDoaRequestReceived
7439 
    self._processMap["markOrderDoaRequestAuthorized"] = Processor.process_markOrderDoaRequestAuthorized
4488 rajveer 7440 
    self._processMap["markOrderReturnRequestReceived"] = Processor.process_markOrderReturnRequestReceived
7441 
    self._processMap["markOrderReturnRequestAuthorized"] = Processor.process_markOrderReturnRequestAuthorized
2536 chandransh 7442 
    self._processMap["requestPickupNumber"] = Processor.process_requestPickupNumber
7443 
    self._processMap["authorizePickup"] = Processor.process_authorizePickup
2764 chandransh 7444 
    self._processMap["markDoasAsPickedUp"] = Processor.process_markDoasAsPickedUp
4910 phani.kuma 7445 
    self._processMap["getDoasNotPickedUp"] = Processor.process_getDoasNotPickedUp
4741 phani.kuma 7446 
    self._processMap["markReturnOrdersAsPickedUp"] = Processor.process_markReturnOrdersAsPickedUp
4910 phani.kuma 7447 
    self._processMap["getReturnOrdersNotPickedUp"] = Processor.process_getReturnOrdersNotPickedUp
2616 chandransh 7448 
    self._processMap["receiveReturn"] = Processor.process_receiveReturn
2591 chandransh 7449 
    self._processMap["validateDoa"] = Processor.process_validateDoa
4495 rajveer 7450 
    self._processMap["validateReturnProduct"] = Processor.process_validateReturnProduct
2616 chandransh 7451 
    self._processMap["reshipOrder"] = Processor.process_reshipOrder
7452 
    self._processMap["refundOrder"] = Processor.process_refundOrder
2690 chandransh 7453 
    self._processMap["getReturnOrders"] = Processor.process_getReturnOrders
5481 phani.kuma 7454 
    self._processMap["getAllReturnOrders"] = Processor.process_getAllReturnOrders
2700 chandransh 7455 
    self._processMap["getReturnOrder"] = Processor.process_getReturnOrder
2690 chandransh 7456 
    self._processMap["processReturn"] = Processor.process_processReturn
3451 chandransh 7457 
    self._processMap["updateWeight"] = Processor.process_updateWeight
3469 chandransh 7458 
    self._processMap["changeItem"] = Processor.process_changeItem
7459 
    self._processMap["shiftToWarehouse"] = Processor.process_shiftToWarehouse
3553 chandransh 7460 
    self._processMap["addDelayReason"] = Processor.process_addDelayReason
3956 chandransh 7461 
    self._processMap["reconcileCodCollection"] = Processor.process_reconcileCodCollection
4008 mandeep.dh 7462 
    self._processMap["getTransactionsRequiringExtraProcessing"] = Processor.process_getTransactionsRequiringExtraProcessing
7463 
    self._processMap["markTransactionAsProcessed"] = Processor.process_markTransactionAsProcessed
4018 chandransh 7464 
    self._processMap["getItemWiseRiskyOrdersCount"] = Processor.process_getItemWiseRiskyOrdersCount
4295 varun.gupt 7465 
    self._processMap["getOrdersForItemIds"] = Processor.process_getOrdersForItemIds
4247 rajveer 7466 
    self._processMap["markOrderCancellationRequestReceived"] = Processor.process_markOrderCancellationRequestReceived
7467 
    self._processMap["markOrderCancellationRequestConfirmed"] = Processor.process_markOrderCancellationRequestConfirmed
7468 
    self._processMap["markOrderCancellationRequestDenied"] = Processor.process_markOrderCancellationRequestDenied
4258 rajveer 7469 
    self._processMap["markTransactionAsPaymentFlagRemoved"] = Processor.process_markTransactionAsPaymentFlagRemoved
4259 anupam.sin 7470 
    self._processMap["refundTransaction"] = Processor.process_refundTransaction
4324 mandeep.dh 7471 
    self._processMap["updateShipmentAddress"] = Processor.process_updateShipmentAddress
4285 rajveer 7472 
    self._processMap["acceptOrdersForItemId"] = Processor.process_acceptOrdersForItemId
4303 rajveer 7473 
    self._processMap["markOrdersAsPORaised"] = Processor.process_markOrdersAsPORaised
7474 
    self._processMap["markOrdersAsReversalInitiated"] = Processor.process_markOrdersAsReversalInitiated
7475 
    self._processMap["markOrdersAsNotAvailabke"] = Processor.process_markOrdersAsNotAvailabke
4369 rajveer 7476 
    self._processMap["markOrdersAsTimeout"] = Processor.process_markOrdersAsTimeout
4662 rajveer 7477 
    self._processMap["markOrderAsLostInTransit"] = Processor.process_markOrderAsLostInTransit
4386 anupam.sin 7478 
    self._processMap["getOrderForAwb"] = Processor.process_getOrderForAwb
4506 phani.kuma 7479 
    self._processMap["getOrdersForProviderForStatus"] = Processor.process_getOrdersForProviderForStatus
4600 varun.gupt 7480 
    self._processMap["getBilledOrdersForVendor"] = Processor.process_getBilledOrdersForVendor
4607 rajveer 7481 
    self._processMap["getSlippedSippingDateOrders"] = Processor.process_getSlippedSippingDateOrders
4709 rajveer 7482 
    self._processMap["getCancelledOrders"] = Processor.process_getCancelledOrders
4600 varun.gupt 7483 
    self._processMap["saveBluedartSettlements"] = Processor.process_saveBluedartSettlements
7484 
    self._processMap["savePaymentSettlements"] = Processor.process_savePaymentSettlements
7485 
    self._processMap["saveEBSSettlementSummary"] = Processor.process_saveEBSSettlementSummary
5386 phani.kuma 7486 
    self._processMap["getSettlementForPrepaid"] = Processor.process_getSettlementForPrepaid
7487 
    self._processMap["getSettlementForCod"] = Processor.process_getSettlementForCod
4600 varun.gupt 7488 
    self._processMap["getEBSSettlementSummaries"] = Processor.process_getEBSSettlementSummaries
7489 
    self._processMap["markEBSSettlementUploaded"] = Processor.process_markEBSSettlementUploaded
7490 
    self._processMap["getEBSSettlementDate"] = Processor.process_getEBSSettlementDate
4715 varun.gupt 7491 
    self._processMap["getSettlementsByDate"] = Processor.process_getSettlementsByDate
7492 
    self._processMap["getReshippedOrderIds"] = Processor.process_getReshippedOrderIds
5481 phani.kuma 7493 
    self._processMap["getBilledOrders"] = Processor.process_getBilledOrders
5031 varun.gupt 7494 
    self._processMap["getStatusDistributionOfOrders"] = Processor.process_getStatusDistributionOfOrders
5067 varun.gupt 7495 
    self._processMap["getOrderIdsForStatus"] = Processor.process_getOrderIdsForStatus
5348 anupam.sin 7496 
    self._processMap["updateCODAgent"] = Processor.process_updateCODAgent
5099 varun.gupt 7497 
    self._processMap["updateOrderAsPaidToVendor"] = Processor.process_updateOrderAsPaidToVendor
5386 phani.kuma 7498 
    self._processMap["updateOrderOnlyAsPaidToVendor"] = Processor.process_updateOrderOnlyAsPaidToVendor
5208 varun.gupt 7499 
    self._processMap["getRefundedOrdersMarkedPaid"] = Processor.process_getRefundedOrdersMarkedPaid
5447 anupam.sin 7500 
    self._processMap["getAllVerificationAgents"] = Processor.process_getAllVerificationAgents
5527 anupam.sin 7501 
    self._processMap["getAllAttributesForOrderId"] = Processor.process_getAllAttributesForOrderId
5676 rajveer 7502 
    self._processMap["setOrderAttributes"] = Processor.process_setOrderAttributes
5527 anupam.sin 7503 
    self._processMap["setOrderAttributeForTransaction"] = Processor.process_setOrderAttributeForTransaction
5553 rajveer 7504 
    self._processMap["getReceivePendingOrders"] = Processor.process_getReceivePendingOrders
7505 
    self._processMap["getReceivedAtStoreOrders"] = Processor.process_getReceivedAtStoreOrders
5713 rajveer 7506 
    self._processMap["getOrdersCollectionAtStore"] = Processor.process_getOrdersCollectionAtStore
5833 rajveer 7507 
    self._processMap["getOrderAttributeValue"] = Processor.process_getOrderAttributeValue
6019 rajveer 7508 
    self._processMap["changeJacketNumber"] = Processor.process_changeJacketNumber
7509 
    self._processMap["markOrderAsRtoInTransit"] = Processor.process_markOrderAsRtoInTransit
5593 mandeep.dh 7510 
    self._processMap["acceptOrderForItem"] = Processor.process_acceptOrderForItem
6000 mandeep.dh 7511 
    self._processMap["createRechargeOrder"] = Processor.process_createRechargeOrder
6031 rajveer 7512 
    self._processMap["getRechargeOrder"] = Processor.process_getRechargeOrder
7513 
    self._processMap["getRechargeOrders"] = Processor.process_getRechargeOrders
6000 mandeep.dh 7514 
    self._processMap["updateRechargeOrderStatus"] = Processor.process_updateRechargeOrderStatus
7515 
    self._processMap["activateRechargeTxn"] = Processor.process_activateRechargeTxn
6031 rajveer 7516 
    self._processMap["getUserWallet"] = Processor.process_getUserWallet
7517 
    self._processMap["getUserWalletHistory"] = Processor.process_getUserWalletHistory
6050 anupam.sin 7518 
    self._processMap["getRechargeOrdersForTransaction"] = Processor.process_getRechargeOrdersForTransaction
6048 rajveer 7519 
    self._processMap["getServiceProviders"] = Processor.process_getServiceProviders
7520 
    self._processMap["getServiceProviderForDevice"] = Processor.process_getServiceProviderForDevice
6269 rajveer 7521 
    self._processMap["validateRecharge"] = Processor.process_validateRecharge
6094 rajveer 7522 
    self._processMap["getRechargeOrdersForDevice"] = Processor.process_getRechargeOrdersForDevice
7523 
    self._processMap["addAmountToWallet"] = Processor.process_addAmountToWallet
6188 rajveer 7524 
    self._processMap["getRechargeStatistics"] = Processor.process_getRechargeStatistics
6154 rajveer 7525 
    self._processMap["getRechargeOrdersForStatus"] = Processor.process_getRechargeOrdersForStatus
6159 rajveer 7526 
    self._processMap["getPlansForOperator"] = Processor.process_getPlansForOperator
6289 anupam.sin 7527 
    self._processMap["getRechargeDenominations"] = Processor.process_getRechargeDenominations
6371 rajveer 7528 
    self._processMap["updateAvailabilityStatus"] = Processor.process_updateAvailabilityStatus
6389 rajveer 7529 
    self._processMap["getAvailableEmiSchemes"] = Processor.process_getAvailableEmiSchemes
7530 
    self._processMap["getMiscCharges"] = Processor.process_getMiscCharges
6507 anupam.sin 7531 
    self._processMap["refundRechargeOrder"] = Processor.process_refundRechargeOrder
6821 amar.kumar 7532 
    self._processMap["getPhysicalOrders"] = Processor.process_getPhysicalOrders
6906 rajveer 7533 
    self._processMap["getDocument"] = Processor.process_getDocument
6985 anupam.sin 7534 
    self._processMap["changeShippingAddress"] = Processor.process_changeShippingAddress
6988 rajveer 7535 
    self._processMap["retrieveInvoice"] = Processor.process_retrieveInvoice
7026 rajveer 7536 
    self._processMap["receiveUpdatesForRedExpress"] = Processor.process_receiveUpdatesForRedExpress
7073 anupam.sin 7537 
    self._processMap["createRechargeTransaction"] = Processor.process_createRechargeTransaction
7085 rajveer 7538 
    self._processMap["getRechargeTransactions"] = Processor.process_getRechargeTransactions
7151 amit.gupta 7539 
    self._processMap["getRechargeTrans"] = Processor.process_getRechargeTrans
7080 anupam.sin 7540 
    self._processMap["getRechargeTransaction"] = Processor.process_getRechargeTransaction
7541 
    self._processMap["getFRCs"] = Processor.process_getFRCs
7096 anupam.sin 7542 
    self._processMap["getHotspotStore"] = Processor.process_getHotspotStore
7543 
    self._processMap["getTelecomCircle"] = Processor.process_getTelecomCircle
7109 anupam.sin 7544 
    self._processMap["retrieveHotspotRechargeInvoice"] = Processor.process_retrieveHotspotRechargeInvoice
7190 amar.kumar 7545 
    self._processMap["splitFreebieOrder"] = Processor.process_splitFreebieOrder
7169 anupam.sin 7546 
    self._processMap["getRechargeTransactionsByNumber"] = Processor.process_getRechargeTransactionsByNumber
7547 
    self._processMap["updateHotspotStorePassword"] = Processor.process_updateHotspotStorePassword
7285 rajveer 7548 
    self._processMap["topupCompanyWallet"] = Processor.process_topupCompanyWallet
7549 
    self._processMap["getWalletBalanceForCompany"] = Processor.process_getWalletBalanceForCompany
7263 anupam.sin 7550 
    self._processMap["getSourceDetail"] = Processor.process_getSourceDetail
7308 rajveer 7551 
    self._processMap["getAllCircles"] = Processor.process_getAllCircles
7552 
    self._processMap["deleteFrcs"] = Processor.process_deleteFrcs
94 ashish 7553 
 
7554 
  def process(self, iprot, oprot):
7555 
    (name, type, seqid) = iprot.readMessageBegin()
7556 
    if name not in self._processMap:
7557 
      iprot.skip(TType.STRUCT)
7558 
      iprot.readMessageEnd()
7559 
      x = TApplicationException(TApplicationException.UNKNOWN_METHOD, 'Unknown function %s' % (name))
7560 
      oprot.writeMessageBegin(name, TMessageType.EXCEPTION, seqid)
7561 
      x.write(oprot)
7562 
      oprot.writeMessageEnd()
7563 
      oprot.trans.flush()
7564 
      return
7565 
    else:
7566 
      self._processMap[name](self, seqid, iprot, oprot)
7567 
    return True
7568 
 
7569 
  def process_createTransaction(self, seqid, iprot, oprot):
7570 
    args = createTransaction_args()
7571 
    args.read(iprot)
7572 
    iprot.readMessageEnd()
7573 
    result = createTransaction_result()
7574 
    try:
132 ashish 7575 
      result.success = self._handler.createTransaction(args.transaction)
94 ashish 7576 
    except TransactionServiceException, ex:
7577 
      result.ex = ex
7578 
    oprot.writeMessageBegin("createTransaction", TMessageType.REPLY, seqid)
7579 
    result.write(oprot)
7580 
    oprot.writeMessageEnd()
7581 
    oprot.trans.flush()
7582 
 
7583 
  def process_getTransaction(self, seqid, iprot, oprot):
7584 
    args = getTransaction_args()
7585 
    args.read(iprot)
7586 
    iprot.readMessageEnd()
7587 
    result = getTransaction_result()
7588 
    try:
7589 
      result.success = self._handler.getTransaction(args.id)
7590 
    except TransactionServiceException, ex:
7591 
      result.ex = ex
7592 
    oprot.writeMessageBegin("getTransaction", TMessageType.REPLY, seqid)
7593 
    result.write(oprot)
7594 
    oprot.writeMessageEnd()
7595 
    oprot.trans.flush()
7596 
 
7597 
  def process_getTransactionsForCustomer(self, seqid, iprot, oprot):
7598 
    args = getTransactionsForCustomer_args()
7599 
    args.read(iprot)
7600 
    iprot.readMessageEnd()
7601 
    result = getTransactionsForCustomer_result()
7602 
    try:
7603 
      result.success = self._handler.getTransactionsForCustomer(args.customerId, args.from_date, args.to_date, args.status)
7604 
    except TransactionServiceException, ex:
7605 
      result.ex = ex
7606 
    oprot.writeMessageBegin("getTransactionsForCustomer", TMessageType.REPLY, seqid)
7607 
    result.write(oprot)
7608 
    oprot.writeMessageEnd()
7609 
    oprot.trans.flush()
7610 
 
132 ashish 7611 
  def process_getTransactionsForShoppingCartId(self, seqid, iprot, oprot):
7612 
    args = getTransactionsForShoppingCartId_args()
7613 
    args.read(iprot)
7614 
    iprot.readMessageEnd()
7615 
    result = getTransactionsForShoppingCartId_result()
7616 
    try:
7617 
      result.success = self._handler.getTransactionsForShoppingCartId(args.shoppingCartId)
7618 
    except TransactionServiceException, ex:
7619 
      result.ex = ex
7620 
    oprot.writeMessageBegin("getTransactionsForShoppingCartId", TMessageType.REPLY, seqid)
7621 
    result.write(oprot)
7622 
    oprot.writeMessageEnd()
7623 
    oprot.trans.flush()
7624 
 
94 ashish 7625 
  def process_getTransactionStatus(self, seqid, iprot, oprot):
7626 
    args = getTransactionStatus_args()
7627 
    args.read(iprot)
7628 
    iprot.readMessageEnd()
7629 
    result = getTransactionStatus_result()
7630 
    try:
7631 
      result.success = self._handler.getTransactionStatus(args.transactionId)
7632 
    except TransactionServiceException, ex:
7633 
      result.ex = ex
7634 
    oprot.writeMessageBegin("getTransactionStatus", TMessageType.REPLY, seqid)
7635 
    result.write(oprot)
7636 
    oprot.writeMessageEnd()
7637 
    oprot.trans.flush()
7638 
 
7639 
  def process_changeTransactionStatus(self, seqid, iprot, oprot):
7640 
    args = changeTransactionStatus_args()
7641 
    args.read(iprot)
7642 
    iprot.readMessageEnd()
7643 
    result = changeTransactionStatus_result()
7644 
    try:
7293 anupam.sin 7645 
      result.success = self._handler.changeTransactionStatus(args.transactionId, args.status, args.description, args.pickUp, args.orderType, args.source)
94 ashish 7646 
    except TransactionServiceException, ex:
7647 
      result.ex = ex
7648 
    oprot.writeMessageBegin("changeTransactionStatus", TMessageType.REPLY, seqid)
7649 
    result.write(oprot)
7650 
    oprot.writeMessageEnd()
7651 
    oprot.trans.flush()
7652 
 
1398 varun.gupt 7653 
  def process_enqueueTransactionInfoEmail(self, seqid, iprot, oprot):
7654 
    args = enqueueTransactionInfoEmail_args()
1382 varun.gupt 7655 
    args.read(iprot)
7656 
    iprot.readMessageEnd()
1398 varun.gupt 7657 
    result = enqueueTransactionInfoEmail_result()
1382 varun.gupt 7658 
    try:
1398 varun.gupt 7659 
      result.success = self._handler.enqueueTransactionInfoEmail(args.transactionId)
1382 varun.gupt 7660 
    except TransactionServiceException, ex:
7661 
      result.ex = ex
1398 varun.gupt 7662 
    oprot.writeMessageBegin("enqueueTransactionInfoEmail", TMessageType.REPLY, seqid)
1382 varun.gupt 7663 
    result.write(oprot)
7664 
    oprot.writeMessageEnd()
7665 
    oprot.trans.flush()
7666 
 
483 rajveer 7667 
  def process_getAllOrders(self, seqid, iprot, oprot):
7668 
    args = getAllOrders_args()
94 ashish 7669 
    args.read(iprot)
7670 
    iprot.readMessageEnd()
483 rajveer 7671 
    result = getAllOrders_result()
94 ashish 7672 
    try:
4801 anupam.sin 7673 
      result.success = self._handler.getAllOrders(args.statuses, args.from_date, args.to_date, args.warehouse_id)
94 ashish 7674 
    except TransactionServiceException, ex:
7675 
      result.ex = ex
483 rajveer 7676 
    oprot.writeMessageBegin("getAllOrders", TMessageType.REPLY, seqid)
94 ashish 7677 
    result.write(oprot)
7678 
    oprot.writeMessageEnd()
7679 
    oprot.trans.flush()
7680 
 
4133 chandransh 7681 
  def process_getOrdersInBatch(self, seqid, iprot, oprot):
7682 
    args = getOrdersInBatch_args()
7683 
    args.read(iprot)
7684 
    iprot.readMessageEnd()
7685 
    result = getOrdersInBatch_result()
7686 
    try:
7687 
      result.success = self._handler.getOrdersInBatch(args.statuses, args.offset, args.limit, args.warehouse_id)
7688 
    except TransactionServiceException, ex:
7689 
      result.ex = ex
7690 
    oprot.writeMessageBegin("getOrdersInBatch", TMessageType.REPLY, seqid)
7691 
    result.write(oprot)
7692 
    oprot.writeMessageEnd()
7693 
    oprot.trans.flush()
7694 
 
7695 
  def process_getOrderCount(self, seqid, iprot, oprot):
7696 
    args = getOrderCount_args()
7697 
    args.read(iprot)
7698 
    iprot.readMessageEnd()
7699 
    result = getOrderCount_result()
7700 
    try:
7701 
      result.success = self._handler.getOrderCount(args.statuses, args.warehouseId)
7702 
    except TransactionServiceException, ex:
7703 
      result.ex = ex
7704 
    oprot.writeMessageBegin("getOrderCount", TMessageType.REPLY, seqid)
7705 
    result.write(oprot)
7706 
    oprot.writeMessageEnd()
7707 
    oprot.trans.flush()
7708 
 
999 varun.gupt 7709 
  def process_getOrdersByBillingDate(self, seqid, iprot, oprot):
7710 
    args = getOrdersByBillingDate_args()
7711 
    args.read(iprot)
7712 
    iprot.readMessageEnd()
7713 
    result = getOrdersByBillingDate_result()
7714 
    try:
7715 
      result.success = self._handler.getOrdersByBillingDate(args.status, args.start_billing_date, args.end_billing_date, args.warehouse_id)
7716 
    except TransactionServiceException, ex:
7717 
      result.ex = ex
7718 
    oprot.writeMessageBegin("getOrdersByBillingDate", TMessageType.REPLY, seqid)
7719 
    result.write(oprot)
7720 
    oprot.writeMessageEnd()
7721 
    oprot.trans.flush()
7722 
 
3427 chandransh 7723 
  def process_getOrdersByShippingDate(self, seqid, iprot, oprot):
7724 
    args = getOrdersByShippingDate_args()
7725 
    args.read(iprot)
7726 
    iprot.readMessageEnd()
7727 
    result = getOrdersByShippingDate_result()
7728 
    try:
3451 chandransh 7729 
      result.success = self._handler.getOrdersByShippingDate(args.fromShippingDate, args.toShippingDate, args.providerId, args.warehouseId, args.cod)
3427 chandransh 7730 
    except TransactionServiceException, ex:
7731 
      result.ex = ex
7732 
    oprot.writeMessageBegin("getOrdersByShippingDate", TMessageType.REPLY, seqid)
7733 
    result.write(oprot)
7734 
    oprot.writeMessageEnd()
7735 
    oprot.trans.flush()
7736 
 
1382 varun.gupt 7737 
  def process_getReturnableOrdersForCustomer(self, seqid, iprot, oprot):
7738 
    args = getReturnableOrdersForCustomer_args()
7739 
    args.read(iprot)
7740 
    iprot.readMessageEnd()
7741 
    result = getReturnableOrdersForCustomer_result()
7742 
    try:
7743 
      result.success = self._handler.getReturnableOrdersForCustomer(args.customer_id, args.limit)
7744 
    except TransactionServiceException, ex:
7745 
      result.ex = ex
7746 
    oprot.writeMessageBegin("getReturnableOrdersForCustomer", TMessageType.REPLY, seqid)
7747 
    result.write(oprot)
7748 
    oprot.writeMessageEnd()
7749 
    oprot.trans.flush()
7750 
 
7751 
  def process_getCancellableOrdersForCustomer(self, seqid, iprot, oprot):
7752 
    args = getCancellableOrdersForCustomer_args()
7753 
    args.read(iprot)
7754 
    iprot.readMessageEnd()
7755 
    result = getCancellableOrdersForCustomer_result()
7756 
    try:
7757 
      result.success = self._handler.getCancellableOrdersForCustomer(args.customer_id, args.limit)
7758 
    except TransactionServiceException, ex:
7759 
      result.ex = ex
7760 
    oprot.writeMessageBegin("getCancellableOrdersForCustomer", TMessageType.REPLY, seqid)
7761 
    result.write(oprot)
7762 
    oprot.writeMessageEnd()
7763 
    oprot.trans.flush()
7764 
 
483 rajveer 7765 
  def process_changeOrderStatus(self, seqid, iprot, oprot):
7766 
    args = changeOrderStatus_args()
94 ashish 7767 
    args.read(iprot)
7768 
    iprot.readMessageEnd()
483 rajveer 7769 
    result = changeOrderStatus_result()
94 ashish 7770 
    try:
483 rajveer 7771 
      result.success = self._handler.changeOrderStatus(args.orderId, args.status, args.description)
94 ashish 7772 
    except TransactionServiceException, ex:
7773 
      result.ex = ex
483 rajveer 7774 
    oprot.writeMessageBegin("changeOrderStatus", TMessageType.REPLY, seqid)
94 ashish 7775 
    result.write(oprot)
7776 
    oprot.writeMessageEnd()
7777 
    oprot.trans.flush()
7778 
 
483 rajveer 7779 
  def process_getOrdersForTransaction(self, seqid, iprot, oprot):
7780 
    args = getOrdersForTransaction_args()
94 ashish 7781 
    args.read(iprot)
7782 
    iprot.readMessageEnd()
483 rajveer 7783 
    result = getOrdersForTransaction_result()
94 ashish 7784 
    try:
1528 ankur.sing 7785 
      result.success = self._handler.getOrdersForTransaction(args.transactionId, args.customerId)
94 ashish 7786 
    except TransactionServiceException, ex:
7787 
      result.ex = ex
483 rajveer 7788 
    oprot.writeMessageBegin("getOrdersForTransaction", TMessageType.REPLY, seqid)
94 ashish 7789 
    result.write(oprot)
7790 
    oprot.writeMessageEnd()
7791 
    oprot.trans.flush()
7792 
 
483 rajveer 7793 
  def process_getOrdersForCustomer(self, seqid, iprot, oprot):
7794 
    args = getOrdersForCustomer_args()
94 ashish 7795 
    args.read(iprot)
7796 
    iprot.readMessageEnd()
483 rajveer 7797 
    result = getOrdersForCustomer_result()
94 ashish 7798 
    try:
3014 chandransh 7799 
      result.success = self._handler.getOrdersForCustomer(args.customerId, args.from_date, args.to_date, args.statuses)
94 ashish 7800 
    except TransactionServiceException, ex:
7801 
      result.ex = ex
483 rajveer 7802 
    oprot.writeMessageBegin("getOrdersForCustomer", TMessageType.REPLY, seqid)
94 ashish 7803 
    result.write(oprot)
7804 
    oprot.writeMessageEnd()
7805 
    oprot.trans.flush()
7806 
 
483 rajveer 7807 
  def process_createOrder(self, seqid, iprot, oprot):
7808 
    args = createOrder_args()
94 ashish 7809 
    args.read(iprot)
7810 
    iprot.readMessageEnd()
483 rajveer 7811 
    result = createOrder_result()
94 ashish 7812 
    try:
483 rajveer 7813 
      result.success = self._handler.createOrder(args.order)
94 ashish 7814 
    except TransactionServiceException, ex:
7815 
      result.ex = ex
483 rajveer 7816 
    oprot.writeMessageBegin("createOrder", TMessageType.REPLY, seqid)
94 ashish 7817 
    result.write(oprot)
7818 
    oprot.writeMessageEnd()
7819 
    oprot.trans.flush()
7820 
 
483 rajveer 7821 
  def process_getOrder(self, seqid, iprot, oprot):
7822 
    args = getOrder_args()
94 ashish 7823 
    args.read(iprot)
7824 
    iprot.readMessageEnd()
483 rajveer 7825 
    result = getOrder_result()
94 ashish 7826 
    try:
483 rajveer 7827 
      result.success = self._handler.getOrder(args.id)
94 ashish 7828 
    except TransactionServiceException, ex:
7829 
      result.ex = ex
483 rajveer 7830 
    oprot.writeMessageBegin("getOrder", TMessageType.REPLY, seqid)
94 ashish 7831 
    result.write(oprot)
7832 
    oprot.writeMessageEnd()
7833 
    oprot.trans.flush()
7834 
 
483 rajveer 7835 
  def process_getLineItemsForOrder(self, seqid, iprot, oprot):
7836 
    args = getLineItemsForOrder_args()
94 ashish 7837 
    args.read(iprot)
7838 
    iprot.readMessageEnd()
483 rajveer 7839 
    result = getLineItemsForOrder_result()
94 ashish 7840 
    try:
483 rajveer 7841 
      result.success = self._handler.getLineItemsForOrder(args.orderId)
94 ashish 7842 
    except TransactionServiceException, ex:
7843 
      result.ex = ex
483 rajveer 7844 
    oprot.writeMessageBegin("getLineItemsForOrder", TMessageType.REPLY, seqid)
94 ashish 7845 
    result.write(oprot)
7846 
    oprot.writeMessageEnd()
7847 
    oprot.trans.flush()
7848 
 
4999 phani.kuma 7849 
  def process_getOrderList(self, seqid, iprot, oprot):
7850 
    args = getOrderList_args()
7851 
    args.read(iprot)
7852 
    iprot.readMessageEnd()
7853 
    result = getOrderList_result()
7854 
    result.success = self._handler.getOrderList(args.order_ids)
7855 
    oprot.writeMessageBegin("getOrderList", TMessageType.REPLY, seqid)
7856 
    result.write(oprot)
7857 
    oprot.writeMessageEnd()
7858 
    oprot.trans.flush()
7859 
 
5386 phani.kuma 7860 
  def process_getOrderListForVendor(self, seqid, iprot, oprot):
7861 
    args = getOrderListForVendor_args()
7862 
    args.read(iprot)
7863 
    iprot.readMessageEnd()
7864 
    result = getOrderListForVendor_result()
7865 
    result.success = self._handler.getOrderListForVendor(args.order_ids, args.vendorId)
7866 
    oprot.writeMessageBegin("getOrderListForVendor", TMessageType.REPLY, seqid)
7867 
    result.write(oprot)
7868 
    oprot.writeMessageEnd()
7869 
    oprot.trans.flush()
7870 
 
1528 ankur.sing 7871 
  def process_getOrderForCustomer(self, seqid, iprot, oprot):
7872 
    args = getOrderForCustomer_args()
7873 
    args.read(iprot)
7874 
    iprot.readMessageEnd()
7875 
    result = getOrderForCustomer_result()
7876 
    try:
7877 
      result.success = self._handler.getOrderForCustomer(args.orderId, args.customerId)
7878 
    except TransactionServiceException, ex:
7879 
      result.ex = ex
7880 
    oprot.writeMessageBegin("getOrderForCustomer", TMessageType.REPLY, seqid)
7881 
    result.write(oprot)
7882 
    oprot.writeMessageEnd()
7883 
    oprot.trans.flush()
7884 
 
3064 chandransh 7885 
  def process_getAlerts(self, seqid, iprot, oprot):
7886 
    args = getAlerts_args()
7887 
    args.read(iprot)
7888 
    iprot.readMessageEnd()
7889 
    result = getAlerts_result()
4444 rajveer 7890 
    result.success = self._handler.getAlerts(args.type, args.warehouseId, args.status, args.timestamp)
3064 chandransh 7891 
    oprot.writeMessageBegin("getAlerts", TMessageType.REPLY, seqid)
7892 
    result.write(oprot)
7893 
    oprot.writeMessageEnd()
7894 
    oprot.trans.flush()
7895 
 
4394 rajveer 7896 
  def process_addAlert(self, seqid, iprot, oprot):
7897 
    args = addAlert_args()
3064 chandransh 7898 
    args.read(iprot)
7899 
    iprot.readMessageEnd()
4394 rajveer 7900 
    result = addAlert_result()
4444 rajveer 7901 
    self._handler.addAlert(args.type, args.warehouseId, args.description)
4394 rajveer 7902 
    oprot.writeMessageBegin("addAlert", TMessageType.REPLY, seqid)
3064 chandransh 7903 
    result.write(oprot)
7904 
    oprot.writeMessageEnd()
7905 
    oprot.trans.flush()
7906 
 
4444 rajveer 7907 
  def process_markAlertsAsSeen(self, seqid, iprot, oprot):
7908 
    args = markAlertsAsSeen_args()
7909 
    args.read(iprot)
7910 
    iprot.readMessageEnd()
7911 
    result = markAlertsAsSeen_result()
7912 
    self._handler.markAlertsAsSeen(args.warehouseId)
7913 
    oprot.writeMessageBegin("markAlertsAsSeen", TMessageType.REPLY, seqid)
7914 
    result.write(oprot)
7915 
    oprot.writeMessageEnd()
7916 
    oprot.trans.flush()
7917 
 
3064 chandransh 7918 
  def process_getValidOrderCount(self, seqid, iprot, oprot):
7919 
    args = getValidOrderCount_args()
7920 
    args.read(iprot)
7921 
    iprot.readMessageEnd()
7922 
    result = getValidOrderCount_result()
7923 
    result.success = self._handler.getValidOrderCount()
7924 
    oprot.writeMessageBegin("getValidOrderCount", TMessageType.REPLY, seqid)
7925 
    result.write(oprot)
7926 
    oprot.writeMessageEnd()
7927 
    oprot.trans.flush()
7928 
 
7929 
  def process_getNoOfCustomersWithSuccessfulTransaction(self, seqid, iprot, oprot):
7930 
    args = getNoOfCustomersWithSuccessfulTransaction_args()
7931 
    args.read(iprot)
7932 
    iprot.readMessageEnd()
7933 
    result = getNoOfCustomersWithSuccessfulTransaction_result()
7934 
    result.success = self._handler.getNoOfCustomersWithSuccessfulTransaction()
7935 
    oprot.writeMessageBegin("getNoOfCustomersWithSuccessfulTransaction", TMessageType.REPLY, seqid)
7936 
    result.write(oprot)
7937 
    oprot.writeMessageEnd()
7938 
    oprot.trans.flush()
7939 
 
7940 
  def process_getValidOrdersAmountRange(self, seqid, iprot, oprot):
7941 
    args = getValidOrdersAmountRange_args()
7942 
    args.read(iprot)
7943 
    iprot.readMessageEnd()
7944 
    result = getValidOrdersAmountRange_result()
7945 
    result.success = self._handler.getValidOrdersAmountRange()
7946 
    oprot.writeMessageBegin("getValidOrdersAmountRange", TMessageType.REPLY, seqid)
7947 
    result.write(oprot)
7948 
    oprot.writeMessageEnd()
7949 
    oprot.trans.flush()
7950 
 
7951 
  def process_getValidOrders(self, seqid, iprot, oprot):
7952 
    args = getValidOrders_args()
7953 
    args.read(iprot)
7954 
    iprot.readMessageEnd()
7955 
    result = getValidOrders_result()
5874 rajveer 7956 
    result.success = self._handler.getValidOrders(args.limit, args.onlyStore)
3064 chandransh 7957 
    oprot.writeMessageBegin("getValidOrders", TMessageType.REPLY, seqid)
7958 
    result.write(oprot)
7959 
    oprot.writeMessageEnd()
7960 
    oprot.trans.flush()
7961 
 
1220 chandransh 7962 
  def process_batchOrders(self, seqid, iprot, oprot):
7963 
    args = batchOrders_args()
7964 
    args.read(iprot)
7965 
    iprot.readMessageEnd()
7966 
    result = batchOrders_result()
7967 
    try:
7968 
      result.success = self._handler.batchOrders(args.warehouseId)
7969 
    except TransactionServiceException, ex:
7970 
      result.ex = ex
7971 
    oprot.writeMessageBegin("batchOrders", TMessageType.REPLY, seqid)
7972 
    result.write(oprot)
7973 
    oprot.writeMessageEnd()
7974 
    oprot.trans.flush()
7975 
 
1208 chandransh 7976 
  def process_markOrderAsOutOfStock(self, seqid, iprot, oprot):
7977 
    args = markOrderAsOutOfStock_args()
7978 
    args.read(iprot)
7979 
    iprot.readMessageEnd()
7980 
    result = markOrderAsOutOfStock_result()
7981 
    try:
7982 
      result.success = self._handler.markOrderAsOutOfStock(args.orderId)
7983 
    except TransactionServiceException, ex:
7984 
      result.ex = ex
7985 
    oprot.writeMessageBegin("markOrderAsOutOfStock", TMessageType.REPLY, seqid)
7986 
    result.write(oprot)
7987 
    oprot.writeMessageEnd()
7988 
    oprot.trans.flush()
7989 
 
3064 chandransh 7990 
  def process_verifyOrder(self, seqid, iprot, oprot):
7991 
    args = verifyOrder_args()
759 chandransh 7992 
    args.read(iprot)
7993 
    iprot.readMessageEnd()
3064 chandransh 7994 
    result = verifyOrder_result()
759 chandransh 7995 
    try:
3064 chandransh 7996 
      result.success = self._handler.verifyOrder(args.orderId)
759 chandransh 7997 
    except TransactionServiceException, ex:
7998 
      result.ex = ex
3064 chandransh 7999 
    oprot.writeMessageBegin("verifyOrder", TMessageType.REPLY, seqid)
759 chandransh 8000 
    result.write(oprot)
8001 
    oprot.writeMessageEnd()
8002 
    oprot.trans.flush()
8003 
 
3064 chandransh 8004 
  def process_acceptOrder(self, seqid, iprot, oprot):
8005 
    args = acceptOrder_args()
1113 chandransh 8006 
    args.read(iprot)
8007 
    iprot.readMessageEnd()
3064 chandransh 8008 
    result = acceptOrder_result()
1113 chandransh 8009 
    try:
3064 chandransh 8010 
      result.success = self._handler.acceptOrder(args.orderId)
1113 chandransh 8011 
    except TransactionServiceException, ex:
8012 
      result.ex = ex
3064 chandransh 8013 
    oprot.writeMessageBegin("acceptOrder", TMessageType.REPLY, seqid)
1113 chandransh 8014 
    result.write(oprot)
8015 
    oprot.writeMessageEnd()
8016 
    oprot.trans.flush()
8017 
 
3064 chandransh 8018 
  def process_addBillingDetails(self, seqid, iprot, oprot):
8019 
    args = addBillingDetails_args()
1135 chandransh 8020 
    args.read(iprot)
8021 
    iprot.readMessageEnd()
3064 chandransh 8022 
    result = addBillingDetails_result()
1135 chandransh 8023 
    try:
7190 amar.kumar 8024 
      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 8025 
    except TransactionServiceException, ex:
8026 
      result.ex = ex
3064 chandransh 8027 
    oprot.writeMessageBegin("addBillingDetails", TMessageType.REPLY, seqid)
1135 chandransh 8028 
    result.write(oprot)
8029 
    oprot.writeMessageEnd()
8030 
    oprot.trans.flush()
8031 
 
4579 rajveer 8032 
  def process_addInvoiceNumber(self, seqid, iprot, oprot):
8033 
    args = addInvoiceNumber_args()
8034 
    args.read(iprot)
8035 
    iprot.readMessageEnd()
8036 
    result = addInvoiceNumber_result()
8037 
    try:
6756 amar.kumar 8038 
      self._handler.addInvoiceNumber(args.orderId, args.invoiceNumber, args.color, args.serialNumber, args.itemNumber)
4579 rajveer 8039 
    except TransactionServiceException, ex:
8040 
      result.ex = ex
8041 
    oprot.writeMessageBegin("addInvoiceNumber", TMessageType.REPLY, seqid)
8042 
    result.write(oprot)
8043 
    oprot.writeMessageEnd()
8044 
    oprot.trans.flush()
8045 
 
4410 rajveer 8046 
  def process_markOrdersAsShippedFromWarehouse(self, seqid, iprot, oprot):
8047 
    args = markOrdersAsShippedFromWarehouse_args()
8048 
    args.read(iprot)
8049 
    iprot.readMessageEnd()
8050 
    result = markOrdersAsShippedFromWarehouse_result()
8051 
    try:
4789 rajveer 8052 
      result.success = self._handler.markOrdersAsShippedFromWarehouse(args.warehouseId, args.providerId, args.cod, args.orderIds)
4410 rajveer 8053 
    except TransactionServiceException, ex:
8054 
      result.ex = ex
8055 
    oprot.writeMessageBegin("markOrdersAsShippedFromWarehouse", TMessageType.REPLY, seqid)
8056 
    result.write(oprot)
8057 
    oprot.writeMessageEnd()
8058 
    oprot.trans.flush()
8059 
 
5676 rajveer 8060 
  def process_markOrdersAsReturnedFromStore(self, seqid, iprot, oprot):
8061 
    args = markOrdersAsReturnedFromStore_args()
8062 
    args.read(iprot)
8063 
    iprot.readMessageEnd()
8064 
    result = markOrdersAsReturnedFromStore_result()
8065 
    try:
5713 rajveer 8066 
      result.success = self._handler.markOrdersAsReturnedFromStore(args.providerId, args.orderIds, args.awbs)
5676 rajveer 8067 
    except TransactionServiceException, ex:
8068 
      result.ex = ex
8069 
    oprot.writeMessageBegin("markOrdersAsReturnedFromStore", TMessageType.REPLY, seqid)
8070 
    result.write(oprot)
8071 
    oprot.writeMessageEnd()
8072 
    oprot.trans.flush()
8073 
 
3064 chandransh 8074 
  def process_markOrdersAsPickedUp(self, seqid, iprot, oprot):
8075 
    args = markOrdersAsPickedUp_args()
304 ashish 8076 
    args.read(iprot)
8077 
    iprot.readMessageEnd()
3064 chandransh 8078 
    result = markOrdersAsPickedUp_result()
8079 
    try:
4910 phani.kuma 8080 
      self._handler.markOrdersAsPickedUp(args.providerId, args.pickupDetails)
3064 chandransh 8081 
    except TransactionServiceException, ex:
8082 
      result.ex = ex
8083 
    oprot.writeMessageBegin("markOrdersAsPickedUp", TMessageType.REPLY, seqid)
304 ashish 8084 
    result.write(oprot)
8085 
    oprot.writeMessageEnd()
8086 
    oprot.trans.flush()
94 ashish 8087 
 
4910 phani.kuma 8088 
  def process_getOrdersNotPickedUp(self, seqid, iprot, oprot):
8089 
    args = getOrdersNotPickedUp_args()
8090 
    args.read(iprot)
8091 
    iprot.readMessageEnd()
8092 
    result = getOrdersNotPickedUp_result()
8093 
    result.success = self._handler.getOrdersNotPickedUp(args.providerId)
8094 
    oprot.writeMessageBegin("getOrdersNotPickedUp", TMessageType.REPLY, seqid)
8095 
    result.write(oprot)
8096 
    oprot.writeMessageEnd()
8097 
    oprot.trans.flush()
8098 
 
3064 chandransh 8099 
  def process_markOrdersAsDelivered(self, seqid, iprot, oprot):
8100 
    args = markOrdersAsDelivered_args()
304 ashish 8101 
    args.read(iprot)
8102 
    iprot.readMessageEnd()
3064 chandransh 8103 
    result = markOrdersAsDelivered_result()
8104 
    try:
8105 
      self._handler.markOrdersAsDelivered(args.providerId, args.deliveredOrders)
8106 
    except TransactionServiceException, ex:
8107 
      result.ex = ex
8108 
    oprot.writeMessageBegin("markOrdersAsDelivered", TMessageType.REPLY, seqid)
304 ashish 8109 
    result.write(oprot)
8110 
    oprot.writeMessageEnd()
8111 
    oprot.trans.flush()
8112 
 
4910 phani.kuma 8113 
  def process_markAsRTOrders(self, seqid, iprot, oprot):
8114 
    args = markAsRTOrders_args()
1596 ankur.sing 8115 
    args.read(iprot)
8116 
    iprot.readMessageEnd()
4910 phani.kuma 8117 
    result = markAsRTOrders_result()
3064 chandransh 8118 
    try:
4910 phani.kuma 8119 
      self._handler.markAsRTOrders(args.providerId, args.returnedOrders)
3064 chandransh 8120 
    except TransactionServiceException, ex:
8121 
      result.ex = ex
4910 phani.kuma 8122 
    oprot.writeMessageBegin("markAsRTOrders", TMessageType.REPLY, seqid)
1596 ankur.sing 8123 
    result.write(oprot)
8124 
    oprot.writeMessageEnd()
8125 
    oprot.trans.flush()
304 ashish 8126 
 
4910 phani.kuma 8127 
  def process_getRTOrders(self, seqid, iprot, oprot):
8128 
    args = getRTOrders_args()
8129 
    args.read(iprot)
8130 
    iprot.readMessageEnd()
8131 
    result = getRTOrders_result()
8132 
    result.success = self._handler.getRTOrders(args.providerId)
8133 
    oprot.writeMessageBegin("getRTOrders", TMessageType.REPLY, seqid)
8134 
    result.write(oprot)
8135 
    oprot.writeMessageEnd()
8136 
    oprot.trans.flush()
8137 
 
3064 chandransh 8138 
  def process_updateNonDeliveryReason(self, seqid, iprot, oprot):
8139 
    args = updateNonDeliveryReason_args()
1627 ankur.sing 8140 
    args.read(iprot)
8141 
    iprot.readMessageEnd()
3064 chandransh 8142 
    result = updateNonDeliveryReason_result()
8143 
    try:
4910 phani.kuma 8144 
      self._handler.updateNonDeliveryReason(args.providerId, args.undeliveredOrders)
3064 chandransh 8145 
    except TransactionServiceException, ex:
8146 
      result.ex = ex
8147 
    oprot.writeMessageBegin("updateNonDeliveryReason", TMessageType.REPLY, seqid)
1627 ankur.sing 8148 
    result.write(oprot)
8149 
    oprot.writeMessageEnd()
8150 
    oprot.trans.flush()
1596 ankur.sing 8151 
 
4910 phani.kuma 8152 
  def process_getNonDeliveredOrdersbyCourier(self, seqid, iprot, oprot):
8153 
    args = getNonDeliveredOrdersbyCourier_args()
8154 
    args.read(iprot)
8155 
    iprot.readMessageEnd()
8156 
    result = getNonDeliveredOrdersbyCourier_result()
8157 
    result.success = self._handler.getNonDeliveredOrdersbyCourier(args.providerId)
8158 
    oprot.writeMessageBegin("getNonDeliveredOrdersbyCourier", TMessageType.REPLY, seqid)
8159 
    result.write(oprot)
8160 
    oprot.writeMessageEnd()
8161 
    oprot.trans.flush()
8162 
 
8163 
  def process_markOrdersAsLocalConnected(self, seqid, iprot, oprot):
8164 
    args = markOrdersAsLocalConnected_args()
8165 
    args.read(iprot)
8166 
    iprot.readMessageEnd()
8167 
    result = markOrdersAsLocalConnected_result()
8168 
    try:
8169 
      self._handler.markOrdersAsLocalConnected(args.providerId, args.local_connected_orders)
8170 
    except TransactionServiceException, ex:
8171 
      result.ex = ex
8172 
    oprot.writeMessageBegin("markOrdersAsLocalConnected", TMessageType.REPLY, seqid)
8173 
    result.write(oprot)
8174 
    oprot.writeMessageEnd()
8175 
    oprot.trans.flush()
8176 
 
8177 
  def process_getOrdersNotLocalConnected(self, seqid, iprot, oprot):
8178 
    args = getOrdersNotLocalConnected_args()
8179 
    args.read(iprot)
8180 
    iprot.readMessageEnd()
8181 
    result = getOrdersNotLocalConnected_result()
8182 
    result.success = self._handler.getOrdersNotLocalConnected(args.providerId)
8183 
    oprot.writeMessageBegin("getOrdersNotLocalConnected", TMessageType.REPLY, seqid)
8184 
    result.write(oprot)
8185 
    oprot.writeMessageEnd()
8186 
    oprot.trans.flush()
8187 
 
8188 
  def process_markOrdersAsDestinationCityReached(self, seqid, iprot, oprot):
8189 
    args = markOrdersAsDestinationCityReached_args()
8190 
    args.read(iprot)
8191 
    iprot.readMessageEnd()
8192 
    result = markOrdersAsDestinationCityReached_result()
8193 
    try:
8194 
      self._handler.markOrdersAsDestinationCityReached(args.providerId, args.destination_city_reached_orders)
8195 
    except TransactionServiceException, ex:
8196 
      result.ex = ex
8197 
    oprot.writeMessageBegin("markOrdersAsDestinationCityReached", TMessageType.REPLY, seqid)
8198 
    result.write(oprot)
8199 
    oprot.writeMessageEnd()
8200 
    oprot.trans.flush()
8201 
 
8202 
  def process_markOrdersAsFirstDeliveryAttempted(self, seqid, iprot, oprot):
8203 
    args = markOrdersAsFirstDeliveryAttempted_args()
8204 
    args.read(iprot)
8205 
    iprot.readMessageEnd()
8206 
    result = markOrdersAsFirstDeliveryAttempted_result()
8207 
    try:
8208 
      self._handler.markOrdersAsFirstDeliveryAttempted(args.providerId, args.first_atdl_orders)
8209 
    except TransactionServiceException, ex:
8210 
      result.ex = ex
8211 
    oprot.writeMessageBegin("markOrdersAsFirstDeliveryAttempted", TMessageType.REPLY, seqid)
8212 
    result.write(oprot)
8213 
    oprot.writeMessageEnd()
8214 
    oprot.trans.flush()
8215 
 
3064 chandransh 8216 
  def process_getUndeliveredOrders(self, seqid, iprot, oprot):
8217 
    args = getUndeliveredOrders_args()
1627 ankur.sing 8218 
    args.read(iprot)
8219 
    iprot.readMessageEnd()
3064 chandransh 8220 
    result = getUndeliveredOrders_result()
8221 
    result.success = self._handler.getUndeliveredOrders(args.providerId, args.warehouseId)
8222 
    oprot.writeMessageBegin("getUndeliveredOrders", TMessageType.REPLY, seqid)
1627 ankur.sing 8223 
    result.write(oprot)
8224 
    oprot.writeMessageEnd()
8225 
    oprot.trans.flush()
8226 
 
4783 phani.kuma 8227 
  def process_getUndeliveredOrdersExpectedDeliveryDateNotMet(self, seqid, iprot, oprot):
8228 
    args = getUndeliveredOrdersExpectedDeliveryDateNotMet_args()
8229 
    args.read(iprot)
8230 
    iprot.readMessageEnd()
8231 
    result = getUndeliveredOrdersExpectedDeliveryDateNotMet_result()
8232 
    result.success = self._handler.getUndeliveredOrdersExpectedDeliveryDateNotMet()
8233 
    oprot.writeMessageBegin("getUndeliveredOrdersExpectedDeliveryDateNotMet", TMessageType.REPLY, seqid)
8234 
    result.write(oprot)
8235 
    oprot.writeMessageEnd()
8236 
    oprot.trans.flush()
8237 
 
2536 chandransh 8238 
  def process_toggleDOAFlag(self, seqid, iprot, oprot):
8239 
    args = toggleDOAFlag_args()
8240 
    args.read(iprot)
8241 
    iprot.readMessageEnd()
8242 
    result = toggleDOAFlag_result()
8243 
    try:
8244 
      result.success = self._handler.toggleDOAFlag(args.orderId)
8245 
    except TransactionServiceException, ex:
8246 
      result.ex = ex
8247 
    oprot.writeMessageBegin("toggleDOAFlag", TMessageType.REPLY, seqid)
8248 
    result.write(oprot)
8249 
    oprot.writeMessageEnd()
8250 
    oprot.trans.flush()
1886 ankur.sing 8251 
 
4712 rajveer 8252 
  def process_markOrderAsDelivered(self, seqid, iprot, oprot):
8253 
    args = markOrderAsDelivered_args()
8254 
    args.read(iprot)
8255 
    iprot.readMessageEnd()
8256 
    result = markOrderAsDelivered_result()
8257 
    try:
8258 
      self._handler.markOrderAsDelivered(args.orderId, args.deliveryTimestamp, args.receiver)
8259 
    except TransactionServiceException, ex:
8260 
      result.ex = ex
8261 
    oprot.writeMessageBegin("markOrderAsDelivered", TMessageType.REPLY, seqid)
8262 
    result.write(oprot)
8263 
    oprot.writeMessageEnd()
8264 
    oprot.trans.flush()
8265 
 
5553 rajveer 8266 
  def process_markOrderAsReceivedAtStore(self, seqid, iprot, oprot):
8267 
    args = markOrderAsReceivedAtStore_args()
8268 
    args.read(iprot)
8269 
    iprot.readMessageEnd()
8270 
    result = markOrderAsReceivedAtStore_result()
8271 
    try:
8272 
      self._handler.markOrderAsReceivedAtStore(args.orderId, args.deliveryTimestamp)
8273 
    except TransactionServiceException, ex:
8274 
      result.ex = ex
8275 
    oprot.writeMessageBegin("markOrderAsReceivedAtStore", TMessageType.REPLY, seqid)
8276 
    result.write(oprot)
8277 
    oprot.writeMessageEnd()
8278 
    oprot.trans.flush()
8279 
 
4454 rajveer 8280 
  def process_markOrderDoaRequestReceived(self, seqid, iprot, oprot):
8281 
    args = markOrderDoaRequestReceived_args()
8282 
    args.read(iprot)
8283 
    iprot.readMessageEnd()
8284 
    result = markOrderDoaRequestReceived_result()
8285 
    try:
8286 
      result.success = self._handler.markOrderDoaRequestReceived(args.orderId)
8287 
    except TransactionServiceException, ex:
8288 
      result.ex = ex
8289 
    oprot.writeMessageBegin("markOrderDoaRequestReceived", TMessageType.REPLY, seqid)
8290 
    result.write(oprot)
8291 
    oprot.writeMessageEnd()
8292 
    oprot.trans.flush()
8293 
 
8294 
  def process_markOrderDoaRequestAuthorized(self, seqid, iprot, oprot):
8295 
    args = markOrderDoaRequestAuthorized_args()
8296 
    args.read(iprot)
8297 
    iprot.readMessageEnd()
8298 
    result = markOrderDoaRequestAuthorized_result()
8299 
    try:
8300 
      result.success = self._handler.markOrderDoaRequestAuthorized(args.orderId, args.isAuthorized)
8301 
    except TransactionServiceException, ex:
8302 
      result.ex = ex
8303 
    oprot.writeMessageBegin("markOrderDoaRequestAuthorized", TMessageType.REPLY, seqid)
8304 
    result.write(oprot)
8305 
    oprot.writeMessageEnd()
8306 
    oprot.trans.flush()
8307 
 
4488 rajveer 8308 
  def process_markOrderReturnRequestReceived(self, seqid, iprot, oprot):
8309 
    args = markOrderReturnRequestReceived_args()
8310 
    args.read(iprot)
8311 
    iprot.readMessageEnd()
8312 
    result = markOrderReturnRequestReceived_result()
8313 
    try:
8314 
      result.success = self._handler.markOrderReturnRequestReceived(args.orderId)
8315 
    except TransactionServiceException, ex:
8316 
      result.ex = ex
8317 
    oprot.writeMessageBegin("markOrderReturnRequestReceived", TMessageType.REPLY, seqid)
8318 
    result.write(oprot)
8319 
    oprot.writeMessageEnd()
8320 
    oprot.trans.flush()
8321 
 
8322 
  def process_markOrderReturnRequestAuthorized(self, seqid, iprot, oprot):
8323 
    args = markOrderReturnRequestAuthorized_args()
8324 
    args.read(iprot)
8325 
    iprot.readMessageEnd()
8326 
    result = markOrderReturnRequestAuthorized_result()
8327 
    try:
8328 
      result.success = self._handler.markOrderReturnRequestAuthorized(args.orderId, args.isAuthorized)
8329 
    except TransactionServiceException, ex:
8330 
      result.ex = ex
8331 
    oprot.writeMessageBegin("markOrderReturnRequestAuthorized", TMessageType.REPLY, seqid)
8332 
    result.write(oprot)
8333 
    oprot.writeMessageEnd()
8334 
    oprot.trans.flush()
8335 
 
2536 chandransh 8336 
  def process_requestPickupNumber(self, seqid, iprot, oprot):
8337 
    args = requestPickupNumber_args()
8338 
    args.read(iprot)
8339 
    iprot.readMessageEnd()
8340 
    result = requestPickupNumber_result()
8341 
    try:
4579 rajveer 8342 
      result.success = self._handler.requestPickupNumber(args.orderId, args.providerId)
2536 chandransh 8343 
    except TransactionServiceException, ex:
8344 
      result.ex = ex
8345 
    oprot.writeMessageBegin("requestPickupNumber", TMessageType.REPLY, seqid)
8346 
    result.write(oprot)
8347 
    oprot.writeMessageEnd()
8348 
    oprot.trans.flush()
8349 
 
8350 
  def process_authorizePickup(self, seqid, iprot, oprot):
8351 
    args = authorizePickup_args()
8352 
    args.read(iprot)
8353 
    iprot.readMessageEnd()
8354 
    result = authorizePickup_result()
8355 
    try:
4602 rajveer 8356 
      result.success = self._handler.authorizePickup(args.orderId, args.pickupNumber, args.providerId)
2536 chandransh 8357 
    except TransactionServiceException, ex:
8358 
      result.ex = ex
8359 
    oprot.writeMessageBegin("authorizePickup", TMessageType.REPLY, seqid)
8360 
    result.write(oprot)
8361 
    oprot.writeMessageEnd()
8362 
    oprot.trans.flush()
8363 
 
2764 chandransh 8364 
  def process_markDoasAsPickedUp(self, seqid, iprot, oprot):
8365 
    args = markDoasAsPickedUp_args()
8366 
    args.read(iprot)
8367 
    iprot.readMessageEnd()
8368 
    result = markDoasAsPickedUp_result()
4910 phani.kuma 8369 
    self._handler.markDoasAsPickedUp(args.providerId, args.pickupDetails)
2764 chandransh 8370 
    oprot.writeMessageBegin("markDoasAsPickedUp", TMessageType.REPLY, seqid)
8371 
    result.write(oprot)
8372 
    oprot.writeMessageEnd()
8373 
    oprot.trans.flush()
8374 
 
4910 phani.kuma 8375 
  def process_getDoasNotPickedUp(self, seqid, iprot, oprot):
8376 
    args = getDoasNotPickedUp_args()
8377 
    args.read(iprot)
8378 
    iprot.readMessageEnd()
8379 
    result = getDoasNotPickedUp_result()
8380 
    result.success = self._handler.getDoasNotPickedUp(args.providerId)
8381 
    oprot.writeMessageBegin("getDoasNotPickedUp", TMessageType.REPLY, seqid)
8382 
    result.write(oprot)
8383 
    oprot.writeMessageEnd()
8384 
    oprot.trans.flush()
8385 
 
4741 phani.kuma 8386 
  def process_markReturnOrdersAsPickedUp(self, seqid, iprot, oprot):
8387 
    args = markReturnOrdersAsPickedUp_args()
8388 
    args.read(iprot)
8389 
    iprot.readMessageEnd()
8390 
    result = markReturnOrdersAsPickedUp_result()
4910 phani.kuma 8391 
    self._handler.markReturnOrdersAsPickedUp(args.providerId, args.pickupDetails)
4741 phani.kuma 8392 
    oprot.writeMessageBegin("markReturnOrdersAsPickedUp", TMessageType.REPLY, seqid)
8393 
    result.write(oprot)
8394 
    oprot.writeMessageEnd()
8395 
    oprot.trans.flush()
8396 
 
4910 phani.kuma 8397 
  def process_getReturnOrdersNotPickedUp(self, seqid, iprot, oprot):
8398 
    args = getReturnOrdersNotPickedUp_args()
8399 
    args.read(iprot)
8400 
    iprot.readMessageEnd()
8401 
    result = getReturnOrdersNotPickedUp_result()
8402 
    result.success = self._handler.getReturnOrdersNotPickedUp(args.providerId)
8403 
    oprot.writeMessageBegin("getReturnOrdersNotPickedUp", TMessageType.REPLY, seqid)
8404 
    result.write(oprot)
8405 
    oprot.writeMessageEnd()
8406 
    oprot.trans.flush()
8407 
 
2616 chandransh 8408 
  def process_receiveReturn(self, seqid, iprot, oprot):
8409 
    args = receiveReturn_args()
2591 chandransh 8410 
    args.read(iprot)
8411 
    iprot.readMessageEnd()
2616 chandransh 8412 
    result = receiveReturn_result()
2591 chandransh 8413 
    try:
4479 rajveer 8414 
      result.success = self._handler.receiveReturn(args.orderId, args.receiveCondition)
2591 chandransh 8415 
    except TransactionServiceException, ex:
8416 
      result.ex = ex
2616 chandransh 8417 
    oprot.writeMessageBegin("receiveReturn", TMessageType.REPLY, seqid)
2591 chandransh 8418 
    result.write(oprot)
8419 
    oprot.writeMessageEnd()
8420 
    oprot.trans.flush()
2536 chandransh 8421 
 
2591 chandransh 8422 
  def process_validateDoa(self, seqid, iprot, oprot):
8423 
    args = validateDoa_args()
8424 
    args.read(iprot)
8425 
    iprot.readMessageEnd()
8426 
    result = validateDoa_result()
8427 
    try:
8428 
      result.success = self._handler.validateDoa(args.orderId, args.isValid)
8429 
    except TransactionServiceException, ex:
8430 
      result.ex = ex
8431 
    oprot.writeMessageBegin("validateDoa", TMessageType.REPLY, seqid)
8432 
    result.write(oprot)
8433 
    oprot.writeMessageEnd()
8434 
    oprot.trans.flush()
8435 
 
4495 rajveer 8436 
  def process_validateReturnProduct(self, seqid, iprot, oprot):
8437 
    args = validateReturnProduct_args()
8438 
    args.read(iprot)
8439 
    iprot.readMessageEnd()
8440 
    result = validateReturnProduct_result()
8441 
    try:
8442 
      result.success = self._handler.validateReturnProduct(args.orderId, args.isUsable)
8443 
    except TransactionServiceException, ex:
8444 
      result.ex = ex
8445 
    oprot.writeMessageBegin("validateReturnProduct", TMessageType.REPLY, seqid)
8446 
    result.write(oprot)
8447 
    oprot.writeMessageEnd()
8448 
    oprot.trans.flush()
8449 
 
2616 chandransh 8450 
  def process_reshipOrder(self, seqid, iprot, oprot):
8451 
    args = reshipOrder_args()
8452 
    args.read(iprot)
8453 
    iprot.readMessageEnd()
8454 
    result = reshipOrder_result()
8455 
    try:
8456 
      result.success = self._handler.reshipOrder(args.orderId)
8457 
    except TransactionServiceException, ex:
8458 
      result.ex = ex
8459 
    oprot.writeMessageBegin("reshipOrder", TMessageType.REPLY, seqid)
8460 
    result.write(oprot)
8461 
    oprot.writeMessageEnd()
8462 
    oprot.trans.flush()
2591 chandransh 8463 
 
2616 chandransh 8464 
  def process_refundOrder(self, seqid, iprot, oprot):
8465 
    args = refundOrder_args()
8466 
    args.read(iprot)
8467 
    iprot.readMessageEnd()
8468 
    result = refundOrder_result()
8469 
    try:
3226 chandransh 8470 
      result.success = self._handler.refundOrder(args.orderId, args.refundedBy, args.reason)
2616 chandransh 8471 
    except TransactionServiceException, ex:
8472 
      result.ex = ex
8473 
    oprot.writeMessageBegin("refundOrder", TMessageType.REPLY, seqid)
8474 
    result.write(oprot)
8475 
    oprot.writeMessageEnd()
8476 
    oprot.trans.flush()
8477 
 
2690 chandransh 8478 
  def process_getReturnOrders(self, seqid, iprot, oprot):
8479 
    args = getReturnOrders_args()
8480 
    args.read(iprot)
8481 
    iprot.readMessageEnd()
8482 
    result = getReturnOrders_result()
8483 
    result.success = self._handler.getReturnOrders(args.warehouseId, args.fromDate, args.toDate)
8484 
    oprot.writeMessageBegin("getReturnOrders", TMessageType.REPLY, seqid)
8485 
    result.write(oprot)
8486 
    oprot.writeMessageEnd()
8487 
    oprot.trans.flush()
2616 chandransh 8488 
 
5481 phani.kuma 8489 
  def process_getAllReturnOrders(self, seqid, iprot, oprot):
8490 
    args = getAllReturnOrders_args()
8491 
    args.read(iprot)
8492 
    iprot.readMessageEnd()
8493 
    result = getAllReturnOrders_result()
8494 
    result.success = self._handler.getAllReturnOrders(args.onlyNotProcessed, args.fromDate, args.toDate)
8495 
    oprot.writeMessageBegin("getAllReturnOrders", TMessageType.REPLY, seqid)
8496 
    result.write(oprot)
8497 
    oprot.writeMessageEnd()
8498 
    oprot.trans.flush()
8499 
 
2700 chandransh 8500 
  def process_getReturnOrder(self, seqid, iprot, oprot):
8501 
    args = getReturnOrder_args()
8502 
    args.read(iprot)
8503 
    iprot.readMessageEnd()
8504 
    result = getReturnOrder_result()
8505 
    try:
8506 
      result.success = self._handler.getReturnOrder(args.id)
8507 
    except TransactionServiceException, ex:
8508 
      result.ex = ex
8509 
    oprot.writeMessageBegin("getReturnOrder", TMessageType.REPLY, seqid)
8510 
    result.write(oprot)
8511 
    oprot.writeMessageEnd()
8512 
    oprot.trans.flush()
8513 
 
2690 chandransh 8514 
  def process_processReturn(self, seqid, iprot, oprot):
8515 
    args = processReturn_args()
8516 
    args.read(iprot)
8517 
    iprot.readMessageEnd()
8518 
    result = processReturn_result()
8519 
    try:
8520 
      self._handler.processReturn(args.returnOrderId)
8521 
    except TransactionServiceException, ex:
8522 
      result.ex = ex
8523 
    oprot.writeMessageBegin("processReturn", TMessageType.REPLY, seqid)
8524 
    result.write(oprot)
8525 
    oprot.writeMessageEnd()
8526 
    oprot.trans.flush()
8527 
 
3451 chandransh 8528 
  def process_updateWeight(self, seqid, iprot, oprot):
8529 
    args = updateWeight_args()
8530 
    args.read(iprot)
8531 
    iprot.readMessageEnd()
8532 
    result = updateWeight_result()
8533 
    try:
8534 
      result.success = self._handler.updateWeight(args.orderId, args.weight)
8535 
    except TransactionServiceException, ex:
8536 
      result.ex = ex
8537 
    oprot.writeMessageBegin("updateWeight", TMessageType.REPLY, seqid)
8538 
    result.write(oprot)
8539 
    oprot.writeMessageEnd()
8540 
    oprot.trans.flush()
2819 chandransh 8541 
 
3469 chandransh 8542 
  def process_changeItem(self, seqid, iprot, oprot):
8543 
    args = changeItem_args()
8544 
    args.read(iprot)
8545 
    iprot.readMessageEnd()
8546 
    result = changeItem_result()
8547 
    try:
8548 
      result.success = self._handler.changeItem(args.orderId, args.itemId)
8549 
    except TransactionServiceException, ex:
8550 
      result.ex = ex
8551 
    oprot.writeMessageBegin("changeItem", TMessageType.REPLY, seqid)
8552 
    result.write(oprot)
8553 
    oprot.writeMessageEnd()
8554 
    oprot.trans.flush()
3451 chandransh 8555 
 
3469 chandransh 8556 
  def process_shiftToWarehouse(self, seqid, iprot, oprot):
8557 
    args = shiftToWarehouse_args()
8558 
    args.read(iprot)
8559 
    iprot.readMessageEnd()
8560 
    result = shiftToWarehouse_result()
8561 
    try:
8562 
      result.success = self._handler.shiftToWarehouse(args.orderId, args.warehouseId)
8563 
    except TransactionServiceException, ex:
8564 
      result.ex = ex
8565 
    oprot.writeMessageBegin("shiftToWarehouse", TMessageType.REPLY, seqid)
8566 
    result.write(oprot)
8567 
    oprot.writeMessageEnd()
8568 
    oprot.trans.flush()
8569 
 
3553 chandransh 8570 
  def process_addDelayReason(self, seqid, iprot, oprot):
8571 
    args = addDelayReason_args()
8572 
    args.read(iprot)
8573 
    iprot.readMessageEnd()
8574 
    result = addDelayReason_result()
8575 
    try:
4647 rajveer 8576 
      result.success = self._handler.addDelayReason(args.orderId, args.delayReason, args.furtherDelay, args.delayReasonText)
3553 chandransh 8577 
    except TransactionServiceException, ex:
8578 
      result.ex = ex
8579 
    oprot.writeMessageBegin("addDelayReason", TMessageType.REPLY, seqid)
8580 
    result.write(oprot)
8581 
    oprot.writeMessageEnd()
8582 
    oprot.trans.flush()
3469 chandransh 8583 
 
3956 chandransh 8584 
  def process_reconcileCodCollection(self, seqid, iprot, oprot):
8585 
    args = reconcileCodCollection_args()
8586 
    args.read(iprot)
8587 
    iprot.readMessageEnd()
8588 
    result = reconcileCodCollection_result()
8589 
    try:
8590 
      result.success = self._handler.reconcileCodCollection(args.collectedAmountMap, args.xferBy, args.xferTxnId, args.xferDate)
8591 
    except TransactionServiceException, ex:
8592 
      result.ex = ex
8593 
    oprot.writeMessageBegin("reconcileCodCollection", TMessageType.REPLY, seqid)
8594 
    result.write(oprot)
8595 
    oprot.writeMessageEnd()
8596 
    oprot.trans.flush()
3553 chandransh 8597 
 
4008 mandeep.dh 8598 
  def process_getTransactionsRequiringExtraProcessing(self, seqid, iprot, oprot):
8599 
    args = getTransactionsRequiringExtraProcessing_args()
8600 
    args.read(iprot)
8601 
    iprot.readMessageEnd()
8602 
    result = getTransactionsRequiringExtraProcessing_result()
8603 
    result.success = self._handler.getTransactionsRequiringExtraProcessing(args.category)
8604 
    oprot.writeMessageBegin("getTransactionsRequiringExtraProcessing", TMessageType.REPLY, seqid)
8605 
    result.write(oprot)
8606 
    oprot.writeMessageEnd()
8607 
    oprot.trans.flush()
3956 chandransh 8608 
 
4008 mandeep.dh 8609 
  def process_markTransactionAsProcessed(self, seqid, iprot, oprot):
8610 
    args = markTransactionAsProcessed_args()
8611 
    args.read(iprot)
8612 
    iprot.readMessageEnd()
8613 
    result = markTransactionAsProcessed_result()
8614 
    self._handler.markTransactionAsProcessed(args.transactionId, args.category)
8615 
    oprot.writeMessageBegin("markTransactionAsProcessed", TMessageType.REPLY, seqid)
8616 
    result.write(oprot)
8617 
    oprot.writeMessageEnd()
8618 
    oprot.trans.flush()
8619 
 
4018 chandransh 8620 
  def process_getItemWiseRiskyOrdersCount(self, seqid, iprot, oprot):
8621 
    args = getItemWiseRiskyOrdersCount_args()
8622 
    args.read(iprot)
8623 
    iprot.readMessageEnd()
8624 
    result = getItemWiseRiskyOrdersCount_result()
8625 
    result.success = self._handler.getItemWiseRiskyOrdersCount()
8626 
    oprot.writeMessageBegin("getItemWiseRiskyOrdersCount", TMessageType.REPLY, seqid)
8627 
    result.write(oprot)
8628 
    oprot.writeMessageEnd()
8629 
    oprot.trans.flush()
4008 mandeep.dh 8630 
 
4295 varun.gupt 8631 
  def process_getOrdersForItemIds(self, seqid, iprot, oprot):
8632 
    args = getOrdersForItemIds_args()
8633 
    args.read(iprot)
8634 
    iprot.readMessageEnd()
8635 
    result = getOrdersForItemIds_result()
8636 
    result.success = self._handler.getOrdersForItemIds(args.itemIds)
8637 
    oprot.writeMessageBegin("getOrdersForItemIds", TMessageType.REPLY, seqid)
8638 
    result.write(oprot)
8639 
    oprot.writeMessageEnd()
8640 
    oprot.trans.flush()
8641 
 
4247 rajveer 8642 
  def process_markOrderCancellationRequestReceived(self, seqid, iprot, oprot):
8643 
    args = markOrderCancellationRequestReceived_args()
8644 
    args.read(iprot)
8645 
    iprot.readMessageEnd()
8646 
    result = markOrderCancellationRequestReceived_result()
8647 
    try:
8648 
      self._handler.markOrderCancellationRequestReceived(args.orderId)
8649 
    except TransactionServiceException, ex:
8650 
      result.ex = ex
8651 
    oprot.writeMessageBegin("markOrderCancellationRequestReceived", TMessageType.REPLY, seqid)
8652 
    result.write(oprot)
8653 
    oprot.writeMessageEnd()
8654 
    oprot.trans.flush()
4018 chandransh 8655 
 
4247 rajveer 8656 
  def process_markOrderCancellationRequestConfirmed(self, seqid, iprot, oprot):
8657 
    args = markOrderCancellationRequestConfirmed_args()
8658 
    args.read(iprot)
8659 
    iprot.readMessageEnd()
8660 
    result = markOrderCancellationRequestConfirmed_result()
8661 
    try:
8662 
      self._handler.markOrderCancellationRequestConfirmed(args.orderId)
8663 
    except TransactionServiceException, ex:
8664 
      result.ex = ex
8665 
    oprot.writeMessageBegin("markOrderCancellationRequestConfirmed", TMessageType.REPLY, seqid)
8666 
    result.write(oprot)
8667 
    oprot.writeMessageEnd()
8668 
    oprot.trans.flush()
8669 
 
8670 
  def process_markOrderCancellationRequestDenied(self, seqid, iprot, oprot):
8671 
    args = markOrderCancellationRequestDenied_args()
8672 
    args.read(iprot)
8673 
    iprot.readMessageEnd()
8674 
    result = markOrderCancellationRequestDenied_result()
8675 
    try:
8676 
      self._handler.markOrderCancellationRequestDenied(args.orderId)
8677 
    except TransactionServiceException, ex:
8678 
      result.ex = ex
8679 
    oprot.writeMessageBegin("markOrderCancellationRequestDenied", TMessageType.REPLY, seqid)
8680 
    result.write(oprot)
8681 
    oprot.writeMessageEnd()
8682 
    oprot.trans.flush()
8683 
 
4258 rajveer 8684 
  def process_markTransactionAsPaymentFlagRemoved(self, seqid, iprot, oprot):
8685 
    args = markTransactionAsPaymentFlagRemoved_args()
4247 rajveer 8686 
    args.read(iprot)
8687 
    iprot.readMessageEnd()
4258 rajveer 8688 
    result = markTransactionAsPaymentFlagRemoved_result()
4247 rajveer 8689 
    try:
4258 rajveer 8690 
      self._handler.markTransactionAsPaymentFlagRemoved(args.transactionId)
4247 rajveer 8691 
    except TransactionServiceException, ex:
8692 
      result.ex = ex
4258 rajveer 8693 
    oprot.writeMessageBegin("markTransactionAsPaymentFlagRemoved", TMessageType.REPLY, seqid)
4247 rajveer 8694 
    result.write(oprot)
8695 
    oprot.writeMessageEnd()
8696 
    oprot.trans.flush()
8697 
 
4259 anupam.sin 8698 
  def process_refundTransaction(self, seqid, iprot, oprot):
8699 
    args = refundTransaction_args()
8700 
    args.read(iprot)
8701 
    iprot.readMessageEnd()
8702 
    result = refundTransaction_result()
8703 
    try:
8704 
      self._handler.refundTransaction(args.transactionId, args.refundedBy, args.reason)
8705 
    except TransactionServiceException, ex:
8706 
      result.ex = ex
8707 
    oprot.writeMessageBegin("refundTransaction", TMessageType.REPLY, seqid)
8708 
    result.write(oprot)
8709 
    oprot.writeMessageEnd()
8710 
    oprot.trans.flush()
4247 rajveer 8711 
 
4324 mandeep.dh 8712 
  def process_updateShipmentAddress(self, seqid, iprot, oprot):
8713 
    args = updateShipmentAddress_args()
8714 
    args.read(iprot)
8715 
    iprot.readMessageEnd()
8716 
    result = updateShipmentAddress_result()
8717 
    try:
8718 
      self._handler.updateShipmentAddress(args.orderId, args.addressId)
8719 
    except TransactionServiceException, ex:
8720 
      result.ex = ex
8721 
    oprot.writeMessageBegin("updateShipmentAddress", TMessageType.REPLY, seqid)
8722 
    result.write(oprot)
8723 
    oprot.writeMessageEnd()
8724 
    oprot.trans.flush()
8725 
 
4285 rajveer 8726 
  def process_acceptOrdersForItemId(self, seqid, iprot, oprot):
8727 
    args = acceptOrdersForItemId_args()
8728 
    args.read(iprot)
8729 
    iprot.readMessageEnd()
8730 
    result = acceptOrdersForItemId_result()
8731 
    try:
8732 
      result.success = self._handler.acceptOrdersForItemId(args.itemId, args.inventory)
8733 
    except TransactionServiceException, ex:
8734 
      result.ex = ex
8735 
    oprot.writeMessageBegin("acceptOrdersForItemId", TMessageType.REPLY, seqid)
8736 
    result.write(oprot)
8737 
    oprot.writeMessageEnd()
8738 
    oprot.trans.flush()
4259 anupam.sin 8739 
 
4303 rajveer 8740 
  def process_markOrdersAsPORaised(self, seqid, iprot, oprot):
8741 
    args = markOrdersAsPORaised_args()
8742 
    args.read(iprot)
8743 
    iprot.readMessageEnd()
8744 
    result = markOrdersAsPORaised_result()
8745 
    try:
4369 rajveer 8746 
      self._handler.markOrdersAsPORaised(args.vendorId, args.itemId, args.quantity, args.estimate, args.isReminder)
4303 rajveer 8747 
    except TransactionServiceException, ex:
8748 
      result.ex = ex
8749 
    oprot.writeMessageBegin("markOrdersAsPORaised", TMessageType.REPLY, seqid)
8750 
    result.write(oprot)
8751 
    oprot.writeMessageEnd()
8752 
    oprot.trans.flush()
4285 rajveer 8753 
 
4303 rajveer 8754 
  def process_markOrdersAsReversalInitiated(self, seqid, iprot, oprot):
8755 
    args = markOrdersAsReversalInitiated_args()
8756 
    args.read(iprot)
8757 
    iprot.readMessageEnd()
8758 
    result = markOrdersAsReversalInitiated_result()
8759 
    try:
4369 rajveer 8760 
      self._handler.markOrdersAsReversalInitiated(args.vendorId, args.itemId, args.quantity, args.estimate, args.isReminder)
4303 rajveer 8761 
    except TransactionServiceException, ex:
8762 
      result.ex = ex
8763 
    oprot.writeMessageBegin("markOrdersAsReversalInitiated", TMessageType.REPLY, seqid)
8764 
    result.write(oprot)
8765 
    oprot.writeMessageEnd()
8766 
    oprot.trans.flush()
8767 
 
8768 
  def process_markOrdersAsNotAvailabke(self, seqid, iprot, oprot):
8769 
    args = markOrdersAsNotAvailabke_args()
8770 
    args.read(iprot)
8771 
    iprot.readMessageEnd()
8772 
    result = markOrdersAsNotAvailabke_result()
8773 
    try:
4369 rajveer 8774 
      self._handler.markOrdersAsNotAvailabke(args.vendorId, args.itemId, args.quantity, args.estimate, args.isReminder)
4303 rajveer 8775 
    except TransactionServiceException, ex:
8776 
      result.ex = ex
8777 
    oprot.writeMessageBegin("markOrdersAsNotAvailabke", TMessageType.REPLY, seqid)
8778 
    result.write(oprot)
8779 
    oprot.writeMessageEnd()
8780 
    oprot.trans.flush()
8781 
 
4369 rajveer 8782 
  def process_markOrdersAsTimeout(self, seqid, iprot, oprot):
8783 
    args = markOrdersAsTimeout_args()
8784 
    args.read(iprot)
8785 
    iprot.readMessageEnd()
8786 
    result = markOrdersAsTimeout_result()
8787 
    try:
8788 
      result.success = self._handler.markOrdersAsTimeout(args.vendorId)
8789 
    except TransactionServiceException, ex:
8790 
      result.ex = ex
8791 
    oprot.writeMessageBegin("markOrdersAsTimeout", TMessageType.REPLY, seqid)
8792 
    result.write(oprot)
8793 
    oprot.writeMessageEnd()
8794 
    oprot.trans.flush()
4303 rajveer 8795 
 
4662 rajveer 8796 
  def process_markOrderAsLostInTransit(self, seqid, iprot, oprot):
8797 
    args = markOrderAsLostInTransit_args()
8798 
    args.read(iprot)
8799 
    iprot.readMessageEnd()
8800 
    result = markOrderAsLostInTransit_result()
8801 
    try:
8802 
      result.success = self._handler.markOrderAsLostInTransit(args.orderId)
8803 
    except TransactionServiceException, ex:
8804 
      result.ex = ex
8805 
    oprot.writeMessageBegin("markOrderAsLostInTransit", TMessageType.REPLY, seqid)
8806 
    result.write(oprot)
8807 
    oprot.writeMessageEnd()
8808 
    oprot.trans.flush()
8809 
 
4386 anupam.sin 8810 
  def process_getOrderForAwb(self, seqid, iprot, oprot):
8811 
    args = getOrderForAwb_args()
8812 
    args.read(iprot)
8813 
    iprot.readMessageEnd()
8814 
    result = getOrderForAwb_result()
8815 
    try:
8816 
      result.success = self._handler.getOrderForAwb(args.awb)
8817 
    except TransactionServiceException, ex:
8818 
      result.ex = ex
8819 
    oprot.writeMessageBegin("getOrderForAwb", TMessageType.REPLY, seqid)
8820 
    result.write(oprot)
8821 
    oprot.writeMessageEnd()
8822 
    oprot.trans.flush()
4369 rajveer 8823 
 
4506 phani.kuma 8824 
  def process_getOrdersForProviderForStatus(self, seqid, iprot, oprot):
8825 
    args = getOrdersForProviderForStatus_args()
8826 
    args.read(iprot)
8827 
    iprot.readMessageEnd()
8828 
    result = getOrdersForProviderForStatus_result()
8829 
    try:
4910 phani.kuma 8830 
      result.success = self._handler.getOrdersForProviderForStatus(args.logistics_provider_id, args.order_status_list)
4506 phani.kuma 8831 
    except TransactionServiceException, ex:
8832 
      result.ex = ex
8833 
    oprot.writeMessageBegin("getOrdersForProviderForStatus", TMessageType.REPLY, seqid)
8834 
    result.write(oprot)
8835 
    oprot.writeMessageEnd()
8836 
    oprot.trans.flush()
4386 anupam.sin 8837 
 
4600 varun.gupt 8838 
  def process_getBilledOrdersForVendor(self, seqid, iprot, oprot):
8839 
    args = getBilledOrdersForVendor_args()
8840 
    args.read(iprot)
8841 
    iprot.readMessageEnd()
8842 
    result = getBilledOrdersForVendor_result()
8843 
    try:
8844 
      result.success = self._handler.getBilledOrdersForVendor(args.vendorId, args.billingDateFrom, args.billingDateTo)
8845 
    except TransactionServiceException, ex:
8846 
      result.ex = ex
8847 
    oprot.writeMessageBegin("getBilledOrdersForVendor", TMessageType.REPLY, seqid)
8848 
    result.write(oprot)
8849 
    oprot.writeMessageEnd()
8850 
    oprot.trans.flush()
4506 phani.kuma 8851 
 
4607 rajveer 8852 
  def process_getSlippedSippingDateOrders(self, seqid, iprot, oprot):
8853 
    args = getSlippedSippingDateOrders_args()
8854 
    args.read(iprot)
8855 
    iprot.readMessageEnd()
8856 
    result = getSlippedSippingDateOrders_result()
8857 
    try:
8858 
      result.success = self._handler.getSlippedSippingDateOrders()
8859 
    except TransactionServiceException, ex:
8860 
      result.ex = ex
8861 
    oprot.writeMessageBegin("getSlippedSippingDateOrders", TMessageType.REPLY, seqid)
8862 
    result.write(oprot)
8863 
    oprot.writeMessageEnd()
8864 
    oprot.trans.flush()
8865 
 
4709 rajveer 8866 
  def process_getCancelledOrders(self, seqid, iprot, oprot):
8867 
    args = getCancelledOrders_args()
8868 
    args.read(iprot)
8869 
    iprot.readMessageEnd()
8870 
    result = getCancelledOrders_result()
8871 
    try:
8872 
      result.success = self._handler.getCancelledOrders(args.cancelDateFrom, args.cancelDateTo)
8873 
    except TransactionServiceException, ex:
8874 
      result.ex = ex
8875 
    oprot.writeMessageBegin("getCancelledOrders", TMessageType.REPLY, seqid)
8876 
    result.write(oprot)
8877 
    oprot.writeMessageEnd()
8878 
    oprot.trans.flush()
8879 
 
4600 varun.gupt 8880 
  def process_saveBluedartSettlements(self, seqid, iprot, oprot):
8881 
    args = saveBluedartSettlements_args()
8882 
    args.read(iprot)
8883 
    iprot.readMessageEnd()
8884 
    result = saveBluedartSettlements_result()
8885 
    try:
8886 
      self._handler.saveBluedartSettlements(args.mapAWBAndAmount)
8887 
    except TransactionServiceException, ex:
8888 
      result.ex = ex
8889 
    oprot.writeMessageBegin("saveBluedartSettlements", TMessageType.REPLY, seqid)
8890 
    result.write(oprot)
8891 
    oprot.writeMessageEnd()
8892 
    oprot.trans.flush()
8893 
 
8894 
  def process_savePaymentSettlements(self, seqid, iprot, oprot):
8895 
    args = savePaymentSettlements_args()
8896 
    args.read(iprot)
8897 
    iprot.readMessageEnd()
8898 
    result = savePaymentSettlements_result()
8899 
    try:
4905 varun.gupt 8900 
      self._handler.savePaymentSettlements(args.settlementDate, args.paymentGatewayId, args.referenceId, args.serviceTax, args.otherCharges, args.netCollection)
4600 varun.gupt 8901 
    except TransactionServiceException, ex:
8902 
      result.ex = ex
8903 
    oprot.writeMessageBegin("savePaymentSettlements", TMessageType.REPLY, seqid)
8904 
    result.write(oprot)
8905 
    oprot.writeMessageEnd()
8906 
    oprot.trans.flush()
8907 
 
8908 
  def process_saveEBSSettlementSummary(self, seqid, iprot, oprot):
8909 
    args = saveEBSSettlementSummary_args()
8910 
    args.read(iprot)
8911 
    iprot.readMessageEnd()
8912 
    result = saveEBSSettlementSummary_result()
8913 
    try:
8914 
      self._handler.saveEBSSettlementSummary(args.settlementId, args.settlementDate, args.transactionDateFrom, args.transactionDateTo, args.amount)
8915 
    except TransactionServiceException, ex:
8916 
      result.ex = ex
8917 
    oprot.writeMessageBegin("saveEBSSettlementSummary", TMessageType.REPLY, seqid)
8918 
    result.write(oprot)
8919 
    oprot.writeMessageEnd()
8920 
    oprot.trans.flush()
8921 
 
5386 phani.kuma 8922 
  def process_getSettlementForPrepaid(self, seqid, iprot, oprot):
8923 
    args = getSettlementForPrepaid_args()
4600 varun.gupt 8924 
    args.read(iprot)
8925 
    iprot.readMessageEnd()
5386 phani.kuma 8926 
    result = getSettlementForPrepaid_result()
4600 varun.gupt 8927 
    try:
5386 phani.kuma 8928 
      result.success = self._handler.getSettlementForPrepaid(args.referenceId, args.isRefund)
4600 varun.gupt 8929 
    except TransactionServiceException, ex:
8930 
      result.ex = ex
5386 phani.kuma 8931 
    oprot.writeMessageBegin("getSettlementForPrepaid", TMessageType.REPLY, seqid)
4600 varun.gupt 8932 
    result.write(oprot)
8933 
    oprot.writeMessageEnd()
8934 
    oprot.trans.flush()
8935 
 
5386 phani.kuma 8936 
  def process_getSettlementForCod(self, seqid, iprot, oprot):
8937 
    args = getSettlementForCod_args()
8938 
    args.read(iprot)
8939 
    iprot.readMessageEnd()
8940 
    result = getSettlementForCod_result()
8941 
    try:
8942 
      result.success = self._handler.getSettlementForCod(args.orderId, args.isRefund)
8943 
    except TransactionServiceException, ex:
8944 
      result.ex = ex
8945 
    oprot.writeMessageBegin("getSettlementForCod", TMessageType.REPLY, seqid)
8946 
    result.write(oprot)
8947 
    oprot.writeMessageEnd()
8948 
    oprot.trans.flush()
8949 
 
4600 varun.gupt 8950 
  def process_getEBSSettlementSummaries(self, seqid, iprot, oprot):
8951 
    args = getEBSSettlementSummaries_args()
8952 
    args.read(iprot)
8953 
    iprot.readMessageEnd()
8954 
    result = getEBSSettlementSummaries_result()
8955 
    try:
8956 
      result.success = self._handler.getEBSSettlementSummaries()
8957 
    except TransactionServiceException, ex:
8958 
      result.ex = ex
8959 
    oprot.writeMessageBegin("getEBSSettlementSummaries", TMessageType.REPLY, seqid)
8960 
    result.write(oprot)
8961 
    oprot.writeMessageEnd()
8962 
    oprot.trans.flush()
8963 
 
8964 
  def process_markEBSSettlementUploaded(self, seqid, iprot, oprot):
8965 
    args = markEBSSettlementUploaded_args()
8966 
    args.read(iprot)
8967 
    iprot.readMessageEnd()
8968 
    result = markEBSSettlementUploaded_result()
8969 
    try:
8970 
      self._handler.markEBSSettlementUploaded(args.settlementId)
8971 
    except TransactionServiceException, ex:
8972 
      result.ex = ex
8973 
    oprot.writeMessageBegin("markEBSSettlementUploaded", TMessageType.REPLY, seqid)
8974 
    result.write(oprot)
8975 
    oprot.writeMessageEnd()
8976 
    oprot.trans.flush()
8977 
 
8978 
  def process_getEBSSettlementDate(self, seqid, iprot, oprot):
8979 
    args = getEBSSettlementDate_args()
8980 
    args.read(iprot)
8981 
    iprot.readMessageEnd()
8982 
    result = getEBSSettlementDate_result()
8983 
    try:
8984 
      result.success = self._handler.getEBSSettlementDate(args.settlementId)
8985 
    except TransactionServiceException, ex:
8986 
      result.ex = ex
8987 
    oprot.writeMessageBegin("getEBSSettlementDate", TMessageType.REPLY, seqid)
8988 
    result.write(oprot)
8989 
    oprot.writeMessageEnd()
8990 
    oprot.trans.flush()
8991 
 
4715 varun.gupt 8992 
  def process_getSettlementsByDate(self, seqid, iprot, oprot):
8993 
    args = getSettlementsByDate_args()
8994 
    args.read(iprot)
8995 
    iprot.readMessageEnd()
8996 
    result = getSettlementsByDate_result()
8997 
    try:
8998 
      result.success = self._handler.getSettlementsByDate(args.settlementDateFrom, args.settlementDateTo, args.isRefund)
8999 
    except TransactionServiceException, ex:
9000 
      result.ex = ex
9001 
    oprot.writeMessageBegin("getSettlementsByDate", TMessageType.REPLY, seqid)
9002 
    result.write(oprot)
9003 
    oprot.writeMessageEnd()
9004 
    oprot.trans.flush()
4600 varun.gupt 9005 
 
4715 varun.gupt 9006 
  def process_getReshippedOrderIds(self, seqid, iprot, oprot):
9007 
    args = getReshippedOrderIds_args()
9008 
    args.read(iprot)
9009 
    iprot.readMessageEnd()
9010 
    result = getReshippedOrderIds_result()
9011 
    try:
9012 
      result.success = self._handler.getReshippedOrderIds(args.orderIds)
9013 
    except TransactionServiceException, ex:
9014 
      result.ex = ex
9015 
    oprot.writeMessageBegin("getReshippedOrderIds", TMessageType.REPLY, seqid)
9016 
    result.write(oprot)
9017 
    oprot.writeMessageEnd()
9018 
    oprot.trans.flush()
9019 
 
5481 phani.kuma 9020 
  def process_getBilledOrders(self, seqid, iprot, oprot):
9021 
    args = getBilledOrders_args()
4875 varun.gupt 9022 
    args.read(iprot)
9023 
    iprot.readMessageEnd()
5481 phani.kuma 9024 
    result = getBilledOrders_result()
4875 varun.gupt 9025 
    try:
5481 phani.kuma 9026 
      result.success = self._handler.getBilledOrders(args.vendorId, args.onlyVendorNotPaid, args.billingDateFrom, args.billingDateTo)
4875 varun.gupt 9027 
    except TransactionServiceException, ex:
9028 
      result.ex = ex
5481 phani.kuma 9029 
    oprot.writeMessageBegin("getBilledOrders", TMessageType.REPLY, seqid)
4875 varun.gupt 9030 
    result.write(oprot)
9031 
    oprot.writeMessageEnd()
9032 
    oprot.trans.flush()
4757 mandeep.dh 9033 
 
5031 varun.gupt 9034 
  def process_getStatusDistributionOfOrders(self, seqid, iprot, oprot):
9035 
    args = getStatusDistributionOfOrders_args()
9036 
    args.read(iprot)
9037 
    iprot.readMessageEnd()
9038 
    result = getStatusDistributionOfOrders_result()
9039 
    try:
9040 
      result.success = self._handler.getStatusDistributionOfOrders(args.startDate, args.endDate)
9041 
    except TransactionServiceException, ex:
9042 
      result.ex = ex
9043 
    oprot.writeMessageBegin("getStatusDistributionOfOrders", TMessageType.REPLY, seqid)
9044 
    result.write(oprot)
9045 
    oprot.writeMessageEnd()
9046 
    oprot.trans.flush()
4875 varun.gupt 9047 
 
5067 varun.gupt 9048 
  def process_getOrderIdsForStatus(self, seqid, iprot, oprot):
9049 
    args = getOrderIdsForStatus_args()
9050 
    args.read(iprot)
9051 
    iprot.readMessageEnd()
9052 
    result = getOrderIdsForStatus_result()
9053 
    try:
9054 
      result.success = self._handler.getOrderIdsForStatus(args.status, args.startDatetime, args.endDatetime)
9055 
    except TransactionServiceException, ex:
9056 
      result.ex = ex
9057 
    oprot.writeMessageBegin("getOrderIdsForStatus", TMessageType.REPLY, seqid)
9058 
    result.write(oprot)
9059 
    oprot.writeMessageEnd()
9060 
    oprot.trans.flush()
5031 varun.gupt 9061 
 
5348 anupam.sin 9062 
  def process_updateCODAgent(self, seqid, iprot, oprot):
9063 
    args = updateCODAgent_args()
9064 
    args.read(iprot)
9065 
    iprot.readMessageEnd()
9066 
    result = updateCODAgent_result()
9067 
    try:
9068 
      self._handler.updateCODAgent(args.agent, args.orderId)
9069 
    except TransactionServiceException, ex:
9070 
      result.ex = ex
9071 
    oprot.writeMessageBegin("updateCODAgent", TMessageType.REPLY, seqid)
9072 
    result.write(oprot)
9073 
    oprot.writeMessageEnd()
9074 
    oprot.trans.flush()
9075 
 
5099 varun.gupt 9076 
  def process_updateOrderAsPaidToVendor(self, seqid, iprot, oprot):
9077 
    args = updateOrderAsPaidToVendor_args()
9078 
    args.read(iprot)
9079 
    iprot.readMessageEnd()
9080 
    result = updateOrderAsPaidToVendor_result()
9081 
    try:
9082 
      self._handler.updateOrderAsPaidToVendor(args.orderId)
9083 
    except TransactionServiceException, ex:
9084 
      result.ex = ex
9085 
    oprot.writeMessageBegin("updateOrderAsPaidToVendor", TMessageType.REPLY, seqid)
9086 
    result.write(oprot)
9087 
    oprot.writeMessageEnd()
9088 
    oprot.trans.flush()
5067 varun.gupt 9089 
 
5386 phani.kuma 9090 
  def process_updateOrderOnlyAsPaidToVendor(self, seqid, iprot, oprot):
9091 
    args = updateOrderOnlyAsPaidToVendor_args()
9092 
    args.read(iprot)
9093 
    iprot.readMessageEnd()
9094 
    result = updateOrderOnlyAsPaidToVendor_result()
9095 
    try:
9096 
      self._handler.updateOrderOnlyAsPaidToVendor(args.orderId)
9097 
    except TransactionServiceException, ex:
9098 
      result.ex = ex
9099 
    oprot.writeMessageBegin("updateOrderOnlyAsPaidToVendor", TMessageType.REPLY, seqid)
9100 
    result.write(oprot)
9101 
    oprot.writeMessageEnd()
9102 
    oprot.trans.flush()
9103 
 
5208 varun.gupt 9104 
  def process_getRefundedOrdersMarkedPaid(self, seqid, iprot, oprot):
9105 
    args = getRefundedOrdersMarkedPaid_args()
9106 
    args.read(iprot)
9107 
    iprot.readMessageEnd()
9108 
    result = getRefundedOrdersMarkedPaid_result()
9109 
    try:
9110 
      result.success = self._handler.getRefundedOrdersMarkedPaid()
9111 
    except TransactionServiceException, ex:
9112 
      result.ex = ex
9113 
    oprot.writeMessageBegin("getRefundedOrdersMarkedPaid", TMessageType.REPLY, seqid)
9114 
    result.write(oprot)
9115 
    oprot.writeMessageEnd()
9116 
    oprot.trans.flush()
5099 varun.gupt 9117 
 
5447 anupam.sin 9118 
  def process_getAllVerificationAgents(self, seqid, iprot, oprot):
9119 
    args = getAllVerificationAgents_args()
9120 
    args.read(iprot)
9121 
    iprot.readMessageEnd()
9122 
    result = getAllVerificationAgents_result()
9123 
    result.success = self._handler.getAllVerificationAgents(args.minOrderId, args.maxOrderId)
9124 
    oprot.writeMessageBegin("getAllVerificationAgents", TMessageType.REPLY, seqid)
9125 
    result.write(oprot)
9126 
    oprot.writeMessageEnd()
9127 
    oprot.trans.flush()
5208 varun.gupt 9128 
 
5527 anupam.sin 9129 
  def process_getAllAttributesForOrderId(self, seqid, iprot, oprot):
9130 
    args = getAllAttributesForOrderId_args()
9131 
    args.read(iprot)
9132 
    iprot.readMessageEnd()
9133 
    result = getAllAttributesForOrderId_result()
9134 
    result.success = self._handler.getAllAttributesForOrderId(args.orderId)
9135 
    oprot.writeMessageBegin("getAllAttributesForOrderId", TMessageType.REPLY, seqid)
9136 
    result.write(oprot)
9137 
    oprot.writeMessageEnd()
9138 
    oprot.trans.flush()
5447 anupam.sin 9139 
 
5676 rajveer 9140 
  def process_setOrderAttributes(self, seqid, iprot, oprot):
9141 
    args = setOrderAttributes_args()
9142 
    args.read(iprot)
9143 
    iprot.readMessageEnd()
9144 
    result = setOrderAttributes_result()
9145 
    self._handler.setOrderAttributes(args.orderId, args.attributes)
9146 
    oprot.writeMessageBegin("setOrderAttributes", TMessageType.REPLY, seqid)
9147 
    result.write(oprot)
9148 
    oprot.writeMessageEnd()
9149 
    oprot.trans.flush()
9150 
 
5527 anupam.sin 9151 
  def process_setOrderAttributeForTransaction(self, seqid, iprot, oprot):
9152 
    args = setOrderAttributeForTransaction_args()
9153 
    args.read(iprot)
9154 
    iprot.readMessageEnd()
9155 
    result = setOrderAttributeForTransaction_result()
9156 
    self._handler.setOrderAttributeForTransaction(args.transactionId, args.attribute)
9157 
    oprot.writeMessageBegin("setOrderAttributeForTransaction", TMessageType.REPLY, seqid)
9158 
    result.write(oprot)
9159 
    oprot.writeMessageEnd()
9160 
    oprot.trans.flush()
9161 
 
5553 rajveer 9162 
  def process_getReceivePendingOrders(self, seqid, iprot, oprot):
9163 
    args = getReceivePendingOrders_args()
9164 
    args.read(iprot)
9165 
    iprot.readMessageEnd()
9166 
    result = getReceivePendingOrders_result()
9167 
    result.success = self._handler.getReceivePendingOrders(args.storeId)
9168 
    oprot.writeMessageBegin("getReceivePendingOrders", TMessageType.REPLY, seqid)
9169 
    result.write(oprot)
9170 
    oprot.writeMessageEnd()
9171 
    oprot.trans.flush()
5527 anupam.sin 9172 
 
5553 rajveer 9173 
  def process_getReceivedAtStoreOrders(self, seqid, iprot, oprot):
9174 
    args = getReceivedAtStoreOrders_args()
9175 
    args.read(iprot)
9176 
    iprot.readMessageEnd()
9177 
    result = getReceivedAtStoreOrders_result()
9178 
    result.success = self._handler.getReceivedAtStoreOrders(args.storeId)
9179 
    oprot.writeMessageBegin("getReceivedAtStoreOrders", TMessageType.REPLY, seqid)
9180 
    result.write(oprot)
9181 
    oprot.writeMessageEnd()
9182 
    oprot.trans.flush()
9183 
 
5713 rajveer 9184 
  def process_getOrdersCollectionAtStore(self, seqid, iprot, oprot):
9185 
    args = getOrdersCollectionAtStore_args()
9186 
    args.read(iprot)
9187 
    iprot.readMessageEnd()
9188 
    result = getOrdersCollectionAtStore_result()
9189 
    result.success = self._handler.getOrdersCollectionAtStore(args.storeId, args.fromDate, args.toDate, args.onlyCod)
9190 
    oprot.writeMessageBegin("getOrdersCollectionAtStore", TMessageType.REPLY, seqid)
9191 
    result.write(oprot)
9192 
    oprot.writeMessageEnd()
9193 
    oprot.trans.flush()
9194 
 
5833 rajveer 9195 
  def process_getOrderAttributeValue(self, seqid, iprot, oprot):
9196 
    args = getOrderAttributeValue_args()
9197 
    args.read(iprot)
9198 
    iprot.readMessageEnd()
9199 
    result = getOrderAttributeValue_result()
9200 
    result.success = self._handler.getOrderAttributeValue(args.orderId, args.attributeName)
9201 
    oprot.writeMessageBegin("getOrderAttributeValue", TMessageType.REPLY, seqid)
9202 
    result.write(oprot)
9203 
    oprot.writeMessageEnd()
9204 
    oprot.trans.flush()
9205 
 
6019 rajveer 9206 
  def process_changeJacketNumber(self, seqid, iprot, oprot):
9207 
    args = changeJacketNumber_args()
9208 
    args.read(iprot)
9209 
    iprot.readMessageEnd()
9210 
    result = changeJacketNumber_result()
9211 
    result.success = self._handler.changeJacketNumber(args.orderId, args.jacketNumber)
9212 
    oprot.writeMessageBegin("changeJacketNumber", TMessageType.REPLY, seqid)
9213 
    result.write(oprot)
9214 
    oprot.writeMessageEnd()
9215 
    oprot.trans.flush()
9216 
 
9217 
  def process_markOrderAsRtoInTransit(self, seqid, iprot, oprot):
9218 
    args = markOrderAsRtoInTransit_args()
9219 
    args.read(iprot)
9220 
    iprot.readMessageEnd()
9221 
    result = markOrderAsRtoInTransit_result()
9222 
    result.success = self._handler.markOrderAsRtoInTransit(args.orderId)
9223 
    oprot.writeMessageBegin("markOrderAsRtoInTransit", TMessageType.REPLY, seqid)
9224 
    result.write(oprot)
9225 
    oprot.writeMessageEnd()
9226 
    oprot.trans.flush()
9227 
 
5593 mandeep.dh 9228 
  def process_acceptOrderForItem(self, seqid, iprot, oprot):
9229 
    args = acceptOrderForItem_args()
9230 
    args.read(iprot)
9231 
    iprot.readMessageEnd()
9232 
    result = acceptOrderForItem_result()
9233 
    self._handler.acceptOrderForItem(args.itemId, args.quantity, args.fulfilmentWarehouseId, args.billingWarehouseId)
9234 
    oprot.writeMessageBegin("acceptOrderForItem", TMessageType.REPLY, seqid)
9235 
    result.write(oprot)
9236 
    oprot.writeMessageEnd()
9237 
    oprot.trans.flush()
5553 rajveer 9238 
 
6000 mandeep.dh 9239 
  def process_createRechargeOrder(self, seqid, iprot, oprot):
9240 
    args = createRechargeOrder_args()
9241 
    args.read(iprot)
9242 
    iprot.readMessageEnd()
9243 
    result = createRechargeOrder_result()
9244 
    try:
9245 
      result.success = self._handler.createRechargeOrder(args.rechargeOrder)
9246 
    except TransactionServiceException, ex:
9247 
      result.ex = ex
9248 
    oprot.writeMessageBegin("createRechargeOrder", TMessageType.REPLY, seqid)
9249 
    result.write(oprot)
9250 
    oprot.writeMessageEnd()
9251 
    oprot.trans.flush()
5593 mandeep.dh 9252 
 
6031 rajveer 9253 
  def process_getRechargeOrder(self, seqid, iprot, oprot):
9254 
    args = getRechargeOrder_args()
9255 
    args.read(iprot)
9256 
    iprot.readMessageEnd()
9257 
    result = getRechargeOrder_result()
9258 
    try:
9259 
      result.success = self._handler.getRechargeOrder(args.rechargeRrderId)
9260 
    except TransactionServiceException, ex:
9261 
      result.ex = ex
9262 
    oprot.writeMessageBegin("getRechargeOrder", TMessageType.REPLY, seqid)
9263 
    result.write(oprot)
9264 
    oprot.writeMessageEnd()
9265 
    oprot.trans.flush()
9266 
 
9267 
  def process_getRechargeOrders(self, seqid, iprot, oprot):
9268 
    args = getRechargeOrders_args()
9269 
    args.read(iprot)
9270 
    iprot.readMessageEnd()
9271 
    result = getRechargeOrders_result()
9272 
    result.success = self._handler.getRechargeOrders(args.userId)
9273 
    oprot.writeMessageBegin("getRechargeOrders", TMessageType.REPLY, seqid)
9274 
    result.write(oprot)
9275 
    oprot.writeMessageEnd()
9276 
    oprot.trans.flush()
9277 
 
6000 mandeep.dh 9278 
  def process_updateRechargeOrderStatus(self, seqid, iprot, oprot):
9279 
    args = updateRechargeOrderStatus_args()
9280 
    args.read(iprot)
9281 
    iprot.readMessageEnd()
9282 
    result = updateRechargeOrderStatus_result()
9283 
    try:
6031 rajveer 9284 
      result.success = self._handler.updateRechargeOrderStatus(args.rechargeOrderId, args.rechargeOrderStatus)
6000 mandeep.dh 9285 
    except TransactionServiceException, ex:
9286 
      result.ex = ex
9287 
    oprot.writeMessageBegin("updateRechargeOrderStatus", TMessageType.REPLY, seqid)
9288 
    result.write(oprot)
9289 
    oprot.writeMessageEnd()
9290 
    oprot.trans.flush()
9291 
 
9292 
  def process_activateRechargeTxn(self, seqid, iprot, oprot):
9293 
    args = activateRechargeTxn_args()
9294 
    args.read(iprot)
9295 
    iprot.readMessageEnd()
9296 
    result = activateRechargeTxn_result()
9297 
    try:
6031 rajveer 9298 
      result.success = self._handler.activateRechargeTxn(args.rechargeOrderId)
6000 mandeep.dh 9299 
    except TransactionServiceException, ex:
9300 
      result.ex = ex
9301 
    oprot.writeMessageBegin("activateRechargeTxn", TMessageType.REPLY, seqid)
9302 
    result.write(oprot)
9303 
    oprot.writeMessageEnd()
9304 
    oprot.trans.flush()
9305 
 
6031 rajveer 9306 
  def process_getUserWallet(self, seqid, iprot, oprot):
9307 
    args = getUserWallet_args()
6000 mandeep.dh 9308 
    args.read(iprot)
9309 
    iprot.readMessageEnd()
6031 rajveer 9310 
    result = getUserWallet_result()
9311 
    result.success = self._handler.getUserWallet(args.userId)
9312 
    oprot.writeMessageBegin("getUserWallet", TMessageType.REPLY, seqid)
6000 mandeep.dh 9313 
    result.write(oprot)
9314 
    oprot.writeMessageEnd()
9315 
    oprot.trans.flush()
9316 
 
6031 rajveer 9317 
  def process_getUserWalletHistory(self, seqid, iprot, oprot):
9318 
    args = getUserWalletHistory_args()
6000 mandeep.dh 9319 
    args.read(iprot)
9320 
    iprot.readMessageEnd()
6031 rajveer 9321 
    result = getUserWalletHistory_result()
9322 
    result.success = self._handler.getUserWalletHistory(args.userId)
9323 
    oprot.writeMessageBegin("getUserWalletHistory", TMessageType.REPLY, seqid)
6000 mandeep.dh 9324 
    result.write(oprot)
9325 
    oprot.writeMessageEnd()
9326 
    oprot.trans.flush()
9327 
 
6050 anupam.sin 9328 
  def process_getRechargeOrdersForTransaction(self, seqid, iprot, oprot):
9329 
    args = getRechargeOrdersForTransaction_args()
9330 
    args.read(iprot)
9331 
    iprot.readMessageEnd()
9332 
    result = getRechargeOrdersForTransaction_result()
9333 
    try:
9334 
      result.success = self._handler.getRechargeOrdersForTransaction(args.txnId)
9335 
    except TransactionServiceException, ex:
9336 
      result.ex = ex
9337 
    oprot.writeMessageBegin("getRechargeOrdersForTransaction", TMessageType.REPLY, seqid)
9338 
    result.write(oprot)
9339 
    oprot.writeMessageEnd()
9340 
    oprot.trans.flush()
9341 
 
6048 rajveer 9342 
  def process_getServiceProviders(self, seqid, iprot, oprot):
9343 
    args = getServiceProviders_args()
9344 
    args.read(iprot)
9345 
    iprot.readMessageEnd()
9346 
    result = getServiceProviders_result()
6206 rajveer 9347 
    result.success = self._handler.getServiceProviders(args.rechargeType, args.onlyActive)
6048 rajveer 9348 
    oprot.writeMessageBegin("getServiceProviders", TMessageType.REPLY, seqid)
9349 
    result.write(oprot)
9350 
    oprot.writeMessageEnd()
9351 
    oprot.trans.flush()
6000 mandeep.dh 9352 
 
6048 rajveer 9353 
  def process_getServiceProviderForDevice(self, seqid, iprot, oprot):
9354 
    args = getServiceProviderForDevice_args()
9355 
    args.read(iprot)
9356 
    iprot.readMessageEnd()
9357 
    result = getServiceProviderForDevice_result()
6049 rajveer 9358 
    result.success = self._handler.getServiceProviderForDevice(args.rechargeType, args.deviceNumber)
6048 rajveer 9359 
    oprot.writeMessageBegin("getServiceProviderForDevice", TMessageType.REPLY, seqid)
9360 
    result.write(oprot)
9361 
    oprot.writeMessageEnd()
9362 
    oprot.trans.flush()
9363 
 
6269 rajveer 9364 
  def process_validateRecharge(self, seqid, iprot, oprot):
9365 
    args = validateRecharge_args()
9366 
    args.read(iprot)
9367 
    iprot.readMessageEnd()
9368 
    result = validateRecharge_result()
6591 anupam.sin 9369 
    result.success = self._handler.validateRecharge(args.rechargeType, args.deviceNumber, args.userSelectedProviderId, args.clientAddress)
6269 rajveer 9370 
    oprot.writeMessageBegin("validateRecharge", TMessageType.REPLY, seqid)
9371 
    result.write(oprot)
9372 
    oprot.writeMessageEnd()
9373 
    oprot.trans.flush()
9374 
 
6094 rajveer 9375 
  def process_getRechargeOrdersForDevice(self, seqid, iprot, oprot):
9376 
    args = getRechargeOrdersForDevice_args()
9377 
    args.read(iprot)
9378 
    iprot.readMessageEnd()
9379 
    result = getRechargeOrdersForDevice_result()
9380 
    result.success = self._handler.getRechargeOrdersForDevice(args.deviceNumber)
9381 
    oprot.writeMessageBegin("getRechargeOrdersForDevice", TMessageType.REPLY, seqid)
9382 
    result.write(oprot)
9383 
    oprot.writeMessageEnd()
9384 
    oprot.trans.flush()
6048 rajveer 9385 
 
6094 rajveer 9386 
  def process_addAmountToWallet(self, seqid, iprot, oprot):
9387 
    args = addAmountToWallet_args()
9388 
    args.read(iprot)
9389 
    iprot.readMessageEnd()
9390 
    result = addAmountToWallet_result()
9391 
    self._handler.addAmountToWallet(args.userId, args.orderId, args.amount)
9392 
    oprot.writeMessageBegin("addAmountToWallet", TMessageType.REPLY, seqid)
9393 
    result.write(oprot)
9394 
    oprot.writeMessageEnd()
9395 
    oprot.trans.flush()
9396 
 
6188 rajveer 9397 
  def process_getRechargeStatistics(self, seqid, iprot, oprot):
9398 
    args = getRechargeStatistics_args()
9399 
    args.read(iprot)
9400 
    iprot.readMessageEnd()
9401 
    result = getRechargeStatistics_result()
9402 
    result.success = self._handler.getRechargeStatistics()
9403 
    oprot.writeMessageBegin("getRechargeStatistics", TMessageType.REPLY, seqid)
9404 
    result.write(oprot)
9405 
    oprot.writeMessageEnd()
9406 
    oprot.trans.flush()
9407 
 
6154 rajveer 9408 
  def process_getRechargeOrdersForStatus(self, seqid, iprot, oprot):
9409 
    args = getRechargeOrdersForStatus_args()
9410 
    args.read(iprot)
9411 
    iprot.readMessageEnd()
9412 
    result = getRechargeOrdersForStatus_result()
9413 
    result.success = self._handler.getRechargeOrdersForStatus(args.status)
9414 
    oprot.writeMessageBegin("getRechargeOrdersForStatus", TMessageType.REPLY, seqid)
9415 
    result.write(oprot)
9416 
    oprot.writeMessageEnd()
9417 
    oprot.trans.flush()
6094 rajveer 9418 
 
6159 rajveer 9419 
  def process_getPlansForOperator(self, seqid, iprot, oprot):
9420 
    args = getPlansForOperator_args()
9421 
    args.read(iprot)
9422 
    iprot.readMessageEnd()
9423 
    result = getPlansForOperator_result()
9424 
    result.success = self._handler.getPlansForOperator(args.operatorId)
9425 
    oprot.writeMessageBegin("getPlansForOperator", TMessageType.REPLY, seqid)
9426 
    result.write(oprot)
9427 
    oprot.writeMessageEnd()
9428 
    oprot.trans.flush()
6154 rajveer 9429 
 
6289 anupam.sin 9430 
  def process_getRechargeDenominations(self, seqid, iprot, oprot):
9431 
    args = getRechargeDenominations_args()
9432 
    args.read(iprot)
9433 
    iprot.readMessageEnd()
9434 
    result = getRechargeDenominations_result()
9435 
    try:
6307 anupam.sin 9436 
      result.success = self._handler.getRechargeDenominations(args.operatorId, args.circleCode, args.denominationType)
6289 anupam.sin 9437 
    except TransactionServiceException, ex:
9438 
      result.ex = ex
9439 
    oprot.writeMessageBegin("getRechargeDenominations", TMessageType.REPLY, seqid)
9440 
    result.write(oprot)
9441 
    oprot.writeMessageEnd()
9442 
    oprot.trans.flush()
6159 rajveer 9443 
 
6371 rajveer 9444 
  def process_updateAvailabilityStatus(self, seqid, iprot, oprot):
9445 
    args = updateAvailabilityStatus_args()
9446 
    args.read(iprot)
9447 
    iprot.readMessageEnd()
9448 
    result = updateAvailabilityStatus_result()
9449 
    self._handler.updateAvailabilityStatus(args.operatorId, args.circleId, args.isAvailable)
9450 
    oprot.writeMessageBegin("updateAvailabilityStatus", TMessageType.REPLY, seqid)
9451 
    result.write(oprot)
9452 
    oprot.writeMessageEnd()
9453 
    oprot.trans.flush()
6289 anupam.sin 9454 
 
6389 rajveer 9455 
  def process_getAvailableEmiSchemes(self, seqid, iprot, oprot):
9456 
    args = getAvailableEmiSchemes_args()
9457 
    args.read(iprot)
9458 
    iprot.readMessageEnd()
9459 
    result = getAvailableEmiSchemes_result()
9460 
    result.success = self._handler.getAvailableEmiSchemes()
9461 
    oprot.writeMessageBegin("getAvailableEmiSchemes", TMessageType.REPLY, seqid)
9462 
    result.write(oprot)
9463 
    oprot.writeMessageEnd()
9464 
    oprot.trans.flush()
6371 rajveer 9465 
 
6389 rajveer 9466 
  def process_getMiscCharges(self, seqid, iprot, oprot):
9467 
    args = getMiscCharges_args()
9468 
    args.read(iprot)
9469 
    iprot.readMessageEnd()
9470 
    result = getMiscCharges_result()
9471 
    result.success = self._handler.getMiscCharges(args.transactionId)
9472 
    oprot.writeMessageBegin("getMiscCharges", TMessageType.REPLY, seqid)
9473 
    result.write(oprot)
9474 
    oprot.writeMessageEnd()
9475 
    oprot.trans.flush()
9476 
 
6507 anupam.sin 9477 
  def process_refundRechargeOrder(self, seqid, iprot, oprot):
9478 
    args = refundRechargeOrder_args()
9479 
    args.read(iprot)
9480 
    iprot.readMessageEnd()
9481 
    result = refundRechargeOrder_result()
9482 
    try:
9483 
      result.success = self._handler.refundRechargeOrder(args.rechargeOrderId)
9484 
    except TransactionServiceException, ex:
9485 
      result.ex = ex
9486 
    oprot.writeMessageBegin("refundRechargeOrder", TMessageType.REPLY, seqid)
9487 
    result.write(oprot)
9488 
    oprot.writeMessageEnd()
9489 
    oprot.trans.flush()
6389 rajveer 9490 
 
6821 amar.kumar 9491 
  def process_getPhysicalOrders(self, seqid, iprot, oprot):
9492 
    args = getPhysicalOrders_args()
9493 
    args.read(iprot)
9494 
    iprot.readMessageEnd()
9495 
    result = getPhysicalOrders_result()
9496 
    result.success = self._handler.getPhysicalOrders(args.fromDate, args.toDate)
9497 
    oprot.writeMessageBegin("getPhysicalOrders", TMessageType.REPLY, seqid)
9498 
    result.write(oprot)
9499 
    oprot.writeMessageEnd()
9500 
    oprot.trans.flush()
6507 anupam.sin 9501 
 
6906 rajveer 9502 
  def process_getDocument(self, seqid, iprot, oprot):
9503 
    args = getDocument_args()
9504 
    args.read(iprot)
9505 
    iprot.readMessageEnd()
9506 
    result = getDocument_result()
9507 
    result.success = self._handler.getDocument(args.docType, args.docSource)
9508 
    oprot.writeMessageBegin("getDocument", TMessageType.REPLY, seqid)
9509 
    result.write(oprot)
9510 
    oprot.writeMessageEnd()
9511 
    oprot.trans.flush()
6821 amar.kumar 9512 
 
6985 anupam.sin 9513 
  def process_changeShippingAddress(self, seqid, iprot, oprot):
9514 
    args = changeShippingAddress_args()
9515 
    args.read(iprot)
9516 
    iprot.readMessageEnd()
9517 
    result = changeShippingAddress_result()
9518 
    result.success = self._handler.changeShippingAddress(args.orderId, args.line1, args.line2, args.city, args.state, args.pin)
9519 
    oprot.writeMessageBegin("changeShippingAddress", TMessageType.REPLY, seqid)
9520 
    result.write(oprot)
9521 
    oprot.writeMessageEnd()
9522 
    oprot.trans.flush()
6906 rajveer 9523 
 
6988 rajveer 9524 
  def process_retrieveInvoice(self, seqid, iprot, oprot):
9525 
    args = retrieveInvoice_args()
9526 
    args.read(iprot)
9527 
    iprot.readMessageEnd()
9528 
    result = retrieveInvoice_result()
7075 rajveer 9529 
    result.success = self._handler.retrieveInvoice(args.orderId, args.userId)
6988 rajveer 9530 
    oprot.writeMessageBegin("retrieveInvoice", TMessageType.REPLY, seqid)
9531 
    result.write(oprot)
9532 
    oprot.writeMessageEnd()
9533 
    oprot.trans.flush()
6985 anupam.sin 9534 
 
7026 rajveer 9535 
  def process_receiveUpdatesForRedExpress(self, seqid, iprot, oprot):
9536 
    args = receiveUpdatesForRedExpress_args()
9537 
    args.read(iprot)
9538 
    iprot.readMessageEnd()
9539 
    result = receiveUpdatesForRedExpress_result()
9540 
    result.success = self._handler.receiveUpdatesForRedExpress(args.awbNumber)
9541 
    oprot.writeMessageBegin("receiveUpdatesForRedExpress", TMessageType.REPLY, seqid)
9542 
    result.write(oprot)
9543 
    oprot.writeMessageEnd()
9544 
    oprot.trans.flush()
6988 rajveer 9545 
 
7073 anupam.sin 9546 
  def process_createRechargeTransaction(self, seqid, iprot, oprot):
9547 
    args = createRechargeTransaction_args()
9548 
    args.read(iprot)
9549 
    iprot.readMessageEnd()
9550 
    result = createRechargeTransaction_result()
9551 
    result.success = self._handler.createRechargeTransaction(args.thriftRechargeTransaction)
9552 
    oprot.writeMessageBegin("createRechargeTransaction", TMessageType.REPLY, seqid)
9553 
    result.write(oprot)
9554 
    oprot.writeMessageEnd()
9555 
    oprot.trans.flush()
7026 rajveer 9556 
 
7085 rajveer 9557 
  def process_getRechargeTransactions(self, seqid, iprot, oprot):
9558 
    args = getRechargeTransactions_args()
9559 
    args.read(iprot)
9560 
    iprot.readMessageEnd()
9561 
    result = getRechargeTransactions_result()
9562 
    result.success = self._handler.getRechargeTransactions(args.storeId)
9563 
    oprot.writeMessageBegin("getRechargeTransactions", TMessageType.REPLY, seqid)
9564 
    result.write(oprot)
9565 
    oprot.writeMessageEnd()
9566 
    oprot.trans.flush()
9567 
 
7151 amit.gupta 9568 
  def process_getRechargeTrans(self, seqid, iprot, oprot):
9569 
    args = getRechargeTrans_args()
9570 
    args.read(iprot)
9571 
    iprot.readMessageEnd()
9572 
    result = getRechargeTrans_result()
9573 
    result.success = self._handler.getRechargeTrans(args.storeId, args.startDate, args.endDate, args.status)
9574 
    oprot.writeMessageBegin("getRechargeTrans", TMessageType.REPLY, seqid)
9575 
    result.write(oprot)
9576 
    oprot.writeMessageEnd()
9577 
    oprot.trans.flush()
9578 
 
7080 anupam.sin 9579 
  def process_getRechargeTransaction(self, seqid, iprot, oprot):
9580 
    args = getRechargeTransaction_args()
9581 
    args.read(iprot)
9582 
    iprot.readMessageEnd()
9583 
    result = getRechargeTransaction_result()
9584 
    result.success = self._handler.getRechargeTransaction(args.rechargeId)
9585 
    oprot.writeMessageBegin("getRechargeTransaction", TMessageType.REPLY, seqid)
9586 
    result.write(oprot)
9587 
    oprot.writeMessageEnd()
9588 
    oprot.trans.flush()
7073 anupam.sin 9589 
 
7080 anupam.sin 9590 
  def process_getFRCs(self, seqid, iprot, oprot):
9591 
    args = getFRCs_args()
9592 
    args.read(iprot)
9593 
    iprot.readMessageEnd()
9594 
    result = getFRCs_result()
9595 
    result.success = self._handler.getFRCs(args.circleId, args.operatorId)
9596 
    oprot.writeMessageBegin("getFRCs", TMessageType.REPLY, seqid)
9597 
    result.write(oprot)
9598 
    oprot.writeMessageEnd()
9599 
    oprot.trans.flush()
9600 
 
7096 anupam.sin 9601 
  def process_getHotspotStore(self, seqid, iprot, oprot):
9602 
    args = getHotspotStore_args()
9603 
    args.read(iprot)
9604 
    iprot.readMessageEnd()
9605 
    result = getHotspotStore_result()
9606 
    result.success = self._handler.getHotspotStore(args.id, args.hotspotid)
9607 
    oprot.writeMessageBegin("getHotspotStore", TMessageType.REPLY, seqid)
9608 
    result.write(oprot)
9609 
    oprot.writeMessageEnd()
9610 
    oprot.trans.flush()
7080 anupam.sin 9611 
 
7096 anupam.sin 9612 
  def process_getTelecomCircle(self, seqid, iprot, oprot):
9613 
    args = getTelecomCircle_args()
9614 
    args.read(iprot)
9615 
    iprot.readMessageEnd()
9616 
    result = getTelecomCircle_result()
9617 
    result.success = self._handler.getTelecomCircle(args.id, args.code)
9618 
    oprot.writeMessageBegin("getTelecomCircle", TMessageType.REPLY, seqid)
9619 
    result.write(oprot)
9620 
    oprot.writeMessageEnd()
9621 
    oprot.trans.flush()
9622 
 
7109 anupam.sin 9623 
  def process_retrieveHotspotRechargeInvoice(self, seqid, iprot, oprot):
9624 
    args = retrieveHotspotRechargeInvoice_args()
9625 
    args.read(iprot)
9626 
    iprot.readMessageEnd()
9627 
    result = retrieveHotspotRechargeInvoice_result()
9628 
    result.success = self._handler.retrieveHotspotRechargeInvoice(args.rechargeId)
9629 
    oprot.writeMessageBegin("retrieveHotspotRechargeInvoice", TMessageType.REPLY, seqid)
9630 
    result.write(oprot)
9631 
    oprot.writeMessageEnd()
9632 
    oprot.trans.flush()
7096 anupam.sin 9633 
 
7190 amar.kumar 9634 
  def process_splitFreebieOrder(self, seqid, iprot, oprot):
9635 
    args = splitFreebieOrder_args()
9636 
    args.read(iprot)
9637 
    iprot.readMessageEnd()
9638 
    result = splitFreebieOrder_result()
9639 
    result.success = self._handler.splitFreebieOrder(args.orderId, args.splitReason, args.shippingDate)
9640 
    oprot.writeMessageBegin("splitFreebieOrder", TMessageType.REPLY, seqid)
9641 
    result.write(oprot)
9642 
    oprot.writeMessageEnd()
9643 
    oprot.trans.flush()
9644 
 
7169 anupam.sin 9645 
  def process_getRechargeTransactionsByNumber(self, seqid, iprot, oprot):
9646 
    args = getRechargeTransactionsByNumber_args()
9647 
    args.read(iprot)
9648 
    iprot.readMessageEnd()
9649 
    result = getRechargeTransactionsByNumber_result()
7172 anupam.sin 9650 
    result.success = self._handler.getRechargeTransactionsByNumber(args.number, args.storeId)
7169 anupam.sin 9651 
    oprot.writeMessageBegin("getRechargeTransactionsByNumber", TMessageType.REPLY, seqid)
9652 
    result.write(oprot)
9653 
    oprot.writeMessageEnd()
9654 
    oprot.trans.flush()
7109 anupam.sin 9655 
 
7169 anupam.sin 9656 
  def process_updateHotspotStorePassword(self, seqid, iprot, oprot):
9657 
    args = updateHotspotStorePassword_args()
9658 
    args.read(iprot)
9659 
    iprot.readMessageEnd()
9660 
    result = updateHotspotStorePassword_result()
9661 
    result.success = self._handler.updateHotspotStorePassword(args.storeId, args.password)
9662 
    oprot.writeMessageBegin("updateHotspotStorePassword", TMessageType.REPLY, seqid)
9663 
    result.write(oprot)
9664 
    oprot.writeMessageEnd()
9665 
    oprot.trans.flush()
9666 
 
7285 rajveer 9667 
  def process_topupCompanyWallet(self, seqid, iprot, oprot):
9668 
    args = topupCompanyWallet_args()
7263 anupam.sin 9669 
    args.read(iprot)
9670 
    iprot.readMessageEnd()
7285 rajveer 9671 
    result = topupCompanyWallet_result()
9672 
    result.success = self._handler.topupCompanyWallet(args.companyId, args.amount)
9673 
    oprot.writeMessageBegin("topupCompanyWallet", TMessageType.REPLY, seqid)
7263 anupam.sin 9674 
    result.write(oprot)
9675 
    oprot.writeMessageEnd()
9676 
    oprot.trans.flush()
7169 anupam.sin 9677 
 
7285 rajveer 9678 
  def process_getWalletBalanceForCompany(self, seqid, iprot, oprot):
9679 
    args = getWalletBalanceForCompany_args()
7267 anupam.sin 9680 
    args.read(iprot)
9681 
    iprot.readMessageEnd()
7285 rajveer 9682 
    result = getWalletBalanceForCompany_result()
9683 
    result.success = self._handler.getWalletBalanceForCompany(args.companyId)
9684 
    oprot.writeMessageBegin("getWalletBalanceForCompany", TMessageType.REPLY, seqid)
7267 anupam.sin 9685 
    result.write(oprot)
9686 
    oprot.writeMessageEnd()
9687 
    oprot.trans.flush()
7263 anupam.sin 9688 
 
7285 rajveer 9689 
  def process_getSourceDetail(self, seqid, iprot, oprot):
9690 
    args = getSourceDetail_args()
7267 anupam.sin 9691 
    args.read(iprot)
9692 
    iprot.readMessageEnd()
7285 rajveer 9693 
    result = getSourceDetail_result()
9694 
    result.success = self._handler.getSourceDetail(args.source)
9695 
    oprot.writeMessageBegin("getSourceDetail", TMessageType.REPLY, seqid)
7267 anupam.sin 9696 
    result.write(oprot)
9697 
    oprot.writeMessageEnd()
9698 
    oprot.trans.flush()
9699 
 
7308 rajveer 9700 
  def process_getAllCircles(self, seqid, iprot, oprot):
9701 
    args = getAllCircles_args()
9702 
    args.read(iprot)
9703 
    iprot.readMessageEnd()
9704 
    result = getAllCircles_result()
9705 
    result.success = self._handler.getAllCircles()
9706 
    oprot.writeMessageBegin("getAllCircles", TMessageType.REPLY, seqid)
9707 
    result.write(oprot)
9708 
    oprot.writeMessageEnd()
9709 
    oprot.trans.flush()
7267 anupam.sin 9710 
 
7308 rajveer 9711 
  def process_deleteFrcs(self, seqid, iprot, oprot):
9712 
    args = deleteFrcs_args()
9713 
    args.read(iprot)
9714 
    iprot.readMessageEnd()
9715 
    result = deleteFrcs_result()
9716 
    result.success = self._handler.deleteFrcs(args.frcIdsToDelete)
9717 
    oprot.writeMessageBegin("deleteFrcs", TMessageType.REPLY, seqid)
9718 
    result.write(oprot)
9719 
    oprot.writeMessageEnd()
9720 
    oprot.trans.flush()
9721 
 
9722 
 
94 ashish 9723 
# HELPER FUNCTIONS AND STRUCTURES
9724 
 
9725 
class createTransaction_args:
9726 
  """
9727 
  Attributes:
9728 
   - transaction
9729 
  """
9730 
 
9731 
  thrift_spec = (
9732 
    None, # 0
9733 
    (1, TType.STRUCT, 'transaction', (Transaction, Transaction.thrift_spec), None, ), # 1
9734 
  )
9735 
 
9736 
  def __init__(self, transaction=None,):
9737 
    self.transaction = transaction
9738 
 
9739 
  def read(self, iprot):
9740 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9741 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9742 
      return
9743 
    iprot.readStructBegin()
9744 
    while True:
9745 
      (fname, ftype, fid) = iprot.readFieldBegin()
9746 
      if ftype == TType.STOP:
9747 
        break
9748 
      if fid == 1:
9749 
        if ftype == TType.STRUCT:
9750 
          self.transaction = Transaction()
9751 
          self.transaction.read(iprot)
9752 
        else:
9753 
          iprot.skip(ftype)
9754 
      else:
9755 
        iprot.skip(ftype)
9756 
      iprot.readFieldEnd()
9757 
    iprot.readStructEnd()
9758 
 
9759 
  def write(self, oprot):
9760 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9761 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9762 
      return
9763 
    oprot.writeStructBegin('createTransaction_args')
3431 rajveer 9764 
    if self.transaction is not None:
94 ashish 9765 
      oprot.writeFieldBegin('transaction', TType.STRUCT, 1)
9766 
      self.transaction.write(oprot)
9767 
      oprot.writeFieldEnd()
9768 
    oprot.writeFieldStop()
9769 
    oprot.writeStructEnd()
9770 
 
3431 rajveer 9771 
  def validate(self):
9772 
    return
9773 
 
9774 
 
94 ashish 9775 
  def __repr__(self):
9776 
    L = ['%s=%r' % (key, value)
9777 
      for key, value in self.__dict__.iteritems()]
9778 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9779 
 
9780 
  def __eq__(self, other):
9781 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9782 
 
9783 
  def __ne__(self, other):
9784 
    return not (self == other)
9785 
 
9786 
class createTransaction_result:
9787 
  """
9788 
  Attributes:
132 ashish 9789 
   - success
94 ashish 9790 
   - ex
9791 
  """
9792 
 
9793 
  thrift_spec = (
132 ashish 9794 
    (0, TType.I64, 'success', None, None, ), # 0
94 ashish 9795 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
9796 
  )
9797 
 
132 ashish 9798 
  def __init__(self, success=None, ex=None,):
9799 
    self.success = success
94 ashish 9800 
    self.ex = ex
9801 
 
9802 
  def read(self, iprot):
9803 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9804 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9805 
      return
9806 
    iprot.readStructBegin()
9807 
    while True:
9808 
      (fname, ftype, fid) = iprot.readFieldBegin()
9809 
      if ftype == TType.STOP:
9810 
        break
132 ashish 9811 
      if fid == 0:
9812 
        if ftype == TType.I64:
9813 
          self.success = iprot.readI64();
9814 
        else:
9815 
          iprot.skip(ftype)
9816 
      elif fid == 1:
94 ashish 9817 
        if ftype == TType.STRUCT:
9818 
          self.ex = TransactionServiceException()
9819 
          self.ex.read(iprot)
9820 
        else:
9821 
          iprot.skip(ftype)
9822 
      else:
9823 
        iprot.skip(ftype)
9824 
      iprot.readFieldEnd()
9825 
    iprot.readStructEnd()
9826 
 
9827 
  def write(self, oprot):
9828 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9829 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9830 
      return
9831 
    oprot.writeStructBegin('createTransaction_result')
3431 rajveer 9832 
    if self.success is not None:
132 ashish 9833 
      oprot.writeFieldBegin('success', TType.I64, 0)
9834 
      oprot.writeI64(self.success)
9835 
      oprot.writeFieldEnd()
3431 rajveer 9836 
    if self.ex is not None:
94 ashish 9837 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9838 
      self.ex.write(oprot)
9839 
      oprot.writeFieldEnd()
9840 
    oprot.writeFieldStop()
9841 
    oprot.writeStructEnd()
9842 
 
3431 rajveer 9843 
  def validate(self):
9844 
    return
9845 
 
9846 
 
94 ashish 9847 
  def __repr__(self):
9848 
    L = ['%s=%r' % (key, value)
9849 
      for key, value in self.__dict__.iteritems()]
9850 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9851 
 
9852 
  def __eq__(self, other):
9853 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9854 
 
9855 
  def __ne__(self, other):
9856 
    return not (self == other)
9857 
 
9858 
class getTransaction_args:
9859 
  """
9860 
  Attributes:
9861 
   - id
9862 
  """
9863 
 
9864 
  thrift_spec = (
9865 
    None, # 0
9866 
    (1, TType.I64, 'id', None, None, ), # 1
9867 
  )
9868 
 
9869 
  def __init__(self, id=None,):
9870 
    self.id = id
9871 
 
9872 
  def read(self, iprot):
9873 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9874 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9875 
      return
9876 
    iprot.readStructBegin()
9877 
    while True:
9878 
      (fname, ftype, fid) = iprot.readFieldBegin()
9879 
      if ftype == TType.STOP:
9880 
        break
9881 
      if fid == 1:
9882 
        if ftype == TType.I64:
9883 
          self.id = iprot.readI64();
9884 
        else:
9885 
          iprot.skip(ftype)
9886 
      else:
9887 
        iprot.skip(ftype)
9888 
      iprot.readFieldEnd()
9889 
    iprot.readStructEnd()
9890 
 
9891 
  def write(self, oprot):
9892 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9893 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9894 
      return
9895 
    oprot.writeStructBegin('getTransaction_args')
3431 rajveer 9896 
    if self.id is not None:
94 ashish 9897 
      oprot.writeFieldBegin('id', TType.I64, 1)
9898 
      oprot.writeI64(self.id)
9899 
      oprot.writeFieldEnd()
9900 
    oprot.writeFieldStop()
9901 
    oprot.writeStructEnd()
9902 
 
3431 rajveer 9903 
  def validate(self):
9904 
    return
9905 
 
9906 
 
94 ashish 9907 
  def __repr__(self):
9908 
    L = ['%s=%r' % (key, value)
9909 
      for key, value in self.__dict__.iteritems()]
9910 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9911 
 
9912 
  def __eq__(self, other):
9913 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9914 
 
9915 
  def __ne__(self, other):
9916 
    return not (self == other)
9917 
 
9918 
class getTransaction_result:
9919 
  """
9920 
  Attributes:
9921 
   - success
9922 
   - ex
9923 
  """
9924 
 
9925 
  thrift_spec = (
9926 
    (0, TType.STRUCT, 'success', (Transaction, Transaction.thrift_spec), None, ), # 0
9927 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
9928 
  )
9929 
 
9930 
  def __init__(self, success=None, ex=None,):
9931 
    self.success = success
9932 
    self.ex = ex
9933 
 
9934 
  def read(self, iprot):
9935 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9936 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9937 
      return
9938 
    iprot.readStructBegin()
9939 
    while True:
9940 
      (fname, ftype, fid) = iprot.readFieldBegin()
9941 
      if ftype == TType.STOP:
9942 
        break
9943 
      if fid == 0:
9944 
        if ftype == TType.STRUCT:
9945 
          self.success = Transaction()
9946 
          self.success.read(iprot)
9947 
        else:
9948 
          iprot.skip(ftype)
9949 
      elif fid == 1:
9950 
        if ftype == TType.STRUCT:
9951 
          self.ex = TransactionServiceException()
9952 
          self.ex.read(iprot)
9953 
        else:
9954 
          iprot.skip(ftype)
9955 
      else:
9956 
        iprot.skip(ftype)
9957 
      iprot.readFieldEnd()
9958 
    iprot.readStructEnd()
9959 
 
9960 
  def write(self, oprot):
9961 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9962 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9963 
      return
9964 
    oprot.writeStructBegin('getTransaction_result')
3431 rajveer 9965 
    if self.success is not None:
94 ashish 9966 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
9967 
      self.success.write(oprot)
9968 
      oprot.writeFieldEnd()
3431 rajveer 9969 
    if self.ex is not None:
94 ashish 9970 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9971 
      self.ex.write(oprot)
9972 
      oprot.writeFieldEnd()
9973 
    oprot.writeFieldStop()
9974 
    oprot.writeStructEnd()
9975 
 
3431 rajveer 9976 
  def validate(self):
9977 
    return
9978 
 
9979 
 
94 ashish 9980 
  def __repr__(self):
9981 
    L = ['%s=%r' % (key, value)
9982 
      for key, value in self.__dict__.iteritems()]
9983 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9984 
 
9985 
  def __eq__(self, other):
9986 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9987 
 
9988 
  def __ne__(self, other):
9989 
    return not (self == other)
9990 
 
9991 
class getTransactionsForCustomer_args:
9992 
  """
9993 
  Attributes:
9994 
   - customerId
9995 
   - from_date
9996 
   - to_date
9997 
   - status
9998 
  """
9999 
 
10000 
  thrift_spec = (
10001 
    None, # 0
10002 
    (1, TType.I64, 'customerId', None, None, ), # 1
10003 
    (2, TType.I64, 'from_date', None, None, ), # 2
10004 
    (3, TType.I64, 'to_date', None, None, ), # 3
10005 
    (4, TType.I32, 'status', None, None, ), # 4
10006 
  )
10007 
 
10008 
  def __init__(self, customerId=None, from_date=None, to_date=None, status=None,):
10009 
    self.customerId = customerId
10010 
    self.from_date = from_date
10011 
    self.to_date = to_date
10012 
    self.status = status
10013 
 
10014 
  def read(self, iprot):
10015 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10016 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10017 
      return
10018 
    iprot.readStructBegin()
10019 
    while True:
10020 
      (fname, ftype, fid) = iprot.readFieldBegin()
10021 
      if ftype == TType.STOP:
10022 
        break
10023 
      if fid == 1:
10024 
        if ftype == TType.I64:
10025 
          self.customerId = iprot.readI64();
10026 
        else:
10027 
          iprot.skip(ftype)
10028 
      elif fid == 2:
10029 
        if ftype == TType.I64:
10030 
          self.from_date = iprot.readI64();
10031 
        else:
10032 
          iprot.skip(ftype)
10033 
      elif fid == 3:
10034 
        if ftype == TType.I64:
10035 
          self.to_date = iprot.readI64();
10036 
        else:
10037 
          iprot.skip(ftype)
10038 
      elif fid == 4:
10039 
        if ftype == TType.I32:
10040 
          self.status = iprot.readI32();
10041 
        else:
10042 
          iprot.skip(ftype)
10043 
      else:
10044 
        iprot.skip(ftype)
10045 
      iprot.readFieldEnd()
10046 
    iprot.readStructEnd()
10047 
 
10048 
  def write(self, oprot):
10049 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10050 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10051 
      return
10052 
    oprot.writeStructBegin('getTransactionsForCustomer_args')
3431 rajveer 10053 
    if self.customerId is not None:
94 ashish 10054 
      oprot.writeFieldBegin('customerId', TType.I64, 1)
10055 
      oprot.writeI64(self.customerId)
10056 
      oprot.writeFieldEnd()
3431 rajveer 10057 
    if self.from_date is not None:
94 ashish 10058 
      oprot.writeFieldBegin('from_date', TType.I64, 2)
10059 
      oprot.writeI64(self.from_date)
10060 
      oprot.writeFieldEnd()
3431 rajveer 10061 
    if self.to_date is not None:
94 ashish 10062 
      oprot.writeFieldBegin('to_date', TType.I64, 3)
10063 
      oprot.writeI64(self.to_date)
10064 
      oprot.writeFieldEnd()
3431 rajveer 10065 
    if self.status is not None:
94 ashish 10066 
      oprot.writeFieldBegin('status', TType.I32, 4)
10067 
      oprot.writeI32(self.status)
10068 
      oprot.writeFieldEnd()
10069 
    oprot.writeFieldStop()
10070 
    oprot.writeStructEnd()
10071 
 
3431 rajveer 10072 
  def validate(self):
10073 
    return
10074 
 
10075 
 
94 ashish 10076 
  def __repr__(self):
10077 
    L = ['%s=%r' % (key, value)
10078 
      for key, value in self.__dict__.iteritems()]
10079 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10080 
 
10081 
  def __eq__(self, other):
10082 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10083 
 
10084 
  def __ne__(self, other):
10085 
    return not (self == other)
10086 
 
10087 
class getTransactionsForCustomer_result:
10088 
  """
10089 
  Attributes:
10090 
   - success
10091 
   - ex
10092 
  """
10093 
 
10094 
  thrift_spec = (
10095 
    (0, TType.LIST, 'success', (TType.STRUCT,(Transaction, Transaction.thrift_spec)), None, ), # 0
10096 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
10097 
  )
10098 
 
10099 
  def __init__(self, success=None, ex=None,):
10100 
    self.success = success
10101 
    self.ex = ex
10102 
 
10103 
  def read(self, iprot):
10104 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10105 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10106 
      return
10107 
    iprot.readStructBegin()
10108 
    while True:
10109 
      (fname, ftype, fid) = iprot.readFieldBegin()
10110 
      if ftype == TType.STOP:
10111 
        break
10112 
      if fid == 0:
10113 
        if ftype == TType.LIST:
10114 
          self.success = []
6188 rajveer 10115 
          (_etype109, _size106) = iprot.readListBegin()
10116 
          for _i110 in xrange(_size106):
10117 
            _elem111 = Transaction()
10118 
            _elem111.read(iprot)
10119 
            self.success.append(_elem111)
94 ashish 10120 
          iprot.readListEnd()
10121 
        else:
10122 
          iprot.skip(ftype)
10123 
      elif fid == 1:
10124 
        if ftype == TType.STRUCT:
10125 
          self.ex = TransactionServiceException()
10126 
          self.ex.read(iprot)
10127 
        else:
10128 
          iprot.skip(ftype)
10129 
      else:
10130 
        iprot.skip(ftype)
10131 
      iprot.readFieldEnd()
10132 
    iprot.readStructEnd()
10133 
 
10134 
  def write(self, oprot):
10135 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10136 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10137 
      return
10138 
    oprot.writeStructBegin('getTransactionsForCustomer_result')
3431 rajveer 10139 
    if self.success is not None:
94 ashish 10140 
      oprot.writeFieldBegin('success', TType.LIST, 0)
10141 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 10142 
      for iter112 in self.success:
10143 
        iter112.write(oprot)
94 ashish 10144 
      oprot.writeListEnd()
10145 
      oprot.writeFieldEnd()
3431 rajveer 10146 
    if self.ex is not None:
94 ashish 10147 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10148 
      self.ex.write(oprot)
10149 
      oprot.writeFieldEnd()
10150 
    oprot.writeFieldStop()
10151 
    oprot.writeStructEnd()
10152 
 
3431 rajveer 10153 
  def validate(self):
10154 
    return
10155 
 
10156 
 
94 ashish 10157 
  def __repr__(self):
10158 
    L = ['%s=%r' % (key, value)
10159 
      for key, value in self.__dict__.iteritems()]
10160 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10161 
 
10162 
  def __eq__(self, other):
10163 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10164 
 
10165 
  def __ne__(self, other):
10166 
    return not (self == other)
10167 
 
132 ashish 10168 
class getTransactionsForShoppingCartId_args:
10169 
  """
10170 
  Attributes:
10171 
   - shoppingCartId
10172 
  """
10173 
 
10174 
  thrift_spec = (
10175 
    None, # 0
10176 
    (1, TType.I64, 'shoppingCartId', None, None, ), # 1
10177 
  )
10178 
 
10179 
  def __init__(self, shoppingCartId=None,):
10180 
    self.shoppingCartId = shoppingCartId
10181 
 
10182 
  def read(self, iprot):
10183 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10184 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10185 
      return
10186 
    iprot.readStructBegin()
10187 
    while True:
10188 
      (fname, ftype, fid) = iprot.readFieldBegin()
10189 
      if ftype == TType.STOP:
10190 
        break
10191 
      if fid == 1:
10192 
        if ftype == TType.I64:
10193 
          self.shoppingCartId = iprot.readI64();
10194 
        else:
10195 
          iprot.skip(ftype)
10196 
      else:
10197 
        iprot.skip(ftype)
10198 
      iprot.readFieldEnd()
10199 
    iprot.readStructEnd()
10200 
 
10201 
  def write(self, oprot):
10202 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10203 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10204 
      return
10205 
    oprot.writeStructBegin('getTransactionsForShoppingCartId_args')
3431 rajveer 10206 
    if self.shoppingCartId is not None:
132 ashish 10207 
      oprot.writeFieldBegin('shoppingCartId', TType.I64, 1)
10208 
      oprot.writeI64(self.shoppingCartId)
10209 
      oprot.writeFieldEnd()
10210 
    oprot.writeFieldStop()
10211 
    oprot.writeStructEnd()
10212 
 
3431 rajveer 10213 
  def validate(self):
10214 
    return
10215 
 
10216 
 
132 ashish 10217 
  def __repr__(self):
10218 
    L = ['%s=%r' % (key, value)
10219 
      for key, value in self.__dict__.iteritems()]
10220 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10221 
 
10222 
  def __eq__(self, other):
10223 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10224 
 
10225 
  def __ne__(self, other):
10226 
    return not (self == other)
10227 
 
10228 
class getTransactionsForShoppingCartId_result:
10229 
  """
10230 
  Attributes:
10231 
   - success
10232 
   - ex
10233 
  """
10234 
 
10235 
  thrift_spec = (
10236 
    (0, TType.LIST, 'success', (TType.STRUCT,(Transaction, Transaction.thrift_spec)), None, ), # 0
10237 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
10238 
  )
10239 
 
10240 
  def __init__(self, success=None, ex=None,):
10241 
    self.success = success
10242 
    self.ex = ex
10243 
 
10244 
  def read(self, iprot):
10245 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10246 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10247 
      return
10248 
    iprot.readStructBegin()
10249 
    while True:
10250 
      (fname, ftype, fid) = iprot.readFieldBegin()
10251 
      if ftype == TType.STOP:
10252 
        break
10253 
      if fid == 0:
10254 
        if ftype == TType.LIST:
10255 
          self.success = []
6188 rajveer 10256 
          (_etype116, _size113) = iprot.readListBegin()
10257 
          for _i117 in xrange(_size113):
10258 
            _elem118 = Transaction()
10259 
            _elem118.read(iprot)
10260 
            self.success.append(_elem118)
132 ashish 10261 
          iprot.readListEnd()
10262 
        else:
10263 
          iprot.skip(ftype)
10264 
      elif fid == 1:
10265 
        if ftype == TType.STRUCT:
10266 
          self.ex = TransactionServiceException()
10267 
          self.ex.read(iprot)
10268 
        else:
10269 
          iprot.skip(ftype)
10270 
      else:
10271 
        iprot.skip(ftype)
10272 
      iprot.readFieldEnd()
10273 
    iprot.readStructEnd()
10274 
 
10275 
  def write(self, oprot):
10276 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10277 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10278 
      return
10279 
    oprot.writeStructBegin('getTransactionsForShoppingCartId_result')
3431 rajveer 10280 
    if self.success is not None:
132 ashish 10281 
      oprot.writeFieldBegin('success', TType.LIST, 0)
10282 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 10283 
      for iter119 in self.success:
10284 
        iter119.write(oprot)
132 ashish 10285 
      oprot.writeListEnd()
10286 
      oprot.writeFieldEnd()
3431 rajveer 10287 
    if self.ex is not None:
132 ashish 10288 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10289 
      self.ex.write(oprot)
10290 
      oprot.writeFieldEnd()
10291 
    oprot.writeFieldStop()
10292 
    oprot.writeStructEnd()
10293 
 
3431 rajveer 10294 
  def validate(self):
10295 
    return
10296 
 
10297 
 
132 ashish 10298 
  def __repr__(self):
10299 
    L = ['%s=%r' % (key, value)
10300 
      for key, value in self.__dict__.iteritems()]
10301 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10302 
 
10303 
  def __eq__(self, other):
10304 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10305 
 
10306 
  def __ne__(self, other):
10307 
    return not (self == other)
10308 
 
94 ashish 10309 
class getTransactionStatus_args:
10310 
  """
10311 
  Attributes:
10312 
   - transactionId
10313 
  """
10314 
 
10315 
  thrift_spec = (
10316 
    None, # 0
10317 
    (1, TType.I64, 'transactionId', None, None, ), # 1
10318 
  )
10319 
 
10320 
  def __init__(self, transactionId=None,):
10321 
    self.transactionId = transactionId
10322 
 
10323 
  def read(self, iprot):
10324 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10325 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10326 
      return
10327 
    iprot.readStructBegin()
10328 
    while True:
10329 
      (fname, ftype, fid) = iprot.readFieldBegin()
10330 
      if ftype == TType.STOP:
10331 
        break
10332 
      if fid == 1:
10333 
        if ftype == TType.I64:
10334 
          self.transactionId = iprot.readI64();
10335 
        else:
10336 
          iprot.skip(ftype)
10337 
      else:
10338 
        iprot.skip(ftype)
10339 
      iprot.readFieldEnd()
10340 
    iprot.readStructEnd()
10341 
 
10342 
  def write(self, oprot):
10343 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10344 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10345 
      return
10346 
    oprot.writeStructBegin('getTransactionStatus_args')
3431 rajveer 10347 
    if self.transactionId is not None:
94 ashish 10348 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
10349 
      oprot.writeI64(self.transactionId)
10350 
      oprot.writeFieldEnd()
10351 
    oprot.writeFieldStop()
10352 
    oprot.writeStructEnd()
10353 
 
3431 rajveer 10354 
  def validate(self):
10355 
    return
10356 
 
10357 
 
94 ashish 10358 
  def __repr__(self):
10359 
    L = ['%s=%r' % (key, value)
10360 
      for key, value in self.__dict__.iteritems()]
10361 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10362 
 
10363 
  def __eq__(self, other):
10364 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10365 
 
10366 
  def __ne__(self, other):
10367 
    return not (self == other)
10368 
 
10369 
class getTransactionStatus_result:
10370 
  """
10371 
  Attributes:
10372 
   - success
10373 
   - ex
10374 
  """
10375 
 
10376 
  thrift_spec = (
10377 
    (0, TType.I32, 'success', None, None, ), # 0
10378 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
10379 
  )
10380 
 
10381 
  def __init__(self, success=None, ex=None,):
10382 
    self.success = success
10383 
    self.ex = ex
10384 
 
10385 
  def read(self, iprot):
10386 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10387 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10388 
      return
10389 
    iprot.readStructBegin()
10390 
    while True:
10391 
      (fname, ftype, fid) = iprot.readFieldBegin()
10392 
      if ftype == TType.STOP:
10393 
        break
10394 
      if fid == 0:
10395 
        if ftype == TType.I32:
10396 
          self.success = iprot.readI32();
10397 
        else:
10398 
          iprot.skip(ftype)
10399 
      elif fid == 1:
10400 
        if ftype == TType.STRUCT:
10401 
          self.ex = TransactionServiceException()
10402 
          self.ex.read(iprot)
10403 
        else:
10404 
          iprot.skip(ftype)
10405 
      else:
10406 
        iprot.skip(ftype)
10407 
      iprot.readFieldEnd()
10408 
    iprot.readStructEnd()
10409 
 
10410 
  def write(self, oprot):
10411 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10412 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10413 
      return
10414 
    oprot.writeStructBegin('getTransactionStatus_result')
3431 rajveer 10415 
    if self.success is not None:
94 ashish 10416 
      oprot.writeFieldBegin('success', TType.I32, 0)
10417 
      oprot.writeI32(self.success)
10418 
      oprot.writeFieldEnd()
3431 rajveer 10419 
    if self.ex is not None:
94 ashish 10420 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10421 
      self.ex.write(oprot)
10422 
      oprot.writeFieldEnd()
10423 
    oprot.writeFieldStop()
10424 
    oprot.writeStructEnd()
10425 
 
3431 rajveer 10426 
  def validate(self):
10427 
    return
10428 
 
10429 
 
94 ashish 10430 
  def __repr__(self):
10431 
    L = ['%s=%r' % (key, value)
10432 
      for key, value in self.__dict__.iteritems()]
10433 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10434 
 
10435 
  def __eq__(self, other):
10436 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10437 
 
10438 
  def __ne__(self, other):
10439 
    return not (self == other)
10440 
 
10441 
class changeTransactionStatus_args:
10442 
  """
10443 
  Attributes:
10444 
   - transactionId
10445 
   - status
10446 
   - description
5527 anupam.sin 10447 
   - pickUp
10448 
   - orderType
7293 anupam.sin 10449 
   - source
94 ashish 10450 
  """
10451 
 
10452 
  thrift_spec = (
10453 
    None, # 0
10454 
    (1, TType.I64, 'transactionId', None, None, ), # 1
10455 
    (2, TType.I32, 'status', None, None, ), # 2
10456 
    (3, TType.STRING, 'description', None, None, ), # 3
5527 anupam.sin 10457 
    (4, TType.I64, 'pickUp', None, None, ), # 4
10458 
    (5, TType.I32, 'orderType', None, None, ), # 5
7293 anupam.sin 10459 
    (6, TType.I32, 'source', None, None, ), # 6
94 ashish 10460 
  )
10461 
 
7293 anupam.sin 10462 
  def __init__(self, transactionId=None, status=None, description=None, pickUp=None, orderType=None, source=None,):
94 ashish 10463 
    self.transactionId = transactionId
10464 
    self.status = status
10465 
    self.description = description
5527 anupam.sin 10466 
    self.pickUp = pickUp
10467 
    self.orderType = orderType
7293 anupam.sin 10468 
    self.source = source
94 ashish 10469 
 
10470 
  def read(self, iprot):
10471 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10472 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10473 
      return
10474 
    iprot.readStructBegin()
10475 
    while True:
10476 
      (fname, ftype, fid) = iprot.readFieldBegin()
10477 
      if ftype == TType.STOP:
10478 
        break
10479 
      if fid == 1:
10480 
        if ftype == TType.I64:
10481 
          self.transactionId = iprot.readI64();
10482 
        else:
10483 
          iprot.skip(ftype)
10484 
      elif fid == 2:
10485 
        if ftype == TType.I32:
10486 
          self.status = iprot.readI32();
10487 
        else:
10488 
          iprot.skip(ftype)
10489 
      elif fid == 3:
10490 
        if ftype == TType.STRING:
10491 
          self.description = iprot.readString();
10492 
        else:
10493 
          iprot.skip(ftype)
5387 rajveer 10494 
      elif fid == 4:
5527 anupam.sin 10495 
        if ftype == TType.I64:
10496 
          self.pickUp = iprot.readI64();
5387 rajveer 10497 
        else:
10498 
          iprot.skip(ftype)
5527 anupam.sin 10499 
      elif fid == 5:
10500 
        if ftype == TType.I32:
10501 
          self.orderType = iprot.readI32();
10502 
        else:
10503 
          iprot.skip(ftype)
7293 anupam.sin 10504 
      elif fid == 6:
10505 
        if ftype == TType.I32:
10506 
          self.source = iprot.readI32();
10507 
        else:
10508 
          iprot.skip(ftype)
94 ashish 10509 
      else:
10510 
        iprot.skip(ftype)
10511 
      iprot.readFieldEnd()
10512 
    iprot.readStructEnd()
10513 
 
10514 
  def write(self, oprot):
10515 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10516 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10517 
      return
10518 
    oprot.writeStructBegin('changeTransactionStatus_args')
3431 rajveer 10519 
    if self.transactionId is not None:
94 ashish 10520 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
10521 
      oprot.writeI64(self.transactionId)
10522 
      oprot.writeFieldEnd()
3431 rajveer 10523 
    if self.status is not None:
94 ashish 10524 
      oprot.writeFieldBegin('status', TType.I32, 2)
10525 
      oprot.writeI32(self.status)
10526 
      oprot.writeFieldEnd()
3431 rajveer 10527 
    if self.description is not None:
94 ashish 10528 
      oprot.writeFieldBegin('description', TType.STRING, 3)
10529 
      oprot.writeString(self.description)
10530 
      oprot.writeFieldEnd()
5527 anupam.sin 10531 
    if self.pickUp is not None:
10532 
      oprot.writeFieldBegin('pickUp', TType.I64, 4)
10533 
      oprot.writeI64(self.pickUp)
5387 rajveer 10534 
      oprot.writeFieldEnd()
5527 anupam.sin 10535 
    if self.orderType is not None:
10536 
      oprot.writeFieldBegin('orderType', TType.I32, 5)
10537 
      oprot.writeI32(self.orderType)
10538 
      oprot.writeFieldEnd()
7293 anupam.sin 10539 
    if self.source is not None:
10540 
      oprot.writeFieldBegin('source', TType.I32, 6)
10541 
      oprot.writeI32(self.source)
10542 
      oprot.writeFieldEnd()
94 ashish 10543 
    oprot.writeFieldStop()
10544 
    oprot.writeStructEnd()
10545 
 
3431 rajveer 10546 
  def validate(self):
10547 
    return
10548 
 
10549 
 
94 ashish 10550 
  def __repr__(self):
10551 
    L = ['%s=%r' % (key, value)
10552 
      for key, value in self.__dict__.iteritems()]
10553 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10554 
 
10555 
  def __eq__(self, other):
10556 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10557 
 
10558 
  def __ne__(self, other):
10559 
    return not (self == other)
10560 
 
10561 
class changeTransactionStatus_result:
10562 
  """
10563 
  Attributes:
10564 
   - success
10565 
   - ex
10566 
  """
10567 
 
10568 
  thrift_spec = (
10569 
    (0, TType.BOOL, 'success', None, None, ), # 0
10570 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
10571 
  )
10572 
 
10573 
  def __init__(self, success=None, ex=None,):
10574 
    self.success = success
10575 
    self.ex = ex
10576 
 
10577 
  def read(self, iprot):
10578 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10579 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10580 
      return
10581 
    iprot.readStructBegin()
10582 
    while True:
10583 
      (fname, ftype, fid) = iprot.readFieldBegin()
10584 
      if ftype == TType.STOP:
10585 
        break
10586 
      if fid == 0:
10587 
        if ftype == TType.BOOL:
10588 
          self.success = iprot.readBool();
10589 
        else:
10590 
          iprot.skip(ftype)
10591 
      elif fid == 1:
10592 
        if ftype == TType.STRUCT:
10593 
          self.ex = TransactionServiceException()
10594 
          self.ex.read(iprot)
10595 
        else:
10596 
          iprot.skip(ftype)
10597 
      else:
10598 
        iprot.skip(ftype)
10599 
      iprot.readFieldEnd()
10600 
    iprot.readStructEnd()
10601 
 
10602 
  def write(self, oprot):
10603 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10604 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10605 
      return
10606 
    oprot.writeStructBegin('changeTransactionStatus_result')
3431 rajveer 10607 
    if self.success is not None:
94 ashish 10608 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
10609 
      oprot.writeBool(self.success)
10610 
      oprot.writeFieldEnd()
3431 rajveer 10611 
    if self.ex is not None:
94 ashish 10612 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10613 
      self.ex.write(oprot)
10614 
      oprot.writeFieldEnd()
10615 
    oprot.writeFieldStop()
10616 
    oprot.writeStructEnd()
10617 
 
3431 rajveer 10618 
  def validate(self):
10619 
    return
10620 
 
10621 
 
94 ashish 10622 
  def __repr__(self):
10623 
    L = ['%s=%r' % (key, value)
10624 
      for key, value in self.__dict__.iteritems()]
10625 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10626 
 
10627 
  def __eq__(self, other):
10628 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10629 
 
10630 
  def __ne__(self, other):
10631 
    return not (self == other)
10632 
 
1398 varun.gupt 10633 
class enqueueTransactionInfoEmail_args:
1382 varun.gupt 10634 
  """
10635 
  Attributes:
10636 
   - transactionId
10637 
  """
10638 
 
10639 
  thrift_spec = (
10640 
    None, # 0
10641 
    (1, TType.I64, 'transactionId', None, None, ), # 1
10642 
  )
10643 
 
10644 
  def __init__(self, transactionId=None,):
10645 
    self.transactionId = transactionId
10646 
 
10647 
  def read(self, iprot):
10648 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10649 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10650 
      return
10651 
    iprot.readStructBegin()
10652 
    while True:
10653 
      (fname, ftype, fid) = iprot.readFieldBegin()
10654 
      if ftype == TType.STOP:
10655 
        break
10656 
      if fid == 1:
10657 
        if ftype == TType.I64:
10658 
          self.transactionId = iprot.readI64();
10659 
        else:
10660 
          iprot.skip(ftype)
10661 
      else:
10662 
        iprot.skip(ftype)
10663 
      iprot.readFieldEnd()
10664 
    iprot.readStructEnd()
10665 
 
10666 
  def write(self, oprot):
10667 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10668 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10669 
      return
1398 varun.gupt 10670 
    oprot.writeStructBegin('enqueueTransactionInfoEmail_args')
3431 rajveer 10671 
    if self.transactionId is not None:
1382 varun.gupt 10672 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
10673 
      oprot.writeI64(self.transactionId)
10674 
      oprot.writeFieldEnd()
10675 
    oprot.writeFieldStop()
10676 
    oprot.writeStructEnd()
10677 
 
3431 rajveer 10678 
  def validate(self):
10679 
    return
10680 
 
10681 
 
1382 varun.gupt 10682 
  def __repr__(self):
10683 
    L = ['%s=%r' % (key, value)
10684 
      for key, value in self.__dict__.iteritems()]
10685 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10686 
 
10687 
  def __eq__(self, other):
10688 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10689 
 
10690 
  def __ne__(self, other):
10691 
    return not (self == other)
10692 
 
1398 varun.gupt 10693 
class enqueueTransactionInfoEmail_result:
1382 varun.gupt 10694 
  """
10695 
  Attributes:
10696 
   - success
10697 
   - ex
10698 
  """
10699 
 
10700 
  thrift_spec = (
10701 
    (0, TType.BOOL, 'success', None, None, ), # 0
10702 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
10703 
  )
10704 
 
10705 
  def __init__(self, success=None, ex=None,):
10706 
    self.success = success
10707 
    self.ex = ex
10708 
 
10709 
  def read(self, iprot):
10710 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10711 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10712 
      return
10713 
    iprot.readStructBegin()
10714 
    while True:
10715 
      (fname, ftype, fid) = iprot.readFieldBegin()
10716 
      if ftype == TType.STOP:
10717 
        break
10718 
      if fid == 0:
10719 
        if ftype == TType.BOOL:
10720 
          self.success = iprot.readBool();
10721 
        else:
10722 
          iprot.skip(ftype)
10723 
      elif fid == 1:
10724 
        if ftype == TType.STRUCT:
10725 
          self.ex = TransactionServiceException()
10726 
          self.ex.read(iprot)
10727 
        else:
10728 
          iprot.skip(ftype)
10729 
      else:
10730 
        iprot.skip(ftype)
10731 
      iprot.readFieldEnd()
10732 
    iprot.readStructEnd()
10733 
 
10734 
  def write(self, oprot):
10735 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10736 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10737 
      return
1398 varun.gupt 10738 
    oprot.writeStructBegin('enqueueTransactionInfoEmail_result')
3431 rajveer 10739 
    if self.success is not None:
1382 varun.gupt 10740 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
10741 
      oprot.writeBool(self.success)
10742 
      oprot.writeFieldEnd()
3431 rajveer 10743 
    if self.ex is not None:
1382 varun.gupt 10744 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10745 
      self.ex.write(oprot)
10746 
      oprot.writeFieldEnd()
10747 
    oprot.writeFieldStop()
10748 
    oprot.writeStructEnd()
10749 
 
3431 rajveer 10750 
  def validate(self):
10751 
    return
10752 
 
10753 
 
1382 varun.gupt 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 
 
483 rajveer 10765 
class getAllOrders_args:
94 ashish 10766 
  """
10767 
  Attributes:
4801 anupam.sin 10768 
   - statuses
483 rajveer 10769 
   - from_date
10770 
   - to_date
10771 
   - warehouse_id
94 ashish 10772 
  """
10773 
 
10774 
  thrift_spec = (
10775 
    None, # 0
4801 anupam.sin 10776 
    (1, TType.LIST, 'statuses', (TType.I32,None), None, ), # 1
483 rajveer 10777 
    (2, TType.I64, 'from_date', None, None, ), # 2
10778 
    (3, TType.I64, 'to_date', None, None, ), # 3
10779 
    (4, TType.I64, 'warehouse_id', None, None, ), # 4
94 ashish 10780 
  )
10781 
 
4801 anupam.sin 10782 
  def __init__(self, statuses=None, from_date=None, to_date=None, warehouse_id=None,):
10783 
    self.statuses = statuses
483 rajveer 10784 
    self.from_date = from_date
10785 
    self.to_date = to_date
10786 
    self.warehouse_id = warehouse_id
94 ashish 10787 
 
10788 
  def read(self, iprot):
10789 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10790 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10791 
      return
10792 
    iprot.readStructBegin()
10793 
    while True:
10794 
      (fname, ftype, fid) = iprot.readFieldBegin()
10795 
      if ftype == TType.STOP:
10796 
        break
10797 
      if fid == 1:
4801 anupam.sin 10798 
        if ftype == TType.LIST:
10799 
          self.statuses = []
6188 rajveer 10800 
          (_etype123, _size120) = iprot.readListBegin()
10801 
          for _i124 in xrange(_size120):
10802 
            _elem125 = iprot.readI32();
10803 
            self.statuses.append(_elem125)
4801 anupam.sin 10804 
          iprot.readListEnd()
94 ashish 10805 
        else:
10806 
          iprot.skip(ftype)
483 rajveer 10807 
      elif fid == 2:
10808 
        if ftype == TType.I64:
10809 
          self.from_date = iprot.readI64();
94 ashish 10810 
        else:
10811 
          iprot.skip(ftype)
483 rajveer 10812 
      elif fid == 3:
10813 
        if ftype == TType.I64:
10814 
          self.to_date = iprot.readI64();
94 ashish 10815 
        else:
10816 
          iprot.skip(ftype)
483 rajveer 10817 
      elif fid == 4:
94 ashish 10818 
        if ftype == TType.I64:
483 rajveer 10819 
          self.warehouse_id = iprot.readI64();
94 ashish 10820 
        else:
10821 
          iprot.skip(ftype)
10822 
      else:
10823 
        iprot.skip(ftype)
10824 
      iprot.readFieldEnd()
10825 
    iprot.readStructEnd()
10826 
 
10827 
  def write(self, oprot):
10828 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10829 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10830 
      return
483 rajveer 10831 
    oprot.writeStructBegin('getAllOrders_args')
4801 anupam.sin 10832 
    if self.statuses is not None:
10833 
      oprot.writeFieldBegin('statuses', TType.LIST, 1)
10834 
      oprot.writeListBegin(TType.I32, len(self.statuses))
6188 rajveer 10835 
      for iter126 in self.statuses:
10836 
        oprot.writeI32(iter126)
4801 anupam.sin 10837 
      oprot.writeListEnd()
94 ashish 10838 
      oprot.writeFieldEnd()
3431 rajveer 10839 
    if self.from_date is not None:
483 rajveer 10840 
      oprot.writeFieldBegin('from_date', TType.I64, 2)
10841 
      oprot.writeI64(self.from_date)
94 ashish 10842 
      oprot.writeFieldEnd()
3431 rajveer 10843 
    if self.to_date is not None:
483 rajveer 10844 
      oprot.writeFieldBegin('to_date', TType.I64, 3)
10845 
      oprot.writeI64(self.to_date)
94 ashish 10846 
      oprot.writeFieldEnd()
3431 rajveer 10847 
    if self.warehouse_id is not None:
483 rajveer 10848 
      oprot.writeFieldBegin('warehouse_id', TType.I64, 4)
10849 
      oprot.writeI64(self.warehouse_id)
94 ashish 10850 
      oprot.writeFieldEnd()
10851 
    oprot.writeFieldStop()
10852 
    oprot.writeStructEnd()
10853 
 
3431 rajveer 10854 
  def validate(self):
10855 
    return
10856 
 
10857 
 
94 ashish 10858 
  def __repr__(self):
10859 
    L = ['%s=%r' % (key, value)
10860 
      for key, value in self.__dict__.iteritems()]
10861 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10862 
 
10863 
  def __eq__(self, other):
10864 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10865 
 
10866 
  def __ne__(self, other):
10867 
    return not (self == other)
10868 
 
483 rajveer 10869 
class getAllOrders_result:
94 ashish 10870 
  """
10871 
  Attributes:
10872 
   - success
10873 
   - ex
10874 
  """
10875 
 
10876 
  thrift_spec = (
483 rajveer 10877 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
94 ashish 10878 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
10879 
  )
10880 
 
10881 
  def __init__(self, success=None, ex=None,):
10882 
    self.success = success
10883 
    self.ex = ex
10884 
 
10885 
  def read(self, iprot):
10886 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10887 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10888 
      return
10889 
    iprot.readStructBegin()
10890 
    while True:
10891 
      (fname, ftype, fid) = iprot.readFieldBegin()
10892 
      if ftype == TType.STOP:
10893 
        break
10894 
      if fid == 0:
483 rajveer 10895 
        if ftype == TType.LIST:
10896 
          self.success = []
6188 rajveer 10897 
          (_etype130, _size127) = iprot.readListBegin()
10898 
          for _i131 in xrange(_size127):
10899 
            _elem132 = Order()
10900 
            _elem132.read(iprot)
10901 
            self.success.append(_elem132)
483 rajveer 10902 
          iprot.readListEnd()
94 ashish 10903 
        else:
10904 
          iprot.skip(ftype)
10905 
      elif fid == 1:
10906 
        if ftype == TType.STRUCT:
10907 
          self.ex = TransactionServiceException()
10908 
          self.ex.read(iprot)
10909 
        else:
10910 
          iprot.skip(ftype)
10911 
      else:
10912 
        iprot.skip(ftype)
10913 
      iprot.readFieldEnd()
10914 
    iprot.readStructEnd()
10915 
 
10916 
  def write(self, oprot):
10917 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10918 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10919 
      return
483 rajveer 10920 
    oprot.writeStructBegin('getAllOrders_result')
3431 rajveer 10921 
    if self.success is not None:
483 rajveer 10922 
      oprot.writeFieldBegin('success', TType.LIST, 0)
10923 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 10924 
      for iter133 in self.success:
10925 
        iter133.write(oprot)
483 rajveer 10926 
      oprot.writeListEnd()
94 ashish 10927 
      oprot.writeFieldEnd()
3431 rajveer 10928 
    if self.ex is not None:
94 ashish 10929 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10930 
      self.ex.write(oprot)
10931 
      oprot.writeFieldEnd()
10932 
    oprot.writeFieldStop()
10933 
    oprot.writeStructEnd()
10934 
 
3431 rajveer 10935 
  def validate(self):
10936 
    return
10937 
 
10938 
 
94 ashish 10939 
  def __repr__(self):
10940 
    L = ['%s=%r' % (key, value)
10941 
      for key, value in self.__dict__.iteritems()]
10942 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10943 
 
10944 
  def __eq__(self, other):
10945 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10946 
 
10947 
  def __ne__(self, other):
10948 
    return not (self == other)
10949 
 
4133 chandransh 10950 
class getOrdersInBatch_args:
10951 
  """
10952 
  Attributes:
10953 
   - statuses
10954 
   - offset
10955 
   - limit
10956 
   - warehouse_id
10957 
  """
10958 
 
10959 
  thrift_spec = (
10960 
    None, # 0
10961 
    (1, TType.LIST, 'statuses', (TType.I32,None), None, ), # 1
10962 
    (2, TType.I64, 'offset', None, None, ), # 2
10963 
    (3, TType.I64, 'limit', None, None, ), # 3
10964 
    (4, TType.I64, 'warehouse_id', None, None, ), # 4
10965 
  )
10966 
 
10967 
  def __init__(self, statuses=None, offset=None, limit=None, warehouse_id=None,):
10968 
    self.statuses = statuses
10969 
    self.offset = offset
10970 
    self.limit = limit
10971 
    self.warehouse_id = warehouse_id
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 == 1:
10983 
        if ftype == TType.LIST:
10984 
          self.statuses = []
6188 rajveer 10985 
          (_etype137, _size134) = iprot.readListBegin()
10986 
          for _i138 in xrange(_size134):
10987 
            _elem139 = iprot.readI32();
10988 
            self.statuses.append(_elem139)
4133 chandransh 10989 
          iprot.readListEnd()
10990 
        else:
10991 
          iprot.skip(ftype)
10992 
      elif fid == 2:
10993 
        if ftype == TType.I64:
10994 
          self.offset = iprot.readI64();
10995 
        else:
10996 
          iprot.skip(ftype)
10997 
      elif fid == 3:
10998 
        if ftype == TType.I64:
10999 
          self.limit = iprot.readI64();
11000 
        else:
11001 
          iprot.skip(ftype)
11002 
      elif fid == 4:
11003 
        if ftype == TType.I64:
11004 
          self.warehouse_id = iprot.readI64();
11005 
        else:
11006 
          iprot.skip(ftype)
11007 
      else:
11008 
        iprot.skip(ftype)
11009 
      iprot.readFieldEnd()
11010 
    iprot.readStructEnd()
11011 
 
11012 
  def write(self, oprot):
11013 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11014 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11015 
      return
11016 
    oprot.writeStructBegin('getOrdersInBatch_args')
11017 
    if self.statuses is not None:
11018 
      oprot.writeFieldBegin('statuses', TType.LIST, 1)
11019 
      oprot.writeListBegin(TType.I32, len(self.statuses))
6188 rajveer 11020 
      for iter140 in self.statuses:
11021 
        oprot.writeI32(iter140)
4133 chandransh 11022 
      oprot.writeListEnd()
11023 
      oprot.writeFieldEnd()
11024 
    if self.offset is not None:
11025 
      oprot.writeFieldBegin('offset', TType.I64, 2)
11026 
      oprot.writeI64(self.offset)
11027 
      oprot.writeFieldEnd()
11028 
    if self.limit is not None:
11029 
      oprot.writeFieldBegin('limit', TType.I64, 3)
11030 
      oprot.writeI64(self.limit)
11031 
      oprot.writeFieldEnd()
11032 
    if self.warehouse_id is not None:
11033 
      oprot.writeFieldBegin('warehouse_id', TType.I64, 4)
11034 
      oprot.writeI64(self.warehouse_id)
11035 
      oprot.writeFieldEnd()
11036 
    oprot.writeFieldStop()
11037 
    oprot.writeStructEnd()
11038 
 
11039 
  def validate(self):
11040 
    return
11041 
 
11042 
 
11043 
  def __repr__(self):
11044 
    L = ['%s=%r' % (key, value)
11045 
      for key, value in self.__dict__.iteritems()]
11046 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11047 
 
11048 
  def __eq__(self, other):
11049 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11050 
 
11051 
  def __ne__(self, other):
11052 
    return not (self == other)
11053 
 
11054 
class getOrdersInBatch_result:
11055 
  """
11056 
  Attributes:
11057 
   - success
11058 
   - ex
11059 
  """
11060 
 
11061 
  thrift_spec = (
11062 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
11063 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
11064 
  )
11065 
 
11066 
  def __init__(self, success=None, ex=None,):
11067 
    self.success = success
11068 
    self.ex = ex
11069 
 
11070 
  def read(self, iprot):
11071 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11072 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11073 
      return
11074 
    iprot.readStructBegin()
11075 
    while True:
11076 
      (fname, ftype, fid) = iprot.readFieldBegin()
11077 
      if ftype == TType.STOP:
11078 
        break
11079 
      if fid == 0:
11080 
        if ftype == TType.LIST:
11081 
          self.success = []
6188 rajveer 11082 
          (_etype144, _size141) = iprot.readListBegin()
11083 
          for _i145 in xrange(_size141):
11084 
            _elem146 = Order()
11085 
            _elem146.read(iprot)
11086 
            self.success.append(_elem146)
4133 chandransh 11087 
          iprot.readListEnd()
11088 
        else:
11089 
          iprot.skip(ftype)
11090 
      elif fid == 1:
11091 
        if ftype == TType.STRUCT:
11092 
          self.ex = TransactionServiceException()
11093 
          self.ex.read(iprot)
11094 
        else:
11095 
          iprot.skip(ftype)
11096 
      else:
11097 
        iprot.skip(ftype)
11098 
      iprot.readFieldEnd()
11099 
    iprot.readStructEnd()
11100 
 
11101 
  def write(self, oprot):
11102 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11103 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11104 
      return
11105 
    oprot.writeStructBegin('getOrdersInBatch_result')
11106 
    if self.success is not None:
11107 
      oprot.writeFieldBegin('success', TType.LIST, 0)
11108 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 11109 
      for iter147 in self.success:
11110 
        iter147.write(oprot)
4133 chandransh 11111 
      oprot.writeListEnd()
11112 
      oprot.writeFieldEnd()
11113 
    if self.ex is not None:
11114 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11115 
      self.ex.write(oprot)
11116 
      oprot.writeFieldEnd()
11117 
    oprot.writeFieldStop()
11118 
    oprot.writeStructEnd()
11119 
 
11120 
  def validate(self):
11121 
    return
11122 
 
11123 
 
11124 
  def __repr__(self):
11125 
    L = ['%s=%r' % (key, value)
11126 
      for key, value in self.__dict__.iteritems()]
11127 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11128 
 
11129 
  def __eq__(self, other):
11130 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11131 
 
11132 
  def __ne__(self, other):
11133 
    return not (self == other)
11134 
 
11135 
class getOrderCount_args:
11136 
  """
11137 
  Attributes:
11138 
   - statuses
11139 
   - warehouseId
11140 
  """
11141 
 
11142 
  thrift_spec = (
11143 
    None, # 0
11144 
    (1, TType.LIST, 'statuses', (TType.I32,None), None, ), # 1
11145 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
11146 
  )
11147 
 
11148 
  def __init__(self, statuses=None, warehouseId=None,):
11149 
    self.statuses = statuses
11150 
    self.warehouseId = warehouseId
11151 
 
11152 
  def read(self, iprot):
11153 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11154 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11155 
      return
11156 
    iprot.readStructBegin()
11157 
    while True:
11158 
      (fname, ftype, fid) = iprot.readFieldBegin()
11159 
      if ftype == TType.STOP:
11160 
        break
11161 
      if fid == 1:
11162 
        if ftype == TType.LIST:
11163 
          self.statuses = []
6188 rajveer 11164 
          (_etype151, _size148) = iprot.readListBegin()
11165 
          for _i152 in xrange(_size148):
11166 
            _elem153 = iprot.readI32();
11167 
            self.statuses.append(_elem153)
4133 chandransh 11168 
          iprot.readListEnd()
11169 
        else:
11170 
          iprot.skip(ftype)
11171 
      elif fid == 2:
11172 
        if ftype == TType.I64:
11173 
          self.warehouseId = iprot.readI64();
11174 
        else:
11175 
          iprot.skip(ftype)
11176 
      else:
11177 
        iprot.skip(ftype)
11178 
      iprot.readFieldEnd()
11179 
    iprot.readStructEnd()
11180 
 
11181 
  def write(self, oprot):
11182 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11183 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11184 
      return
11185 
    oprot.writeStructBegin('getOrderCount_args')
11186 
    if self.statuses is not None:
11187 
      oprot.writeFieldBegin('statuses', TType.LIST, 1)
11188 
      oprot.writeListBegin(TType.I32, len(self.statuses))
6188 rajveer 11189 
      for iter154 in self.statuses:
11190 
        oprot.writeI32(iter154)
4133 chandransh 11191 
      oprot.writeListEnd()
11192 
      oprot.writeFieldEnd()
11193 
    if self.warehouseId is not None:
11194 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
11195 
      oprot.writeI64(self.warehouseId)
11196 
      oprot.writeFieldEnd()
11197 
    oprot.writeFieldStop()
11198 
    oprot.writeStructEnd()
11199 
 
11200 
  def validate(self):
11201 
    return
11202 
 
11203 
 
11204 
  def __repr__(self):
11205 
    L = ['%s=%r' % (key, value)
11206 
      for key, value in self.__dict__.iteritems()]
11207 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11208 
 
11209 
  def __eq__(self, other):
11210 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11211 
 
11212 
  def __ne__(self, other):
11213 
    return not (self == other)
11214 
 
11215 
class getOrderCount_result:
11216 
  """
11217 
  Attributes:
11218 
   - success
11219 
   - ex
11220 
  """
11221 
 
11222 
  thrift_spec = (
11223 
    (0, TType.I32, 'success', None, None, ), # 0
11224 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
11225 
  )
11226 
 
11227 
  def __init__(self, success=None, ex=None,):
11228 
    self.success = success
11229 
    self.ex = ex
11230 
 
11231 
  def read(self, iprot):
11232 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11233 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11234 
      return
11235 
    iprot.readStructBegin()
11236 
    while True:
11237 
      (fname, ftype, fid) = iprot.readFieldBegin()
11238 
      if ftype == TType.STOP:
11239 
        break
11240 
      if fid == 0:
11241 
        if ftype == TType.I32:
11242 
          self.success = iprot.readI32();
11243 
        else:
11244 
          iprot.skip(ftype)
11245 
      elif fid == 1:
11246 
        if ftype == TType.STRUCT:
11247 
          self.ex = TransactionServiceException()
11248 
          self.ex.read(iprot)
11249 
        else:
11250 
          iprot.skip(ftype)
11251 
      else:
11252 
        iprot.skip(ftype)
11253 
      iprot.readFieldEnd()
11254 
    iprot.readStructEnd()
11255 
 
11256 
  def write(self, oprot):
11257 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11258 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11259 
      return
11260 
    oprot.writeStructBegin('getOrderCount_result')
11261 
    if self.success is not None:
11262 
      oprot.writeFieldBegin('success', TType.I32, 0)
11263 
      oprot.writeI32(self.success)
11264 
      oprot.writeFieldEnd()
11265 
    if self.ex is not None:
11266 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11267 
      self.ex.write(oprot)
11268 
      oprot.writeFieldEnd()
11269 
    oprot.writeFieldStop()
11270 
    oprot.writeStructEnd()
11271 
 
11272 
  def validate(self):
11273 
    return
11274 
 
11275 
 
11276 
  def __repr__(self):
11277 
    L = ['%s=%r' % (key, value)
11278 
      for key, value in self.__dict__.iteritems()]
11279 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11280 
 
11281 
  def __eq__(self, other):
11282 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11283 
 
11284 
  def __ne__(self, other):
11285 
    return not (self == other)
11286 
 
999 varun.gupt 11287 
class getOrdersByBillingDate_args:
11288 
  """
11289 
  Attributes:
11290 
   - status
11291 
   - start_billing_date
11292 
   - end_billing_date
11293 
   - warehouse_id
11294 
  """
11295 
 
11296 
  thrift_spec = (
11297 
    None, # 0
11298 
    (1, TType.I32, 'status', None, None, ), # 1
11299 
    (2, TType.I64, 'start_billing_date', None, None, ), # 2
11300 
    (3, TType.I64, 'end_billing_date', None, None, ), # 3
11301 
    (4, TType.I64, 'warehouse_id', None, None, ), # 4
11302 
  )
11303 
 
11304 
  def __init__(self, status=None, start_billing_date=None, end_billing_date=None, warehouse_id=None,):
11305 
    self.status = status
11306 
    self.start_billing_date = start_billing_date
11307 
    self.end_billing_date = end_billing_date
11308 
    self.warehouse_id = warehouse_id
11309 
 
11310 
  def read(self, iprot):
11311 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11312 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11313 
      return
11314 
    iprot.readStructBegin()
11315 
    while True:
11316 
      (fname, ftype, fid) = iprot.readFieldBegin()
11317 
      if ftype == TType.STOP:
11318 
        break
11319 
      if fid == 1:
11320 
        if ftype == TType.I32:
11321 
          self.status = iprot.readI32();
11322 
        else:
11323 
          iprot.skip(ftype)
11324 
      elif fid == 2:
11325 
        if ftype == TType.I64:
11326 
          self.start_billing_date = iprot.readI64();
11327 
        else:
11328 
          iprot.skip(ftype)
11329 
      elif fid == 3:
11330 
        if ftype == TType.I64:
11331 
          self.end_billing_date = iprot.readI64();
11332 
        else:
11333 
          iprot.skip(ftype)
11334 
      elif fid == 4:
11335 
        if ftype == TType.I64:
11336 
          self.warehouse_id = iprot.readI64();
11337 
        else:
11338 
          iprot.skip(ftype)
11339 
      else:
11340 
        iprot.skip(ftype)
11341 
      iprot.readFieldEnd()
11342 
    iprot.readStructEnd()
11343 
 
11344 
  def write(self, oprot):
11345 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11346 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11347 
      return
11348 
    oprot.writeStructBegin('getOrdersByBillingDate_args')
3431 rajveer 11349 
    if self.status is not None:
999 varun.gupt 11350 
      oprot.writeFieldBegin('status', TType.I32, 1)
11351 
      oprot.writeI32(self.status)
11352 
      oprot.writeFieldEnd()
3431 rajveer 11353 
    if self.start_billing_date is not None:
999 varun.gupt 11354 
      oprot.writeFieldBegin('start_billing_date', TType.I64, 2)
11355 
      oprot.writeI64(self.start_billing_date)
11356 
      oprot.writeFieldEnd()
3431 rajveer 11357 
    if self.end_billing_date is not None:
999 varun.gupt 11358 
      oprot.writeFieldBegin('end_billing_date', TType.I64, 3)
11359 
      oprot.writeI64(self.end_billing_date)
11360 
      oprot.writeFieldEnd()
3431 rajveer 11361 
    if self.warehouse_id is not None:
999 varun.gupt 11362 
      oprot.writeFieldBegin('warehouse_id', TType.I64, 4)
11363 
      oprot.writeI64(self.warehouse_id)
11364 
      oprot.writeFieldEnd()
11365 
    oprot.writeFieldStop()
11366 
    oprot.writeStructEnd()
11367 
 
3431 rajveer 11368 
  def validate(self):
11369 
    return
11370 
 
11371 
 
999 varun.gupt 11372 
  def __repr__(self):
11373 
    L = ['%s=%r' % (key, value)
11374 
      for key, value in self.__dict__.iteritems()]
11375 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11376 
 
11377 
  def __eq__(self, other):
11378 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11379 
 
11380 
  def __ne__(self, other):
11381 
    return not (self == other)
11382 
 
11383 
class getOrdersByBillingDate_result:
11384 
  """
11385 
  Attributes:
11386 
   - success
11387 
   - ex
11388 
  """
11389 
 
11390 
  thrift_spec = (
11391 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
11392 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
11393 
  )
11394 
 
11395 
  def __init__(self, success=None, ex=None,):
11396 
    self.success = success
11397 
    self.ex = ex
11398 
 
11399 
  def read(self, iprot):
11400 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11401 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11402 
      return
11403 
    iprot.readStructBegin()
11404 
    while True:
11405 
      (fname, ftype, fid) = iprot.readFieldBegin()
11406 
      if ftype == TType.STOP:
11407 
        break
11408 
      if fid == 0:
11409 
        if ftype == TType.LIST:
11410 
          self.success = []
6188 rajveer 11411 
          (_etype158, _size155) = iprot.readListBegin()
11412 
          for _i159 in xrange(_size155):
11413 
            _elem160 = Order()
11414 
            _elem160.read(iprot)
11415 
            self.success.append(_elem160)
999 varun.gupt 11416 
          iprot.readListEnd()
11417 
        else:
11418 
          iprot.skip(ftype)
11419 
      elif fid == 1:
11420 
        if ftype == TType.STRUCT:
11421 
          self.ex = TransactionServiceException()
11422 
          self.ex.read(iprot)
11423 
        else:
11424 
          iprot.skip(ftype)
11425 
      else:
11426 
        iprot.skip(ftype)
11427 
      iprot.readFieldEnd()
11428 
    iprot.readStructEnd()
11429 
 
11430 
  def write(self, oprot):
11431 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11432 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11433 
      return
11434 
    oprot.writeStructBegin('getOrdersByBillingDate_result')
3431 rajveer 11435 
    if self.success is not None:
999 varun.gupt 11436 
      oprot.writeFieldBegin('success', TType.LIST, 0)
11437 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 11438 
      for iter161 in self.success:
11439 
        iter161.write(oprot)
999 varun.gupt 11440 
      oprot.writeListEnd()
11441 
      oprot.writeFieldEnd()
3431 rajveer 11442 
    if self.ex is not None:
999 varun.gupt 11443 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11444 
      self.ex.write(oprot)
11445 
      oprot.writeFieldEnd()
11446 
    oprot.writeFieldStop()
11447 
    oprot.writeStructEnd()
11448 
 
3431 rajveer 11449 
  def validate(self):
11450 
    return
11451 
 
11452 
 
999 varun.gupt 11453 
  def __repr__(self):
11454 
    L = ['%s=%r' % (key, value)
11455 
      for key, value in self.__dict__.iteritems()]
11456 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11457 
 
11458 
  def __eq__(self, other):
11459 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11460 
 
11461 
  def __ne__(self, other):
11462 
    return not (self == other)
11463 
 
3427 chandransh 11464 
class getOrdersByShippingDate_args:
11465 
  """
11466 
  Attributes:
11467 
   - fromShippingDate
11468 
   - toShippingDate
11469 
   - providerId
11470 
   - warehouseId
3451 chandransh 11471 
   - cod
3427 chandransh 11472 
  """
11473 
 
11474 
  thrift_spec = (
11475 
    None, # 0
11476 
    (1, TType.I64, 'fromShippingDate', None, None, ), # 1
11477 
    (2, TType.I64, 'toShippingDate', None, None, ), # 2
11478 
    (3, TType.I64, 'providerId', None, None, ), # 3
11479 
    (4, TType.I64, 'warehouseId', None, None, ), # 4
3451 chandransh 11480 
    (5, TType.BOOL, 'cod', None, None, ), # 5
3427 chandransh 11481 
  )
11482 
 
3451 chandransh 11483 
  def __init__(self, fromShippingDate=None, toShippingDate=None, providerId=None, warehouseId=None, cod=None,):
3427 chandransh 11484 
    self.fromShippingDate = fromShippingDate
11485 
    self.toShippingDate = toShippingDate
11486 
    self.providerId = providerId
11487 
    self.warehouseId = warehouseId
3451 chandransh 11488 
    self.cod = cod
3427 chandransh 11489 
 
11490 
  def read(self, iprot):
11491 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11492 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11493 
      return
11494 
    iprot.readStructBegin()
11495 
    while True:
11496 
      (fname, ftype, fid) = iprot.readFieldBegin()
11497 
      if ftype == TType.STOP:
11498 
        break
11499 
      if fid == 1:
11500 
        if ftype == TType.I64:
11501 
          self.fromShippingDate = iprot.readI64();
11502 
        else:
11503 
          iprot.skip(ftype)
11504 
      elif fid == 2:
11505 
        if ftype == TType.I64:
11506 
          self.toShippingDate = iprot.readI64();
11507 
        else:
11508 
          iprot.skip(ftype)
11509 
      elif fid == 3:
11510 
        if ftype == TType.I64:
11511 
          self.providerId = iprot.readI64();
11512 
        else:
11513 
          iprot.skip(ftype)
11514 
      elif fid == 4:
11515 
        if ftype == TType.I64:
11516 
          self.warehouseId = iprot.readI64();
11517 
        else:
11518 
          iprot.skip(ftype)
3451 chandransh 11519 
      elif fid == 5:
11520 
        if ftype == TType.BOOL:
11521 
          self.cod = iprot.readBool();
11522 
        else:
11523 
          iprot.skip(ftype)
3427 chandransh 11524 
      else:
11525 
        iprot.skip(ftype)
11526 
      iprot.readFieldEnd()
11527 
    iprot.readStructEnd()
11528 
 
11529 
  def write(self, oprot):
11530 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11531 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11532 
      return
11533 
    oprot.writeStructBegin('getOrdersByShippingDate_args')
3431 rajveer 11534 
    if self.fromShippingDate is not None:
3427 chandransh 11535 
      oprot.writeFieldBegin('fromShippingDate', TType.I64, 1)
11536 
      oprot.writeI64(self.fromShippingDate)
11537 
      oprot.writeFieldEnd()
3431 rajveer 11538 
    if self.toShippingDate is not None:
3427 chandransh 11539 
      oprot.writeFieldBegin('toShippingDate', TType.I64, 2)
11540 
      oprot.writeI64(self.toShippingDate)
11541 
      oprot.writeFieldEnd()
3431 rajveer 11542 
    if self.providerId is not None:
3427 chandransh 11543 
      oprot.writeFieldBegin('providerId', TType.I64, 3)
11544 
      oprot.writeI64(self.providerId)
11545 
      oprot.writeFieldEnd()
3431 rajveer 11546 
    if self.warehouseId is not None:
3427 chandransh 11547 
      oprot.writeFieldBegin('warehouseId', TType.I64, 4)
11548 
      oprot.writeI64(self.warehouseId)
11549 
      oprot.writeFieldEnd()
3451 chandransh 11550 
    if self.cod is not None:
11551 
      oprot.writeFieldBegin('cod', TType.BOOL, 5)
11552 
      oprot.writeBool(self.cod)
11553 
      oprot.writeFieldEnd()
3427 chandransh 11554 
    oprot.writeFieldStop()
11555 
    oprot.writeStructEnd()
11556 
 
3431 rajveer 11557 
  def validate(self):
11558 
    return
11559 
 
11560 
 
3427 chandransh 11561 
  def __repr__(self):
11562 
    L = ['%s=%r' % (key, value)
11563 
      for key, value in self.__dict__.iteritems()]
11564 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11565 
 
11566 
  def __eq__(self, other):
11567 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11568 
 
11569 
  def __ne__(self, other):
11570 
    return not (self == other)
11571 
 
11572 
class getOrdersByShippingDate_result:
11573 
  """
11574 
  Attributes:
11575 
   - success
11576 
   - ex
11577 
  """
11578 
 
11579 
  thrift_spec = (
11580 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
11581 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
11582 
  )
11583 
 
11584 
  def __init__(self, success=None, ex=None,):
11585 
    self.success = success
11586 
    self.ex = ex
11587 
 
11588 
  def read(self, iprot):
11589 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11590 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11591 
      return
11592 
    iprot.readStructBegin()
11593 
    while True:
11594 
      (fname, ftype, fid) = iprot.readFieldBegin()
11595 
      if ftype == TType.STOP:
11596 
        break
11597 
      if fid == 0:
11598 
        if ftype == TType.LIST:
11599 
          self.success = []
6188 rajveer 11600 
          (_etype165, _size162) = iprot.readListBegin()
11601 
          for _i166 in xrange(_size162):
11602 
            _elem167 = Order()
11603 
            _elem167.read(iprot)
11604 
            self.success.append(_elem167)
3427 chandransh 11605 
          iprot.readListEnd()
11606 
        else:
11607 
          iprot.skip(ftype)
11608 
      elif fid == 1:
11609 
        if ftype == TType.STRUCT:
11610 
          self.ex = TransactionServiceException()
11611 
          self.ex.read(iprot)
11612 
        else:
11613 
          iprot.skip(ftype)
11614 
      else:
11615 
        iprot.skip(ftype)
11616 
      iprot.readFieldEnd()
11617 
    iprot.readStructEnd()
11618 
 
11619 
  def write(self, oprot):
11620 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11621 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11622 
      return
11623 
    oprot.writeStructBegin('getOrdersByShippingDate_result')
3431 rajveer 11624 
    if self.success is not None:
3427 chandransh 11625 
      oprot.writeFieldBegin('success', TType.LIST, 0)
11626 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 11627 
      for iter168 in self.success:
11628 
        iter168.write(oprot)
3427 chandransh 11629 
      oprot.writeListEnd()
11630 
      oprot.writeFieldEnd()
3431 rajveer 11631 
    if self.ex is not None:
3427 chandransh 11632 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11633 
      self.ex.write(oprot)
11634 
      oprot.writeFieldEnd()
11635 
    oprot.writeFieldStop()
11636 
    oprot.writeStructEnd()
11637 
 
3431 rajveer 11638 
  def validate(self):
11639 
    return
11640 
 
11641 
 
3427 chandransh 11642 
  def __repr__(self):
11643 
    L = ['%s=%r' % (key, value)
11644 
      for key, value in self.__dict__.iteritems()]
11645 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11646 
 
11647 
  def __eq__(self, other):
11648 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11649 
 
11650 
  def __ne__(self, other):
11651 
    return not (self == other)
11652 
 
1382 varun.gupt 11653 
class getReturnableOrdersForCustomer_args:
11654 
  """
11655 
  Attributes:
11656 
   - customer_id
11657 
   - limit
11658 
  """
11659 
 
11660 
  thrift_spec = (
11661 
    None, # 0
11662 
    (1, TType.I64, 'customer_id', None, None, ), # 1
11663 
    (2, TType.I64, 'limit', None, None, ), # 2
11664 
  )
11665 
 
11666 
  def __init__(self, customer_id=None, limit=None,):
11667 
    self.customer_id = customer_id
11668 
    self.limit = limit
11669 
 
11670 
  def read(self, iprot):
11671 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11672 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11673 
      return
11674 
    iprot.readStructBegin()
11675 
    while True:
11676 
      (fname, ftype, fid) = iprot.readFieldBegin()
11677 
      if ftype == TType.STOP:
11678 
        break
11679 
      if fid == 1:
11680 
        if ftype == TType.I64:
11681 
          self.customer_id = iprot.readI64();
11682 
        else:
11683 
          iprot.skip(ftype)
11684 
      elif fid == 2:
11685 
        if ftype == TType.I64:
11686 
          self.limit = iprot.readI64();
11687 
        else:
11688 
          iprot.skip(ftype)
11689 
      else:
11690 
        iprot.skip(ftype)
11691 
      iprot.readFieldEnd()
11692 
    iprot.readStructEnd()
11693 
 
11694 
  def write(self, oprot):
11695 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11696 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11697 
      return
11698 
    oprot.writeStructBegin('getReturnableOrdersForCustomer_args')
3431 rajveer 11699 
    if self.customer_id is not None:
1382 varun.gupt 11700 
      oprot.writeFieldBegin('customer_id', TType.I64, 1)
11701 
      oprot.writeI64(self.customer_id)
11702 
      oprot.writeFieldEnd()
3431 rajveer 11703 
    if self.limit is not None:
1382 varun.gupt 11704 
      oprot.writeFieldBegin('limit', TType.I64, 2)
11705 
      oprot.writeI64(self.limit)
11706 
      oprot.writeFieldEnd()
11707 
    oprot.writeFieldStop()
11708 
    oprot.writeStructEnd()
11709 
 
3431 rajveer 11710 
  def validate(self):
11711 
    return
11712 
 
11713 
 
1382 varun.gupt 11714 
  def __repr__(self):
11715 
    L = ['%s=%r' % (key, value)
11716 
      for key, value in self.__dict__.iteritems()]
11717 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11718 
 
11719 
  def __eq__(self, other):
11720 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11721 
 
11722 
  def __ne__(self, other):
11723 
    return not (self == other)
11724 
 
11725 
class getReturnableOrdersForCustomer_result:
11726 
  """
11727 
  Attributes:
11728 
   - success
11729 
   - ex
11730 
  """
11731 
 
11732 
  thrift_spec = (
11733 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
11734 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
11735 
  )
11736 
 
11737 
  def __init__(self, success=None, ex=None,):
11738 
    self.success = success
11739 
    self.ex = ex
11740 
 
11741 
  def read(self, iprot):
11742 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11743 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11744 
      return
11745 
    iprot.readStructBegin()
11746 
    while True:
11747 
      (fname, ftype, fid) = iprot.readFieldBegin()
11748 
      if ftype == TType.STOP:
11749 
        break
11750 
      if fid == 0:
11751 
        if ftype == TType.LIST:
11752 
          self.success = []
6188 rajveer 11753 
          (_etype172, _size169) = iprot.readListBegin()
11754 
          for _i173 in xrange(_size169):
11755 
            _elem174 = iprot.readI64();
11756 
            self.success.append(_elem174)
1382 varun.gupt 11757 
          iprot.readListEnd()
11758 
        else:
11759 
          iprot.skip(ftype)
11760 
      elif fid == 1:
11761 
        if ftype == TType.STRUCT:
11762 
          self.ex = TransactionServiceException()
11763 
          self.ex.read(iprot)
11764 
        else:
11765 
          iprot.skip(ftype)
11766 
      else:
11767 
        iprot.skip(ftype)
11768 
      iprot.readFieldEnd()
11769 
    iprot.readStructEnd()
11770 
 
11771 
  def write(self, oprot):
11772 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11773 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11774 
      return
11775 
    oprot.writeStructBegin('getReturnableOrdersForCustomer_result')
3431 rajveer 11776 
    if self.success is not None:
1382 varun.gupt 11777 
      oprot.writeFieldBegin('success', TType.LIST, 0)
11778 
      oprot.writeListBegin(TType.I64, len(self.success))
6188 rajveer 11779 
      for iter175 in self.success:
11780 
        oprot.writeI64(iter175)
1382 varun.gupt 11781 
      oprot.writeListEnd()
11782 
      oprot.writeFieldEnd()
3431 rajveer 11783 
    if self.ex is not None:
1382 varun.gupt 11784 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11785 
      self.ex.write(oprot)
11786 
      oprot.writeFieldEnd()
11787 
    oprot.writeFieldStop()
11788 
    oprot.writeStructEnd()
11789 
 
3431 rajveer 11790 
  def validate(self):
11791 
    return
11792 
 
11793 
 
1382 varun.gupt 11794 
  def __repr__(self):
11795 
    L = ['%s=%r' % (key, value)
11796 
      for key, value in self.__dict__.iteritems()]
11797 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11798 
 
11799 
  def __eq__(self, other):
11800 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11801 
 
11802 
  def __ne__(self, other):
11803 
    return not (self == other)
11804 
 
11805 
class getCancellableOrdersForCustomer_args:
11806 
  """
11807 
  Attributes:
11808 
   - customer_id
11809 
   - limit
11810 
  """
11811 
 
11812 
  thrift_spec = (
11813 
    None, # 0
11814 
    (1, TType.I64, 'customer_id', None, None, ), # 1
11815 
    (2, TType.I64, 'limit', None, None, ), # 2
11816 
  )
11817 
 
11818 
  def __init__(self, customer_id=None, limit=None,):
11819 
    self.customer_id = customer_id
11820 
    self.limit = limit
11821 
 
11822 
  def read(self, iprot):
11823 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11824 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11825 
      return
11826 
    iprot.readStructBegin()
11827 
    while True:
11828 
      (fname, ftype, fid) = iprot.readFieldBegin()
11829 
      if ftype == TType.STOP:
11830 
        break
11831 
      if fid == 1:
11832 
        if ftype == TType.I64:
11833 
          self.customer_id = iprot.readI64();
11834 
        else:
11835 
          iprot.skip(ftype)
11836 
      elif fid == 2:
11837 
        if ftype == TType.I64:
11838 
          self.limit = iprot.readI64();
11839 
        else:
11840 
          iprot.skip(ftype)
11841 
      else:
11842 
        iprot.skip(ftype)
11843 
      iprot.readFieldEnd()
11844 
    iprot.readStructEnd()
11845 
 
11846 
  def write(self, oprot):
11847 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11848 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11849 
      return
11850 
    oprot.writeStructBegin('getCancellableOrdersForCustomer_args')
3431 rajveer 11851 
    if self.customer_id is not None:
1382 varun.gupt 11852 
      oprot.writeFieldBegin('customer_id', TType.I64, 1)
11853 
      oprot.writeI64(self.customer_id)
11854 
      oprot.writeFieldEnd()
3431 rajveer 11855 
    if self.limit is not None:
1382 varun.gupt 11856 
      oprot.writeFieldBegin('limit', TType.I64, 2)
11857 
      oprot.writeI64(self.limit)
11858 
      oprot.writeFieldEnd()
11859 
    oprot.writeFieldStop()
11860 
    oprot.writeStructEnd()
11861 
 
3431 rajveer 11862 
  def validate(self):
11863 
    return
11864 
 
11865 
 
1382 varun.gupt 11866 
  def __repr__(self):
11867 
    L = ['%s=%r' % (key, value)
11868 
      for key, value in self.__dict__.iteritems()]
11869 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11870 
 
11871 
  def __eq__(self, other):
11872 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11873 
 
11874 
  def __ne__(self, other):
11875 
    return not (self == other)
11876 
 
11877 
class getCancellableOrdersForCustomer_result:
11878 
  """
11879 
  Attributes:
11880 
   - success
11881 
   - ex
11882 
  """
11883 
 
11884 
  thrift_spec = (
11885 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
11886 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
11887 
  )
11888 
 
11889 
  def __init__(self, success=None, ex=None,):
11890 
    self.success = success
11891 
    self.ex = ex
11892 
 
11893 
  def read(self, iprot):
11894 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11895 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11896 
      return
11897 
    iprot.readStructBegin()
11898 
    while True:
11899 
      (fname, ftype, fid) = iprot.readFieldBegin()
11900 
      if ftype == TType.STOP:
11901 
        break
11902 
      if fid == 0:
11903 
        if ftype == TType.LIST:
11904 
          self.success = []
6188 rajveer 11905 
          (_etype179, _size176) = iprot.readListBegin()
11906 
          for _i180 in xrange(_size176):
11907 
            _elem181 = iprot.readI64();
11908 
            self.success.append(_elem181)
1382 varun.gupt 11909 
          iprot.readListEnd()
11910 
        else:
11911 
          iprot.skip(ftype)
11912 
      elif fid == 1:
11913 
        if ftype == TType.STRUCT:
11914 
          self.ex = TransactionServiceException()
11915 
          self.ex.read(iprot)
11916 
        else:
11917 
          iprot.skip(ftype)
11918 
      else:
11919 
        iprot.skip(ftype)
11920 
      iprot.readFieldEnd()
11921 
    iprot.readStructEnd()
11922 
 
11923 
  def write(self, oprot):
11924 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11925 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11926 
      return
11927 
    oprot.writeStructBegin('getCancellableOrdersForCustomer_result')
3431 rajveer 11928 
    if self.success is not None:
1382 varun.gupt 11929 
      oprot.writeFieldBegin('success', TType.LIST, 0)
11930 
      oprot.writeListBegin(TType.I64, len(self.success))
6188 rajveer 11931 
      for iter182 in self.success:
11932 
        oprot.writeI64(iter182)
1382 varun.gupt 11933 
      oprot.writeListEnd()
11934 
      oprot.writeFieldEnd()
3431 rajveer 11935 
    if self.ex is not None:
1382 varun.gupt 11936 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11937 
      self.ex.write(oprot)
11938 
      oprot.writeFieldEnd()
11939 
    oprot.writeFieldStop()
11940 
    oprot.writeStructEnd()
11941 
 
3431 rajveer 11942 
  def validate(self):
11943 
    return
11944 
 
11945 
 
1382 varun.gupt 11946 
  def __repr__(self):
11947 
    L = ['%s=%r' % (key, value)
11948 
      for key, value in self.__dict__.iteritems()]
11949 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11950 
 
11951 
  def __eq__(self, other):
11952 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11953 
 
11954 
  def __ne__(self, other):
11955 
    return not (self == other)
11956 
 
483 rajveer 11957 
class changeOrderStatus_args:
94 ashish 11958 
  """
11959 
  Attributes:
483 rajveer 11960 
   - orderId
11961 
   - status
11962 
   - description
94 ashish 11963 
  """
11964 
 
11965 
  thrift_spec = (
11966 
    None, # 0
483 rajveer 11967 
    (1, TType.I64, 'orderId', None, None, ), # 1
11968 
    (2, TType.I32, 'status', None, None, ), # 2
11969 
    (3, TType.STRING, 'description', None, None, ), # 3
94 ashish 11970 
  )
11971 
 
483 rajveer 11972 
  def __init__(self, orderId=None, status=None, description=None,):
11973 
    self.orderId = orderId
11974 
    self.status = status
11975 
    self.description = description
94 ashish 11976 
 
11977 
  def read(self, iprot):
11978 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11979 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11980 
      return
11981 
    iprot.readStructBegin()
11982 
    while True:
11983 
      (fname, ftype, fid) = iprot.readFieldBegin()
11984 
      if ftype == TType.STOP:
11985 
        break
11986 
      if fid == 1:
11987 
        if ftype == TType.I64:
483 rajveer 11988 
          self.orderId = iprot.readI64();
94 ashish 11989 
        else:
11990 
          iprot.skip(ftype)
11991 
      elif fid == 2:
483 rajveer 11992 
        if ftype == TType.I32:
11993 
          self.status = iprot.readI32();
94 ashish 11994 
        else:
11995 
          iprot.skip(ftype)
483 rajveer 11996 
      elif fid == 3:
11997 
        if ftype == TType.STRING:
11998 
          self.description = iprot.readString();
11999 
        else:
12000 
          iprot.skip(ftype)
94 ashish 12001 
      else:
12002 
        iprot.skip(ftype)
12003 
      iprot.readFieldEnd()
12004 
    iprot.readStructEnd()
12005 
 
12006 
  def write(self, oprot):
12007 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12008 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12009 
      return
483 rajveer 12010 
    oprot.writeStructBegin('changeOrderStatus_args')
3431 rajveer 12011 
    if self.orderId is not None:
483 rajveer 12012 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
12013 
      oprot.writeI64(self.orderId)
94 ashish 12014 
      oprot.writeFieldEnd()
3431 rajveer 12015 
    if self.status is not None:
483 rajveer 12016 
      oprot.writeFieldBegin('status', TType.I32, 2)
12017 
      oprot.writeI32(self.status)
94 ashish 12018 
      oprot.writeFieldEnd()
3431 rajveer 12019 
    if self.description is not None:
483 rajveer 12020 
      oprot.writeFieldBegin('description', TType.STRING, 3)
12021 
      oprot.writeString(self.description)
12022 
      oprot.writeFieldEnd()
94 ashish 12023 
    oprot.writeFieldStop()
12024 
    oprot.writeStructEnd()
12025 
 
3431 rajveer 12026 
  def validate(self):
12027 
    return
12028 
 
12029 
 
94 ashish 12030 
  def __repr__(self):
12031 
    L = ['%s=%r' % (key, value)
12032 
      for key, value in self.__dict__.iteritems()]
12033 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12034 
 
12035 
  def __eq__(self, other):
12036 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12037 
 
12038 
  def __ne__(self, other):
12039 
    return not (self == other)
12040 
 
483 rajveer 12041 
class changeOrderStatus_result:
94 ashish 12042 
  """
12043 
  Attributes:
12044 
   - success
12045 
   - ex
12046 
  """
12047 
 
12048 
  thrift_spec = (
12049 
    (0, TType.BOOL, 'success', None, None, ), # 0
12050 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
12051 
  )
12052 
 
12053 
  def __init__(self, success=None, ex=None,):
12054 
    self.success = success
12055 
    self.ex = ex
12056 
 
12057 
  def read(self, iprot):
12058 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12059 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12060 
      return
12061 
    iprot.readStructBegin()
12062 
    while True:
12063 
      (fname, ftype, fid) = iprot.readFieldBegin()
12064 
      if ftype == TType.STOP:
12065 
        break
12066 
      if fid == 0:
12067 
        if ftype == TType.BOOL:
12068 
          self.success = iprot.readBool();
12069 
        else:
12070 
          iprot.skip(ftype)
12071 
      elif fid == 1:
12072 
        if ftype == TType.STRUCT:
12073 
          self.ex = TransactionServiceException()
12074 
          self.ex.read(iprot)
12075 
        else:
12076 
          iprot.skip(ftype)
12077 
      else:
12078 
        iprot.skip(ftype)
12079 
      iprot.readFieldEnd()
12080 
    iprot.readStructEnd()
12081 
 
12082 
  def write(self, oprot):
12083 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12084 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12085 
      return
483 rajveer 12086 
    oprot.writeStructBegin('changeOrderStatus_result')
3431 rajveer 12087 
    if self.success is not None:
94 ashish 12088 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
12089 
      oprot.writeBool(self.success)
12090 
      oprot.writeFieldEnd()
3431 rajveer 12091 
    if self.ex is not None:
94 ashish 12092 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
12093 
      self.ex.write(oprot)
12094 
      oprot.writeFieldEnd()
12095 
    oprot.writeFieldStop()
12096 
    oprot.writeStructEnd()
12097 
 
3431 rajveer 12098 
  def validate(self):
12099 
    return
12100 
 
12101 
 
94 ashish 12102 
  def __repr__(self):
12103 
    L = ['%s=%r' % (key, value)
12104 
      for key, value in self.__dict__.iteritems()]
12105 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12106 
 
12107 
  def __eq__(self, other):
12108 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12109 
 
12110 
  def __ne__(self, other):
12111 
    return not (self == other)
12112 
 
3064 chandransh 12113 
class getOrdersForTransaction_args:
494 rajveer 12114 
  """
12115 
  Attributes:
3064 chandransh 12116 
   - transactionId
12117 
   - customerId
494 rajveer 12118 
  """
12119 
 
12120 
  thrift_spec = (
12121 
    None, # 0
3064 chandransh 12122 
    (1, TType.I64, 'transactionId', None, None, ), # 1
12123 
    (2, TType.I64, 'customerId', None, None, ), # 2
494 rajveer 12124 
  )
12125 
 
3064 chandransh 12126 
  def __init__(self, transactionId=None, customerId=None,):
12127 
    self.transactionId = transactionId
12128 
    self.customerId = customerId
494 rajveer 12129 
 
12130 
  def read(self, iprot):
12131 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12132 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12133 
      return
12134 
    iprot.readStructBegin()
12135 
    while True:
12136 
      (fname, ftype, fid) = iprot.readFieldBegin()
12137 
      if ftype == TType.STOP:
12138 
        break
12139 
      if fid == 1:
12140 
        if ftype == TType.I64:
3064 chandransh 12141 
          self.transactionId = iprot.readI64();
494 rajveer 12142 
        else:
12143 
          iprot.skip(ftype)
12144 
      elif fid == 2:
3064 chandransh 12145 
        if ftype == TType.I64:
12146 
          self.customerId = iprot.readI64();
494 rajveer 12147 
        else:
12148 
          iprot.skip(ftype)
12149 
      else:
12150 
        iprot.skip(ftype)
12151 
      iprot.readFieldEnd()
12152 
    iprot.readStructEnd()
12153 
 
12154 
  def write(self, oprot):
12155 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12156 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12157 
      return
3064 chandransh 12158 
    oprot.writeStructBegin('getOrdersForTransaction_args')
3431 rajveer 12159 
    if self.transactionId is not None:
3064 chandransh 12160 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
12161 
      oprot.writeI64(self.transactionId)
494 rajveer 12162 
      oprot.writeFieldEnd()
3431 rajveer 12163 
    if self.customerId is not None:
3064 chandransh 12164 
      oprot.writeFieldBegin('customerId', TType.I64, 2)
12165 
      oprot.writeI64(self.customerId)
494 rajveer 12166 
      oprot.writeFieldEnd()
12167 
    oprot.writeFieldStop()
12168 
    oprot.writeStructEnd()
12169 
 
3431 rajveer 12170 
  def validate(self):
12171 
    return
12172 
 
12173 
 
494 rajveer 12174 
  def __repr__(self):
12175 
    L = ['%s=%r' % (key, value)
12176 
      for key, value in self.__dict__.iteritems()]
12177 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12178 
 
12179 
  def __eq__(self, other):
12180 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12181 
 
12182 
  def __ne__(self, other):
12183 
    return not (self == other)
12184 
 
3064 chandransh 12185 
class getOrdersForTransaction_result:
494 rajveer 12186 
  """
12187 
  Attributes:
12188 
   - success
12189 
   - ex
12190 
  """
12191 
 
12192 
  thrift_spec = (
3064 chandransh 12193 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
494 rajveer 12194 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
12195 
  )
12196 
 
12197 
  def __init__(self, success=None, ex=None,):
12198 
    self.success = success
12199 
    self.ex = ex
12200 
 
12201 
  def read(self, iprot):
12202 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12203 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12204 
      return
12205 
    iprot.readStructBegin()
12206 
    while True:
12207 
      (fname, ftype, fid) = iprot.readFieldBegin()
12208 
      if ftype == TType.STOP:
12209 
        break
12210 
      if fid == 0:
3064 chandransh 12211 
        if ftype == TType.LIST:
12212 
          self.success = []
6188 rajveer 12213 
          (_etype186, _size183) = iprot.readListBegin()
12214 
          for _i187 in xrange(_size183):
12215 
            _elem188 = Order()
12216 
            _elem188.read(iprot)
12217 
            self.success.append(_elem188)
3064 chandransh 12218 
          iprot.readListEnd()
494 rajveer 12219 
        else:
12220 
          iprot.skip(ftype)
12221 
      elif fid == 1:
12222 
        if ftype == TType.STRUCT:
12223 
          self.ex = TransactionServiceException()
12224 
          self.ex.read(iprot)
12225 
        else:
12226 
          iprot.skip(ftype)
12227 
      else:
12228 
        iprot.skip(ftype)
12229 
      iprot.readFieldEnd()
12230 
    iprot.readStructEnd()
12231 
 
12232 
  def write(self, oprot):
12233 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12234 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12235 
      return
3064 chandransh 12236 
    oprot.writeStructBegin('getOrdersForTransaction_result')
3431 rajveer 12237 
    if self.success is not None:
3064 chandransh 12238 
      oprot.writeFieldBegin('success', TType.LIST, 0)
12239 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 12240 
      for iter189 in self.success:
12241 
        iter189.write(oprot)
3064 chandransh 12242 
      oprot.writeListEnd()
494 rajveer 12243 
      oprot.writeFieldEnd()
3431 rajveer 12244 
    if self.ex is not None:
494 rajveer 12245 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
12246 
      self.ex.write(oprot)
12247 
      oprot.writeFieldEnd()
12248 
    oprot.writeFieldStop()
12249 
    oprot.writeStructEnd()
12250 
 
3431 rajveer 12251 
  def validate(self):
12252 
    return
12253 
 
12254 
 
494 rajveer 12255 
  def __repr__(self):
12256 
    L = ['%s=%r' % (key, value)
12257 
      for key, value in self.__dict__.iteritems()]
12258 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12259 
 
12260 
  def __eq__(self, other):
12261 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12262 
 
12263 
  def __ne__(self, other):
12264 
    return not (self == other)
12265 
 
3064 chandransh 12266 
class getOrdersForCustomer_args:
1149 chandransh 12267 
  """
12268 
  Attributes:
3064 chandransh 12269 
   - customerId
12270 
   - from_date
12271 
   - to_date
12272 
   - statuses
1149 chandransh 12273 
  """
12274 
 
12275 
  thrift_spec = (
12276 
    None, # 0
3064 chandransh 12277 
    (1, TType.I64, 'customerId', None, None, ), # 1
12278 
    (2, TType.I64, 'from_date', None, None, ), # 2
12279 
    (3, TType.I64, 'to_date', None, None, ), # 3
12280 
    (4, TType.LIST, 'statuses', (TType.I32,None), None, ), # 4
1149 chandransh 12281 
  )
12282 
 
3064 chandransh 12283 
  def __init__(self, customerId=None, from_date=None, to_date=None, statuses=None,):
12284 
    self.customerId = customerId
12285 
    self.from_date = from_date
12286 
    self.to_date = to_date
12287 
    self.statuses = statuses
1149 chandransh 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 == 1:
12299 
        if ftype == TType.I64:
3064 chandransh 12300 
          self.customerId = iprot.readI64();
1149 chandransh 12301 
        else:
12302 
          iprot.skip(ftype)
12303 
      elif fid == 2:
12304 
        if ftype == TType.I64:
3064 chandransh 12305 
          self.from_date = iprot.readI64();
1149 chandransh 12306 
        else:
12307 
          iprot.skip(ftype)
2783 chandransh 12308 
      elif fid == 3:
12309 
        if ftype == TType.I64:
3064 chandransh 12310 
          self.to_date = iprot.readI64();
2783 chandransh 12311 
        else:
12312 
          iprot.skip(ftype)
12313 
      elif fid == 4:
3064 chandransh 12314 
        if ftype == TType.LIST:
12315 
          self.statuses = []
6188 rajveer 12316 
          (_etype193, _size190) = iprot.readListBegin()
12317 
          for _i194 in xrange(_size190):
12318 
            _elem195 = iprot.readI32();
12319 
            self.statuses.append(_elem195)
3064 chandransh 12320 
          iprot.readListEnd()
2783 chandransh 12321 
        else:
12322 
          iprot.skip(ftype)
1149 chandransh 12323 
      else:
12324 
        iprot.skip(ftype)
12325 
      iprot.readFieldEnd()
12326 
    iprot.readStructEnd()
12327 
 
12328 
  def write(self, oprot):
12329 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12330 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12331 
      return
3064 chandransh 12332 
    oprot.writeStructBegin('getOrdersForCustomer_args')
3431 rajveer 12333 
    if self.customerId is not None:
3064 chandransh 12334 
      oprot.writeFieldBegin('customerId', TType.I64, 1)
12335 
      oprot.writeI64(self.customerId)
1149 chandransh 12336 
      oprot.writeFieldEnd()
3431 rajveer 12337 
    if self.from_date is not None:
3064 chandransh 12338 
      oprot.writeFieldBegin('from_date', TType.I64, 2)
12339 
      oprot.writeI64(self.from_date)
1149 chandransh 12340 
      oprot.writeFieldEnd()
3431 rajveer 12341 
    if self.to_date is not None:
3064 chandransh 12342 
      oprot.writeFieldBegin('to_date', TType.I64, 3)
12343 
      oprot.writeI64(self.to_date)
2783 chandransh 12344 
      oprot.writeFieldEnd()
3431 rajveer 12345 
    if self.statuses is not None:
3064 chandransh 12346 
      oprot.writeFieldBegin('statuses', TType.LIST, 4)
12347 
      oprot.writeListBegin(TType.I32, len(self.statuses))
6188 rajveer 12348 
      for iter196 in self.statuses:
12349 
        oprot.writeI32(iter196)
3064 chandransh 12350 
      oprot.writeListEnd()
2783 chandransh 12351 
      oprot.writeFieldEnd()
1149 chandransh 12352 
    oprot.writeFieldStop()
12353 
    oprot.writeStructEnd()
12354 
 
3431 rajveer 12355 
  def validate(self):
12356 
    return
12357 
 
12358 
 
1149 chandransh 12359 
  def __repr__(self):
12360 
    L = ['%s=%r' % (key, value)
12361 
      for key, value in self.__dict__.iteritems()]
12362 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12363 
 
12364 
  def __eq__(self, other):
12365 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12366 
 
12367 
  def __ne__(self, other):
12368 
    return not (self == other)
12369 
 
3064 chandransh 12370 
class getOrdersForCustomer_result:
1149 chandransh 12371 
  """
12372 
  Attributes:
12373 
   - success
12374 
   - ex
12375 
  """
12376 
 
12377 
  thrift_spec = (
3064 chandransh 12378 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
1149 chandransh 12379 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
12380 
  )
12381 
 
12382 
  def __init__(self, success=None, ex=None,):
12383 
    self.success = success
12384 
    self.ex = ex
12385 
 
12386 
  def read(self, iprot):
12387 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12388 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12389 
      return
12390 
    iprot.readStructBegin()
12391 
    while True:
12392 
      (fname, ftype, fid) = iprot.readFieldBegin()
12393 
      if ftype == TType.STOP:
12394 
        break
12395 
      if fid == 0:
3064 chandransh 12396 
        if ftype == TType.LIST:
12397 
          self.success = []
6188 rajveer 12398 
          (_etype200, _size197) = iprot.readListBegin()
12399 
          for _i201 in xrange(_size197):
12400 
            _elem202 = Order()
12401 
            _elem202.read(iprot)
12402 
            self.success.append(_elem202)
3064 chandransh 12403 
          iprot.readListEnd()
1149 chandransh 12404 
        else:
12405 
          iprot.skip(ftype)
12406 
      elif fid == 1:
12407 
        if ftype == TType.STRUCT:
12408 
          self.ex = TransactionServiceException()
12409 
          self.ex.read(iprot)
12410 
        else:
12411 
          iprot.skip(ftype)
12412 
      else:
12413 
        iprot.skip(ftype)
12414 
      iprot.readFieldEnd()
12415 
    iprot.readStructEnd()
12416 
 
12417 
  def write(self, oprot):
12418 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12419 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12420 
      return
3064 chandransh 12421 
    oprot.writeStructBegin('getOrdersForCustomer_result')
3431 rajveer 12422 
    if self.success is not None:
3064 chandransh 12423 
      oprot.writeFieldBegin('success', TType.LIST, 0)
12424 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 12425 
      for iter203 in self.success:
12426 
        iter203.write(oprot)
3064 chandransh 12427 
      oprot.writeListEnd()
1149 chandransh 12428 
      oprot.writeFieldEnd()
3431 rajveer 12429 
    if self.ex is not None:
1149 chandransh 12430 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
12431 
      self.ex.write(oprot)
12432 
      oprot.writeFieldEnd()
12433 
    oprot.writeFieldStop()
12434 
    oprot.writeStructEnd()
12435 
 
3431 rajveer 12436 
  def validate(self):
12437 
    return
12438 
 
12439 
 
1149 chandransh 12440 
  def __repr__(self):
12441 
    L = ['%s=%r' % (key, value)
12442 
      for key, value in self.__dict__.iteritems()]
12443 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12444 
 
12445 
  def __eq__(self, other):
12446 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12447 
 
12448 
  def __ne__(self, other):
12449 
    return not (self == other)
12450 
 
3064 chandransh 12451 
class createOrder_args:
921 rajveer 12452 
  """
12453 
  Attributes:
3064 chandransh 12454 
   - order
921 rajveer 12455 
  """
12456 
 
12457 
  thrift_spec = (
12458 
    None, # 0
3064 chandransh 12459 
    (1, TType.STRUCT, 'order', (Order, Order.thrift_spec), None, ), # 1
921 rajveer 12460 
  )
12461 
 
3064 chandransh 12462 
  def __init__(self, order=None,):
12463 
    self.order = order
921 rajveer 12464 
 
12465 
  def read(self, iprot):
12466 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12467 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12468 
      return
12469 
    iprot.readStructBegin()
12470 
    while True:
12471 
      (fname, ftype, fid) = iprot.readFieldBegin()
12472 
      if ftype == TType.STOP:
12473 
        break
12474 
      if fid == 1:
3064 chandransh 12475 
        if ftype == TType.STRUCT:
12476 
          self.order = Order()
12477 
          self.order.read(iprot)
921 rajveer 12478 
        else:
12479 
          iprot.skip(ftype)
12480 
      else:
12481 
        iprot.skip(ftype)
12482 
      iprot.readFieldEnd()
12483 
    iprot.readStructEnd()
12484 
 
12485 
  def write(self, oprot):
12486 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12487 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12488 
      return
3064 chandransh 12489 
    oprot.writeStructBegin('createOrder_args')
3431 rajveer 12490 
    if self.order is not None:
3064 chandransh 12491 
      oprot.writeFieldBegin('order', TType.STRUCT, 1)
12492 
      self.order.write(oprot)
921 rajveer 12493 
      oprot.writeFieldEnd()
12494 
    oprot.writeFieldStop()
12495 
    oprot.writeStructEnd()
12496 
 
3431 rajveer 12497 
  def validate(self):
12498 
    return
12499 
 
12500 
 
921 rajveer 12501 
  def __repr__(self):
12502 
    L = ['%s=%r' % (key, value)
12503 
      for key, value in self.__dict__.iteritems()]
12504 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12505 
 
12506 
  def __eq__(self, other):
12507 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12508 
 
12509 
  def __ne__(self, other):
12510 
    return not (self == other)
12511 
 
3064 chandransh 12512 
class createOrder_result:
921 rajveer 12513 
  """
12514 
  Attributes:
12515 
   - success
12516 
   - ex
12517 
  """
12518 
 
12519 
  thrift_spec = (
3064 chandransh 12520 
    (0, TType.I64, 'success', None, None, ), # 0
921 rajveer 12521 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
12522 
  )
12523 
 
12524 
  def __init__(self, success=None, ex=None,):
12525 
    self.success = success
12526 
    self.ex = ex
12527 
 
12528 
  def read(self, iprot):
12529 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12530 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12531 
      return
12532 
    iprot.readStructBegin()
12533 
    while True:
12534 
      (fname, ftype, fid) = iprot.readFieldBegin()
12535 
      if ftype == TType.STOP:
12536 
        break
12537 
      if fid == 0:
3064 chandransh 12538 
        if ftype == TType.I64:
12539 
          self.success = iprot.readI64();
921 rajveer 12540 
        else:
12541 
          iprot.skip(ftype)
12542 
      elif fid == 1:
12543 
        if ftype == TType.STRUCT:
12544 
          self.ex = TransactionServiceException()
12545 
          self.ex.read(iprot)
12546 
        else:
12547 
          iprot.skip(ftype)
12548 
      else:
12549 
        iprot.skip(ftype)
12550 
      iprot.readFieldEnd()
12551 
    iprot.readStructEnd()
12552 
 
12553 
  def write(self, oprot):
12554 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12555 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12556 
      return
3064 chandransh 12557 
    oprot.writeStructBegin('createOrder_result')
3431 rajveer 12558 
    if self.success is not None:
3064 chandransh 12559 
      oprot.writeFieldBegin('success', TType.I64, 0)
12560 
      oprot.writeI64(self.success)
921 rajveer 12561 
      oprot.writeFieldEnd()
3431 rajveer 12562 
    if self.ex is not None:
921 rajveer 12563 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
12564 
      self.ex.write(oprot)
12565 
      oprot.writeFieldEnd()
12566 
    oprot.writeFieldStop()
12567 
    oprot.writeStructEnd()
12568 
 
3431 rajveer 12569 
  def validate(self):
12570 
    return
12571 
 
12572 
 
921 rajveer 12573 
  def __repr__(self):
12574 
    L = ['%s=%r' % (key, value)
12575 
      for key, value in self.__dict__.iteritems()]
12576 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12577 
 
12578 
  def __eq__(self, other):
12579 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12580 
 
12581 
  def __ne__(self, other):
12582 
    return not (self == other)
12583 
 
3064 chandransh 12584 
class getOrder_args:
921 rajveer 12585 
  """
12586 
  Attributes:
3064 chandransh 12587 
   - id
921 rajveer 12588 
  """
12589 
 
12590 
  thrift_spec = (
12591 
    None, # 0
3064 chandransh 12592 
    (1, TType.I64, 'id', None, None, ), # 1
921 rajveer 12593 
  )
12594 
 
3064 chandransh 12595 
  def __init__(self, id=None,):
12596 
    self.id = id
921 rajveer 12597 
 
12598 
  def read(self, iprot):
12599 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12600 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12601 
      return
12602 
    iprot.readStructBegin()
12603 
    while True:
12604 
      (fname, ftype, fid) = iprot.readFieldBegin()
12605 
      if ftype == TType.STOP:
12606 
        break
12607 
      if fid == 1:
12608 
        if ftype == TType.I64:
3064 chandransh 12609 
          self.id = iprot.readI64();
921 rajveer 12610 
        else:
12611 
          iprot.skip(ftype)
12612 
      else:
12613 
        iprot.skip(ftype)
12614 
      iprot.readFieldEnd()
12615 
    iprot.readStructEnd()
12616 
 
12617 
  def write(self, oprot):
12618 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12619 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12620 
      return
3064 chandransh 12621 
    oprot.writeStructBegin('getOrder_args')
3431 rajveer 12622 
    if self.id is not None:
3064 chandransh 12623 
      oprot.writeFieldBegin('id', TType.I64, 1)
12624 
      oprot.writeI64(self.id)
921 rajveer 12625 
      oprot.writeFieldEnd()
12626 
    oprot.writeFieldStop()
12627 
    oprot.writeStructEnd()
12628 
 
3431 rajveer 12629 
  def validate(self):
12630 
    return
12631 
 
12632 
 
921 rajveer 12633 
  def __repr__(self):
12634 
    L = ['%s=%r' % (key, value)
12635 
      for key, value in self.__dict__.iteritems()]
12636 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12637 
 
12638 
  def __eq__(self, other):
12639 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12640 
 
12641 
  def __ne__(self, other):
12642 
    return not (self == other)
12643 
 
3064 chandransh 12644 
class getOrder_result:
921 rajveer 12645 
  """
12646 
  Attributes:
12647 
   - success
12648 
   - ex
12649 
  """
12650 
 
12651 
  thrift_spec = (
3064 chandransh 12652 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
921 rajveer 12653 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
12654 
  )
12655 
 
12656 
  def __init__(self, success=None, ex=None,):
12657 
    self.success = success
12658 
    self.ex = ex
12659 
 
12660 
  def read(self, iprot):
12661 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12662 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12663 
      return
12664 
    iprot.readStructBegin()
12665 
    while True:
12666 
      (fname, ftype, fid) = iprot.readFieldBegin()
12667 
      if ftype == TType.STOP:
12668 
        break
12669 
      if fid == 0:
3064 chandransh 12670 
        if ftype == TType.STRUCT:
12671 
          self.success = Order()
12672 
          self.success.read(iprot)
921 rajveer 12673 
        else:
12674 
          iprot.skip(ftype)
12675 
      elif fid == 1:
12676 
        if ftype == TType.STRUCT:
12677 
          self.ex = TransactionServiceException()
12678 
          self.ex.read(iprot)
12679 
        else:
12680 
          iprot.skip(ftype)
12681 
      else:
12682 
        iprot.skip(ftype)
12683 
      iprot.readFieldEnd()
12684 
    iprot.readStructEnd()
12685 
 
12686 
  def write(self, oprot):
12687 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12688 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12689 
      return
3064 chandransh 12690 
    oprot.writeStructBegin('getOrder_result')
3431 rajveer 12691 
    if self.success is not None:
3064 chandransh 12692 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
12693 
      self.success.write(oprot)
921 rajveer 12694 
      oprot.writeFieldEnd()
3431 rajveer 12695 
    if self.ex is not None:
921 rajveer 12696 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
12697 
      self.ex.write(oprot)
12698 
      oprot.writeFieldEnd()
12699 
    oprot.writeFieldStop()
12700 
    oprot.writeStructEnd()
12701 
 
3431 rajveer 12702 
  def validate(self):
12703 
    return
12704 
 
12705 
 
921 rajveer 12706 
  def __repr__(self):
12707 
    L = ['%s=%r' % (key, value)
12708 
      for key, value in self.__dict__.iteritems()]
12709 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12710 
 
12711 
  def __eq__(self, other):
12712 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12713 
 
12714 
  def __ne__(self, other):
12715 
    return not (self == other)
12716 
 
3064 chandransh 12717 
class getLineItemsForOrder_args:
94 ashish 12718 
  """
12719 
  Attributes:
3064 chandransh 12720 
   - orderId
94 ashish 12721 
  """
12722 
 
12723 
  thrift_spec = (
12724 
    None, # 0
3064 chandransh 12725 
    (1, TType.I64, 'orderId', None, None, ), # 1
94 ashish 12726 
  )
12727 
 
3064 chandransh 12728 
  def __init__(self, orderId=None,):
12729 
    self.orderId = orderId
94 ashish 12730 
 
12731 
  def read(self, iprot):
12732 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12733 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12734 
      return
12735 
    iprot.readStructBegin()
12736 
    while True:
12737 
      (fname, ftype, fid) = iprot.readFieldBegin()
12738 
      if ftype == TType.STOP:
12739 
        break
12740 
      if fid == 1:
12741 
        if ftype == TType.I64:
3064 chandransh 12742 
          self.orderId = iprot.readI64();
94 ashish 12743 
        else:
12744 
          iprot.skip(ftype)
12745 
      else:
12746 
        iprot.skip(ftype)
12747 
      iprot.readFieldEnd()
12748 
    iprot.readStructEnd()
12749 
 
12750 
  def write(self, oprot):
12751 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12752 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12753 
      return
3064 chandransh 12754 
    oprot.writeStructBegin('getLineItemsForOrder_args')
3431 rajveer 12755 
    if self.orderId is not None:
3064 chandransh 12756 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
12757 
      oprot.writeI64(self.orderId)
94 ashish 12758 
      oprot.writeFieldEnd()
12759 
    oprot.writeFieldStop()
12760 
    oprot.writeStructEnd()
12761 
 
3431 rajveer 12762 
  def validate(self):
12763 
    return
12764 
 
12765 
 
94 ashish 12766 
  def __repr__(self):
12767 
    L = ['%s=%r' % (key, value)
12768 
      for key, value in self.__dict__.iteritems()]
12769 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12770 
 
12771 
  def __eq__(self, other):
12772 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12773 
 
12774 
  def __ne__(self, other):
12775 
    return not (self == other)
12776 
 
3064 chandransh 12777 
class getLineItemsForOrder_result:
94 ashish 12778 
  """
12779 
  Attributes:
12780 
   - success
12781 
   - ex
12782 
  """
12783 
 
12784 
  thrift_spec = (
3064 chandransh 12785 
    (0, TType.LIST, 'success', (TType.STRUCT,(LineItem, LineItem.thrift_spec)), None, ), # 0
94 ashish 12786 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
12787 
  )
12788 
 
12789 
  def __init__(self, success=None, ex=None,):
12790 
    self.success = success
12791 
    self.ex = ex
12792 
 
12793 
  def read(self, iprot):
12794 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12795 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12796 
      return
12797 
    iprot.readStructBegin()
12798 
    while True:
12799 
      (fname, ftype, fid) = iprot.readFieldBegin()
12800 
      if ftype == TType.STOP:
12801 
        break
12802 
      if fid == 0:
483 rajveer 12803 
        if ftype == TType.LIST:
12804 
          self.success = []
6188 rajveer 12805 
          (_etype207, _size204) = iprot.readListBegin()
12806 
          for _i208 in xrange(_size204):
12807 
            _elem209 = LineItem()
12808 
            _elem209.read(iprot)
12809 
            self.success.append(_elem209)
483 rajveer 12810 
          iprot.readListEnd()
94 ashish 12811 
        else:
12812 
          iprot.skip(ftype)
12813 
      elif fid == 1:
12814 
        if ftype == TType.STRUCT:
12815 
          self.ex = TransactionServiceException()
12816 
          self.ex.read(iprot)
12817 
        else:
12818 
          iprot.skip(ftype)
12819 
      else:
12820 
        iprot.skip(ftype)
12821 
      iprot.readFieldEnd()
12822 
    iprot.readStructEnd()
12823 
 
12824 
  def write(self, oprot):
12825 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12826 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12827 
      return
3064 chandransh 12828 
    oprot.writeStructBegin('getLineItemsForOrder_result')
3431 rajveer 12829 
    if self.success is not None:
483 rajveer 12830 
      oprot.writeFieldBegin('success', TType.LIST, 0)
12831 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 12832 
      for iter210 in self.success:
12833 
        iter210.write(oprot)
483 rajveer 12834 
      oprot.writeListEnd()
94 ashish 12835 
      oprot.writeFieldEnd()
3431 rajveer 12836 
    if self.ex is not None:
94 ashish 12837 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
12838 
      self.ex.write(oprot)
12839 
      oprot.writeFieldEnd()
12840 
    oprot.writeFieldStop()
12841 
    oprot.writeStructEnd()
12842 
 
3431 rajveer 12843 
  def validate(self):
12844 
    return
12845 
 
12846 
 
94 ashish 12847 
  def __repr__(self):
12848 
    L = ['%s=%r' % (key, value)
12849 
      for key, value in self.__dict__.iteritems()]
12850 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12851 
 
12852 
  def __eq__(self, other):
12853 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12854 
 
12855 
  def __ne__(self, other):
12856 
    return not (self == other)
12857 
 
4999 phani.kuma 12858 
class getOrderList_args:
12859 
  """
12860 
  Attributes:
12861 
   - order_ids
12862 
  """
12863 
 
12864 
  thrift_spec = (
12865 
    None, # 0
12866 
    (1, TType.LIST, 'order_ids', (TType.I64,None), None, ), # 1
12867 
  )
12868 
 
12869 
  def __init__(self, order_ids=None,):
12870 
    self.order_ids = order_ids
12871 
 
12872 
  def read(self, iprot):
12873 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12874 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12875 
      return
12876 
    iprot.readStructBegin()
12877 
    while True:
12878 
      (fname, ftype, fid) = iprot.readFieldBegin()
12879 
      if ftype == TType.STOP:
12880 
        break
12881 
      if fid == 1:
12882 
        if ftype == TType.LIST:
12883 
          self.order_ids = []
6188 rajveer 12884 
          (_etype214, _size211) = iprot.readListBegin()
12885 
          for _i215 in xrange(_size211):
12886 
            _elem216 = iprot.readI64();
12887 
            self.order_ids.append(_elem216)
4999 phani.kuma 12888 
          iprot.readListEnd()
12889 
        else:
12890 
          iprot.skip(ftype)
12891 
      else:
12892 
        iprot.skip(ftype)
12893 
      iprot.readFieldEnd()
12894 
    iprot.readStructEnd()
12895 
 
12896 
  def write(self, oprot):
12897 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12898 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12899 
      return
12900 
    oprot.writeStructBegin('getOrderList_args')
12901 
    if self.order_ids is not None:
12902 
      oprot.writeFieldBegin('order_ids', TType.LIST, 1)
12903 
      oprot.writeListBegin(TType.I64, len(self.order_ids))
6188 rajveer 12904 
      for iter217 in self.order_ids:
12905 
        oprot.writeI64(iter217)
4999 phani.kuma 12906 
      oprot.writeListEnd()
12907 
      oprot.writeFieldEnd()
12908 
    oprot.writeFieldStop()
12909 
    oprot.writeStructEnd()
12910 
 
12911 
  def validate(self):
12912 
    return
12913 
 
12914 
 
12915 
  def __repr__(self):
12916 
    L = ['%s=%r' % (key, value)
12917 
      for key, value in self.__dict__.iteritems()]
12918 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12919 
 
12920 
  def __eq__(self, other):
12921 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12922 
 
12923 
  def __ne__(self, other):
12924 
    return not (self == other)
12925 
 
12926 
class getOrderList_result:
12927 
  """
12928 
  Attributes:
12929 
   - success
12930 
  """
12931 
 
12932 
  thrift_spec = (
12933 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
12934 
  )
12935 
 
12936 
  def __init__(self, success=None,):
12937 
    self.success = success
12938 
 
12939 
  def read(self, iprot):
12940 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12941 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12942 
      return
12943 
    iprot.readStructBegin()
12944 
    while True:
12945 
      (fname, ftype, fid) = iprot.readFieldBegin()
12946 
      if ftype == TType.STOP:
12947 
        break
12948 
      if fid == 0:
12949 
        if ftype == TType.LIST:
12950 
          self.success = []
6188 rajveer 12951 
          (_etype221, _size218) = iprot.readListBegin()
12952 
          for _i222 in xrange(_size218):
12953 
            _elem223 = Order()
12954 
            _elem223.read(iprot)
12955 
            self.success.append(_elem223)
4999 phani.kuma 12956 
          iprot.readListEnd()
12957 
        else:
12958 
          iprot.skip(ftype)
12959 
      else:
12960 
        iprot.skip(ftype)
12961 
      iprot.readFieldEnd()
12962 
    iprot.readStructEnd()
12963 
 
12964 
  def write(self, oprot):
12965 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12966 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12967 
      return
12968 
    oprot.writeStructBegin('getOrderList_result')
12969 
    if self.success is not None:
12970 
      oprot.writeFieldBegin('success', TType.LIST, 0)
12971 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 12972 
      for iter224 in self.success:
12973 
        iter224.write(oprot)
4999 phani.kuma 12974 
      oprot.writeListEnd()
12975 
      oprot.writeFieldEnd()
12976 
    oprot.writeFieldStop()
12977 
    oprot.writeStructEnd()
12978 
 
12979 
  def validate(self):
12980 
    return
12981 
 
12982 
 
12983 
  def __repr__(self):
12984 
    L = ['%s=%r' % (key, value)
12985 
      for key, value in self.__dict__.iteritems()]
12986 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12987 
 
12988 
  def __eq__(self, other):
12989 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12990 
 
12991 
  def __ne__(self, other):
12992 
    return not (self == other)
12993 
 
5386 phani.kuma 12994 
class getOrderListForVendor_args:
12995 
  """
12996 
  Attributes:
12997 
   - order_ids
12998 
   - vendorId
12999 
  """
13000 
 
13001 
  thrift_spec = (
13002 
    None, # 0
13003 
    (1, TType.LIST, 'order_ids', (TType.I64,None), None, ), # 1
13004 
    (2, TType.I64, 'vendorId', None, None, ), # 2
13005 
  )
13006 
 
13007 
  def __init__(self, order_ids=None, vendorId=None,):
13008 
    self.order_ids = order_ids
13009 
    self.vendorId = vendorId
13010 
 
13011 
  def read(self, iprot):
13012 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13013 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13014 
      return
13015 
    iprot.readStructBegin()
13016 
    while True:
13017 
      (fname, ftype, fid) = iprot.readFieldBegin()
13018 
      if ftype == TType.STOP:
13019 
        break
13020 
      if fid == 1:
13021 
        if ftype == TType.LIST:
13022 
          self.order_ids = []
6188 rajveer 13023 
          (_etype228, _size225) = iprot.readListBegin()
13024 
          for _i229 in xrange(_size225):
13025 
            _elem230 = iprot.readI64();
13026 
            self.order_ids.append(_elem230)
5386 phani.kuma 13027 
          iprot.readListEnd()
13028 
        else:
13029 
          iprot.skip(ftype)
13030 
      elif fid == 2:
13031 
        if ftype == TType.I64:
13032 
          self.vendorId = iprot.readI64();
13033 
        else:
13034 
          iprot.skip(ftype)
13035 
      else:
13036 
        iprot.skip(ftype)
13037 
      iprot.readFieldEnd()
13038 
    iprot.readStructEnd()
13039 
 
13040 
  def write(self, oprot):
13041 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13042 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13043 
      return
13044 
    oprot.writeStructBegin('getOrderListForVendor_args')
13045 
    if self.order_ids is not None:
13046 
      oprot.writeFieldBegin('order_ids', TType.LIST, 1)
13047 
      oprot.writeListBegin(TType.I64, len(self.order_ids))
6188 rajveer 13048 
      for iter231 in self.order_ids:
13049 
        oprot.writeI64(iter231)
5386 phani.kuma 13050 
      oprot.writeListEnd()
13051 
      oprot.writeFieldEnd()
13052 
    if self.vendorId is not None:
13053 
      oprot.writeFieldBegin('vendorId', TType.I64, 2)
13054 
      oprot.writeI64(self.vendorId)
13055 
      oprot.writeFieldEnd()
13056 
    oprot.writeFieldStop()
13057 
    oprot.writeStructEnd()
13058 
 
13059 
  def validate(self):
13060 
    return
13061 
 
13062 
 
13063 
  def __repr__(self):
13064 
    L = ['%s=%r' % (key, value)
13065 
      for key, value in self.__dict__.iteritems()]
13066 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13067 
 
13068 
  def __eq__(self, other):
13069 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13070 
 
13071 
  def __ne__(self, other):
13072 
    return not (self == other)
13073 
 
13074 
class getOrderListForVendor_result:
13075 
  """
13076 
  Attributes:
13077 
   - success
13078 
  """
13079 
 
13080 
  thrift_spec = (
13081 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
13082 
  )
13083 
 
13084 
  def __init__(self, success=None,):
13085 
    self.success = success
13086 
 
13087 
  def read(self, iprot):
13088 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13089 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13090 
      return
13091 
    iprot.readStructBegin()
13092 
    while True:
13093 
      (fname, ftype, fid) = iprot.readFieldBegin()
13094 
      if ftype == TType.STOP:
13095 
        break
13096 
      if fid == 0:
13097 
        if ftype == TType.LIST:
13098 
          self.success = []
6188 rajveer 13099 
          (_etype235, _size232) = iprot.readListBegin()
13100 
          for _i236 in xrange(_size232):
13101 
            _elem237 = Order()
13102 
            _elem237.read(iprot)
13103 
            self.success.append(_elem237)
5386 phani.kuma 13104 
          iprot.readListEnd()
13105 
        else:
13106 
          iprot.skip(ftype)
13107 
      else:
13108 
        iprot.skip(ftype)
13109 
      iprot.readFieldEnd()
13110 
    iprot.readStructEnd()
13111 
 
13112 
  def write(self, oprot):
13113 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13114 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13115 
      return
13116 
    oprot.writeStructBegin('getOrderListForVendor_result')
13117 
    if self.success is not None:
13118 
      oprot.writeFieldBegin('success', TType.LIST, 0)
13119 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 13120 
      for iter238 in self.success:
13121 
        iter238.write(oprot)
5386 phani.kuma 13122 
      oprot.writeListEnd()
13123 
      oprot.writeFieldEnd()
13124 
    oprot.writeFieldStop()
13125 
    oprot.writeStructEnd()
13126 
 
13127 
  def validate(self):
13128 
    return
13129 
 
13130 
 
13131 
  def __repr__(self):
13132 
    L = ['%s=%r' % (key, value)
13133 
      for key, value in self.__dict__.iteritems()]
13134 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13135 
 
13136 
  def __eq__(self, other):
13137 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13138 
 
13139 
  def __ne__(self, other):
13140 
    return not (self == other)
13141 
 
3064 chandransh 13142 
class getOrderForCustomer_args:
94 ashish 13143 
  """
13144 
  Attributes:
3064 chandransh 13145 
   - orderId
483 rajveer 13146 
   - customerId
94 ashish 13147 
  """
13148 
 
13149 
  thrift_spec = (
13150 
    None, # 0
3064 chandransh 13151 
    (1, TType.I64, 'orderId', None, None, ), # 1
13152 
    (2, TType.I64, 'customerId', None, None, ), # 2
94 ashish 13153 
  )
13154 
 
3064 chandransh 13155 
  def __init__(self, orderId=None, customerId=None,):
13156 
    self.orderId = orderId
483 rajveer 13157 
    self.customerId = customerId
94 ashish 13158 
 
13159 
  def read(self, iprot):
13160 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13161 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13162 
      return
13163 
    iprot.readStructBegin()
13164 
    while True:
13165 
      (fname, ftype, fid) = iprot.readFieldBegin()
13166 
      if ftype == TType.STOP:
13167 
        break
13168 
      if fid == 1:
13169 
        if ftype == TType.I64:
3064 chandransh 13170 
          self.orderId = iprot.readI64();
94 ashish 13171 
        else:
13172 
          iprot.skip(ftype)
13173 
      elif fid == 2:
13174 
        if ftype == TType.I64:
3064 chandransh 13175 
          self.customerId = iprot.readI64();
94 ashish 13176 
        else:
13177 
          iprot.skip(ftype)
13178 
      else:
13179 
        iprot.skip(ftype)
13180 
      iprot.readFieldEnd()
13181 
    iprot.readStructEnd()
13182 
 
13183 
  def write(self, oprot):
13184 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13185 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13186 
      return
3064 chandransh 13187 
    oprot.writeStructBegin('getOrderForCustomer_args')
3431 rajveer 13188 
    if self.orderId is not None:
3064 chandransh 13189 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
13190 
      oprot.writeI64(self.orderId)
13191 
      oprot.writeFieldEnd()
3431 rajveer 13192 
    if self.customerId is not None:
3064 chandransh 13193 
      oprot.writeFieldBegin('customerId', TType.I64, 2)
483 rajveer 13194 
      oprot.writeI64(self.customerId)
94 ashish 13195 
      oprot.writeFieldEnd()
13196 
    oprot.writeFieldStop()
13197 
    oprot.writeStructEnd()
13198 
 
3431 rajveer 13199 
  def validate(self):
13200 
    return
13201 
 
13202 
 
94 ashish 13203 
  def __repr__(self):
13204 
    L = ['%s=%r' % (key, value)
13205 
      for key, value in self.__dict__.iteritems()]
13206 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13207 
 
13208 
  def __eq__(self, other):
13209 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13210 
 
13211 
  def __ne__(self, other):
13212 
    return not (self == other)
13213 
 
3064 chandransh 13214 
class getOrderForCustomer_result:
94 ashish 13215 
  """
13216 
  Attributes:
13217 
   - success
13218 
   - ex
13219 
  """
13220 
 
13221 
  thrift_spec = (
3064 chandransh 13222 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
94 ashish 13223 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
13224 
  )
13225 
 
13226 
  def __init__(self, success=None, ex=None,):
13227 
    self.success = success
13228 
    self.ex = ex
13229 
 
13230 
  def read(self, iprot):
13231 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13232 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13233 
      return
13234 
    iprot.readStructBegin()
13235 
    while True:
13236 
      (fname, ftype, fid) = iprot.readFieldBegin()
13237 
      if ftype == TType.STOP:
13238 
        break
13239 
      if fid == 0:
3064 chandransh 13240 
        if ftype == TType.STRUCT:
13241 
          self.success = Order()
13242 
          self.success.read(iprot)
94 ashish 13243 
        else:
13244 
          iprot.skip(ftype)
13245 
      elif fid == 1:
13246 
        if ftype == TType.STRUCT:
13247 
          self.ex = TransactionServiceException()
13248 
          self.ex.read(iprot)
13249 
        else:
13250 
          iprot.skip(ftype)
13251 
      else:
13252 
        iprot.skip(ftype)
13253 
      iprot.readFieldEnd()
13254 
    iprot.readStructEnd()
13255 
 
13256 
  def write(self, oprot):
13257 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13258 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13259 
      return
3064 chandransh 13260 
    oprot.writeStructBegin('getOrderForCustomer_result')
3431 rajveer 13261 
    if self.success is not None:
3064 chandransh 13262 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
13263 
      self.success.write(oprot)
94 ashish 13264 
      oprot.writeFieldEnd()
3431 rajveer 13265 
    if self.ex is not None:
94 ashish 13266 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
13267 
      self.ex.write(oprot)
13268 
      oprot.writeFieldEnd()
13269 
    oprot.writeFieldStop()
13270 
    oprot.writeStructEnd()
13271 
 
3431 rajveer 13272 
  def validate(self):
13273 
    return
13274 
 
13275 
 
94 ashish 13276 
  def __repr__(self):
13277 
    L = ['%s=%r' % (key, value)
13278 
      for key, value in self.__dict__.iteritems()]
13279 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13280 
 
13281 
  def __eq__(self, other):
13282 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13283 
 
13284 
  def __ne__(self, other):
13285 
    return not (self == other)
13286 
 
3064 chandransh 13287 
class getAlerts_args:
94 ashish 13288 
  """
13289 
  Attributes:
4394 rajveer 13290 
   - type
4444 rajveer 13291 
   - warehouseId
4394 rajveer 13292 
   - status
13293 
   - timestamp
94 ashish 13294 
  """
13295 
 
13296 
  thrift_spec = (
13297 
    None, # 0
4394 rajveer 13298 
    (1, TType.I64, 'type', None, None, ), # 1
4444 rajveer 13299 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
13300 
    (3, TType.I64, 'status', None, None, ), # 3
13301 
    (4, TType.I64, 'timestamp', None, None, ), # 4
94 ashish 13302 
  )
13303 
 
4444 rajveer 13304 
  def __init__(self, type=None, warehouseId=None, status=None, timestamp=None,):
4394 rajveer 13305 
    self.type = type
4444 rajveer 13306 
    self.warehouseId = warehouseId
4394 rajveer 13307 
    self.status = status
13308 
    self.timestamp = timestamp
94 ashish 13309 
 
13310 
  def read(self, iprot):
13311 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13312 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13313 
      return
13314 
    iprot.readStructBegin()
13315 
    while True:
13316 
      (fname, ftype, fid) = iprot.readFieldBegin()
13317 
      if ftype == TType.STOP:
13318 
        break
13319 
      if fid == 1:
3064 chandransh 13320 
        if ftype == TType.I64:
4394 rajveer 13321 
          self.type = iprot.readI64();
94 ashish 13322 
        else:
13323 
          iprot.skip(ftype)
3064 chandransh 13324 
      elif fid == 2:
4394 rajveer 13325 
        if ftype == TType.I64:
4444 rajveer 13326 
          self.warehouseId = iprot.readI64();
3064 chandransh 13327 
        else:
13328 
          iprot.skip(ftype)
4394 rajveer 13329 
      elif fid == 3:
13330 
        if ftype == TType.I64:
4444 rajveer 13331 
          self.status = iprot.readI64();
13332 
        else:
13333 
          iprot.skip(ftype)
13334 
      elif fid == 4:
13335 
        if ftype == TType.I64:
4394 rajveer 13336 
          self.timestamp = iprot.readI64();
13337 
        else:
13338 
          iprot.skip(ftype)
94 ashish 13339 
      else:
13340 
        iprot.skip(ftype)
13341 
      iprot.readFieldEnd()
13342 
    iprot.readStructEnd()
13343 
 
13344 
  def write(self, oprot):
13345 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13346 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13347 
      return
3064 chandransh 13348 
    oprot.writeStructBegin('getAlerts_args')
4394 rajveer 13349 
    if self.type is not None:
13350 
      oprot.writeFieldBegin('type', TType.I64, 1)
13351 
      oprot.writeI64(self.type)
94 ashish 13352 
      oprot.writeFieldEnd()
4444 rajveer 13353 
    if self.warehouseId is not None:
13354 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
13355 
      oprot.writeI64(self.warehouseId)
13356 
      oprot.writeFieldEnd()
4394 rajveer 13357 
    if self.status is not None:
4444 rajveer 13358 
      oprot.writeFieldBegin('status', TType.I64, 3)
4394 rajveer 13359 
      oprot.writeI64(self.status)
3064 chandransh 13360 
      oprot.writeFieldEnd()
4394 rajveer 13361 
    if self.timestamp is not None:
4444 rajveer 13362 
      oprot.writeFieldBegin('timestamp', TType.I64, 4)
4394 rajveer 13363 
      oprot.writeI64(self.timestamp)
13364 
      oprot.writeFieldEnd()
94 ashish 13365 
    oprot.writeFieldStop()
13366 
    oprot.writeStructEnd()
13367 
 
3431 rajveer 13368 
  def validate(self):
13369 
    return
13370 
 
13371 
 
94 ashish 13372 
  def __repr__(self):
13373 
    L = ['%s=%r' % (key, value)
13374 
      for key, value in self.__dict__.iteritems()]
13375 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13376 
 
13377 
  def __eq__(self, other):
13378 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13379 
 
13380 
  def __ne__(self, other):
13381 
    return not (self == other)
13382 
 
3064 chandransh 13383 
class getAlerts_result:
94 ashish 13384 
  """
13385 
  Attributes:
13386 
   - success
13387 
  """
13388 
 
13389 
  thrift_spec = (
3064 chandransh 13390 
    (0, TType.LIST, 'success', (TType.STRUCT,(Alert, Alert.thrift_spec)), None, ), # 0
94 ashish 13391 
  )
13392 
 
3064 chandransh 13393 
  def __init__(self, success=None,):
94 ashish 13394 
    self.success = success
13395 
 
13396 
  def read(self, iprot):
13397 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13398 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13399 
      return
13400 
    iprot.readStructBegin()
13401 
    while True:
13402 
      (fname, ftype, fid) = iprot.readFieldBegin()
13403 
      if ftype == TType.STOP:
13404 
        break
13405 
      if fid == 0:
3064 chandransh 13406 
        if ftype == TType.LIST:
13407 
          self.success = []
6188 rajveer 13408 
          (_etype242, _size239) = iprot.readListBegin()
13409 
          for _i243 in xrange(_size239):
13410 
            _elem244 = Alert()
13411 
            _elem244.read(iprot)
13412 
            self.success.append(_elem244)
3064 chandransh 13413 
          iprot.readListEnd()
94 ashish 13414 
        else:
13415 
          iprot.skip(ftype)
13416 
      else:
13417 
        iprot.skip(ftype)
13418 
      iprot.readFieldEnd()
13419 
    iprot.readStructEnd()
13420 
 
13421 
  def write(self, oprot):
13422 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13423 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13424 
      return
3064 chandransh 13425 
    oprot.writeStructBegin('getAlerts_result')
3431 rajveer 13426 
    if self.success is not None:
3064 chandransh 13427 
      oprot.writeFieldBegin('success', TType.LIST, 0)
13428 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 13429 
      for iter245 in self.success:
13430 
        iter245.write(oprot)
3064 chandransh 13431 
      oprot.writeListEnd()
94 ashish 13432 
      oprot.writeFieldEnd()
13433 
    oprot.writeFieldStop()
13434 
    oprot.writeStructEnd()
13435 
 
3431 rajveer 13436 
  def validate(self):
13437 
    return
13438 
 
13439 
 
94 ashish 13440 
  def __repr__(self):
13441 
    L = ['%s=%r' % (key, value)
13442 
      for key, value in self.__dict__.iteritems()]
13443 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13444 
 
13445 
  def __eq__(self, other):
13446 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13447 
 
13448 
  def __ne__(self, other):
13449 
    return not (self == other)
13450 
 
4394 rajveer 13451 
class addAlert_args:
94 ashish 13452 
  """
13453 
  Attributes:
3064 chandransh 13454 
   - type
4444 rajveer 13455 
   - warehouseId
4394 rajveer 13456 
   - description
94 ashish 13457 
  """
13458 
 
13459 
  thrift_spec = (
13460 
    None, # 0
4394 rajveer 13461 
    (1, TType.I64, 'type', None, None, ), # 1
4444 rajveer 13462 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
13463 
    (3, TType.STRING, 'description', None, None, ), # 3
94 ashish 13464 
  )
13465 
 
4444 rajveer 13466 
  def __init__(self, type=None, warehouseId=None, description=None,):
3064 chandransh 13467 
    self.type = type
4444 rajveer 13468 
    self.warehouseId = warehouseId
4394 rajveer 13469 
    self.description = description
94 ashish 13470 
 
13471 
  def read(self, iprot):
13472 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13473 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13474 
      return
13475 
    iprot.readStructBegin()
13476 
    while True:
13477 
      (fname, ftype, fid) = iprot.readFieldBegin()
13478 
      if ftype == TType.STOP:
13479 
        break
13480 
      if fid == 1:
13481 
        if ftype == TType.I64:
4394 rajveer 13482 
          self.type = iprot.readI64();
94 ashish 13483 
        else:
13484 
          iprot.skip(ftype)
3064 chandransh 13485 
      elif fid == 2:
4444 rajveer 13486 
        if ftype == TType.I64:
13487 
          self.warehouseId = iprot.readI64();
13488 
        else:
13489 
          iprot.skip(ftype)
13490 
      elif fid == 3:
3064 chandransh 13491 
        if ftype == TType.STRING:
4394 rajveer 13492 
          self.description = iprot.readString();
3064 chandransh 13493 
        else:
13494 
          iprot.skip(ftype)
94 ashish 13495 
      else:
13496 
        iprot.skip(ftype)
13497 
      iprot.readFieldEnd()
13498 
    iprot.readStructEnd()
13499 
 
13500 
  def write(self, oprot):
13501 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13502 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13503 
      return
4394 rajveer 13504 
    oprot.writeStructBegin('addAlert_args')
3431 rajveer 13505 
    if self.type is not None:
4394 rajveer 13506 
      oprot.writeFieldBegin('type', TType.I64, 1)
3064 chandransh 13507 
      oprot.writeI64(self.type)
13508 
      oprot.writeFieldEnd()
4444 rajveer 13509 
    if self.warehouseId is not None:
13510 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
13511 
      oprot.writeI64(self.warehouseId)
13512 
      oprot.writeFieldEnd()
4394 rajveer 13513 
    if self.description is not None:
4444 rajveer 13514 
      oprot.writeFieldBegin('description', TType.STRING, 3)
4394 rajveer 13515 
      oprot.writeString(self.description)
3064 chandransh 13516 
      oprot.writeFieldEnd()
94 ashish 13517 
    oprot.writeFieldStop()
13518 
    oprot.writeStructEnd()
13519 
 
3431 rajveer 13520 
  def validate(self):
13521 
    return
13522 
 
13523 
 
94 ashish 13524 
  def __repr__(self):
13525 
    L = ['%s=%r' % (key, value)
13526 
      for key, value in self.__dict__.iteritems()]
13527 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13528 
 
13529 
  def __eq__(self, other):
13530 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13531 
 
13532 
  def __ne__(self, other):
13533 
    return not (self == other)
13534 
 
4394 rajveer 13535 
class addAlert_result:
3064 chandransh 13536 
 
13537 
  thrift_spec = (
13538 
  )
13539 
 
13540 
  def read(self, iprot):
13541 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13542 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13543 
      return
13544 
    iprot.readStructBegin()
13545 
    while True:
13546 
      (fname, ftype, fid) = iprot.readFieldBegin()
13547 
      if ftype == TType.STOP:
13548 
        break
13549 
      else:
13550 
        iprot.skip(ftype)
13551 
      iprot.readFieldEnd()
13552 
    iprot.readStructEnd()
13553 
 
13554 
  def write(self, oprot):
13555 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13556 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13557 
      return
4394 rajveer 13558 
    oprot.writeStructBegin('addAlert_result')
3064 chandransh 13559 
    oprot.writeFieldStop()
13560 
    oprot.writeStructEnd()
13561 
 
3431 rajveer 13562 
  def validate(self):
13563 
    return
13564 
 
13565 
 
3064 chandransh 13566 
  def __repr__(self):
13567 
    L = ['%s=%r' % (key, value)
13568 
      for key, value in self.__dict__.iteritems()]
13569 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13570 
 
13571 
  def __eq__(self, other):
13572 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13573 
 
13574 
  def __ne__(self, other):
13575 
    return not (self == other)
13576 
 
4444 rajveer 13577 
class markAlertsAsSeen_args:
13578 
  """
13579 
  Attributes:
13580 
   - warehouseId
13581 
  """
13582 
 
13583 
  thrift_spec = (
13584 
    None, # 0
13585 
    (1, TType.I64, 'warehouseId', None, None, ), # 1
13586 
  )
13587 
 
13588 
  def __init__(self, warehouseId=None,):
13589 
    self.warehouseId = warehouseId
13590 
 
13591 
  def read(self, iprot):
13592 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13593 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13594 
      return
13595 
    iprot.readStructBegin()
13596 
    while True:
13597 
      (fname, ftype, fid) = iprot.readFieldBegin()
13598 
      if ftype == TType.STOP:
13599 
        break
13600 
      if fid == 1:
13601 
        if ftype == TType.I64:
13602 
          self.warehouseId = iprot.readI64();
13603 
        else:
13604 
          iprot.skip(ftype)
13605 
      else:
13606 
        iprot.skip(ftype)
13607 
      iprot.readFieldEnd()
13608 
    iprot.readStructEnd()
13609 
 
13610 
  def write(self, oprot):
13611 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13612 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13613 
      return
13614 
    oprot.writeStructBegin('markAlertsAsSeen_args')
13615 
    if self.warehouseId is not None:
13616 
      oprot.writeFieldBegin('warehouseId', TType.I64, 1)
13617 
      oprot.writeI64(self.warehouseId)
13618 
      oprot.writeFieldEnd()
13619 
    oprot.writeFieldStop()
13620 
    oprot.writeStructEnd()
13621 
 
13622 
  def validate(self):
13623 
    return
13624 
 
13625 
 
13626 
  def __repr__(self):
13627 
    L = ['%s=%r' % (key, value)
13628 
      for key, value in self.__dict__.iteritems()]
13629 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13630 
 
13631 
  def __eq__(self, other):
13632 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13633 
 
13634 
  def __ne__(self, other):
13635 
    return not (self == other)
13636 
 
13637 
class markAlertsAsSeen_result:
13638 
 
13639 
  thrift_spec = (
13640 
  )
13641 
 
13642 
  def read(self, iprot):
13643 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13644 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13645 
      return
13646 
    iprot.readStructBegin()
13647 
    while True:
13648 
      (fname, ftype, fid) = iprot.readFieldBegin()
13649 
      if ftype == TType.STOP:
13650 
        break
13651 
      else:
13652 
        iprot.skip(ftype)
13653 
      iprot.readFieldEnd()
13654 
    iprot.readStructEnd()
13655 
 
13656 
  def write(self, oprot):
13657 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13658 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13659 
      return
13660 
    oprot.writeStructBegin('markAlertsAsSeen_result')
13661 
    oprot.writeFieldStop()
13662 
    oprot.writeStructEnd()
13663 
 
13664 
  def validate(self):
13665 
    return
13666 
 
13667 
 
13668 
  def __repr__(self):
13669 
    L = ['%s=%r' % (key, value)
13670 
      for key, value in self.__dict__.iteritems()]
13671 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13672 
 
13673 
  def __eq__(self, other):
13674 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13675 
 
13676 
  def __ne__(self, other):
13677 
    return not (self == other)
13678 
 
3064 chandransh 13679 
class getValidOrderCount_args:
13680 
 
13681 
  thrift_spec = (
13682 
  )
13683 
 
13684 
  def read(self, iprot):
13685 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13686 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13687 
      return
13688 
    iprot.readStructBegin()
13689 
    while True:
13690 
      (fname, ftype, fid) = iprot.readFieldBegin()
13691 
      if ftype == TType.STOP:
13692 
        break
13693 
      else:
13694 
        iprot.skip(ftype)
13695 
      iprot.readFieldEnd()
13696 
    iprot.readStructEnd()
13697 
 
13698 
  def write(self, oprot):
13699 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13700 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13701 
      return
13702 
    oprot.writeStructBegin('getValidOrderCount_args')
13703 
    oprot.writeFieldStop()
13704 
    oprot.writeStructEnd()
13705 
 
3431 rajveer 13706 
  def validate(self):
13707 
    return
13708 
 
13709 
 
3064 chandransh 13710 
  def __repr__(self):
13711 
    L = ['%s=%r' % (key, value)
13712 
      for key, value in self.__dict__.iteritems()]
13713 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13714 
 
13715 
  def __eq__(self, other):
13716 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13717 
 
13718 
  def __ne__(self, other):
13719 
    return not (self == other)
13720 
 
13721 
class getValidOrderCount_result:
94 ashish 13722 
  """
13723 
  Attributes:
13724 
   - success
13725 
  """
13726 
 
13727 
  thrift_spec = (
3064 chandransh 13728 
    (0, TType.I64, 'success', None, None, ), # 0
94 ashish 13729 
  )
13730 
 
3064 chandransh 13731 
  def __init__(self, success=None,):
94 ashish 13732 
    self.success = success
13733 
 
13734 
  def read(self, iprot):
13735 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13736 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13737 
      return
13738 
    iprot.readStructBegin()
13739 
    while True:
13740 
      (fname, ftype, fid) = iprot.readFieldBegin()
13741 
      if ftype == TType.STOP:
13742 
        break
13743 
      if fid == 0:
3064 chandransh 13744 
        if ftype == TType.I64:
13745 
          self.success = iprot.readI64();
94 ashish 13746 
        else:
13747 
          iprot.skip(ftype)
13748 
      else:
13749 
        iprot.skip(ftype)
13750 
      iprot.readFieldEnd()
13751 
    iprot.readStructEnd()
13752 
 
13753 
  def write(self, oprot):
13754 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13755 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13756 
      return
3064 chandransh 13757 
    oprot.writeStructBegin('getValidOrderCount_result')
3431 rajveer 13758 
    if self.success is not None:
3064 chandransh 13759 
      oprot.writeFieldBegin('success', TType.I64, 0)
13760 
      oprot.writeI64(self.success)
94 ashish 13761 
      oprot.writeFieldEnd()
13762 
    oprot.writeFieldStop()
13763 
    oprot.writeStructEnd()
13764 
 
3431 rajveer 13765 
  def validate(self):
13766 
    return
13767 
 
13768 
 
94 ashish 13769 
  def __repr__(self):
13770 
    L = ['%s=%r' % (key, value)
13771 
      for key, value in self.__dict__.iteritems()]
13772 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13773 
 
13774 
  def __eq__(self, other):
13775 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13776 
 
13777 
  def __ne__(self, other):
13778 
    return not (self == other)
13779 
 
3064 chandransh 13780 
class getNoOfCustomersWithSuccessfulTransaction_args:
13781 
 
13782 
  thrift_spec = (
13783 
  )
13784 
 
13785 
  def read(self, iprot):
13786 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13787 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13788 
      return
13789 
    iprot.readStructBegin()
13790 
    while True:
13791 
      (fname, ftype, fid) = iprot.readFieldBegin()
13792 
      if ftype == TType.STOP:
13793 
        break
13794 
      else:
13795 
        iprot.skip(ftype)
13796 
      iprot.readFieldEnd()
13797 
    iprot.readStructEnd()
13798 
 
13799 
  def write(self, oprot):
13800 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13801 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13802 
      return
13803 
    oprot.writeStructBegin('getNoOfCustomersWithSuccessfulTransaction_args')
13804 
    oprot.writeFieldStop()
13805 
    oprot.writeStructEnd()
13806 
 
3431 rajveer 13807 
  def validate(self):
13808 
    return
13809 
 
13810 
 
3064 chandransh 13811 
  def __repr__(self):
13812 
    L = ['%s=%r' % (key, value)
13813 
      for key, value in self.__dict__.iteritems()]
13814 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13815 
 
13816 
  def __eq__(self, other):
13817 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13818 
 
13819 
  def __ne__(self, other):
13820 
    return not (self == other)
13821 
 
13822 
class getNoOfCustomersWithSuccessfulTransaction_result:
94 ashish 13823 
  """
13824 
  Attributes:
3064 chandransh 13825 
   - success
94 ashish 13826 
  """
13827 
 
13828 
  thrift_spec = (
3064 chandransh 13829 
    (0, TType.I64, 'success', None, None, ), # 0
94 ashish 13830 
  )
13831 
 
3064 chandransh 13832 
  def __init__(self, success=None,):
13833 
    self.success = success
94 ashish 13834 
 
13835 
  def read(self, iprot):
13836 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13837 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13838 
      return
13839 
    iprot.readStructBegin()
13840 
    while True:
13841 
      (fname, ftype, fid) = iprot.readFieldBegin()
13842 
      if ftype == TType.STOP:
13843 
        break
3064 chandransh 13844 
      if fid == 0:
94 ashish 13845 
        if ftype == TType.I64:
3064 chandransh 13846 
          self.success = iprot.readI64();
94 ashish 13847 
        else:
13848 
          iprot.skip(ftype)
13849 
      else:
13850 
        iprot.skip(ftype)
13851 
      iprot.readFieldEnd()
13852 
    iprot.readStructEnd()
13853 
 
13854 
  def write(self, oprot):
13855 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13856 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13857 
      return
3064 chandransh 13858 
    oprot.writeStructBegin('getNoOfCustomersWithSuccessfulTransaction_result')
3431 rajveer 13859 
    if self.success is not None:
3064 chandransh 13860 
      oprot.writeFieldBegin('success', TType.I64, 0)
13861 
      oprot.writeI64(self.success)
94 ashish 13862 
      oprot.writeFieldEnd()
13863 
    oprot.writeFieldStop()
13864 
    oprot.writeStructEnd()
13865 
 
3431 rajveer 13866 
  def validate(self):
13867 
    return
13868 
 
13869 
 
94 ashish 13870 
  def __repr__(self):
13871 
    L = ['%s=%r' % (key, value)
13872 
      for key, value in self.__dict__.iteritems()]
13873 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13874 
 
13875 
  def __eq__(self, other):
13876 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13877 
 
13878 
  def __ne__(self, other):
13879 
    return not (self == other)
13880 
 
3064 chandransh 13881 
class getValidOrdersAmountRange_args:
13882 
 
13883 
  thrift_spec = (
13884 
  )
13885 
 
13886 
  def read(self, iprot):
13887 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13888 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13889 
      return
13890 
    iprot.readStructBegin()
13891 
    while True:
13892 
      (fname, ftype, fid) = iprot.readFieldBegin()
13893 
      if ftype == TType.STOP:
13894 
        break
13895 
      else:
13896 
        iprot.skip(ftype)
13897 
      iprot.readFieldEnd()
13898 
    iprot.readStructEnd()
13899 
 
13900 
  def write(self, oprot):
13901 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13902 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13903 
      return
13904 
    oprot.writeStructBegin('getValidOrdersAmountRange_args')
13905 
    oprot.writeFieldStop()
13906 
    oprot.writeStructEnd()
13907 
 
3431 rajveer 13908 
  def validate(self):
13909 
    return
13910 
 
13911 
 
3064 chandransh 13912 
  def __repr__(self):
13913 
    L = ['%s=%r' % (key, value)
13914 
      for key, value in self.__dict__.iteritems()]
13915 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13916 
 
13917 
  def __eq__(self, other):
13918 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13919 
 
13920 
  def __ne__(self, other):
13921 
    return not (self == other)
13922 
 
13923 
class getValidOrdersAmountRange_result:
94 ashish 13924 
  """
13925 
  Attributes:
13926 
   - success
13927 
  """
13928 
 
13929 
  thrift_spec = (
3064 chandransh 13930 
    (0, TType.LIST, 'success', (TType.DOUBLE,None), None, ), # 0
94 ashish 13931 
  )
13932 
 
3064 chandransh 13933 
  def __init__(self, success=None,):
94 ashish 13934 
    self.success = success
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 
      if fid == 0:
483 rajveer 13946 
        if ftype == TType.LIST:
13947 
          self.success = []
6188 rajveer 13948 
          (_etype249, _size246) = iprot.readListBegin()
13949 
          for _i250 in xrange(_size246):
13950 
            _elem251 = iprot.readDouble();
13951 
            self.success.append(_elem251)
483 rajveer 13952 
          iprot.readListEnd()
94 ashish 13953 
        else:
13954 
          iprot.skip(ftype)
13955 
      else:
13956 
        iprot.skip(ftype)
13957 
      iprot.readFieldEnd()
13958 
    iprot.readStructEnd()
13959 
 
13960 
  def write(self, oprot):
13961 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13962 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13963 
      return
3064 chandransh 13964 
    oprot.writeStructBegin('getValidOrdersAmountRange_result')
3431 rajveer 13965 
    if self.success is not None:
483 rajveer 13966 
      oprot.writeFieldBegin('success', TType.LIST, 0)
3064 chandransh 13967 
      oprot.writeListBegin(TType.DOUBLE, len(self.success))
6188 rajveer 13968 
      for iter252 in self.success:
13969 
        oprot.writeDouble(iter252)
483 rajveer 13970 
      oprot.writeListEnd()
94 ashish 13971 
      oprot.writeFieldEnd()
13972 
    oprot.writeFieldStop()
13973 
    oprot.writeStructEnd()
13974 
 
3431 rajveer 13975 
  def validate(self):
13976 
    return
13977 
 
13978 
 
94 ashish 13979 
  def __repr__(self):
13980 
    L = ['%s=%r' % (key, value)
13981 
      for key, value in self.__dict__.iteritems()]
13982 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13983 
 
13984 
  def __eq__(self, other):
13985 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13986 
 
13987 
  def __ne__(self, other):
13988 
    return not (self == other)
13989 
 
3064 chandransh 13990 
class getValidOrders_args:
1528 ankur.sing 13991 
  """
13992 
  Attributes:
3064 chandransh 13993 
   - limit
5874 rajveer 13994 
   - onlyStore
1528 ankur.sing 13995 
  """
13996 
 
13997 
  thrift_spec = (
13998 
    None, # 0
3064 chandransh 13999 
    (1, TType.I64, 'limit', None, None, ), # 1
5874 rajveer 14000 
    (2, TType.BOOL, 'onlyStore', None, None, ), # 2
1528 ankur.sing 14001 
  )
14002 
 
5874 rajveer 14003 
  def __init__(self, limit=None, onlyStore=None,):
3064 chandransh 14004 
    self.limit = limit
5874 rajveer 14005 
    self.onlyStore = onlyStore
1528 ankur.sing 14006 
 
14007 
  def read(self, iprot):
14008 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14009 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14010 
      return
14011 
    iprot.readStructBegin()
14012 
    while True:
14013 
      (fname, ftype, fid) = iprot.readFieldBegin()
14014 
      if ftype == TType.STOP:
14015 
        break
14016 
      if fid == 1:
14017 
        if ftype == TType.I64:
3064 chandransh 14018 
          self.limit = iprot.readI64();
1528 ankur.sing 14019 
        else:
14020 
          iprot.skip(ftype)
5874 rajveer 14021 
      elif fid == 2:
14022 
        if ftype == TType.BOOL:
14023 
          self.onlyStore = iprot.readBool();
14024 
        else:
14025 
          iprot.skip(ftype)
1528 ankur.sing 14026 
      else:
14027 
        iprot.skip(ftype)
14028 
      iprot.readFieldEnd()
14029 
    iprot.readStructEnd()
14030 
 
14031 
  def write(self, oprot):
14032 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14033 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14034 
      return
3064 chandransh 14035 
    oprot.writeStructBegin('getValidOrders_args')
3431 rajveer 14036 
    if self.limit is not None:
3064 chandransh 14037 
      oprot.writeFieldBegin('limit', TType.I64, 1)
14038 
      oprot.writeI64(self.limit)
1528 ankur.sing 14039 
      oprot.writeFieldEnd()
5874 rajveer 14040 
    if self.onlyStore is not None:
14041 
      oprot.writeFieldBegin('onlyStore', TType.BOOL, 2)
14042 
      oprot.writeBool(self.onlyStore)
14043 
      oprot.writeFieldEnd()
1528 ankur.sing 14044 
    oprot.writeFieldStop()
14045 
    oprot.writeStructEnd()
14046 
 
3431 rajveer 14047 
  def validate(self):
14048 
    return
14049 
 
14050 
 
1528 ankur.sing 14051 
  def __repr__(self):
14052 
    L = ['%s=%r' % (key, value)
14053 
      for key, value in self.__dict__.iteritems()]
14054 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14055 
 
14056 
  def __eq__(self, other):
14057 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14058 
 
14059 
  def __ne__(self, other):
14060 
    return not (self == other)
14061 
 
3064 chandransh 14062 
class getValidOrders_result:
1528 ankur.sing 14063 
  """
14064 
  Attributes:
14065 
   - success
14066 
  """
14067 
 
14068 
  thrift_spec = (
3064 chandransh 14069 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
1528 ankur.sing 14070 
  )
14071 
 
3064 chandransh 14072 
  def __init__(self, success=None,):
1528 ankur.sing 14073 
    self.success = success
14074 
 
14075 
  def read(self, iprot):
14076 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14077 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14078 
      return
14079 
    iprot.readStructBegin()
14080 
    while True:
14081 
      (fname, ftype, fid) = iprot.readFieldBegin()
14082 
      if ftype == TType.STOP:
14083 
        break
14084 
      if fid == 0:
3064 chandransh 14085 
        if ftype == TType.LIST:
14086 
          self.success = []
6188 rajveer 14087 
          (_etype256, _size253) = iprot.readListBegin()
14088 
          for _i257 in xrange(_size253):
14089 
            _elem258 = Order()
14090 
            _elem258.read(iprot)
14091 
            self.success.append(_elem258)
3064 chandransh 14092 
          iprot.readListEnd()
1528 ankur.sing 14093 
        else:
14094 
          iprot.skip(ftype)
14095 
      else:
14096 
        iprot.skip(ftype)
14097 
      iprot.readFieldEnd()
14098 
    iprot.readStructEnd()
14099 
 
14100 
  def write(self, oprot):
14101 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14102 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14103 
      return
3064 chandransh 14104 
    oprot.writeStructBegin('getValidOrders_result')
3431 rajveer 14105 
    if self.success is not None:
3064 chandransh 14106 
      oprot.writeFieldBegin('success', TType.LIST, 0)
14107 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 14108 
      for iter259 in self.success:
14109 
        iter259.write(oprot)
3064 chandransh 14110 
      oprot.writeListEnd()
1528 ankur.sing 14111 
      oprot.writeFieldEnd()
14112 
    oprot.writeFieldStop()
14113 
    oprot.writeStructEnd()
14114 
 
3431 rajveer 14115 
  def validate(self):
14116 
    return
14117 
 
14118 
 
1528 ankur.sing 14119 
  def __repr__(self):
14120 
    L = ['%s=%r' % (key, value)
14121 
      for key, value in self.__dict__.iteritems()]
14122 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14123 
 
14124 
  def __eq__(self, other):
14125 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14126 
 
14127 
  def __ne__(self, other):
14128 
    return not (self == other)
14129 
 
1220 chandransh 14130 
class batchOrders_args:
14131 
  """
14132 
  Attributes:
14133 
   - warehouseId
14134 
  """
14135 
 
14136 
  thrift_spec = (
14137 
    None, # 0
14138 
    (1, TType.I64, 'warehouseId', None, None, ), # 1
14139 
  )
14140 
 
14141 
  def __init__(self, warehouseId=None,):
14142 
    self.warehouseId = warehouseId
14143 
 
14144 
  def read(self, iprot):
14145 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14146 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14147 
      return
14148 
    iprot.readStructBegin()
14149 
    while True:
14150 
      (fname, ftype, fid) = iprot.readFieldBegin()
14151 
      if ftype == TType.STOP:
14152 
        break
14153 
      if fid == 1:
14154 
        if ftype == TType.I64:
14155 
          self.warehouseId = iprot.readI64();
14156 
        else:
14157 
          iprot.skip(ftype)
14158 
      else:
14159 
        iprot.skip(ftype)
14160 
      iprot.readFieldEnd()
14161 
    iprot.readStructEnd()
14162 
 
14163 
  def write(self, oprot):
14164 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14165 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14166 
      return
14167 
    oprot.writeStructBegin('batchOrders_args')
3431 rajveer 14168 
    if self.warehouseId is not None:
1220 chandransh 14169 
      oprot.writeFieldBegin('warehouseId', TType.I64, 1)
14170 
      oprot.writeI64(self.warehouseId)
14171 
      oprot.writeFieldEnd()
14172 
    oprot.writeFieldStop()
14173 
    oprot.writeStructEnd()
14174 
 
3431 rajveer 14175 
  def validate(self):
14176 
    return
14177 
 
14178 
 
1220 chandransh 14179 
  def __repr__(self):
14180 
    L = ['%s=%r' % (key, value)
14181 
      for key, value in self.__dict__.iteritems()]
14182 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14183 
 
14184 
  def __eq__(self, other):
14185 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14186 
 
14187 
  def __ne__(self, other):
14188 
    return not (self == other)
14189 
 
14190 
class batchOrders_result:
14191 
  """
14192 
  Attributes:
14193 
   - success
14194 
   - ex
14195 
  """
14196 
 
14197 
  thrift_spec = (
14198 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
14199 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
14200 
  )
14201 
 
14202 
  def __init__(self, success=None, ex=None,):
14203 
    self.success = success
14204 
    self.ex = ex
14205 
 
14206 
  def read(self, iprot):
14207 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14208 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14209 
      return
14210 
    iprot.readStructBegin()
14211 
    while True:
14212 
      (fname, ftype, fid) = iprot.readFieldBegin()
14213 
      if ftype == TType.STOP:
14214 
        break
14215 
      if fid == 0:
14216 
        if ftype == TType.LIST:
14217 
          self.success = []
6188 rajveer 14218 
          (_etype263, _size260) = iprot.readListBegin()
14219 
          for _i264 in xrange(_size260):
14220 
            _elem265 = Order()
14221 
            _elem265.read(iprot)
14222 
            self.success.append(_elem265)
1220 chandransh 14223 
          iprot.readListEnd()
14224 
        else:
14225 
          iprot.skip(ftype)
14226 
      elif fid == 1:
14227 
        if ftype == TType.STRUCT:
14228 
          self.ex = TransactionServiceException()
14229 
          self.ex.read(iprot)
14230 
        else:
14231 
          iprot.skip(ftype)
14232 
      else:
14233 
        iprot.skip(ftype)
14234 
      iprot.readFieldEnd()
14235 
    iprot.readStructEnd()
14236 
 
14237 
  def write(self, oprot):
14238 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14239 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14240 
      return
14241 
    oprot.writeStructBegin('batchOrders_result')
3431 rajveer 14242 
    if self.success is not None:
1220 chandransh 14243 
      oprot.writeFieldBegin('success', TType.LIST, 0)
14244 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 14245 
      for iter266 in self.success:
14246 
        iter266.write(oprot)
1220 chandransh 14247 
      oprot.writeListEnd()
14248 
      oprot.writeFieldEnd()
3431 rajveer 14249 
    if self.ex is not None:
1220 chandransh 14250 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
14251 
      self.ex.write(oprot)
14252 
      oprot.writeFieldEnd()
14253 
    oprot.writeFieldStop()
14254 
    oprot.writeStructEnd()
14255 
 
3431 rajveer 14256 
  def validate(self):
14257 
    return
14258 
 
14259 
 
1220 chandransh 14260 
  def __repr__(self):
14261 
    L = ['%s=%r' % (key, value)
14262 
      for key, value in self.__dict__.iteritems()]
14263 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14264 
 
14265 
  def __eq__(self, other):
14266 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14267 
 
14268 
  def __ne__(self, other):
14269 
    return not (self == other)
14270 
 
1208 chandransh 14271 
class markOrderAsOutOfStock_args:
14272 
  """
14273 
  Attributes:
14274 
   - orderId
14275 
  """
14276 
 
14277 
  thrift_spec = (
14278 
    None, # 0
14279 
    (1, TType.I64, 'orderId', None, None, ), # 1
14280 
  )
14281 
 
14282 
  def __init__(self, orderId=None,):
14283 
    self.orderId = orderId
14284 
 
14285 
  def read(self, iprot):
14286 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14287 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14288 
      return
14289 
    iprot.readStructBegin()
14290 
    while True:
14291 
      (fname, ftype, fid) = iprot.readFieldBegin()
14292 
      if ftype == TType.STOP:
14293 
        break
14294 
      if fid == 1:
14295 
        if ftype == TType.I64:
14296 
          self.orderId = iprot.readI64();
14297 
        else:
14298 
          iprot.skip(ftype)
14299 
      else:
14300 
        iprot.skip(ftype)
14301 
      iprot.readFieldEnd()
14302 
    iprot.readStructEnd()
14303 
 
14304 
  def write(self, oprot):
14305 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14306 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14307 
      return
14308 
    oprot.writeStructBegin('markOrderAsOutOfStock_args')
3431 rajveer 14309 
    if self.orderId is not None:
1208 chandransh 14310 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
14311 
      oprot.writeI64(self.orderId)
14312 
      oprot.writeFieldEnd()
14313 
    oprot.writeFieldStop()
14314 
    oprot.writeStructEnd()
14315 
 
3431 rajveer 14316 
  def validate(self):
14317 
    return
14318 
 
14319 
 
1208 chandransh 14320 
  def __repr__(self):
14321 
    L = ['%s=%r' % (key, value)
14322 
      for key, value in self.__dict__.iteritems()]
14323 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14324 
 
14325 
  def __eq__(self, other):
14326 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14327 
 
14328 
  def __ne__(self, other):
14329 
    return not (self == other)
14330 
 
14331 
class markOrderAsOutOfStock_result:
14332 
  """
14333 
  Attributes:
14334 
   - success
14335 
   - ex
14336 
  """
14337 
 
14338 
  thrift_spec = (
14339 
    (0, TType.BOOL, 'success', None, None, ), # 0
14340 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
14341 
  )
14342 
 
14343 
  def __init__(self, success=None, ex=None,):
14344 
    self.success = success
14345 
    self.ex = ex
14346 
 
14347 
  def read(self, iprot):
14348 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14349 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14350 
      return
14351 
    iprot.readStructBegin()
14352 
    while True:
14353 
      (fname, ftype, fid) = iprot.readFieldBegin()
14354 
      if ftype == TType.STOP:
14355 
        break
14356 
      if fid == 0:
14357 
        if ftype == TType.BOOL:
14358 
          self.success = iprot.readBool();
14359 
        else:
14360 
          iprot.skip(ftype)
14361 
      elif fid == 1:
14362 
        if ftype == TType.STRUCT:
14363 
          self.ex = TransactionServiceException()
14364 
          self.ex.read(iprot)
14365 
        else:
14366 
          iprot.skip(ftype)
14367 
      else:
14368 
        iprot.skip(ftype)
14369 
      iprot.readFieldEnd()
14370 
    iprot.readStructEnd()
14371 
 
14372 
  def write(self, oprot):
14373 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14374 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14375 
      return
14376 
    oprot.writeStructBegin('markOrderAsOutOfStock_result')
3431 rajveer 14377 
    if self.success is not None:
1208 chandransh 14378 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
14379 
      oprot.writeBool(self.success)
14380 
      oprot.writeFieldEnd()
3431 rajveer 14381 
    if self.ex is not None:
1208 chandransh 14382 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
14383 
      self.ex.write(oprot)
14384 
      oprot.writeFieldEnd()
14385 
    oprot.writeFieldStop()
14386 
    oprot.writeStructEnd()
14387 
 
3431 rajveer 14388 
  def validate(self):
14389 
    return
14390 
 
14391 
 
1208 chandransh 14392 
  def __repr__(self):
14393 
    L = ['%s=%r' % (key, value)
14394 
      for key, value in self.__dict__.iteritems()]
14395 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14396 
 
14397 
  def __eq__(self, other):
14398 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14399 
 
14400 
  def __ne__(self, other):
14401 
    return not (self == other)
14402 
 
3064 chandransh 14403 
class verifyOrder_args:
759 chandransh 14404 
  """
14405 
  Attributes:
3064 chandransh 14406 
   - orderId
759 chandransh 14407 
  """
14408 
 
14409 
  thrift_spec = (
14410 
    None, # 0
3064 chandransh 14411 
    (1, TType.I64, 'orderId', None, None, ), # 1
759 chandransh 14412 
  )
14413 
 
3064 chandransh 14414 
  def __init__(self, orderId=None,):
14415 
    self.orderId = orderId
759 chandransh 14416 
 
14417 
  def read(self, iprot):
14418 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14419 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14420 
      return
14421 
    iprot.readStructBegin()
14422 
    while True:
14423 
      (fname, ftype, fid) = iprot.readFieldBegin()
14424 
      if ftype == TType.STOP:
14425 
        break
14426 
      if fid == 1:
14427 
        if ftype == TType.I64:
3064 chandransh 14428 
          self.orderId = iprot.readI64();
759 chandransh 14429 
        else:
14430 
          iprot.skip(ftype)
14431 
      else:
14432 
        iprot.skip(ftype)
14433 
      iprot.readFieldEnd()
14434 
    iprot.readStructEnd()
14435 
 
14436 
  def write(self, oprot):
14437 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14438 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14439 
      return
3064 chandransh 14440 
    oprot.writeStructBegin('verifyOrder_args')
3431 rajveer 14441 
    if self.orderId is not None:
3064 chandransh 14442 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
14443 
      oprot.writeI64(self.orderId)
759 chandransh 14444 
      oprot.writeFieldEnd()
14445 
    oprot.writeFieldStop()
14446 
    oprot.writeStructEnd()
14447 
 
3431 rajveer 14448 
  def validate(self):
14449 
    return
14450 
 
14451 
 
759 chandransh 14452 
  def __repr__(self):
14453 
    L = ['%s=%r' % (key, value)
14454 
      for key, value in self.__dict__.iteritems()]
14455 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14456 
 
14457 
  def __eq__(self, other):
14458 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14459 
 
14460 
  def __ne__(self, other):
14461 
    return not (self == other)
14462 
 
3064 chandransh 14463 
class verifyOrder_result:
759 chandransh 14464 
  """
14465 
  Attributes:
14466 
   - success
14467 
   - ex
14468 
  """
14469 
 
14470 
  thrift_spec = (
14471 
    (0, TType.BOOL, 'success', None, None, ), # 0
14472 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
14473 
  )
14474 
 
14475 
  def __init__(self, success=None, ex=None,):
14476 
    self.success = success
14477 
    self.ex = ex
14478 
 
14479 
  def read(self, iprot):
14480 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14481 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14482 
      return
14483 
    iprot.readStructBegin()
14484 
    while True:
14485 
      (fname, ftype, fid) = iprot.readFieldBegin()
14486 
      if ftype == TType.STOP:
14487 
        break
14488 
      if fid == 0:
14489 
        if ftype == TType.BOOL:
14490 
          self.success = iprot.readBool();
14491 
        else:
14492 
          iprot.skip(ftype)
14493 
      elif fid == 1:
14494 
        if ftype == TType.STRUCT:
14495 
          self.ex = TransactionServiceException()
14496 
          self.ex.read(iprot)
14497 
        else:
14498 
          iprot.skip(ftype)
14499 
      else:
14500 
        iprot.skip(ftype)
14501 
      iprot.readFieldEnd()
14502 
    iprot.readStructEnd()
14503 
 
14504 
  def write(self, oprot):
14505 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14506 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14507 
      return
3064 chandransh 14508 
    oprot.writeStructBegin('verifyOrder_result')
3431 rajveer 14509 
    if self.success is not None:
759 chandransh 14510 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
14511 
      oprot.writeBool(self.success)
14512 
      oprot.writeFieldEnd()
3431 rajveer 14513 
    if self.ex is not None:
759 chandransh 14514 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
14515 
      self.ex.write(oprot)
14516 
      oprot.writeFieldEnd()
14517 
    oprot.writeFieldStop()
14518 
    oprot.writeStructEnd()
14519 
 
3431 rajveer 14520 
  def validate(self):
14521 
    return
14522 
 
14523 
 
759 chandransh 14524 
  def __repr__(self):
14525 
    L = ['%s=%r' % (key, value)
14526 
      for key, value in self.__dict__.iteritems()]
14527 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14528 
 
14529 
  def __eq__(self, other):
14530 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14531 
 
14532 
  def __ne__(self, other):
14533 
    return not (self == other)
14534 
 
3064 chandransh 14535 
class acceptOrder_args:
1113 chandransh 14536 
  """
14537 
  Attributes:
3064 chandransh 14538 
   - orderId
1113 chandransh 14539 
  """
14540 
 
14541 
  thrift_spec = (
14542 
    None, # 0
3064 chandransh 14543 
    (1, TType.I64, 'orderId', None, None, ), # 1
1113 chandransh 14544 
  )
14545 
 
3064 chandransh 14546 
  def __init__(self, orderId=None,):
14547 
    self.orderId = orderId
1113 chandransh 14548 
 
14549 
  def read(self, iprot):
14550 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14551 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14552 
      return
14553 
    iprot.readStructBegin()
14554 
    while True:
14555 
      (fname, ftype, fid) = iprot.readFieldBegin()
14556 
      if ftype == TType.STOP:
14557 
        break
14558 
      if fid == 1:
14559 
        if ftype == TType.I64:
3064 chandransh 14560 
          self.orderId = iprot.readI64();
1113 chandransh 14561 
        else:
14562 
          iprot.skip(ftype)
14563 
      else:
14564 
        iprot.skip(ftype)
14565 
      iprot.readFieldEnd()
14566 
    iprot.readStructEnd()
14567 
 
14568 
  def write(self, oprot):
14569 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14570 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14571 
      return
3064 chandransh 14572 
    oprot.writeStructBegin('acceptOrder_args')
3431 rajveer 14573 
    if self.orderId is not None:
3064 chandransh 14574 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
14575 
      oprot.writeI64(self.orderId)
1113 chandransh 14576 
      oprot.writeFieldEnd()
14577 
    oprot.writeFieldStop()
14578 
    oprot.writeStructEnd()
14579 
 
3431 rajveer 14580 
  def validate(self):
14581 
    return
14582 
 
14583 
 
1113 chandransh 14584 
  def __repr__(self):
14585 
    L = ['%s=%r' % (key, value)
14586 
      for key, value in self.__dict__.iteritems()]
14587 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14588 
 
14589 
  def __eq__(self, other):
14590 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14591 
 
14592 
  def __ne__(self, other):
14593 
    return not (self == other)
14594 
 
3064 chandransh 14595 
class acceptOrder_result:
1113 chandransh 14596 
  """
14597 
  Attributes:
14598 
   - success
14599 
   - ex
14600 
  """
14601 
 
14602 
  thrift_spec = (
3064 chandransh 14603 
    (0, TType.BOOL, 'success', None, None, ), # 0
1113 chandransh 14604 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
14605 
  )
14606 
 
14607 
  def __init__(self, success=None, ex=None,):
14608 
    self.success = success
14609 
    self.ex = ex
14610 
 
14611 
  def read(self, iprot):
14612 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14613 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14614 
      return
14615 
    iprot.readStructBegin()
14616 
    while True:
14617 
      (fname, ftype, fid) = iprot.readFieldBegin()
14618 
      if ftype == TType.STOP:
14619 
        break
14620 
      if fid == 0:
3064 chandransh 14621 
        if ftype == TType.BOOL:
14622 
          self.success = iprot.readBool();
1113 chandransh 14623 
        else:
14624 
          iprot.skip(ftype)
14625 
      elif fid == 1:
14626 
        if ftype == TType.STRUCT:
14627 
          self.ex = TransactionServiceException()
14628 
          self.ex.read(iprot)
14629 
        else:
14630 
          iprot.skip(ftype)
14631 
      else:
14632 
        iprot.skip(ftype)
14633 
      iprot.readFieldEnd()
14634 
    iprot.readStructEnd()
14635 
 
14636 
  def write(self, oprot):
14637 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14638 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14639 
      return
3064 chandransh 14640 
    oprot.writeStructBegin('acceptOrder_result')
3431 rajveer 14641 
    if self.success is not None:
3064 chandransh 14642 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
14643 
      oprot.writeBool(self.success)
1113 chandransh 14644 
      oprot.writeFieldEnd()
3431 rajveer 14645 
    if self.ex is not None:
1113 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 
 
1113 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 
 
3064 chandransh 14667 
class addBillingDetails_args:
1135 chandransh 14668 
  """
14669 
  Attributes:
3064 chandransh 14670 
   - orderId
14671 
   - invoice_number
4658 mandeep.dh 14672 
   - serialNumber
4283 anupam.sin 14673 
   - itemNumber
7190 amar.kumar 14674 
   - freebieWarehouseId
3064 chandransh 14675 
   - billed_by
4264 rajveer 14676 
   - jacketNumber
4283 anupam.sin 14677 
   - billingType
5110 mandeep.dh 14678 
   - fulfilmentWarehouseId
4763 rajveer 14679 
   - authorize
1135 chandransh 14680 
  """
14681 
 
14682 
  thrift_spec = (
14683 
    None, # 0
3064 chandransh 14684 
    (1, TType.I64, 'orderId', None, None, ), # 1
14685 
    (2, TType.STRING, 'invoice_number', None, None, ), # 2
5411 rajveer 14686 
    (3, TType.LIST, 'serialNumber', (TType.STRING,None), None, ), # 3
14687 
    (4, TType.LIST, 'itemNumber', (TType.STRING,None), None, ), # 4
7190 amar.kumar 14688 
    (5, TType.I64, 'freebieWarehouseId', None, None, ), # 5
14689 
    (6, TType.STRING, 'billed_by', None, None, ), # 6
14690 
    (7, TType.I64, 'jacketNumber', None, None, ), # 7
14691 
    (8, TType.I64, 'billingType', None, None, ), # 8
14692 
    (9, TType.I64, 'fulfilmentWarehouseId', None, None, ), # 9
14693 
    (10, TType.BOOL, 'authorize', None, None, ), # 10
1135 chandransh 14694 
  )
14695 
 
7190 amar.kumar 14696 
  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 14697 
    self.orderId = orderId
14698 
    self.invoice_number = invoice_number
4658 mandeep.dh 14699 
    self.serialNumber = serialNumber
4283 anupam.sin 14700 
    self.itemNumber = itemNumber
7190 amar.kumar 14701 
    self.freebieWarehouseId = freebieWarehouseId
3064 chandransh 14702 
    self.billed_by = billed_by
4264 rajveer 14703 
    self.jacketNumber = jacketNumber
4283 anupam.sin 14704 
    self.billingType = billingType
5110 mandeep.dh 14705 
    self.fulfilmentWarehouseId = fulfilmentWarehouseId
4763 rajveer 14706 
    self.authorize = authorize
1135 chandransh 14707 
 
14708 
  def read(self, iprot):
14709 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14710 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14711 
      return
14712 
    iprot.readStructBegin()
14713 
    while True:
14714 
      (fname, ftype, fid) = iprot.readFieldBegin()
14715 
      if ftype == TType.STOP:
14716 
        break
14717 
      if fid == 1:
14718 
        if ftype == TType.I64:
3064 chandransh 14719 
          self.orderId = iprot.readI64();
1135 chandransh 14720 
        else:
14721 
          iprot.skip(ftype)
14722 
      elif fid == 2:
3064 chandransh 14723 
        if ftype == TType.STRING:
14724 
          self.invoice_number = iprot.readString();
1135 chandransh 14725 
        else:
14726 
          iprot.skip(ftype)
3064 chandransh 14727 
      elif fid == 3:
5411 rajveer 14728 
        if ftype == TType.LIST:
14729 
          self.serialNumber = []
6188 rajveer 14730 
          (_etype270, _size267) = iprot.readListBegin()
14731 
          for _i271 in xrange(_size267):
14732 
            _elem272 = iprot.readString();
14733 
            self.serialNumber.append(_elem272)
5411 rajveer 14734 
          iprot.readListEnd()
3064 chandransh 14735 
        else:
14736 
          iprot.skip(ftype)
14737 
      elif fid == 4:
5411 rajveer 14738 
        if ftype == TType.LIST:
14739 
          self.itemNumber = []
6188 rajveer 14740 
          (_etype276, _size273) = iprot.readListBegin()
14741 
          for _i277 in xrange(_size273):
14742 
            _elem278 = iprot.readString();
14743 
            self.itemNumber.append(_elem278)
5411 rajveer 14744 
          iprot.readListEnd()
3064 chandransh 14745 
        else:
14746 
          iprot.skip(ftype)
14747 
      elif fid == 5:
7190 amar.kumar 14748 
        if ftype == TType.I64:
14749 
          self.freebieWarehouseId = iprot.readI64();
14750 
        else:
14751 
          iprot.skip(ftype)
14752 
      elif fid == 6:
3064 chandransh 14753 
        if ftype == TType.STRING:
4283 anupam.sin 14754 
          self.billed_by = iprot.readString();
3064 chandransh 14755 
        else:
14756 
          iprot.skip(ftype)
7190 amar.kumar 14757 
      elif fid == 7:
3064 chandransh 14758 
        if ftype == TType.I64:
4283 anupam.sin 14759 
          self.jacketNumber = iprot.readI64();
14760 
        else:
14761 
          iprot.skip(ftype)
7190 amar.kumar 14762 
      elif fid == 8:
4283 anupam.sin 14763 
        if ftype == TType.I64:
3064 chandransh 14764 
          self.billingType = iprot.readI64();
14765 
        else:
14766 
          iprot.skip(ftype)
7190 amar.kumar 14767 
      elif fid == 9:
4283 anupam.sin 14768 
        if ftype == TType.I64:
5110 mandeep.dh 14769 
          self.fulfilmentWarehouseId = iprot.readI64();
4283 anupam.sin 14770 
        else:
14771 
          iprot.skip(ftype)
7190 amar.kumar 14772 
      elif fid == 10:
4763 rajveer 14773 
        if ftype == TType.BOOL:
14774 
          self.authorize = iprot.readBool();
14775 
        else:
14776 
          iprot.skip(ftype)
1246 chandransh 14777 
      else:
14778 
        iprot.skip(ftype)
14779 
      iprot.readFieldEnd()
14780 
    iprot.readStructEnd()
14781 
 
14782 
  def write(self, oprot):
14783 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14784 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14785 
      return
4283 anupam.sin 14786 
    oprot.writeStructBegin('addBillingDetails_args')
3431 rajveer 14787 
    if self.orderId is not None:
3064 chandransh 14788 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
14789 
      oprot.writeI64(self.orderId)
1246 chandransh 14790 
      oprot.writeFieldEnd()
4283 anupam.sin 14791 
    if self.invoice_number is not None:
14792 
      oprot.writeFieldBegin('invoice_number', TType.STRING, 2)
14793 
      oprot.writeString(self.invoice_number)
1246 chandransh 14794 
      oprot.writeFieldEnd()
4658 mandeep.dh 14795 
    if self.serialNumber is not None:
5411 rajveer 14796 
      oprot.writeFieldBegin('serialNumber', TType.LIST, 3)
14797 
      oprot.writeListBegin(TType.STRING, len(self.serialNumber))
6188 rajveer 14798 
      for iter279 in self.serialNumber:
14799 
        oprot.writeString(iter279)
5411 rajveer 14800 
      oprot.writeListEnd()
3064 chandransh 14801 
      oprot.writeFieldEnd()
3431 rajveer 14802 
    if self.itemNumber is not None:
5411 rajveer 14803 
      oprot.writeFieldBegin('itemNumber', TType.LIST, 4)
14804 
      oprot.writeListBegin(TType.STRING, len(self.itemNumber))
6188 rajveer 14805 
      for iter280 in self.itemNumber:
14806 
        oprot.writeString(iter280)
5411 rajveer 14807 
      oprot.writeListEnd()
3064 chandransh 14808 
      oprot.writeFieldEnd()
7190 amar.kumar 14809 
    if self.freebieWarehouseId is not None:
14810 
      oprot.writeFieldBegin('freebieWarehouseId', TType.I64, 5)
14811 
      oprot.writeI64(self.freebieWarehouseId)
14812 
      oprot.writeFieldEnd()
4283 anupam.sin 14813 
    if self.billed_by is not None:
7190 amar.kumar 14814 
      oprot.writeFieldBegin('billed_by', TType.STRING, 6)
4283 anupam.sin 14815 
      oprot.writeString(self.billed_by)
3064 chandransh 14816 
      oprot.writeFieldEnd()
4283 anupam.sin 14817 
    if self.jacketNumber is not None:
7190 amar.kumar 14818 
      oprot.writeFieldBegin('jacketNumber', TType.I64, 7)
4283 anupam.sin 14819 
      oprot.writeI64(self.jacketNumber)
14820 
      oprot.writeFieldEnd()
3431 rajveer 14821 
    if self.billingType is not None:
7190 amar.kumar 14822 
      oprot.writeFieldBegin('billingType', TType.I64, 8)
3064 chandransh 14823 
      oprot.writeI64(self.billingType)
14824 
      oprot.writeFieldEnd()
5110 mandeep.dh 14825 
    if self.fulfilmentWarehouseId is not None:
7190 amar.kumar 14826 
      oprot.writeFieldBegin('fulfilmentWarehouseId', TType.I64, 9)
5110 mandeep.dh 14827 
      oprot.writeI64(self.fulfilmentWarehouseId)
4283 anupam.sin 14828 
      oprot.writeFieldEnd()
4763 rajveer 14829 
    if self.authorize is not None:
7190 amar.kumar 14830 
      oprot.writeFieldBegin('authorize', TType.BOOL, 10)
4763 rajveer 14831 
      oprot.writeBool(self.authorize)
14832 
      oprot.writeFieldEnd()
1246 chandransh 14833 
    oprot.writeFieldStop()
14834 
    oprot.writeStructEnd()
14835 
 
3431 rajveer 14836 
  def validate(self):
14837 
    return
14838 
 
14839 
 
1246 chandransh 14840 
  def __repr__(self):
14841 
    L = ['%s=%r' % (key, value)
14842 
      for key, value in self.__dict__.iteritems()]
14843 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14844 
 
14845 
  def __eq__(self, other):
14846 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14847 
 
14848 
  def __ne__(self, other):
14849 
    return not (self == other)
14850 
 
4283 anupam.sin 14851 
class addBillingDetails_result:
1246 chandransh 14852 
  """
14853 
  Attributes:
3064 chandransh 14854 
   - success
1246 chandransh 14855 
   - ex
14856 
  """
14857 
 
14858 
  thrift_spec = (
3064 chandransh 14859 
    (0, TType.BOOL, 'success', None, None, ), # 0
1246 chandransh 14860 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
14861 
  )
14862 
 
3064 chandransh 14863 
  def __init__(self, success=None, ex=None,):
14864 
    self.success = success
1246 chandransh 14865 
    self.ex = ex
14866 
 
14867 
  def read(self, iprot):
14868 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14869 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14870 
      return
14871 
    iprot.readStructBegin()
14872 
    while True:
14873 
      (fname, ftype, fid) = iprot.readFieldBegin()
14874 
      if ftype == TType.STOP:
14875 
        break
3064 chandransh 14876 
      if fid == 0:
14877 
        if ftype == TType.BOOL:
14878 
          self.success = iprot.readBool();
14879 
        else:
14880 
          iprot.skip(ftype)
14881 
      elif fid == 1:
1246 chandransh 14882 
        if ftype == TType.STRUCT:
14883 
          self.ex = TransactionServiceException()
14884 
          self.ex.read(iprot)
14885 
        else:
14886 
          iprot.skip(ftype)
14887 
      else:
14888 
        iprot.skip(ftype)
14889 
      iprot.readFieldEnd()
14890 
    iprot.readStructEnd()
14891 
 
14892 
  def write(self, oprot):
14893 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14894 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14895 
      return
4283 anupam.sin 14896 
    oprot.writeStructBegin('addBillingDetails_result')
3431 rajveer 14897 
    if self.success is not None:
3064 chandransh 14898 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
14899 
      oprot.writeBool(self.success)
14900 
      oprot.writeFieldEnd()
3431 rajveer 14901 
    if self.ex is not None:
1246 chandransh 14902 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
14903 
      self.ex.write(oprot)
14904 
      oprot.writeFieldEnd()
14905 
    oprot.writeFieldStop()
14906 
    oprot.writeStructEnd()
14907 
 
3431 rajveer 14908 
  def validate(self):
14909 
    return
14910 
 
14911 
 
1246 chandransh 14912 
  def __repr__(self):
14913 
    L = ['%s=%r' % (key, value)
14914 
      for key, value in self.__dict__.iteritems()]
14915 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14916 
 
14917 
  def __eq__(self, other):
14918 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14919 
 
14920 
  def __ne__(self, other):
14921 
    return not (self == other)
14922 
 
4579 rajveer 14923 
class addInvoiceNumber_args:
14924 
  """
14925 
  Attributes:
14926 
   - orderId
14927 
   - invoiceNumber
4763 rajveer 14928 
   - color
6756 amar.kumar 14929 
   - serialNumber
14930 
   - itemNumber
4579 rajveer 14931 
  """
14932 
 
14933 
  thrift_spec = (
14934 
    None, # 0
14935 
    (1, TType.I64, 'orderId', None, None, ), # 1
14936 
    (2, TType.STRING, 'invoiceNumber', None, None, ), # 2
4763 rajveer 14937 
    (3, TType.STRING, 'color', None, None, ), # 3
6756 amar.kumar 14938 
    (4, TType.STRING, 'serialNumber', None, None, ), # 4
14939 
    (5, TType.STRING, 'itemNumber', None, None, ), # 5
4579 rajveer 14940 
  )
14941 
 
6756 amar.kumar 14942 
  def __init__(self, orderId=None, invoiceNumber=None, color=None, serialNumber=None, itemNumber=None,):
4579 rajveer 14943 
    self.orderId = orderId
14944 
    self.invoiceNumber = invoiceNumber
4763 rajveer 14945 
    self.color = color
6756 amar.kumar 14946 
    self.serialNumber = serialNumber
14947 
    self.itemNumber = itemNumber
4579 rajveer 14948 
 
14949 
  def read(self, iprot):
14950 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14951 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14952 
      return
14953 
    iprot.readStructBegin()
14954 
    while True:
14955 
      (fname, ftype, fid) = iprot.readFieldBegin()
14956 
      if ftype == TType.STOP:
14957 
        break
14958 
      if fid == 1:
14959 
        if ftype == TType.I64:
14960 
          self.orderId = iprot.readI64();
14961 
        else:
14962 
          iprot.skip(ftype)
14963 
      elif fid == 2:
14964 
        if ftype == TType.STRING:
14965 
          self.invoiceNumber = iprot.readString();
14966 
        else:
14967 
          iprot.skip(ftype)
4763 rajveer 14968 
      elif fid == 3:
14969 
        if ftype == TType.STRING:
14970 
          self.color = iprot.readString();
14971 
        else:
14972 
          iprot.skip(ftype)
6756 amar.kumar 14973 
      elif fid == 4:
14974 
        if ftype == TType.STRING:
14975 
          self.serialNumber = iprot.readString();
14976 
        else:
14977 
          iprot.skip(ftype)
14978 
      elif fid == 5:
14979 
        if ftype == TType.STRING:
14980 
          self.itemNumber = iprot.readString();
14981 
        else:
14982 
          iprot.skip(ftype)
4579 rajveer 14983 
      else:
14984 
        iprot.skip(ftype)
14985 
      iprot.readFieldEnd()
14986 
    iprot.readStructEnd()
14987 
 
14988 
  def write(self, oprot):
14989 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14990 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14991 
      return
14992 
    oprot.writeStructBegin('addInvoiceNumber_args')
14993 
    if self.orderId is not None:
14994 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
14995 
      oprot.writeI64(self.orderId)
14996 
      oprot.writeFieldEnd()
14997 
    if self.invoiceNumber is not None:
14998 
      oprot.writeFieldBegin('invoiceNumber', TType.STRING, 2)
14999 
      oprot.writeString(self.invoiceNumber)
15000 
      oprot.writeFieldEnd()
4763 rajveer 15001 
    if self.color is not None:
15002 
      oprot.writeFieldBegin('color', TType.STRING, 3)
15003 
      oprot.writeString(self.color)
15004 
      oprot.writeFieldEnd()
6756 amar.kumar 15005 
    if self.serialNumber is not None:
15006 
      oprot.writeFieldBegin('serialNumber', TType.STRING, 4)
15007 
      oprot.writeString(self.serialNumber)
15008 
      oprot.writeFieldEnd()
15009 
    if self.itemNumber is not None:
15010 
      oprot.writeFieldBegin('itemNumber', TType.STRING, 5)
15011 
      oprot.writeString(self.itemNumber)
15012 
      oprot.writeFieldEnd()
4579 rajveer 15013 
    oprot.writeFieldStop()
15014 
    oprot.writeStructEnd()
15015 
 
15016 
  def validate(self):
15017 
    return
15018 
 
15019 
 
15020 
  def __repr__(self):
15021 
    L = ['%s=%r' % (key, value)
15022 
      for key, value in self.__dict__.iteritems()]
15023 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15024 
 
15025 
  def __eq__(self, other):
15026 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15027 
 
15028 
  def __ne__(self, other):
15029 
    return not (self == other)
15030 
 
15031 
class addInvoiceNumber_result:
15032 
  """
15033 
  Attributes:
15034 
   - ex
15035 
  """
15036 
 
15037 
  thrift_spec = (
15038 
    None, # 0
15039 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
15040 
  )
15041 
 
15042 
  def __init__(self, ex=None,):
15043 
    self.ex = ex
15044 
 
15045 
  def read(self, iprot):
15046 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15047 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15048 
      return
15049 
    iprot.readStructBegin()
15050 
    while True:
15051 
      (fname, ftype, fid) = iprot.readFieldBegin()
15052 
      if ftype == TType.STOP:
15053 
        break
15054 
      if fid == 1:
15055 
        if ftype == TType.STRUCT:
15056 
          self.ex = TransactionServiceException()
15057 
          self.ex.read(iprot)
15058 
        else:
15059 
          iprot.skip(ftype)
15060 
      else:
15061 
        iprot.skip(ftype)
15062 
      iprot.readFieldEnd()
15063 
    iprot.readStructEnd()
15064 
 
15065 
  def write(self, oprot):
15066 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15067 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15068 
      return
15069 
    oprot.writeStructBegin('addInvoiceNumber_result')
15070 
    if self.ex is not None:
15071 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
15072 
      self.ex.write(oprot)
15073 
      oprot.writeFieldEnd()
15074 
    oprot.writeFieldStop()
15075 
    oprot.writeStructEnd()
15076 
 
15077 
  def validate(self):
15078 
    return
15079 
 
15080 
 
15081 
  def __repr__(self):
15082 
    L = ['%s=%r' % (key, value)
15083 
      for key, value in self.__dict__.iteritems()]
15084 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15085 
 
15086 
  def __eq__(self, other):
15087 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15088 
 
15089 
  def __ne__(self, other):
15090 
    return not (self == other)
15091 
 
4910 phani.kuma 15092 
class markOrdersAsShippedFromWarehouse_args:
1408 ankur.sing 15093 
  """
15094 
  Attributes:
3064 chandransh 15095 
   - warehouseId
1408 ankur.sing 15096 
   - providerId
3064 chandransh 15097 
   - cod
4910 phani.kuma 15098 
   - orderIds
1408 ankur.sing 15099 
  """
15100 
 
15101 
  thrift_spec = (
15102 
    None, # 0
3064 chandransh 15103 
    (1, TType.I64, 'warehouseId', None, None, ), # 1
15104 
    (2, TType.I64, 'providerId', None, None, ), # 2
15105 
    (3, TType.BOOL, 'cod', None, None, ), # 3
4910 phani.kuma 15106 
    (4, TType.LIST, 'orderIds', (TType.I64,None), None, ), # 4
1408 ankur.sing 15107 
  )
15108 
 
4910 phani.kuma 15109 
  def __init__(self, warehouseId=None, providerId=None, cod=None, orderIds=None,):
3064 chandransh 15110 
    self.warehouseId = warehouseId
1408 ankur.sing 15111 
    self.providerId = providerId
3064 chandransh 15112 
    self.cod = cod
4910 phani.kuma 15113 
    self.orderIds = orderIds
1408 ankur.sing 15114 
 
15115 
  def read(self, iprot):
15116 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15117 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15118 
      return
15119 
    iprot.readStructBegin()
15120 
    while True:
15121 
      (fname, ftype, fid) = iprot.readFieldBegin()
15122 
      if ftype == TType.STOP:
15123 
        break
15124 
      if fid == 1:
15125 
        if ftype == TType.I64:
3064 chandransh 15126 
          self.warehouseId = iprot.readI64();
1408 ankur.sing 15127 
        else:
15128 
          iprot.skip(ftype)
15129 
      elif fid == 2:
15130 
        if ftype == TType.I64:
3064 chandransh 15131 
          self.providerId = iprot.readI64();
1408 ankur.sing 15132 
        else:
15133 
          iprot.skip(ftype)
3064 chandransh 15134 
      elif fid == 3:
15135 
        if ftype == TType.BOOL:
15136 
          self.cod = iprot.readBool();
15137 
        else:
15138 
          iprot.skip(ftype)
4910 phani.kuma 15139 
      elif fid == 4:
15140 
        if ftype == TType.LIST:
15141 
          self.orderIds = []
6188 rajveer 15142 
          (_etype284, _size281) = iprot.readListBegin()
15143 
          for _i285 in xrange(_size281):
15144 
            _elem286 = iprot.readI64();
15145 
            self.orderIds.append(_elem286)
4910 phani.kuma 15146 
          iprot.readListEnd()
15147 
        else:
15148 
          iprot.skip(ftype)
1408 ankur.sing 15149 
      else:
15150 
        iprot.skip(ftype)
15151 
      iprot.readFieldEnd()
15152 
    iprot.readStructEnd()
15153 
 
15154 
  def write(self, oprot):
15155 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15156 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15157 
      return
4910 phani.kuma 15158 
    oprot.writeStructBegin('markOrdersAsShippedFromWarehouse_args')
3431 rajveer 15159 
    if self.warehouseId is not None:
3064 chandransh 15160 
      oprot.writeFieldBegin('warehouseId', TType.I64, 1)
15161 
      oprot.writeI64(self.warehouseId)
15162 
      oprot.writeFieldEnd()
3431 rajveer 15163 
    if self.providerId is not None:
3064 chandransh 15164 
      oprot.writeFieldBegin('providerId', TType.I64, 2)
1408 ankur.sing 15165 
      oprot.writeI64(self.providerId)
15166 
      oprot.writeFieldEnd()
3431 rajveer 15167 
    if self.cod is not None:
3064 chandransh 15168 
      oprot.writeFieldBegin('cod', TType.BOOL, 3)
15169 
      oprot.writeBool(self.cod)
1408 ankur.sing 15170 
      oprot.writeFieldEnd()
4910 phani.kuma 15171 
    if self.orderIds is not None:
15172 
      oprot.writeFieldBegin('orderIds', TType.LIST, 4)
15173 
      oprot.writeListBegin(TType.I64, len(self.orderIds))
6188 rajveer 15174 
      for iter287 in self.orderIds:
15175 
        oprot.writeI64(iter287)
4910 phani.kuma 15176 
      oprot.writeListEnd()
15177 
      oprot.writeFieldEnd()
1408 ankur.sing 15178 
    oprot.writeFieldStop()
15179 
    oprot.writeStructEnd()
15180 
 
3431 rajveer 15181 
  def validate(self):
15182 
    return
15183 
 
15184 
 
1408 ankur.sing 15185 
  def __repr__(self):
15186 
    L = ['%s=%r' % (key, value)
15187 
      for key, value in self.__dict__.iteritems()]
15188 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15189 
 
15190 
  def __eq__(self, other):
15191 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15192 
 
15193 
  def __ne__(self, other):
15194 
    return not (self == other)
15195 
 
4910 phani.kuma 15196 
class markOrdersAsShippedFromWarehouse_result:
1408 ankur.sing 15197 
  """
15198 
  Attributes:
15199 
   - success
3064 chandransh 15200 
   - ex
1408 ankur.sing 15201 
  """
15202 
 
15203 
  thrift_spec = (
3064 chandransh 15204 
    (0, TType.BOOL, 'success', None, None, ), # 0
15205 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
1408 ankur.sing 15206 
  )
15207 
 
3064 chandransh 15208 
  def __init__(self, success=None, ex=None,):
1408 ankur.sing 15209 
    self.success = success
3064 chandransh 15210 
    self.ex = ex
1408 ankur.sing 15211 
 
15212 
  def read(self, iprot):
15213 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15214 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15215 
      return
15216 
    iprot.readStructBegin()
15217 
    while True:
15218 
      (fname, ftype, fid) = iprot.readFieldBegin()
15219 
      if ftype == TType.STOP:
15220 
        break
15221 
      if fid == 0:
3064 chandransh 15222 
        if ftype == TType.BOOL:
15223 
          self.success = iprot.readBool();
1408 ankur.sing 15224 
        else:
15225 
          iprot.skip(ftype)
3064 chandransh 15226 
      elif fid == 1:
15227 
        if ftype == TType.STRUCT:
15228 
          self.ex = TransactionServiceException()
15229 
          self.ex.read(iprot)
15230 
        else:
15231 
          iprot.skip(ftype)
1408 ankur.sing 15232 
      else:
15233 
        iprot.skip(ftype)
15234 
      iprot.readFieldEnd()
15235 
    iprot.readStructEnd()
15236 
 
15237 
  def write(self, oprot):
15238 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15239 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15240 
      return
4910 phani.kuma 15241 
    oprot.writeStructBegin('markOrdersAsShippedFromWarehouse_result')
3431 rajveer 15242 
    if self.success is not None:
3064 chandransh 15243 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
15244 
      oprot.writeBool(self.success)
1408 ankur.sing 15245 
      oprot.writeFieldEnd()
3431 rajveer 15246 
    if self.ex is not None:
3064 chandransh 15247 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
15248 
      self.ex.write(oprot)
15249 
      oprot.writeFieldEnd()
1408 ankur.sing 15250 
    oprot.writeFieldStop()
15251 
    oprot.writeStructEnd()
15252 
 
3431 rajveer 15253 
  def validate(self):
15254 
    return
15255 
 
15256 
 
1408 ankur.sing 15257 
  def __repr__(self):
15258 
    L = ['%s=%r' % (key, value)
15259 
      for key, value in self.__dict__.iteritems()]
15260 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15261 
 
15262 
  def __eq__(self, other):
15263 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15264 
 
15265 
  def __ne__(self, other):
15266 
    return not (self == other)
15267 
 
5676 rajveer 15268 
class markOrdersAsReturnedFromStore_args:
15269 
  """
15270 
  Attributes:
15271 
   - providerId
15272 
   - orderIds
5713 rajveer 15273 
   - awbs
5676 rajveer 15274 
  """
15275 
 
15276 
  thrift_spec = (
15277 
    None, # 0
15278 
    (1, TType.I64, 'providerId', None, None, ), # 1
15279 
    (2, TType.LIST, 'orderIds', (TType.I64,None), None, ), # 2
5713 rajveer 15280 
    (3, TType.LIST, 'awbs', (TType.STRING,None), None, ), # 3
5676 rajveer 15281 
  )
15282 
 
5713 rajveer 15283 
  def __init__(self, providerId=None, orderIds=None, awbs=None,):
5676 rajveer 15284 
    self.providerId = providerId
15285 
    self.orderIds = orderIds
5713 rajveer 15286 
    self.awbs = awbs
5676 rajveer 15287 
 
15288 
  def read(self, iprot):
15289 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15290 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15291 
      return
15292 
    iprot.readStructBegin()
15293 
    while True:
15294 
      (fname, ftype, fid) = iprot.readFieldBegin()
15295 
      if ftype == TType.STOP:
15296 
        break
15297 
      if fid == 1:
15298 
        if ftype == TType.I64:
15299 
          self.providerId = iprot.readI64();
15300 
        else:
15301 
          iprot.skip(ftype)
15302 
      elif fid == 2:
15303 
        if ftype == TType.LIST:
15304 
          self.orderIds = []
6188 rajveer 15305 
          (_etype291, _size288) = iprot.readListBegin()
15306 
          for _i292 in xrange(_size288):
15307 
            _elem293 = iprot.readI64();
15308 
            self.orderIds.append(_elem293)
5676 rajveer 15309 
          iprot.readListEnd()
15310 
        else:
15311 
          iprot.skip(ftype)
5713 rajveer 15312 
      elif fid == 3:
15313 
        if ftype == TType.LIST:
15314 
          self.awbs = []
6188 rajveer 15315 
          (_etype297, _size294) = iprot.readListBegin()
15316 
          for _i298 in xrange(_size294):
15317 
            _elem299 = iprot.readString();
15318 
            self.awbs.append(_elem299)
5713 rajveer 15319 
          iprot.readListEnd()
15320 
        else:
15321 
          iprot.skip(ftype)
5676 rajveer 15322 
      else:
15323 
        iprot.skip(ftype)
15324 
      iprot.readFieldEnd()
15325 
    iprot.readStructEnd()
15326 
 
15327 
  def write(self, oprot):
15328 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15329 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15330 
      return
15331 
    oprot.writeStructBegin('markOrdersAsReturnedFromStore_args')
15332 
    if self.providerId is not None:
15333 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
15334 
      oprot.writeI64(self.providerId)
15335 
      oprot.writeFieldEnd()
15336 
    if self.orderIds is not None:
15337 
      oprot.writeFieldBegin('orderIds', TType.LIST, 2)
15338 
      oprot.writeListBegin(TType.I64, len(self.orderIds))
6188 rajveer 15339 
      for iter300 in self.orderIds:
15340 
        oprot.writeI64(iter300)
5676 rajveer 15341 
      oprot.writeListEnd()
15342 
      oprot.writeFieldEnd()
5713 rajveer 15343 
    if self.awbs is not None:
15344 
      oprot.writeFieldBegin('awbs', TType.LIST, 3)
15345 
      oprot.writeListBegin(TType.STRING, len(self.awbs))
6188 rajveer 15346 
      for iter301 in self.awbs:
15347 
        oprot.writeString(iter301)
5713 rajveer 15348 
      oprot.writeListEnd()
15349 
      oprot.writeFieldEnd()
5676 rajveer 15350 
    oprot.writeFieldStop()
15351 
    oprot.writeStructEnd()
15352 
 
15353 
  def validate(self):
15354 
    return
15355 
 
15356 
 
15357 
  def __repr__(self):
15358 
    L = ['%s=%r' % (key, value)
15359 
      for key, value in self.__dict__.iteritems()]
15360 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15361 
 
15362 
  def __eq__(self, other):
15363 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15364 
 
15365 
  def __ne__(self, other):
15366 
    return not (self == other)
15367 
 
15368 
class markOrdersAsReturnedFromStore_result:
15369 
  """
15370 
  Attributes:
15371 
   - success
15372 
   - ex
15373 
  """
15374 
 
15375 
  thrift_spec = (
15376 
    (0, TType.BOOL, 'success', None, None, ), # 0
15377 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
15378 
  )
15379 
 
15380 
  def __init__(self, success=None, ex=None,):
15381 
    self.success = success
15382 
    self.ex = ex
15383 
 
15384 
  def read(self, iprot):
15385 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15386 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15387 
      return
15388 
    iprot.readStructBegin()
15389 
    while True:
15390 
      (fname, ftype, fid) = iprot.readFieldBegin()
15391 
      if ftype == TType.STOP:
15392 
        break
15393 
      if fid == 0:
15394 
        if ftype == TType.BOOL:
15395 
          self.success = iprot.readBool();
15396 
        else:
15397 
          iprot.skip(ftype)
15398 
      elif fid == 1:
15399 
        if ftype == TType.STRUCT:
15400 
          self.ex = TransactionServiceException()
15401 
          self.ex.read(iprot)
15402 
        else:
15403 
          iprot.skip(ftype)
15404 
      else:
15405 
        iprot.skip(ftype)
15406 
      iprot.readFieldEnd()
15407 
    iprot.readStructEnd()
15408 
 
15409 
  def write(self, oprot):
15410 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15411 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15412 
      return
15413 
    oprot.writeStructBegin('markOrdersAsReturnedFromStore_result')
15414 
    if self.success is not None:
15415 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
15416 
      oprot.writeBool(self.success)
15417 
      oprot.writeFieldEnd()
15418 
    if self.ex is not None:
15419 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
15420 
      self.ex.write(oprot)
15421 
      oprot.writeFieldEnd()
15422 
    oprot.writeFieldStop()
15423 
    oprot.writeStructEnd()
15424 
 
15425 
  def validate(self):
15426 
    return
15427 
 
15428 
 
15429 
  def __repr__(self):
15430 
    L = ['%s=%r' % (key, value)
15431 
      for key, value in self.__dict__.iteritems()]
15432 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15433 
 
15434 
  def __eq__(self, other):
15435 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15436 
 
15437 
  def __ne__(self, other):
15438 
    return not (self == other)
15439 
 
4910 phani.kuma 15440 
class markOrdersAsPickedUp_args:
4410 rajveer 15441 
  """
15442 
  Attributes:
15443 
   - providerId
4910 phani.kuma 15444 
   - pickupDetails
4410 rajveer 15445 
  """
15446 
 
15447 
  thrift_spec = (
15448 
    None, # 0
4910 phani.kuma 15449 
    (1, TType.I64, 'providerId', None, None, ), # 1
15450 
    (2, TType.MAP, 'pickupDetails', (TType.STRING,None,TType.STRING,None), None, ), # 2
4410 rajveer 15451 
  )
15452 
 
4910 phani.kuma 15453 
  def __init__(self, providerId=None, pickupDetails=None,):
4410 rajveer 15454 
    self.providerId = providerId
4910 phani.kuma 15455 
    self.pickupDetails = pickupDetails
4410 rajveer 15456 
 
15457 
  def read(self, iprot):
15458 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15459 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15460 
      return
15461 
    iprot.readStructBegin()
15462 
    while True:
15463 
      (fname, ftype, fid) = iprot.readFieldBegin()
15464 
      if ftype == TType.STOP:
15465 
        break
15466 
      if fid == 1:
15467 
        if ftype == TType.I64:
4910 phani.kuma 15468 
          self.providerId = iprot.readI64();
4410 rajveer 15469 
        else:
15470 
          iprot.skip(ftype)
15471 
      elif fid == 2:
4910 phani.kuma 15472 
        if ftype == TType.MAP:
15473 
          self.pickupDetails = {}
6188 rajveer 15474 
          (_ktype303, _vtype304, _size302 ) = iprot.readMapBegin()
15475 
          for _i306 in xrange(_size302):
15476 
            _key307 = iprot.readString();
15477 
            _val308 = iprot.readString();
15478 
            self.pickupDetails[_key307] = _val308
4910 phani.kuma 15479 
          iprot.readMapEnd()
4410 rajveer 15480 
        else:
15481 
          iprot.skip(ftype)
15482 
      else:
15483 
        iprot.skip(ftype)
15484 
      iprot.readFieldEnd()
15485 
    iprot.readStructEnd()
15486 
 
15487 
  def write(self, oprot):
15488 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15489 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15490 
      return
4910 phani.kuma 15491 
    oprot.writeStructBegin('markOrdersAsPickedUp_args')
4410 rajveer 15492 
    if self.providerId is not None:
4910 phani.kuma 15493 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
4410 rajveer 15494 
      oprot.writeI64(self.providerId)
15495 
      oprot.writeFieldEnd()
4910 phani.kuma 15496 
    if self.pickupDetails is not None:
15497 
      oprot.writeFieldBegin('pickupDetails', TType.MAP, 2)
15498 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.pickupDetails))
6188 rajveer 15499 
      for kiter309,viter310 in self.pickupDetails.items():
15500 
        oprot.writeString(kiter309)
15501 
        oprot.writeString(viter310)
4910 phani.kuma 15502 
      oprot.writeMapEnd()
4410 rajveer 15503 
      oprot.writeFieldEnd()
15504 
    oprot.writeFieldStop()
15505 
    oprot.writeStructEnd()
15506 
 
15507 
  def validate(self):
15508 
    return
15509 
 
15510 
 
15511 
  def __repr__(self):
15512 
    L = ['%s=%r' % (key, value)
15513 
      for key, value in self.__dict__.iteritems()]
15514 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15515 
 
15516 
  def __eq__(self, other):
15517 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15518 
 
15519 
  def __ne__(self, other):
15520 
    return not (self == other)
15521 
 
4910 phani.kuma 15522 
class markOrdersAsPickedUp_result:
4410 rajveer 15523 
  """
15524 
  Attributes:
15525 
   - ex
15526 
  """
15527 
 
15528 
  thrift_spec = (
4910 phani.kuma 15529 
    None, # 0
4410 rajveer 15530 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
15531 
  )
15532 
 
4910 phani.kuma 15533 
  def __init__(self, ex=None,):
4410 rajveer 15534 
    self.ex = ex
15535 
 
15536 
  def read(self, iprot):
15537 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15538 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15539 
      return
15540 
    iprot.readStructBegin()
15541 
    while True:
15542 
      (fname, ftype, fid) = iprot.readFieldBegin()
15543 
      if ftype == TType.STOP:
15544 
        break
4910 phani.kuma 15545 
      if fid == 1:
4410 rajveer 15546 
        if ftype == TType.STRUCT:
15547 
          self.ex = TransactionServiceException()
15548 
          self.ex.read(iprot)
15549 
        else:
15550 
          iprot.skip(ftype)
15551 
      else:
15552 
        iprot.skip(ftype)
15553 
      iprot.readFieldEnd()
15554 
    iprot.readStructEnd()
15555 
 
15556 
  def write(self, oprot):
15557 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15558 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15559 
      return
4910 phani.kuma 15560 
    oprot.writeStructBegin('markOrdersAsPickedUp_result')
4410 rajveer 15561 
    if self.ex is not None:
15562 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
15563 
      self.ex.write(oprot)
15564 
      oprot.writeFieldEnd()
15565 
    oprot.writeFieldStop()
15566 
    oprot.writeStructEnd()
15567 
 
15568 
  def validate(self):
15569 
    return
15570 
 
15571 
 
15572 
  def __repr__(self):
15573 
    L = ['%s=%r' % (key, value)
15574 
      for key, value in self.__dict__.iteritems()]
15575 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15576 
 
15577 
  def __eq__(self, other):
15578 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15579 
 
15580 
  def __ne__(self, other):
15581 
    return not (self == other)
15582 
 
4910 phani.kuma 15583 
class getOrdersNotPickedUp_args:
304 ashish 15584 
  """
15585 
  Attributes:
3064 chandransh 15586 
   - providerId
304 ashish 15587 
  """
94 ashish 15588 
 
304 ashish 15589 
  thrift_spec = (
15590 
    None, # 0
3064 chandransh 15591 
    (1, TType.I64, 'providerId', None, None, ), # 1
304 ashish 15592 
  )
15593 
 
4910 phani.kuma 15594 
  def __init__(self, providerId=None,):
3064 chandransh 15595 
    self.providerId = providerId
304 ashish 15596 
 
15597 
  def read(self, iprot):
15598 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15599 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15600 
      return
15601 
    iprot.readStructBegin()
15602 
    while True:
15603 
      (fname, ftype, fid) = iprot.readFieldBegin()
15604 
      if ftype == TType.STOP:
15605 
        break
15606 
      if fid == 1:
15607 
        if ftype == TType.I64:
3064 chandransh 15608 
          self.providerId = iprot.readI64();
304 ashish 15609 
        else:
15610 
          iprot.skip(ftype)
15611 
      else:
15612 
        iprot.skip(ftype)
15613 
      iprot.readFieldEnd()
15614 
    iprot.readStructEnd()
15615 
 
15616 
  def write(self, oprot):
15617 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15618 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15619 
      return
4910 phani.kuma 15620 
    oprot.writeStructBegin('getOrdersNotPickedUp_args')
3431 rajveer 15621 
    if self.providerId is not None:
3064 chandransh 15622 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
15623 
      oprot.writeI64(self.providerId)
304 ashish 15624 
      oprot.writeFieldEnd()
15625 
    oprot.writeFieldStop()
15626 
    oprot.writeStructEnd()
15627 
 
3431 rajveer 15628 
  def validate(self):
15629 
    return
15630 
 
15631 
 
304 ashish 15632 
  def __repr__(self):
15633 
    L = ['%s=%r' % (key, value)
15634 
      for key, value in self.__dict__.iteritems()]
15635 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15636 
 
15637 
  def __eq__(self, other):
15638 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15639 
 
15640 
  def __ne__(self, other):
15641 
    return not (self == other)
15642 
 
4910 phani.kuma 15643 
class getOrdersNotPickedUp_result:
304 ashish 15644 
  """
15645 
  Attributes:
15646 
   - success
15647 
  """
15648 
 
15649 
  thrift_spec = (
3064 chandransh 15650 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
304 ashish 15651 
  )
15652 
 
4910 phani.kuma 15653 
  def __init__(self, success=None,):
304 ashish 15654 
    self.success = success
15655 
 
15656 
  def read(self, iprot):
15657 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15658 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15659 
      return
15660 
    iprot.readStructBegin()
15661 
    while True:
15662 
      (fname, ftype, fid) = iprot.readFieldBegin()
15663 
      if ftype == TType.STOP:
15664 
        break
15665 
      if fid == 0:
15666 
        if ftype == TType.LIST:
15667 
          self.success = []
6188 rajveer 15668 
          (_etype314, _size311) = iprot.readListBegin()
15669 
          for _i315 in xrange(_size311):
15670 
            _elem316 = Order()
15671 
            _elem316.read(iprot)
15672 
            self.success.append(_elem316)
304 ashish 15673 
          iprot.readListEnd()
15674 
        else:
15675 
          iprot.skip(ftype)
15676 
      else:
15677 
        iprot.skip(ftype)
15678 
      iprot.readFieldEnd()
15679 
    iprot.readStructEnd()
15680 
 
15681 
  def write(self, oprot):
15682 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15683 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15684 
      return
4910 phani.kuma 15685 
    oprot.writeStructBegin('getOrdersNotPickedUp_result')
3431 rajveer 15686 
    if self.success is not None:
304 ashish 15687 
      oprot.writeFieldBegin('success', TType.LIST, 0)
15688 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 15689 
      for iter317 in self.success:
15690 
        iter317.write(oprot)
304 ashish 15691 
      oprot.writeListEnd()
15692 
      oprot.writeFieldEnd()
15693 
    oprot.writeFieldStop()
15694 
    oprot.writeStructEnd()
15695 
 
3431 rajveer 15696 
  def validate(self):
15697 
    return
15698 
 
15699 
 
304 ashish 15700 
  def __repr__(self):
15701 
    L = ['%s=%r' % (key, value)
15702 
      for key, value in self.__dict__.iteritems()]
15703 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15704 
 
15705 
  def __eq__(self, other):
15706 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15707 
 
15708 
  def __ne__(self, other):
15709 
    return not (self == other)
15710 
 
3064 chandransh 15711 
class markOrdersAsDelivered_args:
304 ashish 15712 
  """
15713 
  Attributes:
3064 chandransh 15714 
   - providerId
15715 
   - deliveredOrders
304 ashish 15716 
  """
15717 
 
15718 
  thrift_spec = (
15719 
    None, # 0
3064 chandransh 15720 
    (1, TType.I64, 'providerId', None, None, ), # 1
15721 
    (2, TType.MAP, 'deliveredOrders', (TType.STRING,None,TType.STRING,None), None, ), # 2
304 ashish 15722 
  )
15723 
 
3064 chandransh 15724 
  def __init__(self, providerId=None, deliveredOrders=None,):
15725 
    self.providerId = providerId
15726 
    self.deliveredOrders = deliveredOrders
304 ashish 15727 
 
15728 
  def read(self, iprot):
15729 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15730 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15731 
      return
15732 
    iprot.readStructBegin()
15733 
    while True:
15734 
      (fname, ftype, fid) = iprot.readFieldBegin()
15735 
      if ftype == TType.STOP:
15736 
        break
15737 
      if fid == 1:
15738 
        if ftype == TType.I64:
3064 chandransh 15739 
          self.providerId = iprot.readI64();
304 ashish 15740 
        else:
15741 
          iprot.skip(ftype)
15742 
      elif fid == 2:
3064 chandransh 15743 
        if ftype == TType.MAP:
15744 
          self.deliveredOrders = {}
6188 rajveer 15745 
          (_ktype319, _vtype320, _size318 ) = iprot.readMapBegin()
15746 
          for _i322 in xrange(_size318):
15747 
            _key323 = iprot.readString();
15748 
            _val324 = iprot.readString();
15749 
            self.deliveredOrders[_key323] = _val324
3064 chandransh 15750 
          iprot.readMapEnd()
304 ashish 15751 
        else:
15752 
          iprot.skip(ftype)
15753 
      else:
15754 
        iprot.skip(ftype)
15755 
      iprot.readFieldEnd()
15756 
    iprot.readStructEnd()
15757 
 
15758 
  def write(self, oprot):
15759 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15760 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15761 
      return
3064 chandransh 15762 
    oprot.writeStructBegin('markOrdersAsDelivered_args')
3431 rajveer 15763 
    if self.providerId is not None:
3064 chandransh 15764 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
15765 
      oprot.writeI64(self.providerId)
304 ashish 15766 
      oprot.writeFieldEnd()
3431 rajveer 15767 
    if self.deliveredOrders is not None:
3064 chandransh 15768 
      oprot.writeFieldBegin('deliveredOrders', TType.MAP, 2)
15769 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.deliveredOrders))
6188 rajveer 15770 
      for kiter325,viter326 in self.deliveredOrders.items():
15771 
        oprot.writeString(kiter325)
15772 
        oprot.writeString(viter326)
3064 chandransh 15773 
      oprot.writeMapEnd()
304 ashish 15774 
      oprot.writeFieldEnd()
15775 
    oprot.writeFieldStop()
15776 
    oprot.writeStructEnd()
15777 
 
3431 rajveer 15778 
  def validate(self):
15779 
    return
15780 
 
15781 
 
304 ashish 15782 
  def __repr__(self):
15783 
    L = ['%s=%r' % (key, value)
15784 
      for key, value in self.__dict__.iteritems()]
15785 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15786 
 
15787 
  def __eq__(self, other):
15788 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15789 
 
15790 
  def __ne__(self, other):
15791 
    return not (self == other)
15792 
 
3064 chandransh 15793 
class markOrdersAsDelivered_result:
15794 
  """
15795 
  Attributes:
15796 
   - ex
15797 
  """
304 ashish 15798 
 
15799 
  thrift_spec = (
3064 chandransh 15800 
    None, # 0
15801 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
304 ashish 15802 
  )
15803 
 
3064 chandransh 15804 
  def __init__(self, ex=None,):
15805 
    self.ex = ex
304 ashish 15806 
 
1596 ankur.sing 15807 
  def read(self, iprot):
15808 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15809 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15810 
      return
15811 
    iprot.readStructBegin()
15812 
    while True:
15813 
      (fname, ftype, fid) = iprot.readFieldBegin()
15814 
      if ftype == TType.STOP:
15815 
        break
3064 chandransh 15816 
      if fid == 1:
15817 
        if ftype == TType.STRUCT:
15818 
          self.ex = TransactionServiceException()
15819 
          self.ex.read(iprot)
15820 
        else:
15821 
          iprot.skip(ftype)
1596 ankur.sing 15822 
      else:
15823 
        iprot.skip(ftype)
15824 
      iprot.readFieldEnd()
15825 
    iprot.readStructEnd()
15826 
 
15827 
  def write(self, oprot):
15828 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15829 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15830 
      return
3064 chandransh 15831 
    oprot.writeStructBegin('markOrdersAsDelivered_result')
3431 rajveer 15832 
    if self.ex is not None:
3064 chandransh 15833 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
15834 
      self.ex.write(oprot)
15835 
      oprot.writeFieldEnd()
1596 ankur.sing 15836 
    oprot.writeFieldStop()
15837 
    oprot.writeStructEnd()
15838 
 
3431 rajveer 15839 
  def validate(self):
15840 
    return
15841 
 
15842 
 
1596 ankur.sing 15843 
  def __repr__(self):
15844 
    L = ['%s=%r' % (key, value)
15845 
      for key, value in self.__dict__.iteritems()]
15846 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15847 
 
15848 
  def __eq__(self, other):
15849 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15850 
 
15851 
  def __ne__(self, other):
15852 
    return not (self == other)
15853 
 
4910 phani.kuma 15854 
class markAsRTOrders_args:
1596 ankur.sing 15855 
  """
15856 
  Attributes:
3064 chandransh 15857 
   - providerId
15858 
   - returnedOrders
1596 ankur.sing 15859 
  """
15860 
 
15861 
  thrift_spec = (
3064 chandransh 15862 
    None, # 0
15863 
    (1, TType.I64, 'providerId', None, None, ), # 1
15864 
    (2, TType.MAP, 'returnedOrders', (TType.STRING,None,TType.STRING,None), None, ), # 2
1596 ankur.sing 15865 
  )
15866 
 
3064 chandransh 15867 
  def __init__(self, providerId=None, returnedOrders=None,):
15868 
    self.providerId = providerId
15869 
    self.returnedOrders = returnedOrders
1596 ankur.sing 15870 
 
15871 
  def read(self, iprot):
15872 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15873 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15874 
      return
15875 
    iprot.readStructBegin()
15876 
    while True:
15877 
      (fname, ftype, fid) = iprot.readFieldBegin()
15878 
      if ftype == TType.STOP:
15879 
        break
3064 chandransh 15880 
      if fid == 1:
1596 ankur.sing 15881 
        if ftype == TType.I64:
3064 chandransh 15882 
          self.providerId = iprot.readI64();
1596 ankur.sing 15883 
        else:
15884 
          iprot.skip(ftype)
3064 chandransh 15885 
      elif fid == 2:
15886 
        if ftype == TType.MAP:
15887 
          self.returnedOrders = {}
6188 rajveer 15888 
          (_ktype328, _vtype329, _size327 ) = iprot.readMapBegin()
15889 
          for _i331 in xrange(_size327):
15890 
            _key332 = iprot.readString();
15891 
            _val333 = iprot.readString();
15892 
            self.returnedOrders[_key332] = _val333
3064 chandransh 15893 
          iprot.readMapEnd()
15894 
        else:
15895 
          iprot.skip(ftype)
1596 ankur.sing 15896 
      else:
15897 
        iprot.skip(ftype)
15898 
      iprot.readFieldEnd()
15899 
    iprot.readStructEnd()
15900 
 
15901 
  def write(self, oprot):
15902 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15903 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15904 
      return
4910 phani.kuma 15905 
    oprot.writeStructBegin('markAsRTOrders_args')
3431 rajveer 15906 
    if self.providerId is not None:
3064 chandransh 15907 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
15908 
      oprot.writeI64(self.providerId)
1596 ankur.sing 15909 
      oprot.writeFieldEnd()
3431 rajveer 15910 
    if self.returnedOrders is not None:
3064 chandransh 15911 
      oprot.writeFieldBegin('returnedOrders', TType.MAP, 2)
15912 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.returnedOrders))
6188 rajveer 15913 
      for kiter334,viter335 in self.returnedOrders.items():
15914 
        oprot.writeString(kiter334)
15915 
        oprot.writeString(viter335)
3064 chandransh 15916 
      oprot.writeMapEnd()
15917 
      oprot.writeFieldEnd()
1596 ankur.sing 15918 
    oprot.writeFieldStop()
15919 
    oprot.writeStructEnd()
15920 
 
3431 rajveer 15921 
  def validate(self):
15922 
    return
15923 
 
15924 
 
1596 ankur.sing 15925 
  def __repr__(self):
15926 
    L = ['%s=%r' % (key, value)
15927 
      for key, value in self.__dict__.iteritems()]
15928 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15929 
 
15930 
  def __eq__(self, other):
15931 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15932 
 
15933 
  def __ne__(self, other):
15934 
    return not (self == other)
15935 
 
4910 phani.kuma 15936 
class markAsRTOrders_result:
3064 chandransh 15937 
  """
15938 
  Attributes:
15939 
   - ex
15940 
  """
1596 ankur.sing 15941 
 
1627 ankur.sing 15942 
  thrift_spec = (
3064 chandransh 15943 
    None, # 0
15944 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
1627 ankur.sing 15945 
  )
15946 
 
3064 chandransh 15947 
  def __init__(self, ex=None,):
15948 
    self.ex = ex
15949 
 
1627 ankur.sing 15950 
  def read(self, iprot):
15951 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15952 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15953 
      return
15954 
    iprot.readStructBegin()
15955 
    while True:
15956 
      (fname, ftype, fid) = iprot.readFieldBegin()
15957 
      if ftype == TType.STOP:
15958 
        break
3064 chandransh 15959 
      if fid == 1:
15960 
        if ftype == TType.STRUCT:
15961 
          self.ex = TransactionServiceException()
15962 
          self.ex.read(iprot)
15963 
        else:
15964 
          iprot.skip(ftype)
1627 ankur.sing 15965 
      else:
15966 
        iprot.skip(ftype)
15967 
      iprot.readFieldEnd()
15968 
    iprot.readStructEnd()
15969 
 
15970 
  def write(self, oprot):
15971 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15972 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15973 
      return
4910 phani.kuma 15974 
    oprot.writeStructBegin('markAsRTOrders_result')
3431 rajveer 15975 
    if self.ex is not None:
3064 chandransh 15976 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
15977 
      self.ex.write(oprot)
15978 
      oprot.writeFieldEnd()
1627 ankur.sing 15979 
    oprot.writeFieldStop()
15980 
    oprot.writeStructEnd()
15981 
 
3431 rajveer 15982 
  def validate(self):
15983 
    return
15984 
 
15985 
 
1627 ankur.sing 15986 
  def __repr__(self):
15987 
    L = ['%s=%r' % (key, value)
15988 
      for key, value in self.__dict__.iteritems()]
15989 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15990 
 
15991 
  def __eq__(self, other):
15992 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15993 
 
15994 
  def __ne__(self, other):
15995 
    return not (self == other)
15996 
 
4910 phani.kuma 15997 
class getRTOrders_args:
15998 
  """
15999 
  Attributes:
16000 
   - providerId
16001 
  """
16002 
 
16003 
  thrift_spec = (
16004 
    None, # 0
16005 
    (1, TType.I64, 'providerId', None, None, ), # 1
16006 
  )
16007 
 
16008 
  def __init__(self, providerId=None,):
16009 
    self.providerId = providerId
16010 
 
16011 
  def read(self, iprot):
16012 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16013 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16014 
      return
16015 
    iprot.readStructBegin()
16016 
    while True:
16017 
      (fname, ftype, fid) = iprot.readFieldBegin()
16018 
      if ftype == TType.STOP:
16019 
        break
16020 
      if fid == 1:
16021 
        if ftype == TType.I64:
16022 
          self.providerId = iprot.readI64();
16023 
        else:
16024 
          iprot.skip(ftype)
16025 
      else:
16026 
        iprot.skip(ftype)
16027 
      iprot.readFieldEnd()
16028 
    iprot.readStructEnd()
16029 
 
16030 
  def write(self, oprot):
16031 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16032 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16033 
      return
16034 
    oprot.writeStructBegin('getRTOrders_args')
16035 
    if self.providerId is not None:
16036 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
16037 
      oprot.writeI64(self.providerId)
16038 
      oprot.writeFieldEnd()
16039 
    oprot.writeFieldStop()
16040 
    oprot.writeStructEnd()
16041 
 
16042 
  def validate(self):
16043 
    return
16044 
 
16045 
 
16046 
  def __repr__(self):
16047 
    L = ['%s=%r' % (key, value)
16048 
      for key, value in self.__dict__.iteritems()]
16049 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16050 
 
16051 
  def __eq__(self, other):
16052 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16053 
 
16054 
  def __ne__(self, other):
16055 
    return not (self == other)
16056 
 
16057 
class getRTOrders_result:
16058 
  """
16059 
  Attributes:
16060 
   - success
16061 
  """
16062 
 
16063 
  thrift_spec = (
16064 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
16065 
  )
16066 
 
16067 
  def __init__(self, success=None,):
16068 
    self.success = success
16069 
 
16070 
  def read(self, iprot):
16071 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16072 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16073 
      return
16074 
    iprot.readStructBegin()
16075 
    while True:
16076 
      (fname, ftype, fid) = iprot.readFieldBegin()
16077 
      if ftype == TType.STOP:
16078 
        break
16079 
      if fid == 0:
16080 
        if ftype == TType.LIST:
16081 
          self.success = []
6188 rajveer 16082 
          (_etype339, _size336) = iprot.readListBegin()
16083 
          for _i340 in xrange(_size336):
16084 
            _elem341 = Order()
16085 
            _elem341.read(iprot)
16086 
            self.success.append(_elem341)
4910 phani.kuma 16087 
          iprot.readListEnd()
16088 
        else:
16089 
          iprot.skip(ftype)
16090 
      else:
16091 
        iprot.skip(ftype)
16092 
      iprot.readFieldEnd()
16093 
    iprot.readStructEnd()
16094 
 
16095 
  def write(self, oprot):
16096 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16097 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16098 
      return
16099 
    oprot.writeStructBegin('getRTOrders_result')
16100 
    if self.success is not None:
16101 
      oprot.writeFieldBegin('success', TType.LIST, 0)
16102 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 16103 
      for iter342 in self.success:
16104 
        iter342.write(oprot)
4910 phani.kuma 16105 
      oprot.writeListEnd()
16106 
      oprot.writeFieldEnd()
16107 
    oprot.writeFieldStop()
16108 
    oprot.writeStructEnd()
16109 
 
16110 
  def validate(self):
16111 
    return
16112 
 
16113 
 
16114 
  def __repr__(self):
16115 
    L = ['%s=%r' % (key, value)
16116 
      for key, value in self.__dict__.iteritems()]
16117 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16118 
 
16119 
  def __eq__(self, other):
16120 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16121 
 
16122 
  def __ne__(self, other):
16123 
    return not (self == other)
16124 
 
3064 chandransh 16125 
class updateNonDeliveryReason_args:
1627 ankur.sing 16126 
  """
16127 
  Attributes:
3064 chandransh 16128 
   - providerId
16129 
   - undeliveredOrders
1627 ankur.sing 16130 
  """
16131 
 
16132 
  thrift_spec = (
3064 chandransh 16133 
    None, # 0
16134 
    (1, TType.I64, 'providerId', None, None, ), # 1
16135 
    (2, TType.MAP, 'undeliveredOrders', (TType.STRING,None,TType.STRING,None), None, ), # 2
1627 ankur.sing 16136 
  )
16137 
 
3064 chandransh 16138 
  def __init__(self, providerId=None, undeliveredOrders=None,):
16139 
    self.providerId = providerId
16140 
    self.undeliveredOrders = undeliveredOrders
1627 ankur.sing 16141 
 
16142 
  def read(self, iprot):
16143 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16144 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16145 
      return
16146 
    iprot.readStructBegin()
16147 
    while True:
16148 
      (fname, ftype, fid) = iprot.readFieldBegin()
16149 
      if ftype == TType.STOP:
16150 
        break
3064 chandransh 16151 
      if fid == 1:
1627 ankur.sing 16152 
        if ftype == TType.I64:
3064 chandransh 16153 
          self.providerId = iprot.readI64();
1627 ankur.sing 16154 
        else:
16155 
          iprot.skip(ftype)
3064 chandransh 16156 
      elif fid == 2:
16157 
        if ftype == TType.MAP:
16158 
          self.undeliveredOrders = {}
6188 rajveer 16159 
          (_ktype344, _vtype345, _size343 ) = iprot.readMapBegin()
16160 
          for _i347 in xrange(_size343):
16161 
            _key348 = iprot.readString();
16162 
            _val349 = iprot.readString();
16163 
            self.undeliveredOrders[_key348] = _val349
3064 chandransh 16164 
          iprot.readMapEnd()
16165 
        else:
16166 
          iprot.skip(ftype)
1627 ankur.sing 16167 
      else:
16168 
        iprot.skip(ftype)
16169 
      iprot.readFieldEnd()
16170 
    iprot.readStructEnd()
16171 
 
16172 
  def write(self, oprot):
16173 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16174 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16175 
      return
3064 chandransh 16176 
    oprot.writeStructBegin('updateNonDeliveryReason_args')
3431 rajveer 16177 
    if self.providerId is not None:
3064 chandransh 16178 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
16179 
      oprot.writeI64(self.providerId)
1627 ankur.sing 16180 
      oprot.writeFieldEnd()
3431 rajveer 16181 
    if self.undeliveredOrders is not None:
3064 chandransh 16182 
      oprot.writeFieldBegin('undeliveredOrders', TType.MAP, 2)
16183 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.undeliveredOrders))
6188 rajveer 16184 
      for kiter350,viter351 in self.undeliveredOrders.items():
16185 
        oprot.writeString(kiter350)
16186 
        oprot.writeString(viter351)
3064 chandransh 16187 
      oprot.writeMapEnd()
16188 
      oprot.writeFieldEnd()
1627 ankur.sing 16189 
    oprot.writeFieldStop()
16190 
    oprot.writeStructEnd()
16191 
 
3431 rajveer 16192 
  def validate(self):
16193 
    return
16194 
 
16195 
 
1627 ankur.sing 16196 
  def __repr__(self):
16197 
    L = ['%s=%r' % (key, value)
16198 
      for key, value in self.__dict__.iteritems()]
16199 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16200 
 
16201 
  def __eq__(self, other):
16202 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16203 
 
16204 
  def __ne__(self, other):
16205 
    return not (self == other)
16206 
 
3064 chandransh 16207 
class updateNonDeliveryReason_result:
1627 ankur.sing 16208 
  """
16209 
  Attributes:
3064 chandransh 16210 
   - ex
1627 ankur.sing 16211 
  """
16212 
 
16213 
  thrift_spec = (
4910 phani.kuma 16214 
    None, # 0
3064 chandransh 16215 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
1627 ankur.sing 16216 
  )
16217 
 
4910 phani.kuma 16218 
  def __init__(self, ex=None,):
3064 chandransh 16219 
    self.ex = ex
1627 ankur.sing 16220 
 
16221 
  def read(self, iprot):
16222 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16223 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16224 
      return
16225 
    iprot.readStructBegin()
16226 
    while True:
16227 
      (fname, ftype, fid) = iprot.readFieldBegin()
16228 
      if ftype == TType.STOP:
16229 
        break
4910 phani.kuma 16230 
      if fid == 1:
16231 
        if ftype == TType.STRUCT:
16232 
          self.ex = TransactionServiceException()
16233 
          self.ex.read(iprot)
16234 
        else:
16235 
          iprot.skip(ftype)
16236 
      else:
16237 
        iprot.skip(ftype)
16238 
      iprot.readFieldEnd()
16239 
    iprot.readStructEnd()
16240 
 
16241 
  def write(self, oprot):
16242 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16243 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16244 
      return
16245 
    oprot.writeStructBegin('updateNonDeliveryReason_result')
16246 
    if self.ex is not None:
16247 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
16248 
      self.ex.write(oprot)
16249 
      oprot.writeFieldEnd()
16250 
    oprot.writeFieldStop()
16251 
    oprot.writeStructEnd()
16252 
 
16253 
  def validate(self):
16254 
    return
16255 
 
16256 
 
16257 
  def __repr__(self):
16258 
    L = ['%s=%r' % (key, value)
16259 
      for key, value in self.__dict__.iteritems()]
16260 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16261 
 
16262 
  def __eq__(self, other):
16263 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16264 
 
16265 
  def __ne__(self, other):
16266 
    return not (self == other)
16267 
 
16268 
class getNonDeliveredOrdersbyCourier_args:
16269 
  """
16270 
  Attributes:
16271 
   - providerId
16272 
  """
16273 
 
16274 
  thrift_spec = (
16275 
    None, # 0
16276 
    (1, TType.I64, 'providerId', None, None, ), # 1
16277 
  )
16278 
 
16279 
  def __init__(self, providerId=None,):
16280 
    self.providerId = providerId
16281 
 
16282 
  def read(self, iprot):
16283 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16284 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16285 
      return
16286 
    iprot.readStructBegin()
16287 
    while True:
16288 
      (fname, ftype, fid) = iprot.readFieldBegin()
16289 
      if ftype == TType.STOP:
16290 
        break
16291 
      if fid == 1:
16292 
        if ftype == TType.I64:
16293 
          self.providerId = iprot.readI64();
16294 
        else:
16295 
          iprot.skip(ftype)
16296 
      else:
16297 
        iprot.skip(ftype)
16298 
      iprot.readFieldEnd()
16299 
    iprot.readStructEnd()
16300 
 
16301 
  def write(self, oprot):
16302 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16303 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16304 
      return
16305 
    oprot.writeStructBegin('getNonDeliveredOrdersbyCourier_args')
16306 
    if self.providerId is not None:
16307 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
16308 
      oprot.writeI64(self.providerId)
16309 
      oprot.writeFieldEnd()
16310 
    oprot.writeFieldStop()
16311 
    oprot.writeStructEnd()
16312 
 
16313 
  def validate(self):
16314 
    return
16315 
 
16316 
 
16317 
  def __repr__(self):
16318 
    L = ['%s=%r' % (key, value)
16319 
      for key, value in self.__dict__.iteritems()]
16320 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16321 
 
16322 
  def __eq__(self, other):
16323 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16324 
 
16325 
  def __ne__(self, other):
16326 
    return not (self == other)
16327 
 
16328 
class getNonDeliveredOrdersbyCourier_result:
16329 
  """
16330 
  Attributes:
16331 
   - success
16332 
  """
16333 
 
16334 
  thrift_spec = (
16335 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
16336 
  )
16337 
 
16338 
  def __init__(self, success=None,):
16339 
    self.success = success
16340 
 
16341 
  def read(self, iprot):
16342 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16343 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16344 
      return
16345 
    iprot.readStructBegin()
16346 
    while True:
16347 
      (fname, ftype, fid) = iprot.readFieldBegin()
16348 
      if ftype == TType.STOP:
16349 
        break
4581 phani.kuma 16350 
      if fid == 0:
16351 
        if ftype == TType.LIST:
16352 
          self.success = []
6188 rajveer 16353 
          (_etype355, _size352) = iprot.readListBegin()
16354 
          for _i356 in xrange(_size352):
16355 
            _elem357 = Order()
16356 
            _elem357.read(iprot)
16357 
            self.success.append(_elem357)
4581 phani.kuma 16358 
          iprot.readListEnd()
16359 
        else:
16360 
          iprot.skip(ftype)
4910 phani.kuma 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
16370 
    oprot.writeStructBegin('getNonDeliveredOrdersbyCourier_result')
16371 
    if self.success is not None:
16372 
      oprot.writeFieldBegin('success', TType.LIST, 0)
16373 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 16374 
      for iter358 in self.success:
16375 
        iter358.write(oprot)
4910 phani.kuma 16376 
      oprot.writeListEnd()
16377 
      oprot.writeFieldEnd()
16378 
    oprot.writeFieldStop()
16379 
    oprot.writeStructEnd()
16380 
 
16381 
  def validate(self):
16382 
    return
16383 
 
16384 
 
16385 
  def __repr__(self):
16386 
    L = ['%s=%r' % (key, value)
16387 
      for key, value in self.__dict__.iteritems()]
16388 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16389 
 
16390 
  def __eq__(self, other):
16391 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16392 
 
16393 
  def __ne__(self, other):
16394 
    return not (self == other)
16395 
 
16396 
class markOrdersAsLocalConnected_args:
16397 
  """
16398 
  Attributes:
16399 
   - providerId
16400 
   - local_connected_orders
16401 
  """
16402 
 
16403 
  thrift_spec = (
16404 
    None, # 0
16405 
    (1, TType.I64, 'providerId', None, None, ), # 1
16406 
    (2, TType.MAP, 'local_connected_orders', (TType.STRING,None,TType.STRING,None), None, ), # 2
16407 
  )
16408 
 
16409 
  def __init__(self, providerId=None, local_connected_orders=None,):
16410 
    self.providerId = providerId
16411 
    self.local_connected_orders = local_connected_orders
16412 
 
16413 
  def read(self, iprot):
16414 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16415 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16416 
      return
16417 
    iprot.readStructBegin()
16418 
    while True:
16419 
      (fname, ftype, fid) = iprot.readFieldBegin()
16420 
      if ftype == TType.STOP:
16421 
        break
16422 
      if fid == 1:
16423 
        if ftype == TType.I64:
16424 
          self.providerId = iprot.readI64();
16425 
        else:
16426 
          iprot.skip(ftype)
16427 
      elif fid == 2:
16428 
        if ftype == TType.MAP:
16429 
          self.local_connected_orders = {}
6188 rajveer 16430 
          (_ktype360, _vtype361, _size359 ) = iprot.readMapBegin()
16431 
          for _i363 in xrange(_size359):
16432 
            _key364 = iprot.readString();
16433 
            _val365 = iprot.readString();
16434 
            self.local_connected_orders[_key364] = _val365
4910 phani.kuma 16435 
          iprot.readMapEnd()
16436 
        else:
16437 
          iprot.skip(ftype)
16438 
      else:
16439 
        iprot.skip(ftype)
16440 
      iprot.readFieldEnd()
16441 
    iprot.readStructEnd()
16442 
 
16443 
  def write(self, oprot):
16444 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16445 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16446 
      return
16447 
    oprot.writeStructBegin('markOrdersAsLocalConnected_args')
16448 
    if self.providerId is not None:
16449 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
16450 
      oprot.writeI64(self.providerId)
16451 
      oprot.writeFieldEnd()
16452 
    if self.local_connected_orders is not None:
16453 
      oprot.writeFieldBegin('local_connected_orders', TType.MAP, 2)
16454 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.local_connected_orders))
6188 rajveer 16455 
      for kiter366,viter367 in self.local_connected_orders.items():
16456 
        oprot.writeString(kiter366)
16457 
        oprot.writeString(viter367)
4910 phani.kuma 16458 
      oprot.writeMapEnd()
16459 
      oprot.writeFieldEnd()
16460 
    oprot.writeFieldStop()
16461 
    oprot.writeStructEnd()
16462 
 
16463 
  def validate(self):
16464 
    return
16465 
 
16466 
 
16467 
  def __repr__(self):
16468 
    L = ['%s=%r' % (key, value)
16469 
      for key, value in self.__dict__.iteritems()]
16470 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16471 
 
16472 
  def __eq__(self, other):
16473 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16474 
 
16475 
  def __ne__(self, other):
16476 
    return not (self == other)
16477 
 
16478 
class markOrdersAsLocalConnected_result:
16479 
  """
16480 
  Attributes:
16481 
   - ex
16482 
  """
16483 
 
16484 
  thrift_spec = (
16485 
    None, # 0
16486 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
16487 
  )
16488 
 
16489 
  def __init__(self, ex=None,):
16490 
    self.ex = ex
16491 
 
16492 
  def read(self, iprot):
16493 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16494 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16495 
      return
16496 
    iprot.readStructBegin()
16497 
    while True:
16498 
      (fname, ftype, fid) = iprot.readFieldBegin()
16499 
      if ftype == TType.STOP:
16500 
        break
16501 
      if fid == 1:
3064 chandransh 16502 
        if ftype == TType.STRUCT:
16503 
          self.ex = TransactionServiceException()
16504 
          self.ex.read(iprot)
1627 ankur.sing 16505 
        else:
16506 
          iprot.skip(ftype)
16507 
      else:
16508 
        iprot.skip(ftype)
16509 
      iprot.readFieldEnd()
16510 
    iprot.readStructEnd()
16511 
 
16512 
  def write(self, oprot):
16513 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16514 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16515 
      return
4910 phani.kuma 16516 
    oprot.writeStructBegin('markOrdersAsLocalConnected_result')
16517 
    if self.ex is not None:
16518 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
16519 
      self.ex.write(oprot)
16520 
      oprot.writeFieldEnd()
16521 
    oprot.writeFieldStop()
16522 
    oprot.writeStructEnd()
16523 
 
16524 
  def validate(self):
16525 
    return
16526 
 
16527 
 
16528 
  def __repr__(self):
16529 
    L = ['%s=%r' % (key, value)
16530 
      for key, value in self.__dict__.iteritems()]
16531 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16532 
 
16533 
  def __eq__(self, other):
16534 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16535 
 
16536 
  def __ne__(self, other):
16537 
    return not (self == other)
16538 
 
16539 
class getOrdersNotLocalConnected_args:
16540 
  """
16541 
  Attributes:
16542 
   - providerId
16543 
  """
16544 
 
16545 
  thrift_spec = (
16546 
    None, # 0
16547 
    (1, TType.I64, 'providerId', None, None, ), # 1
16548 
  )
16549 
 
16550 
  def __init__(self, providerId=None,):
16551 
    self.providerId = providerId
16552 
 
16553 
  def read(self, iprot):
16554 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16555 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16556 
      return
16557 
    iprot.readStructBegin()
16558 
    while True:
16559 
      (fname, ftype, fid) = iprot.readFieldBegin()
16560 
      if ftype == TType.STOP:
16561 
        break
16562 
      if fid == 1:
16563 
        if ftype == TType.I64:
16564 
          self.providerId = iprot.readI64();
16565 
        else:
16566 
          iprot.skip(ftype)
16567 
      else:
16568 
        iprot.skip(ftype)
16569 
      iprot.readFieldEnd()
16570 
    iprot.readStructEnd()
16571 
 
16572 
  def write(self, oprot):
16573 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16574 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16575 
      return
16576 
    oprot.writeStructBegin('getOrdersNotLocalConnected_args')
16577 
    if self.providerId is not None:
16578 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
16579 
      oprot.writeI64(self.providerId)
16580 
      oprot.writeFieldEnd()
16581 
    oprot.writeFieldStop()
16582 
    oprot.writeStructEnd()
16583 
 
16584 
  def validate(self):
16585 
    return
16586 
 
16587 
 
16588 
  def __repr__(self):
16589 
    L = ['%s=%r' % (key, value)
16590 
      for key, value in self.__dict__.iteritems()]
16591 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16592 
 
16593 
  def __eq__(self, other):
16594 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16595 
 
16596 
  def __ne__(self, other):
16597 
    return not (self == other)
16598 
 
16599 
class getOrdersNotLocalConnected_result:
16600 
  """
16601 
  Attributes:
16602 
   - success
16603 
  """
16604 
 
16605 
  thrift_spec = (
16606 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
16607 
  )
16608 
 
16609 
  def __init__(self, success=None,):
16610 
    self.success = success
16611 
 
16612 
  def read(self, iprot):
16613 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16614 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16615 
      return
16616 
    iprot.readStructBegin()
16617 
    while True:
16618 
      (fname, ftype, fid) = iprot.readFieldBegin()
16619 
      if ftype == TType.STOP:
16620 
        break
16621 
      if fid == 0:
16622 
        if ftype == TType.LIST:
16623 
          self.success = []
6188 rajveer 16624 
          (_etype371, _size368) = iprot.readListBegin()
16625 
          for _i372 in xrange(_size368):
16626 
            _elem373 = Order()
16627 
            _elem373.read(iprot)
16628 
            self.success.append(_elem373)
4910 phani.kuma 16629 
          iprot.readListEnd()
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('getOrdersNotLocalConnected_result')
4581 phani.kuma 16642 
    if self.success is not None:
16643 
      oprot.writeFieldBegin('success', TType.LIST, 0)
16644 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 16645 
      for iter374 in self.success:
16646 
        iter374.write(oprot)
4581 phani.kuma 16647 
      oprot.writeListEnd()
16648 
      oprot.writeFieldEnd()
4910 phani.kuma 16649 
    oprot.writeFieldStop()
16650 
    oprot.writeStructEnd()
16651 
 
16652 
  def validate(self):
16653 
    return
16654 
 
16655 
 
16656 
  def __repr__(self):
16657 
    L = ['%s=%r' % (key, value)
16658 
      for key, value in self.__dict__.iteritems()]
16659 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16660 
 
16661 
  def __eq__(self, other):
16662 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16663 
 
16664 
  def __ne__(self, other):
16665 
    return not (self == other)
16666 
 
16667 
class markOrdersAsDestinationCityReached_args:
16668 
  """
16669 
  Attributes:
16670 
   - providerId
16671 
   - destination_city_reached_orders
16672 
  """
16673 
 
16674 
  thrift_spec = (
16675 
    None, # 0
16676 
    (1, TType.I64, 'providerId', None, None, ), # 1
16677 
    (2, TType.MAP, 'destination_city_reached_orders', (TType.STRING,None,TType.STRING,None), None, ), # 2
16678 
  )
16679 
 
16680 
  def __init__(self, providerId=None, destination_city_reached_orders=None,):
16681 
    self.providerId = providerId
16682 
    self.destination_city_reached_orders = destination_city_reached_orders
16683 
 
16684 
  def read(self, iprot):
16685 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16686 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16687 
      return
16688 
    iprot.readStructBegin()
16689 
    while True:
16690 
      (fname, ftype, fid) = iprot.readFieldBegin()
16691 
      if ftype == TType.STOP:
16692 
        break
16693 
      if fid == 1:
16694 
        if ftype == TType.I64:
16695 
          self.providerId = iprot.readI64();
16696 
        else:
16697 
          iprot.skip(ftype)
16698 
      elif fid == 2:
16699 
        if ftype == TType.MAP:
16700 
          self.destination_city_reached_orders = {}
6188 rajveer 16701 
          (_ktype376, _vtype377, _size375 ) = iprot.readMapBegin()
16702 
          for _i379 in xrange(_size375):
16703 
            _key380 = iprot.readString();
16704 
            _val381 = iprot.readString();
16705 
            self.destination_city_reached_orders[_key380] = _val381
4910 phani.kuma 16706 
          iprot.readMapEnd()
16707 
        else:
16708 
          iprot.skip(ftype)
16709 
      else:
16710 
        iprot.skip(ftype)
16711 
      iprot.readFieldEnd()
16712 
    iprot.readStructEnd()
16713 
 
16714 
  def write(self, oprot):
16715 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16716 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16717 
      return
16718 
    oprot.writeStructBegin('markOrdersAsDestinationCityReached_args')
16719 
    if self.providerId is not None:
16720 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
16721 
      oprot.writeI64(self.providerId)
16722 
      oprot.writeFieldEnd()
16723 
    if self.destination_city_reached_orders is not None:
16724 
      oprot.writeFieldBegin('destination_city_reached_orders', TType.MAP, 2)
16725 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.destination_city_reached_orders))
6188 rajveer 16726 
      for kiter382,viter383 in self.destination_city_reached_orders.items():
16727 
        oprot.writeString(kiter382)
16728 
        oprot.writeString(viter383)
4910 phani.kuma 16729 
      oprot.writeMapEnd()
16730 
      oprot.writeFieldEnd()
16731 
    oprot.writeFieldStop()
16732 
    oprot.writeStructEnd()
16733 
 
16734 
  def validate(self):
16735 
    return
16736 
 
16737 
 
16738 
  def __repr__(self):
16739 
    L = ['%s=%r' % (key, value)
16740 
      for key, value in self.__dict__.iteritems()]
16741 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16742 
 
16743 
  def __eq__(self, other):
16744 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16745 
 
16746 
  def __ne__(self, other):
16747 
    return not (self == other)
16748 
 
16749 
class markOrdersAsDestinationCityReached_result:
16750 
  """
16751 
  Attributes:
16752 
   - ex
16753 
  """
16754 
 
16755 
  thrift_spec = (
16756 
    None, # 0
16757 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
16758 
  )
16759 
 
16760 
  def __init__(self, ex=None,):
16761 
    self.ex = ex
16762 
 
16763 
  def read(self, iprot):
16764 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16765 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16766 
      return
16767 
    iprot.readStructBegin()
16768 
    while True:
16769 
      (fname, ftype, fid) = iprot.readFieldBegin()
16770 
      if ftype == TType.STOP:
16771 
        break
16772 
      if fid == 1:
16773 
        if ftype == TType.STRUCT:
16774 
          self.ex = TransactionServiceException()
16775 
          self.ex.read(iprot)
16776 
        else:
16777 
          iprot.skip(ftype)
16778 
      else:
16779 
        iprot.skip(ftype)
16780 
      iprot.readFieldEnd()
16781 
    iprot.readStructEnd()
16782 
 
16783 
  def write(self, oprot):
16784 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16785 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16786 
      return
16787 
    oprot.writeStructBegin('markOrdersAsDestinationCityReached_result')
3431 rajveer 16788 
    if self.ex is not None:
3064 chandransh 16789 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
16790 
      self.ex.write(oprot)
1627 ankur.sing 16791 
      oprot.writeFieldEnd()
16792 
    oprot.writeFieldStop()
16793 
    oprot.writeStructEnd()
16794 
 
3431 rajveer 16795 
  def validate(self):
16796 
    return
16797 
 
16798 
 
1627 ankur.sing 16799 
  def __repr__(self):
16800 
    L = ['%s=%r' % (key, value)
16801 
      for key, value in self.__dict__.iteritems()]
16802 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16803 
 
16804 
  def __eq__(self, other):
16805 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16806 
 
16807 
  def __ne__(self, other):
16808 
    return not (self == other)
16809 
 
4910 phani.kuma 16810 
class markOrdersAsFirstDeliveryAttempted_args:
16811 
  """
16812 
  Attributes:
16813 
   - providerId
16814 
   - first_atdl_orders
16815 
  """
16816 
 
16817 
  thrift_spec = (
16818 
    None, # 0
16819 
    (1, TType.I64, 'providerId', None, None, ), # 1
16820 
    (2, TType.MAP, 'first_atdl_orders', (TType.STRING,None,TType.STRING,None), None, ), # 2
16821 
  )
16822 
 
16823 
  def __init__(self, providerId=None, first_atdl_orders=None,):
16824 
    self.providerId = providerId
16825 
    self.first_atdl_orders = first_atdl_orders
16826 
 
16827 
  def read(self, iprot):
16828 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16829 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16830 
      return
16831 
    iprot.readStructBegin()
16832 
    while True:
16833 
      (fname, ftype, fid) = iprot.readFieldBegin()
16834 
      if ftype == TType.STOP:
16835 
        break
16836 
      if fid == 1:
16837 
        if ftype == TType.I64:
16838 
          self.providerId = iprot.readI64();
16839 
        else:
16840 
          iprot.skip(ftype)
16841 
      elif fid == 2:
16842 
        if ftype == TType.MAP:
16843 
          self.first_atdl_orders = {}
6188 rajveer 16844 
          (_ktype385, _vtype386, _size384 ) = iprot.readMapBegin()
16845 
          for _i388 in xrange(_size384):
16846 
            _key389 = iprot.readString();
16847 
            _val390 = iprot.readString();
16848 
            self.first_atdl_orders[_key389] = _val390
4910 phani.kuma 16849 
          iprot.readMapEnd()
16850 
        else:
16851 
          iprot.skip(ftype)
16852 
      else:
16853 
        iprot.skip(ftype)
16854 
      iprot.readFieldEnd()
16855 
    iprot.readStructEnd()
16856 
 
16857 
  def write(self, oprot):
16858 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16859 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16860 
      return
16861 
    oprot.writeStructBegin('markOrdersAsFirstDeliveryAttempted_args')
16862 
    if self.providerId is not None:
16863 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
16864 
      oprot.writeI64(self.providerId)
16865 
      oprot.writeFieldEnd()
16866 
    if self.first_atdl_orders is not None:
16867 
      oprot.writeFieldBegin('first_atdl_orders', TType.MAP, 2)
16868 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.first_atdl_orders))
6188 rajveer 16869 
      for kiter391,viter392 in self.first_atdl_orders.items():
16870 
        oprot.writeString(kiter391)
16871 
        oprot.writeString(viter392)
4910 phani.kuma 16872 
      oprot.writeMapEnd()
16873 
      oprot.writeFieldEnd()
16874 
    oprot.writeFieldStop()
16875 
    oprot.writeStructEnd()
16876 
 
16877 
  def validate(self):
16878 
    return
16879 
 
16880 
 
16881 
  def __repr__(self):
16882 
    L = ['%s=%r' % (key, value)
16883 
      for key, value in self.__dict__.iteritems()]
16884 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16885 
 
16886 
  def __eq__(self, other):
16887 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16888 
 
16889 
  def __ne__(self, other):
16890 
    return not (self == other)
16891 
 
16892 
class markOrdersAsFirstDeliveryAttempted_result:
16893 
  """
16894 
  Attributes:
16895 
   - ex
16896 
  """
16897 
 
16898 
  thrift_spec = (
16899 
    None, # 0
16900 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
16901 
  )
16902 
 
16903 
  def __init__(self, ex=None,):
16904 
    self.ex = ex
16905 
 
16906 
  def read(self, iprot):
16907 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16908 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16909 
      return
16910 
    iprot.readStructBegin()
16911 
    while True:
16912 
      (fname, ftype, fid) = iprot.readFieldBegin()
16913 
      if ftype == TType.STOP:
16914 
        break
16915 
      if fid == 1:
16916 
        if ftype == TType.STRUCT:
16917 
          self.ex = TransactionServiceException()
16918 
          self.ex.read(iprot)
16919 
        else:
16920 
          iprot.skip(ftype)
16921 
      else:
16922 
        iprot.skip(ftype)
16923 
      iprot.readFieldEnd()
16924 
    iprot.readStructEnd()
16925 
 
16926 
  def write(self, oprot):
16927 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16928 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16929 
      return
16930 
    oprot.writeStructBegin('markOrdersAsFirstDeliveryAttempted_result')
16931 
    if self.ex is not None:
16932 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
16933 
      self.ex.write(oprot)
16934 
      oprot.writeFieldEnd()
16935 
    oprot.writeFieldStop()
16936 
    oprot.writeStructEnd()
16937 
 
16938 
  def validate(self):
16939 
    return
16940 
 
16941 
 
16942 
  def __repr__(self):
16943 
    L = ['%s=%r' % (key, value)
16944 
      for key, value in self.__dict__.iteritems()]
16945 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16946 
 
16947 
  def __eq__(self, other):
16948 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16949 
 
16950 
  def __ne__(self, other):
16951 
    return not (self == other)
16952 
 
3064 chandransh 16953 
class getUndeliveredOrders_args:
1886 ankur.sing 16954 
  """
16955 
  Attributes:
3064 chandransh 16956 
   - providerId
16957 
   - warehouseId
1886 ankur.sing 16958 
  """
1627 ankur.sing 16959 
 
1886 ankur.sing 16960 
  thrift_spec = (
16961 
    None, # 0
3064 chandransh 16962 
    (1, TType.I64, 'providerId', None, None, ), # 1
16963 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
1886 ankur.sing 16964 
  )
16965 
 
3064 chandransh 16966 
  def __init__(self, providerId=None, warehouseId=None,):
16967 
    self.providerId = providerId
16968 
    self.warehouseId = warehouseId
1886 ankur.sing 16969 
 
16970 
  def read(self, iprot):
16971 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16972 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16973 
      return
16974 
    iprot.readStructBegin()
16975 
    while True:
16976 
      (fname, ftype, fid) = iprot.readFieldBegin()
16977 
      if ftype == TType.STOP:
16978 
        break
16979 
      if fid == 1:
16980 
        if ftype == TType.I64:
3064 chandransh 16981 
          self.providerId = iprot.readI64();
1886 ankur.sing 16982 
        else:
16983 
          iprot.skip(ftype)
3064 chandransh 16984 
      elif fid == 2:
16985 
        if ftype == TType.I64:
16986 
          self.warehouseId = iprot.readI64();
16987 
        else:
16988 
          iprot.skip(ftype)
1886 ankur.sing 16989 
      else:
16990 
        iprot.skip(ftype)
16991 
      iprot.readFieldEnd()
16992 
    iprot.readStructEnd()
16993 
 
16994 
  def write(self, oprot):
16995 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16996 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16997 
      return
3064 chandransh 16998 
    oprot.writeStructBegin('getUndeliveredOrders_args')
3431 rajveer 16999 
    if self.providerId is not None:
3064 chandransh 17000 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
17001 
      oprot.writeI64(self.providerId)
1886 ankur.sing 17002 
      oprot.writeFieldEnd()
3431 rajveer 17003 
    if self.warehouseId is not None:
3064 chandransh 17004 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
17005 
      oprot.writeI64(self.warehouseId)
17006 
      oprot.writeFieldEnd()
1886 ankur.sing 17007 
    oprot.writeFieldStop()
17008 
    oprot.writeStructEnd()
17009 
 
3431 rajveer 17010 
  def validate(self):
17011 
    return
17012 
 
17013 
 
1886 ankur.sing 17014 
  def __repr__(self):
17015 
    L = ['%s=%r' % (key, value)
17016 
      for key, value in self.__dict__.iteritems()]
17017 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17018 
 
17019 
  def __eq__(self, other):
17020 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17021 
 
17022 
  def __ne__(self, other):
17023 
    return not (self == other)
17024 
 
3064 chandransh 17025 
class getUndeliveredOrders_result:
1886 ankur.sing 17026 
  """
17027 
  Attributes:
17028 
   - success
17029 
  """
17030 
 
17031 
  thrift_spec = (
17032 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
17033 
  )
17034 
 
17035 
  def __init__(self, success=None,):
17036 
    self.success = success
17037 
 
17038 
  def read(self, iprot):
17039 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17040 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17041 
      return
17042 
    iprot.readStructBegin()
17043 
    while True:
17044 
      (fname, ftype, fid) = iprot.readFieldBegin()
17045 
      if ftype == TType.STOP:
17046 
        break
17047 
      if fid == 0:
17048 
        if ftype == TType.LIST:
17049 
          self.success = []
6188 rajveer 17050 
          (_etype396, _size393) = iprot.readListBegin()
17051 
          for _i397 in xrange(_size393):
17052 
            _elem398 = Order()
17053 
            _elem398.read(iprot)
17054 
            self.success.append(_elem398)
1886 ankur.sing 17055 
          iprot.readListEnd()
17056 
        else:
17057 
          iprot.skip(ftype)
17058 
      else:
17059 
        iprot.skip(ftype)
17060 
      iprot.readFieldEnd()
17061 
    iprot.readStructEnd()
17062 
 
17063 
  def write(self, oprot):
17064 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17065 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17066 
      return
3064 chandransh 17067 
    oprot.writeStructBegin('getUndeliveredOrders_result')
3431 rajveer 17068 
    if self.success is not None:
1886 ankur.sing 17069 
      oprot.writeFieldBegin('success', TType.LIST, 0)
17070 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 17071 
      for iter399 in self.success:
17072 
        iter399.write(oprot)
1886 ankur.sing 17073 
      oprot.writeListEnd()
17074 
      oprot.writeFieldEnd()
17075 
    oprot.writeFieldStop()
17076 
    oprot.writeStructEnd()
17077 
 
3431 rajveer 17078 
  def validate(self):
17079 
    return
17080 
 
17081 
 
1886 ankur.sing 17082 
  def __repr__(self):
17083 
    L = ['%s=%r' % (key, value)
17084 
      for key, value in self.__dict__.iteritems()]
17085 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17086 
 
17087 
  def __eq__(self, other):
17088 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17089 
 
17090 
  def __ne__(self, other):
17091 
    return not (self == other)
17092 
 
4783 phani.kuma 17093 
class getUndeliveredOrdersExpectedDeliveryDateNotMet_args:
17094 
 
17095 
  thrift_spec = (
17096 
  )
17097 
 
17098 
  def read(self, iprot):
17099 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17100 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17101 
      return
17102 
    iprot.readStructBegin()
17103 
    while True:
17104 
      (fname, ftype, fid) = iprot.readFieldBegin()
17105 
      if ftype == TType.STOP:
17106 
        break
17107 
      else:
17108 
        iprot.skip(ftype)
17109 
      iprot.readFieldEnd()
17110 
    iprot.readStructEnd()
17111 
 
17112 
  def write(self, oprot):
17113 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17114 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17115 
      return
17116 
    oprot.writeStructBegin('getUndeliveredOrdersExpectedDeliveryDateNotMet_args')
17117 
    oprot.writeFieldStop()
17118 
    oprot.writeStructEnd()
17119 
 
17120 
  def validate(self):
17121 
    return
17122 
 
17123 
 
17124 
  def __repr__(self):
17125 
    L = ['%s=%r' % (key, value)
17126 
      for key, value in self.__dict__.iteritems()]
17127 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17128 
 
17129 
  def __eq__(self, other):
17130 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17131 
 
17132 
  def __ne__(self, other):
17133 
    return not (self == other)
17134 
 
17135 
class getUndeliveredOrdersExpectedDeliveryDateNotMet_result:
17136 
  """
17137 
  Attributes:
17138 
   - success
17139 
  """
17140 
 
17141 
  thrift_spec = (
17142 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
17143 
  )
17144 
 
17145 
  def __init__(self, success=None,):
17146 
    self.success = success
17147 
 
17148 
  def read(self, iprot):
17149 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17150 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17151 
      return
17152 
    iprot.readStructBegin()
17153 
    while True:
17154 
      (fname, ftype, fid) = iprot.readFieldBegin()
17155 
      if ftype == TType.STOP:
17156 
        break
17157 
      if fid == 0:
17158 
        if ftype == TType.LIST:
17159 
          self.success = []
6188 rajveer 17160 
          (_etype403, _size400) = iprot.readListBegin()
17161 
          for _i404 in xrange(_size400):
17162 
            _elem405 = Order()
17163 
            _elem405.read(iprot)
17164 
            self.success.append(_elem405)
4783 phani.kuma 17165 
          iprot.readListEnd()
17166 
        else:
17167 
          iprot.skip(ftype)
17168 
      else:
17169 
        iprot.skip(ftype)
17170 
      iprot.readFieldEnd()
17171 
    iprot.readStructEnd()
17172 
 
17173 
  def write(self, oprot):
17174 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17175 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17176 
      return
17177 
    oprot.writeStructBegin('getUndeliveredOrdersExpectedDeliveryDateNotMet_result')
17178 
    if self.success is not None:
17179 
      oprot.writeFieldBegin('success', TType.LIST, 0)
17180 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 17181 
      for iter406 in self.success:
17182 
        iter406.write(oprot)
4783 phani.kuma 17183 
      oprot.writeListEnd()
17184 
      oprot.writeFieldEnd()
17185 
    oprot.writeFieldStop()
17186 
    oprot.writeStructEnd()
17187 
 
17188 
  def validate(self):
17189 
    return
17190 
 
17191 
 
17192 
  def __repr__(self):
17193 
    L = ['%s=%r' % (key, value)
17194 
      for key, value in self.__dict__.iteritems()]
17195 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17196 
 
17197 
  def __eq__(self, other):
17198 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17199 
 
17200 
  def __ne__(self, other):
17201 
    return not (self == other)
17202 
 
2536 chandransh 17203 
class toggleDOAFlag_args:
17204 
  """
17205 
  Attributes:
17206 
   - orderId
17207 
  """
1886 ankur.sing 17208 
 
2536 chandransh 17209 
  thrift_spec = (
17210 
    None, # 0
17211 
    (1, TType.I64, 'orderId', None, None, ), # 1
17212 
  )
17213 
 
17214 
  def __init__(self, orderId=None,):
17215 
    self.orderId = orderId
17216 
 
17217 
  def read(self, iprot):
17218 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17219 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17220 
      return
17221 
    iprot.readStructBegin()
17222 
    while True:
17223 
      (fname, ftype, fid) = iprot.readFieldBegin()
17224 
      if ftype == TType.STOP:
17225 
        break
17226 
      if fid == 1:
17227 
        if ftype == TType.I64:
17228 
          self.orderId = iprot.readI64();
17229 
        else:
17230 
          iprot.skip(ftype)
17231 
      else:
17232 
        iprot.skip(ftype)
17233 
      iprot.readFieldEnd()
17234 
    iprot.readStructEnd()
17235 
 
17236 
  def write(self, oprot):
17237 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17238 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17239 
      return
17240 
    oprot.writeStructBegin('toggleDOAFlag_args')
3431 rajveer 17241 
    if self.orderId is not None:
2536 chandransh 17242 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
17243 
      oprot.writeI64(self.orderId)
17244 
      oprot.writeFieldEnd()
17245 
    oprot.writeFieldStop()
17246 
    oprot.writeStructEnd()
17247 
 
3431 rajveer 17248 
  def validate(self):
17249 
    return
17250 
 
17251 
 
2536 chandransh 17252 
  def __repr__(self):
17253 
    L = ['%s=%r' % (key, value)
17254 
      for key, value in self.__dict__.iteritems()]
17255 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17256 
 
17257 
  def __eq__(self, other):
17258 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17259 
 
17260 
  def __ne__(self, other):
17261 
    return not (self == other)
17262 
 
17263 
class toggleDOAFlag_result:
17264 
  """
17265 
  Attributes:
17266 
   - success
17267 
   - ex
17268 
  """
17269 
 
17270 
  thrift_spec = (
17271 
    (0, TType.BOOL, 'success', None, None, ), # 0
17272 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
17273 
  )
17274 
 
17275 
  def __init__(self, success=None, ex=None,):
17276 
    self.success = success
17277 
    self.ex = ex
17278 
 
17279 
  def read(self, iprot):
17280 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17281 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17282 
      return
17283 
    iprot.readStructBegin()
17284 
    while True:
17285 
      (fname, ftype, fid) = iprot.readFieldBegin()
17286 
      if ftype == TType.STOP:
17287 
        break
17288 
      if fid == 0:
17289 
        if ftype == TType.BOOL:
17290 
          self.success = iprot.readBool();
17291 
        else:
17292 
          iprot.skip(ftype)
17293 
      elif fid == 1:
17294 
        if ftype == TType.STRUCT:
17295 
          self.ex = TransactionServiceException()
17296 
          self.ex.read(iprot)
17297 
        else:
17298 
          iprot.skip(ftype)
17299 
      else:
17300 
        iprot.skip(ftype)
17301 
      iprot.readFieldEnd()
17302 
    iprot.readStructEnd()
17303 
 
17304 
  def write(self, oprot):
17305 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17306 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17307 
      return
17308 
    oprot.writeStructBegin('toggleDOAFlag_result')
3431 rajveer 17309 
    if self.success is not None:
2536 chandransh 17310 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
17311 
      oprot.writeBool(self.success)
17312 
      oprot.writeFieldEnd()
3431 rajveer 17313 
    if self.ex is not None:
2536 chandransh 17314 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
17315 
      self.ex.write(oprot)
17316 
      oprot.writeFieldEnd()
17317 
    oprot.writeFieldStop()
17318 
    oprot.writeStructEnd()
17319 
 
3431 rajveer 17320 
  def validate(self):
17321 
    return
17322 
 
17323 
 
2536 chandransh 17324 
  def __repr__(self):
17325 
    L = ['%s=%r' % (key, value)
17326 
      for key, value in self.__dict__.iteritems()]
17327 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17328 
 
17329 
  def __eq__(self, other):
17330 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17331 
 
17332 
  def __ne__(self, other):
17333 
    return not (self == other)
17334 
 
4712 rajveer 17335 
class markOrderAsDelivered_args:
17336 
  """
17337 
  Attributes:
17338 
   - orderId
17339 
   - deliveryTimestamp
17340 
   - receiver
17341 
  """
17342 
 
17343 
  thrift_spec = None
17344 
  def __init__(self, orderId=None, deliveryTimestamp=None, receiver=None,):
17345 
    self.orderId = orderId
17346 
    self.deliveryTimestamp = deliveryTimestamp
17347 
    self.receiver = receiver
17348 
 
17349 
  def read(self, iprot):
17350 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17351 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17352 
      return
17353 
    iprot.readStructBegin()
17354 
    while True:
17355 
      (fname, ftype, fid) = iprot.readFieldBegin()
17356 
      if ftype == TType.STOP:
17357 
        break
17358 
      if fid == 1:
17359 
        if ftype == TType.I64:
17360 
          self.orderId = iprot.readI64();
17361 
        else:
17362 
          iprot.skip(ftype)
17363 
      elif fid == 2:
17364 
        if ftype == TType.I64:
17365 
          self.deliveryTimestamp = iprot.readI64();
17366 
        else:
17367 
          iprot.skip(ftype)
17368 
      elif fid == -1:
17369 
        if ftype == TType.STRING:
17370 
          self.receiver = iprot.readString();
17371 
        else:
17372 
          iprot.skip(ftype)
17373 
      else:
17374 
        iprot.skip(ftype)
17375 
      iprot.readFieldEnd()
17376 
    iprot.readStructEnd()
17377 
 
17378 
  def write(self, oprot):
17379 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17380 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17381 
      return
17382 
    oprot.writeStructBegin('markOrderAsDelivered_args')
17383 
    if self.receiver is not None:
17384 
      oprot.writeFieldBegin('receiver', TType.STRING, -1)
17385 
      oprot.writeString(self.receiver)
17386 
      oprot.writeFieldEnd()
17387 
    if self.orderId is not None:
17388 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
17389 
      oprot.writeI64(self.orderId)
17390 
      oprot.writeFieldEnd()
17391 
    if self.deliveryTimestamp is not None:
17392 
      oprot.writeFieldBegin('deliveryTimestamp', TType.I64, 2)
17393 
      oprot.writeI64(self.deliveryTimestamp)
17394 
      oprot.writeFieldEnd()
17395 
    oprot.writeFieldStop()
17396 
    oprot.writeStructEnd()
17397 
 
17398 
  def validate(self):
17399 
    return
17400 
 
17401 
 
17402 
  def __repr__(self):
17403 
    L = ['%s=%r' % (key, value)
17404 
      for key, value in self.__dict__.iteritems()]
17405 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17406 
 
17407 
  def __eq__(self, other):
17408 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17409 
 
17410 
  def __ne__(self, other):
17411 
    return not (self == other)
17412 
 
17413 
class markOrderAsDelivered_result:
17414 
  """
17415 
  Attributes:
17416 
   - ex
17417 
  """
17418 
 
17419 
  thrift_spec = (
17420 
    None, # 0
17421 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
17422 
  )
17423 
 
17424 
  def __init__(self, ex=None,):
17425 
    self.ex = ex
17426 
 
17427 
  def read(self, iprot):
17428 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17429 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17430 
      return
17431 
    iprot.readStructBegin()
17432 
    while True:
17433 
      (fname, ftype, fid) = iprot.readFieldBegin()
17434 
      if ftype == TType.STOP:
17435 
        break
17436 
      if fid == 1:
17437 
        if ftype == TType.STRUCT:
17438 
          self.ex = TransactionServiceException()
17439 
          self.ex.read(iprot)
17440 
        else:
17441 
          iprot.skip(ftype)
17442 
      else:
17443 
        iprot.skip(ftype)
17444 
      iprot.readFieldEnd()
17445 
    iprot.readStructEnd()
17446 
 
17447 
  def write(self, oprot):
17448 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17449 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17450 
      return
17451 
    oprot.writeStructBegin('markOrderAsDelivered_result')
17452 
    if self.ex is not None:
17453 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
17454 
      self.ex.write(oprot)
17455 
      oprot.writeFieldEnd()
17456 
    oprot.writeFieldStop()
17457 
    oprot.writeStructEnd()
17458 
 
17459 
  def validate(self):
17460 
    return
17461 
 
17462 
 
17463 
  def __repr__(self):
17464 
    L = ['%s=%r' % (key, value)
17465 
      for key, value in self.__dict__.iteritems()]
17466 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17467 
 
17468 
  def __eq__(self, other):
17469 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17470 
 
17471 
  def __ne__(self, other):
17472 
    return not (self == other)
17473 
 
5553 rajveer 17474 
class markOrderAsReceivedAtStore_args:
17475 
  """
17476 
  Attributes:
17477 
   - orderId
17478 
   - deliveryTimestamp
17479 
  """
17480 
 
17481 
  thrift_spec = (
17482 
    None, # 0
17483 
    (1, TType.I64, 'orderId', None, None, ), # 1
17484 
    (2, TType.I64, 'deliveryTimestamp', None, None, ), # 2
17485 
  )
17486 
 
17487 
  def __init__(self, orderId=None, deliveryTimestamp=None,):
17488 
    self.orderId = orderId
17489 
    self.deliveryTimestamp = deliveryTimestamp
17490 
 
17491 
  def read(self, iprot):
17492 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17493 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17494 
      return
17495 
    iprot.readStructBegin()
17496 
    while True:
17497 
      (fname, ftype, fid) = iprot.readFieldBegin()
17498 
      if ftype == TType.STOP:
17499 
        break
17500 
      if fid == 1:
17501 
        if ftype == TType.I64:
17502 
          self.orderId = iprot.readI64();
17503 
        else:
17504 
          iprot.skip(ftype)
17505 
      elif fid == 2:
17506 
        if ftype == TType.I64:
17507 
          self.deliveryTimestamp = iprot.readI64();
17508 
        else:
17509 
          iprot.skip(ftype)
17510 
      else:
17511 
        iprot.skip(ftype)
17512 
      iprot.readFieldEnd()
17513 
    iprot.readStructEnd()
17514 
 
17515 
  def write(self, oprot):
17516 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17517 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17518 
      return
17519 
    oprot.writeStructBegin('markOrderAsReceivedAtStore_args')
17520 
    if self.orderId is not None:
17521 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
17522 
      oprot.writeI64(self.orderId)
17523 
      oprot.writeFieldEnd()
17524 
    if self.deliveryTimestamp is not None:
17525 
      oprot.writeFieldBegin('deliveryTimestamp', TType.I64, 2)
17526 
      oprot.writeI64(self.deliveryTimestamp)
17527 
      oprot.writeFieldEnd()
17528 
    oprot.writeFieldStop()
17529 
    oprot.writeStructEnd()
17530 
 
17531 
  def validate(self):
17532 
    return
17533 
 
17534 
 
17535 
  def __repr__(self):
17536 
    L = ['%s=%r' % (key, value)
17537 
      for key, value in self.__dict__.iteritems()]
17538 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17539 
 
17540 
  def __eq__(self, other):
17541 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17542 
 
17543 
  def __ne__(self, other):
17544 
    return not (self == other)
17545 
 
17546 
class markOrderAsReceivedAtStore_result:
17547 
  """
17548 
  Attributes:
17549 
   - ex
17550 
  """
17551 
 
17552 
  thrift_spec = (
17553 
    None, # 0
17554 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
17555 
  )
17556 
 
17557 
  def __init__(self, ex=None,):
17558 
    self.ex = ex
17559 
 
17560 
  def read(self, iprot):
17561 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17562 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17563 
      return
17564 
    iprot.readStructBegin()
17565 
    while True:
17566 
      (fname, ftype, fid) = iprot.readFieldBegin()
17567 
      if ftype == TType.STOP:
17568 
        break
17569 
      if fid == 1:
17570 
        if ftype == TType.STRUCT:
17571 
          self.ex = TransactionServiceException()
17572 
          self.ex.read(iprot)
17573 
        else:
17574 
          iprot.skip(ftype)
17575 
      else:
17576 
        iprot.skip(ftype)
17577 
      iprot.readFieldEnd()
17578 
    iprot.readStructEnd()
17579 
 
17580 
  def write(self, oprot):
17581 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17582 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17583 
      return
17584 
    oprot.writeStructBegin('markOrderAsReceivedAtStore_result')
17585 
    if self.ex is not None:
17586 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
17587 
      self.ex.write(oprot)
17588 
      oprot.writeFieldEnd()
17589 
    oprot.writeFieldStop()
17590 
    oprot.writeStructEnd()
17591 
 
17592 
  def validate(self):
17593 
    return
17594 
 
17595 
 
17596 
  def __repr__(self):
17597 
    L = ['%s=%r' % (key, value)
17598 
      for key, value in self.__dict__.iteritems()]
17599 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17600 
 
17601 
  def __eq__(self, other):
17602 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17603 
 
17604 
  def __ne__(self, other):
17605 
    return not (self == other)
17606 
 
4454 rajveer 17607 
class markOrderDoaRequestReceived_args:
17608 
  """
17609 
  Attributes:
17610 
   - orderId
17611 
  """
17612 
 
17613 
  thrift_spec = (
17614 
    None, # 0
17615 
    (1, TType.I64, 'orderId', None, None, ), # 1
17616 
  )
17617 
 
17618 
  def __init__(self, orderId=None,):
17619 
    self.orderId = orderId
17620 
 
17621 
  def read(self, iprot):
17622 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17623 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17624 
      return
17625 
    iprot.readStructBegin()
17626 
    while True:
17627 
      (fname, ftype, fid) = iprot.readFieldBegin()
17628 
      if ftype == TType.STOP:
17629 
        break
17630 
      if fid == 1:
17631 
        if ftype == TType.I64:
17632 
          self.orderId = iprot.readI64();
17633 
        else:
17634 
          iprot.skip(ftype)
17635 
      else:
17636 
        iprot.skip(ftype)
17637 
      iprot.readFieldEnd()
17638 
    iprot.readStructEnd()
17639 
 
17640 
  def write(self, oprot):
17641 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17642 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17643 
      return
17644 
    oprot.writeStructBegin('markOrderDoaRequestReceived_args')
17645 
    if self.orderId is not None:
17646 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
17647 
      oprot.writeI64(self.orderId)
17648 
      oprot.writeFieldEnd()
17649 
    oprot.writeFieldStop()
17650 
    oprot.writeStructEnd()
17651 
 
17652 
  def validate(self):
17653 
    return
17654 
 
17655 
 
17656 
  def __repr__(self):
17657 
    L = ['%s=%r' % (key, value)
17658 
      for key, value in self.__dict__.iteritems()]
17659 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17660 
 
17661 
  def __eq__(self, other):
17662 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17663 
 
17664 
  def __ne__(self, other):
17665 
    return not (self == other)
17666 
 
17667 
class markOrderDoaRequestReceived_result:
17668 
  """
17669 
  Attributes:
17670 
   - success
17671 
   - ex
17672 
  """
17673 
 
17674 
  thrift_spec = (
17675 
    (0, TType.BOOL, 'success', None, None, ), # 0
17676 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
17677 
  )
17678 
 
17679 
  def __init__(self, success=None, ex=None,):
17680 
    self.success = success
17681 
    self.ex = ex
17682 
 
17683 
  def read(self, iprot):
17684 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17685 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17686 
      return
17687 
    iprot.readStructBegin()
17688 
    while True:
17689 
      (fname, ftype, fid) = iprot.readFieldBegin()
17690 
      if ftype == TType.STOP:
17691 
        break
17692 
      if fid == 0:
17693 
        if ftype == TType.BOOL:
17694 
          self.success = iprot.readBool();
17695 
        else:
17696 
          iprot.skip(ftype)
17697 
      elif fid == 1:
17698 
        if ftype == TType.STRUCT:
17699 
          self.ex = TransactionServiceException()
17700 
          self.ex.read(iprot)
17701 
        else:
17702 
          iprot.skip(ftype)
17703 
      else:
17704 
        iprot.skip(ftype)
17705 
      iprot.readFieldEnd()
17706 
    iprot.readStructEnd()
17707 
 
17708 
  def write(self, oprot):
17709 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17710 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17711 
      return
17712 
    oprot.writeStructBegin('markOrderDoaRequestReceived_result')
17713 
    if self.success is not None:
17714 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
17715 
      oprot.writeBool(self.success)
17716 
      oprot.writeFieldEnd()
17717 
    if self.ex is not None:
17718 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
17719 
      self.ex.write(oprot)
17720 
      oprot.writeFieldEnd()
17721 
    oprot.writeFieldStop()
17722 
    oprot.writeStructEnd()
17723 
 
17724 
  def validate(self):
17725 
    return
17726 
 
17727 
 
17728 
  def __repr__(self):
17729 
    L = ['%s=%r' % (key, value)
17730 
      for key, value in self.__dict__.iteritems()]
17731 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17732 
 
17733 
  def __eq__(self, other):
17734 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17735 
 
17736 
  def __ne__(self, other):
17737 
    return not (self == other)
17738 
 
17739 
class markOrderDoaRequestAuthorized_args:
17740 
  """
17741 
  Attributes:
17742 
   - orderId
17743 
   - isAuthorized
17744 
  """
17745 
 
17746 
  thrift_spec = (
17747 
    None, # 0
17748 
    (1, TType.I64, 'orderId', None, None, ), # 1
17749 
    (2, TType.BOOL, 'isAuthorized', None, None, ), # 2
17750 
  )
17751 
 
17752 
  def __init__(self, orderId=None, isAuthorized=None,):
17753 
    self.orderId = orderId
17754 
    self.isAuthorized = isAuthorized
17755 
 
17756 
  def read(self, iprot):
17757 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17758 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17759 
      return
17760 
    iprot.readStructBegin()
17761 
    while True:
17762 
      (fname, ftype, fid) = iprot.readFieldBegin()
17763 
      if ftype == TType.STOP:
17764 
        break
17765 
      if fid == 1:
17766 
        if ftype == TType.I64:
17767 
          self.orderId = iprot.readI64();
17768 
        else:
17769 
          iprot.skip(ftype)
17770 
      elif fid == 2:
17771 
        if ftype == TType.BOOL:
17772 
          self.isAuthorized = iprot.readBool();
17773 
        else:
17774 
          iprot.skip(ftype)
17775 
      else:
17776 
        iprot.skip(ftype)
17777 
      iprot.readFieldEnd()
17778 
    iprot.readStructEnd()
17779 
 
17780 
  def write(self, oprot):
17781 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17782 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17783 
      return
17784 
    oprot.writeStructBegin('markOrderDoaRequestAuthorized_args')
17785 
    if self.orderId is not None:
17786 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
17787 
      oprot.writeI64(self.orderId)
17788 
      oprot.writeFieldEnd()
17789 
    if self.isAuthorized is not None:
17790 
      oprot.writeFieldBegin('isAuthorized', TType.BOOL, 2)
17791 
      oprot.writeBool(self.isAuthorized)
17792 
      oprot.writeFieldEnd()
17793 
    oprot.writeFieldStop()
17794 
    oprot.writeStructEnd()
17795 
 
17796 
  def validate(self):
17797 
    return
17798 
 
17799 
 
17800 
  def __repr__(self):
17801 
    L = ['%s=%r' % (key, value)
17802 
      for key, value in self.__dict__.iteritems()]
17803 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17804 
 
17805 
  def __eq__(self, other):
17806 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17807 
 
17808 
  def __ne__(self, other):
17809 
    return not (self == other)
17810 
 
17811 
class markOrderDoaRequestAuthorized_result:
17812 
  """
17813 
  Attributes:
17814 
   - success
17815 
   - ex
17816 
  """
17817 
 
17818 
  thrift_spec = (
17819 
    (0, TType.BOOL, 'success', None, None, ), # 0
17820 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
17821 
  )
17822 
 
17823 
  def __init__(self, success=None, ex=None,):
17824 
    self.success = success
17825 
    self.ex = ex
17826 
 
17827 
  def read(self, iprot):
17828 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17829 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17830 
      return
17831 
    iprot.readStructBegin()
17832 
    while True:
17833 
      (fname, ftype, fid) = iprot.readFieldBegin()
17834 
      if ftype == TType.STOP:
17835 
        break
17836 
      if fid == 0:
17837 
        if ftype == TType.BOOL:
17838 
          self.success = iprot.readBool();
17839 
        else:
17840 
          iprot.skip(ftype)
17841 
      elif fid == 1:
17842 
        if ftype == TType.STRUCT:
17843 
          self.ex = TransactionServiceException()
17844 
          self.ex.read(iprot)
17845 
        else:
17846 
          iprot.skip(ftype)
17847 
      else:
17848 
        iprot.skip(ftype)
17849 
      iprot.readFieldEnd()
17850 
    iprot.readStructEnd()
17851 
 
17852 
  def write(self, oprot):
17853 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17854 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17855 
      return
17856 
    oprot.writeStructBegin('markOrderDoaRequestAuthorized_result')
17857 
    if self.success is not None:
17858 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
17859 
      oprot.writeBool(self.success)
17860 
      oprot.writeFieldEnd()
17861 
    if self.ex is not None:
17862 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
17863 
      self.ex.write(oprot)
17864 
      oprot.writeFieldEnd()
17865 
    oprot.writeFieldStop()
17866 
    oprot.writeStructEnd()
17867 
 
17868 
  def validate(self):
17869 
    return
17870 
 
17871 
 
17872 
  def __repr__(self):
17873 
    L = ['%s=%r' % (key, value)
17874 
      for key, value in self.__dict__.iteritems()]
17875 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17876 
 
17877 
  def __eq__(self, other):
17878 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17879 
 
17880 
  def __ne__(self, other):
17881 
    return not (self == other)
17882 
 
4488 rajveer 17883 
class markOrderReturnRequestReceived_args:
17884 
  """
17885 
  Attributes:
17886 
   - orderId
17887 
  """
17888 
 
17889 
  thrift_spec = (
17890 
    None, # 0
17891 
    (1, TType.I64, 'orderId', None, None, ), # 1
17892 
  )
17893 
 
17894 
  def __init__(self, orderId=None,):
17895 
    self.orderId = orderId
17896 
 
17897 
  def read(self, iprot):
17898 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17899 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17900 
      return
17901 
    iprot.readStructBegin()
17902 
    while True:
17903 
      (fname, ftype, fid) = iprot.readFieldBegin()
17904 
      if ftype == TType.STOP:
17905 
        break
17906 
      if fid == 1:
17907 
        if ftype == TType.I64:
17908 
          self.orderId = iprot.readI64();
17909 
        else:
17910 
          iprot.skip(ftype)
17911 
      else:
17912 
        iprot.skip(ftype)
17913 
      iprot.readFieldEnd()
17914 
    iprot.readStructEnd()
17915 
 
17916 
  def write(self, oprot):
17917 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17918 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17919 
      return
17920 
    oprot.writeStructBegin('markOrderReturnRequestReceived_args')
17921 
    if self.orderId is not None:
17922 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
17923 
      oprot.writeI64(self.orderId)
17924 
      oprot.writeFieldEnd()
17925 
    oprot.writeFieldStop()
17926 
    oprot.writeStructEnd()
17927 
 
17928 
  def validate(self):
17929 
    return
17930 
 
17931 
 
17932 
  def __repr__(self):
17933 
    L = ['%s=%r' % (key, value)
17934 
      for key, value in self.__dict__.iteritems()]
17935 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17936 
 
17937 
  def __eq__(self, other):
17938 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17939 
 
17940 
  def __ne__(self, other):
17941 
    return not (self == other)
17942 
 
17943 
class markOrderReturnRequestReceived_result:
17944 
  """
17945 
  Attributes:
17946 
   - success
17947 
   - ex
17948 
  """
17949 
 
17950 
  thrift_spec = (
17951 
    (0, TType.BOOL, 'success', None, None, ), # 0
17952 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
17953 
  )
17954 
 
17955 
  def __init__(self, success=None, ex=None,):
17956 
    self.success = success
17957 
    self.ex = ex
17958 
 
17959 
  def read(self, iprot):
17960 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17961 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17962 
      return
17963 
    iprot.readStructBegin()
17964 
    while True:
17965 
      (fname, ftype, fid) = iprot.readFieldBegin()
17966 
      if ftype == TType.STOP:
17967 
        break
17968 
      if fid == 0:
17969 
        if ftype == TType.BOOL:
17970 
          self.success = iprot.readBool();
17971 
        else:
17972 
          iprot.skip(ftype)
17973 
      elif fid == 1:
17974 
        if ftype == TType.STRUCT:
17975 
          self.ex = TransactionServiceException()
17976 
          self.ex.read(iprot)
17977 
        else:
17978 
          iprot.skip(ftype)
17979 
      else:
17980 
        iprot.skip(ftype)
17981 
      iprot.readFieldEnd()
17982 
    iprot.readStructEnd()
17983 
 
17984 
  def write(self, oprot):
17985 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17986 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17987 
      return
17988 
    oprot.writeStructBegin('markOrderReturnRequestReceived_result')
17989 
    if self.success is not None:
17990 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
17991 
      oprot.writeBool(self.success)
17992 
      oprot.writeFieldEnd()
17993 
    if self.ex is not None:
17994 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
17995 
      self.ex.write(oprot)
17996 
      oprot.writeFieldEnd()
17997 
    oprot.writeFieldStop()
17998 
    oprot.writeStructEnd()
17999 
 
18000 
  def validate(self):
18001 
    return
18002 
 
18003 
 
18004 
  def __repr__(self):
18005 
    L = ['%s=%r' % (key, value)
18006 
      for key, value in self.__dict__.iteritems()]
18007 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18008 
 
18009 
  def __eq__(self, other):
18010 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18011 
 
18012 
  def __ne__(self, other):
18013 
    return not (self == other)
18014 
 
18015 
class markOrderReturnRequestAuthorized_args:
18016 
  """
18017 
  Attributes:
18018 
   - orderId
18019 
   - isAuthorized
18020 
  """
18021 
 
18022 
  thrift_spec = (
18023 
    None, # 0
18024 
    (1, TType.I64, 'orderId', None, None, ), # 1
18025 
    (2, TType.BOOL, 'isAuthorized', None, None, ), # 2
18026 
  )
18027 
 
18028 
  def __init__(self, orderId=None, isAuthorized=None,):
18029 
    self.orderId = orderId
18030 
    self.isAuthorized = isAuthorized
18031 
 
18032 
  def read(self, iprot):
18033 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18034 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18035 
      return
18036 
    iprot.readStructBegin()
18037 
    while True:
18038 
      (fname, ftype, fid) = iprot.readFieldBegin()
18039 
      if ftype == TType.STOP:
18040 
        break
18041 
      if fid == 1:
18042 
        if ftype == TType.I64:
18043 
          self.orderId = iprot.readI64();
18044 
        else:
18045 
          iprot.skip(ftype)
18046 
      elif fid == 2:
18047 
        if ftype == TType.BOOL:
18048 
          self.isAuthorized = iprot.readBool();
18049 
        else:
18050 
          iprot.skip(ftype)
18051 
      else:
18052 
        iprot.skip(ftype)
18053 
      iprot.readFieldEnd()
18054 
    iprot.readStructEnd()
18055 
 
18056 
  def write(self, oprot):
18057 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18058 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18059 
      return
18060 
    oprot.writeStructBegin('markOrderReturnRequestAuthorized_args')
18061 
    if self.orderId is not None:
18062 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
18063 
      oprot.writeI64(self.orderId)
18064 
      oprot.writeFieldEnd()
18065 
    if self.isAuthorized is not None:
18066 
      oprot.writeFieldBegin('isAuthorized', TType.BOOL, 2)
18067 
      oprot.writeBool(self.isAuthorized)
18068 
      oprot.writeFieldEnd()
18069 
    oprot.writeFieldStop()
18070 
    oprot.writeStructEnd()
18071 
 
18072 
  def validate(self):
18073 
    return
18074 
 
18075 
 
18076 
  def __repr__(self):
18077 
    L = ['%s=%r' % (key, value)
18078 
      for key, value in self.__dict__.iteritems()]
18079 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18080 
 
18081 
  def __eq__(self, other):
18082 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18083 
 
18084 
  def __ne__(self, other):
18085 
    return not (self == other)
18086 
 
18087 
class markOrderReturnRequestAuthorized_result:
18088 
  """
18089 
  Attributes:
18090 
   - success
18091 
   - ex
18092 
  """
18093 
 
18094 
  thrift_spec = (
18095 
    (0, TType.BOOL, 'success', None, None, ), # 0
18096 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
18097 
  )
18098 
 
18099 
  def __init__(self, success=None, ex=None,):
18100 
    self.success = success
18101 
    self.ex = ex
18102 
 
18103 
  def read(self, iprot):
18104 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18105 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18106 
      return
18107 
    iprot.readStructBegin()
18108 
    while True:
18109 
      (fname, ftype, fid) = iprot.readFieldBegin()
18110 
      if ftype == TType.STOP:
18111 
        break
18112 
      if fid == 0:
18113 
        if ftype == TType.BOOL:
18114 
          self.success = iprot.readBool();
18115 
        else:
18116 
          iprot.skip(ftype)
18117 
      elif fid == 1:
18118 
        if ftype == TType.STRUCT:
18119 
          self.ex = TransactionServiceException()
18120 
          self.ex.read(iprot)
18121 
        else:
18122 
          iprot.skip(ftype)
18123 
      else:
18124 
        iprot.skip(ftype)
18125 
      iprot.readFieldEnd()
18126 
    iprot.readStructEnd()
18127 
 
18128 
  def write(self, oprot):
18129 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18130 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18131 
      return
18132 
    oprot.writeStructBegin('markOrderReturnRequestAuthorized_result')
18133 
    if self.success is not None:
18134 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
18135 
      oprot.writeBool(self.success)
18136 
      oprot.writeFieldEnd()
18137 
    if self.ex is not None:
18138 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
18139 
      self.ex.write(oprot)
18140 
      oprot.writeFieldEnd()
18141 
    oprot.writeFieldStop()
18142 
    oprot.writeStructEnd()
18143 
 
18144 
  def validate(self):
18145 
    return
18146 
 
18147 
 
18148 
  def __repr__(self):
18149 
    L = ['%s=%r' % (key, value)
18150 
      for key, value in self.__dict__.iteritems()]
18151 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18152 
 
18153 
  def __eq__(self, other):
18154 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18155 
 
18156 
  def __ne__(self, other):
18157 
    return not (self == other)
18158 
 
2536 chandransh 18159 
class requestPickupNumber_args:
18160 
  """
18161 
  Attributes:
18162 
   - orderId
4579 rajveer 18163 
   - providerId
2536 chandransh 18164 
  """
18165 
 
18166 
  thrift_spec = (
18167 
    None, # 0
18168 
    (1, TType.I64, 'orderId', None, None, ), # 1
4579 rajveer 18169 
    (2, TType.I64, 'providerId', None, None, ), # 2
2536 chandransh 18170 
  )
18171 
 
4579 rajveer 18172 
  def __init__(self, orderId=None, providerId=None,):
2536 chandransh 18173 
    self.orderId = orderId
4579 rajveer 18174 
    self.providerId = providerId
2536 chandransh 18175 
 
18176 
  def read(self, iprot):
18177 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18178 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18179 
      return
18180 
    iprot.readStructBegin()
18181 
    while True:
18182 
      (fname, ftype, fid) = iprot.readFieldBegin()
18183 
      if ftype == TType.STOP:
18184 
        break
18185 
      if fid == 1:
18186 
        if ftype == TType.I64:
18187 
          self.orderId = iprot.readI64();
18188 
        else:
18189 
          iprot.skip(ftype)
4579 rajveer 18190 
      elif fid == 2:
18191 
        if ftype == TType.I64:
18192 
          self.providerId = iprot.readI64();
18193 
        else:
18194 
          iprot.skip(ftype)
2536 chandransh 18195 
      else:
18196 
        iprot.skip(ftype)
18197 
      iprot.readFieldEnd()
18198 
    iprot.readStructEnd()
18199 
 
18200 
  def write(self, oprot):
18201 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18202 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18203 
      return
18204 
    oprot.writeStructBegin('requestPickupNumber_args')
3431 rajveer 18205 
    if self.orderId is not None:
2536 chandransh 18206 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
18207 
      oprot.writeI64(self.orderId)
18208 
      oprot.writeFieldEnd()
4579 rajveer 18209 
    if self.providerId is not None:
18210 
      oprot.writeFieldBegin('providerId', TType.I64, 2)
18211 
      oprot.writeI64(self.providerId)
18212 
      oprot.writeFieldEnd()
2536 chandransh 18213 
    oprot.writeFieldStop()
18214 
    oprot.writeStructEnd()
18215 
 
3431 rajveer 18216 
  def validate(self):
18217 
    return
18218 
 
18219 
 
2536 chandransh 18220 
  def __repr__(self):
18221 
    L = ['%s=%r' % (key, value)
18222 
      for key, value in self.__dict__.iteritems()]
18223 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18224 
 
18225 
  def __eq__(self, other):
18226 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18227 
 
18228 
  def __ne__(self, other):
18229 
    return not (self == other)
18230 
 
18231 
class requestPickupNumber_result:
18232 
  """
18233 
  Attributes:
18234 
   - success
18235 
   - ex
18236 
  """
18237 
 
18238 
  thrift_spec = (
18239 
    (0, TType.BOOL, 'success', None, None, ), # 0
18240 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
18241 
  )
18242 
 
18243 
  def __init__(self, success=None, ex=None,):
18244 
    self.success = success
18245 
    self.ex = ex
18246 
 
18247 
  def read(self, iprot):
18248 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18249 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18250 
      return
18251 
    iprot.readStructBegin()
18252 
    while True:
18253 
      (fname, ftype, fid) = iprot.readFieldBegin()
18254 
      if ftype == TType.STOP:
18255 
        break
18256 
      if fid == 0:
18257 
        if ftype == TType.BOOL:
18258 
          self.success = iprot.readBool();
18259 
        else:
18260 
          iprot.skip(ftype)
18261 
      elif fid == 1:
18262 
        if ftype == TType.STRUCT:
18263 
          self.ex = TransactionServiceException()
18264 
          self.ex.read(iprot)
18265 
        else:
18266 
          iprot.skip(ftype)
18267 
      else:
18268 
        iprot.skip(ftype)
18269 
      iprot.readFieldEnd()
18270 
    iprot.readStructEnd()
18271 
 
18272 
  def write(self, oprot):
18273 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18274 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18275 
      return
18276 
    oprot.writeStructBegin('requestPickupNumber_result')
3431 rajveer 18277 
    if self.success is not None:
2536 chandransh 18278 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
18279 
      oprot.writeBool(self.success)
18280 
      oprot.writeFieldEnd()
3431 rajveer 18281 
    if self.ex is not None:
2536 chandransh 18282 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
18283 
      self.ex.write(oprot)
18284 
      oprot.writeFieldEnd()
18285 
    oprot.writeFieldStop()
18286 
    oprot.writeStructEnd()
18287 
 
3431 rajveer 18288 
  def validate(self):
18289 
    return
18290 
 
18291 
 
2536 chandransh 18292 
  def __repr__(self):
18293 
    L = ['%s=%r' % (key, value)
18294 
      for key, value in self.__dict__.iteritems()]
18295 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18296 
 
18297 
  def __eq__(self, other):
18298 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18299 
 
18300 
  def __ne__(self, other):
18301 
    return not (self == other)
18302 
 
18303 
class authorizePickup_args:
18304 
  """
18305 
  Attributes:
18306 
   - orderId
18307 
   - pickupNumber
4602 rajveer 18308 
   - providerId
2536 chandransh 18309 
  """
18310 
 
18311 
  thrift_spec = (
18312 
    None, # 0
18313 
    (1, TType.I64, 'orderId', None, None, ), # 1
18314 
    (2, TType.STRING, 'pickupNumber', None, None, ), # 2
4602 rajveer 18315 
    (3, TType.I64, 'providerId', None, None, ), # 3
2536 chandransh 18316 
  )
18317 
 
4602 rajveer 18318 
  def __init__(self, orderId=None, pickupNumber=None, providerId=None,):
2536 chandransh 18319 
    self.orderId = orderId
18320 
    self.pickupNumber = pickupNumber
4602 rajveer 18321 
    self.providerId = providerId
2536 chandransh 18322 
 
18323 
  def read(self, iprot):
18324 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18325 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18326 
      return
18327 
    iprot.readStructBegin()
18328 
    while True:
18329 
      (fname, ftype, fid) = iprot.readFieldBegin()
18330 
      if ftype == TType.STOP:
18331 
        break
18332 
      if fid == 1:
18333 
        if ftype == TType.I64:
18334 
          self.orderId = iprot.readI64();
18335 
        else:
18336 
          iprot.skip(ftype)
18337 
      elif fid == 2:
18338 
        if ftype == TType.STRING:
18339 
          self.pickupNumber = iprot.readString();
18340 
        else:
18341 
          iprot.skip(ftype)
4602 rajveer 18342 
      elif fid == 3:
18343 
        if ftype == TType.I64:
18344 
          self.providerId = iprot.readI64();
18345 
        else:
18346 
          iprot.skip(ftype)
2536 chandransh 18347 
      else:
18348 
        iprot.skip(ftype)
18349 
      iprot.readFieldEnd()
18350 
    iprot.readStructEnd()
18351 
 
18352 
  def write(self, oprot):
18353 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18354 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18355 
      return
18356 
    oprot.writeStructBegin('authorizePickup_args')
3431 rajveer 18357 
    if self.orderId is not None:
2536 chandransh 18358 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
18359 
      oprot.writeI64(self.orderId)
18360 
      oprot.writeFieldEnd()
3431 rajveer 18361 
    if self.pickupNumber is not None:
2536 chandransh 18362 
      oprot.writeFieldBegin('pickupNumber', TType.STRING, 2)
18363 
      oprot.writeString(self.pickupNumber)
18364 
      oprot.writeFieldEnd()
4602 rajveer 18365 
    if self.providerId is not None:
18366 
      oprot.writeFieldBegin('providerId', TType.I64, 3)
18367 
      oprot.writeI64(self.providerId)
18368 
      oprot.writeFieldEnd()
2536 chandransh 18369 
    oprot.writeFieldStop()
18370 
    oprot.writeStructEnd()
18371 
 
3431 rajveer 18372 
  def validate(self):
18373 
    return
18374 
 
18375 
 
2536 chandransh 18376 
  def __repr__(self):
18377 
    L = ['%s=%r' % (key, value)
18378 
      for key, value in self.__dict__.iteritems()]
18379 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18380 
 
18381 
  def __eq__(self, other):
18382 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18383 
 
18384 
  def __ne__(self, other):
18385 
    return not (self == other)
18386 
 
18387 
class authorizePickup_result:
18388 
  """
18389 
  Attributes:
18390 
   - success
18391 
   - ex
18392 
  """
18393 
 
18394 
  thrift_spec = (
18395 
    (0, TType.BOOL, 'success', None, None, ), # 0
18396 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
18397 
  )
18398 
 
18399 
  def __init__(self, success=None, ex=None,):
18400 
    self.success = success
18401 
    self.ex = ex
18402 
 
18403 
  def read(self, iprot):
18404 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18405 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18406 
      return
18407 
    iprot.readStructBegin()
18408 
    while True:
18409 
      (fname, ftype, fid) = iprot.readFieldBegin()
18410 
      if ftype == TType.STOP:
18411 
        break
18412 
      if fid == 0:
18413 
        if ftype == TType.BOOL:
18414 
          self.success = iprot.readBool();
18415 
        else:
18416 
          iprot.skip(ftype)
18417 
      elif fid == 1:
18418 
        if ftype == TType.STRUCT:
18419 
          self.ex = TransactionServiceException()
18420 
          self.ex.read(iprot)
18421 
        else:
18422 
          iprot.skip(ftype)
18423 
      else:
18424 
        iprot.skip(ftype)
18425 
      iprot.readFieldEnd()
18426 
    iprot.readStructEnd()
18427 
 
18428 
  def write(self, oprot):
18429 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18430 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18431 
      return
18432 
    oprot.writeStructBegin('authorizePickup_result')
3431 rajveer 18433 
    if self.success is not None:
2536 chandransh 18434 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
18435 
      oprot.writeBool(self.success)
18436 
      oprot.writeFieldEnd()
3431 rajveer 18437 
    if self.ex is not None:
2536 chandransh 18438 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
18439 
      self.ex.write(oprot)
18440 
      oprot.writeFieldEnd()
18441 
    oprot.writeFieldStop()
18442 
    oprot.writeStructEnd()
18443 
 
3431 rajveer 18444 
  def validate(self):
18445 
    return
18446 
 
18447 
 
2536 chandransh 18448 
  def __repr__(self):
18449 
    L = ['%s=%r' % (key, value)
18450 
      for key, value in self.__dict__.iteritems()]
18451 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18452 
 
18453 
  def __eq__(self, other):
18454 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18455 
 
18456 
  def __ne__(self, other):
18457 
    return not (self == other)
18458 
 
2764 chandransh 18459 
class markDoasAsPickedUp_args:
18460 
  """
18461 
  Attributes:
18462 
   - providerId
18463 
   - pickupDetails
18464 
  """
18465 
 
18466 
  thrift_spec = (
18467 
    None, # 0
18468 
    (1, TType.I64, 'providerId', None, None, ), # 1
18469 
    (2, TType.MAP, 'pickupDetails', (TType.STRING,None,TType.STRING,None), None, ), # 2
18470 
  )
18471 
 
18472 
  def __init__(self, providerId=None, pickupDetails=None,):
18473 
    self.providerId = providerId
18474 
    self.pickupDetails = pickupDetails
18475 
 
18476 
  def read(self, iprot):
18477 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18478 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18479 
      return
18480 
    iprot.readStructBegin()
18481 
    while True:
18482 
      (fname, ftype, fid) = iprot.readFieldBegin()
18483 
      if ftype == TType.STOP:
18484 
        break
18485 
      if fid == 1:
18486 
        if ftype == TType.I64:
18487 
          self.providerId = iprot.readI64();
18488 
        else:
18489 
          iprot.skip(ftype)
18490 
      elif fid == 2:
18491 
        if ftype == TType.MAP:
18492 
          self.pickupDetails = {}
6188 rajveer 18493 
          (_ktype408, _vtype409, _size407 ) = iprot.readMapBegin()
18494 
          for _i411 in xrange(_size407):
18495 
            _key412 = iprot.readString();
18496 
            _val413 = iprot.readString();
18497 
            self.pickupDetails[_key412] = _val413
2764 chandransh 18498 
          iprot.readMapEnd()
18499 
        else:
18500 
          iprot.skip(ftype)
18501 
      else:
18502 
        iprot.skip(ftype)
18503 
      iprot.readFieldEnd()
18504 
    iprot.readStructEnd()
18505 
 
18506 
  def write(self, oprot):
18507 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18508 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18509 
      return
18510 
    oprot.writeStructBegin('markDoasAsPickedUp_args')
3431 rajveer 18511 
    if self.providerId is not None:
2764 chandransh 18512 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
18513 
      oprot.writeI64(self.providerId)
18514 
      oprot.writeFieldEnd()
3431 rajveer 18515 
    if self.pickupDetails is not None:
2764 chandransh 18516 
      oprot.writeFieldBegin('pickupDetails', TType.MAP, 2)
18517 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.pickupDetails))
6188 rajveer 18518 
      for kiter414,viter415 in self.pickupDetails.items():
18519 
        oprot.writeString(kiter414)
18520 
        oprot.writeString(viter415)
2764 chandransh 18521 
      oprot.writeMapEnd()
18522 
      oprot.writeFieldEnd()
18523 
    oprot.writeFieldStop()
18524 
    oprot.writeStructEnd()
18525 
 
3431 rajveer 18526 
  def validate(self):
18527 
    return
18528 
 
18529 
 
2764 chandransh 18530 
  def __repr__(self):
18531 
    L = ['%s=%r' % (key, value)
18532 
      for key, value in self.__dict__.iteritems()]
18533 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18534 
 
18535 
  def __eq__(self, other):
18536 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18537 
 
18538 
  def __ne__(self, other):
18539 
    return not (self == other)
18540 
 
18541 
class markDoasAsPickedUp_result:
4910 phani.kuma 18542 
 
18543 
  thrift_spec = (
18544 
  )
18545 
 
18546 
  def read(self, iprot):
18547 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18548 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18549 
      return
18550 
    iprot.readStructBegin()
18551 
    while True:
18552 
      (fname, ftype, fid) = iprot.readFieldBegin()
18553 
      if ftype == TType.STOP:
18554 
        break
18555 
      else:
18556 
        iprot.skip(ftype)
18557 
      iprot.readFieldEnd()
18558 
    iprot.readStructEnd()
18559 
 
18560 
  def write(self, oprot):
18561 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18562 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18563 
      return
18564 
    oprot.writeStructBegin('markDoasAsPickedUp_result')
18565 
    oprot.writeFieldStop()
18566 
    oprot.writeStructEnd()
18567 
 
18568 
  def validate(self):
18569 
    return
18570 
 
18571 
 
18572 
  def __repr__(self):
18573 
    L = ['%s=%r' % (key, value)
18574 
      for key, value in self.__dict__.iteritems()]
18575 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18576 
 
18577 
  def __eq__(self, other):
18578 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18579 
 
18580 
  def __ne__(self, other):
18581 
    return not (self == other)
18582 
 
18583 
class getDoasNotPickedUp_args:
2764 chandransh 18584 
  """
18585 
  Attributes:
4910 phani.kuma 18586 
   - providerId
18587 
  """
18588 
 
18589 
  thrift_spec = (
18590 
    None, # 0
18591 
    (1, TType.I64, 'providerId', None, None, ), # 1
18592 
  )
18593 
 
18594 
  def __init__(self, providerId=None,):
18595 
    self.providerId = providerId
18596 
 
18597 
  def read(self, iprot):
18598 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18599 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18600 
      return
18601 
    iprot.readStructBegin()
18602 
    while True:
18603 
      (fname, ftype, fid) = iprot.readFieldBegin()
18604 
      if ftype == TType.STOP:
18605 
        break
18606 
      if fid == 1:
18607 
        if ftype == TType.I64:
18608 
          self.providerId = iprot.readI64();
18609 
        else:
18610 
          iprot.skip(ftype)
18611 
      else:
18612 
        iprot.skip(ftype)
18613 
      iprot.readFieldEnd()
18614 
    iprot.readStructEnd()
18615 
 
18616 
  def write(self, oprot):
18617 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18618 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18619 
      return
18620 
    oprot.writeStructBegin('getDoasNotPickedUp_args')
18621 
    if self.providerId is not None:
18622 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
18623 
      oprot.writeI64(self.providerId)
18624 
      oprot.writeFieldEnd()
18625 
    oprot.writeFieldStop()
18626 
    oprot.writeStructEnd()
18627 
 
18628 
  def validate(self):
18629 
    return
18630 
 
18631 
 
18632 
  def __repr__(self):
18633 
    L = ['%s=%r' % (key, value)
18634 
      for key, value in self.__dict__.iteritems()]
18635 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18636 
 
18637 
  def __eq__(self, other):
18638 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18639 
 
18640 
  def __ne__(self, other):
18641 
    return not (self == other)
18642 
 
18643 
class getDoasNotPickedUp_result:
18644 
  """
18645 
  Attributes:
2764 chandransh 18646 
   - success
18647 
  """
18648 
 
18649 
  thrift_spec = (
18650 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
18651 
  )
18652 
 
18653 
  def __init__(self, success=None,):
18654 
    self.success = success
18655 
 
18656 
  def read(self, iprot):
18657 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18658 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18659 
      return
18660 
    iprot.readStructBegin()
18661 
    while True:
18662 
      (fname, ftype, fid) = iprot.readFieldBegin()
18663 
      if ftype == TType.STOP:
18664 
        break
18665 
      if fid == 0:
18666 
        if ftype == TType.LIST:
18667 
          self.success = []
6188 rajveer 18668 
          (_etype419, _size416) = iprot.readListBegin()
18669 
          for _i420 in xrange(_size416):
18670 
            _elem421 = Order()
18671 
            _elem421.read(iprot)
18672 
            self.success.append(_elem421)
2764 chandransh 18673 
          iprot.readListEnd()
18674 
        else:
18675 
          iprot.skip(ftype)
18676 
      else:
18677 
        iprot.skip(ftype)
18678 
      iprot.readFieldEnd()
18679 
    iprot.readStructEnd()
18680 
 
18681 
  def write(self, oprot):
18682 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18683 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18684 
      return
4910 phani.kuma 18685 
    oprot.writeStructBegin('getDoasNotPickedUp_result')
3431 rajveer 18686 
    if self.success is not None:
2764 chandransh 18687 
      oprot.writeFieldBegin('success', TType.LIST, 0)
18688 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 18689 
      for iter422 in self.success:
18690 
        iter422.write(oprot)
2764 chandransh 18691 
      oprot.writeListEnd()
18692 
      oprot.writeFieldEnd()
18693 
    oprot.writeFieldStop()
18694 
    oprot.writeStructEnd()
18695 
 
3431 rajveer 18696 
  def validate(self):
18697 
    return
18698 
 
18699 
 
2764 chandransh 18700 
  def __repr__(self):
18701 
    L = ['%s=%r' % (key, value)
18702 
      for key, value in self.__dict__.iteritems()]
18703 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18704 
 
18705 
  def __eq__(self, other):
18706 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18707 
 
18708 
  def __ne__(self, other):
18709 
    return not (self == other)
18710 
 
4741 phani.kuma 18711 
class markReturnOrdersAsPickedUp_args:
18712 
  """
18713 
  Attributes:
18714 
   - providerId
18715 
   - pickupDetails
18716 
  """
18717 
 
18718 
  thrift_spec = (
18719 
    None, # 0
18720 
    (1, TType.I64, 'providerId', None, None, ), # 1
18721 
    (2, TType.MAP, 'pickupDetails', (TType.STRING,None,TType.STRING,None), None, ), # 2
18722 
  )
18723 
 
18724 
  def __init__(self, providerId=None, pickupDetails=None,):
18725 
    self.providerId = providerId
18726 
    self.pickupDetails = pickupDetails
18727 
 
18728 
  def read(self, iprot):
18729 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18730 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18731 
      return
18732 
    iprot.readStructBegin()
18733 
    while True:
18734 
      (fname, ftype, fid) = iprot.readFieldBegin()
18735 
      if ftype == TType.STOP:
18736 
        break
18737 
      if fid == 1:
18738 
        if ftype == TType.I64:
18739 
          self.providerId = iprot.readI64();
18740 
        else:
18741 
          iprot.skip(ftype)
18742 
      elif fid == 2:
18743 
        if ftype == TType.MAP:
18744 
          self.pickupDetails = {}
6188 rajveer 18745 
          (_ktype424, _vtype425, _size423 ) = iprot.readMapBegin()
18746 
          for _i427 in xrange(_size423):
18747 
            _key428 = iprot.readString();
18748 
            _val429 = iprot.readString();
18749 
            self.pickupDetails[_key428] = _val429
4741 phani.kuma 18750 
          iprot.readMapEnd()
18751 
        else:
18752 
          iprot.skip(ftype)
18753 
      else:
18754 
        iprot.skip(ftype)
18755 
      iprot.readFieldEnd()
18756 
    iprot.readStructEnd()
18757 
 
18758 
  def write(self, oprot):
18759 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18760 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18761 
      return
18762 
    oprot.writeStructBegin('markReturnOrdersAsPickedUp_args')
18763 
    if self.providerId is not None:
18764 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
18765 
      oprot.writeI64(self.providerId)
18766 
      oprot.writeFieldEnd()
18767 
    if self.pickupDetails is not None:
18768 
      oprot.writeFieldBegin('pickupDetails', TType.MAP, 2)
18769 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.pickupDetails))
6188 rajveer 18770 
      for kiter430,viter431 in self.pickupDetails.items():
18771 
        oprot.writeString(kiter430)
18772 
        oprot.writeString(viter431)
4741 phani.kuma 18773 
      oprot.writeMapEnd()
18774 
      oprot.writeFieldEnd()
18775 
    oprot.writeFieldStop()
18776 
    oprot.writeStructEnd()
18777 
 
18778 
  def validate(self):
18779 
    return
18780 
 
18781 
 
18782 
  def __repr__(self):
18783 
    L = ['%s=%r' % (key, value)
18784 
      for key, value in self.__dict__.iteritems()]
18785 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18786 
 
18787 
  def __eq__(self, other):
18788 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18789 
 
18790 
  def __ne__(self, other):
18791 
    return not (self == other)
18792 
 
18793 
class markReturnOrdersAsPickedUp_result:
4910 phani.kuma 18794 
 
18795 
  thrift_spec = (
18796 
  )
18797 
 
18798 
  def read(self, iprot):
18799 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18800 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18801 
      return
18802 
    iprot.readStructBegin()
18803 
    while True:
18804 
      (fname, ftype, fid) = iprot.readFieldBegin()
18805 
      if ftype == TType.STOP:
18806 
        break
18807 
      else:
18808 
        iprot.skip(ftype)
18809 
      iprot.readFieldEnd()
18810 
    iprot.readStructEnd()
18811 
 
18812 
  def write(self, oprot):
18813 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18814 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18815 
      return
18816 
    oprot.writeStructBegin('markReturnOrdersAsPickedUp_result')
18817 
    oprot.writeFieldStop()
18818 
    oprot.writeStructEnd()
18819 
 
18820 
  def validate(self):
18821 
    return
18822 
 
18823 
 
18824 
  def __repr__(self):
18825 
    L = ['%s=%r' % (key, value)
18826 
      for key, value in self.__dict__.iteritems()]
18827 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18828 
 
18829 
  def __eq__(self, other):
18830 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18831 
 
18832 
  def __ne__(self, other):
18833 
    return not (self == other)
18834 
 
18835 
class getReturnOrdersNotPickedUp_args:
4741 phani.kuma 18836 
  """
18837 
  Attributes:
4910 phani.kuma 18838 
   - providerId
18839 
  """
18840 
 
18841 
  thrift_spec = (
18842 
    None, # 0
18843 
    (1, TType.I64, 'providerId', None, None, ), # 1
18844 
  )
18845 
 
18846 
  def __init__(self, providerId=None,):
18847 
    self.providerId = providerId
18848 
 
18849 
  def read(self, iprot):
18850 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18851 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18852 
      return
18853 
    iprot.readStructBegin()
18854 
    while True:
18855 
      (fname, ftype, fid) = iprot.readFieldBegin()
18856 
      if ftype == TType.STOP:
18857 
        break
18858 
      if fid == 1:
18859 
        if ftype == TType.I64:
18860 
          self.providerId = iprot.readI64();
18861 
        else:
18862 
          iprot.skip(ftype)
18863 
      else:
18864 
        iprot.skip(ftype)
18865 
      iprot.readFieldEnd()
18866 
    iprot.readStructEnd()
18867 
 
18868 
  def write(self, oprot):
18869 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18870 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18871 
      return
18872 
    oprot.writeStructBegin('getReturnOrdersNotPickedUp_args')
18873 
    if self.providerId is not None:
18874 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
18875 
      oprot.writeI64(self.providerId)
18876 
      oprot.writeFieldEnd()
18877 
    oprot.writeFieldStop()
18878 
    oprot.writeStructEnd()
18879 
 
18880 
  def validate(self):
18881 
    return
18882 
 
18883 
 
18884 
  def __repr__(self):
18885 
    L = ['%s=%r' % (key, value)
18886 
      for key, value in self.__dict__.iteritems()]
18887 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18888 
 
18889 
  def __eq__(self, other):
18890 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18891 
 
18892 
  def __ne__(self, other):
18893 
    return not (self == other)
18894 
 
18895 
class getReturnOrdersNotPickedUp_result:
18896 
  """
18897 
  Attributes:
4741 phani.kuma 18898 
   - success
18899 
  """
18900 
 
18901 
  thrift_spec = (
18902 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
18903 
  )
18904 
 
18905 
  def __init__(self, success=None,):
18906 
    self.success = success
18907 
 
18908 
  def read(self, iprot):
18909 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18910 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18911 
      return
18912 
    iprot.readStructBegin()
18913 
    while True:
18914 
      (fname, ftype, fid) = iprot.readFieldBegin()
18915 
      if ftype == TType.STOP:
18916 
        break
18917 
      if fid == 0:
18918 
        if ftype == TType.LIST:
18919 
          self.success = []
6188 rajveer 18920 
          (_etype435, _size432) = iprot.readListBegin()
18921 
          for _i436 in xrange(_size432):
18922 
            _elem437 = Order()
18923 
            _elem437.read(iprot)
18924 
            self.success.append(_elem437)
4741 phani.kuma 18925 
          iprot.readListEnd()
18926 
        else:
18927 
          iprot.skip(ftype)
18928 
      else:
18929 
        iprot.skip(ftype)
18930 
      iprot.readFieldEnd()
18931 
    iprot.readStructEnd()
18932 
 
18933 
  def write(self, oprot):
18934 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18935 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18936 
      return
4910 phani.kuma 18937 
    oprot.writeStructBegin('getReturnOrdersNotPickedUp_result')
4741 phani.kuma 18938 
    if self.success is not None:
18939 
      oprot.writeFieldBegin('success', TType.LIST, 0)
18940 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 18941 
      for iter438 in self.success:
18942 
        iter438.write(oprot)
4741 phani.kuma 18943 
      oprot.writeListEnd()
18944 
      oprot.writeFieldEnd()
18945 
    oprot.writeFieldStop()
18946 
    oprot.writeStructEnd()
18947 
 
18948 
  def validate(self):
18949 
    return
18950 
 
18951 
 
18952 
  def __repr__(self):
18953 
    L = ['%s=%r' % (key, value)
18954 
      for key, value in self.__dict__.iteritems()]
18955 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18956 
 
18957 
  def __eq__(self, other):
18958 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18959 
 
18960 
  def __ne__(self, other):
18961 
    return not (self == other)
18962 
 
2616 chandransh 18963 
class receiveReturn_args:
2591 chandransh 18964 
  """
18965 
  Attributes:
18966 
   - orderId
4479 rajveer 18967 
   - receiveCondition
2591 chandransh 18968 
  """
2536 chandransh 18969 
 
2591 chandransh 18970 
  thrift_spec = (
18971 
    None, # 0
18972 
    (1, TType.I64, 'orderId', None, None, ), # 1
4479 rajveer 18973 
    (2, TType.I64, 'receiveCondition', None, None, ), # 2
2591 chandransh 18974 
  )
18975 
 
4479 rajveer 18976 
  def __init__(self, orderId=None, receiveCondition=None,):
2591 chandransh 18977 
    self.orderId = orderId
4479 rajveer 18978 
    self.receiveCondition = receiveCondition
2591 chandransh 18979 
 
18980 
  def read(self, iprot):
18981 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18982 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18983 
      return
18984 
    iprot.readStructBegin()
18985 
    while True:
18986 
      (fname, ftype, fid) = iprot.readFieldBegin()
18987 
      if ftype == TType.STOP:
18988 
        break
18989 
      if fid == 1:
18990 
        if ftype == TType.I64:
18991 
          self.orderId = iprot.readI64();
18992 
        else:
18993 
          iprot.skip(ftype)
4479 rajveer 18994 
      elif fid == 2:
18995 
        if ftype == TType.I64:
18996 
          self.receiveCondition = iprot.readI64();
18997 
        else:
18998 
          iprot.skip(ftype)
2591 chandransh 18999 
      else:
19000 
        iprot.skip(ftype)
19001 
      iprot.readFieldEnd()
19002 
    iprot.readStructEnd()
19003 
 
19004 
  def write(self, oprot):
19005 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19006 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19007 
      return
2616 chandransh 19008 
    oprot.writeStructBegin('receiveReturn_args')
3431 rajveer 19009 
    if self.orderId is not None:
2591 chandransh 19010 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
19011 
      oprot.writeI64(self.orderId)
19012 
      oprot.writeFieldEnd()
4479 rajveer 19013 
    if self.receiveCondition is not None:
19014 
      oprot.writeFieldBegin('receiveCondition', TType.I64, 2)
19015 
      oprot.writeI64(self.receiveCondition)
19016 
      oprot.writeFieldEnd()
2591 chandransh 19017 
    oprot.writeFieldStop()
19018 
    oprot.writeStructEnd()
19019 
 
3431 rajveer 19020 
  def validate(self):
19021 
    return
19022 
 
19023 
 
2591 chandransh 19024 
  def __repr__(self):
19025 
    L = ['%s=%r' % (key, value)
19026 
      for key, value in self.__dict__.iteritems()]
19027 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19028 
 
19029 
  def __eq__(self, other):
19030 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19031 
 
19032 
  def __ne__(self, other):
19033 
    return not (self == other)
19034 
 
2616 chandransh 19035 
class receiveReturn_result:
2591 chandransh 19036 
  """
19037 
  Attributes:
19038 
   - success
19039 
   - ex
19040 
  """
19041 
 
19042 
  thrift_spec = (
19043 
    (0, TType.BOOL, 'success', None, None, ), # 0
19044 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
19045 
  )
19046 
 
19047 
  def __init__(self, success=None, ex=None,):
19048 
    self.success = success
19049 
    self.ex = ex
19050 
 
19051 
  def read(self, iprot):
19052 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19053 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19054 
      return
19055 
    iprot.readStructBegin()
19056 
    while True:
19057 
      (fname, ftype, fid) = iprot.readFieldBegin()
19058 
      if ftype == TType.STOP:
19059 
        break
19060 
      if fid == 0:
19061 
        if ftype == TType.BOOL:
19062 
          self.success = iprot.readBool();
19063 
        else:
19064 
          iprot.skip(ftype)
19065 
      elif fid == 1:
19066 
        if ftype == TType.STRUCT:
19067 
          self.ex = TransactionServiceException()
19068 
          self.ex.read(iprot)
19069 
        else:
19070 
          iprot.skip(ftype)
19071 
      else:
19072 
        iprot.skip(ftype)
19073 
      iprot.readFieldEnd()
19074 
    iprot.readStructEnd()
19075 
 
19076 
  def write(self, oprot):
19077 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19078 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19079 
      return
2616 chandransh 19080 
    oprot.writeStructBegin('receiveReturn_result')
3431 rajveer 19081 
    if self.success is not None:
2591 chandransh 19082 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
19083 
      oprot.writeBool(self.success)
19084 
      oprot.writeFieldEnd()
3431 rajveer 19085 
    if self.ex is not None:
2591 chandransh 19086 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
19087 
      self.ex.write(oprot)
19088 
      oprot.writeFieldEnd()
19089 
    oprot.writeFieldStop()
19090 
    oprot.writeStructEnd()
19091 
 
3431 rajveer 19092 
  def validate(self):
19093 
    return
19094 
 
19095 
 
2591 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 
 
19107 
class validateDoa_args:
19108 
  """
19109 
  Attributes:
19110 
   - orderId
19111 
   - isValid
19112 
  """
19113 
 
19114 
  thrift_spec = (
19115 
    None, # 0
19116 
    (1, TType.I64, 'orderId', None, None, ), # 1
19117 
    (2, TType.BOOL, 'isValid', None, None, ), # 2
19118 
  )
19119 
 
19120 
  def __init__(self, orderId=None, isValid=None,):
19121 
    self.orderId = orderId
19122 
    self.isValid = isValid
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.orderId = iprot.readI64();
19136 
        else:
19137 
          iprot.skip(ftype)
19138 
      elif fid == 2:
19139 
        if ftype == TType.BOOL:
19140 
          self.isValid = iprot.readBool();
19141 
        else:
19142 
          iprot.skip(ftype)
19143 
      else:
19144 
        iprot.skip(ftype)
19145 
      iprot.readFieldEnd()
19146 
    iprot.readStructEnd()
19147 
 
19148 
  def write(self, oprot):
19149 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19150 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19151 
      return
19152 
    oprot.writeStructBegin('validateDoa_args')
3431 rajveer 19153 
    if self.orderId is not None:
2591 chandransh 19154 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
19155 
      oprot.writeI64(self.orderId)
19156 
      oprot.writeFieldEnd()
3431 rajveer 19157 
    if self.isValid is not None:
2591 chandransh 19158 
      oprot.writeFieldBegin('isValid', TType.BOOL, 2)
19159 
      oprot.writeBool(self.isValid)
19160 
      oprot.writeFieldEnd()
19161 
    oprot.writeFieldStop()
19162 
    oprot.writeStructEnd()
19163 
 
3431 rajveer 19164 
  def validate(self):
19165 
    return
19166 
 
19167 
 
2591 chandransh 19168 
  def __repr__(self):
19169 
    L = ['%s=%r' % (key, value)
19170 
      for key, value in self.__dict__.iteritems()]
19171 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19172 
 
19173 
  def __eq__(self, other):
19174 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19175 
 
19176 
  def __ne__(self, other):
19177 
    return not (self == other)
19178 
 
19179 
class validateDoa_result:
19180 
  """
19181 
  Attributes:
19182 
   - success
19183 
   - ex
19184 
  """
19185 
 
19186 
  thrift_spec = (
19187 
    (0, TType.BOOL, 'success', None, None, ), # 0
19188 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
19189 
  )
19190 
 
19191 
  def __init__(self, success=None, ex=None,):
19192 
    self.success = success
19193 
    self.ex = ex
19194 
 
19195 
  def read(self, iprot):
19196 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19197 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19198 
      return
19199 
    iprot.readStructBegin()
19200 
    while True:
19201 
      (fname, ftype, fid) = iprot.readFieldBegin()
19202 
      if ftype == TType.STOP:
19203 
        break
19204 
      if fid == 0:
19205 
        if ftype == TType.BOOL:
19206 
          self.success = iprot.readBool();
19207 
        else:
19208 
          iprot.skip(ftype)
19209 
      elif fid == 1:
19210 
        if ftype == TType.STRUCT:
19211 
          self.ex = TransactionServiceException()
19212 
          self.ex.read(iprot)
19213 
        else:
19214 
          iprot.skip(ftype)
19215 
      else:
19216 
        iprot.skip(ftype)
19217 
      iprot.readFieldEnd()
19218 
    iprot.readStructEnd()
19219 
 
19220 
  def write(self, oprot):
19221 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19222 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19223 
      return
19224 
    oprot.writeStructBegin('validateDoa_result')
3431 rajveer 19225 
    if self.success is not None:
2591 chandransh 19226 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
19227 
      oprot.writeBool(self.success)
19228 
      oprot.writeFieldEnd()
3431 rajveer 19229 
    if self.ex is not None:
2591 chandransh 19230 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
19231 
      self.ex.write(oprot)
19232 
      oprot.writeFieldEnd()
19233 
    oprot.writeFieldStop()
19234 
    oprot.writeStructEnd()
19235 
 
3431 rajveer 19236 
  def validate(self):
19237 
    return
19238 
 
19239 
 
2591 chandransh 19240 
  def __repr__(self):
19241 
    L = ['%s=%r' % (key, value)
19242 
      for key, value in self.__dict__.iteritems()]
19243 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19244 
 
19245 
  def __eq__(self, other):
19246 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19247 
 
19248 
  def __ne__(self, other):
19249 
    return not (self == other)
19250 
 
4495 rajveer 19251 
class validateReturnProduct_args:
19252 
  """
19253 
  Attributes:
19254 
   - orderId
19255 
   - isUsable
19256 
  """
19257 
 
19258 
  thrift_spec = (
19259 
    None, # 0
19260 
    (1, TType.I64, 'orderId', None, None, ), # 1
19261 
    (2, TType.BOOL, 'isUsable', None, None, ), # 2
19262 
  )
19263 
 
19264 
  def __init__(self, orderId=None, isUsable=None,):
19265 
    self.orderId = orderId
19266 
    self.isUsable = isUsable
19267 
 
19268 
  def read(self, iprot):
19269 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19270 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19271 
      return
19272 
    iprot.readStructBegin()
19273 
    while True:
19274 
      (fname, ftype, fid) = iprot.readFieldBegin()
19275 
      if ftype == TType.STOP:
19276 
        break
19277 
      if fid == 1:
19278 
        if ftype == TType.I64:
19279 
          self.orderId = iprot.readI64();
19280 
        else:
19281 
          iprot.skip(ftype)
19282 
      elif fid == 2:
19283 
        if ftype == TType.BOOL:
19284 
          self.isUsable = iprot.readBool();
19285 
        else:
19286 
          iprot.skip(ftype)
19287 
      else:
19288 
        iprot.skip(ftype)
19289 
      iprot.readFieldEnd()
19290 
    iprot.readStructEnd()
19291 
 
19292 
  def write(self, oprot):
19293 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19294 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19295 
      return
19296 
    oprot.writeStructBegin('validateReturnProduct_args')
19297 
    if self.orderId is not None:
19298 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
19299 
      oprot.writeI64(self.orderId)
19300 
      oprot.writeFieldEnd()
19301 
    if self.isUsable is not None:
19302 
      oprot.writeFieldBegin('isUsable', TType.BOOL, 2)
19303 
      oprot.writeBool(self.isUsable)
19304 
      oprot.writeFieldEnd()
19305 
    oprot.writeFieldStop()
19306 
    oprot.writeStructEnd()
19307 
 
19308 
  def validate(self):
19309 
    return
19310 
 
19311 
 
19312 
  def __repr__(self):
19313 
    L = ['%s=%r' % (key, value)
19314 
      for key, value in self.__dict__.iteritems()]
19315 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19316 
 
19317 
  def __eq__(self, other):
19318 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19319 
 
19320 
  def __ne__(self, other):
19321 
    return not (self == other)
19322 
 
19323 
class validateReturnProduct_result:
19324 
  """
19325 
  Attributes:
19326 
   - success
19327 
   - ex
19328 
  """
19329 
 
19330 
  thrift_spec = (
19331 
    (0, TType.BOOL, 'success', None, None, ), # 0
19332 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
19333 
  )
19334 
 
19335 
  def __init__(self, success=None, ex=None,):
19336 
    self.success = success
19337 
    self.ex = ex
19338 
 
19339 
  def read(self, iprot):
19340 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19341 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19342 
      return
19343 
    iprot.readStructBegin()
19344 
    while True:
19345 
      (fname, ftype, fid) = iprot.readFieldBegin()
19346 
      if ftype == TType.STOP:
19347 
        break
19348 
      if fid == 0:
19349 
        if ftype == TType.BOOL:
19350 
          self.success = iprot.readBool();
19351 
        else:
19352 
          iprot.skip(ftype)
19353 
      elif fid == 1:
19354 
        if ftype == TType.STRUCT:
19355 
          self.ex = TransactionServiceException()
19356 
          self.ex.read(iprot)
19357 
        else:
19358 
          iprot.skip(ftype)
19359 
      else:
19360 
        iprot.skip(ftype)
19361 
      iprot.readFieldEnd()
19362 
    iprot.readStructEnd()
19363 
 
19364 
  def write(self, oprot):
19365 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19366 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19367 
      return
19368 
    oprot.writeStructBegin('validateReturnProduct_result')
19369 
    if self.success is not None:
19370 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
19371 
      oprot.writeBool(self.success)
19372 
      oprot.writeFieldEnd()
19373 
    if self.ex is not None:
19374 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
19375 
      self.ex.write(oprot)
19376 
      oprot.writeFieldEnd()
19377 
    oprot.writeFieldStop()
19378 
    oprot.writeStructEnd()
19379 
 
19380 
  def validate(self):
19381 
    return
19382 
 
19383 
 
19384 
  def __repr__(self):
19385 
    L = ['%s=%r' % (key, value)
19386 
      for key, value in self.__dict__.iteritems()]
19387 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19388 
 
19389 
  def __eq__(self, other):
19390 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19391 
 
19392 
  def __ne__(self, other):
19393 
    return not (self == other)
19394 
 
2616 chandransh 19395 
class reshipOrder_args:
19396 
  """
19397 
  Attributes:
19398 
   - orderId
19399 
  """
2591 chandransh 19400 
 
2616 chandransh 19401 
  thrift_spec = (
19402 
    None, # 0
19403 
    (1, TType.I64, 'orderId', None, None, ), # 1
19404 
  )
19405 
 
19406 
  def __init__(self, orderId=None,):
19407 
    self.orderId = orderId
19408 
 
19409 
  def read(self, iprot):
19410 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19411 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19412 
      return
19413 
    iprot.readStructBegin()
19414 
    while True:
19415 
      (fname, ftype, fid) = iprot.readFieldBegin()
19416 
      if ftype == TType.STOP:
19417 
        break
19418 
      if fid == 1:
19419 
        if ftype == TType.I64:
19420 
          self.orderId = iprot.readI64();
19421 
        else:
19422 
          iprot.skip(ftype)
19423 
      else:
19424 
        iprot.skip(ftype)
19425 
      iprot.readFieldEnd()
19426 
    iprot.readStructEnd()
19427 
 
19428 
  def write(self, oprot):
19429 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19430 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19431 
      return
19432 
    oprot.writeStructBegin('reshipOrder_args')
3431 rajveer 19433 
    if self.orderId is not None:
2616 chandransh 19434 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
19435 
      oprot.writeI64(self.orderId)
19436 
      oprot.writeFieldEnd()
19437 
    oprot.writeFieldStop()
19438 
    oprot.writeStructEnd()
19439 
 
3431 rajveer 19440 
  def validate(self):
19441 
    return
19442 
 
19443 
 
2616 chandransh 19444 
  def __repr__(self):
19445 
    L = ['%s=%r' % (key, value)
19446 
      for key, value in self.__dict__.iteritems()]
19447 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19448 
 
19449 
  def __eq__(self, other):
19450 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19451 
 
19452 
  def __ne__(self, other):
19453 
    return not (self == other)
19454 
 
19455 
class reshipOrder_result:
19456 
  """
19457 
  Attributes:
19458 
   - success
19459 
   - ex
19460 
  """
19461 
 
19462 
  thrift_spec = (
19463 
    (0, TType.I64, 'success', None, None, ), # 0
19464 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
19465 
  )
19466 
 
19467 
  def __init__(self, success=None, ex=None,):
19468 
    self.success = success
19469 
    self.ex = ex
19470 
 
19471 
  def read(self, iprot):
19472 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19473 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19474 
      return
19475 
    iprot.readStructBegin()
19476 
    while True:
19477 
      (fname, ftype, fid) = iprot.readFieldBegin()
19478 
      if ftype == TType.STOP:
19479 
        break
19480 
      if fid == 0:
19481 
        if ftype == TType.I64:
19482 
          self.success = iprot.readI64();
19483 
        else:
19484 
          iprot.skip(ftype)
19485 
      elif fid == 1:
19486 
        if ftype == TType.STRUCT:
19487 
          self.ex = TransactionServiceException()
19488 
          self.ex.read(iprot)
19489 
        else:
19490 
          iprot.skip(ftype)
19491 
      else:
19492 
        iprot.skip(ftype)
19493 
      iprot.readFieldEnd()
19494 
    iprot.readStructEnd()
19495 
 
19496 
  def write(self, oprot):
19497 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19498 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19499 
      return
19500 
    oprot.writeStructBegin('reshipOrder_result')
3431 rajveer 19501 
    if self.success is not None:
2616 chandransh 19502 
      oprot.writeFieldBegin('success', TType.I64, 0)
19503 
      oprot.writeI64(self.success)
19504 
      oprot.writeFieldEnd()
3431 rajveer 19505 
    if self.ex is not None:
2616 chandransh 19506 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
19507 
      self.ex.write(oprot)
19508 
      oprot.writeFieldEnd()
19509 
    oprot.writeFieldStop()
19510 
    oprot.writeStructEnd()
19511 
 
3431 rajveer 19512 
  def validate(self):
19513 
    return
19514 
 
19515 
 
2616 chandransh 19516 
  def __repr__(self):
19517 
    L = ['%s=%r' % (key, value)
19518 
      for key, value in self.__dict__.iteritems()]
19519 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19520 
 
19521 
  def __eq__(self, other):
19522 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19523 
 
19524 
  def __ne__(self, other):
19525 
    return not (self == other)
19526 
 
19527 
class refundOrder_args:
19528 
  """
19529 
  Attributes:
19530 
   - orderId
3226 chandransh 19531 
   - refundedBy
19532 
   - reason
2616 chandransh 19533 
  """
19534 
 
19535 
  thrift_spec = (
19536 
    None, # 0
19537 
    (1, TType.I64, 'orderId', None, None, ), # 1
3226 chandransh 19538 
    (2, TType.STRING, 'refundedBy', None, None, ), # 2
19539 
    (3, TType.STRING, 'reason', None, None, ), # 3
2616 chandransh 19540 
  )
19541 
 
3226 chandransh 19542 
  def __init__(self, orderId=None, refundedBy=None, reason=None,):
2616 chandransh 19543 
    self.orderId = orderId
3226 chandransh 19544 
    self.refundedBy = refundedBy
19545 
    self.reason = reason
2616 chandransh 19546 
 
19547 
  def read(self, iprot):
19548 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19549 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19550 
      return
19551 
    iprot.readStructBegin()
19552 
    while True:
19553 
      (fname, ftype, fid) = iprot.readFieldBegin()
19554 
      if ftype == TType.STOP:
19555 
        break
19556 
      if fid == 1:
19557 
        if ftype == TType.I64:
19558 
          self.orderId = iprot.readI64();
19559 
        else:
19560 
          iprot.skip(ftype)
3226 chandransh 19561 
      elif fid == 2:
19562 
        if ftype == TType.STRING:
19563 
          self.refundedBy = iprot.readString();
19564 
        else:
19565 
          iprot.skip(ftype)
19566 
      elif fid == 3:
19567 
        if ftype == TType.STRING:
19568 
          self.reason = iprot.readString();
19569 
        else:
19570 
          iprot.skip(ftype)
2616 chandransh 19571 
      else:
19572 
        iprot.skip(ftype)
19573 
      iprot.readFieldEnd()
19574 
    iprot.readStructEnd()
19575 
 
19576 
  def write(self, oprot):
19577 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19578 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19579 
      return
19580 
    oprot.writeStructBegin('refundOrder_args')
3431 rajveer 19581 
    if self.orderId is not None:
2616 chandransh 19582 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
19583 
      oprot.writeI64(self.orderId)
19584 
      oprot.writeFieldEnd()
3431 rajveer 19585 
    if self.refundedBy is not None:
3226 chandransh 19586 
      oprot.writeFieldBegin('refundedBy', TType.STRING, 2)
19587 
      oprot.writeString(self.refundedBy)
19588 
      oprot.writeFieldEnd()
3431 rajveer 19589 
    if self.reason is not None:
3226 chandransh 19590 
      oprot.writeFieldBegin('reason', TType.STRING, 3)
19591 
      oprot.writeString(self.reason)
19592 
      oprot.writeFieldEnd()
2616 chandransh 19593 
    oprot.writeFieldStop()
19594 
    oprot.writeStructEnd()
19595 
 
3431 rajveer 19596 
  def validate(self):
19597 
    return
19598 
 
19599 
 
2616 chandransh 19600 
  def __repr__(self):
19601 
    L = ['%s=%r' % (key, value)
19602 
      for key, value in self.__dict__.iteritems()]
19603 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19604 
 
19605 
  def __eq__(self, other):
19606 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19607 
 
19608 
  def __ne__(self, other):
19609 
    return not (self == other)
19610 
 
19611 
class refundOrder_result:
19612 
  """
19613 
  Attributes:
19614 
   - success
19615 
   - ex
19616 
  """
19617 
 
19618 
  thrift_spec = (
19619 
    (0, TType.BOOL, 'success', None, None, ), # 0
19620 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
19621 
  )
19622 
 
19623 
  def __init__(self, success=None, ex=None,):
19624 
    self.success = success
19625 
    self.ex = ex
19626 
 
19627 
  def read(self, iprot):
19628 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19629 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19630 
      return
19631 
    iprot.readStructBegin()
19632 
    while True:
19633 
      (fname, ftype, fid) = iprot.readFieldBegin()
19634 
      if ftype == TType.STOP:
19635 
        break
19636 
      if fid == 0:
19637 
        if ftype == TType.BOOL:
19638 
          self.success = iprot.readBool();
19639 
        else:
19640 
          iprot.skip(ftype)
19641 
      elif fid == 1:
19642 
        if ftype == TType.STRUCT:
19643 
          self.ex = TransactionServiceException()
19644 
          self.ex.read(iprot)
19645 
        else:
19646 
          iprot.skip(ftype)
19647 
      else:
19648 
        iprot.skip(ftype)
19649 
      iprot.readFieldEnd()
19650 
    iprot.readStructEnd()
19651 
 
19652 
  def write(self, oprot):
19653 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19654 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19655 
      return
19656 
    oprot.writeStructBegin('refundOrder_result')
3431 rajveer 19657 
    if self.success is not None:
2616 chandransh 19658 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
19659 
      oprot.writeBool(self.success)
19660 
      oprot.writeFieldEnd()
3431 rajveer 19661 
    if self.ex is not None:
2616 chandransh 19662 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
19663 
      self.ex.write(oprot)
19664 
      oprot.writeFieldEnd()
19665 
    oprot.writeFieldStop()
19666 
    oprot.writeStructEnd()
19667 
 
3431 rajveer 19668 
  def validate(self):
19669 
    return
19670 
 
19671 
 
2616 chandransh 19672 
  def __repr__(self):
19673 
    L = ['%s=%r' % (key, value)
19674 
      for key, value in self.__dict__.iteritems()]
19675 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19676 
 
19677 
  def __eq__(self, other):
19678 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19679 
 
19680 
  def __ne__(self, other):
19681 
    return not (self == other)
19682 
 
2690 chandransh 19683 
class getReturnOrders_args:
19684 
  """
19685 
  Attributes:
19686 
   - warehouseId
19687 
   - fromDate
19688 
   - toDate
19689 
  """
2616 chandransh 19690 
 
2690 chandransh 19691 
  thrift_spec = (
19692 
    None, # 0
19693 
    (1, TType.I64, 'warehouseId', None, None, ), # 1
19694 
    (2, TType.I64, 'fromDate', None, None, ), # 2
19695 
    (3, TType.I64, 'toDate', None, None, ), # 3
19696 
  )
19697 
 
19698 
  def __init__(self, warehouseId=None, fromDate=None, toDate=None,):
19699 
    self.warehouseId = warehouseId
19700 
    self.fromDate = fromDate
19701 
    self.toDate = toDate
19702 
 
19703 
  def read(self, iprot):
19704 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19705 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19706 
      return
19707 
    iprot.readStructBegin()
19708 
    while True:
19709 
      (fname, ftype, fid) = iprot.readFieldBegin()
19710 
      if ftype == TType.STOP:
19711 
        break
19712 
      if fid == 1:
19713 
        if ftype == TType.I64:
19714 
          self.warehouseId = iprot.readI64();
19715 
        else:
19716 
          iprot.skip(ftype)
19717 
      elif fid == 2:
19718 
        if ftype == TType.I64:
19719 
          self.fromDate = iprot.readI64();
19720 
        else:
19721 
          iprot.skip(ftype)
19722 
      elif fid == 3:
19723 
        if ftype == TType.I64:
19724 
          self.toDate = iprot.readI64();
19725 
        else:
19726 
          iprot.skip(ftype)
19727 
      else:
19728 
        iprot.skip(ftype)
19729 
      iprot.readFieldEnd()
19730 
    iprot.readStructEnd()
19731 
 
19732 
  def write(self, oprot):
19733 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19734 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19735 
      return
19736 
    oprot.writeStructBegin('getReturnOrders_args')
3431 rajveer 19737 
    if self.warehouseId is not None:
2690 chandransh 19738 
      oprot.writeFieldBegin('warehouseId', TType.I64, 1)
19739 
      oprot.writeI64(self.warehouseId)
19740 
      oprot.writeFieldEnd()
3431 rajveer 19741 
    if self.fromDate is not None:
2690 chandransh 19742 
      oprot.writeFieldBegin('fromDate', TType.I64, 2)
19743 
      oprot.writeI64(self.fromDate)
19744 
      oprot.writeFieldEnd()
3431 rajveer 19745 
    if self.toDate is not None:
2690 chandransh 19746 
      oprot.writeFieldBegin('toDate', TType.I64, 3)
19747 
      oprot.writeI64(self.toDate)
19748 
      oprot.writeFieldEnd()
19749 
    oprot.writeFieldStop()
19750 
    oprot.writeStructEnd()
19751 
 
3431 rajveer 19752 
  def validate(self):
19753 
    return
19754 
 
19755 
 
2690 chandransh 19756 
  def __repr__(self):
19757 
    L = ['%s=%r' % (key, value)
19758 
      for key, value in self.__dict__.iteritems()]
19759 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19760 
 
19761 
  def __eq__(self, other):
19762 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19763 
 
19764 
  def __ne__(self, other):
19765 
    return not (self == other)
19766 
 
19767 
class getReturnOrders_result:
19768 
  """
19769 
  Attributes:
19770 
   - success
19771 
  """
19772 
 
19773 
  thrift_spec = (
19774 
    (0, TType.LIST, 'success', (TType.STRUCT,(ReturnOrder, ReturnOrder.thrift_spec)), None, ), # 0
19775 
  )
19776 
 
19777 
  def __init__(self, success=None,):
19778 
    self.success = success
19779 
 
19780 
  def read(self, iprot):
19781 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19782 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19783 
      return
19784 
    iprot.readStructBegin()
19785 
    while True:
19786 
      (fname, ftype, fid) = iprot.readFieldBegin()
19787 
      if ftype == TType.STOP:
19788 
        break
19789 
      if fid == 0:
19790 
        if ftype == TType.LIST:
19791 
          self.success = []
6188 rajveer 19792 
          (_etype442, _size439) = iprot.readListBegin()
19793 
          for _i443 in xrange(_size439):
19794 
            _elem444 = ReturnOrder()
19795 
            _elem444.read(iprot)
19796 
            self.success.append(_elem444)
2690 chandransh 19797 
          iprot.readListEnd()
19798 
        else:
19799 
          iprot.skip(ftype)
19800 
      else:
19801 
        iprot.skip(ftype)
19802 
      iprot.readFieldEnd()
19803 
    iprot.readStructEnd()
19804 
 
19805 
  def write(self, oprot):
19806 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19807 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19808 
      return
19809 
    oprot.writeStructBegin('getReturnOrders_result')
3431 rajveer 19810 
    if self.success is not None:
2690 chandransh 19811 
      oprot.writeFieldBegin('success', TType.LIST, 0)
19812 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 19813 
      for iter445 in self.success:
19814 
        iter445.write(oprot)
2690 chandransh 19815 
      oprot.writeListEnd()
19816 
      oprot.writeFieldEnd()
19817 
    oprot.writeFieldStop()
19818 
    oprot.writeStructEnd()
19819 
 
3431 rajveer 19820 
  def validate(self):
19821 
    return
19822 
 
19823 
 
2690 chandransh 19824 
  def __repr__(self):
19825 
    L = ['%s=%r' % (key, value)
19826 
      for key, value in self.__dict__.iteritems()]
19827 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19828 
 
19829 
  def __eq__(self, other):
19830 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19831 
 
19832 
  def __ne__(self, other):
19833 
    return not (self == other)
19834 
 
5481 phani.kuma 19835 
class getAllReturnOrders_args:
19836 
  """
19837 
  Attributes:
19838 
   - onlyNotProcessed
19839 
   - fromDate
19840 
   - toDate
19841 
  """
19842 
 
19843 
  thrift_spec = (
19844 
    None, # 0
19845 
    (1, TType.BOOL, 'onlyNotProcessed', None, None, ), # 1
19846 
    (2, TType.I64, 'fromDate', None, None, ), # 2
19847 
    (3, TType.I64, 'toDate', None, None, ), # 3
19848 
  )
19849 
 
19850 
  def __init__(self, onlyNotProcessed=None, fromDate=None, toDate=None,):
19851 
    self.onlyNotProcessed = onlyNotProcessed
19852 
    self.fromDate = fromDate
19853 
    self.toDate = toDate
19854 
 
19855 
  def read(self, iprot):
19856 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19857 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19858 
      return
19859 
    iprot.readStructBegin()
19860 
    while True:
19861 
      (fname, ftype, fid) = iprot.readFieldBegin()
19862 
      if ftype == TType.STOP:
19863 
        break
19864 
      if fid == 1:
19865 
        if ftype == TType.BOOL:
19866 
          self.onlyNotProcessed = iprot.readBool();
19867 
        else:
19868 
          iprot.skip(ftype)
19869 
      elif fid == 2:
19870 
        if ftype == TType.I64:
19871 
          self.fromDate = iprot.readI64();
19872 
        else:
19873 
          iprot.skip(ftype)
19874 
      elif fid == 3:
19875 
        if ftype == TType.I64:
19876 
          self.toDate = iprot.readI64();
19877 
        else:
19878 
          iprot.skip(ftype)
19879 
      else:
19880 
        iprot.skip(ftype)
19881 
      iprot.readFieldEnd()
19882 
    iprot.readStructEnd()
19883 
 
19884 
  def write(self, oprot):
19885 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19886 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19887 
      return
19888 
    oprot.writeStructBegin('getAllReturnOrders_args')
19889 
    if self.onlyNotProcessed is not None:
19890 
      oprot.writeFieldBegin('onlyNotProcessed', TType.BOOL, 1)
19891 
      oprot.writeBool(self.onlyNotProcessed)
19892 
      oprot.writeFieldEnd()
19893 
    if self.fromDate is not None:
19894 
      oprot.writeFieldBegin('fromDate', TType.I64, 2)
19895 
      oprot.writeI64(self.fromDate)
19896 
      oprot.writeFieldEnd()
19897 
    if self.toDate is not None:
19898 
      oprot.writeFieldBegin('toDate', TType.I64, 3)
19899 
      oprot.writeI64(self.toDate)
19900 
      oprot.writeFieldEnd()
19901 
    oprot.writeFieldStop()
19902 
    oprot.writeStructEnd()
19903 
 
19904 
  def validate(self):
19905 
    return
19906 
 
19907 
 
19908 
  def __repr__(self):
19909 
    L = ['%s=%r' % (key, value)
19910 
      for key, value in self.__dict__.iteritems()]
19911 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19912 
 
19913 
  def __eq__(self, other):
19914 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19915 
 
19916 
  def __ne__(self, other):
19917 
    return not (self == other)
19918 
 
19919 
class getAllReturnOrders_result:
19920 
  """
19921 
  Attributes:
19922 
   - success
19923 
  """
19924 
 
19925 
  thrift_spec = (
19926 
    (0, TType.LIST, 'success', (TType.STRUCT,(ReturnOrder, ReturnOrder.thrift_spec)), None, ), # 0
19927 
  )
19928 
 
19929 
  def __init__(self, success=None,):
19930 
    self.success = success
19931 
 
19932 
  def read(self, iprot):
19933 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19934 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19935 
      return
19936 
    iprot.readStructBegin()
19937 
    while True:
19938 
      (fname, ftype, fid) = iprot.readFieldBegin()
19939 
      if ftype == TType.STOP:
19940 
        break
19941 
      if fid == 0:
19942 
        if ftype == TType.LIST:
19943 
          self.success = []
6188 rajveer 19944 
          (_etype449, _size446) = iprot.readListBegin()
19945 
          for _i450 in xrange(_size446):
19946 
            _elem451 = ReturnOrder()
19947 
            _elem451.read(iprot)
19948 
            self.success.append(_elem451)
5481 phani.kuma 19949 
          iprot.readListEnd()
19950 
        else:
19951 
          iprot.skip(ftype)
19952 
      else:
19953 
        iprot.skip(ftype)
19954 
      iprot.readFieldEnd()
19955 
    iprot.readStructEnd()
19956 
 
19957 
  def write(self, oprot):
19958 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19959 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19960 
      return
19961 
    oprot.writeStructBegin('getAllReturnOrders_result')
19962 
    if self.success is not None:
19963 
      oprot.writeFieldBegin('success', TType.LIST, 0)
19964 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 19965 
      for iter452 in self.success:
19966 
        iter452.write(oprot)
5481 phani.kuma 19967 
      oprot.writeListEnd()
19968 
      oprot.writeFieldEnd()
19969 
    oprot.writeFieldStop()
19970 
    oprot.writeStructEnd()
19971 
 
19972 
  def validate(self):
19973 
    return
19974 
 
19975 
 
19976 
  def __repr__(self):
19977 
    L = ['%s=%r' % (key, value)
19978 
      for key, value in self.__dict__.iteritems()]
19979 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19980 
 
19981 
  def __eq__(self, other):
19982 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19983 
 
19984 
  def __ne__(self, other):
19985 
    return not (self == other)
19986 
 
2700 chandransh 19987 
class getReturnOrder_args:
19988 
  """
19989 
  Attributes:
19990 
   - id
19991 
  """
19992 
 
19993 
  thrift_spec = (
19994 
    None, # 0
19995 
    (1, TType.I64, 'id', None, None, ), # 1
19996 
  )
19997 
 
19998 
  def __init__(self, id=None,):
19999 
    self.id = id
20000 
 
20001 
  def read(self, iprot):
20002 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20003 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20004 
      return
20005 
    iprot.readStructBegin()
20006 
    while True:
20007 
      (fname, ftype, fid) = iprot.readFieldBegin()
20008 
      if ftype == TType.STOP:
20009 
        break
20010 
      if fid == 1:
20011 
        if ftype == TType.I64:
20012 
          self.id = iprot.readI64();
20013 
        else:
20014 
          iprot.skip(ftype)
20015 
      else:
20016 
        iprot.skip(ftype)
20017 
      iprot.readFieldEnd()
20018 
    iprot.readStructEnd()
20019 
 
20020 
  def write(self, oprot):
20021 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20022 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20023 
      return
20024 
    oprot.writeStructBegin('getReturnOrder_args')
3431 rajveer 20025 
    if self.id is not None:
2700 chandransh 20026 
      oprot.writeFieldBegin('id', TType.I64, 1)
20027 
      oprot.writeI64(self.id)
20028 
      oprot.writeFieldEnd()
20029 
    oprot.writeFieldStop()
20030 
    oprot.writeStructEnd()
20031 
 
3431 rajveer 20032 
  def validate(self):
20033 
    return
20034 
 
20035 
 
2700 chandransh 20036 
  def __repr__(self):
20037 
    L = ['%s=%r' % (key, value)
20038 
      for key, value in self.__dict__.iteritems()]
20039 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20040 
 
20041 
  def __eq__(self, other):
20042 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20043 
 
20044 
  def __ne__(self, other):
20045 
    return not (self == other)
20046 
 
20047 
class getReturnOrder_result:
20048 
  """
20049 
  Attributes:
20050 
   - success
20051 
   - ex
20052 
  """
20053 
 
20054 
  thrift_spec = (
20055 
    (0, TType.STRUCT, 'success', (ReturnOrder, ReturnOrder.thrift_spec), None, ), # 0
20056 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
20057 
  )
20058 
 
20059 
  def __init__(self, success=None, ex=None,):
20060 
    self.success = success
20061 
    self.ex = ex
20062 
 
20063 
  def read(self, iprot):
20064 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20065 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20066 
      return
20067 
    iprot.readStructBegin()
20068 
    while True:
20069 
      (fname, ftype, fid) = iprot.readFieldBegin()
20070 
      if ftype == TType.STOP:
20071 
        break
20072 
      if fid == 0:
20073 
        if ftype == TType.STRUCT:
20074 
          self.success = ReturnOrder()
20075 
          self.success.read(iprot)
20076 
        else:
20077 
          iprot.skip(ftype)
20078 
      elif fid == 1:
20079 
        if ftype == TType.STRUCT:
20080 
          self.ex = TransactionServiceException()
20081 
          self.ex.read(iprot)
20082 
        else:
20083 
          iprot.skip(ftype)
20084 
      else:
20085 
        iprot.skip(ftype)
20086 
      iprot.readFieldEnd()
20087 
    iprot.readStructEnd()
20088 
 
20089 
  def write(self, oprot):
20090 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20091 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20092 
      return
20093 
    oprot.writeStructBegin('getReturnOrder_result')
3431 rajveer 20094 
    if self.success is not None:
2700 chandransh 20095 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
20096 
      self.success.write(oprot)
20097 
      oprot.writeFieldEnd()
3431 rajveer 20098 
    if self.ex is not None:
2700 chandransh 20099 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
20100 
      self.ex.write(oprot)
20101 
      oprot.writeFieldEnd()
20102 
    oprot.writeFieldStop()
20103 
    oprot.writeStructEnd()
20104 
 
3431 rajveer 20105 
  def validate(self):
20106 
    return
20107 
 
20108 
 
2700 chandransh 20109 
  def __repr__(self):
20110 
    L = ['%s=%r' % (key, value)
20111 
      for key, value in self.__dict__.iteritems()]
20112 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20113 
 
20114 
  def __eq__(self, other):
20115 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20116 
 
20117 
  def __ne__(self, other):
20118 
    return not (self == other)
20119 
 
2690 chandransh 20120 
class processReturn_args:
20121 
  """
20122 
  Attributes:
20123 
   - returnOrderId
20124 
  """
20125 
 
20126 
  thrift_spec = (
20127 
    None, # 0
20128 
    (1, TType.I64, 'returnOrderId', None, None, ), # 1
20129 
  )
20130 
 
20131 
  def __init__(self, returnOrderId=None,):
20132 
    self.returnOrderId = returnOrderId
20133 
 
20134 
  def read(self, iprot):
20135 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20136 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20137 
      return
20138 
    iprot.readStructBegin()
20139 
    while True:
20140 
      (fname, ftype, fid) = iprot.readFieldBegin()
20141 
      if ftype == TType.STOP:
20142 
        break
20143 
      if fid == 1:
20144 
        if ftype == TType.I64:
20145 
          self.returnOrderId = iprot.readI64();
20146 
        else:
20147 
          iprot.skip(ftype)
20148 
      else:
20149 
        iprot.skip(ftype)
20150 
      iprot.readFieldEnd()
20151 
    iprot.readStructEnd()
20152 
 
20153 
  def write(self, oprot):
20154 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20155 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20156 
      return
20157 
    oprot.writeStructBegin('processReturn_args')
3431 rajveer 20158 
    if self.returnOrderId is not None:
2690 chandransh 20159 
      oprot.writeFieldBegin('returnOrderId', TType.I64, 1)
20160 
      oprot.writeI64(self.returnOrderId)
20161 
      oprot.writeFieldEnd()
20162 
    oprot.writeFieldStop()
20163 
    oprot.writeStructEnd()
20164 
 
3431 rajveer 20165 
  def validate(self):
20166 
    return
20167 
 
20168 
 
2690 chandransh 20169 
  def __repr__(self):
20170 
    L = ['%s=%r' % (key, value)
20171 
      for key, value in self.__dict__.iteritems()]
20172 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20173 
 
20174 
  def __eq__(self, other):
20175 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20176 
 
20177 
  def __ne__(self, other):
20178 
    return not (self == other)
20179 
 
20180 
class processReturn_result:
20181 
  """
20182 
  Attributes:
20183 
   - ex
20184 
  """
20185 
 
20186 
  thrift_spec = (
20187 
    None, # 0
20188 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
20189 
  )
20190 
 
20191 
  def __init__(self, ex=None,):
20192 
    self.ex = ex
20193 
 
20194 
  def read(self, iprot):
20195 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20196 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20197 
      return
20198 
    iprot.readStructBegin()
20199 
    while True:
20200 
      (fname, ftype, fid) = iprot.readFieldBegin()
20201 
      if ftype == TType.STOP:
20202 
        break
20203 
      if fid == 1:
20204 
        if ftype == TType.STRUCT:
20205 
          self.ex = TransactionServiceException()
20206 
          self.ex.read(iprot)
20207 
        else:
20208 
          iprot.skip(ftype)
20209 
      else:
20210 
        iprot.skip(ftype)
20211 
      iprot.readFieldEnd()
20212 
    iprot.readStructEnd()
20213 
 
20214 
  def write(self, oprot):
20215 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20216 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20217 
      return
20218 
    oprot.writeStructBegin('processReturn_result')
3431 rajveer 20219 
    if self.ex is not None:
2690 chandransh 20220 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
20221 
      self.ex.write(oprot)
20222 
      oprot.writeFieldEnd()
20223 
    oprot.writeFieldStop()
20224 
    oprot.writeStructEnd()
20225 
 
3431 rajveer 20226 
  def validate(self):
20227 
    return
20228 
 
20229 
 
2690 chandransh 20230 
  def __repr__(self):
20231 
    L = ['%s=%r' % (key, value)
20232 
      for key, value in self.__dict__.iteritems()]
20233 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20234 
 
20235 
  def __eq__(self, other):
20236 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20237 
 
20238 
  def __ne__(self, other):
20239 
    return not (self == other)
20240 
 
3451 chandransh 20241 
class updateWeight_args:
20242 
  """
20243 
  Attributes:
20244 
   - orderId
20245 
   - weight
20246 
  """
20247 
 
20248 
  thrift_spec = (
20249 
    None, # 0
20250 
    (1, TType.I64, 'orderId', None, None, ), # 1
20251 
    (2, TType.DOUBLE, 'weight', None, None, ), # 2
20252 
  )
20253 
 
20254 
  def __init__(self, orderId=None, weight=None,):
20255 
    self.orderId = orderId
20256 
    self.weight = weight
20257 
 
20258 
  def read(self, iprot):
20259 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20260 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20261 
      return
20262 
    iprot.readStructBegin()
20263 
    while True:
20264 
      (fname, ftype, fid) = iprot.readFieldBegin()
20265 
      if ftype == TType.STOP:
20266 
        break
20267 
      if fid == 1:
20268 
        if ftype == TType.I64:
20269 
          self.orderId = iprot.readI64();
20270 
        else:
20271 
          iprot.skip(ftype)
20272 
      elif fid == 2:
20273 
        if ftype == TType.DOUBLE:
20274 
          self.weight = iprot.readDouble();
20275 
        else:
20276 
          iprot.skip(ftype)
20277 
      else:
20278 
        iprot.skip(ftype)
20279 
      iprot.readFieldEnd()
20280 
    iprot.readStructEnd()
20281 
 
20282 
  def write(self, oprot):
20283 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20284 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20285 
      return
20286 
    oprot.writeStructBegin('updateWeight_args')
20287 
    if self.orderId is not None:
20288 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
20289 
      oprot.writeI64(self.orderId)
20290 
      oprot.writeFieldEnd()
20291 
    if self.weight is not None:
20292 
      oprot.writeFieldBegin('weight', TType.DOUBLE, 2)
20293 
      oprot.writeDouble(self.weight)
20294 
      oprot.writeFieldEnd()
20295 
    oprot.writeFieldStop()
20296 
    oprot.writeStructEnd()
20297 
 
20298 
  def validate(self):
20299 
    return
20300 
 
20301 
 
20302 
  def __repr__(self):
20303 
    L = ['%s=%r' % (key, value)
20304 
      for key, value in self.__dict__.iteritems()]
20305 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20306 
 
20307 
  def __eq__(self, other):
20308 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20309 
 
20310 
  def __ne__(self, other):
20311 
    return not (self == other)
20312 
 
20313 
class updateWeight_result:
20314 
  """
20315 
  Attributes:
20316 
   - success
20317 
   - ex
20318 
  """
20319 
 
20320 
  thrift_spec = (
20321 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
20322 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
20323 
  )
20324 
 
20325 
  def __init__(self, success=None, ex=None,):
20326 
    self.success = success
20327 
    self.ex = ex
20328 
 
20329 
  def read(self, iprot):
20330 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20331 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20332 
      return
20333 
    iprot.readStructBegin()
20334 
    while True:
20335 
      (fname, ftype, fid) = iprot.readFieldBegin()
20336 
      if ftype == TType.STOP:
20337 
        break
20338 
      if fid == 0:
20339 
        if ftype == TType.STRUCT:
20340 
          self.success = Order()
20341 
          self.success.read(iprot)
20342 
        else:
20343 
          iprot.skip(ftype)
20344 
      elif fid == 1:
20345 
        if ftype == TType.STRUCT:
20346 
          self.ex = TransactionServiceException()
20347 
          self.ex.read(iprot)
20348 
        else:
20349 
          iprot.skip(ftype)
20350 
      else:
20351 
        iprot.skip(ftype)
20352 
      iprot.readFieldEnd()
20353 
    iprot.readStructEnd()
20354 
 
20355 
  def write(self, oprot):
20356 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20357 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20358 
      return
20359 
    oprot.writeStructBegin('updateWeight_result')
20360 
    if self.success is not None:
20361 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
20362 
      self.success.write(oprot)
20363 
      oprot.writeFieldEnd()
20364 
    if self.ex is not None:
20365 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
20366 
      self.ex.write(oprot)
20367 
      oprot.writeFieldEnd()
20368 
    oprot.writeFieldStop()
20369 
    oprot.writeStructEnd()
20370 
 
20371 
  def validate(self):
20372 
    return
20373 
 
20374 
 
20375 
  def __repr__(self):
20376 
    L = ['%s=%r' % (key, value)
20377 
      for key, value in self.__dict__.iteritems()]
20378 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20379 
 
20380 
  def __eq__(self, other):
20381 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20382 
 
20383 
  def __ne__(self, other):
20384 
    return not (self == other)
3469 chandransh 20385 
 
20386 
class changeItem_args:
20387 
  """
20388 
  Attributes:
20389 
   - orderId
20390 
   - itemId
20391 
  """
20392 
 
20393 
  thrift_spec = (
20394 
    None, # 0
20395 
    (1, TType.I64, 'orderId', None, None, ), # 1
20396 
    (2, TType.I64, 'itemId', None, None, ), # 2
20397 
  )
20398 
 
20399 
  def __init__(self, orderId=None, itemId=None,):
20400 
    self.orderId = orderId
20401 
    self.itemId = itemId
20402 
 
20403 
  def read(self, iprot):
20404 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20405 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20406 
      return
20407 
    iprot.readStructBegin()
20408 
    while True:
20409 
      (fname, ftype, fid) = iprot.readFieldBegin()
20410 
      if ftype == TType.STOP:
20411 
        break
20412 
      if fid == 1:
20413 
        if ftype == TType.I64:
20414 
          self.orderId = iprot.readI64();
20415 
        else:
20416 
          iprot.skip(ftype)
20417 
      elif fid == 2:
20418 
        if ftype == TType.I64:
20419 
          self.itemId = iprot.readI64();
20420 
        else:
20421 
          iprot.skip(ftype)
20422 
      else:
20423 
        iprot.skip(ftype)
20424 
      iprot.readFieldEnd()
20425 
    iprot.readStructEnd()
20426 
 
20427 
  def write(self, oprot):
20428 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20429 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20430 
      return
20431 
    oprot.writeStructBegin('changeItem_args')
20432 
    if self.orderId is not None:
20433 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
20434 
      oprot.writeI64(self.orderId)
20435 
      oprot.writeFieldEnd()
20436 
    if self.itemId is not None:
20437 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
20438 
      oprot.writeI64(self.itemId)
20439 
      oprot.writeFieldEnd()
20440 
    oprot.writeFieldStop()
20441 
    oprot.writeStructEnd()
20442 
 
20443 
  def validate(self):
20444 
    return
20445 
 
20446 
 
20447 
  def __repr__(self):
20448 
    L = ['%s=%r' % (key, value)
20449 
      for key, value in self.__dict__.iteritems()]
20450 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20451 
 
20452 
  def __eq__(self, other):
20453 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20454 
 
20455 
  def __ne__(self, other):
20456 
    return not (self == other)
20457 
 
20458 
class changeItem_result:
20459 
  """
20460 
  Attributes:
20461 
   - success
20462 
   - ex
20463 
  """
20464 
 
20465 
  thrift_spec = (
20466 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
20467 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
20468 
  )
20469 
 
20470 
  def __init__(self, success=None, ex=None,):
20471 
    self.success = success
20472 
    self.ex = ex
20473 
 
20474 
  def read(self, iprot):
20475 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20476 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20477 
      return
20478 
    iprot.readStructBegin()
20479 
    while True:
20480 
      (fname, ftype, fid) = iprot.readFieldBegin()
20481 
      if ftype == TType.STOP:
20482 
        break
20483 
      if fid == 0:
20484 
        if ftype == TType.STRUCT:
20485 
          self.success = Order()
20486 
          self.success.read(iprot)
20487 
        else:
20488 
          iprot.skip(ftype)
20489 
      elif fid == 1:
20490 
        if ftype == TType.STRUCT:
20491 
          self.ex = TransactionServiceException()
20492 
          self.ex.read(iprot)
20493 
        else:
20494 
          iprot.skip(ftype)
20495 
      else:
20496 
        iprot.skip(ftype)
20497 
      iprot.readFieldEnd()
20498 
    iprot.readStructEnd()
20499 
 
20500 
  def write(self, oprot):
20501 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20502 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20503 
      return
20504 
    oprot.writeStructBegin('changeItem_result')
20505 
    if self.success is not None:
20506 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
20507 
      self.success.write(oprot)
20508 
      oprot.writeFieldEnd()
20509 
    if self.ex is not None:
20510 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
20511 
      self.ex.write(oprot)
20512 
      oprot.writeFieldEnd()
20513 
    oprot.writeFieldStop()
20514 
    oprot.writeStructEnd()
20515 
 
20516 
  def validate(self):
20517 
    return
20518 
 
20519 
 
20520 
  def __repr__(self):
20521 
    L = ['%s=%r' % (key, value)
20522 
      for key, value in self.__dict__.iteritems()]
20523 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20524 
 
20525 
  def __eq__(self, other):
20526 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20527 
 
20528 
  def __ne__(self, other):
20529 
    return not (self == other)
20530 
 
20531 
class shiftToWarehouse_args:
20532 
  """
20533 
  Attributes:
20534 
   - orderId
20535 
   - warehouseId
20536 
  """
20537 
 
20538 
  thrift_spec = (
20539 
    None, # 0
20540 
    (1, TType.I64, 'orderId', None, None, ), # 1
20541 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
20542 
  )
20543 
 
20544 
  def __init__(self, orderId=None, warehouseId=None,):
20545 
    self.orderId = orderId
20546 
    self.warehouseId = warehouseId
20547 
 
20548 
  def read(self, iprot):
20549 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20550 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20551 
      return
20552 
    iprot.readStructBegin()
20553 
    while True:
20554 
      (fname, ftype, fid) = iprot.readFieldBegin()
20555 
      if ftype == TType.STOP:
20556 
        break
20557 
      if fid == 1:
20558 
        if ftype == TType.I64:
20559 
          self.orderId = iprot.readI64();
20560 
        else:
20561 
          iprot.skip(ftype)
20562 
      elif fid == 2:
20563 
        if ftype == TType.I64:
20564 
          self.warehouseId = iprot.readI64();
20565 
        else:
20566 
          iprot.skip(ftype)
20567 
      else:
20568 
        iprot.skip(ftype)
20569 
      iprot.readFieldEnd()
20570 
    iprot.readStructEnd()
20571 
 
20572 
  def write(self, oprot):
20573 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20574 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20575 
      return
20576 
    oprot.writeStructBegin('shiftToWarehouse_args')
20577 
    if self.orderId is not None:
20578 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
20579 
      oprot.writeI64(self.orderId)
20580 
      oprot.writeFieldEnd()
20581 
    if self.warehouseId is not None:
20582 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
20583 
      oprot.writeI64(self.warehouseId)
20584 
      oprot.writeFieldEnd()
20585 
    oprot.writeFieldStop()
20586 
    oprot.writeStructEnd()
20587 
 
20588 
  def validate(self):
20589 
    return
20590 
 
20591 
 
20592 
  def __repr__(self):
20593 
    L = ['%s=%r' % (key, value)
20594 
      for key, value in self.__dict__.iteritems()]
20595 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20596 
 
20597 
  def __eq__(self, other):
20598 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20599 
 
20600 
  def __ne__(self, other):
20601 
    return not (self == other)
20602 
 
20603 
class shiftToWarehouse_result:
20604 
  """
20605 
  Attributes:
20606 
   - success
20607 
   - ex
20608 
  """
20609 
 
20610 
  thrift_spec = (
20611 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
20612 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
20613 
  )
20614 
 
20615 
  def __init__(self, success=None, ex=None,):
20616 
    self.success = success
20617 
    self.ex = ex
20618 
 
20619 
  def read(self, iprot):
20620 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20621 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20622 
      return
20623 
    iprot.readStructBegin()
20624 
    while True:
20625 
      (fname, ftype, fid) = iprot.readFieldBegin()
20626 
      if ftype == TType.STOP:
20627 
        break
20628 
      if fid == 0:
20629 
        if ftype == TType.STRUCT:
20630 
          self.success = Order()
20631 
          self.success.read(iprot)
20632 
        else:
20633 
          iprot.skip(ftype)
20634 
      elif fid == 1:
20635 
        if ftype == TType.STRUCT:
20636 
          self.ex = TransactionServiceException()
20637 
          self.ex.read(iprot)
20638 
        else:
20639 
          iprot.skip(ftype)
20640 
      else:
20641 
        iprot.skip(ftype)
20642 
      iprot.readFieldEnd()
20643 
    iprot.readStructEnd()
20644 
 
20645 
  def write(self, oprot):
20646 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20647 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20648 
      return
20649 
    oprot.writeStructBegin('shiftToWarehouse_result')
20650 
    if self.success is not None:
20651 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
20652 
      self.success.write(oprot)
20653 
      oprot.writeFieldEnd()
20654 
    if self.ex is not None:
20655 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
20656 
      self.ex.write(oprot)
20657 
      oprot.writeFieldEnd()
20658 
    oprot.writeFieldStop()
20659 
    oprot.writeStructEnd()
20660 
 
20661 
  def validate(self):
20662 
    return
20663 
 
20664 
 
20665 
  def __repr__(self):
20666 
    L = ['%s=%r' % (key, value)
20667 
      for key, value in self.__dict__.iteritems()]
20668 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20669 
 
20670 
  def __eq__(self, other):
20671 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20672 
 
20673 
  def __ne__(self, other):
20674 
    return not (self == other)
3553 chandransh 20675 
 
20676 
class addDelayReason_args:
20677 
  """
20678 
  Attributes:
20679 
   - orderId
20680 
   - delayReason
3986 chandransh 20681 
   - furtherDelay
4647 rajveer 20682 
   - delayReasonText
3553 chandransh 20683 
  """
20684 
 
20685 
  thrift_spec = (
20686 
    None, # 0
20687 
    (1, TType.I64, 'orderId', None, None, ), # 1
20688 
    (2, TType.I32, 'delayReason', None, None, ), # 2
3986 chandransh 20689 
    (3, TType.I64, 'furtherDelay', None, None, ), # 3
4647 rajveer 20690 
    (4, TType.STRING, 'delayReasonText', None, None, ), # 4
3553 chandransh 20691 
  )
20692 
 
4647 rajveer 20693 
  def __init__(self, orderId=None, delayReason=None, furtherDelay=None, delayReasonText=None,):
3553 chandransh 20694 
    self.orderId = orderId
20695 
    self.delayReason = delayReason
3986 chandransh 20696 
    self.furtherDelay = furtherDelay
4647 rajveer 20697 
    self.delayReasonText = delayReasonText
3553 chandransh 20698 
 
20699 
  def read(self, iprot):
20700 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20701 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20702 
      return
20703 
    iprot.readStructBegin()
20704 
    while True:
20705 
      (fname, ftype, fid) = iprot.readFieldBegin()
20706 
      if ftype == TType.STOP:
20707 
        break
20708 
      if fid == 1:
20709 
        if ftype == TType.I64:
20710 
          self.orderId = iprot.readI64();
20711 
        else:
20712 
          iprot.skip(ftype)
20713 
      elif fid == 2:
20714 
        if ftype == TType.I32:
20715 
          self.delayReason = iprot.readI32();
20716 
        else:
20717 
          iprot.skip(ftype)
3986 chandransh 20718 
      elif fid == 3:
20719 
        if ftype == TType.I64:
20720 
          self.furtherDelay = iprot.readI64();
20721 
        else:
20722 
          iprot.skip(ftype)
4647 rajveer 20723 
      elif fid == 4:
20724 
        if ftype == TType.STRING:
20725 
          self.delayReasonText = iprot.readString();
20726 
        else:
20727 
          iprot.skip(ftype)
3553 chandransh 20728 
      else:
20729 
        iprot.skip(ftype)
20730 
      iprot.readFieldEnd()
20731 
    iprot.readStructEnd()
20732 
 
20733 
  def write(self, oprot):
20734 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20735 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20736 
      return
20737 
    oprot.writeStructBegin('addDelayReason_args')
20738 
    if self.orderId is not None:
20739 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
20740 
      oprot.writeI64(self.orderId)
20741 
      oprot.writeFieldEnd()
20742 
    if self.delayReason is not None:
20743 
      oprot.writeFieldBegin('delayReason', TType.I32, 2)
20744 
      oprot.writeI32(self.delayReason)
20745 
      oprot.writeFieldEnd()
3986 chandransh 20746 
    if self.furtherDelay is not None:
20747 
      oprot.writeFieldBegin('furtherDelay', TType.I64, 3)
20748 
      oprot.writeI64(self.furtherDelay)
20749 
      oprot.writeFieldEnd()
4647 rajveer 20750 
    if self.delayReasonText is not None:
20751 
      oprot.writeFieldBegin('delayReasonText', TType.STRING, 4)
20752 
      oprot.writeString(self.delayReasonText)
20753 
      oprot.writeFieldEnd()
3553 chandransh 20754 
    oprot.writeFieldStop()
20755 
    oprot.writeStructEnd()
20756 
 
20757 
  def validate(self):
20758 
    return
20759 
 
20760 
 
20761 
  def __repr__(self):
20762 
    L = ['%s=%r' % (key, value)
20763 
      for key, value in self.__dict__.iteritems()]
20764 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20765 
 
20766 
  def __eq__(self, other):
20767 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20768 
 
20769 
  def __ne__(self, other):
20770 
    return not (self == other)
20771 
 
20772 
class addDelayReason_result:
20773 
  """
20774 
  Attributes:
20775 
   - success
20776 
   - ex
20777 
  """
20778 
 
20779 
  thrift_spec = (
20780 
    (0, TType.BOOL, 'success', None, None, ), # 0
20781 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
20782 
  )
20783 
 
20784 
  def __init__(self, success=None, ex=None,):
20785 
    self.success = success
20786 
    self.ex = ex
20787 
 
20788 
  def read(self, iprot):
20789 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20790 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20791 
      return
20792 
    iprot.readStructBegin()
20793 
    while True:
20794 
      (fname, ftype, fid) = iprot.readFieldBegin()
20795 
      if ftype == TType.STOP:
20796 
        break
20797 
      if fid == 0:
20798 
        if ftype == TType.BOOL:
20799 
          self.success = iprot.readBool();
20800 
        else:
20801 
          iprot.skip(ftype)
20802 
      elif fid == 1:
20803 
        if ftype == TType.STRUCT:
20804 
          self.ex = TransactionServiceException()
20805 
          self.ex.read(iprot)
20806 
        else:
20807 
          iprot.skip(ftype)
20808 
      else:
20809 
        iprot.skip(ftype)
20810 
      iprot.readFieldEnd()
20811 
    iprot.readStructEnd()
20812 
 
20813 
  def write(self, oprot):
20814 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20815 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20816 
      return
20817 
    oprot.writeStructBegin('addDelayReason_result')
20818 
    if self.success is not None:
20819 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
20820 
      oprot.writeBool(self.success)
20821 
      oprot.writeFieldEnd()
20822 
    if self.ex is not None:
20823 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
20824 
      self.ex.write(oprot)
20825 
      oprot.writeFieldEnd()
20826 
    oprot.writeFieldStop()
20827 
    oprot.writeStructEnd()
20828 
 
20829 
  def validate(self):
20830 
    return
20831 
 
20832 
 
20833 
  def __repr__(self):
20834 
    L = ['%s=%r' % (key, value)
20835 
      for key, value in self.__dict__.iteritems()]
20836 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20837 
 
20838 
  def __eq__(self, other):
20839 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20840 
 
20841 
  def __ne__(self, other):
20842 
    return not (self == other)
3956 chandransh 20843 
 
20844 
class reconcileCodCollection_args:
20845 
  """
20846 
  Attributes:
20847 
   - collectedAmountMap
20848 
   - xferBy
20849 
   - xferTxnId
20850 
   - xferDate
20851 
  """
20852 
 
20853 
  thrift_spec = (
20854 
    None, # 0
20855 
    (1, TType.MAP, 'collectedAmountMap', (TType.STRING,None,TType.DOUBLE,None), None, ), # 1
20856 
    (2, TType.STRING, 'xferBy', None, None, ), # 2
20857 
    (3, TType.STRING, 'xferTxnId', None, None, ), # 3
20858 
    (4, TType.I64, 'xferDate', None, None, ), # 4
20859 
  )
20860 
 
20861 
  def __init__(self, collectedAmountMap=None, xferBy=None, xferTxnId=None, xferDate=None,):
20862 
    self.collectedAmountMap = collectedAmountMap
20863 
    self.xferBy = xferBy
20864 
    self.xferTxnId = xferTxnId
20865 
    self.xferDate = xferDate
20866 
 
20867 
  def read(self, iprot):
20868 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20869 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20870 
      return
20871 
    iprot.readStructBegin()
20872 
    while True:
20873 
      (fname, ftype, fid) = iprot.readFieldBegin()
20874 
      if ftype == TType.STOP:
20875 
        break
20876 
      if fid == 1:
20877 
        if ftype == TType.MAP:
20878 
          self.collectedAmountMap = {}
6188 rajveer 20879 
          (_ktype454, _vtype455, _size453 ) = iprot.readMapBegin()
20880 
          for _i457 in xrange(_size453):
20881 
            _key458 = iprot.readString();
20882 
            _val459 = iprot.readDouble();
20883 
            self.collectedAmountMap[_key458] = _val459
3956 chandransh 20884 
          iprot.readMapEnd()
20885 
        else:
20886 
          iprot.skip(ftype)
20887 
      elif fid == 2:
20888 
        if ftype == TType.STRING:
20889 
          self.xferBy = iprot.readString();
20890 
        else:
20891 
          iprot.skip(ftype)
20892 
      elif fid == 3:
20893 
        if ftype == TType.STRING:
20894 
          self.xferTxnId = iprot.readString();
20895 
        else:
20896 
          iprot.skip(ftype)
20897 
      elif fid == 4:
20898 
        if ftype == TType.I64:
20899 
          self.xferDate = iprot.readI64();
20900 
        else:
20901 
          iprot.skip(ftype)
20902 
      else:
20903 
        iprot.skip(ftype)
20904 
      iprot.readFieldEnd()
20905 
    iprot.readStructEnd()
20906 
 
20907 
  def write(self, oprot):
20908 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20909 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20910 
      return
20911 
    oprot.writeStructBegin('reconcileCodCollection_args')
20912 
    if self.collectedAmountMap is not None:
20913 
      oprot.writeFieldBegin('collectedAmountMap', TType.MAP, 1)
20914 
      oprot.writeMapBegin(TType.STRING, TType.DOUBLE, len(self.collectedAmountMap))
6188 rajveer 20915 
      for kiter460,viter461 in self.collectedAmountMap.items():
20916 
        oprot.writeString(kiter460)
20917 
        oprot.writeDouble(viter461)
3956 chandransh 20918 
      oprot.writeMapEnd()
20919 
      oprot.writeFieldEnd()
20920 
    if self.xferBy is not None:
20921 
      oprot.writeFieldBegin('xferBy', TType.STRING, 2)
20922 
      oprot.writeString(self.xferBy)
20923 
      oprot.writeFieldEnd()
20924 
    if self.xferTxnId is not None:
20925 
      oprot.writeFieldBegin('xferTxnId', TType.STRING, 3)
20926 
      oprot.writeString(self.xferTxnId)
20927 
      oprot.writeFieldEnd()
20928 
    if self.xferDate is not None:
20929 
      oprot.writeFieldBegin('xferDate', TType.I64, 4)
20930 
      oprot.writeI64(self.xferDate)
20931 
      oprot.writeFieldEnd()
20932 
    oprot.writeFieldStop()
20933 
    oprot.writeStructEnd()
20934 
 
20935 
  def validate(self):
20936 
    return
20937 
 
20938 
 
20939 
  def __repr__(self):
20940 
    L = ['%s=%r' % (key, value)
20941 
      for key, value in self.__dict__.iteritems()]
20942 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20943 
 
20944 
  def __eq__(self, other):
20945 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20946 
 
20947 
  def __ne__(self, other):
20948 
    return not (self == other)
20949 
 
20950 
class reconcileCodCollection_result:
20951 
  """
20952 
  Attributes:
20953 
   - success
20954 
   - ex
20955 
  """
20956 
 
20957 
  thrift_spec = (
20958 
    (0, TType.MAP, 'success', (TType.STRING,None,TType.STRING,None), None, ), # 0
20959 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
20960 
  )
20961 
 
20962 
  def __init__(self, success=None, ex=None,):
20963 
    self.success = success
20964 
    self.ex = ex
20965 
 
20966 
  def read(self, iprot):
20967 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20968 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20969 
      return
20970 
    iprot.readStructBegin()
20971 
    while True:
20972 
      (fname, ftype, fid) = iprot.readFieldBegin()
20973 
      if ftype == TType.STOP:
20974 
        break
20975 
      if fid == 0:
20976 
        if ftype == TType.MAP:
20977 
          self.success = {}
6188 rajveer 20978 
          (_ktype463, _vtype464, _size462 ) = iprot.readMapBegin()
20979 
          for _i466 in xrange(_size462):
20980 
            _key467 = iprot.readString();
20981 
            _val468 = iprot.readString();
20982 
            self.success[_key467] = _val468
3956 chandransh 20983 
          iprot.readMapEnd()
20984 
        else:
20985 
          iprot.skip(ftype)
20986 
      elif fid == 1:
20987 
        if ftype == TType.STRUCT:
20988 
          self.ex = TransactionServiceException()
20989 
          self.ex.read(iprot)
20990 
        else:
20991 
          iprot.skip(ftype)
20992 
      else:
20993 
        iprot.skip(ftype)
20994 
      iprot.readFieldEnd()
20995 
    iprot.readStructEnd()
20996 
 
20997 
  def write(self, oprot):
20998 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20999 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21000 
      return
21001 
    oprot.writeStructBegin('reconcileCodCollection_result')
21002 
    if self.success is not None:
21003 
      oprot.writeFieldBegin('success', TType.MAP, 0)
21004 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.success))
6188 rajveer 21005 
      for kiter469,viter470 in self.success.items():
21006 
        oprot.writeString(kiter469)
21007 
        oprot.writeString(viter470)
3956 chandransh 21008 
      oprot.writeMapEnd()
21009 
      oprot.writeFieldEnd()
21010 
    if self.ex is not None:
21011 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
21012 
      self.ex.write(oprot)
21013 
      oprot.writeFieldEnd()
21014 
    oprot.writeFieldStop()
21015 
    oprot.writeStructEnd()
21016 
 
21017 
  def validate(self):
21018 
    return
21019 
 
21020 
 
21021 
  def __repr__(self):
21022 
    L = ['%s=%r' % (key, value)
21023 
      for key, value in self.__dict__.iteritems()]
21024 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21025 
 
21026 
  def __eq__(self, other):
21027 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21028 
 
21029 
  def __ne__(self, other):
21030 
    return not (self == other)
4008 mandeep.dh 21031 
 
21032 
class getTransactionsRequiringExtraProcessing_args:
21033 
  """
21034 
  Attributes:
21035 
   - category
21036 
  """
21037 
 
21038 
  thrift_spec = (
21039 
    None, # 0
21040 
    (1, TType.I32, 'category', None, None, ), # 1
21041 
  )
21042 
 
21043 
  def __init__(self, category=None,):
21044 
    self.category = category
21045 
 
21046 
  def read(self, iprot):
21047 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21048 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21049 
      return
21050 
    iprot.readStructBegin()
21051 
    while True:
21052 
      (fname, ftype, fid) = iprot.readFieldBegin()
21053 
      if ftype == TType.STOP:
21054 
        break
21055 
      if fid == 1:
21056 
        if ftype == TType.I32:
21057 
          self.category = iprot.readI32();
21058 
        else:
21059 
          iprot.skip(ftype)
21060 
      else:
21061 
        iprot.skip(ftype)
21062 
      iprot.readFieldEnd()
21063 
    iprot.readStructEnd()
21064 
 
21065 
  def write(self, oprot):
21066 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21067 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21068 
      return
21069 
    oprot.writeStructBegin('getTransactionsRequiringExtraProcessing_args')
21070 
    if self.category is not None:
21071 
      oprot.writeFieldBegin('category', TType.I32, 1)
21072 
      oprot.writeI32(self.category)
21073 
      oprot.writeFieldEnd()
21074 
    oprot.writeFieldStop()
21075 
    oprot.writeStructEnd()
21076 
 
21077 
  def validate(self):
21078 
    return
21079 
 
21080 
 
21081 
  def __repr__(self):
21082 
    L = ['%s=%r' % (key, value)
21083 
      for key, value in self.__dict__.iteritems()]
21084 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21085 
 
21086 
  def __eq__(self, other):
21087 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21088 
 
21089 
  def __ne__(self, other):
21090 
    return not (self == other)
21091 
 
21092 
class getTransactionsRequiringExtraProcessing_result:
21093 
  """
21094 
  Attributes:
21095 
   - success
21096 
  """
21097 
 
21098 
  thrift_spec = (
21099 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
21100 
  )
21101 
 
21102 
  def __init__(self, success=None,):
21103 
    self.success = success
21104 
 
21105 
  def read(self, iprot):
21106 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21107 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21108 
      return
21109 
    iprot.readStructBegin()
21110 
    while True:
21111 
      (fname, ftype, fid) = iprot.readFieldBegin()
21112 
      if ftype == TType.STOP:
21113 
        break
21114 
      if fid == 0:
21115 
        if ftype == TType.LIST:
21116 
          self.success = []
6188 rajveer 21117 
          (_etype474, _size471) = iprot.readListBegin()
21118 
          for _i475 in xrange(_size471):
21119 
            _elem476 = iprot.readI64();
21120 
            self.success.append(_elem476)
4008 mandeep.dh 21121 
          iprot.readListEnd()
21122 
        else:
21123 
          iprot.skip(ftype)
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('getTransactionsRequiringExtraProcessing_result')
21134 
    if self.success is not None:
21135 
      oprot.writeFieldBegin('success', TType.LIST, 0)
21136 
      oprot.writeListBegin(TType.I64, len(self.success))
6188 rajveer 21137 
      for iter477 in self.success:
21138 
        oprot.writeI64(iter477)
4008 mandeep.dh 21139 
      oprot.writeListEnd()
21140 
      oprot.writeFieldEnd()
21141 
    oprot.writeFieldStop()
21142 
    oprot.writeStructEnd()
21143 
 
21144 
  def validate(self):
21145 
    return
21146 
 
21147 
 
21148 
  def __repr__(self):
21149 
    L = ['%s=%r' % (key, value)
21150 
      for key, value in self.__dict__.iteritems()]
21151 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21152 
 
21153 
  def __eq__(self, other):
21154 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21155 
 
21156 
  def __ne__(self, other):
21157 
    return not (self == other)
21158 
 
21159 
class markTransactionAsProcessed_args:
21160 
  """
21161 
  Attributes:
21162 
   - transactionId
21163 
   - category
21164 
  """
21165 
 
21166 
  thrift_spec = (
21167 
    None, # 0
21168 
    (1, TType.I64, 'transactionId', None, None, ), # 1
21169 
    (2, TType.I32, 'category', None, None, ), # 2
21170 
  )
21171 
 
21172 
  def __init__(self, transactionId=None, category=None,):
21173 
    self.transactionId = transactionId
21174 
    self.category = category
21175 
 
21176 
  def read(self, iprot):
21177 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21178 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21179 
      return
21180 
    iprot.readStructBegin()
21181 
    while True:
21182 
      (fname, ftype, fid) = iprot.readFieldBegin()
21183 
      if ftype == TType.STOP:
21184 
        break
21185 
      if fid == 1:
21186 
        if ftype == TType.I64:
21187 
          self.transactionId = iprot.readI64();
21188 
        else:
21189 
          iprot.skip(ftype)
21190 
      elif fid == 2:
21191 
        if ftype == TType.I32:
21192 
          self.category = iprot.readI32();
21193 
        else:
21194 
          iprot.skip(ftype)
21195 
      else:
21196 
        iprot.skip(ftype)
21197 
      iprot.readFieldEnd()
21198 
    iprot.readStructEnd()
21199 
 
21200 
  def write(self, oprot):
21201 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21202 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21203 
      return
21204 
    oprot.writeStructBegin('markTransactionAsProcessed_args')
21205 
    if self.transactionId is not None:
21206 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
21207 
      oprot.writeI64(self.transactionId)
21208 
      oprot.writeFieldEnd()
21209 
    if self.category is not None:
21210 
      oprot.writeFieldBegin('category', TType.I32, 2)
21211 
      oprot.writeI32(self.category)
21212 
      oprot.writeFieldEnd()
21213 
    oprot.writeFieldStop()
21214 
    oprot.writeStructEnd()
21215 
 
21216 
  def validate(self):
21217 
    return
21218 
 
21219 
 
21220 
  def __repr__(self):
21221 
    L = ['%s=%r' % (key, value)
21222 
      for key, value in self.__dict__.iteritems()]
21223 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21224 
 
21225 
  def __eq__(self, other):
21226 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21227 
 
21228 
  def __ne__(self, other):
21229 
    return not (self == other)
21230 
 
21231 
class markTransactionAsProcessed_result:
21232 
 
21233 
  thrift_spec = (
21234 
  )
21235 
 
21236 
  def read(self, iprot):
21237 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21238 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21239 
      return
21240 
    iprot.readStructBegin()
21241 
    while True:
21242 
      (fname, ftype, fid) = iprot.readFieldBegin()
21243 
      if ftype == TType.STOP:
21244 
        break
21245 
      else:
21246 
        iprot.skip(ftype)
21247 
      iprot.readFieldEnd()
21248 
    iprot.readStructEnd()
21249 
 
21250 
  def write(self, oprot):
21251 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21252 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21253 
      return
21254 
    oprot.writeStructBegin('markTransactionAsProcessed_result')
21255 
    oprot.writeFieldStop()
21256 
    oprot.writeStructEnd()
21257 
 
21258 
  def validate(self):
21259 
    return
21260 
 
21261 
 
21262 
  def __repr__(self):
21263 
    L = ['%s=%r' % (key, value)
21264 
      for key, value in self.__dict__.iteritems()]
21265 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21266 
 
21267 
  def __eq__(self, other):
21268 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21269 
 
21270 
  def __ne__(self, other):
21271 
    return not (self == other)
4018 chandransh 21272 
 
21273 
class getItemWiseRiskyOrdersCount_args:
21274 
 
21275 
  thrift_spec = (
21276 
  )
21277 
 
21278 
  def read(self, iprot):
21279 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21280 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21281 
      return
21282 
    iprot.readStructBegin()
21283 
    while True:
21284 
      (fname, ftype, fid) = iprot.readFieldBegin()
21285 
      if ftype == TType.STOP:
21286 
        break
21287 
      else:
21288 
        iprot.skip(ftype)
21289 
      iprot.readFieldEnd()
21290 
    iprot.readStructEnd()
21291 
 
21292 
  def write(self, oprot):
21293 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21294 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21295 
      return
21296 
    oprot.writeStructBegin('getItemWiseRiskyOrdersCount_args')
21297 
    oprot.writeFieldStop()
21298 
    oprot.writeStructEnd()
21299 
 
21300 
  def validate(self):
21301 
    return
21302 
 
21303 
 
21304 
  def __repr__(self):
21305 
    L = ['%s=%r' % (key, value)
21306 
      for key, value in self.__dict__.iteritems()]
21307 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21308 
 
21309 
  def __eq__(self, other):
21310 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21311 
 
21312 
  def __ne__(self, other):
21313 
    return not (self == other)
21314 
 
21315 
class getItemWiseRiskyOrdersCount_result:
21316 
  """
21317 
  Attributes:
21318 
   - success
21319 
  """
21320 
 
21321 
  thrift_spec = (
21322 
    (0, TType.MAP, 'success', (TType.I64,None,TType.I64,None), None, ), # 0
21323 
  )
21324 
 
21325 
  def __init__(self, success=None,):
21326 
    self.success = success
21327 
 
21328 
  def read(self, iprot):
21329 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21330 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21331 
      return
21332 
    iprot.readStructBegin()
21333 
    while True:
21334 
      (fname, ftype, fid) = iprot.readFieldBegin()
21335 
      if ftype == TType.STOP:
21336 
        break
21337 
      if fid == 0:
21338 
        if ftype == TType.MAP:
21339 
          self.success = {}
6188 rajveer 21340 
          (_ktype479, _vtype480, _size478 ) = iprot.readMapBegin()
21341 
          for _i482 in xrange(_size478):
21342 
            _key483 = iprot.readI64();
21343 
            _val484 = iprot.readI64();
21344 
            self.success[_key483] = _val484
4018 chandransh 21345 
          iprot.readMapEnd()
21346 
        else:
21347 
          iprot.skip(ftype)
21348 
      else:
21349 
        iprot.skip(ftype)
21350 
      iprot.readFieldEnd()
21351 
    iprot.readStructEnd()
21352 
 
21353 
  def write(self, oprot):
21354 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21355 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21356 
      return
21357 
    oprot.writeStructBegin('getItemWiseRiskyOrdersCount_result')
21358 
    if self.success is not None:
21359 
      oprot.writeFieldBegin('success', TType.MAP, 0)
21360 
      oprot.writeMapBegin(TType.I64, TType.I64, len(self.success))
6188 rajveer 21361 
      for kiter485,viter486 in self.success.items():
21362 
        oprot.writeI64(kiter485)
21363 
        oprot.writeI64(viter486)
4018 chandransh 21364 
      oprot.writeMapEnd()
21365 
      oprot.writeFieldEnd()
21366 
    oprot.writeFieldStop()
21367 
    oprot.writeStructEnd()
21368 
 
21369 
  def validate(self):
21370 
    return
21371 
 
21372 
 
21373 
  def __repr__(self):
21374 
    L = ['%s=%r' % (key, value)
21375 
      for key, value in self.__dict__.iteritems()]
21376 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21377 
 
21378 
  def __eq__(self, other):
21379 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21380 
 
21381 
  def __ne__(self, other):
21382 
    return not (self == other)
4247 rajveer 21383 
 
4295 varun.gupt 21384 
class getOrdersForItemIds_args:
21385 
  """
21386 
  Attributes:
21387 
   - itemIds
21388 
  """
21389 
 
21390 
  thrift_spec = (
21391 
    None, # 0
21392 
    (1, TType.LIST, 'itemIds', (TType.I64,None), None, ), # 1
21393 
  )
21394 
 
21395 
  def __init__(self, itemIds=None,):
21396 
    self.itemIds = itemIds
21397 
 
21398 
  def read(self, iprot):
21399 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21400 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21401 
      return
21402 
    iprot.readStructBegin()
21403 
    while True:
21404 
      (fname, ftype, fid) = iprot.readFieldBegin()
21405 
      if ftype == TType.STOP:
21406 
        break
21407 
      if fid == 1:
21408 
        if ftype == TType.LIST:
21409 
          self.itemIds = []
6188 rajveer 21410 
          (_etype490, _size487) = iprot.readListBegin()
21411 
          for _i491 in xrange(_size487):
21412 
            _elem492 = iprot.readI64();
21413 
            self.itemIds.append(_elem492)
4295 varun.gupt 21414 
          iprot.readListEnd()
21415 
        else:
21416 
          iprot.skip(ftype)
21417 
      else:
21418 
        iprot.skip(ftype)
21419 
      iprot.readFieldEnd()
21420 
    iprot.readStructEnd()
21421 
 
21422 
  def write(self, oprot):
21423 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21424 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21425 
      return
21426 
    oprot.writeStructBegin('getOrdersForItemIds_args')
21427 
    if self.itemIds is not None:
21428 
      oprot.writeFieldBegin('itemIds', TType.LIST, 1)
21429 
      oprot.writeListBegin(TType.I64, len(self.itemIds))
6188 rajveer 21430 
      for iter493 in self.itemIds:
21431 
        oprot.writeI64(iter493)
4295 varun.gupt 21432 
      oprot.writeListEnd()
21433 
      oprot.writeFieldEnd()
21434 
    oprot.writeFieldStop()
21435 
    oprot.writeStructEnd()
21436 
 
21437 
  def validate(self):
21438 
    return
21439 
 
21440 
 
21441 
  def __repr__(self):
21442 
    L = ['%s=%r' % (key, value)
21443 
      for key, value in self.__dict__.iteritems()]
21444 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21445 
 
21446 
  def __eq__(self, other):
21447 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21448 
 
21449 
  def __ne__(self, other):
21450 
    return not (self == other)
21451 
 
21452 
class getOrdersForItemIds_result:
21453 
  """
21454 
  Attributes:
21455 
   - success
21456 
  """
21457 
 
21458 
  thrift_spec = (
21459 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
21460 
  )
21461 
 
21462 
  def __init__(self, success=None,):
21463 
    self.success = success
21464 
 
21465 
  def read(self, iprot):
21466 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21467 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21468 
      return
21469 
    iprot.readStructBegin()
21470 
    while True:
21471 
      (fname, ftype, fid) = iprot.readFieldBegin()
21472 
      if ftype == TType.STOP:
21473 
        break
21474 
      if fid == 0:
21475 
        if ftype == TType.LIST:
21476 
          self.success = []
6188 rajveer 21477 
          (_etype497, _size494) = iprot.readListBegin()
21478 
          for _i498 in xrange(_size494):
21479 
            _elem499 = Order()
21480 
            _elem499.read(iprot)
21481 
            self.success.append(_elem499)
4295 varun.gupt 21482 
          iprot.readListEnd()
21483 
        else:
21484 
          iprot.skip(ftype)
21485 
      else:
21486 
        iprot.skip(ftype)
21487 
      iprot.readFieldEnd()
21488 
    iprot.readStructEnd()
21489 
 
21490 
  def write(self, oprot):
21491 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21492 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21493 
      return
21494 
    oprot.writeStructBegin('getOrdersForItemIds_result')
21495 
    if self.success is not None:
21496 
      oprot.writeFieldBegin('success', TType.LIST, 0)
21497 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 21498 
      for iter500 in self.success:
21499 
        iter500.write(oprot)
4295 varun.gupt 21500 
      oprot.writeListEnd()
21501 
      oprot.writeFieldEnd()
21502 
    oprot.writeFieldStop()
21503 
    oprot.writeStructEnd()
21504 
 
21505 
  def validate(self):
21506 
    return
21507 
 
21508 
 
21509 
  def __repr__(self):
21510 
    L = ['%s=%r' % (key, value)
21511 
      for key, value in self.__dict__.iteritems()]
21512 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21513 
 
21514 
  def __eq__(self, other):
21515 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21516 
 
21517 
  def __ne__(self, other):
21518 
    return not (self == other)
21519 
 
4247 rajveer 21520 
class markOrderCancellationRequestReceived_args:
21521 
  """
21522 
  Attributes:
21523 
   - orderId
21524 
  """
21525 
 
21526 
  thrift_spec = (
21527 
    None, # 0
21528 
    (1, TType.I64, 'orderId', None, None, ), # 1
21529 
  )
21530 
 
21531 
  def __init__(self, orderId=None,):
21532 
    self.orderId = orderId
21533 
 
21534 
  def read(self, iprot):
21535 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21536 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21537 
      return
21538 
    iprot.readStructBegin()
21539 
    while True:
21540 
      (fname, ftype, fid) = iprot.readFieldBegin()
21541 
      if ftype == TType.STOP:
21542 
        break
21543 
      if fid == 1:
21544 
        if ftype == TType.I64:
21545 
          self.orderId = iprot.readI64();
21546 
        else:
21547 
          iprot.skip(ftype)
21548 
      else:
21549 
        iprot.skip(ftype)
21550 
      iprot.readFieldEnd()
21551 
    iprot.readStructEnd()
21552 
 
21553 
  def write(self, oprot):
21554 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21555 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21556 
      return
21557 
    oprot.writeStructBegin('markOrderCancellationRequestReceived_args')
21558 
    if self.orderId is not None:
21559 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
21560 
      oprot.writeI64(self.orderId)
21561 
      oprot.writeFieldEnd()
21562 
    oprot.writeFieldStop()
21563 
    oprot.writeStructEnd()
21564 
 
21565 
  def validate(self):
21566 
    return
21567 
 
21568 
 
21569 
  def __repr__(self):
21570 
    L = ['%s=%r' % (key, value)
21571 
      for key, value in self.__dict__.iteritems()]
21572 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21573 
 
21574 
  def __eq__(self, other):
21575 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21576 
 
21577 
  def __ne__(self, other):
21578 
    return not (self == other)
21579 
 
21580 
class markOrderCancellationRequestReceived_result:
21581 
  """
21582 
  Attributes:
21583 
   - ex
21584 
  """
21585 
 
21586 
  thrift_spec = (
21587 
    None, # 0
21588 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
21589 
  )
21590 
 
21591 
  def __init__(self, ex=None,):
21592 
    self.ex = ex
21593 
 
21594 
  def read(self, iprot):
21595 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21596 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21597 
      return
21598 
    iprot.readStructBegin()
21599 
    while True:
21600 
      (fname, ftype, fid) = iprot.readFieldBegin()
21601 
      if ftype == TType.STOP:
21602 
        break
21603 
      if fid == 1:
21604 
        if ftype == TType.STRUCT:
21605 
          self.ex = TransactionServiceException()
21606 
          self.ex.read(iprot)
21607 
        else:
21608 
          iprot.skip(ftype)
21609 
      else:
21610 
        iprot.skip(ftype)
21611 
      iprot.readFieldEnd()
21612 
    iprot.readStructEnd()
21613 
 
21614 
  def write(self, oprot):
21615 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21616 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21617 
      return
21618 
    oprot.writeStructBegin('markOrderCancellationRequestReceived_result')
21619 
    if self.ex is not None:
21620 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
21621 
      self.ex.write(oprot)
21622 
      oprot.writeFieldEnd()
21623 
    oprot.writeFieldStop()
21624 
    oprot.writeStructEnd()
21625 
 
21626 
  def validate(self):
21627 
    return
21628 
 
21629 
 
21630 
  def __repr__(self):
21631 
    L = ['%s=%r' % (key, value)
21632 
      for key, value in self.__dict__.iteritems()]
21633 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21634 
 
21635 
  def __eq__(self, other):
21636 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21637 
 
21638 
  def __ne__(self, other):
21639 
    return not (self == other)
21640 
 
21641 
class markOrderCancellationRequestConfirmed_args:
21642 
  """
21643 
  Attributes:
21644 
   - orderId
21645 
  """
21646 
 
21647 
  thrift_spec = (
21648 
    None, # 0
21649 
    (1, TType.I64, 'orderId', None, None, ), # 1
21650 
  )
21651 
 
21652 
  def __init__(self, orderId=None,):
21653 
    self.orderId = orderId
21654 
 
21655 
  def read(self, iprot):
21656 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21657 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21658 
      return
21659 
    iprot.readStructBegin()
21660 
    while True:
21661 
      (fname, ftype, fid) = iprot.readFieldBegin()
21662 
      if ftype == TType.STOP:
21663 
        break
21664 
      if fid == 1:
21665 
        if ftype == TType.I64:
21666 
          self.orderId = iprot.readI64();
21667 
        else:
21668 
          iprot.skip(ftype)
21669 
      else:
21670 
        iprot.skip(ftype)
21671 
      iprot.readFieldEnd()
21672 
    iprot.readStructEnd()
21673 
 
21674 
  def write(self, oprot):
21675 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21676 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21677 
      return
21678 
    oprot.writeStructBegin('markOrderCancellationRequestConfirmed_args')
21679 
    if self.orderId is not None:
21680 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
21681 
      oprot.writeI64(self.orderId)
21682 
      oprot.writeFieldEnd()
21683 
    oprot.writeFieldStop()
21684 
    oprot.writeStructEnd()
21685 
 
21686 
  def validate(self):
21687 
    return
21688 
 
21689 
 
21690 
  def __repr__(self):
21691 
    L = ['%s=%r' % (key, value)
21692 
      for key, value in self.__dict__.iteritems()]
21693 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21694 
 
21695 
  def __eq__(self, other):
21696 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21697 
 
21698 
  def __ne__(self, other):
21699 
    return not (self == other)
21700 
 
21701 
class markOrderCancellationRequestConfirmed_result:
21702 
  """
21703 
  Attributes:
21704 
   - ex
21705 
  """
21706 
 
21707 
  thrift_spec = (
21708 
    None, # 0
21709 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
21710 
  )
21711 
 
21712 
  def __init__(self, ex=None,):
21713 
    self.ex = ex
21714 
 
21715 
  def read(self, iprot):
21716 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21717 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21718 
      return
21719 
    iprot.readStructBegin()
21720 
    while True:
21721 
      (fname, ftype, fid) = iprot.readFieldBegin()
21722 
      if ftype == TType.STOP:
21723 
        break
21724 
      if fid == 1:
21725 
        if ftype == TType.STRUCT:
21726 
          self.ex = TransactionServiceException()
21727 
          self.ex.read(iprot)
21728 
        else:
21729 
          iprot.skip(ftype)
21730 
      else:
21731 
        iprot.skip(ftype)
21732 
      iprot.readFieldEnd()
21733 
    iprot.readStructEnd()
21734 
 
21735 
  def write(self, oprot):
21736 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21737 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21738 
      return
21739 
    oprot.writeStructBegin('markOrderCancellationRequestConfirmed_result')
21740 
    if self.ex is not None:
21741 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
21742 
      self.ex.write(oprot)
21743 
      oprot.writeFieldEnd()
21744 
    oprot.writeFieldStop()
21745 
    oprot.writeStructEnd()
21746 
 
21747 
  def validate(self):
21748 
    return
21749 
 
21750 
 
21751 
  def __repr__(self):
21752 
    L = ['%s=%r' % (key, value)
21753 
      for key, value in self.__dict__.iteritems()]
21754 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21755 
 
21756 
  def __eq__(self, other):
21757 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21758 
 
21759 
  def __ne__(self, other):
21760 
    return not (self == other)
21761 
 
21762 
class markOrderCancellationRequestDenied_args:
21763 
  """
21764 
  Attributes:
21765 
   - orderId
21766 
  """
21767 
 
21768 
  thrift_spec = (
21769 
    None, # 0
21770 
    (1, TType.I64, 'orderId', None, None, ), # 1
21771 
  )
21772 
 
21773 
  def __init__(self, orderId=None,):
21774 
    self.orderId = orderId
21775 
 
21776 
  def read(self, iprot):
21777 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21778 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21779 
      return
21780 
    iprot.readStructBegin()
21781 
    while True:
21782 
      (fname, ftype, fid) = iprot.readFieldBegin()
21783 
      if ftype == TType.STOP:
21784 
        break
21785 
      if fid == 1:
21786 
        if ftype == TType.I64:
21787 
          self.orderId = iprot.readI64();
21788 
        else:
21789 
          iprot.skip(ftype)
21790 
      else:
21791 
        iprot.skip(ftype)
21792 
      iprot.readFieldEnd()
21793 
    iprot.readStructEnd()
21794 
 
21795 
  def write(self, oprot):
21796 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21797 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21798 
      return
21799 
    oprot.writeStructBegin('markOrderCancellationRequestDenied_args')
21800 
    if self.orderId is not None:
21801 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
21802 
      oprot.writeI64(self.orderId)
21803 
      oprot.writeFieldEnd()
21804 
    oprot.writeFieldStop()
21805 
    oprot.writeStructEnd()
21806 
 
21807 
  def validate(self):
21808 
    return
21809 
 
21810 
 
21811 
  def __repr__(self):
21812 
    L = ['%s=%r' % (key, value)
21813 
      for key, value in self.__dict__.iteritems()]
21814 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21815 
 
21816 
  def __eq__(self, other):
21817 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21818 
 
21819 
  def __ne__(self, other):
21820 
    return not (self == other)
21821 
 
21822 
class markOrderCancellationRequestDenied_result:
21823 
  """
21824 
  Attributes:
21825 
   - ex
21826 
  """
21827 
 
21828 
  thrift_spec = (
21829 
    None, # 0
21830 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
21831 
  )
21832 
 
21833 
  def __init__(self, ex=None,):
21834 
    self.ex = ex
21835 
 
21836 
  def read(self, iprot):
21837 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21838 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21839 
      return
21840 
    iprot.readStructBegin()
21841 
    while True:
21842 
      (fname, ftype, fid) = iprot.readFieldBegin()
21843 
      if ftype == TType.STOP:
21844 
        break
21845 
      if fid == 1:
21846 
        if ftype == TType.STRUCT:
21847 
          self.ex = TransactionServiceException()
21848 
          self.ex.read(iprot)
21849 
        else:
21850 
          iprot.skip(ftype)
21851 
      else:
21852 
        iprot.skip(ftype)
21853 
      iprot.readFieldEnd()
21854 
    iprot.readStructEnd()
21855 
 
21856 
  def write(self, oprot):
21857 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21858 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21859 
      return
21860 
    oprot.writeStructBegin('markOrderCancellationRequestDenied_result')
21861 
    if self.ex is not None:
21862 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
21863 
      self.ex.write(oprot)
21864 
      oprot.writeFieldEnd()
21865 
    oprot.writeFieldStop()
21866 
    oprot.writeStructEnd()
21867 
 
21868 
  def validate(self):
21869 
    return
21870 
 
21871 
 
21872 
  def __repr__(self):
21873 
    L = ['%s=%r' % (key, value)
21874 
      for key, value in self.__dict__.iteritems()]
21875 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21876 
 
21877 
  def __eq__(self, other):
21878 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21879 
 
21880 
  def __ne__(self, other):
21881 
    return not (self == other)
21882 
 
4258 rajveer 21883 
class markTransactionAsPaymentFlagRemoved_args:
4247 rajveer 21884 
  """
21885 
  Attributes:
4258 rajveer 21886 
   - transactionId
4247 rajveer 21887 
  """
21888 
 
21889 
  thrift_spec = (
21890 
    None, # 0
4258 rajveer 21891 
    (1, TType.I64, 'transactionId', None, None, ), # 1
4247 rajveer 21892 
  )
21893 
 
4258 rajveer 21894 
  def __init__(self, transactionId=None,):
21895 
    self.transactionId = transactionId
4247 rajveer 21896 
 
21897 
  def read(self, iprot):
21898 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21899 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21900 
      return
21901 
    iprot.readStructBegin()
21902 
    while True:
21903 
      (fname, ftype, fid) = iprot.readFieldBegin()
21904 
      if ftype == TType.STOP:
21905 
        break
21906 
      if fid == 1:
21907 
        if ftype == TType.I64:
4258 rajveer 21908 
          self.transactionId = iprot.readI64();
4247 rajveer 21909 
        else:
21910 
          iprot.skip(ftype)
21911 
      else:
21912 
        iprot.skip(ftype)
21913 
      iprot.readFieldEnd()
21914 
    iprot.readStructEnd()
21915 
 
21916 
  def write(self, oprot):
21917 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21918 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21919 
      return
4258 rajveer 21920 
    oprot.writeStructBegin('markTransactionAsPaymentFlagRemoved_args')
21921 
    if self.transactionId is not None:
21922 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
21923 
      oprot.writeI64(self.transactionId)
4247 rajveer 21924 
      oprot.writeFieldEnd()
21925 
    oprot.writeFieldStop()
21926 
    oprot.writeStructEnd()
21927 
 
21928 
  def validate(self):
21929 
    return
21930 
 
21931 
 
21932 
  def __repr__(self):
21933 
    L = ['%s=%r' % (key, value)
21934 
      for key, value in self.__dict__.iteritems()]
21935 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21936 
 
21937 
  def __eq__(self, other):
21938 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21939 
 
21940 
  def __ne__(self, other):
21941 
    return not (self == other)
21942 
 
4258 rajveer 21943 
class markTransactionAsPaymentFlagRemoved_result:
4247 rajveer 21944 
  """
21945 
  Attributes:
21946 
   - ex
21947 
  """
21948 
 
21949 
  thrift_spec = (
21950 
    None, # 0
21951 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
21952 
  )
21953 
 
21954 
  def __init__(self, ex=None,):
21955 
    self.ex = ex
21956 
 
21957 
  def read(self, iprot):
21958 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21959 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21960 
      return
21961 
    iprot.readStructBegin()
21962 
    while True:
21963 
      (fname, ftype, fid) = iprot.readFieldBegin()
21964 
      if ftype == TType.STOP:
21965 
        break
21966 
      if fid == 1:
21967 
        if ftype == TType.STRUCT:
21968 
          self.ex = TransactionServiceException()
21969 
          self.ex.read(iprot)
21970 
        else:
21971 
          iprot.skip(ftype)
21972 
      else:
21973 
        iprot.skip(ftype)
21974 
      iprot.readFieldEnd()
21975 
    iprot.readStructEnd()
21976 
 
21977 
  def write(self, oprot):
21978 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21979 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21980 
      return
4258 rajveer 21981 
    oprot.writeStructBegin('markTransactionAsPaymentFlagRemoved_result')
4247 rajveer 21982 
    if self.ex is not None:
21983 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
21984 
      self.ex.write(oprot)
21985 
      oprot.writeFieldEnd()
21986 
    oprot.writeFieldStop()
21987 
    oprot.writeStructEnd()
21988 
 
21989 
  def validate(self):
21990 
    return
21991 
 
21992 
 
21993 
  def __repr__(self):
21994 
    L = ['%s=%r' % (key, value)
21995 
      for key, value in self.__dict__.iteritems()]
21996 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21997 
 
21998 
  def __eq__(self, other):
21999 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22000 
 
22001 
  def __ne__(self, other):
22002 
    return not (self == other)
4259 anupam.sin 22003 
 
22004 
class refundTransaction_args:
22005 
  """
22006 
  Attributes:
22007 
   - transactionId
22008 
   - refundedBy
22009 
   - reason
22010 
  """
22011 
 
22012 
  thrift_spec = (
22013 
    None, # 0
22014 
    (1, TType.I64, 'transactionId', None, None, ), # 1
22015 
    (2, TType.STRING, 'refundedBy', None, None, ), # 2
22016 
    (3, TType.STRING, 'reason', None, None, ), # 3
22017 
  )
22018 
 
22019 
  def __init__(self, transactionId=None, refundedBy=None, reason=None,):
22020 
    self.transactionId = transactionId
22021 
    self.refundedBy = refundedBy
22022 
    self.reason = reason
22023 
 
22024 
  def read(self, iprot):
22025 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22026 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22027 
      return
22028 
    iprot.readStructBegin()
22029 
    while True:
22030 
      (fname, ftype, fid) = iprot.readFieldBegin()
22031 
      if ftype == TType.STOP:
22032 
        break
22033 
      if fid == 1:
22034 
        if ftype == TType.I64:
22035 
          self.transactionId = iprot.readI64();
22036 
        else:
22037 
          iprot.skip(ftype)
22038 
      elif fid == 2:
22039 
        if ftype == TType.STRING:
22040 
          self.refundedBy = iprot.readString();
22041 
        else:
22042 
          iprot.skip(ftype)
22043 
      elif fid == 3:
22044 
        if ftype == TType.STRING:
22045 
          self.reason = iprot.readString();
22046 
        else:
22047 
          iprot.skip(ftype)
22048 
      else:
22049 
        iprot.skip(ftype)
22050 
      iprot.readFieldEnd()
22051 
    iprot.readStructEnd()
22052 
 
22053 
  def write(self, oprot):
22054 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22055 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22056 
      return
22057 
    oprot.writeStructBegin('refundTransaction_args')
22058 
    if self.transactionId is not None:
22059 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
22060 
      oprot.writeI64(self.transactionId)
22061 
      oprot.writeFieldEnd()
22062 
    if self.refundedBy is not None:
22063 
      oprot.writeFieldBegin('refundedBy', TType.STRING, 2)
22064 
      oprot.writeString(self.refundedBy)
22065 
      oprot.writeFieldEnd()
22066 
    if self.reason is not None:
22067 
      oprot.writeFieldBegin('reason', TType.STRING, 3)
22068 
      oprot.writeString(self.reason)
22069 
      oprot.writeFieldEnd()
22070 
    oprot.writeFieldStop()
22071 
    oprot.writeStructEnd()
22072 
 
22073 
  def validate(self):
22074 
    return
22075 
 
22076 
 
22077 
  def __repr__(self):
22078 
    L = ['%s=%r' % (key, value)
22079 
      for key, value in self.__dict__.iteritems()]
22080 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22081 
 
22082 
  def __eq__(self, other):
22083 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22084 
 
22085 
  def __ne__(self, other):
22086 
    return not (self == other)
22087 
 
22088 
class refundTransaction_result:
22089 
  """
22090 
  Attributes:
22091 
   - ex
22092 
  """
22093 
 
22094 
  thrift_spec = (
22095 
    None, # 0
22096 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
22097 
  )
22098 
 
22099 
  def __init__(self, ex=None,):
22100 
    self.ex = ex
22101 
 
22102 
  def read(self, iprot):
22103 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22104 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22105 
      return
22106 
    iprot.readStructBegin()
22107 
    while True:
22108 
      (fname, ftype, fid) = iprot.readFieldBegin()
22109 
      if ftype == TType.STOP:
22110 
        break
22111 
      if fid == 1:
22112 
        if ftype == TType.STRUCT:
22113 
          self.ex = TransactionServiceException()
22114 
          self.ex.read(iprot)
22115 
        else:
22116 
          iprot.skip(ftype)
22117 
      else:
22118 
        iprot.skip(ftype)
22119 
      iprot.readFieldEnd()
22120 
    iprot.readStructEnd()
22121 
 
22122 
  def write(self, oprot):
22123 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22124 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22125 
      return
22126 
    oprot.writeStructBegin('refundTransaction_result')
22127 
    if self.ex is not None:
22128 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
22129 
      self.ex.write(oprot)
22130 
      oprot.writeFieldEnd()
22131 
    oprot.writeFieldStop()
22132 
    oprot.writeStructEnd()
22133 
 
22134 
  def validate(self):
22135 
    return
22136 
 
22137 
 
22138 
  def __repr__(self):
22139 
    L = ['%s=%r' % (key, value)
22140 
      for key, value in self.__dict__.iteritems()]
22141 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22142 
 
22143 
  def __eq__(self, other):
22144 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22145 
 
22146 
  def __ne__(self, other):
22147 
    return not (self == other)
4285 rajveer 22148 
 
4324 mandeep.dh 22149 
class updateShipmentAddress_args:
22150 
  """
22151 
  Attributes:
22152 
   - orderId
22153 
   - addressId
22154 
  """
22155 
 
22156 
  thrift_spec = (
22157 
    None, # 0
22158 
    (1, TType.I64, 'orderId', None, None, ), # 1
22159 
    (2, TType.I64, 'addressId', None, None, ), # 2
22160 
  )
22161 
 
22162 
  def __init__(self, orderId=None, addressId=None,):
22163 
    self.orderId = orderId
22164 
    self.addressId = addressId
22165 
 
22166 
  def read(self, iprot):
22167 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22168 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22169 
      return
22170 
    iprot.readStructBegin()
22171 
    while True:
22172 
      (fname, ftype, fid) = iprot.readFieldBegin()
22173 
      if ftype == TType.STOP:
22174 
        break
22175 
      if fid == 1:
22176 
        if ftype == TType.I64:
22177 
          self.orderId = iprot.readI64();
22178 
        else:
22179 
          iprot.skip(ftype)
22180 
      elif fid == 2:
22181 
        if ftype == TType.I64:
22182 
          self.addressId = iprot.readI64();
22183 
        else:
22184 
          iprot.skip(ftype)
22185 
      else:
22186 
        iprot.skip(ftype)
22187 
      iprot.readFieldEnd()
22188 
    iprot.readStructEnd()
22189 
 
22190 
  def write(self, oprot):
22191 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22192 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22193 
      return
22194 
    oprot.writeStructBegin('updateShipmentAddress_args')
22195 
    if self.orderId is not None:
22196 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
22197 
      oprot.writeI64(self.orderId)
22198 
      oprot.writeFieldEnd()
22199 
    if self.addressId is not None:
22200 
      oprot.writeFieldBegin('addressId', TType.I64, 2)
22201 
      oprot.writeI64(self.addressId)
22202 
      oprot.writeFieldEnd()
22203 
    oprot.writeFieldStop()
22204 
    oprot.writeStructEnd()
22205 
 
22206 
  def validate(self):
22207 
    return
22208 
 
22209 
 
22210 
  def __repr__(self):
22211 
    L = ['%s=%r' % (key, value)
22212 
      for key, value in self.__dict__.iteritems()]
22213 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22214 
 
22215 
  def __eq__(self, other):
22216 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22217 
 
22218 
  def __ne__(self, other):
22219 
    return not (self == other)
22220 
 
22221 
class updateShipmentAddress_result:
22222 
  """
22223 
  Attributes:
22224 
   - ex
22225 
  """
22226 
 
22227 
  thrift_spec = (
22228 
    None, # 0
22229 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
22230 
  )
22231 
 
22232 
  def __init__(self, ex=None,):
22233 
    self.ex = ex
22234 
 
22235 
  def read(self, iprot):
22236 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22237 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22238 
      return
22239 
    iprot.readStructBegin()
22240 
    while True:
22241 
      (fname, ftype, fid) = iprot.readFieldBegin()
22242 
      if ftype == TType.STOP:
22243 
        break
22244 
      if fid == 1:
22245 
        if ftype == TType.STRUCT:
22246 
          self.ex = TransactionServiceException()
22247 
          self.ex.read(iprot)
22248 
        else:
22249 
          iprot.skip(ftype)
22250 
      else:
22251 
        iprot.skip(ftype)
22252 
      iprot.readFieldEnd()
22253 
    iprot.readStructEnd()
22254 
 
22255 
  def write(self, oprot):
22256 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22257 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22258 
      return
22259 
    oprot.writeStructBegin('updateShipmentAddress_result')
22260 
    if self.ex is not None:
22261 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
22262 
      self.ex.write(oprot)
22263 
      oprot.writeFieldEnd()
22264 
    oprot.writeFieldStop()
22265 
    oprot.writeStructEnd()
22266 
 
22267 
  def validate(self):
22268 
    return
22269 
 
22270 
 
22271 
  def __repr__(self):
22272 
    L = ['%s=%r' % (key, value)
22273 
      for key, value in self.__dict__.iteritems()]
22274 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22275 
 
22276 
  def __eq__(self, other):
22277 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22278 
 
22279 
  def __ne__(self, other):
22280 
    return not (self == other)
22281 
 
4285 rajveer 22282 
class acceptOrdersForItemId_args:
22283 
  """
22284 
  Attributes:
22285 
   - itemId
22286 
   - inventory
22287 
  """
22288 
 
22289 
  thrift_spec = (
22290 
    None, # 0
22291 
    (1, TType.I64, 'itemId', None, None, ), # 1
22292 
    (2, TType.I64, 'inventory', None, None, ), # 2
22293 
  )
22294 
 
22295 
  def __init__(self, itemId=None, inventory=None,):
22296 
    self.itemId = itemId
22297 
    self.inventory = inventory
22298 
 
22299 
  def read(self, iprot):
22300 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22301 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22302 
      return
22303 
    iprot.readStructBegin()
22304 
    while True:
22305 
      (fname, ftype, fid) = iprot.readFieldBegin()
22306 
      if ftype == TType.STOP:
22307 
        break
22308 
      if fid == 1:
22309 
        if ftype == TType.I64:
22310 
          self.itemId = iprot.readI64();
22311 
        else:
22312 
          iprot.skip(ftype)
22313 
      elif fid == 2:
22314 
        if ftype == TType.I64:
22315 
          self.inventory = iprot.readI64();
22316 
        else:
22317 
          iprot.skip(ftype)
22318 
      else:
22319 
        iprot.skip(ftype)
22320 
      iprot.readFieldEnd()
22321 
    iprot.readStructEnd()
22322 
 
22323 
  def write(self, oprot):
22324 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22325 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22326 
      return
22327 
    oprot.writeStructBegin('acceptOrdersForItemId_args')
22328 
    if self.itemId is not None:
22329 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
22330 
      oprot.writeI64(self.itemId)
22331 
      oprot.writeFieldEnd()
22332 
    if self.inventory is not None:
22333 
      oprot.writeFieldBegin('inventory', TType.I64, 2)
22334 
      oprot.writeI64(self.inventory)
22335 
      oprot.writeFieldEnd()
22336 
    oprot.writeFieldStop()
22337 
    oprot.writeStructEnd()
22338 
 
22339 
  def validate(self):
22340 
    return
22341 
 
22342 
 
22343 
  def __repr__(self):
22344 
    L = ['%s=%r' % (key, value)
22345 
      for key, value in self.__dict__.iteritems()]
22346 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22347 
 
22348 
  def __eq__(self, other):
22349 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22350 
 
22351 
  def __ne__(self, other):
22352 
    return not (self == other)
22353 
 
22354 
class acceptOrdersForItemId_result:
22355 
  """
22356 
  Attributes:
22357 
   - success
22358 
   - ex
22359 
  """
22360 
 
22361 
  thrift_spec = (
22362 
    (0, TType.BOOL, 'success', None, None, ), # 0
22363 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
22364 
  )
22365 
 
22366 
  def __init__(self, success=None, ex=None,):
22367 
    self.success = success
22368 
    self.ex = ex
22369 
 
22370 
  def read(self, iprot):
22371 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22372 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22373 
      return
22374 
    iprot.readStructBegin()
22375 
    while True:
22376 
      (fname, ftype, fid) = iprot.readFieldBegin()
22377 
      if ftype == TType.STOP:
22378 
        break
22379 
      if fid == 0:
22380 
        if ftype == TType.BOOL:
22381 
          self.success = iprot.readBool();
22382 
        else:
22383 
          iprot.skip(ftype)
22384 
      elif fid == 1:
22385 
        if ftype == TType.STRUCT:
22386 
          self.ex = TransactionServiceException()
22387 
          self.ex.read(iprot)
22388 
        else:
22389 
          iprot.skip(ftype)
22390 
      else:
22391 
        iprot.skip(ftype)
22392 
      iprot.readFieldEnd()
22393 
    iprot.readStructEnd()
22394 
 
22395 
  def write(self, oprot):
22396 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22397 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22398 
      return
22399 
    oprot.writeStructBegin('acceptOrdersForItemId_result')
22400 
    if self.success is not None:
22401 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
22402 
      oprot.writeBool(self.success)
22403 
      oprot.writeFieldEnd()
22404 
    if self.ex is not None:
22405 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
22406 
      self.ex.write(oprot)
22407 
      oprot.writeFieldEnd()
22408 
    oprot.writeFieldStop()
22409 
    oprot.writeStructEnd()
22410 
 
22411 
  def validate(self):
22412 
    return
22413 
 
22414 
 
22415 
  def __repr__(self):
22416 
    L = ['%s=%r' % (key, value)
22417 
      for key, value in self.__dict__.iteritems()]
22418 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22419 
 
22420 
  def __eq__(self, other):
22421 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22422 
 
22423 
  def __ne__(self, other):
22424 
    return not (self == other)
4303 rajveer 22425 
 
22426 
class markOrdersAsPORaised_args:
22427 
  """
22428 
  Attributes:
22429 
   - vendorId
22430 
   - itemId
22431 
   - quantity
22432 
   - estimate
4369 rajveer 22433 
   - isReminder
4303 rajveer 22434 
  """
22435 
 
22436 
  thrift_spec = (
22437 
    None, # 0
22438 
    (1, TType.I64, 'vendorId', None, None, ), # 1
22439 
    (2, TType.I64, 'itemId', None, None, ), # 2
22440 
    (3, TType.I64, 'quantity', None, None, ), # 3
22441 
    (4, TType.I64, 'estimate', None, None, ), # 4
4369 rajveer 22442 
    (5, TType.BOOL, 'isReminder', None, None, ), # 5
4303 rajveer 22443 
  )
22444 
 
4369 rajveer 22445 
  def __init__(self, vendorId=None, itemId=None, quantity=None, estimate=None, isReminder=None,):
4303 rajveer 22446 
    self.vendorId = vendorId
22447 
    self.itemId = itemId
22448 
    self.quantity = quantity
22449 
    self.estimate = estimate
4369 rajveer 22450 
    self.isReminder = isReminder
4303 rajveer 22451 
 
22452 
  def read(self, iprot):
22453 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22454 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22455 
      return
22456 
    iprot.readStructBegin()
22457 
    while True:
22458 
      (fname, ftype, fid) = iprot.readFieldBegin()
22459 
      if ftype == TType.STOP:
22460 
        break
22461 
      if fid == 1:
22462 
        if ftype == TType.I64:
22463 
          self.vendorId = iprot.readI64();
22464 
        else:
22465 
          iprot.skip(ftype)
22466 
      elif fid == 2:
22467 
        if ftype == TType.I64:
22468 
          self.itemId = iprot.readI64();
22469 
        else:
22470 
          iprot.skip(ftype)
22471 
      elif fid == 3:
22472 
        if ftype == TType.I64:
22473 
          self.quantity = iprot.readI64();
22474 
        else:
22475 
          iprot.skip(ftype)
22476 
      elif fid == 4:
22477 
        if ftype == TType.I64:
22478 
          self.estimate = iprot.readI64();
22479 
        else:
22480 
          iprot.skip(ftype)
4369 rajveer 22481 
      elif fid == 5:
22482 
        if ftype == TType.BOOL:
22483 
          self.isReminder = iprot.readBool();
22484 
        else:
22485 
          iprot.skip(ftype)
4303 rajveer 22486 
      else:
22487 
        iprot.skip(ftype)
22488 
      iprot.readFieldEnd()
22489 
    iprot.readStructEnd()
22490 
 
22491 
  def write(self, oprot):
22492 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22493 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22494 
      return
22495 
    oprot.writeStructBegin('markOrdersAsPORaised_args')
22496 
    if self.vendorId is not None:
22497 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
22498 
      oprot.writeI64(self.vendorId)
22499 
      oprot.writeFieldEnd()
22500 
    if self.itemId is not None:
22501 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
22502 
      oprot.writeI64(self.itemId)
22503 
      oprot.writeFieldEnd()
22504 
    if self.quantity is not None:
22505 
      oprot.writeFieldBegin('quantity', TType.I64, 3)
22506 
      oprot.writeI64(self.quantity)
22507 
      oprot.writeFieldEnd()
22508 
    if self.estimate is not None:
22509 
      oprot.writeFieldBegin('estimate', TType.I64, 4)
22510 
      oprot.writeI64(self.estimate)
22511 
      oprot.writeFieldEnd()
4369 rajveer 22512 
    if self.isReminder is not None:
22513 
      oprot.writeFieldBegin('isReminder', TType.BOOL, 5)
22514 
      oprot.writeBool(self.isReminder)
22515 
      oprot.writeFieldEnd()
4303 rajveer 22516 
    oprot.writeFieldStop()
22517 
    oprot.writeStructEnd()
22518 
 
22519 
  def validate(self):
22520 
    return
22521 
 
22522 
 
22523 
  def __repr__(self):
22524 
    L = ['%s=%r' % (key, value)
22525 
      for key, value in self.__dict__.iteritems()]
22526 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22527 
 
22528 
  def __eq__(self, other):
22529 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22530 
 
22531 
  def __ne__(self, other):
22532 
    return not (self == other)
22533 
 
22534 
class markOrdersAsPORaised_result:
22535 
  """
22536 
  Attributes:
22537 
   - ex
22538 
  """
22539 
 
22540 
  thrift_spec = (
22541 
    None, # 0
22542 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
22543 
  )
22544 
 
22545 
  def __init__(self, ex=None,):
22546 
    self.ex = ex
22547 
 
22548 
  def read(self, iprot):
22549 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22550 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22551 
      return
22552 
    iprot.readStructBegin()
22553 
    while True:
22554 
      (fname, ftype, fid) = iprot.readFieldBegin()
22555 
      if ftype == TType.STOP:
22556 
        break
22557 
      if fid == 1:
22558 
        if ftype == TType.STRUCT:
22559 
          self.ex = TransactionServiceException()
22560 
          self.ex.read(iprot)
22561 
        else:
22562 
          iprot.skip(ftype)
22563 
      else:
22564 
        iprot.skip(ftype)
22565 
      iprot.readFieldEnd()
22566 
    iprot.readStructEnd()
22567 
 
22568 
  def write(self, oprot):
22569 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22570 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22571 
      return
22572 
    oprot.writeStructBegin('markOrdersAsPORaised_result')
22573 
    if self.ex is not None:
22574 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
22575 
      self.ex.write(oprot)
22576 
      oprot.writeFieldEnd()
22577 
    oprot.writeFieldStop()
22578 
    oprot.writeStructEnd()
22579 
 
22580 
  def validate(self):
22581 
    return
22582 
 
22583 
 
22584 
  def __repr__(self):
22585 
    L = ['%s=%r' % (key, value)
22586 
      for key, value in self.__dict__.iteritems()]
22587 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22588 
 
22589 
  def __eq__(self, other):
22590 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22591 
 
22592 
  def __ne__(self, other):
22593 
    return not (self == other)
22594 
 
22595 
class markOrdersAsReversalInitiated_args:
22596 
  """
22597 
  Attributes:
22598 
   - vendorId
22599 
   - itemId
22600 
   - quantity
22601 
   - estimate
4369 rajveer 22602 
   - isReminder
4303 rajveer 22603 
  """
22604 
 
22605 
  thrift_spec = (
22606 
    None, # 0
22607 
    (1, TType.I64, 'vendorId', None, None, ), # 1
22608 
    (2, TType.I64, 'itemId', None, None, ), # 2
22609 
    (3, TType.I64, 'quantity', None, None, ), # 3
22610 
    (4, TType.I64, 'estimate', None, None, ), # 4
4369 rajveer 22611 
    (5, TType.BOOL, 'isReminder', None, None, ), # 5
4303 rajveer 22612 
  )
22613 
 
4369 rajveer 22614 
  def __init__(self, vendorId=None, itemId=None, quantity=None, estimate=None, isReminder=None,):
4303 rajveer 22615 
    self.vendorId = vendorId
22616 
    self.itemId = itemId
22617 
    self.quantity = quantity
22618 
    self.estimate = estimate
4369 rajveer 22619 
    self.isReminder = isReminder
4303 rajveer 22620 
 
22621 
  def read(self, iprot):
22622 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22623 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22624 
      return
22625 
    iprot.readStructBegin()
22626 
    while True:
22627 
      (fname, ftype, fid) = iprot.readFieldBegin()
22628 
      if ftype == TType.STOP:
22629 
        break
22630 
      if fid == 1:
22631 
        if ftype == TType.I64:
22632 
          self.vendorId = iprot.readI64();
22633 
        else:
22634 
          iprot.skip(ftype)
22635 
      elif fid == 2:
22636 
        if ftype == TType.I64:
22637 
          self.itemId = iprot.readI64();
22638 
        else:
22639 
          iprot.skip(ftype)
22640 
      elif fid == 3:
22641 
        if ftype == TType.I64:
22642 
          self.quantity = iprot.readI64();
22643 
        else:
22644 
          iprot.skip(ftype)
22645 
      elif fid == 4:
22646 
        if ftype == TType.I64:
22647 
          self.estimate = iprot.readI64();
22648 
        else:
22649 
          iprot.skip(ftype)
4369 rajveer 22650 
      elif fid == 5:
22651 
        if ftype == TType.BOOL:
22652 
          self.isReminder = iprot.readBool();
22653 
        else:
22654 
          iprot.skip(ftype)
4303 rajveer 22655 
      else:
22656 
        iprot.skip(ftype)
22657 
      iprot.readFieldEnd()
22658 
    iprot.readStructEnd()
22659 
 
22660 
  def write(self, oprot):
22661 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22662 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22663 
      return
22664 
    oprot.writeStructBegin('markOrdersAsReversalInitiated_args')
22665 
    if self.vendorId is not None:
22666 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
22667 
      oprot.writeI64(self.vendorId)
22668 
      oprot.writeFieldEnd()
22669 
    if self.itemId is not None:
22670 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
22671 
      oprot.writeI64(self.itemId)
22672 
      oprot.writeFieldEnd()
22673 
    if self.quantity is not None:
22674 
      oprot.writeFieldBegin('quantity', TType.I64, 3)
22675 
      oprot.writeI64(self.quantity)
22676 
      oprot.writeFieldEnd()
22677 
    if self.estimate is not None:
22678 
      oprot.writeFieldBegin('estimate', TType.I64, 4)
22679 
      oprot.writeI64(self.estimate)
22680 
      oprot.writeFieldEnd()
4369 rajveer 22681 
    if self.isReminder is not None:
22682 
      oprot.writeFieldBegin('isReminder', TType.BOOL, 5)
22683 
      oprot.writeBool(self.isReminder)
22684 
      oprot.writeFieldEnd()
4303 rajveer 22685 
    oprot.writeFieldStop()
22686 
    oprot.writeStructEnd()
22687 
 
22688 
  def validate(self):
22689 
    return
22690 
 
22691 
 
22692 
  def __repr__(self):
22693 
    L = ['%s=%r' % (key, value)
22694 
      for key, value in self.__dict__.iteritems()]
22695 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22696 
 
22697 
  def __eq__(self, other):
22698 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22699 
 
22700 
  def __ne__(self, other):
22701 
    return not (self == other)
22702 
 
22703 
class markOrdersAsReversalInitiated_result:
22704 
  """
22705 
  Attributes:
22706 
   - ex
22707 
  """
22708 
 
22709 
  thrift_spec = (
22710 
    None, # 0
22711 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
22712 
  )
22713 
 
22714 
  def __init__(self, ex=None,):
22715 
    self.ex = ex
22716 
 
22717 
  def read(self, iprot):
22718 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22719 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22720 
      return
22721 
    iprot.readStructBegin()
22722 
    while True:
22723 
      (fname, ftype, fid) = iprot.readFieldBegin()
22724 
      if ftype == TType.STOP:
22725 
        break
22726 
      if fid == 1:
22727 
        if ftype == TType.STRUCT:
22728 
          self.ex = TransactionServiceException()
22729 
          self.ex.read(iprot)
22730 
        else:
22731 
          iprot.skip(ftype)
22732 
      else:
22733 
        iprot.skip(ftype)
22734 
      iprot.readFieldEnd()
22735 
    iprot.readStructEnd()
22736 
 
22737 
  def write(self, oprot):
22738 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22739 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22740 
      return
22741 
    oprot.writeStructBegin('markOrdersAsReversalInitiated_result')
22742 
    if self.ex is not None:
22743 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
22744 
      self.ex.write(oprot)
22745 
      oprot.writeFieldEnd()
22746 
    oprot.writeFieldStop()
22747 
    oprot.writeStructEnd()
22748 
 
22749 
  def validate(self):
22750 
    return
22751 
 
22752 
 
22753 
  def __repr__(self):
22754 
    L = ['%s=%r' % (key, value)
22755 
      for key, value in self.__dict__.iteritems()]
22756 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22757 
 
22758 
  def __eq__(self, other):
22759 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22760 
 
22761 
  def __ne__(self, other):
22762 
    return not (self == other)
22763 
 
22764 
class markOrdersAsNotAvailabke_args:
22765 
  """
22766 
  Attributes:
22767 
   - vendorId
22768 
   - itemId
22769 
   - quantity
22770 
   - estimate
4369 rajveer 22771 
   - isReminder
4303 rajveer 22772 
  """
22773 
 
22774 
  thrift_spec = (
22775 
    None, # 0
22776 
    (1, TType.I64, 'vendorId', None, None, ), # 1
22777 
    (2, TType.I64, 'itemId', None, None, ), # 2
22778 
    (3, TType.I64, 'quantity', None, None, ), # 3
22779 
    (4, TType.I64, 'estimate', None, None, ), # 4
4369 rajveer 22780 
    (5, TType.BOOL, 'isReminder', None, None, ), # 5
4303 rajveer 22781 
  )
22782 
 
4369 rajveer 22783 
  def __init__(self, vendorId=None, itemId=None, quantity=None, estimate=None, isReminder=None,):
4303 rajveer 22784 
    self.vendorId = vendorId
22785 
    self.itemId = itemId
22786 
    self.quantity = quantity
22787 
    self.estimate = estimate
4369 rajveer 22788 
    self.isReminder = isReminder
4303 rajveer 22789 
 
22790 
  def read(self, iprot):
22791 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22792 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22793 
      return
22794 
    iprot.readStructBegin()
22795 
    while True:
22796 
      (fname, ftype, fid) = iprot.readFieldBegin()
22797 
      if ftype == TType.STOP:
22798 
        break
22799 
      if fid == 1:
22800 
        if ftype == TType.I64:
22801 
          self.vendorId = iprot.readI64();
22802 
        else:
22803 
          iprot.skip(ftype)
22804 
      elif fid == 2:
22805 
        if ftype == TType.I64:
22806 
          self.itemId = iprot.readI64();
22807 
        else:
22808 
          iprot.skip(ftype)
22809 
      elif fid == 3:
22810 
        if ftype == TType.I64:
22811 
          self.quantity = iprot.readI64();
22812 
        else:
22813 
          iprot.skip(ftype)
22814 
      elif fid == 4:
22815 
        if ftype == TType.I64:
22816 
          self.estimate = iprot.readI64();
22817 
        else:
22818 
          iprot.skip(ftype)
4369 rajveer 22819 
      elif fid == 5:
22820 
        if ftype == TType.BOOL:
22821 
          self.isReminder = iprot.readBool();
22822 
        else:
22823 
          iprot.skip(ftype)
4303 rajveer 22824 
      else:
22825 
        iprot.skip(ftype)
22826 
      iprot.readFieldEnd()
22827 
    iprot.readStructEnd()
22828 
 
22829 
  def write(self, oprot):
22830 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22831 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22832 
      return
22833 
    oprot.writeStructBegin('markOrdersAsNotAvailabke_args')
22834 
    if self.vendorId is not None:
22835 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
22836 
      oprot.writeI64(self.vendorId)
22837 
      oprot.writeFieldEnd()
22838 
    if self.itemId is not None:
22839 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
22840 
      oprot.writeI64(self.itemId)
22841 
      oprot.writeFieldEnd()
22842 
    if self.quantity is not None:
22843 
      oprot.writeFieldBegin('quantity', TType.I64, 3)
22844 
      oprot.writeI64(self.quantity)
22845 
      oprot.writeFieldEnd()
22846 
    if self.estimate is not None:
22847 
      oprot.writeFieldBegin('estimate', TType.I64, 4)
22848 
      oprot.writeI64(self.estimate)
22849 
      oprot.writeFieldEnd()
4369 rajveer 22850 
    if self.isReminder is not None:
22851 
      oprot.writeFieldBegin('isReminder', TType.BOOL, 5)
22852 
      oprot.writeBool(self.isReminder)
22853 
      oprot.writeFieldEnd()
4303 rajveer 22854 
    oprot.writeFieldStop()
22855 
    oprot.writeStructEnd()
22856 
 
22857 
  def validate(self):
22858 
    return
22859 
 
22860 
 
22861 
  def __repr__(self):
22862 
    L = ['%s=%r' % (key, value)
22863 
      for key, value in self.__dict__.iteritems()]
22864 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22865 
 
22866 
  def __eq__(self, other):
22867 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22868 
 
22869 
  def __ne__(self, other):
22870 
    return not (self == other)
22871 
 
22872 
class markOrdersAsNotAvailabke_result:
22873 
  """
22874 
  Attributes:
22875 
   - ex
22876 
  """
22877 
 
22878 
  thrift_spec = (
22879 
    None, # 0
22880 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
22881 
  )
22882 
 
22883 
  def __init__(self, ex=None,):
22884 
    self.ex = ex
22885 
 
22886 
  def read(self, iprot):
22887 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22888 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22889 
      return
22890 
    iprot.readStructBegin()
22891 
    while True:
22892 
      (fname, ftype, fid) = iprot.readFieldBegin()
22893 
      if ftype == TType.STOP:
22894 
        break
22895 
      if fid == 1:
22896 
        if ftype == TType.STRUCT:
22897 
          self.ex = TransactionServiceException()
22898 
          self.ex.read(iprot)
22899 
        else:
22900 
          iprot.skip(ftype)
22901 
      else:
22902 
        iprot.skip(ftype)
22903 
      iprot.readFieldEnd()
22904 
    iprot.readStructEnd()
22905 
 
22906 
  def write(self, oprot):
22907 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22908 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22909 
      return
22910 
    oprot.writeStructBegin('markOrdersAsNotAvailabke_result')
22911 
    if self.ex is not None:
22912 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
22913 
      self.ex.write(oprot)
22914 
      oprot.writeFieldEnd()
22915 
    oprot.writeFieldStop()
22916 
    oprot.writeStructEnd()
22917 
 
22918 
  def validate(self):
22919 
    return
22920 
 
22921 
 
22922 
  def __repr__(self):
22923 
    L = ['%s=%r' % (key, value)
22924 
      for key, value in self.__dict__.iteritems()]
22925 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22926 
 
22927 
  def __eq__(self, other):
22928 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22929 
 
22930 
  def __ne__(self, other):
22931 
    return not (self == other)
4369 rajveer 22932 
 
22933 
class markOrdersAsTimeout_args:
22934 
  """
22935 
  Attributes:
22936 
   - vendorId
22937 
  """
22938 
 
22939 
  thrift_spec = (
22940 
    None, # 0
22941 
    (1, TType.I64, 'vendorId', None, None, ), # 1
22942 
  )
22943 
 
22944 
  def __init__(self, vendorId=None,):
22945 
    self.vendorId = vendorId
22946 
 
22947 
  def read(self, iprot):
22948 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22949 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22950 
      return
22951 
    iprot.readStructBegin()
22952 
    while True:
22953 
      (fname, ftype, fid) = iprot.readFieldBegin()
22954 
      if ftype == TType.STOP:
22955 
        break
22956 
      if fid == 1:
22957 
        if ftype == TType.I64:
22958 
          self.vendorId = iprot.readI64();
22959 
        else:
22960 
          iprot.skip(ftype)
22961 
      else:
22962 
        iprot.skip(ftype)
22963 
      iprot.readFieldEnd()
22964 
    iprot.readStructEnd()
22965 
 
22966 
  def write(self, oprot):
22967 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22968 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22969 
      return
22970 
    oprot.writeStructBegin('markOrdersAsTimeout_args')
22971 
    if self.vendorId is not None:
22972 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
22973 
      oprot.writeI64(self.vendorId)
22974 
      oprot.writeFieldEnd()
22975 
    oprot.writeFieldStop()
22976 
    oprot.writeStructEnd()
22977 
 
22978 
  def validate(self):
22979 
    return
22980 
 
22981 
 
22982 
  def __repr__(self):
22983 
    L = ['%s=%r' % (key, value)
22984 
      for key, value in self.__dict__.iteritems()]
22985 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22986 
 
22987 
  def __eq__(self, other):
22988 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22989 
 
22990 
  def __ne__(self, other):
22991 
    return not (self == other)
22992 
 
22993 
class markOrdersAsTimeout_result:
22994 
  """
22995 
  Attributes:
22996 
   - success
22997 
   - ex
22998 
  """
22999 
 
23000 
  thrift_spec = (
23001 
    (0, TType.MAP, 'success', (TType.I32,None,TType.STRUCT,(TimeoutSummary, TimeoutSummary.thrift_spec)), None, ), # 0
23002 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
23003 
  )
23004 
 
23005 
  def __init__(self, success=None, ex=None,):
23006 
    self.success = success
23007 
    self.ex = ex
23008 
 
23009 
  def read(self, iprot):
23010 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23011 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23012 
      return
23013 
    iprot.readStructBegin()
23014 
    while True:
23015 
      (fname, ftype, fid) = iprot.readFieldBegin()
23016 
      if ftype == TType.STOP:
23017 
        break
23018 
      if fid == 0:
23019 
        if ftype == TType.MAP:
23020 
          self.success = {}
6188 rajveer 23021 
          (_ktype502, _vtype503, _size501 ) = iprot.readMapBegin()
23022 
          for _i505 in xrange(_size501):
23023 
            _key506 = iprot.readI32();
23024 
            _val507 = TimeoutSummary()
23025 
            _val507.read(iprot)
23026 
            self.success[_key506] = _val507
4369 rajveer 23027 
          iprot.readMapEnd()
23028 
        else:
23029 
          iprot.skip(ftype)
23030 
      elif fid == 1:
23031 
        if ftype == TType.STRUCT:
23032 
          self.ex = TransactionServiceException()
23033 
          self.ex.read(iprot)
23034 
        else:
23035 
          iprot.skip(ftype)
23036 
      else:
23037 
        iprot.skip(ftype)
23038 
      iprot.readFieldEnd()
23039 
    iprot.readStructEnd()
23040 
 
23041 
  def write(self, oprot):
23042 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23043 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23044 
      return
23045 
    oprot.writeStructBegin('markOrdersAsTimeout_result')
23046 
    if self.success is not None:
23047 
      oprot.writeFieldBegin('success', TType.MAP, 0)
23048 
      oprot.writeMapBegin(TType.I32, TType.STRUCT, len(self.success))
6188 rajveer 23049 
      for kiter508,viter509 in self.success.items():
23050 
        oprot.writeI32(kiter508)
23051 
        viter509.write(oprot)
4369 rajveer 23052 
      oprot.writeMapEnd()
23053 
      oprot.writeFieldEnd()
23054 
    if self.ex is not None:
23055 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
23056 
      self.ex.write(oprot)
23057 
      oprot.writeFieldEnd()
23058 
    oprot.writeFieldStop()
23059 
    oprot.writeStructEnd()
23060 
 
23061 
  def validate(self):
23062 
    return
23063 
 
23064 
 
23065 
  def __repr__(self):
23066 
    L = ['%s=%r' % (key, value)
23067 
      for key, value in self.__dict__.iteritems()]
23068 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23069 
 
23070 
  def __eq__(self, other):
23071 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23072 
 
23073 
  def __ne__(self, other):
23074 
    return not (self == other)
4386 anupam.sin 23075 
 
4662 rajveer 23076 
class markOrderAsLostInTransit_args:
23077 
  """
23078 
  Attributes:
23079 
   - orderId
23080 
  """
23081 
 
23082 
  thrift_spec = (
23083 
    None, # 0
23084 
    (1, TType.I64, 'orderId', None, None, ), # 1
23085 
  )
23086 
 
23087 
  def __init__(self, orderId=None,):
23088 
    self.orderId = orderId
23089 
 
23090 
  def read(self, iprot):
23091 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23092 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23093 
      return
23094 
    iprot.readStructBegin()
23095 
    while True:
23096 
      (fname, ftype, fid) = iprot.readFieldBegin()
23097 
      if ftype == TType.STOP:
23098 
        break
23099 
      if fid == 1:
23100 
        if ftype == TType.I64:
23101 
          self.orderId = iprot.readI64();
23102 
        else:
23103 
          iprot.skip(ftype)
23104 
      else:
23105 
        iprot.skip(ftype)
23106 
      iprot.readFieldEnd()
23107 
    iprot.readStructEnd()
23108 
 
23109 
  def write(self, oprot):
23110 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23111 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23112 
      return
23113 
    oprot.writeStructBegin('markOrderAsLostInTransit_args')
23114 
    if self.orderId is not None:
23115 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
23116 
      oprot.writeI64(self.orderId)
23117 
      oprot.writeFieldEnd()
23118 
    oprot.writeFieldStop()
23119 
    oprot.writeStructEnd()
23120 
 
23121 
  def validate(self):
23122 
    return
23123 
 
23124 
 
23125 
  def __repr__(self):
23126 
    L = ['%s=%r' % (key, value)
23127 
      for key, value in self.__dict__.iteritems()]
23128 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23129 
 
23130 
  def __eq__(self, other):
23131 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23132 
 
23133 
  def __ne__(self, other):
23134 
    return not (self == other)
23135 
 
23136 
class markOrderAsLostInTransit_result:
23137 
  """
23138 
  Attributes:
23139 
   - success
23140 
   - ex
23141 
  """
23142 
 
23143 
  thrift_spec = (
23144 
    (0, TType.BOOL, 'success', None, None, ), # 0
23145 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
23146 
  )
23147 
 
23148 
  def __init__(self, success=None, ex=None,):
23149 
    self.success = success
23150 
    self.ex = ex
23151 
 
23152 
  def read(self, iprot):
23153 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23154 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23155 
      return
23156 
    iprot.readStructBegin()
23157 
    while True:
23158 
      (fname, ftype, fid) = iprot.readFieldBegin()
23159 
      if ftype == TType.STOP:
23160 
        break
23161 
      if fid == 0:
23162 
        if ftype == TType.BOOL:
23163 
          self.success = iprot.readBool();
23164 
        else:
23165 
          iprot.skip(ftype)
23166 
      elif fid == 1:
23167 
        if ftype == TType.STRUCT:
23168 
          self.ex = TransactionServiceException()
23169 
          self.ex.read(iprot)
23170 
        else:
23171 
          iprot.skip(ftype)
23172 
      else:
23173 
        iprot.skip(ftype)
23174 
      iprot.readFieldEnd()
23175 
    iprot.readStructEnd()
23176 
 
23177 
  def write(self, oprot):
23178 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23179 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23180 
      return
23181 
    oprot.writeStructBegin('markOrderAsLostInTransit_result')
23182 
    if self.success is not None:
23183 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
23184 
      oprot.writeBool(self.success)
23185 
      oprot.writeFieldEnd()
23186 
    if self.ex is not None:
23187 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
23188 
      self.ex.write(oprot)
23189 
      oprot.writeFieldEnd()
23190 
    oprot.writeFieldStop()
23191 
    oprot.writeStructEnd()
23192 
 
23193 
  def validate(self):
23194 
    return
23195 
 
23196 
 
23197 
  def __repr__(self):
23198 
    L = ['%s=%r' % (key, value)
23199 
      for key, value in self.__dict__.iteritems()]
23200 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23201 
 
23202 
  def __eq__(self, other):
23203 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23204 
 
23205 
  def __ne__(self, other):
23206 
    return not (self == other)
23207 
 
4386 anupam.sin 23208 
class getOrderForAwb_args:
23209 
  """
23210 
  Attributes:
23211 
   - awb
23212 
  """
23213 
 
23214 
  thrift_spec = (
23215 
    None, # 0
23216 
    (1, TType.STRING, 'awb', None, None, ), # 1
23217 
  )
23218 
 
23219 
  def __init__(self, awb=None,):
23220 
    self.awb = awb
23221 
 
23222 
  def read(self, iprot):
23223 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23224 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23225 
      return
23226 
    iprot.readStructBegin()
23227 
    while True:
23228 
      (fname, ftype, fid) = iprot.readFieldBegin()
23229 
      if ftype == TType.STOP:
23230 
        break
23231 
      if fid == 1:
23232 
        if ftype == TType.STRING:
23233 
          self.awb = iprot.readString();
23234 
        else:
23235 
          iprot.skip(ftype)
23236 
      else:
23237 
        iprot.skip(ftype)
23238 
      iprot.readFieldEnd()
23239 
    iprot.readStructEnd()
23240 
 
23241 
  def write(self, oprot):
23242 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23243 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23244 
      return
23245 
    oprot.writeStructBegin('getOrderForAwb_args')
23246 
    if self.awb is not None:
23247 
      oprot.writeFieldBegin('awb', TType.STRING, 1)
23248 
      oprot.writeString(self.awb)
23249 
      oprot.writeFieldEnd()
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 getOrderForAwb_result:
23269 
  """
23270 
  Attributes:
23271 
   - success
23272 
   - ex
23273 
  """
23274 
 
23275 
  thrift_spec = (
23276 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
23277 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
23278 
  )
23279 
 
23280 
  def __init__(self, success=None, ex=None,):
23281 
    self.success = success
23282 
    self.ex = ex
23283 
 
23284 
  def read(self, iprot):
23285 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23286 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23287 
      return
23288 
    iprot.readStructBegin()
23289 
    while True:
23290 
      (fname, ftype, fid) = iprot.readFieldBegin()
23291 
      if ftype == TType.STOP:
23292 
        break
23293 
      if fid == 0:
23294 
        if ftype == TType.STRUCT:
23295 
          self.success = Order()
23296 
          self.success.read(iprot)
23297 
        else:
23298 
          iprot.skip(ftype)
23299 
      elif fid == 1:
23300 
        if ftype == TType.STRUCT:
23301 
          self.ex = TransactionServiceException()
23302 
          self.ex.read(iprot)
23303 
        else:
23304 
          iprot.skip(ftype)
23305 
      else:
23306 
        iprot.skip(ftype)
23307 
      iprot.readFieldEnd()
23308 
    iprot.readStructEnd()
23309 
 
23310 
  def write(self, oprot):
23311 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23312 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23313 
      return
23314 
    oprot.writeStructBegin('getOrderForAwb_result')
23315 
    if self.success is not None:
23316 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
23317 
      self.success.write(oprot)
23318 
      oprot.writeFieldEnd()
23319 
    if self.ex is not None:
23320 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
23321 
      self.ex.write(oprot)
23322 
      oprot.writeFieldEnd()
23323 
    oprot.writeFieldStop()
23324 
    oprot.writeStructEnd()
23325 
 
23326 
  def validate(self):
23327 
    return
23328 
 
23329 
 
23330 
  def __repr__(self):
23331 
    L = ['%s=%r' % (key, value)
23332 
      for key, value in self.__dict__.iteritems()]
23333 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23334 
 
23335 
  def __eq__(self, other):
23336 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23337 
 
23338 
  def __ne__(self, other):
23339 
    return not (self == other)
4506 phani.kuma 23340 
 
23341 
class getOrdersForProviderForStatus_args:
23342 
  """
23343 
  Attributes:
23344 
   - logistics_provider_id
4910 phani.kuma 23345 
   - order_status_list
4506 phani.kuma 23346 
  """
23347 
 
23348 
  thrift_spec = (
23349 
    None, # 0
23350 
    (1, TType.I64, 'logistics_provider_id', None, None, ), # 1
4910 phani.kuma 23351 
    (2, TType.LIST, 'order_status_list', (TType.I32,None), None, ), # 2
4506 phani.kuma 23352 
  )
23353 
 
4910 phani.kuma 23354 
  def __init__(self, logistics_provider_id=None, order_status_list=None,):
4506 phani.kuma 23355 
    self.logistics_provider_id = logistics_provider_id
4910 phani.kuma 23356 
    self.order_status_list = order_status_list
4506 phani.kuma 23357 
 
23358 
  def read(self, iprot):
23359 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23360 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23361 
      return
23362 
    iprot.readStructBegin()
23363 
    while True:
23364 
      (fname, ftype, fid) = iprot.readFieldBegin()
23365 
      if ftype == TType.STOP:
23366 
        break
23367 
      if fid == 1:
23368 
        if ftype == TType.I64:
23369 
          self.logistics_provider_id = iprot.readI64();
23370 
        else:
23371 
          iprot.skip(ftype)
23372 
      elif fid == 2:
4910 phani.kuma 23373 
        if ftype == TType.LIST:
23374 
          self.order_status_list = []
6188 rajveer 23375 
          (_etype513, _size510) = iprot.readListBegin()
23376 
          for _i514 in xrange(_size510):
23377 
            _elem515 = iprot.readI32();
23378 
            self.order_status_list.append(_elem515)
4910 phani.kuma 23379 
          iprot.readListEnd()
4506 phani.kuma 23380 
        else:
23381 
          iprot.skip(ftype)
23382 
      else:
23383 
        iprot.skip(ftype)
23384 
      iprot.readFieldEnd()
23385 
    iprot.readStructEnd()
23386 
 
23387 
  def write(self, oprot):
23388 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23389 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23390 
      return
23391 
    oprot.writeStructBegin('getOrdersForProviderForStatus_args')
23392 
    if self.logistics_provider_id is not None:
23393 
      oprot.writeFieldBegin('logistics_provider_id', TType.I64, 1)
23394 
      oprot.writeI64(self.logistics_provider_id)
23395 
      oprot.writeFieldEnd()
4910 phani.kuma 23396 
    if self.order_status_list is not None:
23397 
      oprot.writeFieldBegin('order_status_list', TType.LIST, 2)
23398 
      oprot.writeListBegin(TType.I32, len(self.order_status_list))
6188 rajveer 23399 
      for iter516 in self.order_status_list:
23400 
        oprot.writeI32(iter516)
4910 phani.kuma 23401 
      oprot.writeListEnd()
4506 phani.kuma 23402 
      oprot.writeFieldEnd()
23403 
    oprot.writeFieldStop()
23404 
    oprot.writeStructEnd()
23405 
 
23406 
  def validate(self):
23407 
    return
23408 
 
23409 
 
23410 
  def __repr__(self):
23411 
    L = ['%s=%r' % (key, value)
23412 
      for key, value in self.__dict__.iteritems()]
23413 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23414 
 
23415 
  def __eq__(self, other):
23416 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23417 
 
23418 
  def __ne__(self, other):
23419 
    return not (self == other)
23420 
 
23421 
class getOrdersForProviderForStatus_result:
23422 
  """
23423 
  Attributes:
23424 
   - success
23425 
   - ex
23426 
  """
23427 
 
23428 
  thrift_spec = (
23429 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
23430 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
23431 
  )
23432 
 
23433 
  def __init__(self, success=None, ex=None,):
23434 
    self.success = success
23435 
    self.ex = ex
23436 
 
23437 
  def read(self, iprot):
23438 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23439 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23440 
      return
23441 
    iprot.readStructBegin()
23442 
    while True:
23443 
      (fname, ftype, fid) = iprot.readFieldBegin()
23444 
      if ftype == TType.STOP:
23445 
        break
23446 
      if fid == 0:
23447 
        if ftype == TType.LIST:
23448 
          self.success = []
6188 rajveer 23449 
          (_etype520, _size517) = iprot.readListBegin()
23450 
          for _i521 in xrange(_size517):
23451 
            _elem522 = Order()
23452 
            _elem522.read(iprot)
23453 
            self.success.append(_elem522)
4506 phani.kuma 23454 
          iprot.readListEnd()
23455 
        else:
23456 
          iprot.skip(ftype)
23457 
      elif fid == 1:
23458 
        if ftype == TType.STRUCT:
23459 
          self.ex = TransactionServiceException()
23460 
          self.ex.read(iprot)
23461 
        else:
23462 
          iprot.skip(ftype)
23463 
      else:
23464 
        iprot.skip(ftype)
23465 
      iprot.readFieldEnd()
23466 
    iprot.readStructEnd()
23467 
 
23468 
  def write(self, oprot):
23469 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23470 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23471 
      return
23472 
    oprot.writeStructBegin('getOrdersForProviderForStatus_result')
23473 
    if self.success is not None:
23474 
      oprot.writeFieldBegin('success', TType.LIST, 0)
23475 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 23476 
      for iter523 in self.success:
23477 
        iter523.write(oprot)
4506 phani.kuma 23478 
      oprot.writeListEnd()
23479 
      oprot.writeFieldEnd()
23480 
    if self.ex is not None:
23481 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
23482 
      self.ex.write(oprot)
23483 
      oprot.writeFieldEnd()
23484 
    oprot.writeFieldStop()
23485 
    oprot.writeStructEnd()
23486 
 
23487 
  def validate(self):
23488 
    return
23489 
 
23490 
 
23491 
  def __repr__(self):
23492 
    L = ['%s=%r' % (key, value)
23493 
      for key, value in self.__dict__.iteritems()]
23494 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23495 
 
23496 
  def __eq__(self, other):
23497 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23498 
 
23499 
  def __ne__(self, other):
23500 
    return not (self == other)
4600 varun.gupt 23501 
 
23502 
class getBilledOrdersForVendor_args:
23503 
  """
23504 
  Attributes:
23505 
   - vendorId
23506 
   - billingDateFrom
23507 
   - billingDateTo
23508 
  """
23509 
 
23510 
  thrift_spec = (
23511 
    None, # 0
23512 
    (1, TType.I64, 'vendorId', None, None, ), # 1
23513 
    (2, TType.I64, 'billingDateFrom', None, None, ), # 2
23514 
    (3, TType.I64, 'billingDateTo', None, None, ), # 3
23515 
  )
23516 
 
23517 
  def __init__(self, vendorId=None, billingDateFrom=None, billingDateTo=None,):
23518 
    self.vendorId = vendorId
23519 
    self.billingDateFrom = billingDateFrom
23520 
    self.billingDateTo = billingDateTo
23521 
 
23522 
  def read(self, iprot):
23523 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23524 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23525 
      return
23526 
    iprot.readStructBegin()
23527 
    while True:
23528 
      (fname, ftype, fid) = iprot.readFieldBegin()
23529 
      if ftype == TType.STOP:
23530 
        break
23531 
      if fid == 1:
23532 
        if ftype == TType.I64:
23533 
          self.vendorId = iprot.readI64();
23534 
        else:
23535 
          iprot.skip(ftype)
23536 
      elif fid == 2:
23537 
        if ftype == TType.I64:
23538 
          self.billingDateFrom = iprot.readI64();
23539 
        else:
23540 
          iprot.skip(ftype)
23541 
      elif fid == 3:
23542 
        if ftype == TType.I64:
23543 
          self.billingDateTo = iprot.readI64();
23544 
        else:
23545 
          iprot.skip(ftype)
23546 
      else:
23547 
        iprot.skip(ftype)
23548 
      iprot.readFieldEnd()
23549 
    iprot.readStructEnd()
23550 
 
23551 
  def write(self, oprot):
23552 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23553 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23554 
      return
23555 
    oprot.writeStructBegin('getBilledOrdersForVendor_args')
23556 
    if self.vendorId is not None:
23557 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
23558 
      oprot.writeI64(self.vendorId)
23559 
      oprot.writeFieldEnd()
23560 
    if self.billingDateFrom is not None:
23561 
      oprot.writeFieldBegin('billingDateFrom', TType.I64, 2)
23562 
      oprot.writeI64(self.billingDateFrom)
23563 
      oprot.writeFieldEnd()
23564 
    if self.billingDateTo is not None:
23565 
      oprot.writeFieldBegin('billingDateTo', TType.I64, 3)
23566 
      oprot.writeI64(self.billingDateTo)
23567 
      oprot.writeFieldEnd()
23568 
    oprot.writeFieldStop()
23569 
    oprot.writeStructEnd()
23570 
 
23571 
  def validate(self):
23572 
    return
23573 
 
23574 
 
23575 
  def __repr__(self):
23576 
    L = ['%s=%r' % (key, value)
23577 
      for key, value in self.__dict__.iteritems()]
23578 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23579 
 
23580 
  def __eq__(self, other):
23581 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23582 
 
23583 
  def __ne__(self, other):
23584 
    return not (self == other)
23585 
 
23586 
class getBilledOrdersForVendor_result:
23587 
  """
23588 
  Attributes:
23589 
   - success
23590 
   - ex
23591 
  """
23592 
 
23593 
  thrift_spec = (
23594 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
23595 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
23596 
  )
23597 
 
23598 
  def __init__(self, success=None, ex=None,):
23599 
    self.success = success
23600 
    self.ex = ex
23601 
 
23602 
  def read(self, iprot):
23603 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23604 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23605 
      return
23606 
    iprot.readStructBegin()
23607 
    while True:
23608 
      (fname, ftype, fid) = iprot.readFieldBegin()
23609 
      if ftype == TType.STOP:
23610 
        break
23611 
      if fid == 0:
23612 
        if ftype == TType.LIST:
23613 
          self.success = []
6188 rajveer 23614 
          (_etype527, _size524) = iprot.readListBegin()
23615 
          for _i528 in xrange(_size524):
23616 
            _elem529 = Order()
23617 
            _elem529.read(iprot)
23618 
            self.success.append(_elem529)
4600 varun.gupt 23619 
          iprot.readListEnd()
23620 
        else:
23621 
          iprot.skip(ftype)
23622 
      elif fid == 1:
23623 
        if ftype == TType.STRUCT:
23624 
          self.ex = TransactionServiceException()
23625 
          self.ex.read(iprot)
23626 
        else:
23627 
          iprot.skip(ftype)
23628 
      else:
23629 
        iprot.skip(ftype)
23630 
      iprot.readFieldEnd()
23631 
    iprot.readStructEnd()
23632 
 
23633 
  def write(self, oprot):
23634 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23635 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23636 
      return
23637 
    oprot.writeStructBegin('getBilledOrdersForVendor_result')
23638 
    if self.success is not None:
23639 
      oprot.writeFieldBegin('success', TType.LIST, 0)
23640 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 23641 
      for iter530 in self.success:
23642 
        iter530.write(oprot)
4600 varun.gupt 23643 
      oprot.writeListEnd()
23644 
      oprot.writeFieldEnd()
23645 
    if self.ex is not None:
23646 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
23647 
      self.ex.write(oprot)
23648 
      oprot.writeFieldEnd()
23649 
    oprot.writeFieldStop()
23650 
    oprot.writeStructEnd()
23651 
 
23652 
  def validate(self):
23653 
    return
23654 
 
23655 
 
23656 
  def __repr__(self):
23657 
    L = ['%s=%r' % (key, value)
23658 
      for key, value in self.__dict__.iteritems()]
23659 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23660 
 
23661 
  def __eq__(self, other):
23662 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23663 
 
23664 
  def __ne__(self, other):
23665 
    return not (self == other)
23666 
 
4607 rajveer 23667 
class getSlippedSippingDateOrders_args:
23668 
 
23669 
  thrift_spec = (
23670 
  )
23671 
 
23672 
  def read(self, iprot):
23673 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23674 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23675 
      return
23676 
    iprot.readStructBegin()
23677 
    while True:
23678 
      (fname, ftype, fid) = iprot.readFieldBegin()
23679 
      if ftype == TType.STOP:
23680 
        break
23681 
      else:
23682 
        iprot.skip(ftype)
23683 
      iprot.readFieldEnd()
23684 
    iprot.readStructEnd()
23685 
 
23686 
  def write(self, oprot):
23687 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23688 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23689 
      return
23690 
    oprot.writeStructBegin('getSlippedSippingDateOrders_args')
23691 
    oprot.writeFieldStop()
23692 
    oprot.writeStructEnd()
23693 
 
23694 
  def validate(self):
23695 
    return
23696 
 
23697 
 
23698 
  def __repr__(self):
23699 
    L = ['%s=%r' % (key, value)
23700 
      for key, value in self.__dict__.iteritems()]
23701 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23702 
 
23703 
  def __eq__(self, other):
23704 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23705 
 
23706 
  def __ne__(self, other):
23707 
    return not (self == other)
23708 
 
23709 
class getSlippedSippingDateOrders_result:
23710 
  """
23711 
  Attributes:
23712 
   - success
23713 
   - ex
23714 
  """
23715 
 
23716 
  thrift_spec = (
23717 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
23718 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
23719 
  )
23720 
 
23721 
  def __init__(self, success=None, ex=None,):
23722 
    self.success = success
23723 
    self.ex = ex
23724 
 
23725 
  def read(self, iprot):
23726 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23727 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23728 
      return
23729 
    iprot.readStructBegin()
23730 
    while True:
23731 
      (fname, ftype, fid) = iprot.readFieldBegin()
23732 
      if ftype == TType.STOP:
23733 
        break
23734 
      if fid == 0:
23735 
        if ftype == TType.LIST:
23736 
          self.success = []
6188 rajveer 23737 
          (_etype534, _size531) = iprot.readListBegin()
23738 
          for _i535 in xrange(_size531):
23739 
            _elem536 = Order()
23740 
            _elem536.read(iprot)
23741 
            self.success.append(_elem536)
4607 rajveer 23742 
          iprot.readListEnd()
23743 
        else:
23744 
          iprot.skip(ftype)
23745 
      elif fid == 1:
23746 
        if ftype == TType.STRUCT:
23747 
          self.ex = TransactionServiceException()
23748 
          self.ex.read(iprot)
23749 
        else:
23750 
          iprot.skip(ftype)
23751 
      else:
23752 
        iprot.skip(ftype)
23753 
      iprot.readFieldEnd()
23754 
    iprot.readStructEnd()
23755 
 
23756 
  def write(self, oprot):
23757 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23758 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23759 
      return
23760 
    oprot.writeStructBegin('getSlippedSippingDateOrders_result')
23761 
    if self.success is not None:
23762 
      oprot.writeFieldBegin('success', TType.LIST, 0)
23763 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 23764 
      for iter537 in self.success:
23765 
        iter537.write(oprot)
4607 rajveer 23766 
      oprot.writeListEnd()
23767 
      oprot.writeFieldEnd()
23768 
    if self.ex is not None:
23769 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
23770 
      self.ex.write(oprot)
23771 
      oprot.writeFieldEnd()
23772 
    oprot.writeFieldStop()
23773 
    oprot.writeStructEnd()
23774 
 
23775 
  def validate(self):
23776 
    return
23777 
 
23778 
 
23779 
  def __repr__(self):
23780 
    L = ['%s=%r' % (key, value)
23781 
      for key, value in self.__dict__.iteritems()]
23782 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23783 
 
23784 
  def __eq__(self, other):
23785 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23786 
 
23787 
  def __ne__(self, other):
23788 
    return not (self == other)
23789 
 
4709 rajveer 23790 
class getCancelledOrders_args:
23791 
  """
23792 
  Attributes:
23793 
   - cancelDateFrom
23794 
   - cancelDateTo
23795 
  """
23796 
 
23797 
  thrift_spec = (
23798 
    None, # 0
23799 
    (1, TType.I64, 'cancelDateFrom', None, None, ), # 1
23800 
    (2, TType.I64, 'cancelDateTo', None, None, ), # 2
23801 
  )
23802 
 
23803 
  def __init__(self, cancelDateFrom=None, cancelDateTo=None,):
23804 
    self.cancelDateFrom = cancelDateFrom
23805 
    self.cancelDateTo = cancelDateTo
23806 
 
23807 
  def read(self, iprot):
23808 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23809 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23810 
      return
23811 
    iprot.readStructBegin()
23812 
    while True:
23813 
      (fname, ftype, fid) = iprot.readFieldBegin()
23814 
      if ftype == TType.STOP:
23815 
        break
23816 
      if fid == 1:
23817 
        if ftype == TType.I64:
23818 
          self.cancelDateFrom = iprot.readI64();
23819 
        else:
23820 
          iprot.skip(ftype)
23821 
      elif fid == 2:
23822 
        if ftype == TType.I64:
23823 
          self.cancelDateTo = iprot.readI64();
23824 
        else:
23825 
          iprot.skip(ftype)
23826 
      else:
23827 
        iprot.skip(ftype)
23828 
      iprot.readFieldEnd()
23829 
    iprot.readStructEnd()
23830 
 
23831 
  def write(self, oprot):
23832 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23833 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23834 
      return
23835 
    oprot.writeStructBegin('getCancelledOrders_args')
23836 
    if self.cancelDateFrom is not None:
23837 
      oprot.writeFieldBegin('cancelDateFrom', TType.I64, 1)
23838 
      oprot.writeI64(self.cancelDateFrom)
23839 
      oprot.writeFieldEnd()
23840 
    if self.cancelDateTo is not None:
23841 
      oprot.writeFieldBegin('cancelDateTo', TType.I64, 2)
23842 
      oprot.writeI64(self.cancelDateTo)
23843 
      oprot.writeFieldEnd()
23844 
    oprot.writeFieldStop()
23845 
    oprot.writeStructEnd()
23846 
 
23847 
  def validate(self):
23848 
    return
23849 
 
23850 
 
23851 
  def __repr__(self):
23852 
    L = ['%s=%r' % (key, value)
23853 
      for key, value in self.__dict__.iteritems()]
23854 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23855 
 
23856 
  def __eq__(self, other):
23857 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23858 
 
23859 
  def __ne__(self, other):
23860 
    return not (self == other)
23861 
 
23862 
class getCancelledOrders_result:
23863 
  """
23864 
  Attributes:
23865 
   - success
23866 
   - ex
23867 
  """
23868 
 
23869 
  thrift_spec = (
23870 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
23871 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
23872 
  )
23873 
 
23874 
  def __init__(self, success=None, ex=None,):
23875 
    self.success = success
23876 
    self.ex = ex
23877 
 
23878 
  def read(self, iprot):
23879 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23880 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23881 
      return
23882 
    iprot.readStructBegin()
23883 
    while True:
23884 
      (fname, ftype, fid) = iprot.readFieldBegin()
23885 
      if ftype == TType.STOP:
23886 
        break
23887 
      if fid == 0:
23888 
        if ftype == TType.LIST:
23889 
          self.success = []
6188 rajveer 23890 
          (_etype541, _size538) = iprot.readListBegin()
23891 
          for _i542 in xrange(_size538):
23892 
            _elem543 = Order()
23893 
            _elem543.read(iprot)
23894 
            self.success.append(_elem543)
4709 rajveer 23895 
          iprot.readListEnd()
23896 
        else:
23897 
          iprot.skip(ftype)
23898 
      elif fid == 1:
23899 
        if ftype == TType.STRUCT:
23900 
          self.ex = TransactionServiceException()
23901 
          self.ex.read(iprot)
23902 
        else:
23903 
          iprot.skip(ftype)
23904 
      else:
23905 
        iprot.skip(ftype)
23906 
      iprot.readFieldEnd()
23907 
    iprot.readStructEnd()
23908 
 
23909 
  def write(self, oprot):
23910 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23911 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23912 
      return
23913 
    oprot.writeStructBegin('getCancelledOrders_result')
23914 
    if self.success is not None:
23915 
      oprot.writeFieldBegin('success', TType.LIST, 0)
23916 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 23917 
      for iter544 in self.success:
23918 
        iter544.write(oprot)
4709 rajveer 23919 
      oprot.writeListEnd()
23920 
      oprot.writeFieldEnd()
23921 
    if self.ex is not None:
23922 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
23923 
      self.ex.write(oprot)
23924 
      oprot.writeFieldEnd()
23925 
    oprot.writeFieldStop()
23926 
    oprot.writeStructEnd()
23927 
 
23928 
  def validate(self):
23929 
    return
23930 
 
23931 
 
23932 
  def __repr__(self):
23933 
    L = ['%s=%r' % (key, value)
23934 
      for key, value in self.__dict__.iteritems()]
23935 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23936 
 
23937 
  def __eq__(self, other):
23938 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23939 
 
23940 
  def __ne__(self, other):
23941 
    return not (self == other)
23942 
 
4600 varun.gupt 23943 
class saveBluedartSettlements_args:
23944 
  """
23945 
  Attributes:
23946 
   - mapAWBAndAmount
23947 
  """
23948 
 
23949 
  thrift_spec = (
23950 
    None, # 0
23951 
    (1, TType.MAP, 'mapAWBAndAmount', (TType.I64,None,TType.DOUBLE,None), None, ), # 1
23952 
  )
23953 
 
23954 
  def __init__(self, mapAWBAndAmount=None,):
23955 
    self.mapAWBAndAmount = mapAWBAndAmount
23956 
 
23957 
  def read(self, iprot):
23958 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23959 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23960 
      return
23961 
    iprot.readStructBegin()
23962 
    while True:
23963 
      (fname, ftype, fid) = iprot.readFieldBegin()
23964 
      if ftype == TType.STOP:
23965 
        break
23966 
      if fid == 1:
23967 
        if ftype == TType.MAP:
23968 
          self.mapAWBAndAmount = {}
6188 rajveer 23969 
          (_ktype546, _vtype547, _size545 ) = iprot.readMapBegin()
23970 
          for _i549 in xrange(_size545):
23971 
            _key550 = iprot.readI64();
23972 
            _val551 = iprot.readDouble();
23973 
            self.mapAWBAndAmount[_key550] = _val551
4600 varun.gupt 23974 
          iprot.readMapEnd()
23975 
        else:
23976 
          iprot.skip(ftype)
23977 
      else:
23978 
        iprot.skip(ftype)
23979 
      iprot.readFieldEnd()
23980 
    iprot.readStructEnd()
23981 
 
23982 
  def write(self, oprot):
23983 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23984 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23985 
      return
23986 
    oprot.writeStructBegin('saveBluedartSettlements_args')
23987 
    if self.mapAWBAndAmount is not None:
23988 
      oprot.writeFieldBegin('mapAWBAndAmount', TType.MAP, 1)
23989 
      oprot.writeMapBegin(TType.I64, TType.DOUBLE, len(self.mapAWBAndAmount))
6188 rajveer 23990 
      for kiter552,viter553 in self.mapAWBAndAmount.items():
23991 
        oprot.writeI64(kiter552)
23992 
        oprot.writeDouble(viter553)
4600 varun.gupt 23993 
      oprot.writeMapEnd()
23994 
      oprot.writeFieldEnd()
23995 
    oprot.writeFieldStop()
23996 
    oprot.writeStructEnd()
23997 
 
23998 
  def validate(self):
23999 
    return
24000 
 
24001 
 
24002 
  def __repr__(self):
24003 
    L = ['%s=%r' % (key, value)
24004 
      for key, value in self.__dict__.iteritems()]
24005 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24006 
 
24007 
  def __eq__(self, other):
24008 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24009 
 
24010 
  def __ne__(self, other):
24011 
    return not (self == other)
24012 
 
24013 
class saveBluedartSettlements_result:
24014 
  """
24015 
  Attributes:
24016 
   - ex
24017 
  """
24018 
 
24019 
  thrift_spec = (
24020 
    None, # 0
24021 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
24022 
  )
24023 
 
24024 
  def __init__(self, ex=None,):
24025 
    self.ex = ex
24026 
 
24027 
  def read(self, iprot):
24028 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24029 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24030 
      return
24031 
    iprot.readStructBegin()
24032 
    while True:
24033 
      (fname, ftype, fid) = iprot.readFieldBegin()
24034 
      if ftype == TType.STOP:
24035 
        break
24036 
      if fid == 1:
24037 
        if ftype == TType.STRUCT:
24038 
          self.ex = TransactionServiceException()
24039 
          self.ex.read(iprot)
24040 
        else:
24041 
          iprot.skip(ftype)
24042 
      else:
24043 
        iprot.skip(ftype)
24044 
      iprot.readFieldEnd()
24045 
    iprot.readStructEnd()
24046 
 
24047 
  def write(self, oprot):
24048 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24049 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24050 
      return
24051 
    oprot.writeStructBegin('saveBluedartSettlements_result')
24052 
    if self.ex is not None:
24053 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
24054 
      self.ex.write(oprot)
24055 
      oprot.writeFieldEnd()
24056 
    oprot.writeFieldStop()
24057 
    oprot.writeStructEnd()
24058 
 
24059 
  def validate(self):
24060 
    return
24061 
 
24062 
 
24063 
  def __repr__(self):
24064 
    L = ['%s=%r' % (key, value)
24065 
      for key, value in self.__dict__.iteritems()]
24066 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24067 
 
24068 
  def __eq__(self, other):
24069 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24070 
 
24071 
  def __ne__(self, other):
24072 
    return not (self == other)
24073 
 
24074 
class savePaymentSettlements_args:
24075 
  """
24076 
  Attributes:
24077 
   - settlementDate
24078 
   - paymentGatewayId
4905 varun.gupt 24079 
   - referenceId
4600 varun.gupt 24080 
   - serviceTax
24081 
   - otherCharges
24082 
   - netCollection
24083 
  """
24084 
 
24085 
  thrift_spec = (
24086 
    None, # 0
24087 
    (1, TType.I64, 'settlementDate', None, None, ), # 1
24088 
    (2, TType.I64, 'paymentGatewayId', None, None, ), # 2
4905 varun.gupt 24089 
    (3, TType.I64, 'referenceId', None, None, ), # 3
4600 varun.gupt 24090 
    (4, TType.DOUBLE, 'serviceTax', None, None, ), # 4
24091 
    (5, TType.DOUBLE, 'otherCharges', None, None, ), # 5
24092 
    (6, TType.DOUBLE, 'netCollection', None, None, ), # 6
24093 
  )
24094 
 
4905 varun.gupt 24095 
  def __init__(self, settlementDate=None, paymentGatewayId=None, referenceId=None, serviceTax=None, otherCharges=None, netCollection=None,):
4600 varun.gupt 24096 
    self.settlementDate = settlementDate
24097 
    self.paymentGatewayId = paymentGatewayId
4905 varun.gupt 24098 
    self.referenceId = referenceId
4600 varun.gupt 24099 
    self.serviceTax = serviceTax
24100 
    self.otherCharges = otherCharges
24101 
    self.netCollection = netCollection
24102 
 
24103 
  def read(self, iprot):
24104 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24105 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24106 
      return
24107 
    iprot.readStructBegin()
24108 
    while True:
24109 
      (fname, ftype, fid) = iprot.readFieldBegin()
24110 
      if ftype == TType.STOP:
24111 
        break
24112 
      if fid == 1:
24113 
        if ftype == TType.I64:
24114 
          self.settlementDate = iprot.readI64();
24115 
        else:
24116 
          iprot.skip(ftype)
24117 
      elif fid == 2:
24118 
        if ftype == TType.I64:
24119 
          self.paymentGatewayId = iprot.readI64();
24120 
        else:
24121 
          iprot.skip(ftype)
24122 
      elif fid == 3:
24123 
        if ftype == TType.I64:
4905 varun.gupt 24124 
          self.referenceId = iprot.readI64();
4600 varun.gupt 24125 
        else:
24126 
          iprot.skip(ftype)
24127 
      elif fid == 4:
24128 
        if ftype == TType.DOUBLE:
24129 
          self.serviceTax = iprot.readDouble();
24130 
        else:
24131 
          iprot.skip(ftype)
24132 
      elif fid == 5:
24133 
        if ftype == TType.DOUBLE:
24134 
          self.otherCharges = iprot.readDouble();
24135 
        else:
24136 
          iprot.skip(ftype)
24137 
      elif fid == 6:
24138 
        if ftype == TType.DOUBLE:
24139 
          self.netCollection = iprot.readDouble();
24140 
        else:
24141 
          iprot.skip(ftype)
24142 
      else:
24143 
        iprot.skip(ftype)
24144 
      iprot.readFieldEnd()
24145 
    iprot.readStructEnd()
24146 
 
24147 
  def write(self, oprot):
24148 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24149 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24150 
      return
24151 
    oprot.writeStructBegin('savePaymentSettlements_args')
24152 
    if self.settlementDate is not None:
24153 
      oprot.writeFieldBegin('settlementDate', TType.I64, 1)
24154 
      oprot.writeI64(self.settlementDate)
24155 
      oprot.writeFieldEnd()
24156 
    if self.paymentGatewayId is not None:
24157 
      oprot.writeFieldBegin('paymentGatewayId', TType.I64, 2)
24158 
      oprot.writeI64(self.paymentGatewayId)
24159 
      oprot.writeFieldEnd()
4905 varun.gupt 24160 
    if self.referenceId is not None:
24161 
      oprot.writeFieldBegin('referenceId', TType.I64, 3)
24162 
      oprot.writeI64(self.referenceId)
4600 varun.gupt 24163 
      oprot.writeFieldEnd()
24164 
    if self.serviceTax is not None:
24165 
      oprot.writeFieldBegin('serviceTax', TType.DOUBLE, 4)
24166 
      oprot.writeDouble(self.serviceTax)
24167 
      oprot.writeFieldEnd()
24168 
    if self.otherCharges is not None:
24169 
      oprot.writeFieldBegin('otherCharges', TType.DOUBLE, 5)
24170 
      oprot.writeDouble(self.otherCharges)
24171 
      oprot.writeFieldEnd()
24172 
    if self.netCollection is not None:
24173 
      oprot.writeFieldBegin('netCollection', TType.DOUBLE, 6)
24174 
      oprot.writeDouble(self.netCollection)
24175 
      oprot.writeFieldEnd()
24176 
    oprot.writeFieldStop()
24177 
    oprot.writeStructEnd()
24178 
 
24179 
  def validate(self):
24180 
    return
24181 
 
24182 
 
24183 
  def __repr__(self):
24184 
    L = ['%s=%r' % (key, value)
24185 
      for key, value in self.__dict__.iteritems()]
24186 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24187 
 
24188 
  def __eq__(self, other):
24189 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24190 
 
24191 
  def __ne__(self, other):
24192 
    return not (self == other)
24193 
 
24194 
class savePaymentSettlements_result:
24195 
  """
24196 
  Attributes:
24197 
   - ex
24198 
  """
24199 
 
24200 
  thrift_spec = (
24201 
    None, # 0
24202 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
24203 
  )
24204 
 
24205 
  def __init__(self, ex=None,):
24206 
    self.ex = ex
24207 
 
24208 
  def read(self, iprot):
24209 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24210 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24211 
      return
24212 
    iprot.readStructBegin()
24213 
    while True:
24214 
      (fname, ftype, fid) = iprot.readFieldBegin()
24215 
      if ftype == TType.STOP:
24216 
        break
24217 
      if fid == 1:
24218 
        if ftype == TType.STRUCT:
24219 
          self.ex = TransactionServiceException()
24220 
          self.ex.read(iprot)
24221 
        else:
24222 
          iprot.skip(ftype)
24223 
      else:
24224 
        iprot.skip(ftype)
24225 
      iprot.readFieldEnd()
24226 
    iprot.readStructEnd()
24227 
 
24228 
  def write(self, oprot):
24229 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24230 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24231 
      return
24232 
    oprot.writeStructBegin('savePaymentSettlements_result')
24233 
    if self.ex is not None:
24234 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
24235 
      self.ex.write(oprot)
24236 
      oprot.writeFieldEnd()
24237 
    oprot.writeFieldStop()
24238 
    oprot.writeStructEnd()
24239 
 
24240 
  def validate(self):
24241 
    return
24242 
 
24243 
 
24244 
  def __repr__(self):
24245 
    L = ['%s=%r' % (key, value)
24246 
      for key, value in self.__dict__.iteritems()]
24247 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24248 
 
24249 
  def __eq__(self, other):
24250 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24251 
 
24252 
  def __ne__(self, other):
24253 
    return not (self == other)
24254 
 
24255 
class saveEBSSettlementSummary_args:
24256 
  """
24257 
  Attributes:
24258 
   - settlementId
24259 
   - settlementDate
24260 
   - transactionDateFrom
24261 
   - transactionDateTo
24262 
   - amount
24263 
  """
24264 
 
24265 
  thrift_spec = (
24266 
    None, # 0
24267 
    (1, TType.I64, 'settlementId', None, None, ), # 1
24268 
    (2, TType.I64, 'settlementDate', None, None, ), # 2
24269 
    (3, TType.I64, 'transactionDateFrom', None, None, ), # 3
24270 
    (4, TType.I64, 'transactionDateTo', None, None, ), # 4
24271 
    (5, TType.DOUBLE, 'amount', None, None, ), # 5
24272 
  )
24273 
 
24274 
  def __init__(self, settlementId=None, settlementDate=None, transactionDateFrom=None, transactionDateTo=None, amount=None,):
24275 
    self.settlementId = settlementId
24276 
    self.settlementDate = settlementDate
24277 
    self.transactionDateFrom = transactionDateFrom
24278 
    self.transactionDateTo = transactionDateTo
24279 
    self.amount = amount
24280 
 
24281 
  def read(self, iprot):
24282 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24283 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24284 
      return
24285 
    iprot.readStructBegin()
24286 
    while True:
24287 
      (fname, ftype, fid) = iprot.readFieldBegin()
24288 
      if ftype == TType.STOP:
24289 
        break
24290 
      if fid == 1:
24291 
        if ftype == TType.I64:
24292 
          self.settlementId = iprot.readI64();
24293 
        else:
24294 
          iprot.skip(ftype)
24295 
      elif fid == 2:
24296 
        if ftype == TType.I64:
24297 
          self.settlementDate = iprot.readI64();
24298 
        else:
24299 
          iprot.skip(ftype)
24300 
      elif fid == 3:
24301 
        if ftype == TType.I64:
24302 
          self.transactionDateFrom = iprot.readI64();
24303 
        else:
24304 
          iprot.skip(ftype)
24305 
      elif fid == 4:
24306 
        if ftype == TType.I64:
24307 
          self.transactionDateTo = iprot.readI64();
24308 
        else:
24309 
          iprot.skip(ftype)
24310 
      elif fid == 5:
24311 
        if ftype == TType.DOUBLE:
24312 
          self.amount = iprot.readDouble();
24313 
        else:
24314 
          iprot.skip(ftype)
24315 
      else:
24316 
        iprot.skip(ftype)
24317 
      iprot.readFieldEnd()
24318 
    iprot.readStructEnd()
24319 
 
24320 
  def write(self, oprot):
24321 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24322 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24323 
      return
24324 
    oprot.writeStructBegin('saveEBSSettlementSummary_args')
24325 
    if self.settlementId is not None:
24326 
      oprot.writeFieldBegin('settlementId', TType.I64, 1)
24327 
      oprot.writeI64(self.settlementId)
24328 
      oprot.writeFieldEnd()
24329 
    if self.settlementDate is not None:
24330 
      oprot.writeFieldBegin('settlementDate', TType.I64, 2)
24331 
      oprot.writeI64(self.settlementDate)
24332 
      oprot.writeFieldEnd()
24333 
    if self.transactionDateFrom is not None:
24334 
      oprot.writeFieldBegin('transactionDateFrom', TType.I64, 3)
24335 
      oprot.writeI64(self.transactionDateFrom)
24336 
      oprot.writeFieldEnd()
24337 
    if self.transactionDateTo is not None:
24338 
      oprot.writeFieldBegin('transactionDateTo', TType.I64, 4)
24339 
      oprot.writeI64(self.transactionDateTo)
24340 
      oprot.writeFieldEnd()
24341 
    if self.amount is not None:
24342 
      oprot.writeFieldBegin('amount', TType.DOUBLE, 5)
24343 
      oprot.writeDouble(self.amount)
24344 
      oprot.writeFieldEnd()
24345 
    oprot.writeFieldStop()
24346 
    oprot.writeStructEnd()
24347 
 
24348 
  def validate(self):
24349 
    return
24350 
 
24351 
 
24352 
  def __repr__(self):
24353 
    L = ['%s=%r' % (key, value)
24354 
      for key, value in self.__dict__.iteritems()]
24355 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24356 
 
24357 
  def __eq__(self, other):
24358 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24359 
 
24360 
  def __ne__(self, other):
24361 
    return not (self == other)
24362 
 
24363 
class saveEBSSettlementSummary_result:
24364 
  """
24365 
  Attributes:
24366 
   - ex
24367 
  """
24368 
 
24369 
  thrift_spec = (
24370 
    None, # 0
24371 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
24372 
  )
24373 
 
24374 
  def __init__(self, ex=None,):
24375 
    self.ex = ex
24376 
 
24377 
  def read(self, iprot):
24378 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24379 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24380 
      return
24381 
    iprot.readStructBegin()
24382 
    while True:
24383 
      (fname, ftype, fid) = iprot.readFieldBegin()
24384 
      if ftype == TType.STOP:
24385 
        break
24386 
      if fid == 1:
24387 
        if ftype == TType.STRUCT:
24388 
          self.ex = TransactionServiceException()
24389 
          self.ex.read(iprot)
24390 
        else:
24391 
          iprot.skip(ftype)
24392 
      else:
24393 
        iprot.skip(ftype)
24394 
      iprot.readFieldEnd()
24395 
    iprot.readStructEnd()
24396 
 
24397 
  def write(self, oprot):
24398 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24399 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24400 
      return
24401 
    oprot.writeStructBegin('saveEBSSettlementSummary_result')
24402 
    if self.ex is not None:
24403 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
24404 
      self.ex.write(oprot)
24405 
      oprot.writeFieldEnd()
24406 
    oprot.writeFieldStop()
24407 
    oprot.writeStructEnd()
24408 
 
24409 
  def validate(self):
24410 
    return
24411 
 
24412 
 
24413 
  def __repr__(self):
24414 
    L = ['%s=%r' % (key, value)
24415 
      for key, value in self.__dict__.iteritems()]
24416 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24417 
 
24418 
  def __eq__(self, other):
24419 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24420 
 
24421 
  def __ne__(self, other):
24422 
    return not (self == other)
24423 
 
5386 phani.kuma 24424 
class getSettlementForPrepaid_args:
4600 varun.gupt 24425 
  """
24426 
  Attributes:
5189 varun.gupt 24427 
   - referenceId
24428 
   - isRefund
4600 varun.gupt 24429 
  """
24430 
 
24431 
  thrift_spec = (
24432 
    None, # 0
5189 varun.gupt 24433 
    (1, TType.I64, 'referenceId', None, None, ), # 1
5386 phani.kuma 24434 
    (2, TType.BOOL, 'isRefund', None, None, ), # 2
4600 varun.gupt 24435 
  )
24436 
 
5386 phani.kuma 24437 
  def __init__(self, referenceId=None, isRefund=None,):
5189 varun.gupt 24438 
    self.referenceId = referenceId
24439 
    self.isRefund = isRefund
4600 varun.gupt 24440 
 
24441 
  def read(self, iprot):
24442 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24443 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24444 
      return
24445 
    iprot.readStructBegin()
24446 
    while True:
24447 
      (fname, ftype, fid) = iprot.readFieldBegin()
24448 
      if ftype == TType.STOP:
24449 
        break
24450 
      if fid == 1:
24451 
        if ftype == TType.I64:
5189 varun.gupt 24452 
          self.referenceId = iprot.readI64();
4600 varun.gupt 24453 
        else:
24454 
          iprot.skip(ftype)
5189 varun.gupt 24455 
      elif fid == 2:
24456 
        if ftype == TType.BOOL:
24457 
          self.isRefund = iprot.readBool();
24458 
        else:
24459 
          iprot.skip(ftype)
4600 varun.gupt 24460 
      else:
24461 
        iprot.skip(ftype)
24462 
      iprot.readFieldEnd()
24463 
    iprot.readStructEnd()
24464 
 
24465 
  def write(self, oprot):
24466 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24467 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24468 
      return
5386 phani.kuma 24469 
    oprot.writeStructBegin('getSettlementForPrepaid_args')
5189 varun.gupt 24470 
    if self.referenceId is not None:
24471 
      oprot.writeFieldBegin('referenceId', TType.I64, 1)
24472 
      oprot.writeI64(self.referenceId)
4600 varun.gupt 24473 
      oprot.writeFieldEnd()
5386 phani.kuma 24474 
    if self.isRefund is not None:
24475 
      oprot.writeFieldBegin('isRefund', TType.BOOL, 2)
24476 
      oprot.writeBool(self.isRefund)
5382 varun.gupt 24477 
      oprot.writeFieldEnd()
5386 phani.kuma 24478 
    oprot.writeFieldStop()
24479 
    oprot.writeStructEnd()
24480 
 
24481 
  def validate(self):
24482 
    return
24483 
 
24484 
 
24485 
  def __repr__(self):
24486 
    L = ['%s=%r' % (key, value)
24487 
      for key, value in self.__dict__.iteritems()]
24488 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24489 
 
24490 
  def __eq__(self, other):
24491 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24492 
 
24493 
  def __ne__(self, other):
24494 
    return not (self == other)
24495 
 
24496 
class getSettlementForPrepaid_result:
24497 
  """
24498 
  Attributes:
24499 
   - success
24500 
   - ex
24501 
  """
24502 
 
24503 
  thrift_spec = (
24504 
    (0, TType.STRUCT, 'success', (PaymentSettlement, PaymentSettlement.thrift_spec), None, ), # 0
24505 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
24506 
  )
24507 
 
24508 
  def __init__(self, success=None, ex=None,):
24509 
    self.success = success
24510 
    self.ex = ex
24511 
 
24512 
  def read(self, iprot):
24513 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24514 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24515 
      return
24516 
    iprot.readStructBegin()
24517 
    while True:
24518 
      (fname, ftype, fid) = iprot.readFieldBegin()
24519 
      if ftype == TType.STOP:
24520 
        break
24521 
      if fid == 0:
24522 
        if ftype == TType.STRUCT:
24523 
          self.success = PaymentSettlement()
24524 
          self.success.read(iprot)
24525 
        else:
24526 
          iprot.skip(ftype)
24527 
      elif fid == 1:
24528 
        if ftype == TType.STRUCT:
24529 
          self.ex = TransactionServiceException()
24530 
          self.ex.read(iprot)
24531 
        else:
24532 
          iprot.skip(ftype)
24533 
      else:
24534 
        iprot.skip(ftype)
24535 
      iprot.readFieldEnd()
24536 
    iprot.readStructEnd()
24537 
 
24538 
  def write(self, oprot):
24539 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24540 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24541 
      return
24542 
    oprot.writeStructBegin('getSettlementForPrepaid_result')
24543 
    if self.success is not None:
24544 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
24545 
      self.success.write(oprot)
24546 
      oprot.writeFieldEnd()
24547 
    if self.ex is not None:
24548 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
24549 
      self.ex.write(oprot)
24550 
      oprot.writeFieldEnd()
24551 
    oprot.writeFieldStop()
24552 
    oprot.writeStructEnd()
24553 
 
24554 
  def validate(self):
24555 
    return
24556 
 
24557 
 
24558 
  def __repr__(self):
24559 
    L = ['%s=%r' % (key, value)
24560 
      for key, value in self.__dict__.iteritems()]
24561 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24562 
 
24563 
  def __eq__(self, other):
24564 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24565 
 
24566 
  def __ne__(self, other):
24567 
    return not (self == other)
24568 
 
24569 
class getSettlementForCod_args:
24570 
  """
24571 
  Attributes:
24572 
   - orderId
24573 
   - isRefund
24574 
  """
24575 
 
24576 
  thrift_spec = (
24577 
    None, # 0
24578 
    (1, TType.I64, 'orderId', None, None, ), # 1
24579 
    (2, TType.BOOL, 'isRefund', None, None, ), # 2
24580 
  )
24581 
 
24582 
  def __init__(self, orderId=None, isRefund=None,):
24583 
    self.orderId = orderId
24584 
    self.isRefund = isRefund
24585 
 
24586 
  def read(self, iprot):
24587 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24588 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24589 
      return
24590 
    iprot.readStructBegin()
24591 
    while True:
24592 
      (fname, ftype, fid) = iprot.readFieldBegin()
24593 
      if ftype == TType.STOP:
24594 
        break
24595 
      if fid == 1:
24596 
        if ftype == TType.I64:
24597 
          self.orderId = iprot.readI64();
24598 
        else:
24599 
          iprot.skip(ftype)
24600 
      elif fid == 2:
24601 
        if ftype == TType.BOOL:
24602 
          self.isRefund = iprot.readBool();
24603 
        else:
24604 
          iprot.skip(ftype)
24605 
      else:
24606 
        iprot.skip(ftype)
24607 
      iprot.readFieldEnd()
24608 
    iprot.readStructEnd()
24609 
 
24610 
  def write(self, oprot):
24611 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24612 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24613 
      return
24614 
    oprot.writeStructBegin('getSettlementForCod_args')
24615 
    if self.orderId is not None:
24616 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
24617 
      oprot.writeI64(self.orderId)
24618 
      oprot.writeFieldEnd()
5189 varun.gupt 24619 
    if self.isRefund is not None:
5386 phani.kuma 24620 
      oprot.writeFieldBegin('isRefund', TType.BOOL, 2)
5189 varun.gupt 24621 
      oprot.writeBool(self.isRefund)
24622 
      oprot.writeFieldEnd()
4600 varun.gupt 24623 
    oprot.writeFieldStop()
24624 
    oprot.writeStructEnd()
24625 
 
24626 
  def validate(self):
24627 
    return
24628 
 
24629 
 
24630 
  def __repr__(self):
24631 
    L = ['%s=%r' % (key, value)
24632 
      for key, value in self.__dict__.iteritems()]
24633 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24634 
 
24635 
  def __eq__(self, other):
24636 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24637 
 
24638 
  def __ne__(self, other):
24639 
    return not (self == other)
24640 
 
5386 phani.kuma 24641 
class getSettlementForCod_result:
4600 varun.gupt 24642 
  """
24643 
  Attributes:
24644 
   - success
24645 
   - ex
24646 
  """
24647 
 
24648 
  thrift_spec = (
24649 
    (0, TType.STRUCT, 'success', (PaymentSettlement, PaymentSettlement.thrift_spec), None, ), # 0
24650 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
24651 
  )
24652 
 
24653 
  def __init__(self, success=None, ex=None,):
24654 
    self.success = success
24655 
    self.ex = ex
24656 
 
24657 
  def read(self, iprot):
24658 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24659 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24660 
      return
24661 
    iprot.readStructBegin()
24662 
    while True:
24663 
      (fname, ftype, fid) = iprot.readFieldBegin()
24664 
      if ftype == TType.STOP:
24665 
        break
24666 
      if fid == 0:
24667 
        if ftype == TType.STRUCT:
24668 
          self.success = PaymentSettlement()
24669 
          self.success.read(iprot)
24670 
        else:
24671 
          iprot.skip(ftype)
24672 
      elif fid == 1:
24673 
        if ftype == TType.STRUCT:
24674 
          self.ex = TransactionServiceException()
24675 
          self.ex.read(iprot)
24676 
        else:
24677 
          iprot.skip(ftype)
24678 
      else:
24679 
        iprot.skip(ftype)
24680 
      iprot.readFieldEnd()
24681 
    iprot.readStructEnd()
24682 
 
24683 
  def write(self, oprot):
24684 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24685 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24686 
      return
5386 phani.kuma 24687 
    oprot.writeStructBegin('getSettlementForCod_result')
4600 varun.gupt 24688 
    if self.success is not None:
24689 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
24690 
      self.success.write(oprot)
24691 
      oprot.writeFieldEnd()
24692 
    if self.ex is not None:
24693 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
24694 
      self.ex.write(oprot)
24695 
      oprot.writeFieldEnd()
24696 
    oprot.writeFieldStop()
24697 
    oprot.writeStructEnd()
24698 
 
24699 
  def validate(self):
24700 
    return
24701 
 
24702 
 
24703 
  def __repr__(self):
24704 
    L = ['%s=%r' % (key, value)
24705 
      for key, value in self.__dict__.iteritems()]
24706 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24707 
 
24708 
  def __eq__(self, other):
24709 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24710 
 
24711 
  def __ne__(self, other):
24712 
    return not (self == other)
24713 
 
24714 
class getEBSSettlementSummaries_args:
24715 
 
24716 
  thrift_spec = (
24717 
  )
24718 
 
24719 
  def read(self, iprot):
24720 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24721 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24722 
      return
24723 
    iprot.readStructBegin()
24724 
    while True:
24725 
      (fname, ftype, fid) = iprot.readFieldBegin()
24726 
      if ftype == TType.STOP:
24727 
        break
24728 
      else:
24729 
        iprot.skip(ftype)
24730 
      iprot.readFieldEnd()
24731 
    iprot.readStructEnd()
24732 
 
24733 
  def write(self, oprot):
24734 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24735 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24736 
      return
24737 
    oprot.writeStructBegin('getEBSSettlementSummaries_args')
24738 
    oprot.writeFieldStop()
24739 
    oprot.writeStructEnd()
24740 
 
24741 
  def validate(self):
24742 
    return
24743 
 
24744 
 
24745 
  def __repr__(self):
24746 
    L = ['%s=%r' % (key, value)
24747 
      for key, value in self.__dict__.iteritems()]
24748 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24749 
 
24750 
  def __eq__(self, other):
24751 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24752 
 
24753 
  def __ne__(self, other):
24754 
    return not (self == other)
24755 
 
24756 
class getEBSSettlementSummaries_result:
24757 
  """
24758 
  Attributes:
24759 
   - success
24760 
   - ex
24761 
  """
24762 
 
24763 
  thrift_spec = (
24764 
    (0, TType.MAP, 'success', (TType.I64,None,TType.STRING,None), None, ), # 0
24765 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
24766 
  )
24767 
 
24768 
  def __init__(self, success=None, ex=None,):
24769 
    self.success = success
24770 
    self.ex = ex
24771 
 
24772 
  def read(self, iprot):
24773 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24774 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24775 
      return
24776 
    iprot.readStructBegin()
24777 
    while True:
24778 
      (fname, ftype, fid) = iprot.readFieldBegin()
24779 
      if ftype == TType.STOP:
24780 
        break
24781 
      if fid == 0:
24782 
        if ftype == TType.MAP:
24783 
          self.success = {}
6188 rajveer 24784 
          (_ktype555, _vtype556, _size554 ) = iprot.readMapBegin()
24785 
          for _i558 in xrange(_size554):
24786 
            _key559 = iprot.readI64();
24787 
            _val560 = iprot.readString();
24788 
            self.success[_key559] = _val560
4600 varun.gupt 24789 
          iprot.readMapEnd()
24790 
        else:
24791 
          iprot.skip(ftype)
24792 
      elif fid == 1:
24793 
        if ftype == TType.STRUCT:
24794 
          self.ex = TransactionServiceException()
24795 
          self.ex.read(iprot)
24796 
        else:
24797 
          iprot.skip(ftype)
24798 
      else:
24799 
        iprot.skip(ftype)
24800 
      iprot.readFieldEnd()
24801 
    iprot.readStructEnd()
24802 
 
24803 
  def write(self, oprot):
24804 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24805 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24806 
      return
24807 
    oprot.writeStructBegin('getEBSSettlementSummaries_result')
24808 
    if self.success is not None:
24809 
      oprot.writeFieldBegin('success', TType.MAP, 0)
24810 
      oprot.writeMapBegin(TType.I64, TType.STRING, len(self.success))
6188 rajveer 24811 
      for kiter561,viter562 in self.success.items():
24812 
        oprot.writeI64(kiter561)
24813 
        oprot.writeString(viter562)
4600 varun.gupt 24814 
      oprot.writeMapEnd()
24815 
      oprot.writeFieldEnd()
24816 
    if self.ex is not None:
24817 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
24818 
      self.ex.write(oprot)
24819 
      oprot.writeFieldEnd()
24820 
    oprot.writeFieldStop()
24821 
    oprot.writeStructEnd()
24822 
 
24823 
  def validate(self):
24824 
    return
24825 
 
24826 
 
24827 
  def __repr__(self):
24828 
    L = ['%s=%r' % (key, value)
24829 
      for key, value in self.__dict__.iteritems()]
24830 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24831 
 
24832 
  def __eq__(self, other):
24833 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24834 
 
24835 
  def __ne__(self, other):
24836 
    return not (self == other)
24837 
 
24838 
class markEBSSettlementUploaded_args:
24839 
  """
24840 
  Attributes:
24841 
   - settlementId
24842 
  """
24843 
 
24844 
  thrift_spec = (
24845 
    None, # 0
24846 
    (1, TType.I64, 'settlementId', None, None, ), # 1
24847 
  )
24848 
 
24849 
  def __init__(self, settlementId=None,):
24850 
    self.settlementId = settlementId
24851 
 
24852 
  def read(self, iprot):
24853 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24854 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24855 
      return
24856 
    iprot.readStructBegin()
24857 
    while True:
24858 
      (fname, ftype, fid) = iprot.readFieldBegin()
24859 
      if ftype == TType.STOP:
24860 
        break
24861 
      if fid == 1:
24862 
        if ftype == TType.I64:
24863 
          self.settlementId = iprot.readI64();
24864 
        else:
24865 
          iprot.skip(ftype)
24866 
      else:
24867 
        iprot.skip(ftype)
24868 
      iprot.readFieldEnd()
24869 
    iprot.readStructEnd()
24870 
 
24871 
  def write(self, oprot):
24872 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24873 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24874 
      return
24875 
    oprot.writeStructBegin('markEBSSettlementUploaded_args')
24876 
    if self.settlementId is not None:
24877 
      oprot.writeFieldBegin('settlementId', TType.I64, 1)
24878 
      oprot.writeI64(self.settlementId)
24879 
      oprot.writeFieldEnd()
24880 
    oprot.writeFieldStop()
24881 
    oprot.writeStructEnd()
24882 
 
24883 
  def validate(self):
24884 
    return
24885 
 
24886 
 
24887 
  def __repr__(self):
24888 
    L = ['%s=%r' % (key, value)
24889 
      for key, value in self.__dict__.iteritems()]
24890 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24891 
 
24892 
  def __eq__(self, other):
24893 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24894 
 
24895 
  def __ne__(self, other):
24896 
    return not (self == other)
24897 
 
24898 
class markEBSSettlementUploaded_result:
24899 
  """
24900 
  Attributes:
24901 
   - ex
24902 
  """
24903 
 
24904 
  thrift_spec = (
24905 
    None, # 0
24906 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
24907 
  )
24908 
 
24909 
  def __init__(self, ex=None,):
24910 
    self.ex = ex
24911 
 
24912 
  def read(self, iprot):
24913 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24914 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24915 
      return
24916 
    iprot.readStructBegin()
24917 
    while True:
24918 
      (fname, ftype, fid) = iprot.readFieldBegin()
24919 
      if ftype == TType.STOP:
24920 
        break
24921 
      if fid == 1:
24922 
        if ftype == TType.STRUCT:
24923 
          self.ex = TransactionServiceException()
24924 
          self.ex.read(iprot)
24925 
        else:
24926 
          iprot.skip(ftype)
24927 
      else:
24928 
        iprot.skip(ftype)
24929 
      iprot.readFieldEnd()
24930 
    iprot.readStructEnd()
24931 
 
24932 
  def write(self, oprot):
24933 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24934 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24935 
      return
24936 
    oprot.writeStructBegin('markEBSSettlementUploaded_result')
24937 
    if self.ex is not None:
24938 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
24939 
      self.ex.write(oprot)
24940 
      oprot.writeFieldEnd()
24941 
    oprot.writeFieldStop()
24942 
    oprot.writeStructEnd()
24943 
 
24944 
  def validate(self):
24945 
    return
24946 
 
24947 
 
24948 
  def __repr__(self):
24949 
    L = ['%s=%r' % (key, value)
24950 
      for key, value in self.__dict__.iteritems()]
24951 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24952 
 
24953 
  def __eq__(self, other):
24954 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24955 
 
24956 
  def __ne__(self, other):
24957 
    return not (self == other)
24958 
 
24959 
class getEBSSettlementDate_args:
24960 
  """
24961 
  Attributes:
24962 
   - settlementId
24963 
  """
24964 
 
24965 
  thrift_spec = (
24966 
    None, # 0
24967 
    (1, TType.I64, 'settlementId', None, None, ), # 1
24968 
  )
24969 
 
24970 
  def __init__(self, settlementId=None,):
24971 
    self.settlementId = settlementId
24972 
 
24973 
  def read(self, iprot):
24974 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24975 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24976 
      return
24977 
    iprot.readStructBegin()
24978 
    while True:
24979 
      (fname, ftype, fid) = iprot.readFieldBegin()
24980 
      if ftype == TType.STOP:
24981 
        break
24982 
      if fid == 1:
24983 
        if ftype == TType.I64:
24984 
          self.settlementId = iprot.readI64();
24985 
        else:
24986 
          iprot.skip(ftype)
24987 
      else:
24988 
        iprot.skip(ftype)
24989 
      iprot.readFieldEnd()
24990 
    iprot.readStructEnd()
24991 
 
24992 
  def write(self, oprot):
24993 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24994 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24995 
      return
24996 
    oprot.writeStructBegin('getEBSSettlementDate_args')
24997 
    if self.settlementId is not None:
24998 
      oprot.writeFieldBegin('settlementId', TType.I64, 1)
24999 
      oprot.writeI64(self.settlementId)
25000 
      oprot.writeFieldEnd()
25001 
    oprot.writeFieldStop()
25002 
    oprot.writeStructEnd()
25003 
 
25004 
  def validate(self):
25005 
    return
25006 
 
25007 
 
25008 
  def __repr__(self):
25009 
    L = ['%s=%r' % (key, value)
25010 
      for key, value in self.__dict__.iteritems()]
25011 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25012 
 
25013 
  def __eq__(self, other):
25014 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25015 
 
25016 
  def __ne__(self, other):
25017 
    return not (self == other)
25018 
 
25019 
class getEBSSettlementDate_result:
25020 
  """
25021 
  Attributes:
25022 
   - success
25023 
   - ex
25024 
  """
25025 
 
25026 
  thrift_spec = (
25027 
    (0, TType.I64, 'success', None, None, ), # 0
25028 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
25029 
  )
25030 
 
25031 
  def __init__(self, success=None, ex=None,):
25032 
    self.success = success
25033 
    self.ex = ex
25034 
 
25035 
  def read(self, iprot):
25036 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25037 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25038 
      return
25039 
    iprot.readStructBegin()
25040 
    while True:
25041 
      (fname, ftype, fid) = iprot.readFieldBegin()
25042 
      if ftype == TType.STOP:
25043 
        break
25044 
      if fid == 0:
25045 
        if ftype == TType.I64:
25046 
          self.success = iprot.readI64();
25047 
        else:
25048 
          iprot.skip(ftype)
25049 
      elif fid == 1:
25050 
        if ftype == TType.STRUCT:
25051 
          self.ex = TransactionServiceException()
25052 
          self.ex.read(iprot)
25053 
        else:
25054 
          iprot.skip(ftype)
25055 
      else:
25056 
        iprot.skip(ftype)
25057 
      iprot.readFieldEnd()
25058 
    iprot.readStructEnd()
25059 
 
25060 
  def write(self, oprot):
25061 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25062 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25063 
      return
25064 
    oprot.writeStructBegin('getEBSSettlementDate_result')
25065 
    if self.success is not None:
25066 
      oprot.writeFieldBegin('success', TType.I64, 0)
25067 
      oprot.writeI64(self.success)
25068 
      oprot.writeFieldEnd()
25069 
    if self.ex is not None:
25070 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
25071 
      self.ex.write(oprot)
25072 
      oprot.writeFieldEnd()
25073 
    oprot.writeFieldStop()
25074 
    oprot.writeStructEnd()
25075 
 
25076 
  def validate(self):
25077 
    return
25078 
 
25079 
 
25080 
  def __repr__(self):
25081 
    L = ['%s=%r' % (key, value)
25082 
      for key, value in self.__dict__.iteritems()]
25083 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25084 
 
25085 
  def __eq__(self, other):
25086 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25087 
 
25088 
  def __ne__(self, other):
25089 
    return not (self == other)
4715 varun.gupt 25090 
 
25091 
class getSettlementsByDate_args:
25092 
  """
25093 
  Attributes:
25094 
   - settlementDateFrom
25095 
   - settlementDateTo
25096 
   - isRefund
25097 
  """
25098 
 
25099 
  thrift_spec = (
25100 
    None, # 0
25101 
    (1, TType.I64, 'settlementDateFrom', None, None, ), # 1
25102 
    (2, TType.I64, 'settlementDateTo', None, None, ), # 2
25103 
    (3, TType.BOOL, 'isRefund', None, None, ), # 3
25104 
  )
25105 
 
25106 
  def __init__(self, settlementDateFrom=None, settlementDateTo=None, isRefund=None,):
25107 
    self.settlementDateFrom = settlementDateFrom
25108 
    self.settlementDateTo = settlementDateTo
25109 
    self.isRefund = isRefund
25110 
 
25111 
  def read(self, iprot):
25112 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25113 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25114 
      return
25115 
    iprot.readStructBegin()
25116 
    while True:
25117 
      (fname, ftype, fid) = iprot.readFieldBegin()
25118 
      if ftype == TType.STOP:
25119 
        break
25120 
      if fid == 1:
25121 
        if ftype == TType.I64:
25122 
          self.settlementDateFrom = iprot.readI64();
25123 
        else:
25124 
          iprot.skip(ftype)
25125 
      elif fid == 2:
25126 
        if ftype == TType.I64:
25127 
          self.settlementDateTo = iprot.readI64();
25128 
        else:
25129 
          iprot.skip(ftype)
25130 
      elif fid == 3:
25131 
        if ftype == TType.BOOL:
25132 
          self.isRefund = iprot.readBool();
25133 
        else:
25134 
          iprot.skip(ftype)
25135 
      else:
25136 
        iprot.skip(ftype)
25137 
      iprot.readFieldEnd()
25138 
    iprot.readStructEnd()
25139 
 
25140 
  def write(self, oprot):
25141 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25142 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25143 
      return
25144 
    oprot.writeStructBegin('getSettlementsByDate_args')
25145 
    if self.settlementDateFrom is not None:
25146 
      oprot.writeFieldBegin('settlementDateFrom', TType.I64, 1)
25147 
      oprot.writeI64(self.settlementDateFrom)
25148 
      oprot.writeFieldEnd()
25149 
    if self.settlementDateTo is not None:
25150 
      oprot.writeFieldBegin('settlementDateTo', TType.I64, 2)
25151 
      oprot.writeI64(self.settlementDateTo)
25152 
      oprot.writeFieldEnd()
25153 
    if self.isRefund is not None:
25154 
      oprot.writeFieldBegin('isRefund', TType.BOOL, 3)
25155 
      oprot.writeBool(self.isRefund)
25156 
      oprot.writeFieldEnd()
25157 
    oprot.writeFieldStop()
25158 
    oprot.writeStructEnd()
25159 
 
25160 
  def validate(self):
25161 
    return
25162 
 
25163 
 
25164 
  def __repr__(self):
25165 
    L = ['%s=%r' % (key, value)
25166 
      for key, value in self.__dict__.iteritems()]
25167 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25168 
 
25169 
  def __eq__(self, other):
25170 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25171 
 
25172 
  def __ne__(self, other):
25173 
    return not (self == other)
25174 
 
25175 
class getSettlementsByDate_result:
25176 
  """
25177 
  Attributes:
25178 
   - success
25179 
   - ex
25180 
  """
25181 
 
25182 
  thrift_spec = (
25183 
    (0, TType.LIST, 'success', (TType.STRUCT,(PaymentSettlement, PaymentSettlement.thrift_spec)), None, ), # 0
25184 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
25185 
  )
25186 
 
25187 
  def __init__(self, success=None, ex=None,):
25188 
    self.success = success
25189 
    self.ex = ex
25190 
 
25191 
  def read(self, iprot):
25192 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25193 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25194 
      return
25195 
    iprot.readStructBegin()
25196 
    while True:
25197 
      (fname, ftype, fid) = iprot.readFieldBegin()
25198 
      if ftype == TType.STOP:
25199 
        break
25200 
      if fid == 0:
25201 
        if ftype == TType.LIST:
25202 
          self.success = []
6188 rajveer 25203 
          (_etype566, _size563) = iprot.readListBegin()
25204 
          for _i567 in xrange(_size563):
25205 
            _elem568 = PaymentSettlement()
25206 
            _elem568.read(iprot)
25207 
            self.success.append(_elem568)
4715 varun.gupt 25208 
          iprot.readListEnd()
25209 
        else:
25210 
          iprot.skip(ftype)
25211 
      elif fid == 1:
25212 
        if ftype == TType.STRUCT:
25213 
          self.ex = TransactionServiceException()
25214 
          self.ex.read(iprot)
25215 
        else:
25216 
          iprot.skip(ftype)
25217 
      else:
25218 
        iprot.skip(ftype)
25219 
      iprot.readFieldEnd()
25220 
    iprot.readStructEnd()
25221 
 
25222 
  def write(self, oprot):
25223 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25224 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25225 
      return
25226 
    oprot.writeStructBegin('getSettlementsByDate_result')
25227 
    if self.success is not None:
25228 
      oprot.writeFieldBegin('success', TType.LIST, 0)
25229 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 25230 
      for iter569 in self.success:
25231 
        iter569.write(oprot)
4715 varun.gupt 25232 
      oprot.writeListEnd()
25233 
      oprot.writeFieldEnd()
25234 
    if self.ex is not None:
25235 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
25236 
      self.ex.write(oprot)
25237 
      oprot.writeFieldEnd()
25238 
    oprot.writeFieldStop()
25239 
    oprot.writeStructEnd()
25240 
 
25241 
  def validate(self):
25242 
    return
25243 
 
25244 
 
25245 
  def __repr__(self):
25246 
    L = ['%s=%r' % (key, value)
25247 
      for key, value in self.__dict__.iteritems()]
25248 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25249 
 
25250 
  def __eq__(self, other):
25251 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25252 
 
25253 
  def __ne__(self, other):
25254 
    return not (self == other)
25255 
 
25256 
class getReshippedOrderIds_args:
25257 
  """
25258 
  Attributes:
25259 
   - orderIds
25260 
  """
25261 
 
25262 
  thrift_spec = (
25263 
    None, # 0
25264 
    (1, TType.LIST, 'orderIds', (TType.I64,None), None, ), # 1
25265 
  )
25266 
 
25267 
  def __init__(self, orderIds=None,):
25268 
    self.orderIds = orderIds
25269 
 
25270 
  def read(self, iprot):
25271 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25272 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25273 
      return
25274 
    iprot.readStructBegin()
25275 
    while True:
25276 
      (fname, ftype, fid) = iprot.readFieldBegin()
25277 
      if ftype == TType.STOP:
25278 
        break
25279 
      if fid == 1:
25280 
        if ftype == TType.LIST:
25281 
          self.orderIds = []
6188 rajveer 25282 
          (_etype573, _size570) = iprot.readListBegin()
25283 
          for _i574 in xrange(_size570):
25284 
            _elem575 = iprot.readI64();
25285 
            self.orderIds.append(_elem575)
4715 varun.gupt 25286 
          iprot.readListEnd()
25287 
        else:
25288 
          iprot.skip(ftype)
25289 
      else:
25290 
        iprot.skip(ftype)
25291 
      iprot.readFieldEnd()
25292 
    iprot.readStructEnd()
25293 
 
25294 
  def write(self, oprot):
25295 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25296 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25297 
      return
25298 
    oprot.writeStructBegin('getReshippedOrderIds_args')
25299 
    if self.orderIds is not None:
25300 
      oprot.writeFieldBegin('orderIds', TType.LIST, 1)
25301 
      oprot.writeListBegin(TType.I64, len(self.orderIds))
6188 rajveer 25302 
      for iter576 in self.orderIds:
25303 
        oprot.writeI64(iter576)
4715 varun.gupt 25304 
      oprot.writeListEnd()
25305 
      oprot.writeFieldEnd()
25306 
    oprot.writeFieldStop()
25307 
    oprot.writeStructEnd()
25308 
 
25309 
  def validate(self):
25310 
    return
25311 
 
25312 
 
25313 
  def __repr__(self):
25314 
    L = ['%s=%r' % (key, value)
25315 
      for key, value in self.__dict__.iteritems()]
25316 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25317 
 
25318 
  def __eq__(self, other):
25319 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25320 
 
25321 
  def __ne__(self, other):
25322 
    return not (self == other)
25323 
 
25324 
class getReshippedOrderIds_result:
25325 
  """
25326 
  Attributes:
25327 
   - success
25328 
   - ex
25329 
  """
25330 
 
25331 
  thrift_spec = (
25332 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
25333 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
25334 
  )
25335 
 
25336 
  def __init__(self, success=None, ex=None,):
25337 
    self.success = success
25338 
    self.ex = ex
25339 
 
25340 
  def read(self, iprot):
25341 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25342 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25343 
      return
25344 
    iprot.readStructBegin()
25345 
    while True:
25346 
      (fname, ftype, fid) = iprot.readFieldBegin()
25347 
      if ftype == TType.STOP:
25348 
        break
25349 
      if fid == 0:
25350 
        if ftype == TType.LIST:
25351 
          self.success = []
6188 rajveer 25352 
          (_etype580, _size577) = iprot.readListBegin()
25353 
          for _i581 in xrange(_size577):
25354 
            _elem582 = iprot.readI64();
25355 
            self.success.append(_elem582)
4715 varun.gupt 25356 
          iprot.readListEnd()
25357 
        else:
25358 
          iprot.skip(ftype)
25359 
      elif fid == 1:
25360 
        if ftype == TType.STRUCT:
25361 
          self.ex = TransactionServiceException()
25362 
          self.ex.read(iprot)
25363 
        else:
25364 
          iprot.skip(ftype)
25365 
      else:
25366 
        iprot.skip(ftype)
25367 
      iprot.readFieldEnd()
25368 
    iprot.readStructEnd()
25369 
 
25370 
  def write(self, oprot):
25371 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25372 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25373 
      return
25374 
    oprot.writeStructBegin('getReshippedOrderIds_result')
25375 
    if self.success is not None:
25376 
      oprot.writeFieldBegin('success', TType.LIST, 0)
25377 
      oprot.writeListBegin(TType.I64, len(self.success))
6188 rajveer 25378 
      for iter583 in self.success:
25379 
        oprot.writeI64(iter583)
4715 varun.gupt 25380 
      oprot.writeListEnd()
25381 
      oprot.writeFieldEnd()
25382 
    if self.ex is not None:
25383 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
25384 
      self.ex.write(oprot)
25385 
      oprot.writeFieldEnd()
25386 
    oprot.writeFieldStop()
25387 
    oprot.writeStructEnd()
25388 
 
25389 
  def validate(self):
25390 
    return
25391 
 
25392 
 
25393 
  def __repr__(self):
25394 
    L = ['%s=%r' % (key, value)
25395 
      for key, value in self.__dict__.iteritems()]
25396 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25397 
 
25398 
  def __eq__(self, other):
25399 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25400 
 
25401 
  def __ne__(self, other):
25402 
    return not (self == other)
4757 mandeep.dh 25403 
 
5481 phani.kuma 25404 
class getBilledOrders_args:
4875 varun.gupt 25405 
  """
25406 
  Attributes:
25407 
   - vendorId
5481 phani.kuma 25408 
   - onlyVendorNotPaid
25409 
   - billingDateFrom
25410 
   - billingDateTo
4875 varun.gupt 25411 
  """
25412 
 
25413 
  thrift_spec = (
25414 
    None, # 0
25415 
    (1, TType.I64, 'vendorId', None, None, ), # 1
5481 phani.kuma 25416 
    (2, TType.BOOL, 'onlyVendorNotPaid', None, None, ), # 2
25417 
    (3, TType.I64, 'billingDateFrom', None, None, ), # 3
25418 
    (4, TType.I64, 'billingDateTo', None, None, ), # 4
4875 varun.gupt 25419 
  )
25420 
 
5481 phani.kuma 25421 
  def __init__(self, vendorId=None, onlyVendorNotPaid=None, billingDateFrom=None, billingDateTo=None,):
4875 varun.gupt 25422 
    self.vendorId = vendorId
5481 phani.kuma 25423 
    self.onlyVendorNotPaid = onlyVendorNotPaid
25424 
    self.billingDateFrom = billingDateFrom
25425 
    self.billingDateTo = billingDateTo
4875 varun.gupt 25426 
 
25427 
  def read(self, iprot):
25428 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25429 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25430 
      return
25431 
    iprot.readStructBegin()
25432 
    while True:
25433 
      (fname, ftype, fid) = iprot.readFieldBegin()
25434 
      if ftype == TType.STOP:
25435 
        break
25436 
      if fid == 1:
25437 
        if ftype == TType.I64:
25438 
          self.vendorId = iprot.readI64();
25439 
        else:
25440 
          iprot.skip(ftype)
5481 phani.kuma 25441 
      elif fid == 2:
25442 
        if ftype == TType.BOOL:
25443 
          self.onlyVendorNotPaid = iprot.readBool();
25444 
        else:
25445 
          iprot.skip(ftype)
25446 
      elif fid == 3:
25447 
        if ftype == TType.I64:
25448 
          self.billingDateFrom = iprot.readI64();
25449 
        else:
25450 
          iprot.skip(ftype)
25451 
      elif fid == 4:
25452 
        if ftype == TType.I64:
25453 
          self.billingDateTo = iprot.readI64();
25454 
        else:
25455 
          iprot.skip(ftype)
4875 varun.gupt 25456 
      else:
25457 
        iprot.skip(ftype)
25458 
      iprot.readFieldEnd()
25459 
    iprot.readStructEnd()
25460 
 
25461 
  def write(self, oprot):
25462 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25463 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25464 
      return
5481 phani.kuma 25465 
    oprot.writeStructBegin('getBilledOrders_args')
4875 varun.gupt 25466 
    if self.vendorId is not None:
25467 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
25468 
      oprot.writeI64(self.vendorId)
25469 
      oprot.writeFieldEnd()
5481 phani.kuma 25470 
    if self.onlyVendorNotPaid is not None:
25471 
      oprot.writeFieldBegin('onlyVendorNotPaid', TType.BOOL, 2)
25472 
      oprot.writeBool(self.onlyVendorNotPaid)
25473 
      oprot.writeFieldEnd()
25474 
    if self.billingDateFrom is not None:
25475 
      oprot.writeFieldBegin('billingDateFrom', TType.I64, 3)
25476 
      oprot.writeI64(self.billingDateFrom)
25477 
      oprot.writeFieldEnd()
25478 
    if self.billingDateTo is not None:
25479 
      oprot.writeFieldBegin('billingDateTo', TType.I64, 4)
25480 
      oprot.writeI64(self.billingDateTo)
25481 
      oprot.writeFieldEnd()
4875 varun.gupt 25482 
    oprot.writeFieldStop()
25483 
    oprot.writeStructEnd()
25484 
 
25485 
  def validate(self):
25486 
    return
25487 
 
25488 
 
25489 
  def __repr__(self):
25490 
    L = ['%s=%r' % (key, value)
25491 
      for key, value in self.__dict__.iteritems()]
25492 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25493 
 
25494 
  def __eq__(self, other):
25495 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25496 
 
25497 
  def __ne__(self, other):
25498 
    return not (self == other)
25499 
 
5481 phani.kuma 25500 
class getBilledOrders_result:
4875 varun.gupt 25501 
  """
25502 
  Attributes:
25503 
   - success
25504 
   - ex
25505 
  """
25506 
 
25507 
  thrift_spec = (
25508 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
25509 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
25510 
  )
25511 
 
25512 
  def __init__(self, success=None, ex=None,):
25513 
    self.success = success
25514 
    self.ex = ex
25515 
 
25516 
  def read(self, iprot):
25517 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25518 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25519 
      return
25520 
    iprot.readStructBegin()
25521 
    while True:
25522 
      (fname, ftype, fid) = iprot.readFieldBegin()
25523 
      if ftype == TType.STOP:
25524 
        break
25525 
      if fid == 0:
25526 
        if ftype == TType.LIST:
25527 
          self.success = []
6188 rajveer 25528 
          (_etype587, _size584) = iprot.readListBegin()
25529 
          for _i588 in xrange(_size584):
25530 
            _elem589 = Order()
25531 
            _elem589.read(iprot)
25532 
            self.success.append(_elem589)
4875 varun.gupt 25533 
          iprot.readListEnd()
25534 
        else:
25535 
          iprot.skip(ftype)
25536 
      elif fid == 1:
25537 
        if ftype == TType.STRUCT:
25538 
          self.ex = TransactionServiceException()
25539 
          self.ex.read(iprot)
25540 
        else:
25541 
          iprot.skip(ftype)
25542 
      else:
25543 
        iprot.skip(ftype)
25544 
      iprot.readFieldEnd()
25545 
    iprot.readStructEnd()
25546 
 
25547 
  def write(self, oprot):
25548 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25549 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25550 
      return
5481 phani.kuma 25551 
    oprot.writeStructBegin('getBilledOrders_result')
4875 varun.gupt 25552 
    if self.success is not None:
25553 
      oprot.writeFieldBegin('success', TType.LIST, 0)
25554 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 25555 
      for iter590 in self.success:
25556 
        iter590.write(oprot)
4875 varun.gupt 25557 
      oprot.writeListEnd()
25558 
      oprot.writeFieldEnd()
25559 
    if self.ex is not None:
25560 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
25561 
      self.ex.write(oprot)
25562 
      oprot.writeFieldEnd()
25563 
    oprot.writeFieldStop()
25564 
    oprot.writeStructEnd()
25565 
 
25566 
  def validate(self):
25567 
    return
25568 
 
25569 
 
25570 
  def __repr__(self):
25571 
    L = ['%s=%r' % (key, value)
25572 
      for key, value in self.__dict__.iteritems()]
25573 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25574 
 
25575 
  def __eq__(self, other):
25576 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25577 
 
25578 
  def __ne__(self, other):
25579 
    return not (self == other)
5031 varun.gupt 25580 
 
25581 
class getStatusDistributionOfOrders_args:
25582 
  """
25583 
  Attributes:
25584 
   - startDate
25585 
   - endDate
25586 
  """
25587 
 
25588 
  thrift_spec = (
25589 
    None, # 0
25590 
    (1, TType.I64, 'startDate', None, None, ), # 1
25591 
    (2, TType.I64, 'endDate', None, None, ), # 2
25592 
  )
25593 
 
25594 
  def __init__(self, startDate=None, endDate=None,):
25595 
    self.startDate = startDate
25596 
    self.endDate = endDate
25597 
 
25598 
  def read(self, iprot):
25599 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25600 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25601 
      return
25602 
    iprot.readStructBegin()
25603 
    while True:
25604 
      (fname, ftype, fid) = iprot.readFieldBegin()
25605 
      if ftype == TType.STOP:
25606 
        break
25607 
      if fid == 1:
25608 
        if ftype == TType.I64:
25609 
          self.startDate = iprot.readI64();
25610 
        else:
25611 
          iprot.skip(ftype)
25612 
      elif fid == 2:
25613 
        if ftype == TType.I64:
25614 
          self.endDate = iprot.readI64();
25615 
        else:
25616 
          iprot.skip(ftype)
25617 
      else:
25618 
        iprot.skip(ftype)
25619 
      iprot.readFieldEnd()
25620 
    iprot.readStructEnd()
25621 
 
25622 
  def write(self, oprot):
25623 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25624 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25625 
      return
25626 
    oprot.writeStructBegin('getStatusDistributionOfOrders_args')
25627 
    if self.startDate is not None:
25628 
      oprot.writeFieldBegin('startDate', TType.I64, 1)
25629 
      oprot.writeI64(self.startDate)
25630 
      oprot.writeFieldEnd()
25631 
    if self.endDate is not None:
25632 
      oprot.writeFieldBegin('endDate', TType.I64, 2)
25633 
      oprot.writeI64(self.endDate)
25634 
      oprot.writeFieldEnd()
25635 
    oprot.writeFieldStop()
25636 
    oprot.writeStructEnd()
25637 
 
25638 
  def validate(self):
25639 
    return
25640 
 
25641 
 
25642 
  def __repr__(self):
25643 
    L = ['%s=%r' % (key, value)
25644 
      for key, value in self.__dict__.iteritems()]
25645 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25646 
 
25647 
  def __eq__(self, other):
25648 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25649 
 
25650 
  def __ne__(self, other):
25651 
    return not (self == other)
25652 
 
25653 
class getStatusDistributionOfOrders_result:
25654 
  """
25655 
  Attributes:
25656 
   - success
25657 
   - ex
25658 
  """
25659 
 
25660 
  thrift_spec = (
25661 
    (0, TType.MAP, 'success', (TType.I64,None,TType.I64,None), None, ), # 0
25662 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
25663 
  )
25664 
 
25665 
  def __init__(self, success=None, ex=None,):
25666 
    self.success = success
25667 
    self.ex = ex
25668 
 
25669 
  def read(self, iprot):
25670 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25671 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25672 
      return
25673 
    iprot.readStructBegin()
25674 
    while True:
25675 
      (fname, ftype, fid) = iprot.readFieldBegin()
25676 
      if ftype == TType.STOP:
25677 
        break
25678 
      if fid == 0:
25679 
        if ftype == TType.MAP:
25680 
          self.success = {}
6188 rajveer 25681 
          (_ktype592, _vtype593, _size591 ) = iprot.readMapBegin()
25682 
          for _i595 in xrange(_size591):
25683 
            _key596 = iprot.readI64();
25684 
            _val597 = iprot.readI64();
25685 
            self.success[_key596] = _val597
5031 varun.gupt 25686 
          iprot.readMapEnd()
25687 
        else:
25688 
          iprot.skip(ftype)
25689 
      elif fid == 1:
25690 
        if ftype == TType.STRUCT:
25691 
          self.ex = TransactionServiceException()
25692 
          self.ex.read(iprot)
25693 
        else:
25694 
          iprot.skip(ftype)
25695 
      else:
25696 
        iprot.skip(ftype)
25697 
      iprot.readFieldEnd()
25698 
    iprot.readStructEnd()
25699 
 
25700 
  def write(self, oprot):
25701 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25702 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25703 
      return
25704 
    oprot.writeStructBegin('getStatusDistributionOfOrders_result')
25705 
    if self.success is not None:
25706 
      oprot.writeFieldBegin('success', TType.MAP, 0)
25707 
      oprot.writeMapBegin(TType.I64, TType.I64, len(self.success))
6188 rajveer 25708 
      for kiter598,viter599 in self.success.items():
25709 
        oprot.writeI64(kiter598)
25710 
        oprot.writeI64(viter599)
5031 varun.gupt 25711 
      oprot.writeMapEnd()
25712 
      oprot.writeFieldEnd()
25713 
    if self.ex is not None:
25714 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
25715 
      self.ex.write(oprot)
25716 
      oprot.writeFieldEnd()
25717 
    oprot.writeFieldStop()
25718 
    oprot.writeStructEnd()
25719 
 
25720 
  def validate(self):
25721 
    return
25722 
 
25723 
 
25724 
  def __repr__(self):
25725 
    L = ['%s=%r' % (key, value)
25726 
      for key, value in self.__dict__.iteritems()]
25727 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25728 
 
25729 
  def __eq__(self, other):
25730 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25731 
 
25732 
  def __ne__(self, other):
25733 
    return not (self == other)
5067 varun.gupt 25734 
 
25735 
class getOrderIdsForStatus_args:
25736 
  """
25737 
  Attributes:
25738 
   - status
25739 
   - startDatetime
25740 
   - endDatetime
25741 
  """
25742 
 
25743 
  thrift_spec = (
25744 
    None, # 0
25745 
    (1, TType.I64, 'status', None, None, ), # 1
25746 
    (2, TType.I64, 'startDatetime', None, None, ), # 2
25747 
    (3, TType.I64, 'endDatetime', None, None, ), # 3
25748 
  )
25749 
 
25750 
  def __init__(self, status=None, startDatetime=None, endDatetime=None,):
25751 
    self.status = status
25752 
    self.startDatetime = startDatetime
25753 
    self.endDatetime = endDatetime
25754 
 
25755 
  def read(self, iprot):
25756 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25757 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25758 
      return
25759 
    iprot.readStructBegin()
25760 
    while True:
25761 
      (fname, ftype, fid) = iprot.readFieldBegin()
25762 
      if ftype == TType.STOP:
25763 
        break
25764 
      if fid == 1:
25765 
        if ftype == TType.I64:
25766 
          self.status = iprot.readI64();
25767 
        else:
25768 
          iprot.skip(ftype)
25769 
      elif fid == 2:
25770 
        if ftype == TType.I64:
25771 
          self.startDatetime = iprot.readI64();
25772 
        else:
25773 
          iprot.skip(ftype)
25774 
      elif fid == 3:
25775 
        if ftype == TType.I64:
25776 
          self.endDatetime = iprot.readI64();
25777 
        else:
25778 
          iprot.skip(ftype)
25779 
      else:
25780 
        iprot.skip(ftype)
25781 
      iprot.readFieldEnd()
25782 
    iprot.readStructEnd()
25783 
 
25784 
  def write(self, oprot):
25785 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25786 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25787 
      return
25788 
    oprot.writeStructBegin('getOrderIdsForStatus_args')
25789 
    if self.status is not None:
25790 
      oprot.writeFieldBegin('status', TType.I64, 1)
25791 
      oprot.writeI64(self.status)
25792 
      oprot.writeFieldEnd()
25793 
    if self.startDatetime is not None:
25794 
      oprot.writeFieldBegin('startDatetime', TType.I64, 2)
25795 
      oprot.writeI64(self.startDatetime)
25796 
      oprot.writeFieldEnd()
25797 
    if self.endDatetime is not None:
25798 
      oprot.writeFieldBegin('endDatetime', TType.I64, 3)
25799 
      oprot.writeI64(self.endDatetime)
25800 
      oprot.writeFieldEnd()
25801 
    oprot.writeFieldStop()
25802 
    oprot.writeStructEnd()
25803 
 
25804 
  def validate(self):
25805 
    return
25806 
 
25807 
 
25808 
  def __repr__(self):
25809 
    L = ['%s=%r' % (key, value)
25810 
      for key, value in self.__dict__.iteritems()]
25811 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25812 
 
25813 
  def __eq__(self, other):
25814 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25815 
 
25816 
  def __ne__(self, other):
25817 
    return not (self == other)
25818 
 
25819 
class getOrderIdsForStatus_result:
25820 
  """
25821 
  Attributes:
25822 
   - success
25823 
   - ex
25824 
  """
25825 
 
25826 
  thrift_spec = (
25827 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
25828 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
25829 
  )
25830 
 
25831 
  def __init__(self, success=None, ex=None,):
25832 
    self.success = success
25833 
    self.ex = ex
25834 
 
25835 
  def read(self, iprot):
25836 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25837 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25838 
      return
25839 
    iprot.readStructBegin()
25840 
    while True:
25841 
      (fname, ftype, fid) = iprot.readFieldBegin()
25842 
      if ftype == TType.STOP:
25843 
        break
25844 
      if fid == 0:
25845 
        if ftype == TType.LIST:
25846 
          self.success = []
6188 rajveer 25847 
          (_etype603, _size600) = iprot.readListBegin()
25848 
          for _i604 in xrange(_size600):
25849 
            _elem605 = iprot.readI64();
25850 
            self.success.append(_elem605)
5067 varun.gupt 25851 
          iprot.readListEnd()
25852 
        else:
25853 
          iprot.skip(ftype)
25854 
      elif fid == 1:
25855 
        if ftype == TType.STRUCT:
25856 
          self.ex = TransactionServiceException()
25857 
          self.ex.read(iprot)
25858 
        else:
25859 
          iprot.skip(ftype)
25860 
      else:
25861 
        iprot.skip(ftype)
25862 
      iprot.readFieldEnd()
25863 
    iprot.readStructEnd()
25864 
 
25865 
  def write(self, oprot):
25866 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25867 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25868 
      return
25869 
    oprot.writeStructBegin('getOrderIdsForStatus_result')
25870 
    if self.success is not None:
25871 
      oprot.writeFieldBegin('success', TType.LIST, 0)
25872 
      oprot.writeListBegin(TType.I64, len(self.success))
6188 rajveer 25873 
      for iter606 in self.success:
25874 
        oprot.writeI64(iter606)
5067 varun.gupt 25875 
      oprot.writeListEnd()
25876 
      oprot.writeFieldEnd()
25877 
    if self.ex is not None:
25878 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
25879 
      self.ex.write(oprot)
25880 
      oprot.writeFieldEnd()
25881 
    oprot.writeFieldStop()
25882 
    oprot.writeStructEnd()
25883 
 
25884 
  def validate(self):
25885 
    return
25886 
 
25887 
 
25888 
  def __repr__(self):
25889 
    L = ['%s=%r' % (key, value)
25890 
      for key, value in self.__dict__.iteritems()]
25891 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25892 
 
25893 
  def __eq__(self, other):
25894 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25895 
 
25896 
  def __ne__(self, other):
25897 
    return not (self == other)
5099 varun.gupt 25898 
 
5348 anupam.sin 25899 
class updateCODAgent_args:
25900 
  """
25901 
  Attributes:
25902 
   - agent
25903 
   - orderId
25904 
  """
25905 
 
25906 
  thrift_spec = (
25907 
    None, # 0
25908 
    (1, TType.STRING, 'agent', None, None, ), # 1
25909 
    (2, TType.I64, 'orderId', None, None, ), # 2
25910 
  )
25911 
 
25912 
  def __init__(self, agent=None, orderId=None,):
25913 
    self.agent = agent
25914 
    self.orderId = orderId
25915 
 
25916 
  def read(self, iprot):
25917 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25918 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25919 
      return
25920 
    iprot.readStructBegin()
25921 
    while True:
25922 
      (fname, ftype, fid) = iprot.readFieldBegin()
25923 
      if ftype == TType.STOP:
25924 
        break
25925 
      if fid == 1:
25926 
        if ftype == TType.STRING:
25927 
          self.agent = iprot.readString();
25928 
        else:
25929 
          iprot.skip(ftype)
25930 
      elif fid == 2:
25931 
        if ftype == TType.I64:
25932 
          self.orderId = iprot.readI64();
25933 
        else:
25934 
          iprot.skip(ftype)
25935 
      else:
25936 
        iprot.skip(ftype)
25937 
      iprot.readFieldEnd()
25938 
    iprot.readStructEnd()
25939 
 
25940 
  def write(self, oprot):
25941 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25942 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25943 
      return
25944 
    oprot.writeStructBegin('updateCODAgent_args')
25945 
    if self.agent is not None:
25946 
      oprot.writeFieldBegin('agent', TType.STRING, 1)
25947 
      oprot.writeString(self.agent)
25948 
      oprot.writeFieldEnd()
25949 
    if self.orderId is not None:
25950 
      oprot.writeFieldBegin('orderId', TType.I64, 2)
25951 
      oprot.writeI64(self.orderId)
25952 
      oprot.writeFieldEnd()
25953 
    oprot.writeFieldStop()
25954 
    oprot.writeStructEnd()
25955 
 
25956 
  def validate(self):
25957 
    return
25958 
 
25959 
 
25960 
  def __repr__(self):
25961 
    L = ['%s=%r' % (key, value)
25962 
      for key, value in self.__dict__.iteritems()]
25963 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25964 
 
25965 
  def __eq__(self, other):
25966 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25967 
 
25968 
  def __ne__(self, other):
25969 
    return not (self == other)
25970 
 
25971 
class updateCODAgent_result:
25972 
  """
25973 
  Attributes:
25974 
   - ex
25975 
  """
25976 
 
25977 
  thrift_spec = (
25978 
    None, # 0
25979 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
25980 
  )
25981 
 
25982 
  def __init__(self, ex=None,):
25983 
    self.ex = ex
25984 
 
25985 
  def read(self, iprot):
25986 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25987 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25988 
      return
25989 
    iprot.readStructBegin()
25990 
    while True:
25991 
      (fname, ftype, fid) = iprot.readFieldBegin()
25992 
      if ftype == TType.STOP:
25993 
        break
25994 
      if fid == 1:
25995 
        if ftype == TType.STRUCT:
25996 
          self.ex = TransactionServiceException()
25997 
          self.ex.read(iprot)
25998 
        else:
25999 
          iprot.skip(ftype)
26000 
      else:
26001 
        iprot.skip(ftype)
26002 
      iprot.readFieldEnd()
26003 
    iprot.readStructEnd()
26004 
 
26005 
  def write(self, oprot):
26006 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26007 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26008 
      return
26009 
    oprot.writeStructBegin('updateCODAgent_result')
26010 
    if self.ex is not None:
26011 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
26012 
      self.ex.write(oprot)
26013 
      oprot.writeFieldEnd()
26014 
    oprot.writeFieldStop()
26015 
    oprot.writeStructEnd()
26016 
 
26017 
  def validate(self):
26018 
    return
26019 
 
26020 
 
26021 
  def __repr__(self):
26022 
    L = ['%s=%r' % (key, value)
26023 
      for key, value in self.__dict__.iteritems()]
26024 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26025 
 
26026 
  def __eq__(self, other):
26027 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26028 
 
26029 
  def __ne__(self, other):
26030 
    return not (self == other)
26031 
 
5099 varun.gupt 26032 
class updateOrderAsPaidToVendor_args:
26033 
  """
26034 
  Attributes:
26035 
   - orderId
26036 
  """
26037 
 
26038 
  thrift_spec = (
26039 
    None, # 0
26040 
    (1, TType.I64, 'orderId', None, None, ), # 1
26041 
  )
26042 
 
26043 
  def __init__(self, orderId=None,):
26044 
    self.orderId = orderId
26045 
 
26046 
  def read(self, iprot):
26047 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26048 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26049 
      return
26050 
    iprot.readStructBegin()
26051 
    while True:
26052 
      (fname, ftype, fid) = iprot.readFieldBegin()
26053 
      if ftype == TType.STOP:
26054 
        break
26055 
      if fid == 1:
26056 
        if ftype == TType.I64:
26057 
          self.orderId = iprot.readI64();
26058 
        else:
26059 
          iprot.skip(ftype)
26060 
      else:
26061 
        iprot.skip(ftype)
26062 
      iprot.readFieldEnd()
26063 
    iprot.readStructEnd()
26064 
 
26065 
  def write(self, oprot):
26066 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26067 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26068 
      return
26069 
    oprot.writeStructBegin('updateOrderAsPaidToVendor_args')
26070 
    if self.orderId is not None:
26071 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
26072 
      oprot.writeI64(self.orderId)
26073 
      oprot.writeFieldEnd()
26074 
    oprot.writeFieldStop()
26075 
    oprot.writeStructEnd()
26076 
 
26077 
  def validate(self):
26078 
    return
26079 
 
26080 
 
26081 
  def __repr__(self):
26082 
    L = ['%s=%r' % (key, value)
26083 
      for key, value in self.__dict__.iteritems()]
26084 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26085 
 
26086 
  def __eq__(self, other):
26087 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26088 
 
26089 
  def __ne__(self, other):
26090 
    return not (self == other)
26091 
 
26092 
class updateOrderAsPaidToVendor_result:
26093 
  """
26094 
  Attributes:
26095 
   - ex
26096 
  """
26097 
 
26098 
  thrift_spec = (
26099 
    None, # 0
26100 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
26101 
  )
26102 
 
26103 
  def __init__(self, ex=None,):
26104 
    self.ex = ex
26105 
 
26106 
  def read(self, iprot):
26107 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26108 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26109 
      return
26110 
    iprot.readStructBegin()
26111 
    while True:
26112 
      (fname, ftype, fid) = iprot.readFieldBegin()
26113 
      if ftype == TType.STOP:
26114 
        break
26115 
      if fid == 1:
26116 
        if ftype == TType.STRUCT:
26117 
          self.ex = TransactionServiceException()
26118 
          self.ex.read(iprot)
26119 
        else:
26120 
          iprot.skip(ftype)
26121 
      else:
26122 
        iprot.skip(ftype)
26123 
      iprot.readFieldEnd()
26124 
    iprot.readStructEnd()
26125 
 
26126 
  def write(self, oprot):
26127 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26128 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26129 
      return
26130 
    oprot.writeStructBegin('updateOrderAsPaidToVendor_result')
26131 
    if self.ex is not None:
26132 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
26133 
      self.ex.write(oprot)
26134 
      oprot.writeFieldEnd()
26135 
    oprot.writeFieldStop()
26136 
    oprot.writeStructEnd()
26137 
 
26138 
  def validate(self):
26139 
    return
26140 
 
26141 
 
26142 
  def __repr__(self):
26143 
    L = ['%s=%r' % (key, value)
26144 
      for key, value in self.__dict__.iteritems()]
26145 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26146 
 
26147 
  def __eq__(self, other):
26148 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26149 
 
26150 
  def __ne__(self, other):
26151 
    return not (self == other)
5208 varun.gupt 26152 
 
5386 phani.kuma 26153 
class updateOrderOnlyAsPaidToVendor_args:
26154 
  """
26155 
  Attributes:
26156 
   - orderId
26157 
  """
26158 
 
26159 
  thrift_spec = (
26160 
    None, # 0
26161 
    (1, TType.I64, 'orderId', None, None, ), # 1
26162 
  )
26163 
 
26164 
  def __init__(self, orderId=None,):
26165 
    self.orderId = orderId
26166 
 
26167 
  def read(self, iprot):
26168 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26169 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26170 
      return
26171 
    iprot.readStructBegin()
26172 
    while True:
26173 
      (fname, ftype, fid) = iprot.readFieldBegin()
26174 
      if ftype == TType.STOP:
26175 
        break
26176 
      if fid == 1:
26177 
        if ftype == TType.I64:
26178 
          self.orderId = iprot.readI64();
26179 
        else:
26180 
          iprot.skip(ftype)
26181 
      else:
26182 
        iprot.skip(ftype)
26183 
      iprot.readFieldEnd()
26184 
    iprot.readStructEnd()
26185 
 
26186 
  def write(self, oprot):
26187 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26188 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26189 
      return
26190 
    oprot.writeStructBegin('updateOrderOnlyAsPaidToVendor_args')
26191 
    if self.orderId is not None:
26192 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
26193 
      oprot.writeI64(self.orderId)
26194 
      oprot.writeFieldEnd()
26195 
    oprot.writeFieldStop()
26196 
    oprot.writeStructEnd()
26197 
 
26198 
  def validate(self):
26199 
    return
26200 
 
26201 
 
26202 
  def __repr__(self):
26203 
    L = ['%s=%r' % (key, value)
26204 
      for key, value in self.__dict__.iteritems()]
26205 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26206 
 
26207 
  def __eq__(self, other):
26208 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26209 
 
26210 
  def __ne__(self, other):
26211 
    return not (self == other)
26212 
 
26213 
class updateOrderOnlyAsPaidToVendor_result:
26214 
  """
26215 
  Attributes:
26216 
   - ex
26217 
  """
26218 
 
26219 
  thrift_spec = (
26220 
    None, # 0
26221 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
26222 
  )
26223 
 
26224 
  def __init__(self, ex=None,):
26225 
    self.ex = ex
26226 
 
26227 
  def read(self, iprot):
26228 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26229 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26230 
      return
26231 
    iprot.readStructBegin()
26232 
    while True:
26233 
      (fname, ftype, fid) = iprot.readFieldBegin()
26234 
      if ftype == TType.STOP:
26235 
        break
26236 
      if fid == 1:
26237 
        if ftype == TType.STRUCT:
26238 
          self.ex = TransactionServiceException()
26239 
          self.ex.read(iprot)
26240 
        else:
26241 
          iprot.skip(ftype)
26242 
      else:
26243 
        iprot.skip(ftype)
26244 
      iprot.readFieldEnd()
26245 
    iprot.readStructEnd()
26246 
 
26247 
  def write(self, oprot):
26248 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26249 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26250 
      return
26251 
    oprot.writeStructBegin('updateOrderOnlyAsPaidToVendor_result')
26252 
    if self.ex is not None:
26253 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
26254 
      self.ex.write(oprot)
26255 
      oprot.writeFieldEnd()
26256 
    oprot.writeFieldStop()
26257 
    oprot.writeStructEnd()
26258 
 
26259 
  def validate(self):
26260 
    return
26261 
 
26262 
 
26263 
  def __repr__(self):
26264 
    L = ['%s=%r' % (key, value)
26265 
      for key, value in self.__dict__.iteritems()]
26266 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26267 
 
26268 
  def __eq__(self, other):
26269 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26270 
 
26271 
  def __ne__(self, other):
26272 
    return not (self == other)
26273 
 
5208 varun.gupt 26274 
class getRefundedOrdersMarkedPaid_args:
26275 
 
26276 
  thrift_spec = (
26277 
  )
26278 
 
26279 
  def read(self, iprot):
26280 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26281 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26282 
      return
26283 
    iprot.readStructBegin()
26284 
    while True:
26285 
      (fname, ftype, fid) = iprot.readFieldBegin()
26286 
      if ftype == TType.STOP:
26287 
        break
26288 
      else:
26289 
        iprot.skip(ftype)
26290 
      iprot.readFieldEnd()
26291 
    iprot.readStructEnd()
26292 
 
26293 
  def write(self, oprot):
26294 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26295 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26296 
      return
26297 
    oprot.writeStructBegin('getRefundedOrdersMarkedPaid_args')
26298 
    oprot.writeFieldStop()
26299 
    oprot.writeStructEnd()
26300 
 
26301 
  def validate(self):
26302 
    return
26303 
 
26304 
 
26305 
  def __repr__(self):
26306 
    L = ['%s=%r' % (key, value)
26307 
      for key, value in self.__dict__.iteritems()]
26308 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26309 
 
26310 
  def __eq__(self, other):
26311 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26312 
 
26313 
  def __ne__(self, other):
26314 
    return not (self == other)
26315 
 
26316 
class getRefundedOrdersMarkedPaid_result:
26317 
  """
26318 
  Attributes:
26319 
   - success
26320 
   - ex
26321 
  """
26322 
 
26323 
  thrift_spec = (
26324 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
26325 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
26326 
  )
26327 
 
26328 
  def __init__(self, success=None, ex=None,):
26329 
    self.success = success
26330 
    self.ex = ex
26331 
 
26332 
  def read(self, iprot):
26333 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26334 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26335 
      return
26336 
    iprot.readStructBegin()
26337 
    while True:
26338 
      (fname, ftype, fid) = iprot.readFieldBegin()
26339 
      if ftype == TType.STOP:
26340 
        break
26341 
      if fid == 0:
26342 
        if ftype == TType.LIST:
26343 
          self.success = []
6188 rajveer 26344 
          (_etype610, _size607) = iprot.readListBegin()
26345 
          for _i611 in xrange(_size607):
26346 
            _elem612 = Order()
26347 
            _elem612.read(iprot)
26348 
            self.success.append(_elem612)
5208 varun.gupt 26349 
          iprot.readListEnd()
26350 
        else:
26351 
          iprot.skip(ftype)
26352 
      elif fid == 1:
26353 
        if ftype == TType.STRUCT:
26354 
          self.ex = TransactionServiceException()
26355 
          self.ex.read(iprot)
26356 
        else:
26357 
          iprot.skip(ftype)
26358 
      else:
26359 
        iprot.skip(ftype)
26360 
      iprot.readFieldEnd()
26361 
    iprot.readStructEnd()
26362 
 
26363 
  def write(self, oprot):
26364 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26365 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26366 
      return
26367 
    oprot.writeStructBegin('getRefundedOrdersMarkedPaid_result')
26368 
    if self.success is not None:
26369 
      oprot.writeFieldBegin('success', TType.LIST, 0)
26370 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 26371 
      for iter613 in self.success:
26372 
        iter613.write(oprot)
5208 varun.gupt 26373 
      oprot.writeListEnd()
26374 
      oprot.writeFieldEnd()
26375 
    if self.ex is not None:
26376 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
26377 
      self.ex.write(oprot)
26378 
      oprot.writeFieldEnd()
26379 
    oprot.writeFieldStop()
26380 
    oprot.writeStructEnd()
26381 
 
26382 
  def validate(self):
26383 
    return
26384 
 
26385 
 
26386 
  def __repr__(self):
26387 
    L = ['%s=%r' % (key, value)
26388 
      for key, value in self.__dict__.iteritems()]
26389 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26390 
 
26391 
  def __eq__(self, other):
26392 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26393 
 
26394 
  def __ne__(self, other):
26395 
    return not (self == other)
5447 anupam.sin 26396 
 
26397 
class getAllVerificationAgents_args:
26398 
  """
26399 
  Attributes:
26400 
   - minOrderId
26401 
   - maxOrderId
26402 
  """
26403 
 
26404 
  thrift_spec = (
26405 
    None, # 0
26406 
    (1, TType.I64, 'minOrderId', None, None, ), # 1
26407 
    (2, TType.I64, 'maxOrderId', None, None, ), # 2
26408 
  )
26409 
 
26410 
  def __init__(self, minOrderId=None, maxOrderId=None,):
26411 
    self.minOrderId = minOrderId
26412 
    self.maxOrderId = maxOrderId
26413 
 
26414 
  def read(self, iprot):
26415 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26416 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26417 
      return
26418 
    iprot.readStructBegin()
26419 
    while True:
26420 
      (fname, ftype, fid) = iprot.readFieldBegin()
26421 
      if ftype == TType.STOP:
26422 
        break
26423 
      if fid == 1:
26424 
        if ftype == TType.I64:
26425 
          self.minOrderId = iprot.readI64();
26426 
        else:
26427 
          iprot.skip(ftype)
26428 
      elif fid == 2:
26429 
        if ftype == TType.I64:
26430 
          self.maxOrderId = iprot.readI64();
26431 
        else:
26432 
          iprot.skip(ftype)
26433 
      else:
26434 
        iprot.skip(ftype)
26435 
      iprot.readFieldEnd()
26436 
    iprot.readStructEnd()
26437 
 
26438 
  def write(self, oprot):
26439 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26440 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26441 
      return
26442 
    oprot.writeStructBegin('getAllVerificationAgents_args')
26443 
    if self.minOrderId is not None:
26444 
      oprot.writeFieldBegin('minOrderId', TType.I64, 1)
26445 
      oprot.writeI64(self.minOrderId)
26446 
      oprot.writeFieldEnd()
26447 
    if self.maxOrderId is not None:
26448 
      oprot.writeFieldBegin('maxOrderId', TType.I64, 2)
26449 
      oprot.writeI64(self.maxOrderId)
26450 
      oprot.writeFieldEnd()
26451 
    oprot.writeFieldStop()
26452 
    oprot.writeStructEnd()
26453 
 
26454 
  def validate(self):
26455 
    return
26456 
 
26457 
 
26458 
  def __repr__(self):
26459 
    L = ['%s=%r' % (key, value)
26460 
      for key, value in self.__dict__.iteritems()]
26461 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26462 
 
26463 
  def __eq__(self, other):
26464 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26465 
 
26466 
  def __ne__(self, other):
26467 
    return not (self == other)
26468 
 
26469 
class getAllVerificationAgents_result:
26470 
  """
26471 
  Attributes:
26472 
   - success
26473 
  """
26474 
 
26475 
  thrift_spec = (
26476 
    (0, TType.LIST, 'success', (TType.STRUCT,(CODVerificationAgent, CODVerificationAgent.thrift_spec)), None, ), # 0
26477 
  )
26478 
 
26479 
  def __init__(self, success=None,):
26480 
    self.success = success
26481 
 
26482 
  def read(self, iprot):
26483 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26484 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26485 
      return
26486 
    iprot.readStructBegin()
26487 
    while True:
26488 
      (fname, ftype, fid) = iprot.readFieldBegin()
26489 
      if ftype == TType.STOP:
26490 
        break
26491 
      if fid == 0:
26492 
        if ftype == TType.LIST:
26493 
          self.success = []
6188 rajveer 26494 
          (_etype617, _size614) = iprot.readListBegin()
26495 
          for _i618 in xrange(_size614):
26496 
            _elem619 = CODVerificationAgent()
26497 
            _elem619.read(iprot)
26498 
            self.success.append(_elem619)
5447 anupam.sin 26499 
          iprot.readListEnd()
26500 
        else:
26501 
          iprot.skip(ftype)
26502 
      else:
26503 
        iprot.skip(ftype)
26504 
      iprot.readFieldEnd()
26505 
    iprot.readStructEnd()
26506 
 
26507 
  def write(self, oprot):
26508 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26509 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26510 
      return
26511 
    oprot.writeStructBegin('getAllVerificationAgents_result')
26512 
    if self.success is not None:
26513 
      oprot.writeFieldBegin('success', TType.LIST, 0)
26514 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 26515 
      for iter620 in self.success:
26516 
        iter620.write(oprot)
5447 anupam.sin 26517 
      oprot.writeListEnd()
26518 
      oprot.writeFieldEnd()
26519 
    oprot.writeFieldStop()
26520 
    oprot.writeStructEnd()
26521 
 
26522 
  def validate(self):
26523 
    return
26524 
 
26525 
 
26526 
  def __repr__(self):
26527 
    L = ['%s=%r' % (key, value)
26528 
      for key, value in self.__dict__.iteritems()]
26529 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26530 
 
26531 
  def __eq__(self, other):
26532 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26533 
 
26534 
  def __ne__(self, other):
26535 
    return not (self == other)
5527 anupam.sin 26536 
 
26537 
class getAllAttributesForOrderId_args:
26538 
  """
26539 
  Attributes:
26540 
   - orderId
26541 
  """
26542 
 
26543 
  thrift_spec = (
26544 
    None, # 0
26545 
    (1, TType.I64, 'orderId', None, None, ), # 1
26546 
  )
26547 
 
26548 
  def __init__(self, orderId=None,):
26549 
    self.orderId = orderId
26550 
 
26551 
  def read(self, iprot):
26552 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26553 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26554 
      return
26555 
    iprot.readStructBegin()
26556 
    while True:
26557 
      (fname, ftype, fid) = iprot.readFieldBegin()
26558 
      if ftype == TType.STOP:
26559 
        break
26560 
      if fid == 1:
26561 
        if ftype == TType.I64:
26562 
          self.orderId = iprot.readI64();
26563 
        else:
26564 
          iprot.skip(ftype)
26565 
      else:
26566 
        iprot.skip(ftype)
26567 
      iprot.readFieldEnd()
26568 
    iprot.readStructEnd()
26569 
 
26570 
  def write(self, oprot):
26571 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26572 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26573 
      return
26574 
    oprot.writeStructBegin('getAllAttributesForOrderId_args')
26575 
    if self.orderId is not None:
26576 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
26577 
      oprot.writeI64(self.orderId)
26578 
      oprot.writeFieldEnd()
26579 
    oprot.writeFieldStop()
26580 
    oprot.writeStructEnd()
26581 
 
26582 
  def validate(self):
26583 
    return
26584 
 
26585 
 
26586 
  def __repr__(self):
26587 
    L = ['%s=%r' % (key, value)
26588 
      for key, value in self.__dict__.iteritems()]
26589 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26590 
 
26591 
  def __eq__(self, other):
26592 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26593 
 
26594 
  def __ne__(self, other):
26595 
    return not (self == other)
26596 
 
26597 
class getAllAttributesForOrderId_result:
26598 
  """
26599 
  Attributes:
26600 
   - success
26601 
  """
26602 
 
26603 
  thrift_spec = (
26604 
    (0, TType.LIST, 'success', (TType.STRUCT,(Attribute, Attribute.thrift_spec)), None, ), # 0
26605 
  )
26606 
 
26607 
  def __init__(self, success=None,):
26608 
    self.success = success
26609 
 
26610 
  def read(self, iprot):
26611 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26612 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26613 
      return
26614 
    iprot.readStructBegin()
26615 
    while True:
26616 
      (fname, ftype, fid) = iprot.readFieldBegin()
26617 
      if ftype == TType.STOP:
26618 
        break
26619 
      if fid == 0:
26620 
        if ftype == TType.LIST:
26621 
          self.success = []
6188 rajveer 26622 
          (_etype624, _size621) = iprot.readListBegin()
26623 
          for _i625 in xrange(_size621):
26624 
            _elem626 = Attribute()
26625 
            _elem626.read(iprot)
26626 
            self.success.append(_elem626)
5527 anupam.sin 26627 
          iprot.readListEnd()
26628 
        else:
26629 
          iprot.skip(ftype)
26630 
      else:
26631 
        iprot.skip(ftype)
26632 
      iprot.readFieldEnd()
26633 
    iprot.readStructEnd()
26634 
 
26635 
  def write(self, oprot):
26636 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26637 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26638 
      return
26639 
    oprot.writeStructBegin('getAllAttributesForOrderId_result')
26640 
    if self.success is not None:
26641 
      oprot.writeFieldBegin('success', TType.LIST, 0)
26642 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 26643 
      for iter627 in self.success:
26644 
        iter627.write(oprot)
5527 anupam.sin 26645 
      oprot.writeListEnd()
26646 
      oprot.writeFieldEnd()
26647 
    oprot.writeFieldStop()
26648 
    oprot.writeStructEnd()
26649 
 
26650 
  def validate(self):
26651 
    return
26652 
 
26653 
 
26654 
  def __repr__(self):
26655 
    L = ['%s=%r' % (key, value)
26656 
      for key, value in self.__dict__.iteritems()]
26657 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26658 
 
26659 
  def __eq__(self, other):
26660 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26661 
 
26662 
  def __ne__(self, other):
26663 
    return not (self == other)
26664 
 
5676 rajveer 26665 
class setOrderAttributes_args:
26666 
  """
26667 
  Attributes:
26668 
   - orderId
26669 
   - attributes
26670 
  """
26671 
 
26672 
  thrift_spec = None
26673 
  def __init__(self, orderId=None, attributes=None,):
26674 
    self.orderId = orderId
26675 
    self.attributes = attributes
26676 
 
26677 
  def read(self, iprot):
26678 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26679 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26680 
      return
26681 
    iprot.readStructBegin()
26682 
    while True:
26683 
      (fname, ftype, fid) = iprot.readFieldBegin()
26684 
      if ftype == TType.STOP:
26685 
        break
26686 
      if fid == 1:
26687 
        if ftype == TType.I64:
26688 
          self.orderId = iprot.readI64();
26689 
        else:
26690 
          iprot.skip(ftype)
26691 
      elif fid == -1:
26692 
        if ftype == TType.LIST:
26693 
          self.attributes = []
6188 rajveer 26694 
          (_etype631, _size628) = iprot.readListBegin()
26695 
          for _i632 in xrange(_size628):
26696 
            _elem633 = Attribute()
26697 
            _elem633.read(iprot)
26698 
            self.attributes.append(_elem633)
5676 rajveer 26699 
          iprot.readListEnd()
26700 
        else:
26701 
          iprot.skip(ftype)
26702 
      else:
26703 
        iprot.skip(ftype)
26704 
      iprot.readFieldEnd()
26705 
    iprot.readStructEnd()
26706 
 
26707 
  def write(self, oprot):
26708 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26709 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26710 
      return
26711 
    oprot.writeStructBegin('setOrderAttributes_args')
26712 
    if self.attributes is not None:
26713 
      oprot.writeFieldBegin('attributes', TType.LIST, -1)
26714 
      oprot.writeListBegin(TType.STRUCT, len(self.attributes))
6188 rajveer 26715 
      for iter634 in self.attributes:
26716 
        iter634.write(oprot)
5676 rajveer 26717 
      oprot.writeListEnd()
26718 
      oprot.writeFieldEnd()
26719 
    if self.orderId is not None:
26720 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
26721 
      oprot.writeI64(self.orderId)
26722 
      oprot.writeFieldEnd()
26723 
    oprot.writeFieldStop()
26724 
    oprot.writeStructEnd()
26725 
 
26726 
  def validate(self):
26727 
    return
26728 
 
26729 
 
26730 
  def __repr__(self):
26731 
    L = ['%s=%r' % (key, value)
26732 
      for key, value in self.__dict__.iteritems()]
26733 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26734 
 
26735 
  def __eq__(self, other):
26736 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26737 
 
26738 
  def __ne__(self, other):
26739 
    return not (self == other)
26740 
 
26741 
class setOrderAttributes_result:
26742 
 
26743 
  thrift_spec = (
26744 
  )
26745 
 
26746 
  def read(self, iprot):
26747 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26748 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26749 
      return
26750 
    iprot.readStructBegin()
26751 
    while True:
26752 
      (fname, ftype, fid) = iprot.readFieldBegin()
26753 
      if ftype == TType.STOP:
26754 
        break
26755 
      else:
26756 
        iprot.skip(ftype)
26757 
      iprot.readFieldEnd()
26758 
    iprot.readStructEnd()
26759 
 
26760 
  def write(self, oprot):
26761 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26762 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26763 
      return
26764 
    oprot.writeStructBegin('setOrderAttributes_result')
26765 
    oprot.writeFieldStop()
26766 
    oprot.writeStructEnd()
26767 
 
26768 
  def validate(self):
26769 
    return
26770 
 
26771 
 
26772 
  def __repr__(self):
26773 
    L = ['%s=%r' % (key, value)
26774 
      for key, value in self.__dict__.iteritems()]
26775 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26776 
 
26777 
  def __eq__(self, other):
26778 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26779 
 
26780 
  def __ne__(self, other):
26781 
    return not (self == other)
26782 
 
5527 anupam.sin 26783 
class setOrderAttributeForTransaction_args:
26784 
  """
26785 
  Attributes:
26786 
   - transactionId
26787 
   - attribute
26788 
  """
26789 
 
26790 
  thrift_spec = None
26791 
  def __init__(self, transactionId=None, attribute=None,):
26792 
    self.transactionId = transactionId
26793 
    self.attribute = attribute
26794 
 
26795 
  def read(self, iprot):
26796 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26797 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26798 
      return
26799 
    iprot.readStructBegin()
26800 
    while True:
26801 
      (fname, ftype, fid) = iprot.readFieldBegin()
26802 
      if ftype == TType.STOP:
26803 
        break
26804 
      if fid == 1:
26805 
        if ftype == TType.I64:
26806 
          self.transactionId = iprot.readI64();
26807 
        else:
26808 
          iprot.skip(ftype)
26809 
      elif fid == -1:
26810 
        if ftype == TType.STRUCT:
26811 
          self.attribute = Attribute()
26812 
          self.attribute.read(iprot)
26813 
        else:
26814 
          iprot.skip(ftype)
26815 
      else:
26816 
        iprot.skip(ftype)
26817 
      iprot.readFieldEnd()
26818 
    iprot.readStructEnd()
26819 
 
26820 
  def write(self, oprot):
26821 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26822 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26823 
      return
26824 
    oprot.writeStructBegin('setOrderAttributeForTransaction_args')
26825 
    if self.attribute is not None:
26826 
      oprot.writeFieldBegin('attribute', TType.STRUCT, -1)
26827 
      self.attribute.write(oprot)
26828 
      oprot.writeFieldEnd()
26829 
    if self.transactionId is not None:
26830 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
26831 
      oprot.writeI64(self.transactionId)
26832 
      oprot.writeFieldEnd()
26833 
    oprot.writeFieldStop()
26834 
    oprot.writeStructEnd()
26835 
 
26836 
  def validate(self):
26837 
    return
26838 
 
26839 
 
26840 
  def __repr__(self):
26841 
    L = ['%s=%r' % (key, value)
26842 
      for key, value in self.__dict__.iteritems()]
26843 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26844 
 
26845 
  def __eq__(self, other):
26846 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26847 
 
26848 
  def __ne__(self, other):
26849 
    return not (self == other)
26850 
 
26851 
class setOrderAttributeForTransaction_result:
26852 
 
26853 
  thrift_spec = (
26854 
  )
26855 
 
26856 
  def read(self, iprot):
26857 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26858 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26859 
      return
26860 
    iprot.readStructBegin()
26861 
    while True:
26862 
      (fname, ftype, fid) = iprot.readFieldBegin()
26863 
      if ftype == TType.STOP:
26864 
        break
26865 
      else:
26866 
        iprot.skip(ftype)
26867 
      iprot.readFieldEnd()
26868 
    iprot.readStructEnd()
26869 
 
26870 
  def write(self, oprot):
26871 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26872 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26873 
      return
26874 
    oprot.writeStructBegin('setOrderAttributeForTransaction_result')
26875 
    oprot.writeFieldStop()
26876 
    oprot.writeStructEnd()
26877 
 
26878 
  def validate(self):
26879 
    return
26880 
 
26881 
 
26882 
  def __repr__(self):
26883 
    L = ['%s=%r' % (key, value)
26884 
      for key, value in self.__dict__.iteritems()]
26885 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26886 
 
26887 
  def __eq__(self, other):
26888 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26889 
 
26890 
  def __ne__(self, other):
26891 
    return not (self == other)
5553 rajveer 26892 
 
26893 
class getReceivePendingOrders_args:
26894 
  """
26895 
  Attributes:
26896 
   - storeId
26897 
  """
26898 
 
26899 
  thrift_spec = (
26900 
    None, # 0
26901 
    (1, TType.I64, 'storeId', None, None, ), # 1
26902 
  )
26903 
 
26904 
  def __init__(self, storeId=None,):
26905 
    self.storeId = storeId
26906 
 
26907 
  def read(self, iprot):
26908 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26909 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26910 
      return
26911 
    iprot.readStructBegin()
26912 
    while True:
26913 
      (fname, ftype, fid) = iprot.readFieldBegin()
26914 
      if ftype == TType.STOP:
26915 
        break
26916 
      if fid == 1:
26917 
        if ftype == TType.I64:
26918 
          self.storeId = iprot.readI64();
26919 
        else:
26920 
          iprot.skip(ftype)
26921 
      else:
26922 
        iprot.skip(ftype)
26923 
      iprot.readFieldEnd()
26924 
    iprot.readStructEnd()
26925 
 
26926 
  def write(self, oprot):
26927 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26928 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26929 
      return
26930 
    oprot.writeStructBegin('getReceivePendingOrders_args')
26931 
    if self.storeId is not None:
26932 
      oprot.writeFieldBegin('storeId', TType.I64, 1)
26933 
      oprot.writeI64(self.storeId)
26934 
      oprot.writeFieldEnd()
26935 
    oprot.writeFieldStop()
26936 
    oprot.writeStructEnd()
26937 
 
26938 
  def validate(self):
26939 
    return
26940 
 
26941 
 
26942 
  def __repr__(self):
26943 
    L = ['%s=%r' % (key, value)
26944 
      for key, value in self.__dict__.iteritems()]
26945 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26946 
 
26947 
  def __eq__(self, other):
26948 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26949 
 
26950 
  def __ne__(self, other):
26951 
    return not (self == other)
26952 
 
26953 
class getReceivePendingOrders_result:
26954 
  """
26955 
  Attributes:
26956 
   - success
26957 
  """
26958 
 
26959 
  thrift_spec = (
26960 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
26961 
  )
26962 
 
26963 
  def __init__(self, success=None,):
26964 
    self.success = success
26965 
 
26966 
  def read(self, iprot):
26967 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26968 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26969 
      return
26970 
    iprot.readStructBegin()
26971 
    while True:
26972 
      (fname, ftype, fid) = iprot.readFieldBegin()
26973 
      if ftype == TType.STOP:
26974 
        break
26975 
      if fid == 0:
26976 
        if ftype == TType.LIST:
26977 
          self.success = []
6188 rajveer 26978 
          (_etype638, _size635) = iprot.readListBegin()
26979 
          for _i639 in xrange(_size635):
26980 
            _elem640 = Order()
26981 
            _elem640.read(iprot)
26982 
            self.success.append(_elem640)
5553 rajveer 26983 
          iprot.readListEnd()
26984 
        else:
26985 
          iprot.skip(ftype)
26986 
      else:
26987 
        iprot.skip(ftype)
26988 
      iprot.readFieldEnd()
26989 
    iprot.readStructEnd()
26990 
 
26991 
  def write(self, oprot):
26992 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26993 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26994 
      return
26995 
    oprot.writeStructBegin('getReceivePendingOrders_result')
26996 
    if self.success is not None:
26997 
      oprot.writeFieldBegin('success', TType.LIST, 0)
26998 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 26999 
      for iter641 in self.success:
27000 
        iter641.write(oprot)
5553 rajveer 27001 
      oprot.writeListEnd()
27002 
      oprot.writeFieldEnd()
27003 
    oprot.writeFieldStop()
27004 
    oprot.writeStructEnd()
27005 
 
27006 
  def validate(self):
27007 
    return
27008 
 
27009 
 
27010 
  def __repr__(self):
27011 
    L = ['%s=%r' % (key, value)
27012 
      for key, value in self.__dict__.iteritems()]
27013 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27014 
 
27015 
  def __eq__(self, other):
27016 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27017 
 
27018 
  def __ne__(self, other):
27019 
    return not (self == other)
27020 
 
27021 
class getReceivedAtStoreOrders_args:
27022 
  """
27023 
  Attributes:
27024 
   - storeId
27025 
  """
27026 
 
27027 
  thrift_spec = (
27028 
    None, # 0
27029 
    (1, TType.I64, 'storeId', None, None, ), # 1
27030 
  )
27031 
 
27032 
  def __init__(self, storeId=None,):
27033 
    self.storeId = storeId
27034 
 
27035 
  def read(self, iprot):
27036 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27037 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27038 
      return
27039 
    iprot.readStructBegin()
27040 
    while True:
27041 
      (fname, ftype, fid) = iprot.readFieldBegin()
27042 
      if ftype == TType.STOP:
27043 
        break
27044 
      if fid == 1:
27045 
        if ftype == TType.I64:
27046 
          self.storeId = iprot.readI64();
27047 
        else:
27048 
          iprot.skip(ftype)
27049 
      else:
27050 
        iprot.skip(ftype)
27051 
      iprot.readFieldEnd()
27052 
    iprot.readStructEnd()
27053 
 
27054 
  def write(self, oprot):
27055 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27056 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27057 
      return
27058 
    oprot.writeStructBegin('getReceivedAtStoreOrders_args')
27059 
    if self.storeId is not None:
27060 
      oprot.writeFieldBegin('storeId', TType.I64, 1)
27061 
      oprot.writeI64(self.storeId)
27062 
      oprot.writeFieldEnd()
27063 
    oprot.writeFieldStop()
27064 
    oprot.writeStructEnd()
27065 
 
27066 
  def validate(self):
27067 
    return
27068 
 
27069 
 
27070 
  def __repr__(self):
27071 
    L = ['%s=%r' % (key, value)
27072 
      for key, value in self.__dict__.iteritems()]
27073 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27074 
 
27075 
  def __eq__(self, other):
27076 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27077 
 
27078 
  def __ne__(self, other):
27079 
    return not (self == other)
27080 
 
27081 
class getReceivedAtStoreOrders_result:
27082 
  """
27083 
  Attributes:
27084 
   - success
27085 
  """
27086 
 
27087 
  thrift_spec = (
27088 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
27089 
  )
27090 
 
27091 
  def __init__(self, success=None,):
27092 
    self.success = success
27093 
 
27094 
  def read(self, iprot):
27095 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27096 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27097 
      return
27098 
    iprot.readStructBegin()
27099 
    while True:
27100 
      (fname, ftype, fid) = iprot.readFieldBegin()
27101 
      if ftype == TType.STOP:
27102 
        break
27103 
      if fid == 0:
27104 
        if ftype == TType.LIST:
27105 
          self.success = []
6188 rajveer 27106 
          (_etype645, _size642) = iprot.readListBegin()
27107 
          for _i646 in xrange(_size642):
27108 
            _elem647 = Order()
27109 
            _elem647.read(iprot)
27110 
            self.success.append(_elem647)
5553 rajveer 27111 
          iprot.readListEnd()
27112 
        else:
27113 
          iprot.skip(ftype)
27114 
      else:
27115 
        iprot.skip(ftype)
27116 
      iprot.readFieldEnd()
27117 
    iprot.readStructEnd()
27118 
 
27119 
  def write(self, oprot):
27120 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27121 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27122 
      return
27123 
    oprot.writeStructBegin('getReceivedAtStoreOrders_result')
27124 
    if self.success is not None:
27125 
      oprot.writeFieldBegin('success', TType.LIST, 0)
27126 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 27127 
      for iter648 in self.success:
27128 
        iter648.write(oprot)
5553 rajveer 27129 
      oprot.writeListEnd()
27130 
      oprot.writeFieldEnd()
27131 
    oprot.writeFieldStop()
27132 
    oprot.writeStructEnd()
27133 
 
27134 
  def validate(self):
27135 
    return
27136 
 
27137 
 
27138 
  def __repr__(self):
27139 
    L = ['%s=%r' % (key, value)
27140 
      for key, value in self.__dict__.iteritems()]
27141 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27142 
 
27143 
  def __eq__(self, other):
27144 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27145 
 
27146 
  def __ne__(self, other):
27147 
    return not (self == other)
5593 mandeep.dh 27148 
 
5713 rajveer 27149 
class getOrdersCollectionAtStore_args:
27150 
  """
27151 
  Attributes:
27152 
   - storeId
27153 
   - fromDate
27154 
   - toDate
27155 
   - onlyCod
27156 
  """
27157 
 
27158 
  thrift_spec = (
27159 
    None, # 0
27160 
    (1, TType.I64, 'storeId', None, None, ), # 1
27161 
    (2, TType.I64, 'fromDate', None, None, ), # 2
27162 
    (3, TType.I64, 'toDate', None, None, ), # 3
27163 
    (4, TType.BOOL, 'onlyCod', None, None, ), # 4
27164 
  )
27165 
 
27166 
  def __init__(self, storeId=None, fromDate=None, toDate=None, onlyCod=None,):
27167 
    self.storeId = storeId
27168 
    self.fromDate = fromDate
27169 
    self.toDate = toDate
27170 
    self.onlyCod = onlyCod
27171 
 
27172 
  def read(self, iprot):
27173 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27174 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27175 
      return
27176 
    iprot.readStructBegin()
27177 
    while True:
27178 
      (fname, ftype, fid) = iprot.readFieldBegin()
27179 
      if ftype == TType.STOP:
27180 
        break
27181 
      if fid == 1:
27182 
        if ftype == TType.I64:
27183 
          self.storeId = iprot.readI64();
27184 
        else:
27185 
          iprot.skip(ftype)
27186 
      elif fid == 2:
27187 
        if ftype == TType.I64:
27188 
          self.fromDate = iprot.readI64();
27189 
        else:
27190 
          iprot.skip(ftype)
27191 
      elif fid == 3:
27192 
        if ftype == TType.I64:
27193 
          self.toDate = iprot.readI64();
27194 
        else:
27195 
          iprot.skip(ftype)
27196 
      elif fid == 4:
27197 
        if ftype == TType.BOOL:
27198 
          self.onlyCod = iprot.readBool();
27199 
        else:
27200 
          iprot.skip(ftype)
27201 
      else:
27202 
        iprot.skip(ftype)
27203 
      iprot.readFieldEnd()
27204 
    iprot.readStructEnd()
27205 
 
27206 
  def write(self, oprot):
27207 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27208 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27209 
      return
27210 
    oprot.writeStructBegin('getOrdersCollectionAtStore_args')
27211 
    if self.storeId is not None:
27212 
      oprot.writeFieldBegin('storeId', TType.I64, 1)
27213 
      oprot.writeI64(self.storeId)
27214 
      oprot.writeFieldEnd()
27215 
    if self.fromDate is not None:
27216 
      oprot.writeFieldBegin('fromDate', TType.I64, 2)
27217 
      oprot.writeI64(self.fromDate)
27218 
      oprot.writeFieldEnd()
27219 
    if self.toDate is not None:
27220 
      oprot.writeFieldBegin('toDate', TType.I64, 3)
27221 
      oprot.writeI64(self.toDate)
27222 
      oprot.writeFieldEnd()
27223 
    if self.onlyCod is not None:
27224 
      oprot.writeFieldBegin('onlyCod', TType.BOOL, 4)
27225 
      oprot.writeBool(self.onlyCod)
27226 
      oprot.writeFieldEnd()
27227 
    oprot.writeFieldStop()
27228 
    oprot.writeStructEnd()
27229 
 
27230 
  def validate(self):
27231 
    return
27232 
 
27233 
 
27234 
  def __repr__(self):
27235 
    L = ['%s=%r' % (key, value)
27236 
      for key, value in self.__dict__.iteritems()]
27237 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27238 
 
27239 
  def __eq__(self, other):
27240 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27241 
 
27242 
  def __ne__(self, other):
27243 
    return not (self == other)
27244 
 
27245 
class getOrdersCollectionAtStore_result:
27246 
  """
27247 
  Attributes:
27248 
   - success
27249 
  """
27250 
 
27251 
  thrift_spec = (
27252 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
27253 
  )
27254 
 
27255 
  def __init__(self, success=None,):
27256 
    self.success = success
27257 
 
27258 
  def read(self, iprot):
27259 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27260 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27261 
      return
27262 
    iprot.readStructBegin()
27263 
    while True:
27264 
      (fname, ftype, fid) = iprot.readFieldBegin()
27265 
      if ftype == TType.STOP:
27266 
        break
27267 
      if fid == 0:
27268 
        if ftype == TType.LIST:
27269 
          self.success = []
6188 rajveer 27270 
          (_etype652, _size649) = iprot.readListBegin()
27271 
          for _i653 in xrange(_size649):
27272 
            _elem654 = Order()
27273 
            _elem654.read(iprot)
27274 
            self.success.append(_elem654)
5713 rajveer 27275 
          iprot.readListEnd()
27276 
        else:
27277 
          iprot.skip(ftype)
27278 
      else:
27279 
        iprot.skip(ftype)
27280 
      iprot.readFieldEnd()
27281 
    iprot.readStructEnd()
27282 
 
27283 
  def write(self, oprot):
27284 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27285 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27286 
      return
27287 
    oprot.writeStructBegin('getOrdersCollectionAtStore_result')
27288 
    if self.success is not None:
27289 
      oprot.writeFieldBegin('success', TType.LIST, 0)
27290 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 27291 
      for iter655 in self.success:
27292 
        iter655.write(oprot)
5713 rajveer 27293 
      oprot.writeListEnd()
27294 
      oprot.writeFieldEnd()
27295 
    oprot.writeFieldStop()
27296 
    oprot.writeStructEnd()
27297 
 
27298 
  def validate(self):
27299 
    return
27300 
 
27301 
 
27302 
  def __repr__(self):
27303 
    L = ['%s=%r' % (key, value)
27304 
      for key, value in self.__dict__.iteritems()]
27305 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27306 
 
27307 
  def __eq__(self, other):
27308 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27309 
 
27310 
  def __ne__(self, other):
27311 
    return not (self == other)
27312 
 
5833 rajveer 27313 
class getOrderAttributeValue_args:
27314 
  """
27315 
  Attributes:
27316 
   - orderId
27317 
   - attributeName
27318 
  """
27319 
 
27320 
  thrift_spec = None
27321 
  def __init__(self, orderId=None, attributeName=None,):
27322 
    self.orderId = orderId
27323 
    self.attributeName = attributeName
27324 
 
27325 
  def read(self, iprot):
27326 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27327 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27328 
      return
27329 
    iprot.readStructBegin()
27330 
    while True:
27331 
      (fname, ftype, fid) = iprot.readFieldBegin()
27332 
      if ftype == TType.STOP:
27333 
        break
27334 
      if fid == 1:
27335 
        if ftype == TType.I64:
27336 
          self.orderId = iprot.readI64();
27337 
        else:
27338 
          iprot.skip(ftype)
27339 
      elif fid == -1:
27340 
        if ftype == TType.STRING:
27341 
          self.attributeName = iprot.readString();
27342 
        else:
27343 
          iprot.skip(ftype)
27344 
      else:
27345 
        iprot.skip(ftype)
27346 
      iprot.readFieldEnd()
27347 
    iprot.readStructEnd()
27348 
 
27349 
  def write(self, oprot):
27350 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27351 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27352 
      return
27353 
    oprot.writeStructBegin('getOrderAttributeValue_args')
27354 
    if self.attributeName is not None:
27355 
      oprot.writeFieldBegin('attributeName', TType.STRING, -1)
27356 
      oprot.writeString(self.attributeName)
27357 
      oprot.writeFieldEnd()
27358 
    if self.orderId is not None:
27359 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
27360 
      oprot.writeI64(self.orderId)
27361 
      oprot.writeFieldEnd()
27362 
    oprot.writeFieldStop()
27363 
    oprot.writeStructEnd()
27364 
 
27365 
  def validate(self):
27366 
    return
27367 
 
27368 
 
27369 
  def __repr__(self):
27370 
    L = ['%s=%r' % (key, value)
27371 
      for key, value in self.__dict__.iteritems()]
27372 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27373 
 
27374 
  def __eq__(self, other):
27375 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27376 
 
27377 
  def __ne__(self, other):
27378 
    return not (self == other)
27379 
 
27380 
class getOrderAttributeValue_result:
27381 
  """
27382 
  Attributes:
27383 
   - success
27384 
  """
27385 
 
27386 
  thrift_spec = (
27387 
    (0, TType.STRING, 'success', None, None, ), # 0
27388 
  )
27389 
 
27390 
  def __init__(self, success=None,):
27391 
    self.success = success
27392 
 
27393 
  def read(self, iprot):
27394 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27395 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27396 
      return
27397 
    iprot.readStructBegin()
27398 
    while True:
27399 
      (fname, ftype, fid) = iprot.readFieldBegin()
27400 
      if ftype == TType.STOP:
27401 
        break
27402 
      if fid == 0:
27403 
        if ftype == TType.STRING:
27404 
          self.success = iprot.readString();
27405 
        else:
27406 
          iprot.skip(ftype)
27407 
      else:
27408 
        iprot.skip(ftype)
27409 
      iprot.readFieldEnd()
27410 
    iprot.readStructEnd()
27411 
 
27412 
  def write(self, oprot):
27413 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27414 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27415 
      return
27416 
    oprot.writeStructBegin('getOrderAttributeValue_result')
27417 
    if self.success is not None:
27418 
      oprot.writeFieldBegin('success', TType.STRING, 0)
27419 
      oprot.writeString(self.success)
27420 
      oprot.writeFieldEnd()
27421 
    oprot.writeFieldStop()
27422 
    oprot.writeStructEnd()
27423 
 
27424 
  def validate(self):
27425 
    return
27426 
 
27427 
 
27428 
  def __repr__(self):
27429 
    L = ['%s=%r' % (key, value)
27430 
      for key, value in self.__dict__.iteritems()]
27431 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27432 
 
27433 
  def __eq__(self, other):
27434 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27435 
 
27436 
  def __ne__(self, other):
27437 
    return not (self == other)
27438 
 
6019 rajveer 27439 
class changeJacketNumber_args:
27440 
  """
27441 
  Attributes:
27442 
   - orderId
27443 
   - jacketNumber
27444 
  """
27445 
 
27446 
  thrift_spec = (
27447 
    None, # 0
27448 
    (1, TType.I64, 'orderId', None, None, ), # 1
27449 
    (2, TType.I64, 'jacketNumber', None, None, ), # 2
27450 
  )
27451 
 
27452 
  def __init__(self, orderId=None, jacketNumber=None,):
27453 
    self.orderId = orderId
27454 
    self.jacketNumber = jacketNumber
27455 
 
27456 
  def read(self, iprot):
27457 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27458 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27459 
      return
27460 
    iprot.readStructBegin()
27461 
    while True:
27462 
      (fname, ftype, fid) = iprot.readFieldBegin()
27463 
      if ftype == TType.STOP:
27464 
        break
27465 
      if fid == 1:
27466 
        if ftype == TType.I64:
27467 
          self.orderId = iprot.readI64();
27468 
        else:
27469 
          iprot.skip(ftype)
27470 
      elif fid == 2:
27471 
        if ftype == TType.I64:
27472 
          self.jacketNumber = iprot.readI64();
27473 
        else:
27474 
          iprot.skip(ftype)
27475 
      else:
27476 
        iprot.skip(ftype)
27477 
      iprot.readFieldEnd()
27478 
    iprot.readStructEnd()
27479 
 
27480 
  def write(self, oprot):
27481 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27482 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27483 
      return
27484 
    oprot.writeStructBegin('changeJacketNumber_args')
27485 
    if self.orderId is not None:
27486 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
27487 
      oprot.writeI64(self.orderId)
27488 
      oprot.writeFieldEnd()
27489 
    if self.jacketNumber is not None:
27490 
      oprot.writeFieldBegin('jacketNumber', TType.I64, 2)
27491 
      oprot.writeI64(self.jacketNumber)
27492 
      oprot.writeFieldEnd()
27493 
    oprot.writeFieldStop()
27494 
    oprot.writeStructEnd()
27495 
 
27496 
  def validate(self):
27497 
    return
27498 
 
27499 
 
27500 
  def __repr__(self):
27501 
    L = ['%s=%r' % (key, value)
27502 
      for key, value in self.__dict__.iteritems()]
27503 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27504 
 
27505 
  def __eq__(self, other):
27506 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27507 
 
27508 
  def __ne__(self, other):
27509 
    return not (self == other)
27510 
 
27511 
class changeJacketNumber_result:
27512 
  """
27513 
  Attributes:
27514 
   - success
27515 
  """
27516 
 
27517 
  thrift_spec = (
27518 
    (0, TType.BOOL, 'success', None, None, ), # 0
27519 
  )
27520 
 
27521 
  def __init__(self, success=None,):
27522 
    self.success = success
27523 
 
27524 
  def read(self, iprot):
27525 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27526 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27527 
      return
27528 
    iprot.readStructBegin()
27529 
    while True:
27530 
      (fname, ftype, fid) = iprot.readFieldBegin()
27531 
      if ftype == TType.STOP:
27532 
        break
27533 
      if fid == 0:
27534 
        if ftype == TType.BOOL:
27535 
          self.success = iprot.readBool();
27536 
        else:
27537 
          iprot.skip(ftype)
27538 
      else:
27539 
        iprot.skip(ftype)
27540 
      iprot.readFieldEnd()
27541 
    iprot.readStructEnd()
27542 
 
27543 
  def write(self, oprot):
27544 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27545 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27546 
      return
27547 
    oprot.writeStructBegin('changeJacketNumber_result')
27548 
    if self.success is not None:
27549 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
27550 
      oprot.writeBool(self.success)
27551 
      oprot.writeFieldEnd()
27552 
    oprot.writeFieldStop()
27553 
    oprot.writeStructEnd()
27554 
 
27555 
  def validate(self):
27556 
    return
27557 
 
27558 
 
27559 
  def __repr__(self):
27560 
    L = ['%s=%r' % (key, value)
27561 
      for key, value in self.__dict__.iteritems()]
27562 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27563 
 
27564 
  def __eq__(self, other):
27565 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27566 
 
27567 
  def __ne__(self, other):
27568 
    return not (self == other)
27569 
 
27570 
class markOrderAsRtoInTransit_args:
27571 
  """
27572 
  Attributes:
27573 
   - orderId
27574 
  """
27575 
 
27576 
  thrift_spec = (
27577 
    None, # 0
27578 
    (1, TType.I64, 'orderId', None, None, ), # 1
27579 
  )
27580 
 
27581 
  def __init__(self, orderId=None,):
27582 
    self.orderId = orderId
27583 
 
27584 
  def read(self, iprot):
27585 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27586 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27587 
      return
27588 
    iprot.readStructBegin()
27589 
    while True:
27590 
      (fname, ftype, fid) = iprot.readFieldBegin()
27591 
      if ftype == TType.STOP:
27592 
        break
27593 
      if fid == 1:
27594 
        if ftype == TType.I64:
27595 
          self.orderId = iprot.readI64();
27596 
        else:
27597 
          iprot.skip(ftype)
27598 
      else:
27599 
        iprot.skip(ftype)
27600 
      iprot.readFieldEnd()
27601 
    iprot.readStructEnd()
27602 
 
27603 
  def write(self, oprot):
27604 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27605 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27606 
      return
27607 
    oprot.writeStructBegin('markOrderAsRtoInTransit_args')
27608 
    if self.orderId is not None:
27609 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
27610 
      oprot.writeI64(self.orderId)
27611 
      oprot.writeFieldEnd()
27612 
    oprot.writeFieldStop()
27613 
    oprot.writeStructEnd()
27614 
 
27615 
  def validate(self):
27616 
    return
27617 
 
27618 
 
27619 
  def __repr__(self):
27620 
    L = ['%s=%r' % (key, value)
27621 
      for key, value in self.__dict__.iteritems()]
27622 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27623 
 
27624 
  def __eq__(self, other):
27625 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27626 
 
27627 
  def __ne__(self, other):
27628 
    return not (self == other)
27629 
 
27630 
class markOrderAsRtoInTransit_result:
27631 
  """
27632 
  Attributes:
27633 
   - success
27634 
  """
27635 
 
27636 
  thrift_spec = (
27637 
    (0, TType.BOOL, 'success', None, None, ), # 0
27638 
  )
27639 
 
27640 
  def __init__(self, success=None,):
27641 
    self.success = success
27642 
 
27643 
  def read(self, iprot):
27644 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27645 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27646 
      return
27647 
    iprot.readStructBegin()
27648 
    while True:
27649 
      (fname, ftype, fid) = iprot.readFieldBegin()
27650 
      if ftype == TType.STOP:
27651 
        break
27652 
      if fid == 0:
27653 
        if ftype == TType.BOOL:
27654 
          self.success = iprot.readBool();
27655 
        else:
27656 
          iprot.skip(ftype)
27657 
      else:
27658 
        iprot.skip(ftype)
27659 
      iprot.readFieldEnd()
27660 
    iprot.readStructEnd()
27661 
 
27662 
  def write(self, oprot):
27663 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27664 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27665 
      return
27666 
    oprot.writeStructBegin('markOrderAsRtoInTransit_result')
27667 
    if self.success is not None:
27668 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
27669 
      oprot.writeBool(self.success)
27670 
      oprot.writeFieldEnd()
27671 
    oprot.writeFieldStop()
27672 
    oprot.writeStructEnd()
27673 
 
27674 
  def validate(self):
27675 
    return
27676 
 
27677 
 
27678 
  def __repr__(self):
27679 
    L = ['%s=%r' % (key, value)
27680 
      for key, value in self.__dict__.iteritems()]
27681 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27682 
 
27683 
  def __eq__(self, other):
27684 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27685 
 
27686 
  def __ne__(self, other):
27687 
    return not (self == other)
27688 
 
5593 mandeep.dh 27689 
class acceptOrderForItem_args:
27690 
  """
27691 
  Attributes:
27692 
   - itemId
27693 
   - quantity
27694 
   - fulfilmentWarehouseId
27695 
   - billingWarehouseId
27696 
  """
27697 
 
27698 
  thrift_spec = (
27699 
    None, # 0
27700 
    (1, TType.I64, 'itemId', None, None, ), # 1
27701 
    (2, TType.I64, 'quantity', None, None, ), # 2
27702 
    (3, TType.I64, 'fulfilmentWarehouseId', None, None, ), # 3
27703 
    (4, TType.I64, 'billingWarehouseId', None, None, ), # 4
27704 
  )
27705 
 
27706 
  def __init__(self, itemId=None, quantity=None, fulfilmentWarehouseId=None, billingWarehouseId=None,):
27707 
    self.itemId = itemId
27708 
    self.quantity = quantity
27709 
    self.fulfilmentWarehouseId = fulfilmentWarehouseId
27710 
    self.billingWarehouseId = billingWarehouseId
27711 
 
27712 
  def read(self, iprot):
27713 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27714 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27715 
      return
27716 
    iprot.readStructBegin()
27717 
    while True:
27718 
      (fname, ftype, fid) = iprot.readFieldBegin()
27719 
      if ftype == TType.STOP:
27720 
        break
27721 
      if fid == 1:
27722 
        if ftype == TType.I64:
27723 
          self.itemId = iprot.readI64();
27724 
        else:
27725 
          iprot.skip(ftype)
27726 
      elif fid == 2:
27727 
        if ftype == TType.I64:
27728 
          self.quantity = iprot.readI64();
27729 
        else:
27730 
          iprot.skip(ftype)
27731 
      elif fid == 3:
27732 
        if ftype == TType.I64:
27733 
          self.fulfilmentWarehouseId = iprot.readI64();
27734 
        else:
27735 
          iprot.skip(ftype)
27736 
      elif fid == 4:
27737 
        if ftype == TType.I64:
27738 
          self.billingWarehouseId = iprot.readI64();
27739 
        else:
27740 
          iprot.skip(ftype)
27741 
      else:
27742 
        iprot.skip(ftype)
27743 
      iprot.readFieldEnd()
27744 
    iprot.readStructEnd()
27745 
 
27746 
  def write(self, oprot):
27747 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27748 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27749 
      return
27750 
    oprot.writeStructBegin('acceptOrderForItem_args')
27751 
    if self.itemId is not None:
27752 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
27753 
      oprot.writeI64(self.itemId)
27754 
      oprot.writeFieldEnd()
27755 
    if self.quantity is not None:
27756 
      oprot.writeFieldBegin('quantity', TType.I64, 2)
27757 
      oprot.writeI64(self.quantity)
27758 
      oprot.writeFieldEnd()
27759 
    if self.fulfilmentWarehouseId is not None:
27760 
      oprot.writeFieldBegin('fulfilmentWarehouseId', TType.I64, 3)
27761 
      oprot.writeI64(self.fulfilmentWarehouseId)
27762 
      oprot.writeFieldEnd()
27763 
    if self.billingWarehouseId is not None:
27764 
      oprot.writeFieldBegin('billingWarehouseId', TType.I64, 4)
27765 
      oprot.writeI64(self.billingWarehouseId)
27766 
      oprot.writeFieldEnd()
27767 
    oprot.writeFieldStop()
27768 
    oprot.writeStructEnd()
27769 
 
27770 
  def validate(self):
27771 
    return
27772 
 
27773 
 
27774 
  def __repr__(self):
27775 
    L = ['%s=%r' % (key, value)
27776 
      for key, value in self.__dict__.iteritems()]
27777 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27778 
 
27779 
  def __eq__(self, other):
27780 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27781 
 
27782 
  def __ne__(self, other):
27783 
    return not (self == other)
27784 
 
27785 
class acceptOrderForItem_result:
27786 
 
27787 
  thrift_spec = (
27788 
  )
27789 
 
27790 
  def read(self, iprot):
27791 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27792 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27793 
      return
27794 
    iprot.readStructBegin()
27795 
    while True:
27796 
      (fname, ftype, fid) = iprot.readFieldBegin()
27797 
      if ftype == TType.STOP:
27798 
        break
27799 
      else:
27800 
        iprot.skip(ftype)
27801 
      iprot.readFieldEnd()
27802 
    iprot.readStructEnd()
27803 
 
27804 
  def write(self, oprot):
27805 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27806 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27807 
      return
27808 
    oprot.writeStructBegin('acceptOrderForItem_result')
27809 
    oprot.writeFieldStop()
27810 
    oprot.writeStructEnd()
27811 
 
27812 
  def validate(self):
27813 
    return
27814 
 
27815 
 
27816 
  def __repr__(self):
27817 
    L = ['%s=%r' % (key, value)
27818 
      for key, value in self.__dict__.iteritems()]
27819 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27820 
 
27821 
  def __eq__(self, other):
27822 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27823 
 
27824 
  def __ne__(self, other):
27825 
    return not (self == other)
6000 mandeep.dh 27826 
 
27827 
class createRechargeOrder_args:
27828 
  """
27829 
  Attributes:
27830 
   - rechargeOrder
27831 
  """
27832 
 
27833 
  thrift_spec = (
27834 
    None, # 0
27835 
    (1, TType.STRUCT, 'rechargeOrder', (RechargeOrder, RechargeOrder.thrift_spec), None, ), # 1
27836 
  )
27837 
 
27838 
  def __init__(self, rechargeOrder=None,):
27839 
    self.rechargeOrder = rechargeOrder
27840 
 
27841 
  def read(self, iprot):
27842 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27843 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27844 
      return
27845 
    iprot.readStructBegin()
27846 
    while True:
27847 
      (fname, ftype, fid) = iprot.readFieldBegin()
27848 
      if ftype == TType.STOP:
27849 
        break
27850 
      if fid == 1:
27851 
        if ftype == TType.STRUCT:
27852 
          self.rechargeOrder = RechargeOrder()
27853 
          self.rechargeOrder.read(iprot)
27854 
        else:
27855 
          iprot.skip(ftype)
27856 
      else:
27857 
        iprot.skip(ftype)
27858 
      iprot.readFieldEnd()
27859 
    iprot.readStructEnd()
27860 
 
27861 
  def write(self, oprot):
27862 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27863 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27864 
      return
27865 
    oprot.writeStructBegin('createRechargeOrder_args')
27866 
    if self.rechargeOrder is not None:
27867 
      oprot.writeFieldBegin('rechargeOrder', TType.STRUCT, 1)
27868 
      self.rechargeOrder.write(oprot)
27869 
      oprot.writeFieldEnd()
27870 
    oprot.writeFieldStop()
27871 
    oprot.writeStructEnd()
27872 
 
27873 
  def validate(self):
27874 
    return
27875 
 
27876 
 
27877 
  def __repr__(self):
27878 
    L = ['%s=%r' % (key, value)
27879 
      for key, value in self.__dict__.iteritems()]
27880 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27881 
 
27882 
  def __eq__(self, other):
27883 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27884 
 
27885 
  def __ne__(self, other):
27886 
    return not (self == other)
27887 
 
27888 
class createRechargeOrder_result:
27889 
  """
27890 
  Attributes:
27891 
   - success
27892 
   - ex
27893 
  """
27894 
 
27895 
  thrift_spec = (
27896 
    (0, TType.STRUCT, 'success', (RechargeOrder, RechargeOrder.thrift_spec), None, ), # 0
27897 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
27898 
  )
27899 
 
27900 
  def __init__(self, success=None, ex=None,):
27901 
    self.success = success
27902 
    self.ex = ex
27903 
 
27904 
  def read(self, iprot):
27905 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27906 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27907 
      return
27908 
    iprot.readStructBegin()
27909 
    while True:
27910 
      (fname, ftype, fid) = iprot.readFieldBegin()
27911 
      if ftype == TType.STOP:
27912 
        break
27913 
      if fid == 0:
27914 
        if ftype == TType.STRUCT:
27915 
          self.success = RechargeOrder()
27916 
          self.success.read(iprot)
27917 
        else:
27918 
          iprot.skip(ftype)
27919 
      elif fid == 1:
27920 
        if ftype == TType.STRUCT:
27921 
          self.ex = TransactionServiceException()
27922 
          self.ex.read(iprot)
27923 
        else:
27924 
          iprot.skip(ftype)
27925 
      else:
27926 
        iprot.skip(ftype)
27927 
      iprot.readFieldEnd()
27928 
    iprot.readStructEnd()
27929 
 
27930 
  def write(self, oprot):
27931 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27932 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27933 
      return
27934 
    oprot.writeStructBegin('createRechargeOrder_result')
27935 
    if self.success is not None:
27936 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
27937 
      self.success.write(oprot)
27938 
      oprot.writeFieldEnd()
27939 
    if self.ex is not None:
27940 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
27941 
      self.ex.write(oprot)
27942 
      oprot.writeFieldEnd()
27943 
    oprot.writeFieldStop()
27944 
    oprot.writeStructEnd()
27945 
 
27946 
  def validate(self):
27947 
    return
27948 
 
27949 
 
27950 
  def __repr__(self):
27951 
    L = ['%s=%r' % (key, value)
27952 
      for key, value in self.__dict__.iteritems()]
27953 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27954 
 
27955 
  def __eq__(self, other):
27956 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27957 
 
27958 
  def __ne__(self, other):
27959 
    return not (self == other)
27960 
 
6031 rajveer 27961 
class getRechargeOrder_args:
27962 
  """
27963 
  Attributes:
27964 
   - rechargeRrderId
27965 
  """
27966 
 
27967 
  thrift_spec = (
27968 
    None, # 0
27969 
    (1, TType.I64, 'rechargeRrderId', None, None, ), # 1
27970 
  )
27971 
 
27972 
  def __init__(self, rechargeRrderId=None,):
27973 
    self.rechargeRrderId = rechargeRrderId
27974 
 
27975 
  def read(self, iprot):
27976 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27977 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27978 
      return
27979 
    iprot.readStructBegin()
27980 
    while True:
27981 
      (fname, ftype, fid) = iprot.readFieldBegin()
27982 
      if ftype == TType.STOP:
27983 
        break
27984 
      if fid == 1:
27985 
        if ftype == TType.I64:
27986 
          self.rechargeRrderId = iprot.readI64();
27987 
        else:
27988 
          iprot.skip(ftype)
27989 
      else:
27990 
        iprot.skip(ftype)
27991 
      iprot.readFieldEnd()
27992 
    iprot.readStructEnd()
27993 
 
27994 
  def write(self, oprot):
27995 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27996 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27997 
      return
27998 
    oprot.writeStructBegin('getRechargeOrder_args')
27999 
    if self.rechargeRrderId is not None:
28000 
      oprot.writeFieldBegin('rechargeRrderId', TType.I64, 1)
28001 
      oprot.writeI64(self.rechargeRrderId)
28002 
      oprot.writeFieldEnd()
28003 
    oprot.writeFieldStop()
28004 
    oprot.writeStructEnd()
28005 
 
28006 
  def validate(self):
28007 
    return
28008 
 
28009 
 
28010 
  def __repr__(self):
28011 
    L = ['%s=%r' % (key, value)
28012 
      for key, value in self.__dict__.iteritems()]
28013 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28014 
 
28015 
  def __eq__(self, other):
28016 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28017 
 
28018 
  def __ne__(self, other):
28019 
    return not (self == other)
28020 
 
28021 
class getRechargeOrder_result:
28022 
  """
28023 
  Attributes:
28024 
   - success
28025 
   - ex
28026 
  """
28027 
 
28028 
  thrift_spec = (
28029 
    (0, TType.STRUCT, 'success', (RechargeOrder, RechargeOrder.thrift_spec), None, ), # 0
28030 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
28031 
  )
28032 
 
28033 
  def __init__(self, success=None, ex=None,):
28034 
    self.success = success
28035 
    self.ex = ex
28036 
 
28037 
  def read(self, iprot):
28038 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28039 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28040 
      return
28041 
    iprot.readStructBegin()
28042 
    while True:
28043 
      (fname, ftype, fid) = iprot.readFieldBegin()
28044 
      if ftype == TType.STOP:
28045 
        break
28046 
      if fid == 0:
28047 
        if ftype == TType.STRUCT:
28048 
          self.success = RechargeOrder()
28049 
          self.success.read(iprot)
28050 
        else:
28051 
          iprot.skip(ftype)
28052 
      elif fid == 1:
28053 
        if ftype == TType.STRUCT:
28054 
          self.ex = TransactionServiceException()
28055 
          self.ex.read(iprot)
28056 
        else:
28057 
          iprot.skip(ftype)
28058 
      else:
28059 
        iprot.skip(ftype)
28060 
      iprot.readFieldEnd()
28061 
    iprot.readStructEnd()
28062 
 
28063 
  def write(self, oprot):
28064 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28065 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28066 
      return
28067 
    oprot.writeStructBegin('getRechargeOrder_result')
28068 
    if self.success is not None:
28069 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
28070 
      self.success.write(oprot)
28071 
      oprot.writeFieldEnd()
28072 
    if self.ex is not None:
28073 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
28074 
      self.ex.write(oprot)
28075 
      oprot.writeFieldEnd()
28076 
    oprot.writeFieldStop()
28077 
    oprot.writeStructEnd()
28078 
 
28079 
  def validate(self):
28080 
    return
28081 
 
28082 
 
28083 
  def __repr__(self):
28084 
    L = ['%s=%r' % (key, value)
28085 
      for key, value in self.__dict__.iteritems()]
28086 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28087 
 
28088 
  def __eq__(self, other):
28089 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28090 
 
28091 
  def __ne__(self, other):
28092 
    return not (self == other)
28093 
 
28094 
class getRechargeOrders_args:
28095 
  """
28096 
  Attributes:
28097 
   - userId
28098 
  """
28099 
 
28100 
  thrift_spec = (
28101 
    None, # 0
28102 
    (1, TType.I64, 'userId', None, None, ), # 1
28103 
  )
28104 
 
28105 
  def __init__(self, userId=None,):
28106 
    self.userId = userId
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.userId = iprot.readI64();
28120 
        else:
28121 
          iprot.skip(ftype)
28122 
      else:
28123 
        iprot.skip(ftype)
28124 
      iprot.readFieldEnd()
28125 
    iprot.readStructEnd()
28126 
 
28127 
  def write(self, oprot):
28128 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28129 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28130 
      return
28131 
    oprot.writeStructBegin('getRechargeOrders_args')
28132 
    if self.userId is not None:
28133 
      oprot.writeFieldBegin('userId', TType.I64, 1)
28134 
      oprot.writeI64(self.userId)
28135 
      oprot.writeFieldEnd()
28136 
    oprot.writeFieldStop()
28137 
    oprot.writeStructEnd()
28138 
 
28139 
  def validate(self):
28140 
    return
28141 
 
28142 
 
28143 
  def __repr__(self):
28144 
    L = ['%s=%r' % (key, value)
28145 
      for key, value in self.__dict__.iteritems()]
28146 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28147 
 
28148 
  def __eq__(self, other):
28149 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28150 
 
28151 
  def __ne__(self, other):
28152 
    return not (self == other)
28153 
 
28154 
class getRechargeOrders_result:
28155 
  """
28156 
  Attributes:
28157 
   - success
28158 
  """
28159 
 
28160 
  thrift_spec = (
28161 
    (0, TType.LIST, 'success', (TType.STRUCT,(RechargeOrder, RechargeOrder.thrift_spec)), None, ), # 0
28162 
  )
28163 
 
28164 
  def __init__(self, success=None,):
28165 
    self.success = success
28166 
 
28167 
  def read(self, iprot):
28168 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28169 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28170 
      return
28171 
    iprot.readStructBegin()
28172 
    while True:
28173 
      (fname, ftype, fid) = iprot.readFieldBegin()
28174 
      if ftype == TType.STOP:
28175 
        break
28176 
      if fid == 0:
28177 
        if ftype == TType.LIST:
28178 
          self.success = []
6188 rajveer 28179 
          (_etype659, _size656) = iprot.readListBegin()
28180 
          for _i660 in xrange(_size656):
28181 
            _elem661 = RechargeOrder()
28182 
            _elem661.read(iprot)
28183 
            self.success.append(_elem661)
6031 rajveer 28184 
          iprot.readListEnd()
28185 
        else:
28186 
          iprot.skip(ftype)
28187 
      else:
28188 
        iprot.skip(ftype)
28189 
      iprot.readFieldEnd()
28190 
    iprot.readStructEnd()
28191 
 
28192 
  def write(self, oprot):
28193 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28194 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28195 
      return
28196 
    oprot.writeStructBegin('getRechargeOrders_result')
28197 
    if self.success is not None:
28198 
      oprot.writeFieldBegin('success', TType.LIST, 0)
28199 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 28200 
      for iter662 in self.success:
28201 
        iter662.write(oprot)
6031 rajveer 28202 
      oprot.writeListEnd()
28203 
      oprot.writeFieldEnd()
28204 
    oprot.writeFieldStop()
28205 
    oprot.writeStructEnd()
28206 
 
28207 
  def validate(self):
28208 
    return
28209 
 
28210 
 
28211 
  def __repr__(self):
28212 
    L = ['%s=%r' % (key, value)
28213 
      for key, value in self.__dict__.iteritems()]
28214 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28215 
 
28216 
  def __eq__(self, other):
28217 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28218 
 
28219 
  def __ne__(self, other):
28220 
    return not (self == other)
28221 
 
6000 mandeep.dh 28222 
class updateRechargeOrderStatus_args:
28223 
  """
28224 
  Attributes:
28225 
   - rechargeOrderId
28226 
   - rechargeOrderStatus
28227 
  """
28228 
 
28229 
  thrift_spec = (
28230 
    None, # 0
28231 
    (1, TType.I64, 'rechargeOrderId', None, None, ), # 1
28232 
    (2, TType.I32, 'rechargeOrderStatus', None, None, ), # 2
28233 
  )
28234 
 
28235 
  def __init__(self, rechargeOrderId=None, rechargeOrderStatus=None,):
28236 
    self.rechargeOrderId = rechargeOrderId
28237 
    self.rechargeOrderStatus = rechargeOrderStatus
28238 
 
28239 
  def read(self, iprot):
28240 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28241 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28242 
      return
28243 
    iprot.readStructBegin()
28244 
    while True:
28245 
      (fname, ftype, fid) = iprot.readFieldBegin()
28246 
      if ftype == TType.STOP:
28247 
        break
28248 
      if fid == 1:
28249 
        if ftype == TType.I64:
28250 
          self.rechargeOrderId = iprot.readI64();
28251 
        else:
28252 
          iprot.skip(ftype)
28253 
      elif fid == 2:
28254 
        if ftype == TType.I32:
28255 
          self.rechargeOrderStatus = iprot.readI32();
28256 
        else:
28257 
          iprot.skip(ftype)
28258 
      else:
28259 
        iprot.skip(ftype)
28260 
      iprot.readFieldEnd()
28261 
    iprot.readStructEnd()
28262 
 
28263 
  def write(self, oprot):
28264 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28265 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28266 
      return
28267 
    oprot.writeStructBegin('updateRechargeOrderStatus_args')
28268 
    if self.rechargeOrderId is not None:
28269 
      oprot.writeFieldBegin('rechargeOrderId', TType.I64, 1)
28270 
      oprot.writeI64(self.rechargeOrderId)
28271 
      oprot.writeFieldEnd()
28272 
    if self.rechargeOrderStatus is not None:
28273 
      oprot.writeFieldBegin('rechargeOrderStatus', TType.I32, 2)
28274 
      oprot.writeI32(self.rechargeOrderStatus)
28275 
      oprot.writeFieldEnd()
28276 
    oprot.writeFieldStop()
28277 
    oprot.writeStructEnd()
28278 
 
28279 
  def validate(self):
28280 
    return
28281 
 
28282 
 
28283 
  def __repr__(self):
28284 
    L = ['%s=%r' % (key, value)
28285 
      for key, value in self.__dict__.iteritems()]
28286 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28287 
 
28288 
  def __eq__(self, other):
28289 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28290 
 
28291 
  def __ne__(self, other):
28292 
    return not (self == other)
28293 
 
28294 
class updateRechargeOrderStatus_result:
28295 
  """
28296 
  Attributes:
6031 rajveer 28297 
   - success
6000 mandeep.dh 28298 
   - ex
28299 
  """
28300 
 
28301 
  thrift_spec = (
6031 rajveer 28302 
    (0, TType.BOOL, 'success', None, None, ), # 0
6000 mandeep.dh 28303 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
28304 
  )
28305 
 
6031 rajveer 28306 
  def __init__(self, success=None, ex=None,):
28307 
    self.success = success
6000 mandeep.dh 28308 
    self.ex = ex
28309 
 
28310 
  def read(self, iprot):
28311 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28312 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28313 
      return
28314 
    iprot.readStructBegin()
28315 
    while True:
28316 
      (fname, ftype, fid) = iprot.readFieldBegin()
28317 
      if ftype == TType.STOP:
28318 
        break
6031 rajveer 28319 
      if fid == 0:
28320 
        if ftype == TType.BOOL:
28321 
          self.success = iprot.readBool();
28322 
        else:
28323 
          iprot.skip(ftype)
28324 
      elif fid == 1:
6000 mandeep.dh 28325 
        if ftype == TType.STRUCT:
28326 
          self.ex = TransactionServiceException()
28327 
          self.ex.read(iprot)
28328 
        else:
28329 
          iprot.skip(ftype)
28330 
      else:
28331 
        iprot.skip(ftype)
28332 
      iprot.readFieldEnd()
28333 
    iprot.readStructEnd()
28334 
 
28335 
  def write(self, oprot):
28336 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28337 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28338 
      return
28339 
    oprot.writeStructBegin('updateRechargeOrderStatus_result')
6031 rajveer 28340 
    if self.success is not None:
28341 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
28342 
      oprot.writeBool(self.success)
28343 
      oprot.writeFieldEnd()
6000 mandeep.dh 28344 
    if self.ex is not None:
28345 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
28346 
      self.ex.write(oprot)
28347 
      oprot.writeFieldEnd()
28348 
    oprot.writeFieldStop()
28349 
    oprot.writeStructEnd()
28350 
 
28351 
  def validate(self):
28352 
    return
28353 
 
28354 
 
28355 
  def __repr__(self):
28356 
    L = ['%s=%r' % (key, value)
28357 
      for key, value in self.__dict__.iteritems()]
28358 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28359 
 
28360 
  def __eq__(self, other):
28361 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28362 
 
28363 
  def __ne__(self, other):
28364 
    return not (self == other)
28365 
 
28366 
class activateRechargeTxn_args:
28367 
  """
28368 
  Attributes:
6031 rajveer 28369 
   - rechargeOrderId
6000 mandeep.dh 28370 
  """
28371 
 
28372 
  thrift_spec = (
28373 
    None, # 0
6031 rajveer 28374 
    (1, TType.I64, 'rechargeOrderId', None, None, ), # 1
6000 mandeep.dh 28375 
  )
28376 
 
6031 rajveer 28377 
  def __init__(self, rechargeOrderId=None,):
28378 
    self.rechargeOrderId = rechargeOrderId
6000 mandeep.dh 28379 
 
28380 
  def read(self, iprot):
28381 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28382 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28383 
      return
28384 
    iprot.readStructBegin()
28385 
    while True:
28386 
      (fname, ftype, fid) = iprot.readFieldBegin()
28387 
      if ftype == TType.STOP:
28388 
        break
28389 
      if fid == 1:
6031 rajveer 28390 
        if ftype == TType.I64:
28391 
          self.rechargeOrderId = iprot.readI64();
6000 mandeep.dh 28392 
        else:
28393 
          iprot.skip(ftype)
28394 
      else:
28395 
        iprot.skip(ftype)
28396 
      iprot.readFieldEnd()
28397 
    iprot.readStructEnd()
28398 
 
28399 
  def write(self, oprot):
28400 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28401 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28402 
      return
28403 
    oprot.writeStructBegin('activateRechargeTxn_args')
6031 rajveer 28404 
    if self.rechargeOrderId is not None:
28405 
      oprot.writeFieldBegin('rechargeOrderId', TType.I64, 1)
28406 
      oprot.writeI64(self.rechargeOrderId)
6000 mandeep.dh 28407 
      oprot.writeFieldEnd()
28408 
    oprot.writeFieldStop()
28409 
    oprot.writeStructEnd()
28410 
 
28411 
  def validate(self):
28412 
    return
28413 
 
28414 
 
28415 
  def __repr__(self):
28416 
    L = ['%s=%r' % (key, value)
28417 
      for key, value in self.__dict__.iteritems()]
28418 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28419 
 
28420 
  def __eq__(self, other):
28421 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28422 
 
28423 
  def __ne__(self, other):
28424 
    return not (self == other)
28425 
 
28426 
class activateRechargeTxn_result:
28427 
  """
28428 
  Attributes:
28429 
   - success
28430 
   - ex
28431 
  """
28432 
 
28433 
  thrift_spec = (
6031 rajveer 28434 
    (0, TType.BOOL, 'success', None, None, ), # 0
6000 mandeep.dh 28435 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
28436 
  )
28437 
 
28438 
  def __init__(self, success=None, ex=None,):
28439 
    self.success = success
28440 
    self.ex = ex
28441 
 
28442 
  def read(self, iprot):
28443 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28444 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28445 
      return
28446 
    iprot.readStructBegin()
28447 
    while True:
28448 
      (fname, ftype, fid) = iprot.readFieldBegin()
28449 
      if ftype == TType.STOP:
28450 
        break
28451 
      if fid == 0:
6031 rajveer 28452 
        if ftype == TType.BOOL:
28453 
          self.success = iprot.readBool();
6000 mandeep.dh 28454 
        else:
28455 
          iprot.skip(ftype)
28456 
      elif fid == 1:
28457 
        if ftype == TType.STRUCT:
28458 
          self.ex = TransactionServiceException()
28459 
          self.ex.read(iprot)
28460 
        else:
28461 
          iprot.skip(ftype)
28462 
      else:
28463 
        iprot.skip(ftype)
28464 
      iprot.readFieldEnd()
28465 
    iprot.readStructEnd()
28466 
 
28467 
  def write(self, oprot):
28468 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28469 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28470 
      return
28471 
    oprot.writeStructBegin('activateRechargeTxn_result')
28472 
    if self.success is not None:
6031 rajveer 28473 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
28474 
      oprot.writeBool(self.success)
6000 mandeep.dh 28475 
      oprot.writeFieldEnd()
28476 
    if self.ex is not None:
28477 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
28478 
      self.ex.write(oprot)
28479 
      oprot.writeFieldEnd()
28480 
    oprot.writeFieldStop()
28481 
    oprot.writeStructEnd()
28482 
 
28483 
  def validate(self):
28484 
    return
28485 
 
28486 
 
28487 
  def __repr__(self):
28488 
    L = ['%s=%r' % (key, value)
28489 
      for key, value in self.__dict__.iteritems()]
28490 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28491 
 
28492 
  def __eq__(self, other):
28493 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28494 
 
28495 
  def __ne__(self, other):
28496 
    return not (self == other)
28497 
 
6031 rajveer 28498 
class getUserWallet_args:
6000 mandeep.dh 28499 
  """
28500 
  Attributes:
6031 rajveer 28501 
   - userId
6000 mandeep.dh 28502 
  """
28503 
 
28504 
  thrift_spec = (
28505 
    None, # 0
6031 rajveer 28506 
    (1, TType.I64, 'userId', None, None, ), # 1
6000 mandeep.dh 28507 
  )
28508 
 
6031 rajveer 28509 
  def __init__(self, userId=None,):
28510 
    self.userId = userId
6000 mandeep.dh 28511 
 
28512 
  def read(self, iprot):
28513 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28514 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28515 
      return
28516 
    iprot.readStructBegin()
28517 
    while True:
28518 
      (fname, ftype, fid) = iprot.readFieldBegin()
28519 
      if ftype == TType.STOP:
28520 
        break
28521 
      if fid == 1:
28522 
        if ftype == TType.I64:
6031 rajveer 28523 
          self.userId = iprot.readI64();
6000 mandeep.dh 28524 
        else:
28525 
          iprot.skip(ftype)
28526 
      else:
28527 
        iprot.skip(ftype)
28528 
      iprot.readFieldEnd()
28529 
    iprot.readStructEnd()
28530 
 
28531 
  def write(self, oprot):
28532 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28533 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28534 
      return
6031 rajveer 28535 
    oprot.writeStructBegin('getUserWallet_args')
28536 
    if self.userId is not None:
28537 
      oprot.writeFieldBegin('userId', TType.I64, 1)
28538 
      oprot.writeI64(self.userId)
6000 mandeep.dh 28539 
      oprot.writeFieldEnd()
28540 
    oprot.writeFieldStop()
28541 
    oprot.writeStructEnd()
28542 
 
28543 
  def validate(self):
28544 
    return
28545 
 
28546 
 
28547 
  def __repr__(self):
28548 
    L = ['%s=%r' % (key, value)
28549 
      for key, value in self.__dict__.iteritems()]
28550 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28551 
 
28552 
  def __eq__(self, other):
28553 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28554 
 
28555 
  def __ne__(self, other):
28556 
    return not (self == other)
28557 
 
6031 rajveer 28558 
class getUserWallet_result:
6000 mandeep.dh 28559 
  """
28560 
  Attributes:
28561 
   - success
28562 
  """
28563 
 
28564 
  thrift_spec = (
6031 rajveer 28565 
    (0, TType.STRUCT, 'success', (UserWallet, UserWallet.thrift_spec), None, ), # 0
6000 mandeep.dh 28566 
  )
28567 
 
28568 
  def __init__(self, success=None,):
28569 
    self.success = success
28570 
 
28571 
  def read(self, iprot):
28572 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28573 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28574 
      return
28575 
    iprot.readStructBegin()
28576 
    while True:
28577 
      (fname, ftype, fid) = iprot.readFieldBegin()
28578 
      if ftype == TType.STOP:
28579 
        break
28580 
      if fid == 0:
6031 rajveer 28581 
        if ftype == TType.STRUCT:
28582 
          self.success = UserWallet()
28583 
          self.success.read(iprot)
6000 mandeep.dh 28584 
        else:
28585 
          iprot.skip(ftype)
28586 
      else:
28587 
        iprot.skip(ftype)
28588 
      iprot.readFieldEnd()
28589 
    iprot.readStructEnd()
28590 
 
28591 
  def write(self, oprot):
28592 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28593 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28594 
      return
6031 rajveer 28595 
    oprot.writeStructBegin('getUserWallet_result')
6000 mandeep.dh 28596 
    if self.success is not None:
6031 rajveer 28597 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
28598 
      self.success.write(oprot)
6000 mandeep.dh 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 
 
6031 rajveer 28618 
class getUserWalletHistory_args:
6000 mandeep.dh 28619 
  """
28620 
  Attributes:
6031 rajveer 28621 
   - userId
6000 mandeep.dh 28622 
  """
28623 
 
28624 
  thrift_spec = (
28625 
    None, # 0
6031 rajveer 28626 
    (1, TType.I64, 'userId', None, None, ), # 1
6000 mandeep.dh 28627 
  )
28628 
 
6031 rajveer 28629 
  def __init__(self, userId=None,):
28630 
    self.userId = userId
6000 mandeep.dh 28631 
 
28632 
  def read(self, iprot):
28633 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28634 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28635 
      return
28636 
    iprot.readStructBegin()
28637 
    while True:
28638 
      (fname, ftype, fid) = iprot.readFieldBegin()
28639 
      if ftype == TType.STOP:
28640 
        break
28641 
      if fid == 1:
28642 
        if ftype == TType.I64:
6031 rajveer 28643 
          self.userId = iprot.readI64();
6000 mandeep.dh 28644 
        else:
28645 
          iprot.skip(ftype)
28646 
      else:
28647 
        iprot.skip(ftype)
28648 
      iprot.readFieldEnd()
28649 
    iprot.readStructEnd()
28650 
 
28651 
  def write(self, oprot):
28652 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28653 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28654 
      return
6031 rajveer 28655 
    oprot.writeStructBegin('getUserWalletHistory_args')
28656 
    if self.userId is not None:
28657 
      oprot.writeFieldBegin('userId', TType.I64, 1)
28658 
      oprot.writeI64(self.userId)
6000 mandeep.dh 28659 
      oprot.writeFieldEnd()
28660 
    oprot.writeFieldStop()
28661 
    oprot.writeStructEnd()
28662 
 
28663 
  def validate(self):
28664 
    return
28665 
 
28666 
 
28667 
  def __repr__(self):
28668 
    L = ['%s=%r' % (key, value)
28669 
      for key, value in self.__dict__.iteritems()]
28670 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28671 
 
28672 
  def __eq__(self, other):
28673 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28674 
 
28675 
  def __ne__(self, other):
28676 
    return not (self == other)
28677 
 
6031 rajveer 28678 
class getUserWalletHistory_result:
6000 mandeep.dh 28679 
  """
28680 
  Attributes:
28681 
   - success
28682 
  """
28683 
 
28684 
  thrift_spec = (
6031 rajveer 28685 
    (0, TType.LIST, 'success', (TType.STRUCT,(UserWalletHistory, UserWalletHistory.thrift_spec)), None, ), # 0
6000 mandeep.dh 28686 
  )
28687 
 
28688 
  def __init__(self, success=None,):
28689 
    self.success = success
28690 
 
28691 
  def read(self, iprot):
28692 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28693 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28694 
      return
28695 
    iprot.readStructBegin()
28696 
    while True:
28697 
      (fname, ftype, fid) = iprot.readFieldBegin()
28698 
      if ftype == TType.STOP:
28699 
        break
28700 
      if fid == 0:
28701 
        if ftype == TType.LIST:
28702 
          self.success = []
6188 rajveer 28703 
          (_etype666, _size663) = iprot.readListBegin()
28704 
          for _i667 in xrange(_size663):
28705 
            _elem668 = UserWalletHistory()
28706 
            _elem668.read(iprot)
28707 
            self.success.append(_elem668)
6000 mandeep.dh 28708 
          iprot.readListEnd()
28709 
        else:
28710 
          iprot.skip(ftype)
28711 
      else:
28712 
        iprot.skip(ftype)
28713 
      iprot.readFieldEnd()
28714 
    iprot.readStructEnd()
28715 
 
28716 
  def write(self, oprot):
28717 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28718 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28719 
      return
6031 rajveer 28720 
    oprot.writeStructBegin('getUserWalletHistory_result')
6000 mandeep.dh 28721 
    if self.success is not None:
28722 
      oprot.writeFieldBegin('success', TType.LIST, 0)
28723 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 28724 
      for iter669 in self.success:
28725 
        iter669.write(oprot)
6000 mandeep.dh 28726 
      oprot.writeListEnd()
28727 
      oprot.writeFieldEnd()
28728 
    oprot.writeFieldStop()
28729 
    oprot.writeStructEnd()
28730 
 
28731 
  def validate(self):
28732 
    return
28733 
 
28734 
 
28735 
  def __repr__(self):
28736 
    L = ['%s=%r' % (key, value)
28737 
      for key, value in self.__dict__.iteritems()]
28738 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28739 
 
28740 
  def __eq__(self, other):
28741 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28742 
 
28743 
  def __ne__(self, other):
28744 
    return not (self == other)
6048 rajveer 28745 
 
6050 anupam.sin 28746 
class getRechargeOrdersForTransaction_args:
28747 
  """
28748 
  Attributes:
28749 
   - txnId
28750 
  """
28751 
 
28752 
  thrift_spec = (
28753 
    None, # 0
28754 
    (1, TType.I64, 'txnId', None, None, ), # 1
28755 
  )
28756 
 
28757 
  def __init__(self, txnId=None,):
28758 
    self.txnId = txnId
28759 
 
28760 
  def read(self, iprot):
28761 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28762 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28763 
      return
28764 
    iprot.readStructBegin()
28765 
    while True:
28766 
      (fname, ftype, fid) = iprot.readFieldBegin()
28767 
      if ftype == TType.STOP:
28768 
        break
28769 
      if fid == 1:
28770 
        if ftype == TType.I64:
28771 
          self.txnId = iprot.readI64();
28772 
        else:
28773 
          iprot.skip(ftype)
28774 
      else:
28775 
        iprot.skip(ftype)
28776 
      iprot.readFieldEnd()
28777 
    iprot.readStructEnd()
28778 
 
28779 
  def write(self, oprot):
28780 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28781 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28782 
      return
28783 
    oprot.writeStructBegin('getRechargeOrdersForTransaction_args')
28784 
    if self.txnId is not None:
28785 
      oprot.writeFieldBegin('txnId', TType.I64, 1)
28786 
      oprot.writeI64(self.txnId)
28787 
      oprot.writeFieldEnd()
28788 
    oprot.writeFieldStop()
28789 
    oprot.writeStructEnd()
28790 
 
28791 
  def validate(self):
28792 
    return
28793 
 
28794 
 
28795 
  def __repr__(self):
28796 
    L = ['%s=%r' % (key, value)
28797 
      for key, value in self.__dict__.iteritems()]
28798 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28799 
 
28800 
  def __eq__(self, other):
28801 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28802 
 
28803 
  def __ne__(self, other):
28804 
    return not (self == other)
28805 
 
28806 
class getRechargeOrdersForTransaction_result:
28807 
  """
28808 
  Attributes:
28809 
   - success
28810 
   - ex
28811 
  """
28812 
 
28813 
  thrift_spec = (
28814 
    (0, TType.STRUCT, 'success', (RechargeOrder, RechargeOrder.thrift_spec), None, ), # 0
28815 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
28816 
  )
28817 
 
28818 
  def __init__(self, success=None, ex=None,):
28819 
    self.success = success
28820 
    self.ex = ex
28821 
 
28822 
  def read(self, iprot):
28823 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28824 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28825 
      return
28826 
    iprot.readStructBegin()
28827 
    while True:
28828 
      (fname, ftype, fid) = iprot.readFieldBegin()
28829 
      if ftype == TType.STOP:
28830 
        break
28831 
      if fid == 0:
28832 
        if ftype == TType.STRUCT:
28833 
          self.success = RechargeOrder()
28834 
          self.success.read(iprot)
28835 
        else:
28836 
          iprot.skip(ftype)
28837 
      elif fid == 1:
28838 
        if ftype == TType.STRUCT:
28839 
          self.ex = TransactionServiceException()
28840 
          self.ex.read(iprot)
28841 
        else:
28842 
          iprot.skip(ftype)
28843 
      else:
28844 
        iprot.skip(ftype)
28845 
      iprot.readFieldEnd()
28846 
    iprot.readStructEnd()
28847 
 
28848 
  def write(self, oprot):
28849 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28850 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28851 
      return
28852 
    oprot.writeStructBegin('getRechargeOrdersForTransaction_result')
28853 
    if self.success is not None:
28854 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
28855 
      self.success.write(oprot)
28856 
      oprot.writeFieldEnd()
28857 
    if self.ex is not None:
28858 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
28859 
      self.ex.write(oprot)
28860 
      oprot.writeFieldEnd()
28861 
    oprot.writeFieldStop()
28862 
    oprot.writeStructEnd()
28863 
 
28864 
  def validate(self):
28865 
    return
28866 
 
28867 
 
28868 
  def __repr__(self):
28869 
    L = ['%s=%r' % (key, value)
28870 
      for key, value in self.__dict__.iteritems()]
28871 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28872 
 
28873 
  def __eq__(self, other):
28874 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28875 
 
28876 
  def __ne__(self, other):
28877 
    return not (self == other)
28878 
 
6048 rajveer 28879 
class getServiceProviders_args:
28880 
  """
28881 
  Attributes:
28882 
   - rechargeType
6206 rajveer 28883 
   - onlyActive
6048 rajveer 28884 
  """
28885 
 
28886 
  thrift_spec = (
28887 
    None, # 0
28888 
    (1, TType.I32, 'rechargeType', None, None, ), # 1
6206 rajveer 28889 
    (2, TType.BOOL, 'onlyActive', None, None, ), # 2
6048 rajveer 28890 
  )
28891 
 
6206 rajveer 28892 
  def __init__(self, rechargeType=None, onlyActive=None,):
6048 rajveer 28893 
    self.rechargeType = rechargeType
6206 rajveer 28894 
    self.onlyActive = onlyActive
6048 rajveer 28895 
 
28896 
  def read(self, iprot):
28897 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28898 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28899 
      return
28900 
    iprot.readStructBegin()
28901 
    while True:
28902 
      (fname, ftype, fid) = iprot.readFieldBegin()
28903 
      if ftype == TType.STOP:
28904 
        break
28905 
      if fid == 1:
28906 
        if ftype == TType.I32:
28907 
          self.rechargeType = iprot.readI32();
28908 
        else:
28909 
          iprot.skip(ftype)
6206 rajveer 28910 
      elif fid == 2:
28911 
        if ftype == TType.BOOL:
28912 
          self.onlyActive = iprot.readBool();
28913 
        else:
28914 
          iprot.skip(ftype)
6048 rajveer 28915 
      else:
28916 
        iprot.skip(ftype)
28917 
      iprot.readFieldEnd()
28918 
    iprot.readStructEnd()
28919 
 
28920 
  def write(self, oprot):
28921 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28922 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28923 
      return
28924 
    oprot.writeStructBegin('getServiceProviders_args')
28925 
    if self.rechargeType is not None:
28926 
      oprot.writeFieldBegin('rechargeType', TType.I32, 1)
28927 
      oprot.writeI32(self.rechargeType)
28928 
      oprot.writeFieldEnd()
6206 rajveer 28929 
    if self.onlyActive is not None:
28930 
      oprot.writeFieldBegin('onlyActive', TType.BOOL, 2)
28931 
      oprot.writeBool(self.onlyActive)
28932 
      oprot.writeFieldEnd()
6048 rajveer 28933 
    oprot.writeFieldStop()
28934 
    oprot.writeStructEnd()
28935 
 
28936 
  def validate(self):
28937 
    return
28938 
 
28939 
 
28940 
  def __repr__(self):
28941 
    L = ['%s=%r' % (key, value)
28942 
      for key, value in self.__dict__.iteritems()]
28943 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28944 
 
28945 
  def __eq__(self, other):
28946 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28947 
 
28948 
  def __ne__(self, other):
28949 
    return not (self == other)
28950 
 
28951 
class getServiceProviders_result:
28952 
  """
28953 
  Attributes:
28954 
   - success
28955 
  """
28956 
 
28957 
  thrift_spec = (
28958 
    (0, TType.MAP, 'success', (TType.I64,None,TType.STRING,None), None, ), # 0
28959 
  )
28960 
 
28961 
  def __init__(self, success=None,):
28962 
    self.success = success
28963 
 
28964 
  def read(self, iprot):
28965 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28966 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28967 
      return
28968 
    iprot.readStructBegin()
28969 
    while True:
28970 
      (fname, ftype, fid) = iprot.readFieldBegin()
28971 
      if ftype == TType.STOP:
28972 
        break
28973 
      if fid == 0:
28974 
        if ftype == TType.MAP:
28975 
          self.success = {}
6188 rajveer 28976 
          (_ktype671, _vtype672, _size670 ) = iprot.readMapBegin()
28977 
          for _i674 in xrange(_size670):
28978 
            _key675 = iprot.readI64();
28979 
            _val676 = iprot.readString();
28980 
            self.success[_key675] = _val676
6048 rajveer 28981 
          iprot.readMapEnd()
28982 
        else:
28983 
          iprot.skip(ftype)
28984 
      else:
28985 
        iprot.skip(ftype)
28986 
      iprot.readFieldEnd()
28987 
    iprot.readStructEnd()
28988 
 
28989 
  def write(self, oprot):
28990 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28991 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28992 
      return
28993 
    oprot.writeStructBegin('getServiceProviders_result')
28994 
    if self.success is not None:
28995 
      oprot.writeFieldBegin('success', TType.MAP, 0)
28996 
      oprot.writeMapBegin(TType.I64, TType.STRING, len(self.success))
6188 rajveer 28997 
      for kiter677,viter678 in self.success.items():
28998 
        oprot.writeI64(kiter677)
28999 
        oprot.writeString(viter678)
6048 rajveer 29000 
      oprot.writeMapEnd()
29001 
      oprot.writeFieldEnd()
29002 
    oprot.writeFieldStop()
29003 
    oprot.writeStructEnd()
29004 
 
29005 
  def validate(self):
29006 
    return
29007 
 
29008 
 
29009 
  def __repr__(self):
29010 
    L = ['%s=%r' % (key, value)
29011 
      for key, value in self.__dict__.iteritems()]
29012 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
29013 
 
29014 
  def __eq__(self, other):
29015 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
29016 
 
29017 
  def __ne__(self, other):
29018 
    return not (self == other)
29019 
 
29020 
class getServiceProviderForDevice_args:
29021 
  """
29022 
  Attributes:
6049 rajveer 29023 
   - rechargeType
6048 rajveer 29024 
   - deviceNumber
29025 
  """
29026 
 
29027 
  thrift_spec = (
29028 
    None, # 0
6049 rajveer 29029 
    (1, TType.I32, 'rechargeType', None, None, ), # 1
29030 
    (2, TType.STRING, 'deviceNumber', None, None, ), # 2
6048 rajveer 29031 
  )
29032 
 
6049 rajveer 29033 
  def __init__(self, rechargeType=None, deviceNumber=None,):
29034 
    self.rechargeType = rechargeType
6048 rajveer 29035 
    self.deviceNumber = deviceNumber
29036 
 
29037 
  def read(self, iprot):
29038 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
29039 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
29040 
      return
29041 
    iprot.readStructBegin()
29042 
    while True:
29043 
      (fname, ftype, fid) = iprot.readFieldBegin()
29044 
      if ftype == TType.STOP:
29045 
        break
29046 
      if fid == 1:
6049 rajveer 29047 
        if ftype == TType.I32:
29048 
          self.rechargeType = iprot.readI32();
29049 
        else:
29050 
          iprot.skip(ftype)
29051 
      elif fid == 2:
6048 rajveer 29052 
        if ftype == TType.STRING:
29053 
          self.deviceNumber = iprot.readString();
29054 
        else:
29055 
          iprot.skip(ftype)
29056 
      else:
29057 
        iprot.skip(ftype)
29058 
      iprot.readFieldEnd()
29059 
    iprot.readStructEnd()
29060 
 
29061 
  def write(self, oprot):
29062 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
29063 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
29064 
      return
29065 
    oprot.writeStructBegin('getServiceProviderForDevice_args')
6049 rajveer 29066 
    if self.rechargeType is not None:
29067 
      oprot.writeFieldBegin('rechargeType', TType.I32, 1)
29068 
      oprot.writeI32(self.rechargeType)
29069 
      oprot.writeFieldEnd()
6048 rajveer 29070 
    if self.deviceNumber is not None:
6049 rajveer 29071 
      oprot.writeFieldBegin('deviceNumber', TType.STRING, 2)
6048 rajveer 29072 
      oprot.writeString(self.deviceNumber)
29073 
      oprot.writeFieldEnd()
29074 
    oprot.writeFieldStop()
29075 
    oprot.writeStructEnd()
29076 
 
29077 
  def validate(self):
29078 
    return
29079 
 
29080 
 
29081 
  def __repr__(self):
29082 
    L = ['%s=%r' % (key, value)
29083 
      for key, value in self.__dict__.iteritems()]
29084 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
29085 
 
29086 
  def __eq__(self, other):
29087 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
29088 
 
29089 
  def __ne__(self, other):
29090 
    return not (self == other)
29091 
 
29092 
class getServiceProviderForDevice_result:
29093 
  """
29094 
  Attributes:
29095 
   - success
29096 
  """
29097 
 
29098 
  thrift_spec = (
6289 anupam.sin 29099 
    (0, TType.STRUCT, 'success', (DeviceNumberInfo, DeviceNumberInfo.thrift_spec), None, ), # 0
6048 rajveer 29100 
  )
29101 
 
29102 
  def __init__(self, success=None,):
29103 
    self.success = success
29104 
 
29105 
  def read(self, iprot):
29106 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
29107 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
29108 
      return
29109 
    iprot.readStructBegin()
29110 
    while True:
29111 
      (fname, ftype, fid) = iprot.readFieldBegin()
29112 
      if ftype == TType.STOP:
29113 
        break
29114 
      if fid == 0:
6289 anupam.sin 29115 
        if ftype == TType.STRUCT:
29116 
          self.success = DeviceNumberInfo()
29117 
          self.success.read(iprot)
6048 rajveer 29118 
        else:
29119 
          iprot.skip(ftype)
29120 
      else:
29121 
        iprot.skip(ftype)
29122 
      iprot.readFieldEnd()
29123 
    iprot.readStructEnd()
29124 
 
29125 
  def write(self, oprot):
29126 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
29127 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
29128 
      return
29129 
    oprot.writeStructBegin('getServiceProviderForDevice_result')
29130 
    if self.success is not None:
6289 anupam.sin 29131 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
29132 
      self.success.write(oprot)
6048 rajveer 29133 
      oprot.writeFieldEnd()
29134 
    oprot.writeFieldStop()
29135 
    oprot.writeStructEnd()
29136 
 
29137 
  def validate(self):
29138 
    return
29139 
 
29140 
 
29141 
  def __repr__(self):
29142 
    L = ['%s=%r' % (key, value)
29143 
      for key, value in self.__dict__.iteritems()]
29144 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
29145 
 
29146 
  def __eq__(self, other):
29147 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
29148 
 
29149 
  def __ne__(self, other):
29150 
    return not (self == other)
6094 rajveer 29151 
 
6269 rajveer 29152 
class validateRecharge_args:
29153 
  """
29154 
  Attributes:
29155 
   - rechargeType
29156 
   - deviceNumber
6307 anupam.sin 29157 
   - userSelectedProviderId
6591 anupam.sin 29158 
   - clientAddress
6269 rajveer 29159 
  """
29160 
 
29161 
  thrift_spec = (
29162 
    None, # 0
29163 
    (1, TType.I32, 'rechargeType', None, None, ), # 1
29164 
    (2, TType.STRING, 'deviceNumber', None, None, ), # 2
6336 anupam.sin 29165 
    (3, TType.I64, 'userSelectedProviderId', None, None, ), # 3
6591 anupam.sin 29166 
    (4, TType.STRING, 'clientAddress', None, None, ), # 4
6269 rajveer 29167 
  )
29168 
 
6591 anupam.sin 29169 
  def __init__(self, rechargeType=None, deviceNumber=None, userSelectedProviderId=None, clientAddress=None,):
6269 rajveer 29170 
    self.rechargeType = rechargeType
29171 
    self.deviceNumber = deviceNumber
6307 anupam.sin 29172 
    self.userSelectedProviderId = userSelectedProviderId
6591 anupam.sin 29173 
    self.clientAddress = clientAddress
6269 rajveer 29174 
 
29175 
  def read(self, iprot):
29176 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
29177 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
29178 
      return
29179 
    iprot.readStructBegin()
29180 
    while True:
29181 
      (fname, ftype, fid) = iprot.readFieldBegin()
29182 
      if ftype == TType.STOP:
29183 
        break
29184 
      if fid == 1:
29185 
        if ftype == TType.I32:
29186 
          self.rechargeType = iprot.readI32();
29187 
        else:
29188 
          iprot.skip(ftype)
29189 
      elif fid == 2:
29190 
        if ftype == TType.STRING:
29191 
          self.deviceNumber = iprot.readString();
29192 
        else:
29193 
          iprot.skip(ftype)
6307 anupam.sin 29194 
      elif fid == 3:
29195 
        if ftype == TType.I64:
29196 
          self.userSelectedProviderId = iprot.readI64();
29197 
        else:
29198 
          iprot.skip(ftype)
6591 anupam.sin 29199 
      elif fid == 4:
29200 
        if ftype == TType.STRING:
29201 
          self.clientAddress = iprot.readString();
29202 
        else:
29203 
          iprot.skip(ftype)
6269 rajveer 29204 
      else:
29205 
        iprot.skip(ftype)
29206 
      iprot.readFieldEnd()
29207 
    iprot.readStructEnd()
29208 
 
29209 
  def write(self, oprot):
29210 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
29211 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
29212 
      return
29213 
    oprot.writeStructBegin('validateRecharge_args')
29214 
    if self.rechargeType is not None:
29215 
      oprot.writeFieldBegin('rechargeType', TType.I32, 1)
29216 
      oprot.writeI32(self.rechargeType)
29217 
      oprot.writeFieldEnd()
29218 
    if self.deviceNumber is not None:
29219 
      oprot.writeFieldBegin('deviceNumber', TType.STRING, 2)
29220 
      oprot.writeString(self.deviceNumber)
29221 
      oprot.writeFieldEnd()
6307 anupam.sin 29222 
    if self.userSelectedProviderId is not None:
6336 anupam.sin 29223 
      oprot.writeFieldBegin('userSelectedProviderId', TType.I64, 3)
6307 anupam.sin 29224 
      oprot.writeI64(self.userSelectedProviderId)
29225 
      oprot.writeFieldEnd()
6591 anupam.sin 29226 
    if self.clientAddress is not None:
29227 
      oprot.writeFieldBegin('clientAddress', TType.STRING, 4)
29228 
      oprot.writeString(self.clientAddress)
29229 
      oprot.writeFieldEnd()
6269 rajveer 29230 
    oprot.writeFieldStop()
29231 
    oprot.writeStructEnd()
29232 
 
29233 
  def validate(self):
29234 
    return
29235 
 
29236 
 
29237 
  def __repr__(self):
29238 
    L = ['%s=%r' % (key, value)
29239 
      for key, value in self.__dict__.iteritems()]
29240 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
29241 
 
29242 
  def __eq__(self, other):
29243 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
29244 
 
29245 
  def __ne__(self, other):
29246 
    return not (self == other)
29247 
 
29248 
class validateRecharge_result:
29249 
  """
29250 
  Attributes:
29251 
   - success
29252 
  """
29253 
 
29254 
  thrift_spec = (
29255 
    (0, TType.STRING, 'success', None, None, ), # 0
29256 
  )
29257 
 
29258 
  def __init__(self, success=None,):
29259 
    self.success = success
29260 
 
29261 
  def read(self, iprot):
29262 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
29263 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
29264 
      return
29265 
    iprot.readStructBegin()
29266 
    while True:
29267 
      (fname, ftype, fid) = iprot.readFieldBegin()
29268 
      if ftype == TType.STOP:
29269 
        break
29270 
      if fid == 0:
29271 
        if ftype == TType.STRING:
29272 
          self.success = iprot.readString();
29273 
        else:
29274 
          iprot.skip(ftype)
29275 
      else:
29276 
        iprot.skip(ftype)
29277 
      iprot.readFieldEnd()
29278 
    iprot.readStructEnd()
29279 
 
29280 
  def write(self, oprot):
29281 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
29282 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
29283 
      return
29284 
    oprot.writeStructBegin('validateRecharge_result')
29285 
    if self.success is not None:
29286 
      oprot.writeFieldBegin('success', TType.STRING, 0)
29287 
      oprot.writeString(self.success)
29288 
      oprot.writeFieldEnd()
29289 
    oprot.writeFieldStop()
29290 
    oprot.writeStructEnd()
29291 
 
29292 
  def validate(self):
29293 
    return
29294 
 
29295 
 
29296 
  def __repr__(self):
29297 
    L = ['%s=%r' % (key, value)
29298 
      for key, value in self.__dict__.iteritems()]
29299 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
29300 
 
29301 
  def __eq__(self, other):
29302 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
29303 
 
29304 
  def __ne__(self, other):
29305 
    return not (self == other)
29306 
 
6094 rajveer 29307 
class getRechargeOrdersForDevice_args:
29308 
  """
29309 
  Attributes:
29310 
   - deviceNumber
29311 
  """
29312 
 
29313 
  thrift_spec = (
29314 
    None, # 0
29315 
    (1, TType.STRING, 'deviceNumber', None, None, ), # 1
29316 
  )
29317 
 
29318 
  def __init__(self, deviceNumber=None,):
29319 
    self.deviceNumber = deviceNumber
29320 
 
29321 
  def read(self, iprot):
29322 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
29323 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
29324 
      return
29325 
    iprot.readStructBegin()
29326 
    while True:
29327 
      (fname, ftype, fid) = iprot.readFieldBegin()
29328 
      if ftype == TType.STOP:
29329 
        break
29330 
      if fid == 1:
29331 
        if ftype == TType.STRING:
29332 
          self.deviceNumber = iprot.readString();
29333 
        else:
29334 
          iprot.skip(ftype)
29335 
      else:
29336 
        iprot.skip(ftype)
29337 
      iprot.readFieldEnd()
29338 
    iprot.readStructEnd()
29339 
 
29340 
  def write(self, oprot):
29341 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
29342 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
29343 
      return
29344 
    oprot.writeStructBegin('getRechargeOrdersForDevice_args')
29345 
    if self.deviceNumber is not None:
29346 
      oprot.writeFieldBegin('deviceNumber', TType.STRING, 1)
29347 
      oprot.writeString(self.deviceNumber)
29348 
      oprot.writeFieldEnd()
29349 
    oprot.writeFieldStop()
29350 
    oprot.writeStructEnd()
29351 
 
29352 
  def validate(self):
29353 
    return
29354 
 
29355 
 
29356 
  def __repr__(self):
29357 
    L = ['%s=%r' % (key, value)
29358 
      for key, value in self.__dict__.iteritems()]
29359 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
29360 
 
29361 
  def __eq__(self, other):
29362 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
29363 
 
29364 
  def __ne__(self, other):
29365 
    return not (self == other)
29366 
 
29367 
class getRechargeOrdersForDevice_result:
29368 
  """
29369 
  Attributes:
29370 
   - success
29371 
  """
29372 
 
29373 
  thrift_spec = (
29374 
    (0, TType.LIST, 'success', (TType.STRUCT,(RechargeOrder, RechargeOrder.thrift_spec)), None, ), # 0
29375 
  )
29376 
 
29377 
  def __init__(self, success=None,):
29378 
    self.success = success
29379 
 
29380 
  def read(self, iprot):
29381 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
29382 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
29383 
      return
29384 
    iprot.readStructBegin()
29385 
    while True:
29386 
      (fname, ftype, fid) = iprot.readFieldBegin()
29387 
      if ftype == TType.STOP:
29388 
        break
29389 
      if fid == 0:
29390 
        if ftype == TType.LIST:
29391 
          self.success = []
6188 rajveer 29392 
          (_etype682, _size679) = iprot.readListBegin()
29393 
          for _i683 in xrange(_size679):
29394 
            _elem684 = RechargeOrder()
29395 
            _elem684.read(iprot)
29396 
            self.success.append(_elem684)
6094 rajveer 29397 
          iprot.readListEnd()
29398 
        else:
29399 
          iprot.skip(ftype)
29400 
      else:
29401 
        iprot.skip(ftype)
29402 
      iprot.readFieldEnd()
29403 
    iprot.readStructEnd()
29404 
 
29405 
  def write(self, oprot):
29406 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
29407 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
29408 
      return
29409 
    oprot.writeStructBegin('getRechargeOrdersForDevice_result')
29410 
    if self.success is not None:
29411 
      oprot.writeFieldBegin('success', TType.LIST, 0)
29412 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 29413 
      for iter685 in self.success:
29414 
        iter685.write(oprot)
6094 rajveer 29415 
      oprot.writeListEnd()
29416 
      oprot.writeFieldEnd()
29417 
    oprot.writeFieldStop()
29418 
    oprot.writeStructEnd()
29419 
 
29420 
  def validate(self):
29421 
    return
29422 
 
29423 
 
29424 
  def __repr__(self):
29425 
    L = ['%s=%r' % (key, value)
29426 
      for key, value in self.__dict__.iteritems()]
29427 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
29428 
 
29429 
  def __eq__(self, other):
29430 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
29431 
 
29432 
  def __ne__(self, other):
29433 
    return not (self == other)
29434 
 
29435 
class addAmountToWallet_args:
29436 
  """
29437 
  Attributes:
29438 
   - userId
29439 
   - orderId
29440 
   - amount
29441 
  """
29442 
 
29443 
  thrift_spec = (
29444 
    None, # 0
29445 
    (1, TType.I64, 'userId', None, None, ), # 1
29446 
    (2, TType.I64, 'orderId', None, None, ), # 2
29447 
    (3, TType.I64, 'amount', None, None, ), # 3
29448 
  )
29449 
 
29450 
  def __init__(self, userId=None, orderId=None, amount=None,):
29451 
    self.userId = userId
29452 
    self.orderId = orderId
29453 
    self.amount = amount
29454 
 
29455 
  def read(self, iprot):
29456 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
29457 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
29458 
      return
29459 
    iprot.readStructBegin()
29460 
    while True:
29461 
      (fname, ftype, fid) = iprot.readFieldBegin()
29462 
      if ftype == TType.STOP:
29463 
        break
29464 
      if fid == 1:
29465 
        if ftype == TType.I64:
29466 
          self.userId = iprot.readI64();
29467 
        else:
29468 
          iprot.skip(ftype)
29469 
      elif fid == 2:
29470 
        if ftype == TType.I64:
29471 
          self.orderId = iprot.readI64();
29472 
        else:
29473 
          iprot.skip(ftype)
29474 
      elif fid == 3:
29475 
        if ftype == TType.I64:
29476 
          self.amount = iprot.readI64();
29477 
        else:
29478 
          iprot.skip(ftype)
29479 
      else:
29480 
        iprot.skip(ftype)
29481 
      iprot.readFieldEnd()
29482 
    iprot.readStructEnd()
29483 
 
29484 
  def write(self, oprot):
29485 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
29486 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
29487 
      return
29488 
    oprot.writeStructBegin('addAmountToWallet_args')
29489 
    if self.userId is not None:
29490 
      oprot.writeFieldBegin('userId', TType.I64, 1)
29491 
      oprot.writeI64(self.userId)
29492 
      oprot.writeFieldEnd()
29493 
    if self.orderId is not None:
29494 
      oprot.writeFieldBegin('orderId', TType.I64, 2)
29495 
      oprot.writeI64(self.orderId)
29496 
      oprot.writeFieldEnd()
29497 
    if self.amount is not None:
29498 
      oprot.writeFieldBegin('amount', TType.I64, 3)
29499 
      oprot.writeI64(self.amount)
29500 
      oprot.writeFieldEnd()
29501 
    oprot.writeFieldStop()
29502 
    oprot.writeStructEnd()
29503 
 
29504 
  def validate(self):
29505 
    return
29506 
 
29507 
 
29508 
  def __repr__(self):
29509 
    L = ['%s=%r' % (key, value)
29510 
      for key, value in self.__dict__.iteritems()]
29511 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
29512 
 
29513 
  def __eq__(self, other):
29514 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
29515 
 
29516 
  def __ne__(self, other):
29517 
    return not (self == other)
29518 
 
29519 
class addAmountToWallet_result:
29520 
 
29521 
  thrift_spec = (
29522 
  )
29523 
 
29524 
  def read(self, iprot):
29525 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
29526 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
29527 
      return
29528 
    iprot.readStructBegin()
29529 
    while True:
29530 
      (fname, ftype, fid) = iprot.readFieldBegin()
29531 
      if ftype == TType.STOP:
29532 
        break
29533 
      else:
29534 
        iprot.skip(ftype)
29535 
      iprot.readFieldEnd()
29536 
    iprot.readStructEnd()
29537 
 
29538 
  def write(self, oprot):
29539 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
29540 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
29541 
      return
29542 
    oprot.writeStructBegin('addAmountToWallet_result')
29543 
    oprot.writeFieldStop()
29544 
    oprot.writeStructEnd()
29545 
 
29546 
  def validate(self):
29547 
    return
29548 
 
29549 
 
29550 
  def __repr__(self):
29551 
    L = ['%s=%r' % (key, value)
29552 
      for key, value in self.__dict__.iteritems()]
29553 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
29554 
 
29555 
  def __eq__(self, other):
29556 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
29557 
 
29558 
  def __ne__(self, other):
29559 
    return not (self == other)
6154 rajveer 29560 
 
6188 rajveer 29561 
class getRechargeStatistics_args:
29562 
 
29563 
  thrift_spec = (
29564 
  )
29565 
 
29566 
  def read(self, iprot):
29567 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
29568 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
29569 
      return
29570 
    iprot.readStructBegin()
29571 
    while True:
29572 
      (fname, ftype, fid) = iprot.readFieldBegin()
29573 
      if ftype == TType.STOP:
29574 
        break
29575 
      else:
29576 
        iprot.skip(ftype)
29577 
      iprot.readFieldEnd()
29578 
    iprot.readStructEnd()
29579 
 
29580 
  def write(self, oprot):
29581 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
29582 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
29583 
      return
29584 
    oprot.writeStructBegin('getRechargeStatistics_args')
29585 
    oprot.writeFieldStop()
29586 
    oprot.writeStructEnd()
29587 
 
29588 
  def validate(self):
29589 
    return
29590 
 
29591 
 
29592 
  def __repr__(self):
29593 
    L = ['%s=%r' % (key, value)
29594 
      for key, value in self.__dict__.iteritems()]
29595 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
29596 
 
29597 
  def __eq__(self, other):
29598 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
29599 
 
29600 
  def __ne__(self, other):
29601 
    return not (self == other)
29602 
 
29603 
class getRechargeStatistics_result:
29604 
  """
29605 
  Attributes:
29606 
   - success
29607 
  """
29608 
 
29609 
  thrift_spec = (
29610 
    (0, TType.STRUCT, 'success', (RechargeStatistics, RechargeStatistics.thrift_spec), None, ), # 0
29611 
  )
29612 
 
29613 
  def __init__(self, success=None,):
29614 
    self.success = success
29615 
 
29616 
  def read(self, iprot):
29617 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
29618 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
29619 
      return
29620 
    iprot.readStructBegin()
29621 
    while True:
29622 
      (fname, ftype, fid) = iprot.readFieldBegin()
29623 
      if ftype == TType.STOP:
29624 
        break
29625 
      if fid == 0:
29626 
        if ftype == TType.STRUCT:
29627 
          self.success = RechargeStatistics()
29628 
          self.success.read(iprot)
29629 
        else:
29630 
          iprot.skip(ftype)
29631 
      else:
29632 
        iprot.skip(ftype)
29633 
      iprot.readFieldEnd()
29634 
    iprot.readStructEnd()
29635 
 
29636 
  def write(self, oprot):
29637 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
29638 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
29639 
      return
29640 
    oprot.writeStructBegin('getRechargeStatistics_result')
29641 
    if self.success is not None:
29642 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
29643 
      self.success.write(oprot)
29644 
      oprot.writeFieldEnd()
29645 
    oprot.writeFieldStop()
29646 
    oprot.writeStructEnd()
29647 
 
29648 
  def validate(self):
29649 
    return
29650 
 
29651 
 
29652 
  def __repr__(self):
29653 
    L = ['%s=%r' % (key, value)
29654 
      for key, value in self.__dict__.iteritems()]
29655 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
29656 
 
29657 
  def __eq__(self, other):
29658 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
29659 
 
29660 
  def __ne__(self, other):
29661 
    return not (self == other)
29662 
 
6154 rajveer 29663 
class getRechargeOrdersForStatus_args:
29664 
  """
29665 
  Attributes:
29666 
   - status
29667 
  """
29668 
 
29669 
  thrift_spec = (
29670 
    None, # 0
29671 
    (1, TType.I64, 'status', None, None, ), # 1
29672 
  )
29673 
 
29674 
  def __init__(self, status=None,):
29675 
    self.status = status
29676 
 
29677 
  def read(self, iprot):
29678 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
29679 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
29680 
      return
29681 
    iprot.readStructBegin()
29682 
    while True:
29683 
      (fname, ftype, fid) = iprot.readFieldBegin()
29684 
      if ftype == TType.STOP:
29685 
        break
29686 
      if fid == 1:
29687 
        if ftype == TType.I64:
29688 
          self.status = iprot.readI64();
29689 
        else:
29690 
          iprot.skip(ftype)
29691 
      else:
29692 
        iprot.skip(ftype)
29693 
      iprot.readFieldEnd()
29694 
    iprot.readStructEnd()
29695 
 
29696 
  def write(self, oprot):
29697 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
29698 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
29699 
      return
29700 
    oprot.writeStructBegin('getRechargeOrdersForStatus_args')
29701 
    if self.status is not None:
29702 
      oprot.writeFieldBegin('status', TType.I64, 1)
29703 
      oprot.writeI64(self.status)
29704 
      oprot.writeFieldEnd()
29705 
    oprot.writeFieldStop()
29706 
    oprot.writeStructEnd()
29707 
 
29708 
  def validate(self):
29709 
    return
29710 
 
29711 
 
29712 
  def __repr__(self):
29713 
    L = ['%s=%r' % (key, value)
29714 
      for key, value in self.__dict__.iteritems()]
29715 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
29716 
 
29717 
  def __eq__(self, other):
29718 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
29719 
 
29720 
  def __ne__(self, other):
29721 
    return not (self == other)
29722 
 
29723 
class getRechargeOrdersForStatus_result:
29724 
  """
29725 
  Attributes:
29726 
   - success
29727 
  """
29728 
 
29729 
  thrift_spec = (
29730 
    (0, TType.LIST, 'success', (TType.STRUCT,(RechargeOrder, RechargeOrder.thrift_spec)), None, ), # 0
29731 
  )
29732 
 
29733 
  def __init__(self, success=None,):
29734 
    self.success = success
29735 
 
29736 
  def read(self, iprot):
29737 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
29738 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
29739 
      return
29740 
    iprot.readStructBegin()
29741 
    while True:
29742 
      (fname, ftype, fid) = iprot.readFieldBegin()
29743 
      if ftype == TType.STOP:
29744 
        break
29745 
      if fid == 0:
29746 
        if ftype == TType.LIST:
29747 
          self.success = []
6188 rajveer 29748 
          (_etype689, _size686) = iprot.readListBegin()
29749 
          for _i690 in xrange(_size686):
29750 
            _elem691 = RechargeOrder()
29751 
            _elem691.read(iprot)
29752 
            self.success.append(_elem691)
6154 rajveer 29753 
          iprot.readListEnd()
29754 
        else:
29755 
          iprot.skip(ftype)
29756 
      else:
29757 
        iprot.skip(ftype)
29758 
      iprot.readFieldEnd()
29759 
    iprot.readStructEnd()
29760 
 
29761 
  def write(self, oprot):
29762 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
29763 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
29764 
      return
29765 
    oprot.writeStructBegin('getRechargeOrdersForStatus_result')
29766 
    if self.success is not None:
29767 
      oprot.writeFieldBegin('success', TType.LIST, 0)
29768 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 29769 
      for iter692 in self.success:
29770 
        iter692.write(oprot)
6154 rajveer 29771 
      oprot.writeListEnd()
29772 
      oprot.writeFieldEnd()
29773 
    oprot.writeFieldStop()
29774 
    oprot.writeStructEnd()
29775 
 
29776 
  def validate(self):
29777 
    return
29778 
 
29779 
 
29780 
  def __repr__(self):
29781 
    L = ['%s=%r' % (key, value)
29782 
      for key, value in self.__dict__.iteritems()]
29783 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
29784 
 
29785 
  def __eq__(self, other):
29786 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
29787 
 
29788 
  def __ne__(self, other):
29789 
    return not (self == other)
6159 rajveer 29790 
 
29791 
class getPlansForOperator_args:
29792 
  """
29793 
  Attributes:
29794 
   - operatorId
29795 
  """
29796 
 
29797 
  thrift_spec = (
29798 
    None, # 0
29799 
    (1, TType.I64, 'operatorId', None, None, ), # 1
29800 
  )
29801 
 
29802 
  def __init__(self, operatorId=None,):
29803 
    self.operatorId = operatorId
29804 
 
29805 
  def read(self, iprot):
29806 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
29807 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
29808 
      return
29809 
    iprot.readStructBegin()
29810 
    while True:
29811 
      (fname, ftype, fid) = iprot.readFieldBegin()
29812 
      if ftype == TType.STOP:
29813 
        break
29814 
      if fid == 1:
29815 
        if ftype == TType.I64:
29816 
          self.operatorId = iprot.readI64();
29817 
        else:
29818 
          iprot.skip(ftype)
29819 
      else:
29820 
        iprot.skip(ftype)
29821 
      iprot.readFieldEnd()
29822 
    iprot.readStructEnd()
29823 
 
29824 
  def write(self, oprot):
29825 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
29826 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
29827 
      return
29828 
    oprot.writeStructBegin('getPlansForOperator_args')
29829 
    if self.operatorId is not None:
29830 
      oprot.writeFieldBegin('operatorId', TType.I64, 1)
29831 
      oprot.writeI64(self.operatorId)
29832 
      oprot.writeFieldEnd()
29833 
    oprot.writeFieldStop()
29834 
    oprot.writeStructEnd()
29835 
 
29836 
  def validate(self):
29837 
    return
29838 
 
29839 
 
29840 
  def __repr__(self):
29841 
    L = ['%s=%r' % (key, value)
29842 
      for key, value in self.__dict__.iteritems()]
29843 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
29844 
 
29845 
  def __eq__(self, other):
29846 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
29847 
 
29848 
  def __ne__(self, other):
29849 
    return not (self == other)
29850 
 
29851 
class getPlansForOperator_result:
29852 
  """
29853 
  Attributes:
29854 
   - success
29855 
  """
29856 
 
29857 
  thrift_spec = (
29858 
    (0, TType.LIST, 'success', (TType.STRUCT,(RechargePlan, RechargePlan.thrift_spec)), None, ), # 0
29859 
  )
29860 
 
29861 
  def __init__(self, success=None,):
29862 
    self.success = success
29863 
 
29864 
  def read(self, iprot):
29865 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
29866 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
29867 
      return
29868 
    iprot.readStructBegin()
29869 
    while True:
29870 
      (fname, ftype, fid) = iprot.readFieldBegin()
29871 
      if ftype == TType.STOP:
29872 
        break
29873 
      if fid == 0:
29874 
        if ftype == TType.LIST:
29875 
          self.success = []
6188 rajveer 29876 
          (_etype696, _size693) = iprot.readListBegin()
29877 
          for _i697 in xrange(_size693):
29878 
            _elem698 = RechargePlan()
29879 
            _elem698.read(iprot)
29880 
            self.success.append(_elem698)
6159 rajveer 29881 
          iprot.readListEnd()
29882 
        else:
29883 
          iprot.skip(ftype)
29884 
      else:
29885 
        iprot.skip(ftype)
29886 
      iprot.readFieldEnd()
29887 
    iprot.readStructEnd()
29888 
 
29889 
  def write(self, oprot):
29890 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
29891 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
29892 
      return
29893 
    oprot.writeStructBegin('getPlansForOperator_result')
29894 
    if self.success is not None:
29895 
      oprot.writeFieldBegin('success', TType.LIST, 0)
29896 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 29897 
      for iter699 in self.success:
29898 
        iter699.write(oprot)
6159 rajveer 29899 
      oprot.writeListEnd()
29900 
      oprot.writeFieldEnd()
29901 
    oprot.writeFieldStop()
29902 
    oprot.writeStructEnd()
29903 
 
29904 
  def validate(self):
29905 
    return
29906 
 
29907 
 
29908 
  def __repr__(self):
29909 
    L = ['%s=%r' % (key, value)
29910 
      for key, value in self.__dict__.iteritems()]
29911 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
29912 
 
29913 
  def __eq__(self, other):
29914 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
29915 
 
29916 
  def __ne__(self, other):
29917 
    return not (self == other)
6289 anupam.sin 29918 
 
29919 
class getRechargeDenominations_args:
29920 
  """
29921 
  Attributes:
29922 
   - operatorId
6307 anupam.sin 29923 
   - circleCode
6289 anupam.sin 29924 
   - denominationType
29925 
  """
29926 
 
29927 
  thrift_spec = (
29928 
    None, # 0
29929 
    (1, TType.I64, 'operatorId', None, None, ), # 1
6307 anupam.sin 29930 
    (2, TType.STRING, 'circleCode', None, None, ), # 2
6289 anupam.sin 29931 
    (3, TType.I32, 'denominationType', None, None, ), # 3
29932 
  )
29933 
 
6307 anupam.sin 29934 
  def __init__(self, operatorId=None, circleCode=None, denominationType=None,):
6289 anupam.sin 29935 
    self.operatorId = operatorId
6307 anupam.sin 29936 
    self.circleCode = circleCode
6289 anupam.sin 29937 
    self.denominationType = denominationType
29938 
 
29939 
  def read(self, iprot):
29940 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
29941 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
29942 
      return
29943 
    iprot.readStructBegin()
29944 
    while True:
29945 
      (fname, ftype, fid) = iprot.readFieldBegin()
29946 
      if ftype == TType.STOP:
29947 
        break
29948 
      if fid == 1:
29949 
        if ftype == TType.I64:
29950 
          self.operatorId = iprot.readI64();
29951 
        else:
29952 
          iprot.skip(ftype)
29953 
      elif fid == 2:
29954 
        if ftype == TType.STRING:
6307 anupam.sin 29955 
          self.circleCode = iprot.readString();
6289 anupam.sin 29956 
        else:
29957 
          iprot.skip(ftype)
29958 
      elif fid == 3:
29959 
        if ftype == TType.I32:
29960 
          self.denominationType = iprot.readI32();
29961 
        else:
29962 
          iprot.skip(ftype)
29963 
      else:
29964 
        iprot.skip(ftype)
29965 
      iprot.readFieldEnd()
29966 
    iprot.readStructEnd()
29967 
 
29968 
  def write(self, oprot):
29969 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
29970 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
29971 
      return
29972 
    oprot.writeStructBegin('getRechargeDenominations_args')
29973 
    if self.operatorId is not None:
29974 
      oprot.writeFieldBegin('operatorId', TType.I64, 1)
29975 
      oprot.writeI64(self.operatorId)
29976 
      oprot.writeFieldEnd()
6307 anupam.sin 29977 
    if self.circleCode is not None:
29978 
      oprot.writeFieldBegin('circleCode', TType.STRING, 2)
29979 
      oprot.writeString(self.circleCode)
6289 anupam.sin 29980 
      oprot.writeFieldEnd()
29981 
    if self.denominationType is not None:
29982 
      oprot.writeFieldBegin('denominationType', TType.I32, 3)
29983 
      oprot.writeI32(self.denominationType)
29984 
      oprot.writeFieldEnd()
29985 
    oprot.writeFieldStop()
29986 
    oprot.writeStructEnd()
29987 
 
29988 
  def validate(self):
29989 
    return
29990 
 
29991 
 
29992 
  def __repr__(self):
29993 
    L = ['%s=%r' % (key, value)
29994 
      for key, value in self.__dict__.iteritems()]
29995 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
29996 
 
29997 
  def __eq__(self, other):
29998 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
29999 
 
30000 
  def __ne__(self, other):
30001 
    return not (self == other)
30002 
 
30003 
class getRechargeDenominations_result:
30004 
  """
30005 
  Attributes:
30006 
   - success
30007 
   - ex
30008 
  """
30009 
 
30010 
  thrift_spec = (
30011 
    (0, TType.LIST, 'success', (TType.STRUCT,(RechargeDenomination, RechargeDenomination.thrift_spec)), None, ), # 0
30012 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
30013 
  )
30014 
 
30015 
  def __init__(self, success=None, ex=None,):
30016 
    self.success = success
30017 
    self.ex = ex
30018 
 
30019 
  def read(self, iprot):
30020 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
30021 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
30022 
      return
30023 
    iprot.readStructBegin()
30024 
    while True:
30025 
      (fname, ftype, fid) = iprot.readFieldBegin()
30026 
      if ftype == TType.STOP:
30027 
        break
30028 
      if fid == 0:
30029 
        if ftype == TType.LIST:
30030 
          self.success = []
30031 
          (_etype703, _size700) = iprot.readListBegin()
30032 
          for _i704 in xrange(_size700):
30033 
            _elem705 = RechargeDenomination()
30034 
            _elem705.read(iprot)
30035 
            self.success.append(_elem705)
30036 
          iprot.readListEnd()
30037 
        else:
30038 
          iprot.skip(ftype)
30039 
      elif fid == 1:
30040 
        if ftype == TType.STRUCT:
30041 
          self.ex = TransactionServiceException()
30042 
          self.ex.read(iprot)
30043 
        else:
30044 
          iprot.skip(ftype)
30045 
      else:
30046 
        iprot.skip(ftype)
30047 
      iprot.readFieldEnd()
30048 
    iprot.readStructEnd()
30049 
 
30050 
  def write(self, oprot):
30051 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
30052 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
30053 
      return
30054 
    oprot.writeStructBegin('getRechargeDenominations_result')
30055 
    if self.success is not None:
30056 
      oprot.writeFieldBegin('success', TType.LIST, 0)
30057 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
30058 
      for iter706 in self.success:
30059 
        iter706.write(oprot)
30060 
      oprot.writeListEnd()
30061 
      oprot.writeFieldEnd()
30062 
    if self.ex is not None:
30063 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
30064 
      self.ex.write(oprot)
30065 
      oprot.writeFieldEnd()
30066 
    oprot.writeFieldStop()
30067 
    oprot.writeStructEnd()
30068 
 
30069 
  def validate(self):
30070 
    return
30071 
 
30072 
 
30073 
  def __repr__(self):
30074 
    L = ['%s=%r' % (key, value)
30075 
      for key, value in self.__dict__.iteritems()]
30076 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
30077 
 
30078 
  def __eq__(self, other):
30079 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
30080 
 
30081 
  def __ne__(self, other):
30082 
    return not (self == other)
6371 rajveer 30083 
 
30084 
class updateAvailabilityStatus_args:
30085 
  """
30086 
  Attributes:
30087 
   - operatorId
30088 
   - circleId
30089 
   - isAvailable
30090 
  """
30091 
 
30092 
  thrift_spec = (
30093 
    None, # 0
30094 
    (1, TType.I64, 'operatorId', None, None, ), # 1
30095 
    (2, TType.I64, 'circleId', None, None, ), # 2
30096 
    (3, TType.BOOL, 'isAvailable', None, None, ), # 3
30097 
  )
30098 
 
30099 
  def __init__(self, operatorId=None, circleId=None, isAvailable=None,):
30100 
    self.operatorId = operatorId
30101 
    self.circleId = circleId
30102 
    self.isAvailable = isAvailable
30103 
 
30104 
  def read(self, iprot):
30105 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
30106 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
30107 
      return
30108 
    iprot.readStructBegin()
30109 
    while True:
30110 
      (fname, ftype, fid) = iprot.readFieldBegin()
30111 
      if ftype == TType.STOP:
30112 
        break
30113 
      if fid == 1:
30114 
        if ftype == TType.I64:
30115 
          self.operatorId = iprot.readI64();
30116 
        else:
30117 
          iprot.skip(ftype)
30118 
      elif fid == 2:
30119 
        if ftype == TType.I64:
30120 
          self.circleId = iprot.readI64();
30121 
        else:
30122 
          iprot.skip(ftype)
30123 
      elif fid == 3:
30124 
        if ftype == TType.BOOL:
30125 
          self.isAvailable = iprot.readBool();
30126 
        else:
30127 
          iprot.skip(ftype)
30128 
      else:
30129 
        iprot.skip(ftype)
30130 
      iprot.readFieldEnd()
30131 
    iprot.readStructEnd()
30132 
 
30133 
  def write(self, oprot):
30134 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
30135 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
30136 
      return
30137 
    oprot.writeStructBegin('updateAvailabilityStatus_args')
30138 
    if self.operatorId is not None:
30139 
      oprot.writeFieldBegin('operatorId', TType.I64, 1)
30140 
      oprot.writeI64(self.operatorId)
30141 
      oprot.writeFieldEnd()
30142 
    if self.circleId is not None:
30143 
      oprot.writeFieldBegin('circleId', TType.I64, 2)
30144 
      oprot.writeI64(self.circleId)
30145 
      oprot.writeFieldEnd()
30146 
    if self.isAvailable is not None:
30147 
      oprot.writeFieldBegin('isAvailable', TType.BOOL, 3)
30148 
      oprot.writeBool(self.isAvailable)
30149 
      oprot.writeFieldEnd()
30150 
    oprot.writeFieldStop()
30151 
    oprot.writeStructEnd()
30152 
 
30153 
  def validate(self):
30154 
    return
30155 
 
30156 
 
30157 
  def __repr__(self):
30158 
    L = ['%s=%r' % (key, value)
30159 
      for key, value in self.__dict__.iteritems()]
30160 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
30161 
 
30162 
  def __eq__(self, other):
30163 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
30164 
 
30165 
  def __ne__(self, other):
30166 
    return not (self == other)
30167 
 
30168 
class updateAvailabilityStatus_result:
30169 
 
30170 
  thrift_spec = (
30171 
  )
30172 
 
30173 
  def read(self, iprot):
30174 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
30175 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
30176 
      return
30177 
    iprot.readStructBegin()
30178 
    while True:
30179 
      (fname, ftype, fid) = iprot.readFieldBegin()
30180 
      if ftype == TType.STOP:
30181 
        break
30182 
      else:
30183 
        iprot.skip(ftype)
30184 
      iprot.readFieldEnd()
30185 
    iprot.readStructEnd()
30186 
 
30187 
  def write(self, oprot):
30188 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
30189 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
30190 
      return
30191 
    oprot.writeStructBegin('updateAvailabilityStatus_result')
30192 
    oprot.writeFieldStop()
30193 
    oprot.writeStructEnd()
30194 
 
30195 
  def validate(self):
30196 
    return
30197 
 
30198 
 
30199 
  def __repr__(self):
30200 
    L = ['%s=%r' % (key, value)
30201 
      for key, value in self.__dict__.iteritems()]
30202 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
30203 
 
30204 
  def __eq__(self, other):
30205 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
30206 
 
30207 
  def __ne__(self, other):
30208 
    return not (self == other)
6389 rajveer 30209 
 
30210 
class getAvailableEmiSchemes_args:
30211 
 
30212 
  thrift_spec = (
30213 
  )
30214 
 
30215 
  def read(self, iprot):
30216 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
30217 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
30218 
      return
30219 
    iprot.readStructBegin()
30220 
    while True:
30221 
      (fname, ftype, fid) = iprot.readFieldBegin()
30222 
      if ftype == TType.STOP:
30223 
        break
30224 
      else:
30225 
        iprot.skip(ftype)
30226 
      iprot.readFieldEnd()
30227 
    iprot.readStructEnd()
30228 
 
30229 
  def write(self, oprot):
30230 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
30231 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
30232 
      return
30233 
    oprot.writeStructBegin('getAvailableEmiSchemes_args')
30234 
    oprot.writeFieldStop()
30235 
    oprot.writeStructEnd()
30236 
 
30237 
  def validate(self):
30238 
    return
30239 
 
30240 
 
30241 
  def __repr__(self):
30242 
    L = ['%s=%r' % (key, value)
30243 
      for key, value in self.__dict__.iteritems()]
30244 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
30245 
 
30246 
  def __eq__(self, other):
30247 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
30248 
 
30249 
  def __ne__(self, other):
30250 
    return not (self == other)
30251 
 
30252 
class getAvailableEmiSchemes_result:
30253 
  """
30254 
  Attributes:
30255 
   - success
30256 
  """
30257 
 
30258 
  thrift_spec = (
30259 
    (0, TType.LIST, 'success', (TType.STRUCT,(EmiScheme, EmiScheme.thrift_spec)), None, ), # 0
30260 
  )
30261 
 
30262 
  def __init__(self, success=None,):
30263 
    self.success = success
30264 
 
30265 
  def read(self, iprot):
30266 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
30267 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
30268 
      return
30269 
    iprot.readStructBegin()
30270 
    while True:
30271 
      (fname, ftype, fid) = iprot.readFieldBegin()
30272 
      if ftype == TType.STOP:
30273 
        break
30274 
      if fid == 0:
30275 
        if ftype == TType.LIST:
30276 
          self.success = []
30277 
          (_etype710, _size707) = iprot.readListBegin()
30278 
          for _i711 in xrange(_size707):
30279 
            _elem712 = EmiScheme()
30280 
            _elem712.read(iprot)
30281 
            self.success.append(_elem712)
30282 
          iprot.readListEnd()
30283 
        else:
30284 
          iprot.skip(ftype)
30285 
      else:
30286 
        iprot.skip(ftype)
30287 
      iprot.readFieldEnd()
30288 
    iprot.readStructEnd()
30289 
 
30290 
  def write(self, oprot):
30291 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
30292 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
30293 
      return
30294 
    oprot.writeStructBegin('getAvailableEmiSchemes_result')
30295 
    if self.success is not None:
30296 
      oprot.writeFieldBegin('success', TType.LIST, 0)
30297 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
30298 
      for iter713 in self.success:
30299 
        iter713.write(oprot)
30300 
      oprot.writeListEnd()
30301 
      oprot.writeFieldEnd()
30302 
    oprot.writeFieldStop()
30303 
    oprot.writeStructEnd()
30304 
 
30305 
  def validate(self):
30306 
    return
30307 
 
30308 
 
30309 
  def __repr__(self):
30310 
    L = ['%s=%r' % (key, value)
30311 
      for key, value in self.__dict__.iteritems()]
30312 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
30313 
 
30314 
  def __eq__(self, other):
30315 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
30316 
 
30317 
  def __ne__(self, other):
30318 
    return not (self == other)
30319 
 
30320 
class getMiscCharges_args:
30321 
  """
30322 
  Attributes:
30323 
   - transactionId
30324 
  """
30325 
 
30326 
  thrift_spec = (
30327 
    None, # 0
30328 
    (1, TType.I64, 'transactionId', None, None, ), # 1
30329 
  )
30330 
 
30331 
  def __init__(self, transactionId=None,):
30332 
    self.transactionId = transactionId
30333 
 
30334 
  def read(self, iprot):
30335 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
30336 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
30337 
      return
30338 
    iprot.readStructBegin()
30339 
    while True:
30340 
      (fname, ftype, fid) = iprot.readFieldBegin()
30341 
      if ftype == TType.STOP:
30342 
        break
30343 
      if fid == 1:
30344 
        if ftype == TType.I64:
30345 
          self.transactionId = iprot.readI64();
30346 
        else:
30347 
          iprot.skip(ftype)
30348 
      else:
30349 
        iprot.skip(ftype)
30350 
      iprot.readFieldEnd()
30351 
    iprot.readStructEnd()
30352 
 
30353 
  def write(self, oprot):
30354 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
30355 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
30356 
      return
30357 
    oprot.writeStructBegin('getMiscCharges_args')
30358 
    if self.transactionId is not None:
30359 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
30360 
      oprot.writeI64(self.transactionId)
30361 
      oprot.writeFieldEnd()
30362 
    oprot.writeFieldStop()
30363 
    oprot.writeStructEnd()
30364 
 
30365 
  def validate(self):
30366 
    return
30367 
 
30368 
 
30369 
  def __repr__(self):
30370 
    L = ['%s=%r' % (key, value)
30371 
      for key, value in self.__dict__.iteritems()]
30372 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
30373 
 
30374 
  def __eq__(self, other):
30375 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
30376 
 
30377 
  def __ne__(self, other):
30378 
    return not (self == other)
30379 
 
30380 
class getMiscCharges_result:
30381 
  """
30382 
  Attributes:
30383 
   - success
30384 
  """
30385 
 
30386 
  thrift_spec = (
6412 rajveer 30387 
    (0, TType.MAP, 'success', (TType.I64,None,TType.DOUBLE,None), None, ), # 0
6389 rajveer 30388 
  )
30389 
 
30390 
  def __init__(self, success=None,):
30391 
    self.success = success
30392 
 
30393 
  def read(self, iprot):
30394 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
30395 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
30396 
      return
30397 
    iprot.readStructBegin()
30398 
    while True:
30399 
      (fname, ftype, fid) = iprot.readFieldBegin()
30400 
      if ftype == TType.STOP:
30401 
        break
30402 
      if fid == 0:
30403 
        if ftype == TType.MAP:
30404 
          self.success = {}
30405 
          (_ktype715, _vtype716, _size714 ) = iprot.readMapBegin()
30406 
          for _i718 in xrange(_size714):
30407 
            _key719 = iprot.readI64();
6412 rajveer 30408 
            _val720 = iprot.readDouble();
6389 rajveer 30409 
            self.success[_key719] = _val720
30410 
          iprot.readMapEnd()
30411 
        else:
30412 
          iprot.skip(ftype)
30413 
      else:
30414 
        iprot.skip(ftype)
30415 
      iprot.readFieldEnd()
30416 
    iprot.readStructEnd()
30417 
 
30418 
  def write(self, oprot):
30419 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
30420 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
30421 
      return
30422 
    oprot.writeStructBegin('getMiscCharges_result')
30423 
    if self.success is not None:
30424 
      oprot.writeFieldBegin('success', TType.MAP, 0)
6412 rajveer 30425 
      oprot.writeMapBegin(TType.I64, TType.DOUBLE, len(self.success))
6389 rajveer 30426 
      for kiter721,viter722 in self.success.items():
30427 
        oprot.writeI64(kiter721)
6412 rajveer 30428 
        oprot.writeDouble(viter722)
6389 rajveer 30429 
      oprot.writeMapEnd()
30430 
      oprot.writeFieldEnd()
30431 
    oprot.writeFieldStop()
30432 
    oprot.writeStructEnd()
30433 
 
30434 
  def validate(self):
30435 
    return
30436 
 
30437 
 
30438 
  def __repr__(self):
30439 
    L = ['%s=%r' % (key, value)
30440 
      for key, value in self.__dict__.iteritems()]
30441 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
30442 
 
30443 
  def __eq__(self, other):
30444 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
30445 
 
30446 
  def __ne__(self, other):
30447 
    return not (self == other)
6507 anupam.sin 30448 
 
30449 
class refundRechargeOrder_args:
30450 
  """
30451 
  Attributes:
30452 
   - rechargeOrderId
30453 
  """
30454 
 
30455 
  thrift_spec = (
30456 
    None, # 0
30457 
    (1, TType.I64, 'rechargeOrderId', None, None, ), # 1
30458 
  )
30459 
 
30460 
  def __init__(self, rechargeOrderId=None,):
30461 
    self.rechargeOrderId = rechargeOrderId
30462 
 
30463 
  def read(self, iprot):
30464 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
30465 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
30466 
      return
30467 
    iprot.readStructBegin()
30468 
    while True:
30469 
      (fname, ftype, fid) = iprot.readFieldBegin()
30470 
      if ftype == TType.STOP:
30471 
        break
30472 
      if fid == 1:
30473 
        if ftype == TType.I64:
30474 
          self.rechargeOrderId = iprot.readI64();
30475 
        else:
30476 
          iprot.skip(ftype)
30477 
      else:
30478 
        iprot.skip(ftype)
30479 
      iprot.readFieldEnd()
30480 
    iprot.readStructEnd()
30481 
 
30482 
  def write(self, oprot):
30483 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
30484 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
30485 
      return
30486 
    oprot.writeStructBegin('refundRechargeOrder_args')
30487 
    if self.rechargeOrderId is not None:
30488 
      oprot.writeFieldBegin('rechargeOrderId', TType.I64, 1)
30489 
      oprot.writeI64(self.rechargeOrderId)
30490 
      oprot.writeFieldEnd()
30491 
    oprot.writeFieldStop()
30492 
    oprot.writeStructEnd()
30493 
 
30494 
  def validate(self):
30495 
    return
30496 
 
30497 
 
30498 
  def __repr__(self):
30499 
    L = ['%s=%r' % (key, value)
30500 
      for key, value in self.__dict__.iteritems()]
30501 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
30502 
 
30503 
  def __eq__(self, other):
30504 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
30505 
 
30506 
  def __ne__(self, other):
30507 
    return not (self == other)
30508 
 
30509 
class refundRechargeOrder_result:
30510 
  """
30511 
  Attributes:
30512 
   - success
30513 
   - ex
30514 
  """
30515 
 
30516 
  thrift_spec = (
30517 
    (0, TType.BOOL, 'success', None, None, ), # 0
30518 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
30519 
  )
30520 
 
30521 
  def __init__(self, success=None, ex=None,):
30522 
    self.success = success
30523 
    self.ex = ex
30524 
 
30525 
  def read(self, iprot):
30526 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
30527 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
30528 
      return
30529 
    iprot.readStructBegin()
30530 
    while True:
30531 
      (fname, ftype, fid) = iprot.readFieldBegin()
30532 
      if ftype == TType.STOP:
30533 
        break
30534 
      if fid == 0:
30535 
        if ftype == TType.BOOL:
30536 
          self.success = iprot.readBool();
30537 
        else:
30538 
          iprot.skip(ftype)
30539 
      elif fid == 1:
30540 
        if ftype == TType.STRUCT:
30541 
          self.ex = TransactionServiceException()
30542 
          self.ex.read(iprot)
30543 
        else:
30544 
          iprot.skip(ftype)
30545 
      else:
30546 
        iprot.skip(ftype)
30547 
      iprot.readFieldEnd()
30548 
    iprot.readStructEnd()
30549 
 
30550 
  def write(self, oprot):
30551 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
30552 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
30553 
      return
30554 
    oprot.writeStructBegin('refundRechargeOrder_result')
30555 
    if self.success is not None:
30556 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
30557 
      oprot.writeBool(self.success)
30558 
      oprot.writeFieldEnd()
30559 
    if self.ex is not None:
30560 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
30561 
      self.ex.write(oprot)
30562 
      oprot.writeFieldEnd()
30563 
    oprot.writeFieldStop()
30564 
    oprot.writeStructEnd()
30565 
 
30566 
  def validate(self):
30567 
    return
30568 
 
30569 
 
30570 
  def __repr__(self):
30571 
    L = ['%s=%r' % (key, value)
30572 
      for key, value in self.__dict__.iteritems()]
30573 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
30574 
 
30575 
  def __eq__(self, other):
30576 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
30577 
 
30578 
  def __ne__(self, other):
30579 
    return not (self == other)
6821 amar.kumar 30580 
 
30581 
class getPhysicalOrders_args:
30582 
  """
30583 
  Attributes:
30584 
   - fromDate
30585 
   - toDate
30586 
  """
30587 
 
30588 
  thrift_spec = (
30589 
    None, # 0
30590 
    (1, TType.I64, 'fromDate', None, None, ), # 1
30591 
    (2, TType.I64, 'toDate', None, None, ), # 2
30592 
  )
30593 
 
30594 
  def __init__(self, fromDate=None, toDate=None,):
30595 
    self.fromDate = fromDate
30596 
    self.toDate = toDate
30597 
 
30598 
  def read(self, iprot):
30599 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
30600 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
30601 
      return
30602 
    iprot.readStructBegin()
30603 
    while True:
30604 
      (fname, ftype, fid) = iprot.readFieldBegin()
30605 
      if ftype == TType.STOP:
30606 
        break
30607 
      if fid == 1:
30608 
        if ftype == TType.I64:
30609 
          self.fromDate = iprot.readI64();
30610 
        else:
30611 
          iprot.skip(ftype)
30612 
      elif fid == 2:
30613 
        if ftype == TType.I64:
30614 
          self.toDate = iprot.readI64();
30615 
        else:
30616 
          iprot.skip(ftype)
30617 
      else:
30618 
        iprot.skip(ftype)
30619 
      iprot.readFieldEnd()
30620 
    iprot.readStructEnd()
30621 
 
30622 
  def write(self, oprot):
30623 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
30624 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
30625 
      return
30626 
    oprot.writeStructBegin('getPhysicalOrders_args')
30627 
    if self.fromDate is not None:
30628 
      oprot.writeFieldBegin('fromDate', TType.I64, 1)
30629 
      oprot.writeI64(self.fromDate)
30630 
      oprot.writeFieldEnd()
30631 
    if self.toDate is not None:
30632 
      oprot.writeFieldBegin('toDate', TType.I64, 2)
30633 
      oprot.writeI64(self.toDate)
30634 
      oprot.writeFieldEnd()
30635 
    oprot.writeFieldStop()
30636 
    oprot.writeStructEnd()
30637 
 
30638 
  def validate(self):
30639 
    return
30640 
 
30641 
 
30642 
  def __repr__(self):
30643 
    L = ['%s=%r' % (key, value)
30644 
      for key, value in self.__dict__.iteritems()]
30645 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
30646 
 
30647 
  def __eq__(self, other):
30648 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
30649 
 
30650 
  def __ne__(self, other):
30651 
    return not (self == other)
30652 
 
30653 
class getPhysicalOrders_result:
30654 
  """
30655 
  Attributes:
30656 
   - success
30657 
  """
30658 
 
30659 
  thrift_spec = (
30660 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
30661 
  )
30662 
 
30663 
  def __init__(self, success=None,):
30664 
    self.success = success
30665 
 
30666 
  def read(self, iprot):
30667 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
30668 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
30669 
      return
30670 
    iprot.readStructBegin()
30671 
    while True:
30672 
      (fname, ftype, fid) = iprot.readFieldBegin()
30673 
      if ftype == TType.STOP:
30674 
        break
30675 
      if fid == 0:
30676 
        if ftype == TType.LIST:
30677 
          self.success = []
30678 
          (_etype726, _size723) = iprot.readListBegin()
30679 
          for _i727 in xrange(_size723):
30680 
            _elem728 = Order()
30681 
            _elem728.read(iprot)
30682 
            self.success.append(_elem728)
30683 
          iprot.readListEnd()
30684 
        else:
30685 
          iprot.skip(ftype)
30686 
      else:
30687 
        iprot.skip(ftype)
30688 
      iprot.readFieldEnd()
30689 
    iprot.readStructEnd()
30690 
 
30691 
  def write(self, oprot):
30692 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
30693 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
30694 
      return
30695 
    oprot.writeStructBegin('getPhysicalOrders_result')
30696 
    if self.success is not None:
30697 
      oprot.writeFieldBegin('success', TType.LIST, 0)
30698 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
30699 
      for iter729 in self.success:
30700 
        iter729.write(oprot)
30701 
      oprot.writeListEnd()
30702 
      oprot.writeFieldEnd()
30703 
    oprot.writeFieldStop()
30704 
    oprot.writeStructEnd()
30705 
 
30706 
  def validate(self):
30707 
    return
30708 
 
30709 
 
30710 
  def __repr__(self):
30711 
    L = ['%s=%r' % (key, value)
30712 
      for key, value in self.__dict__.iteritems()]
30713 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
30714 
 
30715 
  def __eq__(self, other):
30716 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
30717 
 
30718 
  def __ne__(self, other):
30719 
    return not (self == other)
6906 rajveer 30720 
 
30721 
class getDocument_args:
30722 
  """
30723 
  Attributes:
30724 
   - docType
30725 
   - docSource
30726 
  """
30727 
 
30728 
  thrift_spec = (
30729 
    None, # 0
30730 
    (1, TType.I64, 'docType', None, None, ), # 1
30731 
    (2, TType.I64, 'docSource', None, None, ), # 2
30732 
  )
30733 
 
30734 
  def __init__(self, docType=None, docSource=None,):
30735 
    self.docType = docType
30736 
    self.docSource = docSource
30737 
 
30738 
  def read(self, iprot):
30739 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
30740 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
30741 
      return
30742 
    iprot.readStructBegin()
30743 
    while True:
30744 
      (fname, ftype, fid) = iprot.readFieldBegin()
30745 
      if ftype == TType.STOP:
30746 
        break
30747 
      if fid == 1:
30748 
        if ftype == TType.I64:
30749 
          self.docType = iprot.readI64();
30750 
        else:
30751 
          iprot.skip(ftype)
30752 
      elif fid == 2:
30753 
        if ftype == TType.I64:
30754 
          self.docSource = iprot.readI64();
30755 
        else:
30756 
          iprot.skip(ftype)
30757 
      else:
30758 
        iprot.skip(ftype)
30759 
      iprot.readFieldEnd()
30760 
    iprot.readStructEnd()
30761 
 
30762 
  def write(self, oprot):
30763 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
30764 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
30765 
      return
30766 
    oprot.writeStructBegin('getDocument_args')
30767 
    if self.docType is not None:
30768 
      oprot.writeFieldBegin('docType', TType.I64, 1)
30769 
      oprot.writeI64(self.docType)
30770 
      oprot.writeFieldEnd()
30771 
    if self.docSource is not None:
30772 
      oprot.writeFieldBegin('docSource', TType.I64, 2)
30773 
      oprot.writeI64(self.docSource)
30774 
      oprot.writeFieldEnd()
30775 
    oprot.writeFieldStop()
30776 
    oprot.writeStructEnd()
30777 
 
30778 
  def validate(self):
30779 
    return
30780 
 
30781 
 
30782 
  def __repr__(self):
30783 
    L = ['%s=%r' % (key, value)
30784 
      for key, value in self.__dict__.iteritems()]
30785 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
30786 
 
30787 
  def __eq__(self, other):
30788 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
30789 
 
30790 
  def __ne__(self, other):
30791 
    return not (self == other)
30792 
 
30793 
class getDocument_result:
30794 
  """
30795 
  Attributes:
30796 
   - success
30797 
  """
30798 
 
30799 
  thrift_spec = (
30800 
    (0, TType.STRING, 'success', None, None, ), # 0
30801 
  )
30802 
 
30803 
  def __init__(self, success=None,):
30804 
    self.success = success
30805 
 
30806 
  def read(self, iprot):
30807 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
30808 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
30809 
      return
30810 
    iprot.readStructBegin()
30811 
    while True:
30812 
      (fname, ftype, fid) = iprot.readFieldBegin()
30813 
      if ftype == TType.STOP:
30814 
        break
30815 
      if fid == 0:
30816 
        if ftype == TType.STRING:
30817 
          self.success = iprot.readString();
30818 
        else:
30819 
          iprot.skip(ftype)
30820 
      else:
30821 
        iprot.skip(ftype)
30822 
      iprot.readFieldEnd()
30823 
    iprot.readStructEnd()
30824 
 
30825 
  def write(self, oprot):
30826 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
30827 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
30828 
      return
30829 
    oprot.writeStructBegin('getDocument_result')
30830 
    if self.success is not None:
30831 
      oprot.writeFieldBegin('success', TType.STRING, 0)
30832 
      oprot.writeString(self.success)
30833 
      oprot.writeFieldEnd()
30834 
    oprot.writeFieldStop()
30835 
    oprot.writeStructEnd()
30836 
 
30837 
  def validate(self):
30838 
    return
30839 
 
30840 
 
30841 
  def __repr__(self):
30842 
    L = ['%s=%r' % (key, value)
30843 
      for key, value in self.__dict__.iteritems()]
30844 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
30845 
 
30846 
  def __eq__(self, other):
30847 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
30848 
 
30849 
  def __ne__(self, other):
30850 
    return not (self == other)
6985 anupam.sin 30851 
 
30852 
class changeShippingAddress_args:
30853 
  """
30854 
  Attributes:
30855 
   - orderId
30856 
   - line1
30857 
   - line2
30858 
   - city
30859 
   - state
30860 
   - pin
30861 
  """
30862 
 
30863 
  thrift_spec = (
30864 
    None, # 0
30865 
    (1, TType.I64, 'orderId', None, None, ), # 1
30866 
    (2, TType.STRING, 'line1', None, None, ), # 2
30867 
    (3, TType.STRING, 'line2', None, None, ), # 3
30868 
    (4, TType.STRING, 'city', None, None, ), # 4
30869 
    (5, TType.STRING, 'state', None, None, ), # 5
30870 
    (6, TType.STRING, 'pin', None, None, ), # 6
30871 
  )
30872 
 
30873 
  def __init__(self, orderId=None, line1=None, line2=None, city=None, state=None, pin=None,):
30874 
    self.orderId = orderId
30875 
    self.line1 = line1
30876 
    self.line2 = line2
30877 
    self.city = city
30878 
    self.state = state
30879 
    self.pin = pin
30880 
 
30881 
  def read(self, iprot):
30882 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
30883 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
30884 
      return
30885 
    iprot.readStructBegin()
30886 
    while True:
30887 
      (fname, ftype, fid) = iprot.readFieldBegin()
30888 
      if ftype == TType.STOP:
30889 
        break
30890 
      if fid == 1:
30891 
        if ftype == TType.I64:
30892 
          self.orderId = iprot.readI64();
30893 
        else:
30894 
          iprot.skip(ftype)
30895 
      elif fid == 2:
30896 
        if ftype == TType.STRING:
30897 
          self.line1 = iprot.readString();
30898 
        else:
30899 
          iprot.skip(ftype)
30900 
      elif fid == 3:
30901 
        if ftype == TType.STRING:
30902 
          self.line2 = iprot.readString();
30903 
        else:
30904 
          iprot.skip(ftype)
30905 
      elif fid == 4:
30906 
        if ftype == TType.STRING:
30907 
          self.city = iprot.readString();
30908 
        else:
30909 
          iprot.skip(ftype)
30910 
      elif fid == 5:
30911 
        if ftype == TType.STRING:
30912 
          self.state = iprot.readString();
30913 
        else:
30914 
          iprot.skip(ftype)
30915 
      elif fid == 6:
30916 
        if ftype == TType.STRING:
30917 
          self.pin = iprot.readString();
30918 
        else:
30919 
          iprot.skip(ftype)
30920 
      else:
30921 
        iprot.skip(ftype)
30922 
      iprot.readFieldEnd()
30923 
    iprot.readStructEnd()
30924 
 
30925 
  def write(self, oprot):
30926 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
30927 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
30928 
      return
30929 
    oprot.writeStructBegin('changeShippingAddress_args')
30930 
    if self.orderId is not None:
30931 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
30932 
      oprot.writeI64(self.orderId)
30933 
      oprot.writeFieldEnd()
30934 
    if self.line1 is not None:
30935 
      oprot.writeFieldBegin('line1', TType.STRING, 2)
30936 
      oprot.writeString(self.line1)
30937 
      oprot.writeFieldEnd()
30938 
    if self.line2 is not None:
30939 
      oprot.writeFieldBegin('line2', TType.STRING, 3)
30940 
      oprot.writeString(self.line2)
30941 
      oprot.writeFieldEnd()
30942 
    if self.city is not None:
30943 
      oprot.writeFieldBegin('city', TType.STRING, 4)
30944 
      oprot.writeString(self.city)
30945 
      oprot.writeFieldEnd()
30946 
    if self.state is not None:
30947 
      oprot.writeFieldBegin('state', TType.STRING, 5)
30948 
      oprot.writeString(self.state)
30949 
      oprot.writeFieldEnd()
30950 
    if self.pin is not None:
30951 
      oprot.writeFieldBegin('pin', TType.STRING, 6)
30952 
      oprot.writeString(self.pin)
30953 
      oprot.writeFieldEnd()
30954 
    oprot.writeFieldStop()
30955 
    oprot.writeStructEnd()
30956 
 
30957 
  def validate(self):
30958 
    return
30959 
 
30960 
 
30961 
  def __repr__(self):
30962 
    L = ['%s=%r' % (key, value)
30963 
      for key, value in self.__dict__.iteritems()]
30964 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
30965 
 
30966 
  def __eq__(self, other):
30967 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
30968 
 
30969 
  def __ne__(self, other):
30970 
    return not (self == other)
30971 
 
30972 
class changeShippingAddress_result:
30973 
  """
30974 
  Attributes:
30975 
   - success
30976 
  """
30977 
 
30978 
  thrift_spec = (
30979 
    (0, TType.BOOL, 'success', None, None, ), # 0
30980 
  )
30981 
 
30982 
  def __init__(self, success=None,):
30983 
    self.success = success
30984 
 
30985 
  def read(self, iprot):
30986 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
30987 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
30988 
      return
30989 
    iprot.readStructBegin()
30990 
    while True:
30991 
      (fname, ftype, fid) = iprot.readFieldBegin()
30992 
      if ftype == TType.STOP:
30993 
        break
30994 
      if fid == 0:
30995 
        if ftype == TType.BOOL:
30996 
          self.success = iprot.readBool();
30997 
        else:
30998 
          iprot.skip(ftype)
30999 
      else:
31000 
        iprot.skip(ftype)
31001 
      iprot.readFieldEnd()
31002 
    iprot.readStructEnd()
31003 
 
31004 
  def write(self, oprot):
31005 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
31006 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
31007 
      return
31008 
    oprot.writeStructBegin('changeShippingAddress_result')
31009 
    if self.success is not None:
31010 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
31011 
      oprot.writeBool(self.success)
31012 
      oprot.writeFieldEnd()
31013 
    oprot.writeFieldStop()
31014 
    oprot.writeStructEnd()
31015 
 
31016 
  def validate(self):
31017 
    return
31018 
 
31019 
 
31020 
  def __repr__(self):
31021 
    L = ['%s=%r' % (key, value)
31022 
      for key, value in self.__dict__.iteritems()]
31023 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
31024 
 
31025 
  def __eq__(self, other):
31026 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
31027 
 
31028 
  def __ne__(self, other):
31029 
    return not (self == other)
6988 rajveer 31030 
 
31031 
class retrieveInvoice_args:
31032 
  """
31033 
  Attributes:
31034 
   - orderId
7075 rajveer 31035 
   - userId
6988 rajveer 31036 
  """
31037 
 
31038 
  thrift_spec = (
31039 
    None, # 0
31040 
    (1, TType.I64, 'orderId', None, None, ), # 1
7075 rajveer 31041 
    (2, TType.I64, 'userId', None, None, ), # 2
6988 rajveer 31042 
  )
31043 
 
7075 rajveer 31044 
  def __init__(self, orderId=None, userId=None,):
6988 rajveer 31045 
    self.orderId = orderId
7075 rajveer 31046 
    self.userId = userId
6988 rajveer 31047 
 
31048 
  def read(self, iprot):
31049 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
31050 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
31051 
      return
31052 
    iprot.readStructBegin()
31053 
    while True:
31054 
      (fname, ftype, fid) = iprot.readFieldBegin()
31055 
      if ftype == TType.STOP:
31056 
        break
31057 
      if fid == 1:
31058 
        if ftype == TType.I64:
31059 
          self.orderId = iprot.readI64();
31060 
        else:
31061 
          iprot.skip(ftype)
7075 rajveer 31062 
      elif fid == 2:
31063 
        if ftype == TType.I64:
31064 
          self.userId = iprot.readI64();
31065 
        else:
31066 
          iprot.skip(ftype)
6988 rajveer 31067 
      else:
31068 
        iprot.skip(ftype)
31069 
      iprot.readFieldEnd()
31070 
    iprot.readStructEnd()
31071 
 
31072 
  def write(self, oprot):
31073 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
31074 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
31075 
      return
31076 
    oprot.writeStructBegin('retrieveInvoice_args')
31077 
    if self.orderId is not None:
31078 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
31079 
      oprot.writeI64(self.orderId)
31080 
      oprot.writeFieldEnd()
7075 rajveer 31081 
    if self.userId is not None:
31082 
      oprot.writeFieldBegin('userId', TType.I64, 2)
31083 
      oprot.writeI64(self.userId)
31084 
      oprot.writeFieldEnd()
6988 rajveer 31085 
    oprot.writeFieldStop()
31086 
    oprot.writeStructEnd()
31087 
 
31088 
  def validate(self):
31089 
    return
31090 
 
31091 
 
31092 
  def __repr__(self):
31093 
    L = ['%s=%r' % (key, value)
31094 
      for key, value in self.__dict__.iteritems()]
31095 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
31096 
 
31097 
  def __eq__(self, other):
31098 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
31099 
 
31100 
  def __ne__(self, other):
31101 
    return not (self == other)
31102 
 
31103 
class retrieveInvoice_result:
31104 
  """
31105 
  Attributes:
31106 
   - success
31107 
  """
31108 
 
31109 
  thrift_spec = (
31110 
    (0, TType.STRING, 'success', None, None, ), # 0
31111 
  )
31112 
 
31113 
  def __init__(self, success=None,):
31114 
    self.success = success
31115 
 
31116 
  def read(self, iprot):
31117 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
31118 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
31119 
      return
31120 
    iprot.readStructBegin()
31121 
    while True:
31122 
      (fname, ftype, fid) = iprot.readFieldBegin()
31123 
      if ftype == TType.STOP:
31124 
        break
31125 
      if fid == 0:
31126 
        if ftype == TType.STRING:
31127 
          self.success = iprot.readString();
31128 
        else:
31129 
          iprot.skip(ftype)
31130 
      else:
31131 
        iprot.skip(ftype)
31132 
      iprot.readFieldEnd()
31133 
    iprot.readStructEnd()
31134 
 
31135 
  def write(self, oprot):
31136 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
31137 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
31138 
      return
31139 
    oprot.writeStructBegin('retrieveInvoice_result')
31140 
    if self.success is not None:
31141 
      oprot.writeFieldBegin('success', TType.STRING, 0)
31142 
      oprot.writeString(self.success)
31143 
      oprot.writeFieldEnd()
31144 
    oprot.writeFieldStop()
31145 
    oprot.writeStructEnd()
31146 
 
31147 
  def validate(self):
31148 
    return
31149 
 
31150 
 
31151 
  def __repr__(self):
31152 
    L = ['%s=%r' % (key, value)
31153 
      for key, value in self.__dict__.iteritems()]
31154 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
31155 
 
31156 
  def __eq__(self, other):
31157 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
31158 
 
31159 
  def __ne__(self, other):
31160 
    return not (self == other)
7026 rajveer 31161 
 
31162 
class receiveUpdatesForRedExpress_args:
31163 
  """
31164 
  Attributes:
31165 
   - awbNumber
31166 
  """
31167 
 
31168 
  thrift_spec = (
31169 
    None, # 0
31170 
    (1, TType.STRING, 'awbNumber', None, None, ), # 1
31171 
  )
31172 
 
31173 
  def __init__(self, awbNumber=None,):
31174 
    self.awbNumber = awbNumber
31175 
 
31176 
  def read(self, iprot):
31177 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
31178 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
31179 
      return
31180 
    iprot.readStructBegin()
31181 
    while True:
31182 
      (fname, ftype, fid) = iprot.readFieldBegin()
31183 
      if ftype == TType.STOP:
31184 
        break
31185 
      if fid == 1:
31186 
        if ftype == TType.STRING:
31187 
          self.awbNumber = iprot.readString();
31188 
        else:
31189 
          iprot.skip(ftype)
31190 
      else:
31191 
        iprot.skip(ftype)
31192 
      iprot.readFieldEnd()
31193 
    iprot.readStructEnd()
31194 
 
31195 
  def write(self, oprot):
31196 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
31197 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
31198 
      return
31199 
    oprot.writeStructBegin('receiveUpdatesForRedExpress_args')
31200 
    if self.awbNumber is not None:
31201 
      oprot.writeFieldBegin('awbNumber', TType.STRING, 1)
31202 
      oprot.writeString(self.awbNumber)
31203 
      oprot.writeFieldEnd()
31204 
    oprot.writeFieldStop()
31205 
    oprot.writeStructEnd()
31206 
 
31207 
  def validate(self):
31208 
    return
31209 
 
31210 
 
31211 
  def __repr__(self):
31212 
    L = ['%s=%r' % (key, value)
31213 
      for key, value in self.__dict__.iteritems()]
31214 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
31215 
 
31216 
  def __eq__(self, other):
31217 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
31218 
 
31219 
  def __ne__(self, other):
31220 
    return not (self == other)
31221 
 
31222 
class receiveUpdatesForRedExpress_result:
31223 
  """
31224 
  Attributes:
31225 
   - success
31226 
  """
31227 
 
31228 
  thrift_spec = (
31229 
    (0, TType.LIST, 'success', (TType.STRING,None), None, ), # 0
31230 
  )
31231 
 
31232 
  def __init__(self, success=None,):
31233 
    self.success = success
31234 
 
31235 
  def read(self, iprot):
31236 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
31237 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
31238 
      return
31239 
    iprot.readStructBegin()
31240 
    while True:
31241 
      (fname, ftype, fid) = iprot.readFieldBegin()
31242 
      if ftype == TType.STOP:
31243 
        break
31244 
      if fid == 0:
31245 
        if ftype == TType.LIST:
31246 
          self.success = []
31247 
          (_etype733, _size730) = iprot.readListBegin()
31248 
          for _i734 in xrange(_size730):
31249 
            _elem735 = iprot.readString();
31250 
            self.success.append(_elem735)
31251 
          iprot.readListEnd()
31252 
        else:
31253 
          iprot.skip(ftype)
31254 
      else:
31255 
        iprot.skip(ftype)
31256 
      iprot.readFieldEnd()
31257 
    iprot.readStructEnd()
31258 
 
31259 
  def write(self, oprot):
31260 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
31261 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
31262 
      return
31263 
    oprot.writeStructBegin('receiveUpdatesForRedExpress_result')
31264 
    if self.success is not None:
31265 
      oprot.writeFieldBegin('success', TType.LIST, 0)
31266 
      oprot.writeListBegin(TType.STRING, len(self.success))
31267 
      for iter736 in self.success:
31268 
        oprot.writeString(iter736)
31269 
      oprot.writeListEnd()
31270 
      oprot.writeFieldEnd()
31271 
    oprot.writeFieldStop()
31272 
    oprot.writeStructEnd()
31273 
 
31274 
  def validate(self):
31275 
    return
31276 
 
31277 
 
31278 
  def __repr__(self):
31279 
    L = ['%s=%r' % (key, value)
31280 
      for key, value in self.__dict__.iteritems()]
31281 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
31282 
 
31283 
  def __eq__(self, other):
31284 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
31285 
 
31286 
  def __ne__(self, other):
31287 
    return not (self == other)
7073 anupam.sin 31288 
 
31289 
class createRechargeTransaction_args:
31290 
  """
31291 
  Attributes:
31292 
   - thriftRechargeTransaction
31293 
  """
31294 
 
31295 
  thrift_spec = (
31296 
    None, # 0
31297 
    (1, TType.STRUCT, 'thriftRechargeTransaction', (RechargeTransaction, RechargeTransaction.thrift_spec), None, ), # 1
31298 
  )
31299 
 
31300 
  def __init__(self, thriftRechargeTransaction=None,):
31301 
    self.thriftRechargeTransaction = thriftRechargeTransaction
31302 
 
31303 
  def read(self, iprot):
31304 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
31305 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
31306 
      return
31307 
    iprot.readStructBegin()
31308 
    while True:
31309 
      (fname, ftype, fid) = iprot.readFieldBegin()
31310 
      if ftype == TType.STOP:
31311 
        break
31312 
      if fid == 1:
31313 
        if ftype == TType.STRUCT:
31314 
          self.thriftRechargeTransaction = RechargeTransaction()
31315 
          self.thriftRechargeTransaction.read(iprot)
31316 
        else:
31317 
          iprot.skip(ftype)
31318 
      else:
31319 
        iprot.skip(ftype)
31320 
      iprot.readFieldEnd()
31321 
    iprot.readStructEnd()
31322 
 
31323 
  def write(self, oprot):
31324 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
31325 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
31326 
      return
31327 
    oprot.writeStructBegin('createRechargeTransaction_args')
31328 
    if self.thriftRechargeTransaction is not None:
31329 
      oprot.writeFieldBegin('thriftRechargeTransaction', TType.STRUCT, 1)
31330 
      self.thriftRechargeTransaction.write(oprot)
31331 
      oprot.writeFieldEnd()
31332 
    oprot.writeFieldStop()
31333 
    oprot.writeStructEnd()
31334 
 
31335 
  def validate(self):
31336 
    return
31337 
 
31338 
 
31339 
  def __repr__(self):
31340 
    L = ['%s=%r' % (key, value)
31341 
      for key, value in self.__dict__.iteritems()]
31342 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
31343 
 
31344 
  def __eq__(self, other):
31345 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
31346 
 
31347 
  def __ne__(self, other):
31348 
    return not (self == other)
31349 
 
31350 
class createRechargeTransaction_result:
31351 
  """
31352 
  Attributes:
31353 
   - success
31354 
  """
31355 
 
31356 
  thrift_spec = (
31357 
    (0, TType.STRUCT, 'success', (RechargeTransaction, RechargeTransaction.thrift_spec), None, ), # 0
31358 
  )
31359 
 
31360 
  def __init__(self, success=None,):
31361 
    self.success = success
31362 
 
31363 
  def read(self, iprot):
31364 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
31365 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
31366 
      return
31367 
    iprot.readStructBegin()
31368 
    while True:
31369 
      (fname, ftype, fid) = iprot.readFieldBegin()
31370 
      if ftype == TType.STOP:
31371 
        break
31372 
      if fid == 0:
31373 
        if ftype == TType.STRUCT:
31374 
          self.success = RechargeTransaction()
31375 
          self.success.read(iprot)
31376 
        else:
31377 
          iprot.skip(ftype)
31378 
      else:
31379 
        iprot.skip(ftype)
31380 
      iprot.readFieldEnd()
31381 
    iprot.readStructEnd()
31382 
 
31383 
  def write(self, oprot):
31384 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
31385 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
31386 
      return
31387 
    oprot.writeStructBegin('createRechargeTransaction_result')
31388 
    if self.success is not None:
31389 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
31390 
      self.success.write(oprot)
31391 
      oprot.writeFieldEnd()
31392 
    oprot.writeFieldStop()
31393 
    oprot.writeStructEnd()
31394 
 
31395 
  def validate(self):
31396 
    return
31397 
 
31398 
 
31399 
  def __repr__(self):
31400 
    L = ['%s=%r' % (key, value)
31401 
      for key, value in self.__dict__.iteritems()]
31402 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
31403 
 
31404 
  def __eq__(self, other):
31405 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
31406 
 
31407 
  def __ne__(self, other):
31408 
    return not (self == other)
7080 anupam.sin 31409 
 
7085 rajveer 31410 
class getRechargeTransactions_args:
31411 
  """
31412 
  Attributes:
31413 
   - storeId
31414 
  """
31415 
 
31416 
  thrift_spec = (
31417 
    None, # 0
31418 
    (1, TType.I64, 'storeId', None, None, ), # 1
31419 
  )
31420 
 
31421 
  def __init__(self, storeId=None,):
31422 
    self.storeId = storeId
31423 
 
31424 
  def read(self, iprot):
31425 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
31426 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
31427 
      return
31428 
    iprot.readStructBegin()
31429 
    while True:
31430 
      (fname, ftype, fid) = iprot.readFieldBegin()
31431 
      if ftype == TType.STOP:
31432 
        break
31433 
      if fid == 1:
31434 
        if ftype == TType.I64:
31435 
          self.storeId = iprot.readI64();
31436 
        else:
31437 
          iprot.skip(ftype)
31438 
      else:
31439 
        iprot.skip(ftype)
31440 
      iprot.readFieldEnd()
31441 
    iprot.readStructEnd()
31442 
 
31443 
  def write(self, oprot):
31444 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
31445 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
31446 
      return
31447 
    oprot.writeStructBegin('getRechargeTransactions_args')
31448 
    if self.storeId is not None:
31449 
      oprot.writeFieldBegin('storeId', TType.I64, 1)
31450 
      oprot.writeI64(self.storeId)
31451 
      oprot.writeFieldEnd()
31452 
    oprot.writeFieldStop()
31453 
    oprot.writeStructEnd()
31454 
 
31455 
  def validate(self):
31456 
    return
31457 
 
31458 
 
31459 
  def __repr__(self):
31460 
    L = ['%s=%r' % (key, value)
31461 
      for key, value in self.__dict__.iteritems()]
31462 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
31463 
 
31464 
  def __eq__(self, other):
31465 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
31466 
 
31467 
  def __ne__(self, other):
31468 
    return not (self == other)
31469 
 
31470 
class getRechargeTransactions_result:
31471 
  """
31472 
  Attributes:
31473 
   - success
31474 
  """
31475 
 
31476 
  thrift_spec = (
31477 
    (0, TType.LIST, 'success', (TType.STRUCT,(RechargeTransaction, RechargeTransaction.thrift_spec)), None, ), # 0
31478 
  )
31479 
 
31480 
  def __init__(self, success=None,):
31481 
    self.success = success
31482 
 
31483 
  def read(self, iprot):
31484 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
31485 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
31486 
      return
31487 
    iprot.readStructBegin()
31488 
    while True:
31489 
      (fname, ftype, fid) = iprot.readFieldBegin()
31490 
      if ftype == TType.STOP:
31491 
        break
31492 
      if fid == 0:
31493 
        if ftype == TType.LIST:
31494 
          self.success = []
31495 
          (_etype740, _size737) = iprot.readListBegin()
31496 
          for _i741 in xrange(_size737):
31497 
            _elem742 = RechargeTransaction()
31498 
            _elem742.read(iprot)
31499 
            self.success.append(_elem742)
31500 
          iprot.readListEnd()
31501 
        else:
31502 
          iprot.skip(ftype)
31503 
      else:
31504 
        iprot.skip(ftype)
31505 
      iprot.readFieldEnd()
31506 
    iprot.readStructEnd()
31507 
 
31508 
  def write(self, oprot):
31509 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
31510 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
31511 
      return
31512 
    oprot.writeStructBegin('getRechargeTransactions_result')
31513 
    if self.success is not None:
31514 
      oprot.writeFieldBegin('success', TType.LIST, 0)
31515 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
31516 
      for iter743 in self.success:
31517 
        iter743.write(oprot)
31518 
      oprot.writeListEnd()
31519 
      oprot.writeFieldEnd()
31520 
    oprot.writeFieldStop()
31521 
    oprot.writeStructEnd()
31522 
 
31523 
  def validate(self):
31524 
    return
31525 
 
31526 
 
31527 
  def __repr__(self):
31528 
    L = ['%s=%r' % (key, value)
31529 
      for key, value in self.__dict__.iteritems()]
31530 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
31531 
 
31532 
  def __eq__(self, other):
31533 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
31534 
 
31535 
  def __ne__(self, other):
31536 
    return not (self == other)
31537 
 
7151 amit.gupta 31538 
class getRechargeTrans_args:
31539 
  """
31540 
  Attributes:
31541 
   - storeId
31542 
   - startDate
31543 
   - endDate
31544 
   - status
31545 
  """
31546 
 
31547 
  thrift_spec = (
31548 
    None, # 0
31549 
    (1, TType.I64, 'storeId', None, None, ), # 1
31550 
    (2, TType.I64, 'startDate', None, None, ), # 2
31551 
    (3, TType.I64, 'endDate', None, None, ), # 3
31552 
    (4, TType.I32, 'status', None, None, ), # 4
31553 
  )
31554 
 
31555 
  def __init__(self, storeId=None, startDate=None, endDate=None, status=None,):
31556 
    self.storeId = storeId
31557 
    self.startDate = startDate
31558 
    self.endDate = endDate
31559 
    self.status = status
31560 
 
31561 
  def read(self, iprot):
31562 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
31563 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
31564 
      return
31565 
    iprot.readStructBegin()
31566 
    while True:
31567 
      (fname, ftype, fid) = iprot.readFieldBegin()
31568 
      if ftype == TType.STOP:
31569 
        break
31570 
      if fid == 1:
31571 
        if ftype == TType.I64:
31572 
          self.storeId = iprot.readI64();
31573 
        else:
31574 
          iprot.skip(ftype)
31575 
      elif fid == 2:
31576 
        if ftype == TType.I64:
31577 
          self.startDate = iprot.readI64();
31578 
        else:
31579 
          iprot.skip(ftype)
31580 
      elif fid == 3:
31581 
        if ftype == TType.I64:
31582 
          self.endDate = iprot.readI64();
31583 
        else:
31584 
          iprot.skip(ftype)
31585 
      elif fid == 4:
31586 
        if ftype == TType.I32:
31587 
          self.status = iprot.readI32();
31588 
        else:
31589 
          iprot.skip(ftype)
31590 
      else:
31591 
        iprot.skip(ftype)
31592 
      iprot.readFieldEnd()
31593 
    iprot.readStructEnd()
31594 
 
31595 
  def write(self, oprot):
31596 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
31597 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
31598 
      return
31599 
    oprot.writeStructBegin('getRechargeTrans_args')
31600 
    if self.storeId is not None:
31601 
      oprot.writeFieldBegin('storeId', TType.I64, 1)
31602 
      oprot.writeI64(self.storeId)
31603 
      oprot.writeFieldEnd()
31604 
    if self.startDate is not None:
31605 
      oprot.writeFieldBegin('startDate', TType.I64, 2)
31606 
      oprot.writeI64(self.startDate)
31607 
      oprot.writeFieldEnd()
31608 
    if self.endDate is not None:
31609 
      oprot.writeFieldBegin('endDate', TType.I64, 3)
31610 
      oprot.writeI64(self.endDate)
31611 
      oprot.writeFieldEnd()
31612 
    if self.status is not None:
31613 
      oprot.writeFieldBegin('status', TType.I32, 4)
31614 
      oprot.writeI32(self.status)
31615 
      oprot.writeFieldEnd()
31616 
    oprot.writeFieldStop()
31617 
    oprot.writeStructEnd()
31618 
 
31619 
  def validate(self):
31620 
    return
31621 
 
31622 
 
31623 
  def __repr__(self):
31624 
    L = ['%s=%r' % (key, value)
31625 
      for key, value in self.__dict__.iteritems()]
31626 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
31627 
 
31628 
  def __eq__(self, other):
31629 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
31630 
 
31631 
  def __ne__(self, other):
31632 
    return not (self == other)
31633 
 
31634 
class getRechargeTrans_result:
31635 
  """
31636 
  Attributes:
31637 
   - success
31638 
  """
31639 
 
31640 
  thrift_spec = (
31641 
    (0, TType.LIST, 'success', (TType.STRUCT,(RechargeTransaction, RechargeTransaction.thrift_spec)), None, ), # 0
31642 
  )
31643 
 
31644 
  def __init__(self, success=None,):
31645 
    self.success = success
31646 
 
31647 
  def read(self, iprot):
31648 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
31649 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
31650 
      return
31651 
    iprot.readStructBegin()
31652 
    while True:
31653 
      (fname, ftype, fid) = iprot.readFieldBegin()
31654 
      if ftype == TType.STOP:
31655 
        break
31656 
      if fid == 0:
31657 
        if ftype == TType.LIST:
31658 
          self.success = []
31659 
          (_etype747, _size744) = iprot.readListBegin()
31660 
          for _i748 in xrange(_size744):
31661 
            _elem749 = RechargeTransaction()
31662 
            _elem749.read(iprot)
31663 
            self.success.append(_elem749)
31664 
          iprot.readListEnd()
31665 
        else:
31666 
          iprot.skip(ftype)
31667 
      else:
31668 
        iprot.skip(ftype)
31669 
      iprot.readFieldEnd()
31670 
    iprot.readStructEnd()
31671 
 
31672 
  def write(self, oprot):
31673 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
31674 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
31675 
      return
31676 
    oprot.writeStructBegin('getRechargeTrans_result')
31677 
    if self.success is not None:
31678 
      oprot.writeFieldBegin('success', TType.LIST, 0)
31679 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
31680 
      for iter750 in self.success:
31681 
        iter750.write(oprot)
31682 
      oprot.writeListEnd()
31683 
      oprot.writeFieldEnd()
31684 
    oprot.writeFieldStop()
31685 
    oprot.writeStructEnd()
31686 
 
31687 
  def validate(self):
31688 
    return
31689 
 
31690 
 
31691 
  def __repr__(self):
31692 
    L = ['%s=%r' % (key, value)
31693 
      for key, value in self.__dict__.iteritems()]
31694 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
31695 
 
31696 
  def __eq__(self, other):
31697 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
31698 
 
31699 
  def __ne__(self, other):
31700 
    return not (self == other)
31701 
 
7080 anupam.sin 31702 
class getRechargeTransaction_args:
31703 
  """
31704 
  Attributes:
31705 
   - rechargeId
31706 
  """
31707 
 
31708 
  thrift_spec = (
31709 
    None, # 0
31710 
    (1, TType.I64, 'rechargeId', None, None, ), # 1
31711 
  )
31712 
 
31713 
  def __init__(self, rechargeId=None,):
31714 
    self.rechargeId = rechargeId
31715 
 
31716 
  def read(self, iprot):
31717 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
31718 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
31719 
      return
31720 
    iprot.readStructBegin()
31721 
    while True:
31722 
      (fname, ftype, fid) = iprot.readFieldBegin()
31723 
      if ftype == TType.STOP:
31724 
        break
31725 
      if fid == 1:
31726 
        if ftype == TType.I64:
31727 
          self.rechargeId = iprot.readI64();
31728 
        else:
31729 
          iprot.skip(ftype)
31730 
      else:
31731 
        iprot.skip(ftype)
31732 
      iprot.readFieldEnd()
31733 
    iprot.readStructEnd()
31734 
 
31735 
  def write(self, oprot):
31736 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
31737 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
31738 
      return
31739 
    oprot.writeStructBegin('getRechargeTransaction_args')
31740 
    if self.rechargeId is not None:
31741 
      oprot.writeFieldBegin('rechargeId', TType.I64, 1)
31742 
      oprot.writeI64(self.rechargeId)
31743 
      oprot.writeFieldEnd()
31744 
    oprot.writeFieldStop()
31745 
    oprot.writeStructEnd()
31746 
 
31747 
  def validate(self):
31748 
    return
31749 
 
31750 
 
31751 
  def __repr__(self):
31752 
    L = ['%s=%r' % (key, value)
31753 
      for key, value in self.__dict__.iteritems()]
31754 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
31755 
 
31756 
  def __eq__(self, other):
31757 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
31758 
 
31759 
  def __ne__(self, other):
31760 
    return not (self == other)
31761 
 
31762 
class getRechargeTransaction_result:
31763 
  """
31764 
  Attributes:
31765 
   - success
31766 
  """
31767 
 
31768 
  thrift_spec = (
31769 
    (0, TType.STRUCT, 'success', (RechargeTransaction, RechargeTransaction.thrift_spec), None, ), # 0
31770 
  )
31771 
 
31772 
  def __init__(self, success=None,):
31773 
    self.success = success
31774 
 
31775 
  def read(self, iprot):
31776 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
31777 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
31778 
      return
31779 
    iprot.readStructBegin()
31780 
    while True:
31781 
      (fname, ftype, fid) = iprot.readFieldBegin()
31782 
      if ftype == TType.STOP:
31783 
        break
31784 
      if fid == 0:
31785 
        if ftype == TType.STRUCT:
31786 
          self.success = RechargeTransaction()
31787 
          self.success.read(iprot)
31788 
        else:
31789 
          iprot.skip(ftype)
31790 
      else:
31791 
        iprot.skip(ftype)
31792 
      iprot.readFieldEnd()
31793 
    iprot.readStructEnd()
31794 
 
31795 
  def write(self, oprot):
31796 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
31797 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
31798 
      return
31799 
    oprot.writeStructBegin('getRechargeTransaction_result')
31800 
    if self.success is not None:
31801 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
31802 
      self.success.write(oprot)
31803 
      oprot.writeFieldEnd()
31804 
    oprot.writeFieldStop()
31805 
    oprot.writeStructEnd()
31806 
 
31807 
  def validate(self):
31808 
    return
31809 
 
31810 
 
31811 
  def __repr__(self):
31812 
    L = ['%s=%r' % (key, value)
31813 
      for key, value in self.__dict__.iteritems()]
31814 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
31815 
 
31816 
  def __eq__(self, other):
31817 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
31818 
 
31819 
  def __ne__(self, other):
31820 
    return not (self == other)
31821 
 
31822 
class getFRCs_args:
31823 
  """
31824 
  Attributes:
31825 
   - circleId
31826 
   - operatorId
31827 
  """
31828 
 
31829 
  thrift_spec = (
31830 
    None, # 0
31831 
    (1, TType.I64, 'circleId', None, None, ), # 1
31832 
    (2, TType.I64, 'operatorId', None, None, ), # 2
31833 
  )
31834 
 
31835 
  def __init__(self, circleId=None, operatorId=None,):
31836 
    self.circleId = circleId
31837 
    self.operatorId = operatorId
31838 
 
31839 
  def read(self, iprot):
31840 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
31841 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
31842 
      return
31843 
    iprot.readStructBegin()
31844 
    while True:
31845 
      (fname, ftype, fid) = iprot.readFieldBegin()
31846 
      if ftype == TType.STOP:
31847 
        break
31848 
      if fid == 1:
31849 
        if ftype == TType.I64:
31850 
          self.circleId = iprot.readI64();
31851 
        else:
31852 
          iprot.skip(ftype)
31853 
      elif fid == 2:
31854 
        if ftype == TType.I64:
31855 
          self.operatorId = iprot.readI64();
31856 
        else:
31857 
          iprot.skip(ftype)
31858 
      else:
31859 
        iprot.skip(ftype)
31860 
      iprot.readFieldEnd()
31861 
    iprot.readStructEnd()
31862 
 
31863 
  def write(self, oprot):
31864 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
31865 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
31866 
      return
31867 
    oprot.writeStructBegin('getFRCs_args')
31868 
    if self.circleId is not None:
31869 
      oprot.writeFieldBegin('circleId', TType.I64, 1)
31870 
      oprot.writeI64(self.circleId)
31871 
      oprot.writeFieldEnd()
31872 
    if self.operatorId is not None:
31873 
      oprot.writeFieldBegin('operatorId', TType.I64, 2)
31874 
      oprot.writeI64(self.operatorId)
31875 
      oprot.writeFieldEnd()
31876 
    oprot.writeFieldStop()
31877 
    oprot.writeStructEnd()
31878 
 
31879 
  def validate(self):
31880 
    return
31881 
 
31882 
 
31883 
  def __repr__(self):
31884 
    L = ['%s=%r' % (key, value)
31885 
      for key, value in self.__dict__.iteritems()]
31886 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
31887 
 
31888 
  def __eq__(self, other):
31889 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
31890 
 
31891 
  def __ne__(self, other):
31892 
    return not (self == other)
31893 
 
31894 
class getFRCs_result:
31895 
  """
31896 
  Attributes:
31897 
   - success
31898 
  """
31899 
 
31900 
  thrift_spec = (
31901 
    (0, TType.LIST, 'success', (TType.STRUCT,(FRC, FRC.thrift_spec)), None, ), # 0
31902 
  )
31903 
 
31904 
  def __init__(self, success=None,):
31905 
    self.success = success
31906 
 
31907 
  def read(self, iprot):
31908 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
31909 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
31910 
      return
31911 
    iprot.readStructBegin()
31912 
    while True:
31913 
      (fname, ftype, fid) = iprot.readFieldBegin()
31914 
      if ftype == TType.STOP:
31915 
        break
31916 
      if fid == 0:
31917 
        if ftype == TType.LIST:
31918 
          self.success = []
7151 amit.gupta 31919 
          (_etype754, _size751) = iprot.readListBegin()
31920 
          for _i755 in xrange(_size751):
31921 
            _elem756 = FRC()
31922 
            _elem756.read(iprot)
31923 
            self.success.append(_elem756)
7080 anupam.sin 31924 
          iprot.readListEnd()
31925 
        else:
31926 
          iprot.skip(ftype)
31927 
      else:
31928 
        iprot.skip(ftype)
31929 
      iprot.readFieldEnd()
31930 
    iprot.readStructEnd()
31931 
 
31932 
  def write(self, oprot):
31933 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
31934 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
31935 
      return
31936 
    oprot.writeStructBegin('getFRCs_result')
31937 
    if self.success is not None:
31938 
      oprot.writeFieldBegin('success', TType.LIST, 0)
31939 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
7151 amit.gupta 31940 
      for iter757 in self.success:
31941 
        iter757.write(oprot)
7080 anupam.sin 31942 
      oprot.writeListEnd()
31943 
      oprot.writeFieldEnd()
31944 
    oprot.writeFieldStop()
31945 
    oprot.writeStructEnd()
31946 
 
31947 
  def validate(self):
31948 
    return
31949 
 
31950 
 
31951 
  def __repr__(self):
31952 
    L = ['%s=%r' % (key, value)
31953 
      for key, value in self.__dict__.iteritems()]
31954 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
31955 
 
31956 
  def __eq__(self, other):
31957 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
31958 
 
31959 
  def __ne__(self, other):
31960 
    return not (self == other)
7096 anupam.sin 31961 
 
31962 
class getHotspotStore_args:
31963 
  """
31964 
  Attributes:
31965 
   - id
31966 
   - hotspotid
31967 
  """
31968 
 
31969 
  thrift_spec = (
31970 
    None, # 0
31971 
    (1, TType.I64, 'id', None, None, ), # 1
31972 
    (2, TType.STRING, 'hotspotid', None, None, ), # 2
31973 
  )
31974 
 
31975 
  def __init__(self, id=None, hotspotid=None,):
31976 
    self.id = id
31977 
    self.hotspotid = hotspotid
31978 
 
31979 
  def read(self, iprot):
31980 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
31981 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
31982 
      return
31983 
    iprot.readStructBegin()
31984 
    while True:
31985 
      (fname, ftype, fid) = iprot.readFieldBegin()
31986 
      if ftype == TType.STOP:
31987 
        break
31988 
      if fid == 1:
31989 
        if ftype == TType.I64:
31990 
          self.id = iprot.readI64();
31991 
        else:
31992 
          iprot.skip(ftype)
31993 
      elif fid == 2:
31994 
        if ftype == TType.STRING:
31995 
          self.hotspotid = iprot.readString();
31996 
        else:
31997 
          iprot.skip(ftype)
31998 
      else:
31999 
        iprot.skip(ftype)
32000 
      iprot.readFieldEnd()
32001 
    iprot.readStructEnd()
32002 
 
32003 
  def write(self, oprot):
32004 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
32005 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
32006 
      return
32007 
    oprot.writeStructBegin('getHotspotStore_args')
32008 
    if self.id is not None:
32009 
      oprot.writeFieldBegin('id', TType.I64, 1)
32010 
      oprot.writeI64(self.id)
32011 
      oprot.writeFieldEnd()
32012 
    if self.hotspotid is not None:
32013 
      oprot.writeFieldBegin('hotspotid', TType.STRING, 2)
32014 
      oprot.writeString(self.hotspotid)
32015 
      oprot.writeFieldEnd()
32016 
    oprot.writeFieldStop()
32017 
    oprot.writeStructEnd()
32018 
 
32019 
  def validate(self):
32020 
    return
32021 
 
32022 
 
32023 
  def __repr__(self):
32024 
    L = ['%s=%r' % (key, value)
32025 
      for key, value in self.__dict__.iteritems()]
32026 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
32027 
 
32028 
  def __eq__(self, other):
32029 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
32030 
 
32031 
  def __ne__(self, other):
32032 
    return not (self == other)
32033 
 
32034 
class getHotspotStore_result:
32035 
  """
32036 
  Attributes:
32037 
   - success
32038 
  """
32039 
 
32040 
  thrift_spec = (
32041 
    (0, TType.STRUCT, 'success', (HotspotStore, HotspotStore.thrift_spec), None, ), # 0
32042 
  )
32043 
 
32044 
  def __init__(self, success=None,):
32045 
    self.success = success
32046 
 
32047 
  def read(self, iprot):
32048 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
32049 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
32050 
      return
32051 
    iprot.readStructBegin()
32052 
    while True:
32053 
      (fname, ftype, fid) = iprot.readFieldBegin()
32054 
      if ftype == TType.STOP:
32055 
        break
32056 
      if fid == 0:
32057 
        if ftype == TType.STRUCT:
32058 
          self.success = HotspotStore()
32059 
          self.success.read(iprot)
32060 
        else:
32061 
          iprot.skip(ftype)
32062 
      else:
32063 
        iprot.skip(ftype)
32064 
      iprot.readFieldEnd()
32065 
    iprot.readStructEnd()
32066 
 
32067 
  def write(self, oprot):
32068 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
32069 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
32070 
      return
32071 
    oprot.writeStructBegin('getHotspotStore_result')
32072 
    if self.success is not None:
32073 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
32074 
      self.success.write(oprot)
32075 
      oprot.writeFieldEnd()
32076 
    oprot.writeFieldStop()
32077 
    oprot.writeStructEnd()
32078 
 
32079 
  def validate(self):
32080 
    return
32081 
 
32082 
 
32083 
  def __repr__(self):
32084 
    L = ['%s=%r' % (key, value)
32085 
      for key, value in self.__dict__.iteritems()]
32086 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
32087 
 
32088 
  def __eq__(self, other):
32089 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
32090 
 
32091 
  def __ne__(self, other):
32092 
    return not (self == other)
32093 
 
32094 
class getTelecomCircle_args:
32095 
  """
32096 
  Attributes:
32097 
   - id
32098 
   - code
32099 
  """
32100 
 
32101 
  thrift_spec = (
32102 
    None, # 0
32103 
    (1, TType.I64, 'id', None, None, ), # 1
32104 
    (2, TType.STRING, 'code', None, None, ), # 2
32105 
  )
32106 
 
32107 
  def __init__(self, id=None, code=None,):
32108 
    self.id = id
32109 
    self.code = code
32110 
 
32111 
  def read(self, iprot):
32112 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
32113 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
32114 
      return
32115 
    iprot.readStructBegin()
32116 
    while True:
32117 
      (fname, ftype, fid) = iprot.readFieldBegin()
32118 
      if ftype == TType.STOP:
32119 
        break
32120 
      if fid == 1:
32121 
        if ftype == TType.I64:
32122 
          self.id = iprot.readI64();
32123 
        else:
32124 
          iprot.skip(ftype)
32125 
      elif fid == 2:
32126 
        if ftype == TType.STRING:
32127 
          self.code = iprot.readString();
32128 
        else:
32129 
          iprot.skip(ftype)
32130 
      else:
32131 
        iprot.skip(ftype)
32132 
      iprot.readFieldEnd()
32133 
    iprot.readStructEnd()
32134 
 
32135 
  def write(self, oprot):
32136 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
32137 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
32138 
      return
32139 
    oprot.writeStructBegin('getTelecomCircle_args')
32140 
    if self.id is not None:
32141 
      oprot.writeFieldBegin('id', TType.I64, 1)
32142 
      oprot.writeI64(self.id)
32143 
      oprot.writeFieldEnd()
32144 
    if self.code is not None:
32145 
      oprot.writeFieldBegin('code', TType.STRING, 2)
32146 
      oprot.writeString(self.code)
32147 
      oprot.writeFieldEnd()
32148 
    oprot.writeFieldStop()
32149 
    oprot.writeStructEnd()
32150 
 
32151 
  def validate(self):
32152 
    return
32153 
 
32154 
 
32155 
  def __repr__(self):
32156 
    L = ['%s=%r' % (key, value)
32157 
      for key, value in self.__dict__.iteritems()]
32158 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
32159 
 
32160 
  def __eq__(self, other):
32161 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
32162 
 
32163 
  def __ne__(self, other):
32164 
    return not (self == other)
32165 
 
32166 
class getTelecomCircle_result:
32167 
  """
32168 
  Attributes:
32169 
   - success
32170 
  """
32171 
 
32172 
  thrift_spec = (
32173 
    (0, TType.STRUCT, 'success', (TelecomCircle, TelecomCircle.thrift_spec), None, ), # 0
32174 
  )
32175 
 
32176 
  def __init__(self, success=None,):
32177 
    self.success = success
32178 
 
32179 
  def read(self, iprot):
32180 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
32181 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
32182 
      return
32183 
    iprot.readStructBegin()
32184 
    while True:
32185 
      (fname, ftype, fid) = iprot.readFieldBegin()
32186 
      if ftype == TType.STOP:
32187 
        break
32188 
      if fid == 0:
32189 
        if ftype == TType.STRUCT:
32190 
          self.success = TelecomCircle()
32191 
          self.success.read(iprot)
32192 
        else:
32193 
          iprot.skip(ftype)
32194 
      else:
32195 
        iprot.skip(ftype)
32196 
      iprot.readFieldEnd()
32197 
    iprot.readStructEnd()
32198 
 
32199 
  def write(self, oprot):
32200 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
32201 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
32202 
      return
32203 
    oprot.writeStructBegin('getTelecomCircle_result')
32204 
    if self.success is not None:
32205 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
32206 
      self.success.write(oprot)
32207 
      oprot.writeFieldEnd()
32208 
    oprot.writeFieldStop()
32209 
    oprot.writeStructEnd()
32210 
 
32211 
  def validate(self):
32212 
    return
32213 
 
32214 
 
32215 
  def __repr__(self):
32216 
    L = ['%s=%r' % (key, value)
32217 
      for key, value in self.__dict__.iteritems()]
32218 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
32219 
 
32220 
  def __eq__(self, other):
32221 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
32222 
 
32223 
  def __ne__(self, other):
32224 
    return not (self == other)
7109 anupam.sin 32225 
 
32226 
class retrieveHotspotRechargeInvoice_args:
32227 
  """
32228 
  Attributes:
32229 
   - rechargeId
32230 
  """
32231 
 
32232 
  thrift_spec = (
32233 
    None, # 0
32234 
    (1, TType.I64, 'rechargeId', None, None, ), # 1
32235 
  )
32236 
 
32237 
  def __init__(self, rechargeId=None,):
32238 
    self.rechargeId = rechargeId
32239 
 
32240 
  def read(self, iprot):
32241 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
32242 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
32243 
      return
32244 
    iprot.readStructBegin()
32245 
    while True:
32246 
      (fname, ftype, fid) = iprot.readFieldBegin()
32247 
      if ftype == TType.STOP:
32248 
        break
32249 
      if fid == 1:
32250 
        if ftype == TType.I64:
32251 
          self.rechargeId = 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('retrieveHotspotRechargeInvoice_args')
32264 
    if self.rechargeId is not None:
32265 
      oprot.writeFieldBegin('rechargeId', TType.I64, 1)
32266 
      oprot.writeI64(self.rechargeId)
32267 
      oprot.writeFieldEnd()
32268 
    oprot.writeFieldStop()
32269 
    oprot.writeStructEnd()
32270 
 
32271 
  def validate(self):
32272 
    return
32273 
 
32274 
 
32275 
  def __repr__(self):
32276 
    L = ['%s=%r' % (key, value)
32277 
      for key, value in self.__dict__.iteritems()]
32278 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
32279 
 
32280 
  def __eq__(self, other):
32281 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
32282 
 
32283 
  def __ne__(self, other):
32284 
    return not (self == other)
32285 
 
32286 
class retrieveHotspotRechargeInvoice_result:
32287 
  """
32288 
  Attributes:
32289 
   - success
32290 
  """
32291 
 
32292 
  thrift_spec = (
32293 
    (0, TType.STRING, 'success', None, None, ), # 0
32294 
  )
32295 
 
32296 
  def __init__(self, success=None,):
32297 
    self.success = success
32298 
 
32299 
  def read(self, iprot):
32300 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
32301 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
32302 
      return
32303 
    iprot.readStructBegin()
32304 
    while True:
32305 
      (fname, ftype, fid) = iprot.readFieldBegin()
32306 
      if ftype == TType.STOP:
32307 
        break
32308 
      if fid == 0:
32309 
        if ftype == TType.STRING:
32310 
          self.success = iprot.readString();
32311 
        else:
32312 
          iprot.skip(ftype)
32313 
      else:
32314 
        iprot.skip(ftype)
32315 
      iprot.readFieldEnd()
32316 
    iprot.readStructEnd()
32317 
 
32318 
  def write(self, oprot):
32319 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
32320 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
32321 
      return
32322 
    oprot.writeStructBegin('retrieveHotspotRechargeInvoice_result')
32323 
    if self.success is not None:
32324 
      oprot.writeFieldBegin('success', TType.STRING, 0)
32325 
      oprot.writeString(self.success)
32326 
      oprot.writeFieldEnd()
32327 
    oprot.writeFieldStop()
32328 
    oprot.writeStructEnd()
32329 
 
32330 
  def validate(self):
32331 
    return
32332 
 
32333 
 
32334 
  def __repr__(self):
32335 
    L = ['%s=%r' % (key, value)
32336 
      for key, value in self.__dict__.iteritems()]
32337 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
32338 
 
32339 
  def __eq__(self, other):
32340 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
32341 
 
32342 
  def __ne__(self, other):
32343 
    return not (self == other)
7169 anupam.sin 32344 
 
7190 amar.kumar 32345 
class splitFreebieOrder_args:
32346 
  """
32347 
  Attributes:
32348 
   - orderId
32349 
   - splitReason
32350 
   - shippingDate
32351 
  """
32352 
 
32353 
  thrift_spec = (
32354 
    None, # 0
32355 
    (1, TType.I64, 'orderId', None, None, ), # 1
32356 
    (2, TType.STRING, 'splitReason', None, None, ), # 2
32357 
    (3, TType.I64, 'shippingDate', None, None, ), # 3
32358 
  )
32359 
 
32360 
  def __init__(self, orderId=None, splitReason=None, shippingDate=None,):
32361 
    self.orderId = orderId
32362 
    self.splitReason = splitReason
32363 
    self.shippingDate = shippingDate
32364 
 
32365 
  def read(self, iprot):
32366 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
32367 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
32368 
      return
32369 
    iprot.readStructBegin()
32370 
    while True:
32371 
      (fname, ftype, fid) = iprot.readFieldBegin()
32372 
      if ftype == TType.STOP:
32373 
        break
32374 
      if fid == 1:
32375 
        if ftype == TType.I64:
32376 
          self.orderId = iprot.readI64();
32377 
        else:
32378 
          iprot.skip(ftype)
32379 
      elif fid == 2:
32380 
        if ftype == TType.STRING:
32381 
          self.splitReason = iprot.readString();
32382 
        else:
32383 
          iprot.skip(ftype)
32384 
      elif fid == 3:
32385 
        if ftype == TType.I64:
32386 
          self.shippingDate = iprot.readI64();
32387 
        else:
32388 
          iprot.skip(ftype)
32389 
      else:
32390 
        iprot.skip(ftype)
32391 
      iprot.readFieldEnd()
32392 
    iprot.readStructEnd()
32393 
 
32394 
  def write(self, oprot):
32395 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
32396 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
32397 
      return
32398 
    oprot.writeStructBegin('splitFreebieOrder_args')
32399 
    if self.orderId is not None:
32400 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
32401 
      oprot.writeI64(self.orderId)
32402 
      oprot.writeFieldEnd()
32403 
    if self.splitReason is not None:
32404 
      oprot.writeFieldBegin('splitReason', TType.STRING, 2)
32405 
      oprot.writeString(self.splitReason)
32406 
      oprot.writeFieldEnd()
32407 
    if self.shippingDate is not None:
32408 
      oprot.writeFieldBegin('shippingDate', TType.I64, 3)
32409 
      oprot.writeI64(self.shippingDate)
32410 
      oprot.writeFieldEnd()
32411 
    oprot.writeFieldStop()
32412 
    oprot.writeStructEnd()
32413 
 
32414 
  def validate(self):
32415 
    return
32416 
 
32417 
 
32418 
  def __repr__(self):
32419 
    L = ['%s=%r' % (key, value)
32420 
      for key, value in self.__dict__.iteritems()]
32421 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
32422 
 
32423 
  def __eq__(self, other):
32424 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
32425 
 
32426 
  def __ne__(self, other):
32427 
    return not (self == other)
32428 
 
32429 
class splitFreebieOrder_result:
32430 
  """
32431 
  Attributes:
32432 
   - success
32433 
  """
32434 
 
32435 
  thrift_spec = (
32436 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
32437 
  )
32438 
 
32439 
  def __init__(self, success=None,):
32440 
    self.success = success
32441 
 
32442 
  def read(self, iprot):
32443 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
32444 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
32445 
      return
32446 
    iprot.readStructBegin()
32447 
    while True:
32448 
      (fname, ftype, fid) = iprot.readFieldBegin()
32449 
      if ftype == TType.STOP:
32450 
        break
32451 
      if fid == 0:
32452 
        if ftype == TType.STRUCT:
32453 
          self.success = Order()
32454 
          self.success.read(iprot)
32455 
        else:
32456 
          iprot.skip(ftype)
32457 
      else:
32458 
        iprot.skip(ftype)
32459 
      iprot.readFieldEnd()
32460 
    iprot.readStructEnd()
32461 
 
32462 
  def write(self, oprot):
32463 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
32464 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
32465 
      return
32466 
    oprot.writeStructBegin('splitFreebieOrder_result')
32467 
    if self.success is not None:
32468 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
32469 
      self.success.write(oprot)
32470 
      oprot.writeFieldEnd()
32471 
    oprot.writeFieldStop()
32472 
    oprot.writeStructEnd()
32473 
 
32474 
  def validate(self):
32475 
    return
32476 
 
32477 
 
32478 
  def __repr__(self):
32479 
    L = ['%s=%r' % (key, value)
32480 
      for key, value in self.__dict__.iteritems()]
32481 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
32482 
 
32483 
  def __eq__(self, other):
32484 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
32485 
 
32486 
  def __ne__(self, other):
32487 
    return not (self == other)
32488 
 
7169 anupam.sin 32489 
class getRechargeTransactionsByNumber_args:
32490 
  """
32491 
  Attributes:
32492 
   - number
7172 anupam.sin 32493 
   - storeId
7169 anupam.sin 32494 
  """
32495 
 
32496 
  thrift_spec = (
32497 
    None, # 0
32498 
    (1, TType.STRING, 'number', None, None, ), # 1
7172 anupam.sin 32499 
    (2, TType.I64, 'storeId', None, None, ), # 2
7169 anupam.sin 32500 
  )
32501 
 
7172 anupam.sin 32502 
  def __init__(self, number=None, storeId=None,):
7169 anupam.sin 32503 
    self.number = number
7172 anupam.sin 32504 
    self.storeId = storeId
7169 anupam.sin 32505 
 
32506 
  def read(self, iprot):
32507 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
32508 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
32509 
      return
32510 
    iprot.readStructBegin()
32511 
    while True:
32512 
      (fname, ftype, fid) = iprot.readFieldBegin()
32513 
      if ftype == TType.STOP:
32514 
        break
32515 
      if fid == 1:
32516 
        if ftype == TType.STRING:
32517 
          self.number = iprot.readString();
32518 
        else:
32519 
          iprot.skip(ftype)
7172 anupam.sin 32520 
      elif fid == 2:
32521 
        if ftype == TType.I64:
32522 
          self.storeId = iprot.readI64();
32523 
        else:
32524 
          iprot.skip(ftype)
7169 anupam.sin 32525 
      else:
32526 
        iprot.skip(ftype)
32527 
      iprot.readFieldEnd()
32528 
    iprot.readStructEnd()
32529 
 
32530 
  def write(self, oprot):
32531 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
32532 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
32533 
      return
32534 
    oprot.writeStructBegin('getRechargeTransactionsByNumber_args')
32535 
    if self.number is not None:
32536 
      oprot.writeFieldBegin('number', TType.STRING, 1)
32537 
      oprot.writeString(self.number)
32538 
      oprot.writeFieldEnd()
7172 anupam.sin 32539 
    if self.storeId is not None:
32540 
      oprot.writeFieldBegin('storeId', TType.I64, 2)
32541 
      oprot.writeI64(self.storeId)
32542 
      oprot.writeFieldEnd()
7169 anupam.sin 32543 
    oprot.writeFieldStop()
32544 
    oprot.writeStructEnd()
32545 
 
32546 
  def validate(self):
32547 
    return
32548 
 
32549 
 
32550 
  def __repr__(self):
32551 
    L = ['%s=%r' % (key, value)
32552 
      for key, value in self.__dict__.iteritems()]
32553 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
32554 
 
32555 
  def __eq__(self, other):
32556 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
32557 
 
32558 
  def __ne__(self, other):
32559 
    return not (self == other)
32560 
 
32561 
class getRechargeTransactionsByNumber_result:
32562 
  """
32563 
  Attributes:
32564 
   - success
32565 
  """
32566 
 
32567 
  thrift_spec = (
32568 
    (0, TType.LIST, 'success', (TType.STRUCT,(RechargeTransaction, RechargeTransaction.thrift_spec)), None, ), # 0
32569 
  )
32570 
 
32571 
  def __init__(self, success=None,):
32572 
    self.success = success
32573 
 
32574 
  def read(self, iprot):
32575 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
32576 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
32577 
      return
32578 
    iprot.readStructBegin()
32579 
    while True:
32580 
      (fname, ftype, fid) = iprot.readFieldBegin()
32581 
      if ftype == TType.STOP:
32582 
        break
32583 
      if fid == 0:
32584 
        if ftype == TType.LIST:
32585 
          self.success = []
32586 
          (_etype761, _size758) = iprot.readListBegin()
32587 
          for _i762 in xrange(_size758):
32588 
            _elem763 = RechargeTransaction()
32589 
            _elem763.read(iprot)
32590 
            self.success.append(_elem763)
32591 
          iprot.readListEnd()
32592 
        else:
32593 
          iprot.skip(ftype)
32594 
      else:
32595 
        iprot.skip(ftype)
32596 
      iprot.readFieldEnd()
32597 
    iprot.readStructEnd()
32598 
 
32599 
  def write(self, oprot):
32600 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
32601 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
32602 
      return
32603 
    oprot.writeStructBegin('getRechargeTransactionsByNumber_result')
32604 
    if self.success is not None:
32605 
      oprot.writeFieldBegin('success', TType.LIST, 0)
32606 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
32607 
      for iter764 in self.success:
32608 
        iter764.write(oprot)
32609 
      oprot.writeListEnd()
32610 
      oprot.writeFieldEnd()
32611 
    oprot.writeFieldStop()
32612 
    oprot.writeStructEnd()
32613 
 
32614 
  def validate(self):
32615 
    return
32616 
 
32617 
 
32618 
  def __repr__(self):
32619 
    L = ['%s=%r' % (key, value)
32620 
      for key, value in self.__dict__.iteritems()]
32621 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
32622 
 
32623 
  def __eq__(self, other):
32624 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
32625 
 
32626 
  def __ne__(self, other):
32627 
    return not (self == other)
32628 
 
32629 
class updateHotspotStorePassword_args:
32630 
  """
32631 
  Attributes:
32632 
   - storeId
32633 
   - password
32634 
  """
32635 
 
32636 
  thrift_spec = (
32637 
    None, # 0
32638 
    (1, TType.I64, 'storeId', None, None, ), # 1
32639 
    (2, TType.STRING, 'password', None, None, ), # 2
32640 
  )
32641 
 
32642 
  def __init__(self, storeId=None, password=None,):
32643 
    self.storeId = storeId
32644 
    self.password = password
32645 
 
32646 
  def read(self, iprot):
32647 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
32648 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
32649 
      return
32650 
    iprot.readStructBegin()
32651 
    while True:
32652 
      (fname, ftype, fid) = iprot.readFieldBegin()
32653 
      if ftype == TType.STOP:
32654 
        break
32655 
      if fid == 1:
32656 
        if ftype == TType.I64:
32657 
          self.storeId = iprot.readI64();
32658 
        else:
32659 
          iprot.skip(ftype)
32660 
      elif fid == 2:
32661 
        if ftype == TType.STRING:
32662 
          self.password = iprot.readString();
32663 
        else:
32664 
          iprot.skip(ftype)
32665 
      else:
32666 
        iprot.skip(ftype)
32667 
      iprot.readFieldEnd()
32668 
    iprot.readStructEnd()
32669 
 
32670 
  def write(self, oprot):
32671 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
32672 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
32673 
      return
32674 
    oprot.writeStructBegin('updateHotspotStorePassword_args')
32675 
    if self.storeId is not None:
32676 
      oprot.writeFieldBegin('storeId', TType.I64, 1)
32677 
      oprot.writeI64(self.storeId)
32678 
      oprot.writeFieldEnd()
32679 
    if self.password is not None:
32680 
      oprot.writeFieldBegin('password', TType.STRING, 2)
32681 
      oprot.writeString(self.password)
32682 
      oprot.writeFieldEnd()
32683 
    oprot.writeFieldStop()
32684 
    oprot.writeStructEnd()
32685 
 
32686 
  def validate(self):
32687 
    return
32688 
 
32689 
 
32690 
  def __repr__(self):
32691 
    L = ['%s=%r' % (key, value)
32692 
      for key, value in self.__dict__.iteritems()]
32693 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
32694 
 
32695 
  def __eq__(self, other):
32696 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
32697 
 
32698 
  def __ne__(self, other):
32699 
    return not (self == other)
32700 
 
32701 
class updateHotspotStorePassword_result:
32702 
  """
32703 
  Attributes:
32704 
   - success
32705 
  """
32706 
 
32707 
  thrift_spec = (
32708 
    (0, TType.BOOL, 'success', None, None, ), # 0
32709 
  )
32710 
 
32711 
  def __init__(self, success=None,):
32712 
    self.success = success
32713 
 
32714 
  def read(self, iprot):
32715 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
32716 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
32717 
      return
32718 
    iprot.readStructBegin()
32719 
    while True:
32720 
      (fname, ftype, fid) = iprot.readFieldBegin()
32721 
      if ftype == TType.STOP:
32722 
        break
32723 
      if fid == 0:
32724 
        if ftype == TType.BOOL:
32725 
          self.success = iprot.readBool();
32726 
        else:
32727 
          iprot.skip(ftype)
32728 
      else:
32729 
        iprot.skip(ftype)
32730 
      iprot.readFieldEnd()
32731 
    iprot.readStructEnd()
32732 
 
32733 
  def write(self, oprot):
32734 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
32735 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
32736 
      return
32737 
    oprot.writeStructBegin('updateHotspotStorePassword_result')
32738 
    if self.success is not None:
32739 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
32740 
      oprot.writeBool(self.success)
32741 
      oprot.writeFieldEnd()
32742 
    oprot.writeFieldStop()
32743 
    oprot.writeStructEnd()
32744 
 
32745 
  def validate(self):
32746 
    return
32747 
 
32748 
 
32749 
  def __repr__(self):
32750 
    L = ['%s=%r' % (key, value)
32751 
      for key, value in self.__dict__.iteritems()]
32752 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
32753 
 
32754 
  def __eq__(self, other):
32755 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
32756 
 
32757 
  def __ne__(self, other):
32758 
    return not (self == other)
7263 anupam.sin 32759 
 
7285 rajveer 32760 
class topupCompanyWallet_args:
7263 anupam.sin 32761 
  """
32762 
  Attributes:
7285 rajveer 32763 
   - companyId
32764 
   - amount
7263 anupam.sin 32765 
  """
32766 
 
32767 
  thrift_spec = (
32768 
    None, # 0
7285 rajveer 32769 
    (1, TType.I64, 'companyId', None, None, ), # 1
32770 
    (2, TType.I64, 'amount', None, None, ), # 2
7263 anupam.sin 32771 
  )
32772 
 
7285 rajveer 32773 
  def __init__(self, companyId=None, amount=None,):
32774 
    self.companyId = companyId
32775 
    self.amount = amount
7263 anupam.sin 32776 
 
32777 
  def read(self, iprot):
32778 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
32779 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
32780 
      return
32781 
    iprot.readStructBegin()
32782 
    while True:
32783 
      (fname, ftype, fid) = iprot.readFieldBegin()
32784 
      if ftype == TType.STOP:
32785 
        break
32786 
      if fid == 1:
32787 
        if ftype == TType.I64:
7285 rajveer 32788 
          self.companyId = iprot.readI64();
7263 anupam.sin 32789 
        else:
32790 
          iprot.skip(ftype)
7285 rajveer 32791 
      elif fid == 2:
32792 
        if ftype == TType.I64:
32793 
          self.amount = iprot.readI64();
32794 
        else:
32795 
          iprot.skip(ftype)
7263 anupam.sin 32796 
      else:
32797 
        iprot.skip(ftype)
32798 
      iprot.readFieldEnd()
32799 
    iprot.readStructEnd()
32800 
 
32801 
  def write(self, oprot):
32802 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
32803 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
32804 
      return
7285 rajveer 32805 
    oprot.writeStructBegin('topupCompanyWallet_args')
32806 
    if self.companyId is not None:
32807 
      oprot.writeFieldBegin('companyId', TType.I64, 1)
32808 
      oprot.writeI64(self.companyId)
7263 anupam.sin 32809 
      oprot.writeFieldEnd()
7285 rajveer 32810 
    if self.amount is not None:
32811 
      oprot.writeFieldBegin('amount', TType.I64, 2)
32812 
      oprot.writeI64(self.amount)
32813 
      oprot.writeFieldEnd()
7263 anupam.sin 32814 
    oprot.writeFieldStop()
32815 
    oprot.writeStructEnd()
32816 
 
32817 
  def validate(self):
32818 
    return
32819 
 
32820 
 
32821 
  def __repr__(self):
32822 
    L = ['%s=%r' % (key, value)
32823 
      for key, value in self.__dict__.iteritems()]
32824 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
32825 
 
32826 
  def __eq__(self, other):
32827 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
32828 
 
32829 
  def __ne__(self, other):
32830 
    return not (self == other)
32831 
 
7285 rajveer 32832 
class topupCompanyWallet_result:
7263 anupam.sin 32833 
  """
32834 
  Attributes:
32835 
   - success
32836 
  """
32837 
 
32838 
  thrift_spec = (
7285 rajveer 32839 
    (0, TType.I64, 'success', None, None, ), # 0
7263 anupam.sin 32840 
  )
32841 
 
32842 
  def __init__(self, success=None,):
32843 
    self.success = success
32844 
 
32845 
  def read(self, iprot):
32846 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
32847 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
32848 
      return
32849 
    iprot.readStructBegin()
32850 
    while True:
32851 
      (fname, ftype, fid) = iprot.readFieldBegin()
32852 
      if ftype == TType.STOP:
32853 
        break
32854 
      if fid == 0:
7285 rajveer 32855 
        if ftype == TType.I64:
32856 
          self.success = iprot.readI64();
7263 anupam.sin 32857 
        else:
32858 
          iprot.skip(ftype)
32859 
      else:
32860 
        iprot.skip(ftype)
32861 
      iprot.readFieldEnd()
32862 
    iprot.readStructEnd()
32863 
 
32864 
  def write(self, oprot):
32865 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
32866 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
32867 
      return
7285 rajveer 32868 
    oprot.writeStructBegin('topupCompanyWallet_result')
7263 anupam.sin 32869 
    if self.success is not None:
7285 rajveer 32870 
      oprot.writeFieldBegin('success', TType.I64, 0)
32871 
      oprot.writeI64(self.success)
7263 anupam.sin 32872 
      oprot.writeFieldEnd()
32873 
    oprot.writeFieldStop()
32874 
    oprot.writeStructEnd()
32875 
 
32876 
  def validate(self):
32877 
    return
32878 
 
32879 
 
32880 
  def __repr__(self):
32881 
    L = ['%s=%r' % (key, value)
32882 
      for key, value in self.__dict__.iteritems()]
32883 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
32884 
 
32885 
  def __eq__(self, other):
32886 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
32887 
 
32888 
  def __ne__(self, other):
32889 
    return not (self == other)
7267 anupam.sin 32890 
 
7285 rajveer 32891 
class getWalletBalanceForCompany_args:
32892 
  """
32893 
  Attributes:
32894 
   - companyId
32895 
  """
7267 anupam.sin 32896 
 
32897 
  thrift_spec = (
7285 rajveer 32898 
    None, # 0
32899 
    (1, TType.I64, 'companyId', None, None, ), # 1
7267 anupam.sin 32900 
  )
32901 
 
7285 rajveer 32902 
  def __init__(self, companyId=None,):
32903 
    self.companyId = companyId
32904 
 
7267 anupam.sin 32905 
  def read(self, iprot):
32906 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
32907 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
32908 
      return
32909 
    iprot.readStructBegin()
32910 
    while True:
32911 
      (fname, ftype, fid) = iprot.readFieldBegin()
32912 
      if ftype == TType.STOP:
32913 
        break
7285 rajveer 32914 
      if fid == 1:
32915 
        if ftype == TType.I64:
32916 
          self.companyId = iprot.readI64();
32917 
        else:
32918 
          iprot.skip(ftype)
7267 anupam.sin 32919 
      else:
32920 
        iprot.skip(ftype)
32921 
      iprot.readFieldEnd()
32922 
    iprot.readStructEnd()
32923 
 
32924 
  def write(self, oprot):
32925 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
32926 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
32927 
      return
7285 rajveer 32928 
    oprot.writeStructBegin('getWalletBalanceForCompany_args')
32929 
    if self.companyId is not None:
32930 
      oprot.writeFieldBegin('companyId', TType.I64, 1)
32931 
      oprot.writeI64(self.companyId)
32932 
      oprot.writeFieldEnd()
7267 anupam.sin 32933 
    oprot.writeFieldStop()
32934 
    oprot.writeStructEnd()
32935 
 
32936 
  def validate(self):
32937 
    return
32938 
 
32939 
 
32940 
  def __repr__(self):
32941 
    L = ['%s=%r' % (key, value)
32942 
      for key, value in self.__dict__.iteritems()]
32943 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
32944 
 
32945 
  def __eq__(self, other):
32946 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
32947 
 
32948 
  def __ne__(self, other):
32949 
    return not (self == other)
32950 
 
7285 rajveer 32951 
class getWalletBalanceForCompany_result:
7267 anupam.sin 32952 
  """
32953 
  Attributes:
32954 
   - success
32955 
  """
32956 
 
32957 
  thrift_spec = (
7285 rajveer 32958 
    (0, TType.I64, 'success', None, None, ), # 0
7267 anupam.sin 32959 
  )
32960 
 
32961 
  def __init__(self, success=None,):
32962 
    self.success = success
32963 
 
32964 
  def read(self, iprot):
32965 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
32966 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
32967 
      return
32968 
    iprot.readStructBegin()
32969 
    while True:
32970 
      (fname, ftype, fid) = iprot.readFieldBegin()
32971 
      if ftype == TType.STOP:
32972 
        break
32973 
      if fid == 0:
7285 rajveer 32974 
        if ftype == TType.I64:
32975 
          self.success = iprot.readI64();
7267 anupam.sin 32976 
        else:
32977 
          iprot.skip(ftype)
32978 
      else:
32979 
        iprot.skip(ftype)
32980 
      iprot.readFieldEnd()
32981 
    iprot.readStructEnd()
32982 
 
32983 
  def write(self, oprot):
32984 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
32985 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
32986 
      return
7285 rajveer 32987 
    oprot.writeStructBegin('getWalletBalanceForCompany_result')
7267 anupam.sin 32988 
    if self.success is not None:
7285 rajveer 32989 
      oprot.writeFieldBegin('success', TType.I64, 0)
32990 
      oprot.writeI64(self.success)
7267 anupam.sin 32991 
      oprot.writeFieldEnd()
32992 
    oprot.writeFieldStop()
32993 
    oprot.writeStructEnd()
32994 
 
32995 
  def validate(self):
32996 
    return
32997 
 
32998 
 
32999 
  def __repr__(self):
33000 
    L = ['%s=%r' % (key, value)
33001 
      for key, value in self.__dict__.iteritems()]
33002 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
33003 
 
33004 
  def __eq__(self, other):
33005 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
33006 
 
33007 
  def __ne__(self, other):
33008 
    return not (self == other)
33009 
 
7285 rajveer 33010 
class getSourceDetail_args:
7267 anupam.sin 33011 
  """
33012 
  Attributes:
7285 rajveer 33013 
   - source
7267 anupam.sin 33014 
  """
33015 
 
33016 
  thrift_spec = (
33017 
    None, # 0
7285 rajveer 33018 
    (1, TType.I64, 'source', None, None, ), # 1
7267 anupam.sin 33019 
  )
33020 
 
7285 rajveer 33021 
  def __init__(self, source=None,):
33022 
    self.source = source
7267 anupam.sin 33023 
 
33024 
  def read(self, iprot):
33025 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
33026 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
33027 
      return
33028 
    iprot.readStructBegin()
33029 
    while True:
33030 
      (fname, ftype, fid) = iprot.readFieldBegin()
33031 
      if ftype == TType.STOP:
33032 
        break
33033 
      if fid == 1:
7285 rajveer 33034 
        if ftype == TType.I64:
33035 
          self.source = iprot.readI64();
7267 anupam.sin 33036 
        else:
33037 
          iprot.skip(ftype)
33038 
      else:
33039 
        iprot.skip(ftype)
33040 
      iprot.readFieldEnd()
33041 
    iprot.readStructEnd()
33042 
 
33043 
  def write(self, oprot):
33044 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
33045 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
33046 
      return
7285 rajveer 33047 
    oprot.writeStructBegin('getSourceDetail_args')
33048 
    if self.source is not None:
33049 
      oprot.writeFieldBegin('source', TType.I64, 1)
33050 
      oprot.writeI64(self.source)
7267 anupam.sin 33051 
      oprot.writeFieldEnd()
33052 
    oprot.writeFieldStop()
33053 
    oprot.writeStructEnd()
33054 
 
33055 
  def validate(self):
33056 
    return
33057 
 
33058 
 
33059 
  def __repr__(self):
33060 
    L = ['%s=%r' % (key, value)
33061 
      for key, value in self.__dict__.iteritems()]
33062 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
33063 
 
33064 
  def __eq__(self, other):
33065 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
33066 
 
33067 
  def __ne__(self, other):
33068 
    return not (self == other)
33069 
 
7285 rajveer 33070 
class getSourceDetail_result:
7267 anupam.sin 33071 
  """
33072 
  Attributes:
33073 
   - success
33074 
  """
33075 
 
33076 
  thrift_spec = (
7285 rajveer 33077 
    (0, TType.STRUCT, 'success', (SourceDetail, SourceDetail.thrift_spec), None, ), # 0
7267 anupam.sin 33078 
  )
33079 
 
33080 
  def __init__(self, success=None,):
33081 
    self.success = success
33082 
 
33083 
  def read(self, iprot):
33084 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
33085 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
33086 
      return
33087 
    iprot.readStructBegin()
33088 
    while True:
33089 
      (fname, ftype, fid) = iprot.readFieldBegin()
33090 
      if ftype == TType.STOP:
33091 
        break
33092 
      if fid == 0:
7285 rajveer 33093 
        if ftype == TType.STRUCT:
33094 
          self.success = SourceDetail()
33095 
          self.success.read(iprot)
7267 anupam.sin 33096 
        else:
33097 
          iprot.skip(ftype)
33098 
      else:
33099 
        iprot.skip(ftype)
33100 
      iprot.readFieldEnd()
33101 
    iprot.readStructEnd()
33102 
 
33103 
  def write(self, oprot):
33104 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
33105 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
33106 
      return
7285 rajveer 33107 
    oprot.writeStructBegin('getSourceDetail_result')
7267 anupam.sin 33108 
    if self.success is not None:
7285 rajveer 33109 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
33110 
      self.success.write(oprot)
7267 anupam.sin 33111 
      oprot.writeFieldEnd()
33112 
    oprot.writeFieldStop()
33113 
    oprot.writeStructEnd()
33114 
 
33115 
  def validate(self):
33116 
    return
33117 
 
33118 
 
33119 
  def __repr__(self):
33120 
    L = ['%s=%r' % (key, value)
33121 
      for key, value in self.__dict__.iteritems()]
33122 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
33123 
 
33124 
  def __eq__(self, other):
33125 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
33126 
 
33127 
  def __ne__(self, other):
33128 
    return not (self == other)
7308 rajveer 33129 
 
33130 
class getAllCircles_args:
33131 
 
33132 
  thrift_spec = (
33133 
  )
33134 
 
33135 
  def read(self, iprot):
33136 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
33137 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
33138 
      return
33139 
    iprot.readStructBegin()
33140 
    while True:
33141 
      (fname, ftype, fid) = iprot.readFieldBegin()
33142 
      if ftype == TType.STOP:
33143 
        break
33144 
      else:
33145 
        iprot.skip(ftype)
33146 
      iprot.readFieldEnd()
33147 
    iprot.readStructEnd()
33148 
 
33149 
  def write(self, oprot):
33150 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
33151 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
33152 
      return
33153 
    oprot.writeStructBegin('getAllCircles_args')
33154 
    oprot.writeFieldStop()
33155 
    oprot.writeStructEnd()
33156 
 
33157 
  def validate(self):
33158 
    return
33159 
 
33160 
 
33161 
  def __repr__(self):
33162 
    L = ['%s=%r' % (key, value)
33163 
      for key, value in self.__dict__.iteritems()]
33164 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
33165 
 
33166 
  def __eq__(self, other):
33167 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
33168 
 
33169 
  def __ne__(self, other):
33170 
    return not (self == other)
33171 
 
33172 
class getAllCircles_result:
33173 
  """
33174 
  Attributes:
33175 
   - success
33176 
  """
33177 
 
33178 
  thrift_spec = (
33179 
    (0, TType.LIST, 'success', (TType.STRUCT,(TelecomCircle, TelecomCircle.thrift_spec)), None, ), # 0
33180 
  )
33181 
 
33182 
  def __init__(self, success=None,):
33183 
    self.success = success
33184 
 
33185 
  def read(self, iprot):
33186 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
33187 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
33188 
      return
33189 
    iprot.readStructBegin()
33190 
    while True:
33191 
      (fname, ftype, fid) = iprot.readFieldBegin()
33192 
      if ftype == TType.STOP:
33193 
        break
33194 
      if fid == 0:
33195 
        if ftype == TType.LIST:
33196 
          self.success = []
33197 
          (_etype768, _size765) = iprot.readListBegin()
33198 
          for _i769 in xrange(_size765):
33199 
            _elem770 = TelecomCircle()
33200 
            _elem770.read(iprot)
33201 
            self.success.append(_elem770)
33202 
          iprot.readListEnd()
33203 
        else:
33204 
          iprot.skip(ftype)
33205 
      else:
33206 
        iprot.skip(ftype)
33207 
      iprot.readFieldEnd()
33208 
    iprot.readStructEnd()
33209 
 
33210 
  def write(self, oprot):
33211 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
33212 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
33213 
      return
33214 
    oprot.writeStructBegin('getAllCircles_result')
33215 
    if self.success is not None:
33216 
      oprot.writeFieldBegin('success', TType.LIST, 0)
33217 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
33218 
      for iter771 in self.success:
33219 
        iter771.write(oprot)
33220 
      oprot.writeListEnd()
33221 
      oprot.writeFieldEnd()
33222 
    oprot.writeFieldStop()
33223 
    oprot.writeStructEnd()
33224 
 
33225 
  def validate(self):
33226 
    return
33227 
 
33228 
 
33229 
  def __repr__(self):
33230 
    L = ['%s=%r' % (key, value)
33231 
      for key, value in self.__dict__.iteritems()]
33232 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
33233 
 
33234 
  def __eq__(self, other):
33235 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
33236 
 
33237 
  def __ne__(self, other):
33238 
    return not (self == other)
33239 
 
33240 
class deleteFrcs_args:
33241 
  """
33242 
  Attributes:
33243 
   - frcIdsToDelete
33244 
  """
33245 
 
33246 
  thrift_spec = (
33247 
    None, # 0
33248 
    (1, TType.LIST, 'frcIdsToDelete', (TType.I64,None), None, ), # 1
33249 
  )
33250 
 
33251 
  def __init__(self, frcIdsToDelete=None,):
33252 
    self.frcIdsToDelete = frcIdsToDelete
33253 
 
33254 
  def read(self, iprot):
33255 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
33256 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
33257 
      return
33258 
    iprot.readStructBegin()
33259 
    while True:
33260 
      (fname, ftype, fid) = iprot.readFieldBegin()
33261 
      if ftype == TType.STOP:
33262 
        break
33263 
      if fid == 1:
33264 
        if ftype == TType.LIST:
33265 
          self.frcIdsToDelete = []
33266 
          (_etype775, _size772) = iprot.readListBegin()
33267 
          for _i776 in xrange(_size772):
33268 
            _elem777 = iprot.readI64();
33269 
            self.frcIdsToDelete.append(_elem777)
33270 
          iprot.readListEnd()
33271 
        else:
33272 
          iprot.skip(ftype)
33273 
      else:
33274 
        iprot.skip(ftype)
33275 
      iprot.readFieldEnd()
33276 
    iprot.readStructEnd()
33277 
 
33278 
  def write(self, oprot):
33279 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
33280 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
33281 
      return
33282 
    oprot.writeStructBegin('deleteFrcs_args')
33283 
    if self.frcIdsToDelete is not None:
33284 
      oprot.writeFieldBegin('frcIdsToDelete', TType.LIST, 1)
33285 
      oprot.writeListBegin(TType.I64, len(self.frcIdsToDelete))
33286 
      for iter778 in self.frcIdsToDelete:
33287 
        oprot.writeI64(iter778)
33288 
      oprot.writeListEnd()
33289 
      oprot.writeFieldEnd()
33290 
    oprot.writeFieldStop()
33291 
    oprot.writeStructEnd()
33292 
 
33293 
  def validate(self):
33294 
    return
33295 
 
33296 
 
33297 
  def __repr__(self):
33298 
    L = ['%s=%r' % (key, value)
33299 
      for key, value in self.__dict__.iteritems()]
33300 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
33301 
 
33302 
  def __eq__(self, other):
33303 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
33304 
 
33305 
  def __ne__(self, other):
33306 
    return not (self == other)
33307 
 
33308 
class deleteFrcs_result:
33309 
  """
33310 
  Attributes:
33311 
   - success
33312 
  """
33313 
 
33314 
  thrift_spec = (
33315 
    (0, TType.BOOL, 'success', None, None, ), # 0
33316 
  )
33317 
 
33318 
  def __init__(self, success=None,):
33319 
    self.success = success
33320 
 
33321 
  def read(self, iprot):
33322 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
33323 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
33324 
      return
33325 
    iprot.readStructBegin()
33326 
    while True:
33327 
      (fname, ftype, fid) = iprot.readFieldBegin()
33328 
      if ftype == TType.STOP:
33329 
        break
33330 
      if fid == 0:
33331 
        if ftype == TType.BOOL:
33332 
          self.success = iprot.readBool();
33333 
        else:
33334 
          iprot.skip(ftype)
33335 
      else:
33336 
        iprot.skip(ftype)
33337 
      iprot.readFieldEnd()
33338 
    iprot.readStructEnd()
33339 
 
33340 
  def write(self, oprot):
33341 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
33342 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
33343 
      return
33344 
    oprot.writeStructBegin('deleteFrcs_result')
33345 
    if self.success is not None:
33346 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
33347 
      oprot.writeBool(self.success)
33348 
      oprot.writeFieldEnd()
33349 
    oprot.writeFieldStop()
33350 
    oprot.writeStructEnd()
33351 
 
33352 
  def validate(self):
33353 
    return
33354 
 
33355 
 
33356 
  def __repr__(self):
33357 
    L = ['%s=%r' % (key, value)
33358 
      for key, value in self.__dict__.iteritems()]
33359 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
33360 
 
33361 
  def __eq__(self, other):
33362 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
33363 
 
33364 
  def __ne__(self, other):
33365 
    return not (self == other)