Subversion Repositories SmartDukaan

Rev

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

Rev Author Line No. Line
94 ashish 1 
#
3431 rajveer 2 
# Autogenerated by Thrift Compiler (0.7.0)
94 ashish 3 
#
4 
# DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
5 
#
6 
 
7 
from thrift.Thrift import *
3376 rajveer 8 
import shop2020.thriftpy.generic.GenericService
94 ashish 9 
from ttypes import *
10 
from thrift.Thrift import TProcessor
11 
from thrift.transport import TTransport
3431 rajveer 12 
from thrift.protocol import TBinaryProtocol, TProtocol
94 ashish 13 
try:
14 
  from thrift.protocol import fastbinary
15 
except:
16 
  fastbinary = None
17 
 
18 
 
3376 rajveer 19 
class Iface(shop2020.thriftpy.generic.GenericService.Iface):
94 ashish 20 
  def createTransaction(self, transaction):
21 
    """
22 
    Parameters:
23 
     - transaction
24 
    """
25 
    pass
26 
 
27 
  def getTransaction(self, id):
28 
    """
29 
    Parameters:
30 
     - id
31 
    """
32 
    pass
33 
 
34 
  def getTransactionsForCustomer(self, customerId, from_date, to_date, status):
35 
    """
36 
    Parameters:
37 
     - customerId
38 
     - from_date
39 
     - to_date
40 
     - status
41 
    """
42 
    pass
43 
 
132 ashish 44 
  def getTransactionsForShoppingCartId(self, shoppingCartId):
45 
    """
46 
    Parameters:
47 
     - shoppingCartId
48 
    """
49 
    pass
50 
 
94 ashish 51 
  def getTransactionStatus(self, transactionId):
52 
    """
53 
    Parameters:
54 
     - transactionId
55 
    """
56 
    pass
57 
 
7293 anupam.sin 58 
  def changeTransactionStatus(self, transactionId, status, description, pickUp, orderType, source):
94 ashish 59 
    """
60 
    Parameters:
61 
     - transactionId
62 
     - status
63 
     - description
5527 anupam.sin 64 
     - pickUp
65 
     - orderType
7293 anupam.sin 66 
     - source
94 ashish 67 
    """
68 
    pass
69 
 
1398 varun.gupt 70 
  def enqueueTransactionInfoEmail(self, transactionId):
1382 varun.gupt 71 
    """
72 
    Parameters:
73 
     - transactionId
74 
    """
75 
    pass
76 
 
4801 anupam.sin 77 
  def getAllOrders(self, statuses, from_date, to_date, warehouse_id):
94 ashish 78 
    """
79 
    Parameters:
4801 anupam.sin 80 
     - statuses
483 rajveer 81 
     - from_date
82 
     - to_date
83 
     - warehouse_id
94 ashish 84 
    """
85 
    pass
86 
 
4133 chandransh 87 
  def getOrdersInBatch(self, statuses, offset, limit, warehouse_id):
88 
    """
89 
    Returns at most 'limit' orders with the given statuses for the given warehouse starting from the given offset.
90 
    Pass the status as null and the limit as 0 to ignore them.
91 
 
92 
    Parameters:
93 
     - statuses
94 
     - offset
95 
     - limit
96 
     - warehouse_id
97 
    """
98 
    pass
99 
 
100 
  def getOrderCount(self, statuses, warehouseId):
101 
    """
102 
    Returns the count of orders with the given statuses assigned to the given warehouse.
103 
 
104 
    Parameters:
105 
     - statuses
106 
     - warehouseId
107 
    """
108 
    pass
109 
 
999 varun.gupt 110 
  def getOrdersByBillingDate(self, status, start_billing_date, end_billing_date, warehouse_id):
111 
    """
1132 chandransh 112 
    Returns orders within a range of their billing dates
3431 rajveer 113 
 
999 varun.gupt 114 
    Parameters:
115 
     - status
116 
     - start_billing_date
117 
     - end_billing_date
118 
     - warehouse_id
119 
    """
120 
    pass
121 
 
3451 chandransh 122 
  def getOrdersByShippingDate(self, fromShippingDate, toShippingDate, providerId, warehouseId, cod):
3427 chandransh 123 
    """
124 
    Returns orders for a particular provider and warehouse which were shipped between the given dates.
3451 chandransh 125 
    Returned orders comprise of COD orders if cod parameter is true. It comprises of prepaid orders otherwise.
126 
    Pass providerId and warehouseId as -1 to ignore both these parameters.
3431 rajveer 127 
 
3427 chandransh 128 
    Parameters:
129 
     - fromShippingDate
130 
     - toShippingDate
131 
     - providerId
132 
     - warehouseId
3451 chandransh 133 
     - cod
3427 chandransh 134 
    """
135 
    pass
136 
 
1382 varun.gupt 137 
  def getReturnableOrdersForCustomer(self, customer_id, limit):
138 
    """
139 
    Returns order ids for orders which can be returned
3431 rajveer 140 
 
1382 varun.gupt 141 
    Parameters:
142 
     - customer_id
143 
     - limit
144 
    """
145 
    pass
146 
 
147 
  def getCancellableOrdersForCustomer(self, customer_id, limit):
148 
    """
149 
    Returns order ids for orders which can be cancelled
3431 rajveer 150 
 
1382 varun.gupt 151 
    Parameters:
152 
     - customer_id
153 
     - limit
154 
    """
155 
    pass
156 
 
483 rajveer 157 
  def changeOrderStatus(self, orderId, status, description):
94 ashish 158 
    """
159 
    Parameters:
483 rajveer 160 
     - orderId
161 
     - status
162 
     - description
94 ashish 163 
    """
164 
    pass
165 
 
1528 ankur.sing 166 
  def getOrdersForTransaction(self, transactionId, customerId):
94 ashish 167 
    """
1528 ankur.sing 168 
    Returns list of orders for given transaction Id. Also filters based on customer Id so that
169 
    only user who owns the transaction can view its order details.
3431 rajveer 170 
 
94 ashish 171 
    Parameters:
172 
     - transactionId
1528 ankur.sing 173 
     - customerId
94 ashish 174 
    """
175 
    pass
176 
 
3014 chandransh 177 
  def getOrdersForCustomer(self, customerId, from_date, to_date, statuses):
94 ashish 178 
    """
3014 chandransh 179 
    Returns list of orders for the given customer created between the given dates and having the given statuses.
180 
    Pass and empty list to ignore filtering on statuses.
3431 rajveer 181 
 
94 ashish 182 
    Parameters:
483 rajveer 183 
     - customerId
184 
     - from_date
185 
     - to_date
3014 chandransh 186 
     - statuses
94 ashish 187 
    """
188 
    pass
189 
 
483 rajveer 190 
  def createOrder(self, order):
94 ashish 191 
    """
192 
    Parameters:
483 rajveer 193 
     - order
94 ashish 194 
    """
195 
    pass
196 
 
483 rajveer 197 
  def getOrder(self, id):
94 ashish 198 
    """
199 
    Parameters:
483 rajveer 200 
     - id
94 ashish 201 
    """
202 
    pass
203 
 
483 rajveer 204 
  def getLineItemsForOrder(self, orderId):
94 ashish 205 
    """
206 
    Parameters:
483 rajveer 207 
     - orderId
94 ashish 208 
    """
209 
    pass
210 
 
4999 phani.kuma 211 
  def getOrderList(self, order_ids):
212 
    """
213 
    Parameters:
214 
     - order_ids
215 
    """
216 
    pass
217 
 
5386 phani.kuma 218 
  def getOrderListForVendor(self, order_ids, vendorId):
219 
    """
220 
    Parameters:
221 
     - order_ids
222 
     - vendorId
223 
    """
224 
    pass
225 
 
1528 ankur.sing 226 
  def getOrderForCustomer(self, orderId, customerId):
227 
    """
228 
    Returns an order for the order Id. Also checks if the order belongs to the customer whose Id is passed.
229 
    Throws exception if either order Id is invalid or order does not below to the customer whose Id is passed.
3431 rajveer 230 
 
1528 ankur.sing 231 
    Parameters:
232 
     - orderId
233 
     - customerId
234 
    """
235 
    pass
236 
 
4444 rajveer 237 
  def getAlerts(self, type, warehouseId, status, timestamp):
3064 chandransh 238 
    """
239 
    Parameters:
4394 rajveer 240 
     - type
4444 rajveer 241 
     - warehouseId
4394 rajveer 242 
     - status
243 
     - timestamp
3064 chandransh 244 
    """
245 
    pass
246 
 
4444 rajveer 247 
  def addAlert(self, type, warehouseId, description):
3064 chandransh 248 
    """
249 
    Parameters:
250 
     - type
4444 rajveer 251 
     - warehouseId
4394 rajveer 252 
     - description
3064 chandransh 253 
    """
254 
    pass
255 
 
4444 rajveer 256 
  def markAlertsAsSeen(self, warehouseId):
257 
    """
258 
    Parameters:
259 
     - warehouseId
260 
    """
261 
    pass
262 
 
3064 chandransh 263 
  def getValidOrderCount(self, ):
264 
    """
265 
    Return the number of valid orders. (OrderStatus >= OrderStatus.SUBMITTED_FOR_PROCESSING)
266 
    """
267 
    pass
268 
 
269 
  def getNoOfCustomersWithSuccessfulTransaction(self, ):
270 
    """
271 
    Returns the number of distinct customers who have done successful transactions
272 
    """
273 
    pass
274 
 
275 
  def getValidOrdersAmountRange(self, ):
276 
    """
277 
    Returns the minimum and maximum amounts of a valid order. (OrderStatus >= OrderStatus.SUBMITTED_FOR_PROCESSING)
278 
    List contains two values, first minimum amount and second maximum amount.
279 
    """
280 
    pass
281 
 
5874 rajveer 282 
  def getValidOrders(self, limit, onlyStore):
3064 chandransh 283 
    """
284 
    Returns list of Orders in descending order by Order creation date. List is restricted to limit Orders.
285 
    If limit is passed as 0, then all valid Orders are returned.
3431 rajveer 286 
 
3064 chandransh 287 
    Parameters:
288 
     - limit
5874 rajveer 289 
     - onlyStore
3064 chandransh 290 
    """
291 
    pass
292 
 
1220 chandransh 293 
  def batchOrders(self, warehouseId):
294 
    """
295 
    Create a batch of all the pending orders for the given warehouse.
296 
    The returned list is orderd by created_timestamp.
297 
    If there are no pending orders, an empty list is returned.
3431 rajveer 298 
 
1220 chandransh 299 
    Parameters:
300 
     - warehouseId
301 
    """
302 
    pass
303 
 
1208 chandransh 304 
  def markOrderAsOutOfStock(self, orderId):
305 
    """
306 
    Mark the given order as out of stock. Throws an exception if the order with the given Id couldn't be found.
3431 rajveer 307 
 
1208 chandransh 308 
    Parameters:
309 
     - orderId
310 
    """
311 
    pass
312 
 
3064 chandransh 313 
  def verifyOrder(self, orderId):
759 chandransh 314 
    """
3064 chandransh 315 
    Marks the given order as SUBMITTED_FOR_PROCESSING and updates the verified
316 
    timestamp. It is intended to be used for COD orders but can be harmlessly
317 
    used for all other orders as well.
318 
    Throws an exception if no such order exists.
3431 rajveer 319 
 
759 chandransh 320 
    Parameters:
3064 chandransh 321 
     - orderId
322 
    """
323 
    pass
324 
 
325 
  def acceptOrder(self, orderId):
326 
    """
327 
    Marks the given order as ACCEPTED and updates the accepted timestamp. If the
328 
    given order is not a COD order, it also captures the payment if the same has
329 
    not been captured.
330 
    Throws an exception if no such order exists.
3431 rajveer 331 
 
3064 chandransh 332 
    Parameters:
333 
     - orderId
334 
    """
335 
    pass
336 
 
7190 amar.kumar 337 
  def addBillingDetails(self, orderId, invoice_number, serialNumber, itemNumber, freebieWarehouseId, billed_by, jacketNumber, billingType, fulfilmentWarehouseId, authorize):
3064 chandransh 338 
    """
339 
    Add billing details such as the bill number and the biller to the Order.
4658 mandeep.dh 340 
    Adds jacket number, item number and Serial no. to the order. Doesn't update
3064 chandransh 341 
    the IMEI no. if a -1 is supplied.
342 
    Also, it generates an invoice number for the order, marks the order as
343 
    BILLED and sets the billing timestamp.
344 
    Returns false if it doesn't find the order with the given ID.
3431 rajveer 345 
 
3064 chandransh 346 
    Parameters:
347 
     - orderId
4283 anupam.sin 348 
     - invoice_number
4658 mandeep.dh 349 
     - serialNumber
3064 chandransh 350 
     - itemNumber
7190 amar.kumar 351 
     - freebieWarehouseId
4283 anupam.sin 352 
     - billed_by
353 
     - jacketNumber
3064 chandransh 354 
     - billingType
5110 mandeep.dh 355 
     - fulfilmentWarehouseId
4763 rajveer 356 
     - authorize
3064 chandransh 357 
    """
358 
    pass
359 
 
6756 amar.kumar 360 
  def addInvoiceNumber(self, orderId, invoiceNumber, color, serialNumber, itemNumber):
4579 rajveer 361 
    """
362 
    Add the invoice number to the order.
363 
 
364 
    Parameters:
365 
     - orderId
366 
     - invoiceNumber
4763 rajveer 367 
     - color
6756 amar.kumar 368 
     - serialNumber
369 
     - itemNumber
4579 rajveer 370 
    """
371 
    pass
372 
 
4910 phani.kuma 373 
  def markOrdersAsShippedFromWarehouse(self, warehouseId, providerId, cod, orderIds):
3064 chandransh 374 
    """
375 
    Depending on the third parameter, marks either all prepaid or all cod orders BILLED by the
4910 phani.kuma 376 
    given warehouse and were picked up by the given provider as SHIPPED_FROM_WH.
4410 rajveer 377 
 
378 
    Parameters:
379 
     - warehouseId
380 
     - providerId
381 
     - cod
4910 phani.kuma 382 
     - orderIds
4410 rajveer 383 
    """
384 
    pass
385 
 
5713 rajveer 386 
  def markOrdersAsReturnedFromStore(self, providerId, orderIds, awbs):
5676 rajveer 387 
    """
388 
    Parameters:
389 
     - providerId
390 
     - orderIds
5713 rajveer 391 
     - awbs
5676 rajveer 392 
    """
393 
    pass
394 
 
4910 phani.kuma 395 
  def markOrdersAsPickedUp(self, providerId, pickupDetails):
4410 rajveer 396 
    """
4910 phani.kuma 397 
    Marks all SHIPPED_FROM_WH orders of the previous day for a provider as SHIPPED_TO_LOGISTICS.
398 
    Raises an exception if we encounter report for an AWB number that we did not ship.
3431 rajveer 399 
 
3064 chandransh 400 
    Parameters:
759 chandransh 401 
     - providerId
4910 phani.kuma 402 
     - pickupDetails
759 chandransh 403 
    """
404 
    pass
405 
 
4910 phani.kuma 406 
  def getOrdersNotPickedUp(self, providerId):
1113 chandransh 407 
    """
408 
    Returns a list of orders that were shipped from warehouse but did not appear in the pick-up report.
3431 rajveer 409 
 
1113 chandransh 410 
    Parameters:
411 
     - providerId
412 
    """
413 
    pass
414 
 
1132 chandransh 415 
  def markOrdersAsDelivered(self, providerId, deliveredOrders):
416 
    """
417 
    Marks all orders with AWBs in the given map as delivered. Also sets the delivery timestamp and
418 
    the name of the receiver.
419 
    Raises an exception if we encounter report for an AWB number that we did not ship.
3431 rajveer 420 
 
1132 chandransh 421 
    Parameters:
422 
     - providerId
423 
     - deliveredOrders
424 
    """
425 
    pass
426 
 
4910 phani.kuma 427 
  def markAsRTOrders(self, providerId, returnedOrders):
1135 chandransh 428 
    """
4910 phani.kuma 429 
    Mark all orders with AWBs in the given map as RTO. Also sets the delivery timestamp.
1135 chandransh 430 
    Raises an exception if we encounter report for an AWB number that we did not ship.
3431 rajveer 431 
 
1135 chandransh 432 
    Parameters:
433 
     - providerId
434 
     - returnedOrders
435 
    """
436 
    pass
437 
 
4910 phani.kuma 438 
  def getRTOrders(self, providerId):
439 
    """
440 
    Returns a list of orders that were returned by courier.
441 
 
442 
    Parameters:
443 
     - providerId
444 
    """
445 
    pass
446 
 
1246 chandransh 447 
  def updateNonDeliveryReason(self, providerId, undeliveredOrders):
448 
    """
449 
    Update the status description of orders whose AWB numbers are keys of the Map.
3431 rajveer 450 
 
1246 chandransh 451 
    Parameters:
452 
     - providerId
453 
     - undeliveredOrders
454 
    """
455 
    pass
456 
 
4910 phani.kuma 457 
  def getNonDeliveredOrdersbyCourier(self, providerId):
458 
    """
459 
    Returns a list of orders that were picked up or shipped four days ago but did not get delivered.
460 
 
461 
    Parameters:
462 
     - providerId
463 
    """
464 
    pass
465 
 
466 
  def markOrdersAsLocalConnected(self, providerId, local_connected_orders):
467 
    """
468 
    Mark all orders with AWBs in the given map as local connected. Also sets the local connected timestamp.
469 
 
470 
    Parameters:
471 
     - providerId
472 
     - local_connected_orders
473 
    """
474 
    pass
475 
 
476 
  def getOrdersNotLocalConnected(self, providerId):
477 
    """
478 
    Returns a list of orders that were picked up or shipped but pending local connection.
479 
 
480 
    Parameters:
481 
     - providerId
482 
    """
483 
    pass
484 
 
485 
  def markOrdersAsDestinationCityReached(self, providerId, destination_city_reached_orders):
486 
    """
487 
    Mark all orders with AWBs in the given map as reached destination city. Also sets the reached destination timestamp.
488 
 
489 
    Parameters:
490 
     - providerId
491 
     - destination_city_reached_orders
492 
    """
493 
    pass
494 
 
495 
  def markOrdersAsFirstDeliveryAttempted(self, providerId, first_atdl_orders):
496 
    """
497 
    Mark all orders with AWBs in the given map as first delivery attempt made. Also sets the first delivery attempted timestamp.
498 
 
499 
    Parameters:
500 
     - providerId
501 
     - first_atdl_orders
502 
    """
503 
    pass
504 
 
1408 ankur.sing 505 
  def getUndeliveredOrders(self, providerId, warehouseId):
506 
    """
507 
    Returns the list of orders whose delivery time has passed but have not been
508 
    delivered yet for the given provider and warehouse. To get a complete list of
509 
    undelivered orders, pass them as -1.
510 
    Returns an empty list if no such orders exist.
3431 rajveer 511 
 
1408 ankur.sing 512 
    Parameters:
513 
     - providerId
514 
     - warehouseId
515 
    """
516 
    pass
517 
 
4783 phani.kuma 518 
  def getUndeliveredOrdersExpectedDeliveryDateNotMet(self, ):
519 
    """
520 
    Returns the list of orders whose expected delivery date has passed but have not been
521 
    delivered yet.
522 
    Returns an empty list if no such orders exist.
523 
    """
524 
    pass
525 
 
2536 chandransh 526 
  def toggleDOAFlag(self, orderId):
527 
    """
528 
    Toggle the DOA flag of an order. This should be used to flag an order for follow-up and unflag it when the follow-up is complete.
529 
    Returns the final flag status.
530 
    Throws an exception if the order with the given id couldn't be found or if the order status is not DELVIERY_SUCCESS.
3431 rajveer 531 
 
2536 chandransh 532 
    Parameters:
533 
     - orderId
534 
    """
535 
    pass
1886 ankur.sing 536 
 
4712 rajveer 537 
  def markOrderAsDelivered(self, orderId, deliveryTimestamp, receiver):
538 
    """
539 
    Parameters:
540 
     - orderId
541 
     - deliveryTimestamp
542 
     - receiver
543 
    """
544 
    pass
545 
 
5553 rajveer 546 
  def markOrderAsReceivedAtStore(self, orderId, deliveryTimestamp):
547 
    """
548 
    Parameters:
549 
     - orderId
550 
     - deliveryTimestamp
551 
    """
552 
    pass
553 
 
4454 rajveer 554 
  def markOrderDoaRequestReceived(self, orderId):
555 
    """
556 
    Once user raise the request for a DOA, order status will be changed from DELVIERY_SUCCESS to DOA_REQUEST_RECEIVED
557 
 
558 
    Parameters:
559 
     - orderId
560 
    """
561 
    pass
562 
 
563 
  def markOrderDoaRequestAuthorized(self, orderId, isAuthorized):
564 
    """
565 
    CRM person can authorize or deny the request reised by customer. If he authorizes order will change from DOA_REQUEST_RECEIVED
566 
    to DOA_REQUEST_AUTHORIZED. If he denies, status will be changed back to DELVIERY_SUCCESS.
567 
 
568 
    Parameters:
569 
     - orderId
570 
     - isAuthorized
571 
    """
572 
    pass
573 
 
4488 rajveer 574 
  def markOrderReturnRequestReceived(self, orderId):
575 
    """
576 
    Once user raise the request for a RET, order status will be changed from DELVIERY_SUCCESS to RET_REQUEST_RECEIVED
577 
 
578 
    Parameters:
579 
     - orderId
580 
    """
581 
    pass
582 
 
583 
  def markOrderReturnRequestAuthorized(self, orderId, isAuthorized):
584 
    """
585 
    CRM person can authorize or deny the request reised by customer. If he authorizes order will change from RET_REQUEST_RECEIVED
586 
    to RET_REQUEST_AUTHORIZED. If he denies, status will be changed back to DELVIERY_SUCCESS.
587 
 
588 
    Parameters:
589 
     - orderId
590 
     - isAuthorized
591 
    """
592 
    pass
593 
 
4579 rajveer 594 
  def requestPickupNumber(self, orderId, providerId):
2536 chandransh 595 
    """
596 
    Sends out an email to the account manager of the original courier provider used to ship the order.
4452 rajveer 597 
    If the order status was DELIVERY_SUCCESS, it is changed to be DOA_PICKUP_REQUEST_RAISED.
598 
    If the order status was DOA_PICKUP_REQUEST_RAISED, it is left unchanged.
2536 chandransh 599 
    For any other status, it returns false.
600 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 601 
 
2536 chandransh 602 
    Parameters:
603 
     - orderId
4579 rajveer 604 
     - providerId
2536 chandransh 605 
    """
606 
    pass
607 
 
4602 rajveer 608 
  def authorizePickup(self, orderId, pickupNumber, providerId):
2536 chandransh 609 
    """
4452 rajveer 610 
    If the order status is DOA_PICKUP_REQUEST_RAISED, it does the following
2536 chandransh 611 
    	1. Sends out an email to the customer with the dispatch advice that he has to print as an attachment.
612 
    	2. Changes order status to be DOA_PICKUP_AUTHORIZED.
613 
    	3. Returns true
2591 chandransh 614 
    If the order is in any other status, it returns false.
2536 chandransh 615 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 616 
 
2536 chandransh 617 
    Parameters:
618 
     - orderId
619 
     - pickupNumber
4602 rajveer 620 
     - providerId
2536 chandransh 621 
    """
622 
    pass
623 
 
2764 chandransh 624 
  def markDoasAsPickedUp(self, providerId, pickupDetails):
625 
    """
626 
    Marks all DOA_PICKUP_AUTHORIZED orders of the previous day for a provider as DOA_RETURN_IN_TRANSIT.
3431 rajveer 627 
 
2764 chandransh 628 
    Parameters:
629 
     - providerId
630 
     - pickupDetails
631 
    """
632 
    pass
633 
 
4910 phani.kuma 634 
  def getDoasNotPickedUp(self, providerId):
635 
    """
636 
    Returns a list of orders that were authorized for pickup but did not appear in the pick-up report.
637 
 
638 
    Parameters:
639 
     - providerId
640 
    """
641 
    pass
642 
 
4741 phani.kuma 643 
  def markReturnOrdersAsPickedUp(self, providerId, pickupDetails):
644 
    """
645 
    Marks all RET_PICKUP_CONFIRMED orders of the previous day for a provider as RET_RETURN_IN_TRANSIT.
646 
 
647 
    Parameters:
648 
     - providerId
649 
     - pickupDetails
650 
    """
651 
    pass
652 
 
4910 phani.kuma 653 
  def getReturnOrdersNotPickedUp(self, providerId):
654 
    """
655 
    Returns a list of orders that were authorized for pickup but did not appear in the pick-up report.
656 
 
657 
    Parameters:
658 
     - providerId
659 
    """
660 
    pass
661 
 
4479 rajveer 662 
  def receiveReturn(self, orderId, receiveCondition):
2591 chandransh 663 
    """
4452 rajveer 664 
    If the order status is DOA_PICKUP_CONFIRMED or DOA_RETURN_IN_TRANSIT, marks the order status as DOA_RECEIVED_PRESTINE and returns true.
4484 rajveer 665 
    If the order status is RTO_IN_TRANSIT, marks the order status as RTO_RECEIVED_PRESTINE and returns true.
2591 chandransh 666 
    If the order is in any other state, it returns false.
667 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 668 
 
2591 chandransh 669 
    Parameters:
670 
     - orderId
4479 rajveer 671 
     - receiveCondition
2591 chandransh 672 
    """
673 
    pass
2536 chandransh 674 
 
2591 chandransh 675 
  def validateDoa(self, orderId, isValid):
676 
    """
4452 rajveer 677 
    Used to validate the DOA certificate for an order in the DOA_RECEIVED_PRESTINE state. If the certificate is valid,
2616 chandransh 678 
    the order state is changed to DOA_CERT_VALID. If the certificate is invalid, the order state is changed to DOA_CERT_INVALID.
2591 chandransh 679 
    If the order is in any other state, it returns false.
680 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 681 
 
2591 chandransh 682 
    Parameters:
683 
     - orderId
684 
     - isValid
685 
    """
686 
    pass
687 
 
4495 rajveer 688 
  def validateReturnProduct(self, orderId, isUsable):
689 
    """
690 
    Parameters:
691 
     - orderId
692 
     - isUsable
693 
    """
694 
    pass
695 
 
2616 chandransh 696 
  def reshipOrder(self, orderId):
697 
    """
4484 rajveer 698 
    If the order is in RTO_RECEIVED_PRESTINE or DOA_CERT_INVALID state, it does the following:
2616 chandransh 699 
    	1. Creates a new order for processing in the BILLED state. All billing information is saved.
4484 rajveer 700 
    	2. Marks the current order as one of the final states RTO_RESHIPPED and DOA_INVALID_RESHIPPED depending on what state the order started in.
2616 chandransh 701 
 
702 
    If the order is in DOA_CERT_VALID state, it does the following:
703 
    	1. Creates a new order for processing in the SUBMITTED_FOR_PROCESSING state.
704 
    	2. Creates a return order for the warehouse executive to return the DOA material.
4452 rajveer 705 
    	3. Marks the current order as the final DOA_VALID_RESHIPPED state.
3431 rajveer 706 
 
2616 chandransh 707 
    Returns the id of the newly created order.
3431 rajveer 708 
 
2616 chandransh 709 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 710 
 
2616 chandransh 711 
    Parameters:
712 
     - orderId
713 
    """
714 
    pass
2591 chandransh 715 
 
3226 chandransh 716 
  def refundOrder(self, orderId, refundedBy, reason):
2616 chandransh 717 
    """
4484 rajveer 718 
    If the order is in RTO_RECEIVED_PRESTINE, DOA_CERT_VALID or DOA_CERT_INVALID state, it does the following:
2616 chandransh 719 
    	1. Creates a refund request for batch processing.
720 
    	2. Creates a return order for the warehouse executive to return the shipped material.
4484 rajveer 721 
    	3. Marks the current order as RTO_REFUNDED, DOA_VALID_REFUNDED or DOA_INVALID_REFUNDED final states.
3431 rajveer 722 
 
2616 chandransh 723 
    If the order is in SUBMITTED_FOR_PROCESSING or INVENTORY_LOW state, it does the following:
724 
    	1. Creates a refund request for batch processing.
3226 chandransh 725 
    	2. Cancels the reservation of the item in the warehouse.
726 
    	3. Marks the current order as the REFUNDED final state.
3431 rajveer 727 
 
3226 chandransh 728 
    For all COD orders, if the order is in INIT, SUBMITTED_FOR_PROCESSING or INVENTORY_LOW state, it does the following:
729 
    	1. Cancels the reservation of the item in the warehouse.
730 
    	2. Marks the current order as CANCELED.
731 
 
732 
    In all cases, it updates the reason for cancellation or refund and the person who performed the action.
733 
 
2616 chandransh 734 
    Returns True if it is successful, False otherwise.
3431 rajveer 735 
 
2616 chandransh 736 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 737 
 
2616 chandransh 738 
    Parameters:
739 
     - orderId
3226 chandransh 740 
     - refundedBy
741 
     - reason
2616 chandransh 742 
    """
743 
    pass
744 
 
2690 chandransh 745 
  def getReturnOrders(self, warehouseId, fromDate, toDate):
746 
    """
747 
    Get all return orders created between the from and to dates for the given warehouse.
748 
    Ignores the warehouse if it is passed as -1.
3431 rajveer 749 
 
2690 chandransh 750 
    Parameters:
751 
     - warehouseId
752 
     - fromDate
753 
     - toDate
754 
    """
755 
    pass
2616 chandransh 756 
 
5481 phani.kuma 757 
  def getAllReturnOrders(self, onlyNotProcessed, fromDate, toDate):
758 
    """
759 
    Get all return orders created between the from and to dates.
760 
 
761 
    Parameters:
762 
     - onlyNotProcessed
763 
     - fromDate
764 
     - toDate
765 
    """
766 
    pass
767 
 
2700 chandransh 768 
  def getReturnOrder(self, id):
769 
    """
770 
    Returns the ReturnOrder corresponding to the given id.
771 
    Throws an exception if the return order with the given id couldn't be found.
3431 rajveer 772 
 
2700 chandransh 773 
    Parameters:
774 
     - id
775 
    """
776 
    pass
777 
 
2690 chandransh 778 
  def processReturn(self, returnOrderId):
779 
    """
780 
    Marks the return order with the given id as processed. Raises an exception if no such return order exists.
3431 rajveer 781 
 
2690 chandransh 782 
    Parameters:
783 
     - returnOrderId
784 
    """
785 
    pass
786 
 
3451 chandransh 787 
  def updateWeight(self, orderId, weight):
788 
    """
789 
    Set the weight of the given order to the provided value. Will attempt to update the weight of the item in the catalog as well.
2819 chandransh 790 
 
3451 chandransh 791 
    Parameters:
792 
     - orderId
793 
     - weight
794 
    """
795 
    pass
796 
 
3469 chandransh 797 
  def changeItem(self, orderId, itemId):
798 
    """
799 
    Change the item to be shipped for this order. Also adjusts the reservation in the inventory accordingly.
800 
    Currently, it also ensures that only a different color of the given item is shipped.
3451 chandransh 801 
 
3469 chandransh 802 
    Parameters:
803 
     - orderId
804 
     - itemId
805 
    """
806 
    pass
807 
 
808 
  def shiftToWarehouse(self, orderId, warehouseId):
809 
    """
810 
    Moves the given order to the given warehouse. Also adjusts the inventory reservations accordingly.
811 
 
812 
    Parameters:
813 
     - orderId
814 
     - warehouseId
815 
    """
816 
    pass
817 
 
4647 rajveer 818 
  def addDelayReason(self, orderId, delayReason, furtherDelay, delayReasonText):
3553 chandransh 819 
    """
820 
    Adds the given delay reason to the given order.
3986 chandransh 821 
    Increases the expected delivery time of the given order by the given no. of days.
3553 chandransh 822 
    Raises an exception if no order with the given id can be found.
3469 chandransh 823 
 
3553 chandransh 824 
    Parameters:
825 
     - orderId
826 
     - delayReason
3986 chandransh 827 
     - furtherDelay
4647 rajveer 828 
     - delayReasonText
3553 chandransh 829 
    """
830 
    pass
831 
 
3956 chandransh 832 
  def reconcileCodCollection(self, collectedAmountMap, xferBy, xferTxnId, xferDate):
833 
    """
834 
    Marks the COD orders with given AWB nos. as having been processed.
835 
    Updates the captured amount for the corresponding payment.
3553 chandransh 836 
 
3956 chandransh 837 
    Returns a map of AWBs which were not processed and the associated reason. An AWB is not processed if:
838 
    1. There is no order corresponding to an AWB number.
839 
    2. The captured amount for a payment exceeds the total payment.
840 
    3. The order corresponding to an AWB no. is in a state prior to DELIVERY_SUCCESS.
841 
 
842 
    Parameters:
843 
     - collectedAmountMap
844 
     - xferBy
845 
     - xferTxnId
846 
     - xferDate
847 
    """
848 
    pass
849 
 
4008 mandeep.dh 850 
  def getTransactionsRequiringExtraProcessing(self, category):
851 
    """
4065 mandeep.dh 852 
    Returns the list of transaction ids that require some extra processing and
4008 mandeep.dh 853 
    which belong to a particular category. This is currently used by CRM
4065 mandeep.dh 854 
    application. If no such transaction ids are present, it returns an empty list.
3956 chandransh 855 
 
4008 mandeep.dh 856 
    Parameters:
857 
     - category
858 
    """
859 
    pass
860 
 
861 
  def markTransactionAsProcessed(self, transactionId, category):
862 
    """
863 
    Marks a particular transaction as processed for a particular cateogory.
4065 mandeep.dh 864 
    It essentially deletes the transaction id record for a particular
865 
    processing type category (if present) from DB.
866 
    This is currently used by CRM application.
4008 mandeep.dh 867 
 
868 
    Parameters:
869 
     - transactionId
870 
     - category
871 
    """
872 
    pass
873 
 
4018 chandransh 874 
  def getItemWiseRiskyOrdersCount(self, ):
875 
    """
876 
    Returns a map containing the number of risky orders keyed by item id. A risky order
877 
    is defined as one whose shipping date is about to expire.
878 
    """
879 
    pass
4008 mandeep.dh 880 
 
4295 varun.gupt 881 
  def getOrdersForItemIds(self, itemIds):
882 
    """
883 
    Returns a list of all orders which have items with given id
884 
 
885 
    Parameters:
886 
     - itemIds
887 
    """
888 
    pass
889 
 
4247 rajveer 890 
  def markOrderCancellationRequestReceived(self, orderId):
891 
    """
892 
    Mark order as cancellation request received. If customer sends request of cancellation of
893 
    a particular order, this method will be called. It will just change status of the order
894 
    depending on its current status. It also records the previous status, so that we can move
895 
    back to that status if cancellation request is denied.
4018 chandransh 896 
 
4247 rajveer 897 
    Parameters:
898 
     - orderId
899 
    """
900 
    pass
901 
 
902 
  def markOrderCancellationRequestConfirmed(self, orderId):
903 
    """
904 
    If we decide to to cancel order, CRM will call this method to move the status of order to
905 
    cancellation request confirmed. After this OM will be able to cancel the order.
906 
 
907 
    Parameters:
908 
     - orderId
909 
    """
910 
    pass
911 
 
912 
  def markOrderCancellationRequestDenied(self, orderId):
913 
    """
914 
    If we decide to not to cancel order, we will move the order ro previous status.
915 
 
916 
    Parameters:
917 
     - orderId
918 
    """
919 
    pass
920 
 
4258 rajveer 921 
  def markTransactionAsPaymentFlagRemoved(self, transactionId):
4247 rajveer 922 
    """
4258 rajveer 923 
    If we and/or payment gateway has decided to accept the payment, this method needs to be called.
924 
    Changed transaction and all orders status to payment accepted.
4247 rajveer 925 
 
926 
    Parameters:
4258 rajveer 927 
     - transactionId
4247 rajveer 928 
    """
929 
    pass
930 
 
4259 anupam.sin 931 
  def refundTransaction(self, transactionId, refundedBy, reason):
932 
    """
933 
    This method is called when a flagged payment is deemed unserviceable and the corresponding orders
934 
    need to be cancelled
4247 rajveer 935 
 
4259 anupam.sin 936 
    Parameters:
937 
     - transactionId
938 
     - refundedBy
939 
     - reason
940 
    """
941 
    pass
942 
 
4324 mandeep.dh 943 
  def updateShipmentAddress(self, orderId, addressId):
944 
    """
945 
    Updates shipment address of an order. Delivery and shipping date estimates
946 
    etc. are also updated here.
947 
 
948 
    Throws TransactionServiceException in case address change is not
949 
    possible due to certain reasons such as new pincode in address is
950 
    not serviceable etc.
951 
 
952 
    Parameters:
953 
     - orderId
954 
     - addressId
955 
    """
956 
    pass
957 
 
4285 rajveer 958 
  def acceptOrdersForItemId(self, itemId, inventory):
959 
    """
960 
    Marks the orders as ACCEPTED for the given itemId and inventory. It also updates the accepted timestamp. If the
961 
    given order is not a COD order, it also captures the payment if the same has not been captured.
4259 anupam.sin 962 
 
4285 rajveer 963 
    Parameters:
964 
     - itemId
965 
     - inventory
966 
    """
967 
    pass
968 
 
4369 rajveer 969 
  def markOrdersAsPORaised(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 970 
    """
971 
    Parameters:
972 
     - vendorId
973 
     - itemId
974 
     - quantity
975 
     - estimate
4369 rajveer 976 
     - isReminder
4303 rajveer 977 
    """
978 
    pass
4285 rajveer 979 
 
4369 rajveer 980 
  def markOrdersAsReversalInitiated(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 981 
    """
982 
    Parameters:
983 
     - vendorId
984 
     - itemId
985 
     - quantity
986 
     - estimate
4369 rajveer 987 
     - isReminder
4303 rajveer 988 
    """
989 
    pass
990 
 
4369 rajveer 991 
  def markOrdersAsNotAvailabke(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 992 
    """
993 
    Parameters:
994 
     - vendorId
995 
     - itemId
996 
     - quantity
997 
     - estimate
4369 rajveer 998 
     - isReminder
4303 rajveer 999 
    """
1000 
    pass
1001 
 
4369 rajveer 1002 
  def markOrdersAsTimeout(self, vendorId):
1003 
    """
1004 
    Parameters:
1005 
     - vendorId
1006 
    """
1007 
    pass
4303 rajveer 1008 
 
4662 rajveer 1009 
  def markOrderAsLostInTransit(self, orderId):
1010 
    """
1011 
    Mark order as LOST_IN_TRANSIT
1012 
 
1013 
    Parameters:
1014 
     - orderId
1015 
    """
1016 
    pass
1017 
 
4386 anupam.sin 1018 
  def getOrderForAwb(self, awb):
1019 
    """
1020 
    Returns the order corresponding to an AWB number
4369 rajveer 1021 
 
4386 anupam.sin 1022 
    Parameters:
1023 
     - awb
1024 
    """
1025 
    pass
1026 
 
4910 phani.kuma 1027 
  def getOrdersForProviderForStatus(self, logistics_provider_id, order_status_list):
4506 phani.kuma 1028 
    """
4910 phani.kuma 1029 
    Returns the order corresponding to a logistics provider id for a given list of order status
4386 anupam.sin 1030 
 
4506 phani.kuma 1031 
    Parameters:
1032 
     - logistics_provider_id
4910 phani.kuma 1033 
     - order_status_list
4506 phani.kuma 1034 
    """
1035 
    pass
1036 
 
4600 varun.gupt 1037 
  def getBilledOrdersForVendor(self, vendorId, billingDateFrom, billingDateTo):
1038 
    """
1039 
    Returns list of orders fullfiled from a certain vendor and billed in a given date range
4506 phani.kuma 1040 
 
4600 varun.gupt 1041 
    Parameters:
1042 
     - vendorId
1043 
     - billingDateFrom
1044 
     - billingDateTo
1045 
    """
1046 
    pass
1047 
 
4607 rajveer 1048 
  def getSlippedSippingDateOrders(self, ):
1049 
    pass
1050 
 
4709 rajveer 1051 
  def getCancelledOrders(self, cancelDateFrom, cancelDateTo):
1052 
    """
1053 
    Parameters:
1054 
     - cancelDateFrom
1055 
     - cancelDateTo
1056 
    """
1057 
    pass
1058 
 
4600 varun.gupt 1059 
  def saveBluedartSettlements(self, mapAWBAndAmount):
1060 
    """
1061 
    Parameters:
1062 
     - mapAWBAndAmount
1063 
    """
1064 
    pass
1065 
 
4905 varun.gupt 1066 
  def savePaymentSettlements(self, settlementDate, paymentGatewayId, referenceId, serviceTax, otherCharges, netCollection):
4600 varun.gupt 1067 
    """
1068 
    Parameters:
1069 
     - settlementDate
1070 
     - paymentGatewayId
4905 varun.gupt 1071 
     - referenceId
4600 varun.gupt 1072 
     - serviceTax
1073 
     - otherCharges
1074 
     - netCollection
1075 
    """
1076 
    pass
1077 
 
1078 
  def saveEBSSettlementSummary(self, settlementId, settlementDate, transactionDateFrom, transactionDateTo, amount):
1079 
    """
1080 
    Parameters:
1081 
     - settlementId
1082 
     - settlementDate
1083 
     - transactionDateFrom
1084 
     - transactionDateTo
1085 
     - amount
1086 
    """
1087 
    pass
1088 
 
5386 phani.kuma 1089 
  def getSettlementForPrepaid(self, referenceId, isRefund):
4600 varun.gupt 1090 
    """
1091 
    Parameters:
5189 varun.gupt 1092 
     - referenceId
1093 
     - isRefund
4600 varun.gupt 1094 
    """
1095 
    pass
1096 
 
5386 phani.kuma 1097 
  def getSettlementForCod(self, orderId, isRefund):
1098 
    """
1099 
    Parameters:
1100 
     - orderId
1101 
     - isRefund
1102 
    """
1103 
    pass
1104 
 
4600 varun.gupt 1105 
  def getEBSSettlementSummaries(self, ):
1106 
    pass
1107 
 
1108 
  def markEBSSettlementUploaded(self, settlementId):
1109 
    """
1110 
    Parameters:
1111 
     - settlementId
1112 
    """
1113 
    pass
1114 
 
1115 
  def getEBSSettlementDate(self, settlementId):
1116 
    """
1117 
    Parameters:
1118 
     - settlementId
1119 
    """
1120 
    pass
1121 
 
4715 varun.gupt 1122 
  def getSettlementsByDate(self, settlementDateFrom, settlementDateTo, isRefund):
1123 
    """
1124 
    Parameters:
1125 
     - settlementDateFrom
1126 
     - settlementDateTo
1127 
     - isRefund
1128 
    """
1129 
    pass
4600 varun.gupt 1130 
 
4715 varun.gupt 1131 
  def getReshippedOrderIds(self, orderIds):
1132 
    """
1133 
    Returns list of Order Ids, which belong to reshiped orders, shortlisted from a given list of Order Ids
1134 
 
1135 
    Parameters:
1136 
     - orderIds
1137 
    """
1138 
    pass
1139 
 
5481 phani.kuma 1140 
  def getBilledOrders(self, vendorId, onlyVendorNotPaid, billingDateFrom, billingDateTo):
4875 varun.gupt 1141 
    """
1142 
    Parameters:
1143 
     - vendorId
5481 phani.kuma 1144 
     - onlyVendorNotPaid
1145 
     - billingDateFrom
1146 
     - billingDateTo
4875 varun.gupt 1147 
    """
1148 
    pass
4757 mandeep.dh 1149 
 
5031 varun.gupt 1150 
  def getStatusDistributionOfOrders(self, startDate, endDate):
1151 
    """
1152 
    Parameters:
1153 
     - startDate
1154 
     - endDate
1155 
    """
1156 
    pass
4875 varun.gupt 1157 
 
5067 varun.gupt 1158 
  def getOrderIdsForStatus(self, status, startDatetime, endDatetime):
1159 
    """
1160 
    Parameters:
1161 
     - status
1162 
     - startDatetime
1163 
     - endDatetime
1164 
    """
1165 
    pass
5031 varun.gupt 1166 
 
5348 anupam.sin 1167 
  def updateCODAgent(self, agent, orderId):
1168 
    """
1169 
    Updates the agent who handled the COD verification call
1170 
 
1171 
    Parameters:
1172 
     - agent
1173 
     - orderId
1174 
    """
1175 
    pass
1176 
 
5099 varun.gupt 1177 
  def updateOrderAsPaidToVendor(self, orderId):
1178 
    """
1179 
    Parameters:
1180 
     - orderId
1181 
    """
1182 
    pass
5067 varun.gupt 1183 
 
5386 phani.kuma 1184 
  def updateOrderOnlyAsPaidToVendor(self, orderId):
1185 
    """
1186 
    Parameters:
1187 
     - orderId
1188 
    """
1189 
    pass
1190 
 
5208 varun.gupt 1191 
  def getRefundedOrdersMarkedPaid(self, ):
1192 
    pass
5099 varun.gupt 1193 
 
5447 anupam.sin 1194 
  def getAllVerificationAgents(self, minOrderId, maxOrderId):
1195 
    """
1196 
    gets all COD Verification Agents for all orderIds from a minId to maxId
5208 varun.gupt 1197 
 
5447 anupam.sin 1198 
 
1199 
    Parameters:
1200 
     - minOrderId
1201 
     - maxOrderId
1202 
    """
1203 
    pass
1204 
 
5527 anupam.sin 1205 
  def getAllAttributesForOrderId(self, orderId):
1206 
    """
1207 
    gets all attributes for a given orderId
5447 anupam.sin 1208 
 
5527 anupam.sin 1209 
    Parameters:
1210 
     - orderId
1211 
    """
1212 
    pass
1213 
 
5676 rajveer 1214 
  def setOrderAttributes(self, orderId, attributes):
1215 
    """
1216 
    sets attributes for an order
1217 
 
1218 
    Parameters:
1219 
     - orderId
1220 
     - attributes
1221 
    """
1222 
    pass
1223 
 
5527 anupam.sin 1224 
  def setOrderAttributeForTransaction(self, transactionId, attribute):
1225 
    """
1226 
    sets attributes for all orders in a transaction
1227 
 
1228 
    Parameters:
1229 
     - transactionId
1230 
     - attribute
1231 
    """
1232 
    pass
1233 
 
5553 rajveer 1234 
  def getReceivePendingOrders(self, storeId):
1235 
    """
1236 
    Parameters:
1237 
     - storeId
1238 
    """
1239 
    pass
5527 anupam.sin 1240 
 
5553 rajveer 1241 
  def getReceivedAtStoreOrders(self, storeId):
1242 
    """
1243 
    Parameters:
1244 
     - storeId
1245 
    """
1246 
    pass
1247 
 
5713 rajveer 1248 
  def getOrdersCollectionAtStore(self, storeId, fromDate, toDate, onlyCod):
1249 
    """
1250 
    Parameters:
1251 
     - storeId
1252 
     - fromDate
1253 
     - toDate
1254 
     - onlyCod
1255 
    """
1256 
    pass
1257 
 
5833 rajveer 1258 
  def getOrderAttributeValue(self, orderId, attributeName):
1259 
    """
1260 
    Parameters:
1261 
     - orderId
1262 
     - attributeName
1263 
    """
1264 
    pass
1265 
 
6019 rajveer 1266 
  def changeJacketNumber(self, orderId, jacketNumber):
1267 
    """
1268 
    Parameters:
1269 
     - orderId
1270 
     - jacketNumber
1271 
    """
1272 
    pass
1273 
 
1274 
  def markOrderAsRtoInTransit(self, orderId):
1275 
    """
1276 
    Parameters:
1277 
     - orderId
1278 
    """
1279 
    pass
1280 
 
5593 mandeep.dh 1281 
  def acceptOrderForItem(self, itemId, quantity, fulfilmentWarehouseId, billingWarehouseId):
1282 
    """
1283 
    Accepts appropriate order for an item in a given billingWarehouse. Usually
1284 
    invoked while scanning IN of items.
5553 rajveer 1285 
 
5593 mandeep.dh 1286 
    Parameters:
1287 
     - itemId
1288 
     - quantity
1289 
     - fulfilmentWarehouseId
1290 
     - billingWarehouseId
1291 
    """
1292 
    pass
1293 
 
6000 mandeep.dh 1294 
  def createRechargeOrder(self, rechargeOrder):
1295 
    """
1296 
    Parameters:
1297 
     - rechargeOrder
1298 
    """
1299 
    pass
5593 mandeep.dh 1300 
 
6031 rajveer 1301 
  def getRechargeOrder(self, rechargeRrderId):
1302 
    """
1303 
    Parameters:
1304 
     - rechargeRrderId
1305 
    """
1306 
    pass
1307 
 
1308 
  def getRechargeOrders(self, userId):
1309 
    """
1310 
    Parameters:
1311 
     - userId
1312 
    """
1313 
    pass
1314 
 
6000 mandeep.dh 1315 
  def updateRechargeOrderStatus(self, rechargeOrderId, rechargeOrderStatus):
1316 
    """
1317 
    Parameters:
1318 
     - rechargeOrderId
1319 
     - rechargeOrderStatus
1320 
    """
1321 
    pass
1322 
 
6031 rajveer 1323 
  def activateRechargeTxn(self, rechargeOrderId):
6000 mandeep.dh 1324 
    """
1325 
    Parameters:
6031 rajveer 1326 
     - rechargeOrderId
6000 mandeep.dh 1327 
    """
1328 
    pass
1329 
 
6031 rajveer 1330 
  def getUserWallet(self, userId):
6000 mandeep.dh 1331 
    """
1332 
    Parameters:
6031 rajveer 1333 
     - userId
6000 mandeep.dh 1334 
    """
1335 
    pass
1336 
 
6031 rajveer 1337 
  def getUserWalletHistory(self, userId):
6000 mandeep.dh 1338 
    """
1339 
    Parameters:
6031 rajveer 1340 
     - userId
6000 mandeep.dh 1341 
    """
1342 
    pass
1343 
 
6050 anupam.sin 1344 
  def getRechargeOrdersForTransaction(self, txnId):
1345 
    """
1346 
    Returns a recharge order for a given transactionId
1347 
 
1348 
    Parameters:
1349 
     - txnId
1350 
    """
1351 
    pass
1352 
 
6206 rajveer 1353 
  def getServiceProviders(self, rechargeType, onlyActive):
6048 rajveer 1354 
    """
1355 
    Parameters:
1356 
     - rechargeType
6206 rajveer 1357 
     - onlyActive
6048 rajveer 1358 
    """
1359 
    pass
6000 mandeep.dh 1360 
 
6049 rajveer 1361 
  def getServiceProviderForDevice(self, rechargeType, deviceNumber):
6048 rajveer 1362 
    """
1363 
    Parameters:
6049 rajveer 1364 
     - rechargeType
6048 rajveer 1365 
     - deviceNumber
1366 
    """
1367 
    pass
1368 
 
6591 anupam.sin 1369 
  def validateRecharge(self, rechargeType, deviceNumber, userSelectedProviderId, clientAddress):
6269 rajveer 1370 
    """
1371 
    Parameters:
1372 
     - rechargeType
1373 
     - deviceNumber
6307 anupam.sin 1374 
     - userSelectedProviderId
6591 anupam.sin 1375 
     - clientAddress
6269 rajveer 1376 
    """
1377 
    pass
1378 
 
6094 rajveer 1379 
  def getRechargeOrdersForDevice(self, deviceNumber):
1380 
    """
1381 
    Parameters:
1382 
     - deviceNumber
1383 
    """
1384 
    pass
6048 rajveer 1385 
 
6094 rajveer 1386 
  def addAmountToWallet(self, userId, orderId, amount):
1387 
    """
1388 
    Parameters:
1389 
     - userId
1390 
     - orderId
1391 
     - amount
1392 
    """
1393 
    pass
1394 
 
6188 rajveer 1395 
  def getRechargeStatistics(self, ):
1396 
    pass
1397 
 
6154 rajveer 1398 
  def getRechargeOrdersForStatus(self, status):
1399 
    """
1400 
    Parameters:
1401 
     - status
1402 
    """
1403 
    pass
6094 rajveer 1404 
 
6159 rajveer 1405 
  def getPlansForOperator(self, operatorId):
1406 
    """
1407 
    Parameters:
1408 
     - operatorId
1409 
    """
1410 
    pass
6154 rajveer 1411 
 
6307 anupam.sin 1412 
  def getRechargeDenominations(self, operatorId, circleCode, denominationType):
6289 anupam.sin 1413 
    """
1414 
    Returns denominations for a given operator and circle
6159 rajveer 1415 
 
6289 anupam.sin 1416 
    Parameters:
1417 
     - operatorId
6307 anupam.sin 1418 
     - circleCode
6289 anupam.sin 1419 
     - denominationType
1420 
    """
1421 
    pass
1422 
 
6371 rajveer 1423 
  def updateAvailabilityStatus(self, operatorId, circleId, isAvailable):
1424 
    """
1425 
    Parameters:
1426 
     - operatorId
1427 
     - circleId
1428 
     - isAvailable
1429 
    """
1430 
    pass
6289 anupam.sin 1431 
 
6389 rajveer 1432 
  def getAvailableEmiSchemes(self, ):
1433 
    pass
6371 rajveer 1434 
 
6389 rajveer 1435 
  def getMiscCharges(self, transactionId):
1436 
    """
1437 
    Parameters:
1438 
     - transactionId
1439 
    """
1440 
    pass
1441 
 
6507 anupam.sin 1442 
  def refundRechargeOrder(self, rechargeOrderId):
1443 
    """
1444 
    Parameters:
1445 
     - rechargeOrderId
1446 
    """
1447 
    pass
6389 rajveer 1448 
 
6821 amar.kumar 1449 
  def getPhysicalOrders(self, fromDate, toDate):
1450 
    """
1451 
    Parameters:
1452 
     - fromDate
1453 
     - toDate
1454 
    """
1455 
    pass
6507 anupam.sin 1456 
 
6906 rajveer 1457 
  def getDocument(self, docType, docSource):
1458 
    """
1459 
    Parameters:
1460 
     - docType
1461 
     - docSource
1462 
    """
1463 
    pass
6821 amar.kumar 1464 
 
6985 anupam.sin 1465 
  def changeShippingAddress(self, orderId, line1, line2, city, state, pin):
1466 
    """
1467 
    Parameters:
1468 
     - orderId
1469 
     - line1
1470 
     - line2
1471 
     - city
1472 
     - state
1473 
     - pin
1474 
    """
1475 
    pass
6906 rajveer 1476 
 
7075 rajveer 1477 
  def retrieveInvoice(self, orderId, userId):
6988 rajveer 1478 
    """
1479 
    Parameters:
1480 
     - orderId
7075 rajveer 1481 
     - userId
6988 rajveer 1482 
    """
1483 
    pass
6985 anupam.sin 1484 
 
7026 rajveer 1485 
  def receiveUpdatesForRedExpress(self, awbNumber):
1486 
    """
1487 
    Parameters:
1488 
     - awbNumber
1489 
    """
1490 
    pass
6988 rajveer 1491 
 
7073 anupam.sin 1492 
  def createRechargeTransaction(self, thriftRechargeTransaction):
1493 
    """
1494 
    Parameters:
1495 
     - thriftRechargeTransaction
1496 
    """
1497 
    pass
7026 rajveer 1498 
 
7085 rajveer 1499 
  def getRechargeTransactions(self, storeId):
1500 
    """
1501 
    Parameters:
1502 
     - storeId
1503 
    """
1504 
    pass
1505 
 
7151 amit.gupta 1506 
  def getRechargeTrans(self, storeId, startDate, endDate, status):
1507 
    """
1508 
    Parameters:
1509 
     - storeId
1510 
     - startDate
1511 
     - endDate
1512 
     - status
1513 
    """
1514 
    pass
1515 
 
7080 anupam.sin 1516 
  def getRechargeTransaction(self, rechargeId):
1517 
    """
1518 
    Parameters:
1519 
     - rechargeId
1520 
    """
1521 
    pass
7073 anupam.sin 1522 
 
7080 anupam.sin 1523 
  def getFRCs(self, circleId, operatorId):
1524 
    """
1525 
    Parameters:
1526 
     - circleId
1527 
     - operatorId
1528 
    """
1529 
    pass
1530 
 
7096 anupam.sin 1531 
  def getHotspotStore(self, id, hotspotid):
1532 
    """
1533 
    Parameters:
1534 
     - id
1535 
     - hotspotid
1536 
    """
1537 
    pass
7080 anupam.sin 1538 
 
7096 anupam.sin 1539 
  def getTelecomCircle(self, id, code):
1540 
    """
1541 
    Parameters:
1542 
     - id
1543 
     - code
1544 
    """
1545 
    pass
1546 
 
7109 anupam.sin 1547 
  def retrieveHotspotRechargeInvoice(self, rechargeId):
1548 
    """
1549 
    Parameters:
1550 
     - rechargeId
1551 
    """
1552 
    pass
7096 anupam.sin 1553 
 
7190 amar.kumar 1554 
  def splitFreebieOrder(self, orderId, splitReason, shippingDate):
1555 
    """
1556 
    Parameters:
1557 
     - orderId
1558 
     - splitReason
1559 
     - shippingDate
1560 
    """
1561 
    pass
1562 
 
7172 anupam.sin 1563 
  def getRechargeTransactionsByNumber(self, number, storeId):
7169 anupam.sin 1564 
    """
1565 
    Parameters:
1566 
     - number
7172 anupam.sin 1567 
     - storeId
7169 anupam.sin 1568 
    """
1569 
    pass
7109 anupam.sin 1570 
 
7169 anupam.sin 1571 
  def updateHotspotStorePassword(self, storeId, password):
1572 
    """
1573 
    Parameters:
1574 
     - storeId
1575 
     - password
1576 
    """
1577 
    pass
1578 
 
7285 rajveer 1579 
  def topupCompanyWallet(self, companyId, amount):
7263 anupam.sin 1580 
    """
1581 
    Parameters:
7285 rajveer 1582 
     - companyId
1583 
     - amount
7263 anupam.sin 1584 
    """
1585 
    pass
7169 anupam.sin 1586 
 
7285 rajveer 1587 
  def getWalletBalanceForCompany(self, companyId):
1588 
    """
1589 
    Parameters:
1590 
     - companyId
1591 
    """
7267 anupam.sin 1592 
    pass
7263 anupam.sin 1593 
 
7285 rajveer 1594 
  def getSourceDetail(self, source):
7267 anupam.sin 1595 
    """
1596 
    Parameters:
7285 rajveer 1597 
     - source
7267 anupam.sin 1598 
    """
1599 
    pass
1600 
 
7308 rajveer 1601 
  def getAllCircles(self, ):
1602 
    pass
7267 anupam.sin 1603 
 
7308 rajveer 1604 
  def deleteFrcs(self, frcIdsToDelete):
1605 
    """
1606 
    Parameters:
1607 
     - frcIdsToDelete
1608 
    """
1609 
    pass
1610 
 
7311 kshitij.so 1611 
  def addAmazonOrder(self, amazonOrder):
1612 
    """
1613 
    Parameters:
1614 
     - amazonOrder
1615 
    """
1616 
    pass
7308 rajveer 1617 
 
7322 vikram.rag 1618 
  def updateAmazonOrderStatus(self, orderId, status):
7311 kshitij.so 1619 
    """
1620 
    Parameters:
1621 
     - orderId
1622 
     - status
1623 
    """
1624 
    pass
1625 
 
1626 
  def getAmazonOrdersShipped(self, interval):
1627 
    """
1628 
    Parameters:
1629 
     - interval
1630 
    """
1631 
    pass
1632 
 
1633 
  def getAmazonOrdersCancelled(self, interval):
1634 
    """
1635 
    Parameters:
1636 
     - interval
1637 
    """
1638 
    pass
1639 
 
7322 vikram.rag 1640 
  def getAmazonOrder(self, orderId):
1641 
    """
1642 
    Parameters:
1643 
     - orderId
1644 
    """
1645 
    pass
7311 kshitij.so 1646 
 
7343 anupam.sin 1647 
  def getOrdersForStore(self, id, storeId, startDate, endDate, statuses):
1648 
    """
1649 
    Parameters:
1650 
     - id
1651 
     - storeId
1652 
     - startDate
1653 
     - endDate
1654 
     - statuses
1655 
    """
1656 
    pass
7322 vikram.rag 1657 
 
7343 anupam.sin 1658 
  def getStoreOrderAdvanceInvoice(self, orderId):
1659 
    """
1660 
    Parameters:
1661 
     - orderId
1662 
    """
1663 
    pass
1664 
 
1665 
 
3376 rajveer 1666 
class Client(shop2020.thriftpy.generic.GenericService.Client, Iface):
94 ashish 1667 
  def __init__(self, iprot, oprot=None):
3376 rajveer 1668 
    shop2020.thriftpy.generic.GenericService.Client.__init__(self, iprot, oprot)
94 ashish 1669 
 
1670 
  def createTransaction(self, transaction):
1671 
    """
1672 
    Parameters:
1673 
     - transaction
1674 
    """
1675 
    self.send_createTransaction(transaction)
132 ashish 1676 
    return self.recv_createTransaction()
94 ashish 1677 
 
1678 
  def send_createTransaction(self, transaction):
1679 
    self._oprot.writeMessageBegin('createTransaction', TMessageType.CALL, self._seqid)
1680 
    args = createTransaction_args()
1681 
    args.transaction = transaction
1682 
    args.write(self._oprot)
1683 
    self._oprot.writeMessageEnd()
1684 
    self._oprot.trans.flush()
1685 
 
1686 
  def recv_createTransaction(self, ):
1687 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1688 
    if mtype == TMessageType.EXCEPTION:
1689 
      x = TApplicationException()
1690 
      x.read(self._iprot)
1691 
      self._iprot.readMessageEnd()
1692 
      raise x
1693 
    result = createTransaction_result()
1694 
    result.read(self._iprot)
1695 
    self._iprot.readMessageEnd()
3431 rajveer 1696 
    if result.success is not None:
132 ashish 1697 
      return result.success
3431 rajveer 1698 
    if result.ex is not None:
94 ashish 1699 
      raise result.ex
132 ashish 1700 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createTransaction failed: unknown result");
94 ashish 1701 
 
1702 
  def getTransaction(self, id):
1703 
    """
1704 
    Parameters:
1705 
     - id
1706 
    """
1707 
    self.send_getTransaction(id)
1708 
    return self.recv_getTransaction()
1709 
 
1710 
  def send_getTransaction(self, id):
1711 
    self._oprot.writeMessageBegin('getTransaction', TMessageType.CALL, self._seqid)
1712 
    args = getTransaction_args()
1713 
    args.id = id
1714 
    args.write(self._oprot)
1715 
    self._oprot.writeMessageEnd()
1716 
    self._oprot.trans.flush()
1717 
 
1718 
  def recv_getTransaction(self, ):
1719 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1720 
    if mtype == TMessageType.EXCEPTION:
1721 
      x = TApplicationException()
1722 
      x.read(self._iprot)
1723 
      self._iprot.readMessageEnd()
1724 
      raise x
1725 
    result = getTransaction_result()
1726 
    result.read(self._iprot)
1727 
    self._iprot.readMessageEnd()
3431 rajveer 1728 
    if result.success is not None:
94 ashish 1729 
      return result.success
3431 rajveer 1730 
    if result.ex is not None:
94 ashish 1731 
      raise result.ex
1732 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransaction failed: unknown result");
1733 
 
1734 
  def getTransactionsForCustomer(self, customerId, from_date, to_date, status):
1735 
    """
1736 
    Parameters:
1737 
     - customerId
1738 
     - from_date
1739 
     - to_date
1740 
     - status
1741 
    """
1742 
    self.send_getTransactionsForCustomer(customerId, from_date, to_date, status)
1743 
    return self.recv_getTransactionsForCustomer()
1744 
 
1745 
  def send_getTransactionsForCustomer(self, customerId, from_date, to_date, status):
1746 
    self._oprot.writeMessageBegin('getTransactionsForCustomer', TMessageType.CALL, self._seqid)
1747 
    args = getTransactionsForCustomer_args()
1748 
    args.customerId = customerId
1749 
    args.from_date = from_date
1750 
    args.to_date = to_date
1751 
    args.status = status
1752 
    args.write(self._oprot)
1753 
    self._oprot.writeMessageEnd()
1754 
    self._oprot.trans.flush()
1755 
 
1756 
  def recv_getTransactionsForCustomer(self, ):
1757 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1758 
    if mtype == TMessageType.EXCEPTION:
1759 
      x = TApplicationException()
1760 
      x.read(self._iprot)
1761 
      self._iprot.readMessageEnd()
1762 
      raise x
1763 
    result = getTransactionsForCustomer_result()
1764 
    result.read(self._iprot)
1765 
    self._iprot.readMessageEnd()
3431 rajveer 1766 
    if result.success is not None:
94 ashish 1767 
      return result.success
3431 rajveer 1768 
    if result.ex is not None:
94 ashish 1769 
      raise result.ex
1770 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransactionsForCustomer failed: unknown result");
1771 
 
132 ashish 1772 
  def getTransactionsForShoppingCartId(self, shoppingCartId):
1773 
    """
1774 
    Parameters:
1775 
     - shoppingCartId
1776 
    """
1777 
    self.send_getTransactionsForShoppingCartId(shoppingCartId)
1778 
    return self.recv_getTransactionsForShoppingCartId()
1779 
 
1780 
  def send_getTransactionsForShoppingCartId(self, shoppingCartId):
1781 
    self._oprot.writeMessageBegin('getTransactionsForShoppingCartId', TMessageType.CALL, self._seqid)
1782 
    args = getTransactionsForShoppingCartId_args()
1783 
    args.shoppingCartId = shoppingCartId
1784 
    args.write(self._oprot)
1785 
    self._oprot.writeMessageEnd()
1786 
    self._oprot.trans.flush()
1787 
 
1788 
  def recv_getTransactionsForShoppingCartId(self, ):
1789 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1790 
    if mtype == TMessageType.EXCEPTION:
1791 
      x = TApplicationException()
1792 
      x.read(self._iprot)
1793 
      self._iprot.readMessageEnd()
1794 
      raise x
1795 
    result = getTransactionsForShoppingCartId_result()
1796 
    result.read(self._iprot)
1797 
    self._iprot.readMessageEnd()
3431 rajveer 1798 
    if result.success is not None:
132 ashish 1799 
      return result.success
3431 rajveer 1800 
    if result.ex is not None:
132 ashish 1801 
      raise result.ex
1802 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransactionsForShoppingCartId failed: unknown result");
1803 
 
94 ashish 1804 
  def getTransactionStatus(self, transactionId):
1805 
    """
1806 
    Parameters:
1807 
     - transactionId
1808 
    """
1809 
    self.send_getTransactionStatus(transactionId)
1810 
    return self.recv_getTransactionStatus()
1811 
 
1812 
  def send_getTransactionStatus(self, transactionId):
1813 
    self._oprot.writeMessageBegin('getTransactionStatus', TMessageType.CALL, self._seqid)
1814 
    args = getTransactionStatus_args()
1815 
    args.transactionId = transactionId
1816 
    args.write(self._oprot)
1817 
    self._oprot.writeMessageEnd()
1818 
    self._oprot.trans.flush()
1819 
 
1820 
  def recv_getTransactionStatus(self, ):
1821 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1822 
    if mtype == TMessageType.EXCEPTION:
1823 
      x = TApplicationException()
1824 
      x.read(self._iprot)
1825 
      self._iprot.readMessageEnd()
1826 
      raise x
1827 
    result = getTransactionStatus_result()
1828 
    result.read(self._iprot)
1829 
    self._iprot.readMessageEnd()
3431 rajveer 1830 
    if result.success is not None:
94 ashish 1831 
      return result.success
3431 rajveer 1832 
    if result.ex is not None:
94 ashish 1833 
      raise result.ex
1834 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransactionStatus failed: unknown result");
1835 
 
7293 anupam.sin 1836 
  def changeTransactionStatus(self, transactionId, status, description, pickUp, orderType, source):
94 ashish 1837 
    """
1838 
    Parameters:
1839 
     - transactionId
1840 
     - status
1841 
     - description
5527 anupam.sin 1842 
     - pickUp
1843 
     - orderType
7293 anupam.sin 1844 
     - source
94 ashish 1845 
    """
7293 anupam.sin 1846 
    self.send_changeTransactionStatus(transactionId, status, description, pickUp, orderType, source)
94 ashish 1847 
    return self.recv_changeTransactionStatus()
1848 
 
7293 anupam.sin 1849 
  def send_changeTransactionStatus(self, transactionId, status, description, pickUp, orderType, source):
94 ashish 1850 
    self._oprot.writeMessageBegin('changeTransactionStatus', TMessageType.CALL, self._seqid)
1851 
    args = changeTransactionStatus_args()
1852 
    args.transactionId = transactionId
1853 
    args.status = status
1854 
    args.description = description
5527 anupam.sin 1855 
    args.pickUp = pickUp
1856 
    args.orderType = orderType
7293 anupam.sin 1857 
    args.source = source
94 ashish 1858 
    args.write(self._oprot)
1859 
    self._oprot.writeMessageEnd()
1860 
    self._oprot.trans.flush()
1861 
 
1862 
  def recv_changeTransactionStatus(self, ):
1863 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1864 
    if mtype == TMessageType.EXCEPTION:
1865 
      x = TApplicationException()
1866 
      x.read(self._iprot)
1867 
      self._iprot.readMessageEnd()
1868 
      raise x
1869 
    result = changeTransactionStatus_result()
1870 
    result.read(self._iprot)
1871 
    self._iprot.readMessageEnd()
3431 rajveer 1872 
    if result.success is not None:
94 ashish 1873 
      return result.success
3431 rajveer 1874 
    if result.ex is not None:
94 ashish 1875 
      raise result.ex
1876 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "changeTransactionStatus failed: unknown result");
1877 
 
1398 varun.gupt 1878 
  def enqueueTransactionInfoEmail(self, transactionId):
1382 varun.gupt 1879 
    """
1880 
    Parameters:
1881 
     - transactionId
1882 
    """
1398 varun.gupt 1883 
    self.send_enqueueTransactionInfoEmail(transactionId)
1884 
    return self.recv_enqueueTransactionInfoEmail()
1382 varun.gupt 1885 
 
1398 varun.gupt 1886 
  def send_enqueueTransactionInfoEmail(self, transactionId):
1887 
    self._oprot.writeMessageBegin('enqueueTransactionInfoEmail', TMessageType.CALL, self._seqid)
1888 
    args = enqueueTransactionInfoEmail_args()
1382 varun.gupt 1889 
    args.transactionId = transactionId
1890 
    args.write(self._oprot)
1891 
    self._oprot.writeMessageEnd()
1892 
    self._oprot.trans.flush()
1893 
 
1398 varun.gupt 1894 
  def recv_enqueueTransactionInfoEmail(self, ):
1382 varun.gupt 1895 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1896 
    if mtype == TMessageType.EXCEPTION:
1897 
      x = TApplicationException()
1898 
      x.read(self._iprot)
1899 
      self._iprot.readMessageEnd()
1900 
      raise x
1398 varun.gupt 1901 
    result = enqueueTransactionInfoEmail_result()
1382 varun.gupt 1902 
    result.read(self._iprot)
1903 
    self._iprot.readMessageEnd()
3431 rajveer 1904 
    if result.success is not None:
1382 varun.gupt 1905 
      return result.success
3431 rajveer 1906 
    if result.ex is not None:
1382 varun.gupt 1907 
      raise result.ex
1398 varun.gupt 1908 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "enqueueTransactionInfoEmail failed: unknown result");
1382 varun.gupt 1909 
 
4801 anupam.sin 1910 
  def getAllOrders(self, statuses, from_date, to_date, warehouse_id):
94 ashish 1911 
    """
1912 
    Parameters:
4801 anupam.sin 1913 
     - statuses
483 rajveer 1914 
     - from_date
1915 
     - to_date
1916 
     - warehouse_id
94 ashish 1917 
    """
4801 anupam.sin 1918 
    self.send_getAllOrders(statuses, from_date, to_date, warehouse_id)
483 rajveer 1919 
    return self.recv_getAllOrders()
94 ashish 1920 
 
4801 anupam.sin 1921 
  def send_getAllOrders(self, statuses, from_date, to_date, warehouse_id):
483 rajveer 1922 
    self._oprot.writeMessageBegin('getAllOrders', TMessageType.CALL, self._seqid)
1923 
    args = getAllOrders_args()
4801 anupam.sin 1924 
    args.statuses = statuses
483 rajveer 1925 
    args.from_date = from_date
1926 
    args.to_date = to_date
1927 
    args.warehouse_id = warehouse_id
94 ashish 1928 
    args.write(self._oprot)
1929 
    self._oprot.writeMessageEnd()
1930 
    self._oprot.trans.flush()
1931 
 
483 rajveer 1932 
  def recv_getAllOrders(self, ):
94 ashish 1933 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1934 
    if mtype == TMessageType.EXCEPTION:
1935 
      x = TApplicationException()
1936 
      x.read(self._iprot)
1937 
      self._iprot.readMessageEnd()
1938 
      raise x
483 rajveer 1939 
    result = getAllOrders_result()
94 ashish 1940 
    result.read(self._iprot)
1941 
    self._iprot.readMessageEnd()
3431 rajveer 1942 
    if result.success is not None:
94 ashish 1943 
      return result.success
3431 rajveer 1944 
    if result.ex is not None:
94 ashish 1945 
      raise result.ex
483 rajveer 1946 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllOrders failed: unknown result");
94 ashish 1947 
 
4133 chandransh 1948 
  def getOrdersInBatch(self, statuses, offset, limit, warehouse_id):
1949 
    """
1950 
    Returns at most 'limit' orders with the given statuses for the given warehouse starting from the given offset.
1951 
    Pass the status as null and the limit as 0 to ignore them.
1952 
 
1953 
    Parameters:
1954 
     - statuses
1955 
     - offset
1956 
     - limit
1957 
     - warehouse_id
1958 
    """
1959 
    self.send_getOrdersInBatch(statuses, offset, limit, warehouse_id)
1960 
    return self.recv_getOrdersInBatch()
1961 
 
1962 
  def send_getOrdersInBatch(self, statuses, offset, limit, warehouse_id):
1963 
    self._oprot.writeMessageBegin('getOrdersInBatch', TMessageType.CALL, self._seqid)
1964 
    args = getOrdersInBatch_args()
1965 
    args.statuses = statuses
1966 
    args.offset = offset
1967 
    args.limit = limit
1968 
    args.warehouse_id = warehouse_id
1969 
    args.write(self._oprot)
1970 
    self._oprot.writeMessageEnd()
1971 
    self._oprot.trans.flush()
1972 
 
1973 
  def recv_getOrdersInBatch(self, ):
1974 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1975 
    if mtype == TMessageType.EXCEPTION:
1976 
      x = TApplicationException()
1977 
      x.read(self._iprot)
1978 
      self._iprot.readMessageEnd()
1979 
      raise x
1980 
    result = getOrdersInBatch_result()
1981 
    result.read(self._iprot)
1982 
    self._iprot.readMessageEnd()
1983 
    if result.success is not None:
1984 
      return result.success
1985 
    if result.ex is not None:
1986 
      raise result.ex
1987 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersInBatch failed: unknown result");
1988 
 
1989 
  def getOrderCount(self, statuses, warehouseId):
1990 
    """
1991 
    Returns the count of orders with the given statuses assigned to the given warehouse.
1992 
 
1993 
    Parameters:
1994 
     - statuses
1995 
     - warehouseId
1996 
    """
1997 
    self.send_getOrderCount(statuses, warehouseId)
1998 
    return self.recv_getOrderCount()
1999 
 
2000 
  def send_getOrderCount(self, statuses, warehouseId):
2001 
    self._oprot.writeMessageBegin('getOrderCount', TMessageType.CALL, self._seqid)
2002 
    args = getOrderCount_args()
2003 
    args.statuses = statuses
2004 
    args.warehouseId = warehouseId
2005 
    args.write(self._oprot)
2006 
    self._oprot.writeMessageEnd()
2007 
    self._oprot.trans.flush()
2008 
 
2009 
  def recv_getOrderCount(self, ):
2010 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2011 
    if mtype == TMessageType.EXCEPTION:
2012 
      x = TApplicationException()
2013 
      x.read(self._iprot)
2014 
      self._iprot.readMessageEnd()
2015 
      raise x
2016 
    result = getOrderCount_result()
2017 
    result.read(self._iprot)
2018 
    self._iprot.readMessageEnd()
2019 
    if result.success is not None:
2020 
      return result.success
2021 
    if result.ex is not None:
2022 
      raise result.ex
2023 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderCount failed: unknown result");
2024 
 
999 varun.gupt 2025 
  def getOrdersByBillingDate(self, status, start_billing_date, end_billing_date, warehouse_id):
2026 
    """
1132 chandransh 2027 
    Returns orders within a range of their billing dates
3431 rajveer 2028 
 
999 varun.gupt 2029 
    Parameters:
2030 
     - status
2031 
     - start_billing_date
2032 
     - end_billing_date
2033 
     - warehouse_id
2034 
    """
2035 
    self.send_getOrdersByBillingDate(status, start_billing_date, end_billing_date, warehouse_id)
2036 
    return self.recv_getOrdersByBillingDate()
2037 
 
2038 
  def send_getOrdersByBillingDate(self, status, start_billing_date, end_billing_date, warehouse_id):
2039 
    self._oprot.writeMessageBegin('getOrdersByBillingDate', TMessageType.CALL, self._seqid)
2040 
    args = getOrdersByBillingDate_args()
2041 
    args.status = status
2042 
    args.start_billing_date = start_billing_date
2043 
    args.end_billing_date = end_billing_date
2044 
    args.warehouse_id = warehouse_id
2045 
    args.write(self._oprot)
2046 
    self._oprot.writeMessageEnd()
2047 
    self._oprot.trans.flush()
2048 
 
2049 
  def recv_getOrdersByBillingDate(self, ):
2050 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2051 
    if mtype == TMessageType.EXCEPTION:
2052 
      x = TApplicationException()
2053 
      x.read(self._iprot)
2054 
      self._iprot.readMessageEnd()
2055 
      raise x
2056 
    result = getOrdersByBillingDate_result()
2057 
    result.read(self._iprot)
2058 
    self._iprot.readMessageEnd()
3431 rajveer 2059 
    if result.success is not None:
999 varun.gupt 2060 
      return result.success
3431 rajveer 2061 
    if result.ex is not None:
999 varun.gupt 2062 
      raise result.ex
2063 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersByBillingDate failed: unknown result");
2064 
 
3451 chandransh 2065 
  def getOrdersByShippingDate(self, fromShippingDate, toShippingDate, providerId, warehouseId, cod):
3427 chandransh 2066 
    """
2067 
    Returns orders for a particular provider and warehouse which were shipped between the given dates.
3451 chandransh 2068 
    Returned orders comprise of COD orders if cod parameter is true. It comprises of prepaid orders otherwise.
2069 
    Pass providerId and warehouseId as -1 to ignore both these parameters.
3431 rajveer 2070 
 
3427 chandransh 2071 
    Parameters:
2072 
     - fromShippingDate
2073 
     - toShippingDate
2074 
     - providerId
2075 
     - warehouseId
3451 chandransh 2076 
     - cod
3427 chandransh 2077 
    """
3451 chandransh 2078 
    self.send_getOrdersByShippingDate(fromShippingDate, toShippingDate, providerId, warehouseId, cod)
3427 chandransh 2079 
    return self.recv_getOrdersByShippingDate()
2080 
 
3451 chandransh 2081 
  def send_getOrdersByShippingDate(self, fromShippingDate, toShippingDate, providerId, warehouseId, cod):
3427 chandransh 2082 
    self._oprot.writeMessageBegin('getOrdersByShippingDate', TMessageType.CALL, self._seqid)
2083 
    args = getOrdersByShippingDate_args()
2084 
    args.fromShippingDate = fromShippingDate
2085 
    args.toShippingDate = toShippingDate
2086 
    args.providerId = providerId
2087 
    args.warehouseId = warehouseId
3451 chandransh 2088 
    args.cod = cod
3427 chandransh 2089 
    args.write(self._oprot)
2090 
    self._oprot.writeMessageEnd()
2091 
    self._oprot.trans.flush()
2092 
 
2093 
  def recv_getOrdersByShippingDate(self, ):
2094 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2095 
    if mtype == TMessageType.EXCEPTION:
2096 
      x = TApplicationException()
2097 
      x.read(self._iprot)
2098 
      self._iprot.readMessageEnd()
2099 
      raise x
2100 
    result = getOrdersByShippingDate_result()
2101 
    result.read(self._iprot)
2102 
    self._iprot.readMessageEnd()
3431 rajveer 2103 
    if result.success is not None:
3427 chandransh 2104 
      return result.success
3431 rajveer 2105 
    if result.ex is not None:
3427 chandransh 2106 
      raise result.ex
2107 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersByShippingDate failed: unknown result");
2108 
 
1382 varun.gupt 2109 
  def getReturnableOrdersForCustomer(self, customer_id, limit):
2110 
    """
2111 
    Returns order ids for orders which can be returned
3431 rajveer 2112 
 
1382 varun.gupt 2113 
    Parameters:
2114 
     - customer_id
2115 
     - limit
2116 
    """
2117 
    self.send_getReturnableOrdersForCustomer(customer_id, limit)
2118 
    return self.recv_getReturnableOrdersForCustomer()
2119 
 
2120 
  def send_getReturnableOrdersForCustomer(self, customer_id, limit):
2121 
    self._oprot.writeMessageBegin('getReturnableOrdersForCustomer', TMessageType.CALL, self._seqid)
2122 
    args = getReturnableOrdersForCustomer_args()
2123 
    args.customer_id = customer_id
2124 
    args.limit = limit
2125 
    args.write(self._oprot)
2126 
    self._oprot.writeMessageEnd()
2127 
    self._oprot.trans.flush()
2128 
 
2129 
  def recv_getReturnableOrdersForCustomer(self, ):
2130 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2131 
    if mtype == TMessageType.EXCEPTION:
2132 
      x = TApplicationException()
2133 
      x.read(self._iprot)
2134 
      self._iprot.readMessageEnd()
2135 
      raise x
2136 
    result = getReturnableOrdersForCustomer_result()
2137 
    result.read(self._iprot)
2138 
    self._iprot.readMessageEnd()
3431 rajveer 2139 
    if result.success is not None:
1382 varun.gupt 2140 
      return result.success
3431 rajveer 2141 
    if result.ex is not None:
1382 varun.gupt 2142 
      raise result.ex
2143 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReturnableOrdersForCustomer failed: unknown result");
2144 
 
2145 
  def getCancellableOrdersForCustomer(self, customer_id, limit):
2146 
    """
2147 
    Returns order ids for orders which can be cancelled
3431 rajveer 2148 
 
1382 varun.gupt 2149 
    Parameters:
2150 
     - customer_id
2151 
     - limit
2152 
    """
2153 
    self.send_getCancellableOrdersForCustomer(customer_id, limit)
2154 
    return self.recv_getCancellableOrdersForCustomer()
2155 
 
2156 
  def send_getCancellableOrdersForCustomer(self, customer_id, limit):
2157 
    self._oprot.writeMessageBegin('getCancellableOrdersForCustomer', TMessageType.CALL, self._seqid)
2158 
    args = getCancellableOrdersForCustomer_args()
2159 
    args.customer_id = customer_id
2160 
    args.limit = limit
2161 
    args.write(self._oprot)
2162 
    self._oprot.writeMessageEnd()
2163 
    self._oprot.trans.flush()
2164 
 
2165 
  def recv_getCancellableOrdersForCustomer(self, ):
2166 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2167 
    if mtype == TMessageType.EXCEPTION:
2168 
      x = TApplicationException()
2169 
      x.read(self._iprot)
2170 
      self._iprot.readMessageEnd()
2171 
      raise x
2172 
    result = getCancellableOrdersForCustomer_result()
2173 
    result.read(self._iprot)
2174 
    self._iprot.readMessageEnd()
3431 rajveer 2175 
    if result.success is not None:
1382 varun.gupt 2176 
      return result.success
3431 rajveer 2177 
    if result.ex is not None:
1382 varun.gupt 2178 
      raise result.ex
2179 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCancellableOrdersForCustomer failed: unknown result");
2180 
 
483 rajveer 2181 
  def changeOrderStatus(self, orderId, status, description):
94 ashish 2182 
    """
2183 
    Parameters:
483 rajveer 2184 
     - orderId
2185 
     - status
2186 
     - description
94 ashish 2187 
    """
483 rajveer 2188 
    self.send_changeOrderStatus(orderId, status, description)
2189 
    return self.recv_changeOrderStatus()
94 ashish 2190 
 
483 rajveer 2191 
  def send_changeOrderStatus(self, orderId, status, description):
2192 
    self._oprot.writeMessageBegin('changeOrderStatus', TMessageType.CALL, self._seqid)
2193 
    args = changeOrderStatus_args()
2194 
    args.orderId = orderId
2195 
    args.status = status
2196 
    args.description = description
94 ashish 2197 
    args.write(self._oprot)
2198 
    self._oprot.writeMessageEnd()
2199 
    self._oprot.trans.flush()
2200 
 
483 rajveer 2201 
  def recv_changeOrderStatus(self, ):
94 ashish 2202 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2203 
    if mtype == TMessageType.EXCEPTION:
2204 
      x = TApplicationException()
2205 
      x.read(self._iprot)
2206 
      self._iprot.readMessageEnd()
2207 
      raise x
483 rajveer 2208 
    result = changeOrderStatus_result()
94 ashish 2209 
    result.read(self._iprot)
2210 
    self._iprot.readMessageEnd()
3431 rajveer 2211 
    if result.success is not None:
94 ashish 2212 
      return result.success
3431 rajveer 2213 
    if result.ex is not None:
94 ashish 2214 
      raise result.ex
483 rajveer 2215 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "changeOrderStatus failed: unknown result");
94 ashish 2216 
 
1528 ankur.sing 2217 
  def getOrdersForTransaction(self, transactionId, customerId):
94 ashish 2218 
    """
1528 ankur.sing 2219 
    Returns list of orders for given transaction Id. Also filters based on customer Id so that
2220 
    only user who owns the transaction can view its order details.
3431 rajveer 2221 
 
94 ashish 2222 
    Parameters:
2223 
     - transactionId
1528 ankur.sing 2224 
     - customerId
94 ashish 2225 
    """
1528 ankur.sing 2226 
    self.send_getOrdersForTransaction(transactionId, customerId)
483 rajveer 2227 
    return self.recv_getOrdersForTransaction()
94 ashish 2228 
 
1528 ankur.sing 2229 
  def send_getOrdersForTransaction(self, transactionId, customerId):
483 rajveer 2230 
    self._oprot.writeMessageBegin('getOrdersForTransaction', TMessageType.CALL, self._seqid)
2231 
    args = getOrdersForTransaction_args()
94 ashish 2232 
    args.transactionId = transactionId
1528 ankur.sing 2233 
    args.customerId = customerId
94 ashish 2234 
    args.write(self._oprot)
2235 
    self._oprot.writeMessageEnd()
2236 
    self._oprot.trans.flush()
2237 
 
483 rajveer 2238 
  def recv_getOrdersForTransaction(self, ):
94 ashish 2239 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2240 
    if mtype == TMessageType.EXCEPTION:
2241 
      x = TApplicationException()
2242 
      x.read(self._iprot)
2243 
      self._iprot.readMessageEnd()
2244 
      raise x
483 rajveer 2245 
    result = getOrdersForTransaction_result()
94 ashish 2246 
    result.read(self._iprot)
2247 
    self._iprot.readMessageEnd()
3431 rajveer 2248 
    if result.success is not None:
94 ashish 2249 
      return result.success
3431 rajveer 2250 
    if result.ex is not None:
94 ashish 2251 
      raise result.ex
483 rajveer 2252 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersForTransaction failed: unknown result");
94 ashish 2253 
 
3014 chandransh 2254 
  def getOrdersForCustomer(self, customerId, from_date, to_date, statuses):
94 ashish 2255 
    """
3014 chandransh 2256 
    Returns list of orders for the given customer created between the given dates and having the given statuses.
2257 
    Pass and empty list to ignore filtering on statuses.
3431 rajveer 2258 
 
94 ashish 2259 
    Parameters:
483 rajveer 2260 
     - customerId
2261 
     - from_date
2262 
     - to_date
3014 chandransh 2263 
     - statuses
94 ashish 2264 
    """
3014 chandransh 2265 
    self.send_getOrdersForCustomer(customerId, from_date, to_date, statuses)
483 rajveer 2266 
    return self.recv_getOrdersForCustomer()
94 ashish 2267 
 
3014 chandransh 2268 
  def send_getOrdersForCustomer(self, customerId, from_date, to_date, statuses):
483 rajveer 2269 
    self._oprot.writeMessageBegin('getOrdersForCustomer', TMessageType.CALL, self._seqid)
2270 
    args = getOrdersForCustomer_args()
2271 
    args.customerId = customerId
2272 
    args.from_date = from_date
2273 
    args.to_date = to_date
3014 chandransh 2274 
    args.statuses = statuses
94 ashish 2275 
    args.write(self._oprot)
2276 
    self._oprot.writeMessageEnd()
2277 
    self._oprot.trans.flush()
2278 
 
483 rajveer 2279 
  def recv_getOrdersForCustomer(self, ):
94 ashish 2280 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2281 
    if mtype == TMessageType.EXCEPTION:
2282 
      x = TApplicationException()
2283 
      x.read(self._iprot)
2284 
      self._iprot.readMessageEnd()
2285 
      raise x
483 rajveer 2286 
    result = getOrdersForCustomer_result()
94 ashish 2287 
    result.read(self._iprot)
2288 
    self._iprot.readMessageEnd()
3431 rajveer 2289 
    if result.success is not None:
94 ashish 2290 
      return result.success
3431 rajveer 2291 
    if result.ex is not None:
94 ashish 2292 
      raise result.ex
483 rajveer 2293 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersForCustomer failed: unknown result");
94 ashish 2294 
 
483 rajveer 2295 
  def createOrder(self, order):
94 ashish 2296 
    """
2297 
    Parameters:
483 rajveer 2298 
     - order
94 ashish 2299 
    """
483 rajveer 2300 
    self.send_createOrder(order)
2301 
    return self.recv_createOrder()
94 ashish 2302 
 
483 rajveer 2303 
  def send_createOrder(self, order):
2304 
    self._oprot.writeMessageBegin('createOrder', TMessageType.CALL, self._seqid)
2305 
    args = createOrder_args()
2306 
    args.order = order
94 ashish 2307 
    args.write(self._oprot)
2308 
    self._oprot.writeMessageEnd()
2309 
    self._oprot.trans.flush()
2310 
 
483 rajveer 2311 
  def recv_createOrder(self, ):
94 ashish 2312 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2313 
    if mtype == TMessageType.EXCEPTION:
2314 
      x = TApplicationException()
2315 
      x.read(self._iprot)
2316 
      self._iprot.readMessageEnd()
2317 
      raise x
483 rajveer 2318 
    result = createOrder_result()
94 ashish 2319 
    result.read(self._iprot)
2320 
    self._iprot.readMessageEnd()
3431 rajveer 2321 
    if result.success is not None:
94 ashish 2322 
      return result.success
3431 rajveer 2323 
    if result.ex is not None:
94 ashish 2324 
      raise result.ex
483 rajveer 2325 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createOrder failed: unknown result");
94 ashish 2326 
 
483 rajveer 2327 
  def getOrder(self, id):
94 ashish 2328 
    """
2329 
    Parameters:
483 rajveer 2330 
     - id
94 ashish 2331 
    """
483 rajveer 2332 
    self.send_getOrder(id)
2333 
    return self.recv_getOrder()
94 ashish 2334 
 
483 rajveer 2335 
  def send_getOrder(self, id):
2336 
    self._oprot.writeMessageBegin('getOrder', TMessageType.CALL, self._seqid)
2337 
    args = getOrder_args()
2338 
    args.id = id
94 ashish 2339 
    args.write(self._oprot)
2340 
    self._oprot.writeMessageEnd()
2341 
    self._oprot.trans.flush()
2342 
 
483 rajveer 2343 
  def recv_getOrder(self, ):
94 ashish 2344 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2345 
    if mtype == TMessageType.EXCEPTION:
2346 
      x = TApplicationException()
2347 
      x.read(self._iprot)
2348 
      self._iprot.readMessageEnd()
2349 
      raise x
483 rajveer 2350 
    result = getOrder_result()
94 ashish 2351 
    result.read(self._iprot)
2352 
    self._iprot.readMessageEnd()
3431 rajveer 2353 
    if result.success is not None:
94 ashish 2354 
      return result.success
3431 rajveer 2355 
    if result.ex is not None:
94 ashish 2356 
      raise result.ex
483 rajveer 2357 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrder failed: unknown result");
94 ashish 2358 
 
483 rajveer 2359 
  def getLineItemsForOrder(self, orderId):
94 ashish 2360 
    """
2361 
    Parameters:
483 rajveer 2362 
     - orderId
94 ashish 2363 
    """
483 rajveer 2364 
    self.send_getLineItemsForOrder(orderId)
2365 
    return self.recv_getLineItemsForOrder()
94 ashish 2366 
 
483 rajveer 2367 
  def send_getLineItemsForOrder(self, orderId):
2368 
    self._oprot.writeMessageBegin('getLineItemsForOrder', TMessageType.CALL, self._seqid)
2369 
    args = getLineItemsForOrder_args()
2370 
    args.orderId = orderId
94 ashish 2371 
    args.write(self._oprot)
2372 
    self._oprot.writeMessageEnd()
2373 
    self._oprot.trans.flush()
2374 
 
483 rajveer 2375 
  def recv_getLineItemsForOrder(self, ):
94 ashish 2376 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2377 
    if mtype == TMessageType.EXCEPTION:
2378 
      x = TApplicationException()
2379 
      x.read(self._iprot)
2380 
      self._iprot.readMessageEnd()
2381 
      raise x
483 rajveer 2382 
    result = getLineItemsForOrder_result()
94 ashish 2383 
    result.read(self._iprot)
2384 
    self._iprot.readMessageEnd()
3431 rajveer 2385 
    if result.success is not None:
94 ashish 2386 
      return result.success
3431 rajveer 2387 
    if result.ex is not None:
94 ashish 2388 
      raise result.ex
483 rajveer 2389 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getLineItemsForOrder failed: unknown result");
94 ashish 2390 
 
4999 phani.kuma 2391 
  def getOrderList(self, order_ids):
2392 
    """
2393 
    Parameters:
2394 
     - order_ids
2395 
    """
2396 
    self.send_getOrderList(order_ids)
2397 
    return self.recv_getOrderList()
2398 
 
2399 
  def send_getOrderList(self, order_ids):
2400 
    self._oprot.writeMessageBegin('getOrderList', TMessageType.CALL, self._seqid)
2401 
    args = getOrderList_args()
2402 
    args.order_ids = order_ids
2403 
    args.write(self._oprot)
2404 
    self._oprot.writeMessageEnd()
2405 
    self._oprot.trans.flush()
2406 
 
2407 
  def recv_getOrderList(self, ):
2408 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2409 
    if mtype == TMessageType.EXCEPTION:
2410 
      x = TApplicationException()
2411 
      x.read(self._iprot)
2412 
      self._iprot.readMessageEnd()
2413 
      raise x
2414 
    result = getOrderList_result()
2415 
    result.read(self._iprot)
2416 
    self._iprot.readMessageEnd()
2417 
    if result.success is not None:
2418 
      return result.success
2419 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderList failed: unknown result");
2420 
 
5386 phani.kuma 2421 
  def getOrderListForVendor(self, order_ids, vendorId):
2422 
    """
2423 
    Parameters:
2424 
     - order_ids
2425 
     - vendorId
2426 
    """
2427 
    self.send_getOrderListForVendor(order_ids, vendorId)
2428 
    return self.recv_getOrderListForVendor()
2429 
 
2430 
  def send_getOrderListForVendor(self, order_ids, vendorId):
2431 
    self._oprot.writeMessageBegin('getOrderListForVendor', TMessageType.CALL, self._seqid)
2432 
    args = getOrderListForVendor_args()
2433 
    args.order_ids = order_ids
2434 
    args.vendorId = vendorId
2435 
    args.write(self._oprot)
2436 
    self._oprot.writeMessageEnd()
2437 
    self._oprot.trans.flush()
2438 
 
2439 
  def recv_getOrderListForVendor(self, ):
2440 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2441 
    if mtype == TMessageType.EXCEPTION:
2442 
      x = TApplicationException()
2443 
      x.read(self._iprot)
2444 
      self._iprot.readMessageEnd()
2445 
      raise x
2446 
    result = getOrderListForVendor_result()
2447 
    result.read(self._iprot)
2448 
    self._iprot.readMessageEnd()
2449 
    if result.success is not None:
2450 
      return result.success
2451 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderListForVendor failed: unknown result");
2452 
 
1528 ankur.sing 2453 
  def getOrderForCustomer(self, orderId, customerId):
2454 
    """
2455 
    Returns an order for the order Id. Also checks if the order belongs to the customer whose Id is passed.
2456 
    Throws exception if either order Id is invalid or order does not below to the customer whose Id is passed.
3431 rajveer 2457 
 
1528 ankur.sing 2458 
    Parameters:
2459 
     - orderId
2460 
     - customerId
2461 
    """
2462 
    self.send_getOrderForCustomer(orderId, customerId)
2463 
    return self.recv_getOrderForCustomer()
2464 
 
2465 
  def send_getOrderForCustomer(self, orderId, customerId):
2466 
    self._oprot.writeMessageBegin('getOrderForCustomer', TMessageType.CALL, self._seqid)
2467 
    args = getOrderForCustomer_args()
2468 
    args.orderId = orderId
2469 
    args.customerId = customerId
2470 
    args.write(self._oprot)
2471 
    self._oprot.writeMessageEnd()
2472 
    self._oprot.trans.flush()
2473 
 
2474 
  def recv_getOrderForCustomer(self, ):
2475 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2476 
    if mtype == TMessageType.EXCEPTION:
2477 
      x = TApplicationException()
2478 
      x.read(self._iprot)
2479 
      self._iprot.readMessageEnd()
2480 
      raise x
2481 
    result = getOrderForCustomer_result()
2482 
    result.read(self._iprot)
2483 
    self._iprot.readMessageEnd()
3431 rajveer 2484 
    if result.success is not None:
1528 ankur.sing 2485 
      return result.success
3431 rajveer 2486 
    if result.ex is not None:
1528 ankur.sing 2487 
      raise result.ex
2488 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderForCustomer failed: unknown result");
2489 
 
4444 rajveer 2490 
  def getAlerts(self, type, warehouseId, status, timestamp):
3064 chandransh 2491 
    """
2492 
    Parameters:
4394 rajveer 2493 
     - type
4444 rajveer 2494 
     - warehouseId
4394 rajveer 2495 
     - status
2496 
     - timestamp
3064 chandransh 2497 
    """
4444 rajveer 2498 
    self.send_getAlerts(type, warehouseId, status, timestamp)
3064 chandransh 2499 
    return self.recv_getAlerts()
2500 
 
4444 rajveer 2501 
  def send_getAlerts(self, type, warehouseId, status, timestamp):
3064 chandransh 2502 
    self._oprot.writeMessageBegin('getAlerts', TMessageType.CALL, self._seqid)
2503 
    args = getAlerts_args()
4394 rajveer 2504 
    args.type = type
4444 rajveer 2505 
    args.warehouseId = warehouseId
4394 rajveer 2506 
    args.status = status
2507 
    args.timestamp = timestamp
3064 chandransh 2508 
    args.write(self._oprot)
2509 
    self._oprot.writeMessageEnd()
2510 
    self._oprot.trans.flush()
2511 
 
2512 
  def recv_getAlerts(self, ):
2513 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2514 
    if mtype == TMessageType.EXCEPTION:
2515 
      x = TApplicationException()
2516 
      x.read(self._iprot)
2517 
      self._iprot.readMessageEnd()
2518 
      raise x
2519 
    result = getAlerts_result()
2520 
    result.read(self._iprot)
2521 
    self._iprot.readMessageEnd()
3431 rajveer 2522 
    if result.success is not None:
3064 chandransh 2523 
      return result.success
2524 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAlerts failed: unknown result");
2525 
 
4444 rajveer 2526 
  def addAlert(self, type, warehouseId, description):
3064 chandransh 2527 
    """
2528 
    Parameters:
2529 
     - type
4444 rajveer 2530 
     - warehouseId
4394 rajveer 2531 
     - description
3064 chandransh 2532 
    """
4444 rajveer 2533 
    self.send_addAlert(type, warehouseId, description)
4394 rajveer 2534 
    self.recv_addAlert()
3064 chandransh 2535 
 
4444 rajveer 2536 
  def send_addAlert(self, type, warehouseId, description):
4394 rajveer 2537 
    self._oprot.writeMessageBegin('addAlert', TMessageType.CALL, self._seqid)
2538 
    args = addAlert_args()
3064 chandransh 2539 
    args.type = type
4444 rajveer 2540 
    args.warehouseId = warehouseId
4394 rajveer 2541 
    args.description = description
3064 chandransh 2542 
    args.write(self._oprot)
2543 
    self._oprot.writeMessageEnd()
2544 
    self._oprot.trans.flush()
2545 
 
4394 rajveer 2546 
  def recv_addAlert(self, ):
3064 chandransh 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
4394 rajveer 2553 
    result = addAlert_result()
3064 chandransh 2554 
    result.read(self._iprot)
2555 
    self._iprot.readMessageEnd()
2556 
    return
2557 
 
4444 rajveer 2558 
  def markAlertsAsSeen(self, warehouseId):
2559 
    """
2560 
    Parameters:
2561 
     - warehouseId
2562 
    """
2563 
    self.send_markAlertsAsSeen(warehouseId)
2564 
    self.recv_markAlertsAsSeen()
2565 
 
2566 
  def send_markAlertsAsSeen(self, warehouseId):
2567 
    self._oprot.writeMessageBegin('markAlertsAsSeen', TMessageType.CALL, self._seqid)
2568 
    args = markAlertsAsSeen_args()
2569 
    args.warehouseId = warehouseId
2570 
    args.write(self._oprot)
2571 
    self._oprot.writeMessageEnd()
2572 
    self._oprot.trans.flush()
2573 
 
2574 
  def recv_markAlertsAsSeen(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 = markAlertsAsSeen_result()
2582 
    result.read(self._iprot)
2583 
    self._iprot.readMessageEnd()
2584 
    return
2585 
 
3064 chandransh 2586 
  def getValidOrderCount(self, ):
2587 
    """
2588 
    Return the number of valid orders. (OrderStatus >= OrderStatus.SUBMITTED_FOR_PROCESSING)
2589 
    """
2590 
    self.send_getValidOrderCount()
2591 
    return self.recv_getValidOrderCount()
2592 
 
2593 
  def send_getValidOrderCount(self, ):
2594 
    self._oprot.writeMessageBegin('getValidOrderCount', TMessageType.CALL, self._seqid)
2595 
    args = getValidOrderCount_args()
2596 
    args.write(self._oprot)
2597 
    self._oprot.writeMessageEnd()
2598 
    self._oprot.trans.flush()
2599 
 
2600 
  def recv_getValidOrderCount(self, ):
2601 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2602 
    if mtype == TMessageType.EXCEPTION:
2603 
      x = TApplicationException()
2604 
      x.read(self._iprot)
2605 
      self._iprot.readMessageEnd()
2606 
      raise x
2607 
    result = getValidOrderCount_result()
2608 
    result.read(self._iprot)
2609 
    self._iprot.readMessageEnd()
3431 rajveer 2610 
    if result.success is not None:
3064 chandransh 2611 
      return result.success
2612 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getValidOrderCount failed: unknown result");
2613 
 
2614 
  def getNoOfCustomersWithSuccessfulTransaction(self, ):
2615 
    """
2616 
    Returns the number of distinct customers who have done successful transactions
2617 
    """
2618 
    self.send_getNoOfCustomersWithSuccessfulTransaction()
2619 
    return self.recv_getNoOfCustomersWithSuccessfulTransaction()
2620 
 
2621 
  def send_getNoOfCustomersWithSuccessfulTransaction(self, ):
2622 
    self._oprot.writeMessageBegin('getNoOfCustomersWithSuccessfulTransaction', TMessageType.CALL, self._seqid)
2623 
    args = getNoOfCustomersWithSuccessfulTransaction_args()
2624 
    args.write(self._oprot)
2625 
    self._oprot.writeMessageEnd()
2626 
    self._oprot.trans.flush()
2627 
 
2628 
  def recv_getNoOfCustomersWithSuccessfulTransaction(self, ):
2629 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2630 
    if mtype == TMessageType.EXCEPTION:
2631 
      x = TApplicationException()
2632 
      x.read(self._iprot)
2633 
      self._iprot.readMessageEnd()
2634 
      raise x
2635 
    result = getNoOfCustomersWithSuccessfulTransaction_result()
2636 
    result.read(self._iprot)
2637 
    self._iprot.readMessageEnd()
3431 rajveer 2638 
    if result.success is not None:
3064 chandransh 2639 
      return result.success
2640 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getNoOfCustomersWithSuccessfulTransaction failed: unknown result");
2641 
 
2642 
  def getValidOrdersAmountRange(self, ):
2643 
    """
2644 
    Returns the minimum and maximum amounts of a valid order. (OrderStatus >= OrderStatus.SUBMITTED_FOR_PROCESSING)
2645 
    List contains two values, first minimum amount and second maximum amount.
2646 
    """
2647 
    self.send_getValidOrdersAmountRange()
2648 
    return self.recv_getValidOrdersAmountRange()
2649 
 
2650 
  def send_getValidOrdersAmountRange(self, ):
2651 
    self._oprot.writeMessageBegin('getValidOrdersAmountRange', TMessageType.CALL, self._seqid)
2652 
    args = getValidOrdersAmountRange_args()
2653 
    args.write(self._oprot)
2654 
    self._oprot.writeMessageEnd()
2655 
    self._oprot.trans.flush()
2656 
 
2657 
  def recv_getValidOrdersAmountRange(self, ):
2658 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2659 
    if mtype == TMessageType.EXCEPTION:
2660 
      x = TApplicationException()
2661 
      x.read(self._iprot)
2662 
      self._iprot.readMessageEnd()
2663 
      raise x
2664 
    result = getValidOrdersAmountRange_result()
2665 
    result.read(self._iprot)
2666 
    self._iprot.readMessageEnd()
3431 rajveer 2667 
    if result.success is not None:
3064 chandransh 2668 
      return result.success
2669 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getValidOrdersAmountRange failed: unknown result");
2670 
 
5874 rajveer 2671 
  def getValidOrders(self, limit, onlyStore):
3064 chandransh 2672 
    """
2673 
    Returns list of Orders in descending order by Order creation date. List is restricted to limit Orders.
2674 
    If limit is passed as 0, then all valid Orders are returned.
3431 rajveer 2675 
 
3064 chandransh 2676 
    Parameters:
2677 
     - limit
5874 rajveer 2678 
     - onlyStore
3064 chandransh 2679 
    """
5874 rajveer 2680 
    self.send_getValidOrders(limit, onlyStore)
3064 chandransh 2681 
    return self.recv_getValidOrders()
2682 
 
5874 rajveer 2683 
  def send_getValidOrders(self, limit, onlyStore):
3064 chandransh 2684 
    self._oprot.writeMessageBegin('getValidOrders', TMessageType.CALL, self._seqid)
2685 
    args = getValidOrders_args()
2686 
    args.limit = limit
5874 rajveer 2687 
    args.onlyStore = onlyStore
3064 chandransh 2688 
    args.write(self._oprot)
2689 
    self._oprot.writeMessageEnd()
2690 
    self._oprot.trans.flush()
2691 
 
2692 
  def recv_getValidOrders(self, ):
2693 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2694 
    if mtype == TMessageType.EXCEPTION:
2695 
      x = TApplicationException()
2696 
      x.read(self._iprot)
2697 
      self._iprot.readMessageEnd()
2698 
      raise x
2699 
    result = getValidOrders_result()
2700 
    result.read(self._iprot)
2701 
    self._iprot.readMessageEnd()
3431 rajveer 2702 
    if result.success is not None:
3064 chandransh 2703 
      return result.success
2704 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getValidOrders failed: unknown result");
2705 
 
1220 chandransh 2706 
  def batchOrders(self, warehouseId):
2707 
    """
2708 
    Create a batch of all the pending orders for the given warehouse.
2709 
    The returned list is orderd by created_timestamp.
2710 
    If there are no pending orders, an empty list is returned.
3431 rajveer 2711 
 
1220 chandransh 2712 
    Parameters:
2713 
     - warehouseId
2714 
    """
2715 
    self.send_batchOrders(warehouseId)
2716 
    return self.recv_batchOrders()
2717 
 
2718 
  def send_batchOrders(self, warehouseId):
2719 
    self._oprot.writeMessageBegin('batchOrders', TMessageType.CALL, self._seqid)
2720 
    args = batchOrders_args()
2721 
    args.warehouseId = warehouseId
2722 
    args.write(self._oprot)
2723 
    self._oprot.writeMessageEnd()
2724 
    self._oprot.trans.flush()
2725 
 
2726 
  def recv_batchOrders(self, ):
2727 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2728 
    if mtype == TMessageType.EXCEPTION:
2729 
      x = TApplicationException()
2730 
      x.read(self._iprot)
2731 
      self._iprot.readMessageEnd()
2732 
      raise x
2733 
    result = batchOrders_result()
2734 
    result.read(self._iprot)
2735 
    self._iprot.readMessageEnd()
3431 rajveer 2736 
    if result.success is not None:
1220 chandransh 2737 
      return result.success
3431 rajveer 2738 
    if result.ex is not None:
1220 chandransh 2739 
      raise result.ex
2740 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "batchOrders failed: unknown result");
2741 
 
1208 chandransh 2742 
  def markOrderAsOutOfStock(self, orderId):
2743 
    """
2744 
    Mark the given order as out of stock. Throws an exception if the order with the given Id couldn't be found.
3431 rajveer 2745 
 
1208 chandransh 2746 
    Parameters:
2747 
     - orderId
2748 
    """
2749 
    self.send_markOrderAsOutOfStock(orderId)
2750 
    return self.recv_markOrderAsOutOfStock()
2751 
 
2752 
  def send_markOrderAsOutOfStock(self, orderId):
2753 
    self._oprot.writeMessageBegin('markOrderAsOutOfStock', TMessageType.CALL, self._seqid)
2754 
    args = markOrderAsOutOfStock_args()
2755 
    args.orderId = orderId
2756 
    args.write(self._oprot)
2757 
    self._oprot.writeMessageEnd()
2758 
    self._oprot.trans.flush()
2759 
 
2760 
  def recv_markOrderAsOutOfStock(self, ):
2761 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2762 
    if mtype == TMessageType.EXCEPTION:
2763 
      x = TApplicationException()
2764 
      x.read(self._iprot)
2765 
      self._iprot.readMessageEnd()
2766 
      raise x
2767 
    result = markOrderAsOutOfStock_result()
2768 
    result.read(self._iprot)
2769 
    self._iprot.readMessageEnd()
3431 rajveer 2770 
    if result.success is not None:
1208 chandransh 2771 
      return result.success
3431 rajveer 2772 
    if result.ex is not None:
1208 chandransh 2773 
      raise result.ex
2774 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderAsOutOfStock failed: unknown result");
2775 
 
3064 chandransh 2776 
  def verifyOrder(self, orderId):
759 chandransh 2777 
    """
3064 chandransh 2778 
    Marks the given order as SUBMITTED_FOR_PROCESSING and updates the verified
2779 
    timestamp. It is intended to be used for COD orders but can be harmlessly
2780 
    used for all other orders as well.
2781 
    Throws an exception if no such order exists.
3431 rajveer 2782 
 
759 chandransh 2783 
    Parameters:
3064 chandransh 2784 
     - orderId
759 chandransh 2785 
    """
3064 chandransh 2786 
    self.send_verifyOrder(orderId)
2787 
    return self.recv_verifyOrder()
759 chandransh 2788 
 
3064 chandransh 2789 
  def send_verifyOrder(self, orderId):
2790 
    self._oprot.writeMessageBegin('verifyOrder', TMessageType.CALL, self._seqid)
2791 
    args = verifyOrder_args()
2792 
    args.orderId = orderId
759 chandransh 2793 
    args.write(self._oprot)
2794 
    self._oprot.writeMessageEnd()
2795 
    self._oprot.trans.flush()
2796 
 
3064 chandransh 2797 
  def recv_verifyOrder(self, ):
759 chandransh 2798 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2799 
    if mtype == TMessageType.EXCEPTION:
2800 
      x = TApplicationException()
2801 
      x.read(self._iprot)
2802 
      self._iprot.readMessageEnd()
2803 
      raise x
3064 chandransh 2804 
    result = verifyOrder_result()
759 chandransh 2805 
    result.read(self._iprot)
2806 
    self._iprot.readMessageEnd()
3431 rajveer 2807 
    if result.success is not None:
759 chandransh 2808 
      return result.success
3431 rajveer 2809 
    if result.ex is not None:
759 chandransh 2810 
      raise result.ex
3064 chandransh 2811 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "verifyOrder failed: unknown result");
759 chandransh 2812 
 
3064 chandransh 2813 
  def acceptOrder(self, orderId):
1113 chandransh 2814 
    """
3064 chandransh 2815 
    Marks the given order as ACCEPTED and updates the accepted timestamp. If the
2816 
    given order is not a COD order, it also captures the payment if the same has
2817 
    not been captured.
2818 
    Throws an exception if no such order exists.
3431 rajveer 2819 
 
1113 chandransh 2820 
    Parameters:
3064 chandransh 2821 
     - orderId
1113 chandransh 2822 
    """
3064 chandransh 2823 
    self.send_acceptOrder(orderId)
2824 
    return self.recv_acceptOrder()
1113 chandransh 2825 
 
3064 chandransh 2826 
  def send_acceptOrder(self, orderId):
2827 
    self._oprot.writeMessageBegin('acceptOrder', TMessageType.CALL, self._seqid)
2828 
    args = acceptOrder_args()
2829 
    args.orderId = orderId
1113 chandransh 2830 
    args.write(self._oprot)
2831 
    self._oprot.writeMessageEnd()
2832 
    self._oprot.trans.flush()
2833 
 
3064 chandransh 2834 
  def recv_acceptOrder(self, ):
1113 chandransh 2835 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2836 
    if mtype == TMessageType.EXCEPTION:
2837 
      x = TApplicationException()
2838 
      x.read(self._iprot)
2839 
      self._iprot.readMessageEnd()
2840 
      raise x
3064 chandransh 2841 
    result = acceptOrder_result()
1113 chandransh 2842 
    result.read(self._iprot)
2843 
    self._iprot.readMessageEnd()
3431 rajveer 2844 
    if result.success is not None:
1113 chandransh 2845 
      return result.success
3431 rajveer 2846 
    if result.ex is not None:
1113 chandransh 2847 
      raise result.ex
3064 chandransh 2848 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "acceptOrder failed: unknown result");
1113 chandransh 2849 
 
7190 amar.kumar 2850 
  def addBillingDetails(self, orderId, invoice_number, serialNumber, itemNumber, freebieWarehouseId, billed_by, jacketNumber, billingType, fulfilmentWarehouseId, authorize):
1132 chandransh 2851 
    """
3064 chandransh 2852 
    Add billing details such as the bill number and the biller to the Order.
4658 mandeep.dh 2853 
    Adds jacket number, item number and Serial no. to the order. Doesn't update
4283 anupam.sin 2854 
    the IMEI no. if a -1 is supplied.
2855 
    Also, it generates an invoice number for the order, marks the order as
2856 
    BILLED and sets the billing timestamp.
2857 
    Returns false if it doesn't find the order with the given ID.
3431 rajveer 2858 
 
1135 chandransh 2859 
    Parameters:
3064 chandransh 2860 
     - orderId
2861 
     - invoice_number
4658 mandeep.dh 2862 
     - serialNumber
4283 anupam.sin 2863 
     - itemNumber
7190 amar.kumar 2864 
     - freebieWarehouseId
3064 chandransh 2865 
     - billed_by
4264 rajveer 2866 
     - jacketNumber
4283 anupam.sin 2867 
     - billingType
5110 mandeep.dh 2868 
     - fulfilmentWarehouseId
4763 rajveer 2869 
     - authorize
1135 chandransh 2870 
    """
7190 amar.kumar 2871 
    self.send_addBillingDetails(orderId, invoice_number, serialNumber, itemNumber, freebieWarehouseId, billed_by, jacketNumber, billingType, fulfilmentWarehouseId, authorize)
3064 chandransh 2872 
    return self.recv_addBillingDetails()
1135 chandransh 2873 
 
7190 amar.kumar 2874 
  def send_addBillingDetails(self, orderId, invoice_number, serialNumber, itemNumber, freebieWarehouseId, billed_by, jacketNumber, billingType, fulfilmentWarehouseId, authorize):
3064 chandransh 2875 
    self._oprot.writeMessageBegin('addBillingDetails', TMessageType.CALL, self._seqid)
2876 
    args = addBillingDetails_args()
2877 
    args.orderId = orderId
2878 
    args.invoice_number = invoice_number
4658 mandeep.dh 2879 
    args.serialNumber = serialNumber
4283 anupam.sin 2880 
    args.itemNumber = itemNumber
7190 amar.kumar 2881 
    args.freebieWarehouseId = freebieWarehouseId
3064 chandransh 2882 
    args.billed_by = billed_by
4264 rajveer 2883 
    args.jacketNumber = jacketNumber
4283 anupam.sin 2884 
    args.billingType = billingType
5110 mandeep.dh 2885 
    args.fulfilmentWarehouseId = fulfilmentWarehouseId
4763 rajveer 2886 
    args.authorize = authorize
1135 chandransh 2887 
    args.write(self._oprot)
2888 
    self._oprot.writeMessageEnd()
2889 
    self._oprot.trans.flush()
2890 
 
3064 chandransh 2891 
  def recv_addBillingDetails(self, ):
1135 chandransh 2892 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2893 
    if mtype == TMessageType.EXCEPTION:
2894 
      x = TApplicationException()
2895 
      x.read(self._iprot)
2896 
      self._iprot.readMessageEnd()
2897 
      raise x
3064 chandransh 2898 
    result = addBillingDetails_result()
1135 chandransh 2899 
    result.read(self._iprot)
2900 
    self._iprot.readMessageEnd()
3431 rajveer 2901 
    if result.success is not None:
3064 chandransh 2902 
      return result.success
3431 rajveer 2903 
    if result.ex is not None:
1135 chandransh 2904 
      raise result.ex
3064 chandransh 2905 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addBillingDetails failed: unknown result");
1135 chandransh 2906 
 
6756 amar.kumar 2907 
  def addInvoiceNumber(self, orderId, invoiceNumber, color, serialNumber, itemNumber):
4579 rajveer 2908 
    """
2909 
    Add the invoice number to the order.
2910 
 
2911 
    Parameters:
2912 
     - orderId
2913 
     - invoiceNumber
4763 rajveer 2914 
     - color
6756 amar.kumar 2915 
     - serialNumber
2916 
     - itemNumber
4579 rajveer 2917 
    """
6756 amar.kumar 2918 
    self.send_addInvoiceNumber(orderId, invoiceNumber, color, serialNumber, itemNumber)
4579 rajveer 2919 
    self.recv_addInvoiceNumber()
2920 
 
6756 amar.kumar 2921 
  def send_addInvoiceNumber(self, orderId, invoiceNumber, color, serialNumber, itemNumber):
4579 rajveer 2922 
    self._oprot.writeMessageBegin('addInvoiceNumber', TMessageType.CALL, self._seqid)
2923 
    args = addInvoiceNumber_args()
2924 
    args.orderId = orderId
2925 
    args.invoiceNumber = invoiceNumber
4763 rajveer 2926 
    args.color = color
6756 amar.kumar 2927 
    args.serialNumber = serialNumber
2928 
    args.itemNumber = itemNumber
4579 rajveer 2929 
    args.write(self._oprot)
2930 
    self._oprot.writeMessageEnd()
2931 
    self._oprot.trans.flush()
2932 
 
2933 
  def recv_addInvoiceNumber(self, ):
2934 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2935 
    if mtype == TMessageType.EXCEPTION:
2936 
      x = TApplicationException()
2937 
      x.read(self._iprot)
2938 
      self._iprot.readMessageEnd()
2939 
      raise x
2940 
    result = addInvoiceNumber_result()
2941 
    result.read(self._iprot)
2942 
    self._iprot.readMessageEnd()
2943 
    if result.ex is not None:
2944 
      raise result.ex
2945 
    return
2946 
 
4910 phani.kuma 2947 
  def markOrdersAsShippedFromWarehouse(self, warehouseId, providerId, cod, orderIds):
1408 ankur.sing 2948 
    """
3064 chandransh 2949 
    Depending on the third parameter, marks either all prepaid or all cod orders BILLED by the
4910 phani.kuma 2950 
    given warehouse and were picked up by the given provider as SHIPPED_FROM_WH.
3431 rajveer 2951 
 
1408 ankur.sing 2952 
    Parameters:
3064 chandransh 2953 
     - warehouseId
1408 ankur.sing 2954 
     - providerId
3064 chandransh 2955 
     - cod
4910 phani.kuma 2956 
     - orderIds
1408 ankur.sing 2957 
    """
4910 phani.kuma 2958 
    self.send_markOrdersAsShippedFromWarehouse(warehouseId, providerId, cod, orderIds)
2959 
    return self.recv_markOrdersAsShippedFromWarehouse()
1408 ankur.sing 2960 
 
4910 phani.kuma 2961 
  def send_markOrdersAsShippedFromWarehouse(self, warehouseId, providerId, cod, orderIds):
2962 
    self._oprot.writeMessageBegin('markOrdersAsShippedFromWarehouse', TMessageType.CALL, self._seqid)
2963 
    args = markOrdersAsShippedFromWarehouse_args()
3064 chandransh 2964 
    args.warehouseId = warehouseId
1408 ankur.sing 2965 
    args.providerId = providerId
3064 chandransh 2966 
    args.cod = cod
4910 phani.kuma 2967 
    args.orderIds = orderIds
1408 ankur.sing 2968 
    args.write(self._oprot)
2969 
    self._oprot.writeMessageEnd()
2970 
    self._oprot.trans.flush()
2971 
 
4910 phani.kuma 2972 
  def recv_markOrdersAsShippedFromWarehouse(self, ):
1408 ankur.sing 2973 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2974 
    if mtype == TMessageType.EXCEPTION:
2975 
      x = TApplicationException()
2976 
      x.read(self._iprot)
2977 
      self._iprot.readMessageEnd()
2978 
      raise x
4910 phani.kuma 2979 
    result = markOrdersAsShippedFromWarehouse_result()
1408 ankur.sing 2980 
    result.read(self._iprot)
2981 
    self._iprot.readMessageEnd()
3431 rajveer 2982 
    if result.success is not None:
1408 ankur.sing 2983 
      return result.success
3431 rajveer 2984 
    if result.ex is not None:
3064 chandransh 2985 
      raise result.ex
4910 phani.kuma 2986 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrdersAsShippedFromWarehouse failed: unknown result");
1408 ankur.sing 2987 
 
5713 rajveer 2988 
  def markOrdersAsReturnedFromStore(self, providerId, orderIds, awbs):
5676 rajveer 2989 
    """
2990 
    Parameters:
2991 
     - providerId
2992 
     - orderIds
5713 rajveer 2993 
     - awbs
5676 rajveer 2994 
    """
5713 rajveer 2995 
    self.send_markOrdersAsReturnedFromStore(providerId, orderIds, awbs)
5676 rajveer 2996 
    return self.recv_markOrdersAsReturnedFromStore()
2997 
 
5713 rajveer 2998 
  def send_markOrdersAsReturnedFromStore(self, providerId, orderIds, awbs):
5676 rajveer 2999 
    self._oprot.writeMessageBegin('markOrdersAsReturnedFromStore', TMessageType.CALL, self._seqid)
3000 
    args = markOrdersAsReturnedFromStore_args()
3001 
    args.providerId = providerId
3002 
    args.orderIds = orderIds
5713 rajveer 3003 
    args.awbs = awbs
5676 rajveer 3004 
    args.write(self._oprot)
3005 
    self._oprot.writeMessageEnd()
3006 
    self._oprot.trans.flush()
3007 
 
3008 
  def recv_markOrdersAsReturnedFromStore(self, ):
3009 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3010 
    if mtype == TMessageType.EXCEPTION:
3011 
      x = TApplicationException()
3012 
      x.read(self._iprot)
3013 
      self._iprot.readMessageEnd()
3014 
      raise x
3015 
    result = markOrdersAsReturnedFromStore_result()
3016 
    result.read(self._iprot)
3017 
    self._iprot.readMessageEnd()
3018 
    if result.success is not None:
3019 
      return result.success
3020 
    if result.ex is not None:
3021 
      raise result.ex
3022 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrdersAsReturnedFromStore failed: unknown result");
3023 
 
4910 phani.kuma 3024 
  def markOrdersAsPickedUp(self, providerId, pickupDetails):
4410 rajveer 3025 
    """
4910 phani.kuma 3026 
    Marks all SHIPPED_FROM_WH orders of the previous day for a provider as SHIPPED_TO_LOGISTICS.
3027 
    Raises an exception if we encounter report for an AWB number that we did not ship.
4410 rajveer 3028 
 
3029 
    Parameters:
3030 
     - providerId
4910 phani.kuma 3031 
     - pickupDetails
4410 rajveer 3032 
    """
4910 phani.kuma 3033 
    self.send_markOrdersAsPickedUp(providerId, pickupDetails)
3034 
    self.recv_markOrdersAsPickedUp()
4410 rajveer 3035 
 
4910 phani.kuma 3036 
  def send_markOrdersAsPickedUp(self, providerId, pickupDetails):
3037 
    self._oprot.writeMessageBegin('markOrdersAsPickedUp', TMessageType.CALL, self._seqid)
3038 
    args = markOrdersAsPickedUp_args()
4410 rajveer 3039 
    args.providerId = providerId
4910 phani.kuma 3040 
    args.pickupDetails = pickupDetails
4410 rajveer 3041 
    args.write(self._oprot)
3042 
    self._oprot.writeMessageEnd()
3043 
    self._oprot.trans.flush()
3044 
 
4910 phani.kuma 3045 
  def recv_markOrdersAsPickedUp(self, ):
4410 rajveer 3046 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3047 
    if mtype == TMessageType.EXCEPTION:
3048 
      x = TApplicationException()
3049 
      x.read(self._iprot)
3050 
      self._iprot.readMessageEnd()
3051 
      raise x
4910 phani.kuma 3052 
    result = markOrdersAsPickedUp_result()
4410 rajveer 3053 
    result.read(self._iprot)
3054 
    self._iprot.readMessageEnd()
3055 
    if result.ex is not None:
3056 
      raise result.ex
4910 phani.kuma 3057 
    return
4410 rajveer 3058 
 
4910 phani.kuma 3059 
  def getOrdersNotPickedUp(self, providerId):
94 ashish 3060 
    """
3064 chandransh 3061 
    Returns a list of orders that were shipped from warehouse but did not appear in the pick-up report.
3431 rajveer 3062 
 
94 ashish 3063 
    Parameters:
3064 chandransh 3064 
     - providerId
304 ashish 3065 
    """
4910 phani.kuma 3066 
    self.send_getOrdersNotPickedUp(providerId)
3067 
    return self.recv_getOrdersNotPickedUp()
94 ashish 3068 
 
4910 phani.kuma 3069 
  def send_getOrdersNotPickedUp(self, providerId):
3070 
    self._oprot.writeMessageBegin('getOrdersNotPickedUp', TMessageType.CALL, self._seqid)
3071 
    args = getOrdersNotPickedUp_args()
3064 chandransh 3072 
    args.providerId = providerId
304 ashish 3073 
    args.write(self._oprot)
3074 
    self._oprot.writeMessageEnd()
3075 
    self._oprot.trans.flush()
3076 
 
4910 phani.kuma 3077 
  def recv_getOrdersNotPickedUp(self, ):
304 ashish 3078 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3079 
    if mtype == TMessageType.EXCEPTION:
3080 
      x = TApplicationException()
3081 
      x.read(self._iprot)
3082 
      self._iprot.readMessageEnd()
3083 
      raise x
4910 phani.kuma 3084 
    result = getOrdersNotPickedUp_result()
304 ashish 3085 
    result.read(self._iprot)
3086 
    self._iprot.readMessageEnd()
3431 rajveer 3087 
    if result.success is not None:
304 ashish 3088 
      return result.success
4910 phani.kuma 3089 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersNotPickedUp failed: unknown result");
304 ashish 3090 
 
3064 chandransh 3091 
  def markOrdersAsDelivered(self, providerId, deliveredOrders):
304 ashish 3092 
    """
3064 chandransh 3093 
    Marks all orders with AWBs in the given map as delivered. Also sets the delivery timestamp and
3094 
    the name of the receiver.
3095 
    Raises an exception if we encounter report for an AWB number that we did not ship.
3431 rajveer 3096 
 
304 ashish 3097 
    Parameters:
3064 chandransh 3098 
     - providerId
3099 
     - deliveredOrders
304 ashish 3100 
    """
3064 chandransh 3101 
    self.send_markOrdersAsDelivered(providerId, deliveredOrders)
3102 
    self.recv_markOrdersAsDelivered()
304 ashish 3103 
 
3064 chandransh 3104 
  def send_markOrdersAsDelivered(self, providerId, deliveredOrders):
3105 
    self._oprot.writeMessageBegin('markOrdersAsDelivered', TMessageType.CALL, self._seqid)
3106 
    args = markOrdersAsDelivered_args()
3107 
    args.providerId = providerId
3108 
    args.deliveredOrders = deliveredOrders
304 ashish 3109 
    args.write(self._oprot)
3110 
    self._oprot.writeMessageEnd()
3111 
    self._oprot.trans.flush()
3112 
 
3064 chandransh 3113 
  def recv_markOrdersAsDelivered(self, ):
304 ashish 3114 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3115 
    if mtype == TMessageType.EXCEPTION:
3116 
      x = TApplicationException()
3117 
      x.read(self._iprot)
3118 
      self._iprot.readMessageEnd()
3119 
      raise x
3064 chandransh 3120 
    result = markOrdersAsDelivered_result()
304 ashish 3121 
    result.read(self._iprot)
3122 
    self._iprot.readMessageEnd()
3431 rajveer 3123 
    if result.ex is not None:
3064 chandransh 3124 
      raise result.ex
304 ashish 3125 
    return
3126 
 
4910 phani.kuma 3127 
  def markAsRTOrders(self, providerId, returnedOrders):
1596 ankur.sing 3128 
    """
4910 phani.kuma 3129 
    Mark all orders with AWBs in the given map as RTO. Also sets the delivery timestamp.
3064 chandransh 3130 
    Raises an exception if we encounter report for an AWB number that we did not ship.
3431 rajveer 3131 
 
3064 chandransh 3132 
    Parameters:
3133 
     - providerId
3134 
     - returnedOrders
1596 ankur.sing 3135 
    """
4910 phani.kuma 3136 
    self.send_markAsRTOrders(providerId, returnedOrders)
3137 
    self.recv_markAsRTOrders()
304 ashish 3138 
 
4910 phani.kuma 3139 
  def send_markAsRTOrders(self, providerId, returnedOrders):
3140 
    self._oprot.writeMessageBegin('markAsRTOrders', TMessageType.CALL, self._seqid)
3141 
    args = markAsRTOrders_args()
3064 chandransh 3142 
    args.providerId = providerId
3143 
    args.returnedOrders = returnedOrders
1596 ankur.sing 3144 
    args.write(self._oprot)
3145 
    self._oprot.writeMessageEnd()
3146 
    self._oprot.trans.flush()
3147 
 
4910 phani.kuma 3148 
  def recv_markAsRTOrders(self, ):
1596 ankur.sing 3149 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3150 
    if mtype == TMessageType.EXCEPTION:
3151 
      x = TApplicationException()
3152 
      x.read(self._iprot)
3153 
      self._iprot.readMessageEnd()
3154 
      raise x
4910 phani.kuma 3155 
    result = markAsRTOrders_result()
1596 ankur.sing 3156 
    result.read(self._iprot)
3157 
    self._iprot.readMessageEnd()
3431 rajveer 3158 
    if result.ex is not None:
3064 chandransh 3159 
      raise result.ex
3160 
    return
1596 ankur.sing 3161 
 
4910 phani.kuma 3162 
  def getRTOrders(self, providerId):
3163 
    """
3164 
    Returns a list of orders that were returned by courier.
3165 
 
3166 
    Parameters:
3167 
     - providerId
3168 
    """
3169 
    self.send_getRTOrders(providerId)
3170 
    return self.recv_getRTOrders()
3171 
 
3172 
  def send_getRTOrders(self, providerId):
3173 
    self._oprot.writeMessageBegin('getRTOrders', TMessageType.CALL, self._seqid)
3174 
    args = getRTOrders_args()
3175 
    args.providerId = providerId
3176 
    args.write(self._oprot)
3177 
    self._oprot.writeMessageEnd()
3178 
    self._oprot.trans.flush()
3179 
 
3180 
  def recv_getRTOrders(self, ):
3181 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3182 
    if mtype == TMessageType.EXCEPTION:
3183 
      x = TApplicationException()
3184 
      x.read(self._iprot)
3185 
      self._iprot.readMessageEnd()
3186 
      raise x
3187 
    result = getRTOrders_result()
3188 
    result.read(self._iprot)
3189 
    self._iprot.readMessageEnd()
3190 
    if result.success is not None:
3191 
      return result.success
3192 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getRTOrders failed: unknown result");
3193 
 
3064 chandransh 3194 
  def updateNonDeliveryReason(self, providerId, undeliveredOrders):
1627 ankur.sing 3195 
    """
3064 chandransh 3196 
    Update the status description of orders whose AWB numbers are keys of the Map.
3431 rajveer 3197 
 
3064 chandransh 3198 
    Parameters:
3199 
     - providerId
3200 
     - undeliveredOrders
1627 ankur.sing 3201 
    """
3064 chandransh 3202 
    self.send_updateNonDeliveryReason(providerId, undeliveredOrders)
4910 phani.kuma 3203 
    self.recv_updateNonDeliveryReason()
1596 ankur.sing 3204 
 
3064 chandransh 3205 
  def send_updateNonDeliveryReason(self, providerId, undeliveredOrders):
3206 
    self._oprot.writeMessageBegin('updateNonDeliveryReason', TMessageType.CALL, self._seqid)
3207 
    args = updateNonDeliveryReason_args()
3208 
    args.providerId = providerId
3209 
    args.undeliveredOrders = undeliveredOrders
1627 ankur.sing 3210 
    args.write(self._oprot)
3211 
    self._oprot.writeMessageEnd()
3212 
    self._oprot.trans.flush()
3213 
 
3064 chandransh 3214 
  def recv_updateNonDeliveryReason(self, ):
1627 ankur.sing 3215 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3216 
    if mtype == TMessageType.EXCEPTION:
3217 
      x = TApplicationException()
3218 
      x.read(self._iprot)
3219 
      self._iprot.readMessageEnd()
3220 
      raise x
3064 chandransh 3221 
    result = updateNonDeliveryReason_result()
1627 ankur.sing 3222 
    result.read(self._iprot)
3223 
    self._iprot.readMessageEnd()
4910 phani.kuma 3224 
    if result.ex is not None:
3225 
      raise result.ex
3226 
    return
3227 
 
3228 
  def getNonDeliveredOrdersbyCourier(self, providerId):
3229 
    """
3230 
    Returns a list of orders that were picked up or shipped four days ago but did not get delivered.
3231 
 
3232 
    Parameters:
3233 
     - providerId
3234 
    """
3235 
    self.send_getNonDeliveredOrdersbyCourier(providerId)
3236 
    return self.recv_getNonDeliveredOrdersbyCourier()
3237 
 
3238 
  def send_getNonDeliveredOrdersbyCourier(self, providerId):
3239 
    self._oprot.writeMessageBegin('getNonDeliveredOrdersbyCourier', TMessageType.CALL, self._seqid)
3240 
    args = getNonDeliveredOrdersbyCourier_args()
3241 
    args.providerId = providerId
3242 
    args.write(self._oprot)
3243 
    self._oprot.writeMessageEnd()
3244 
    self._oprot.trans.flush()
3245 
 
3246 
  def recv_getNonDeliveredOrdersbyCourier(self, ):
3247 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3248 
    if mtype == TMessageType.EXCEPTION:
3249 
      x = TApplicationException()
3250 
      x.read(self._iprot)
3251 
      self._iprot.readMessageEnd()
3252 
      raise x
3253 
    result = getNonDeliveredOrdersbyCourier_result()
3254 
    result.read(self._iprot)
3255 
    self._iprot.readMessageEnd()
4581 phani.kuma 3256 
    if result.success is not None:
3257 
      return result.success
4910 phani.kuma 3258 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getNonDeliveredOrdersbyCourier failed: unknown result");
3259 
 
3260 
  def markOrdersAsLocalConnected(self, providerId, local_connected_orders):
3261 
    """
3262 
    Mark all orders with AWBs in the given map as local connected. Also sets the local connected timestamp.
3263 
 
3264 
    Parameters:
3265 
     - providerId
3266 
     - local_connected_orders
3267 
    """
3268 
    self.send_markOrdersAsLocalConnected(providerId, local_connected_orders)
3269 
    self.recv_markOrdersAsLocalConnected()
3270 
 
3271 
  def send_markOrdersAsLocalConnected(self, providerId, local_connected_orders):
3272 
    self._oprot.writeMessageBegin('markOrdersAsLocalConnected', TMessageType.CALL, self._seqid)
3273 
    args = markOrdersAsLocalConnected_args()
3274 
    args.providerId = providerId
3275 
    args.local_connected_orders = local_connected_orders
3276 
    args.write(self._oprot)
3277 
    self._oprot.writeMessageEnd()
3278 
    self._oprot.trans.flush()
3279 
 
3280 
  def recv_markOrdersAsLocalConnected(self, ):
3281 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3282 
    if mtype == TMessageType.EXCEPTION:
3283 
      x = TApplicationException()
3284 
      x.read(self._iprot)
3285 
      self._iprot.readMessageEnd()
3286 
      raise x
3287 
    result = markOrdersAsLocalConnected_result()
3288 
    result.read(self._iprot)
3289 
    self._iprot.readMessageEnd()
3431 rajveer 3290 
    if result.ex is not None:
3064 chandransh 3291 
      raise result.ex
4910 phani.kuma 3292 
    return
1627 ankur.sing 3293 
 
4910 phani.kuma 3294 
  def getOrdersNotLocalConnected(self, providerId):
3295 
    """
3296 
    Returns a list of orders that were picked up or shipped but pending local connection.
3297 
 
3298 
    Parameters:
3299 
     - providerId
3300 
    """
3301 
    self.send_getOrdersNotLocalConnected(providerId)
3302 
    return self.recv_getOrdersNotLocalConnected()
3303 
 
3304 
  def send_getOrdersNotLocalConnected(self, providerId):
3305 
    self._oprot.writeMessageBegin('getOrdersNotLocalConnected', TMessageType.CALL, self._seqid)
3306 
    args = getOrdersNotLocalConnected_args()
3307 
    args.providerId = providerId
3308 
    args.write(self._oprot)
3309 
    self._oprot.writeMessageEnd()
3310 
    self._oprot.trans.flush()
3311 
 
3312 
  def recv_getOrdersNotLocalConnected(self, ):
3313 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3314 
    if mtype == TMessageType.EXCEPTION:
3315 
      x = TApplicationException()
3316 
      x.read(self._iprot)
3317 
      self._iprot.readMessageEnd()
3318 
      raise x
3319 
    result = getOrdersNotLocalConnected_result()
3320 
    result.read(self._iprot)
3321 
    self._iprot.readMessageEnd()
3322 
    if result.success is not None:
3323 
      return result.success
3324 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersNotLocalConnected failed: unknown result");
3325 
 
3326 
  def markOrdersAsDestinationCityReached(self, providerId, destination_city_reached_orders):
3327 
    """
3328 
    Mark all orders with AWBs in the given map as reached destination city. Also sets the reached destination timestamp.
3329 
 
3330 
    Parameters:
3331 
     - providerId
3332 
     - destination_city_reached_orders
3333 
    """
3334 
    self.send_markOrdersAsDestinationCityReached(providerId, destination_city_reached_orders)
3335 
    self.recv_markOrdersAsDestinationCityReached()
3336 
 
3337 
  def send_markOrdersAsDestinationCityReached(self, providerId, destination_city_reached_orders):
3338 
    self._oprot.writeMessageBegin('markOrdersAsDestinationCityReached', TMessageType.CALL, self._seqid)
3339 
    args = markOrdersAsDestinationCityReached_args()
3340 
    args.providerId = providerId
3341 
    args.destination_city_reached_orders = destination_city_reached_orders
3342 
    args.write(self._oprot)
3343 
    self._oprot.writeMessageEnd()
3344 
    self._oprot.trans.flush()
3345 
 
3346 
  def recv_markOrdersAsDestinationCityReached(self, ):
3347 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3348 
    if mtype == TMessageType.EXCEPTION:
3349 
      x = TApplicationException()
3350 
      x.read(self._iprot)
3351 
      self._iprot.readMessageEnd()
3352 
      raise x
3353 
    result = markOrdersAsDestinationCityReached_result()
3354 
    result.read(self._iprot)
3355 
    self._iprot.readMessageEnd()
3356 
    if result.ex is not None:
3357 
      raise result.ex
3358 
    return
3359 
 
3360 
  def markOrdersAsFirstDeliveryAttempted(self, providerId, first_atdl_orders):
3361 
    """
3362 
    Mark all orders with AWBs in the given map as first delivery attempt made. Also sets the first delivery attempted timestamp.
3363 
 
3364 
    Parameters:
3365 
     - providerId
3366 
     - first_atdl_orders
3367 
    """
3368 
    self.send_markOrdersAsFirstDeliveryAttempted(providerId, first_atdl_orders)
3369 
    self.recv_markOrdersAsFirstDeliveryAttempted()
3370 
 
3371 
  def send_markOrdersAsFirstDeliveryAttempted(self, providerId, first_atdl_orders):
3372 
    self._oprot.writeMessageBegin('markOrdersAsFirstDeliveryAttempted', TMessageType.CALL, self._seqid)
3373 
    args = markOrdersAsFirstDeliveryAttempted_args()
3374 
    args.providerId = providerId
3375 
    args.first_atdl_orders = first_atdl_orders
3376 
    args.write(self._oprot)
3377 
    self._oprot.writeMessageEnd()
3378 
    self._oprot.trans.flush()
3379 
 
3380 
  def recv_markOrdersAsFirstDeliveryAttempted(self, ):
3381 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3382 
    if mtype == TMessageType.EXCEPTION:
3383 
      x = TApplicationException()
3384 
      x.read(self._iprot)
3385 
      self._iprot.readMessageEnd()
3386 
      raise x
3387 
    result = markOrdersAsFirstDeliveryAttempted_result()
3388 
    result.read(self._iprot)
3389 
    self._iprot.readMessageEnd()
3390 
    if result.ex is not None:
3391 
      raise result.ex
3392 
    return
3393 
 
3064 chandransh 3394 
  def getUndeliveredOrders(self, providerId, warehouseId):
1627 ankur.sing 3395 
    """
3064 chandransh 3396 
    Returns the list of orders whose delivery time has passed but have not been
3397 
    delivered yet for the given provider and warehouse. To get a complete list of
3398 
    undelivered orders, pass them as -1.
3399 
    Returns an empty list if no such orders exist.
3431 rajveer 3400 
 
1886 ankur.sing 3401 
    Parameters:
3064 chandransh 3402 
     - providerId
3403 
     - warehouseId
1886 ankur.sing 3404 
    """
3064 chandransh 3405 
    self.send_getUndeliveredOrders(providerId, warehouseId)
3406 
    return self.recv_getUndeliveredOrders()
1627 ankur.sing 3407 
 
3064 chandransh 3408 
  def send_getUndeliveredOrders(self, providerId, warehouseId):
3409 
    self._oprot.writeMessageBegin('getUndeliveredOrders', TMessageType.CALL, self._seqid)
3410 
    args = getUndeliveredOrders_args()
3411 
    args.providerId = providerId
3412 
    args.warehouseId = warehouseId
1886 ankur.sing 3413 
    args.write(self._oprot)
3414 
    self._oprot.writeMessageEnd()
3415 
    self._oprot.trans.flush()
3416 
 
3064 chandransh 3417 
  def recv_getUndeliveredOrders(self, ):
1886 ankur.sing 3418 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3419 
    if mtype == TMessageType.EXCEPTION:
3420 
      x = TApplicationException()
3421 
      x.read(self._iprot)
3422 
      self._iprot.readMessageEnd()
3423 
      raise x
3064 chandransh 3424 
    result = getUndeliveredOrders_result()
1886 ankur.sing 3425 
    result.read(self._iprot)
3426 
    self._iprot.readMessageEnd()
3431 rajveer 3427 
    if result.success is not None:
1886 ankur.sing 3428 
      return result.success
3064 chandransh 3429 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUndeliveredOrders failed: unknown result");
1886 ankur.sing 3430 
 
4783 phani.kuma 3431 
  def getUndeliveredOrdersExpectedDeliveryDateNotMet(self, ):
3432 
    """
3433 
    Returns the list of orders whose expected delivery date has passed but have not been
3434 
    delivered yet.
3435 
    Returns an empty list if no such orders exist.
3436 
    """
3437 
    self.send_getUndeliveredOrdersExpectedDeliveryDateNotMet()
3438 
    return self.recv_getUndeliveredOrdersExpectedDeliveryDateNotMet()
3439 
 
3440 
  def send_getUndeliveredOrdersExpectedDeliveryDateNotMet(self, ):
3441 
    self._oprot.writeMessageBegin('getUndeliveredOrdersExpectedDeliveryDateNotMet', TMessageType.CALL, self._seqid)
3442 
    args = getUndeliveredOrdersExpectedDeliveryDateNotMet_args()
3443 
    args.write(self._oprot)
3444 
    self._oprot.writeMessageEnd()
3445 
    self._oprot.trans.flush()
3446 
 
3447 
  def recv_getUndeliveredOrdersExpectedDeliveryDateNotMet(self, ):
3448 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3449 
    if mtype == TMessageType.EXCEPTION:
3450 
      x = TApplicationException()
3451 
      x.read(self._iprot)
3452 
      self._iprot.readMessageEnd()
3453 
      raise x
3454 
    result = getUndeliveredOrdersExpectedDeliveryDateNotMet_result()
3455 
    result.read(self._iprot)
3456 
    self._iprot.readMessageEnd()
3457 
    if result.success is not None:
3458 
      return result.success
3459 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUndeliveredOrdersExpectedDeliveryDateNotMet failed: unknown result");
3460 
 
2536 chandransh 3461 
  def toggleDOAFlag(self, orderId):
3462 
    """
3463 
    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.
3464 
    Returns the final flag status.
3465 
    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 3466 
 
2536 chandransh 3467 
    Parameters:
3468 
     - orderId
3469 
    """
3470 
    self.send_toggleDOAFlag(orderId)
3471 
    return self.recv_toggleDOAFlag()
1886 ankur.sing 3472 
 
2536 chandransh 3473 
  def send_toggleDOAFlag(self, orderId):
3474 
    self._oprot.writeMessageBegin('toggleDOAFlag', TMessageType.CALL, self._seqid)
3475 
    args = toggleDOAFlag_args()
3476 
    args.orderId = orderId
3477 
    args.write(self._oprot)
3478 
    self._oprot.writeMessageEnd()
3479 
    self._oprot.trans.flush()
3480 
 
3481 
  def recv_toggleDOAFlag(self, ):
3482 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3483 
    if mtype == TMessageType.EXCEPTION:
3484 
      x = TApplicationException()
3485 
      x.read(self._iprot)
3486 
      self._iprot.readMessageEnd()
3487 
      raise x
3488 
    result = toggleDOAFlag_result()
3489 
    result.read(self._iprot)
3490 
    self._iprot.readMessageEnd()
3431 rajveer 3491 
    if result.success is not None:
2536 chandransh 3492 
      return result.success
3431 rajveer 3493 
    if result.ex is not None:
2536 chandransh 3494 
      raise result.ex
3495 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "toggleDOAFlag failed: unknown result");
3496 
 
4712 rajveer 3497 
  def markOrderAsDelivered(self, orderId, deliveryTimestamp, receiver):
3498 
    """
3499 
    Parameters:
3500 
     - orderId
3501 
     - deliveryTimestamp
3502 
     - receiver
3503 
    """
3504 
    self.send_markOrderAsDelivered(orderId, deliveryTimestamp, receiver)
3505 
    self.recv_markOrderAsDelivered()
3506 
 
3507 
  def send_markOrderAsDelivered(self, orderId, deliveryTimestamp, receiver):
3508 
    self._oprot.writeMessageBegin('markOrderAsDelivered', TMessageType.CALL, self._seqid)
3509 
    args = markOrderAsDelivered_args()
3510 
    args.orderId = orderId
3511 
    args.deliveryTimestamp = deliveryTimestamp
3512 
    args.receiver = receiver
3513 
    args.write(self._oprot)
3514 
    self._oprot.writeMessageEnd()
3515 
    self._oprot.trans.flush()
3516 
 
3517 
  def recv_markOrderAsDelivered(self, ):
3518 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3519 
    if mtype == TMessageType.EXCEPTION:
3520 
      x = TApplicationException()
3521 
      x.read(self._iprot)
3522 
      self._iprot.readMessageEnd()
3523 
      raise x
3524 
    result = markOrderAsDelivered_result()
3525 
    result.read(self._iprot)
3526 
    self._iprot.readMessageEnd()
3527 
    if result.ex is not None:
3528 
      raise result.ex
3529 
    return
3530 
 
5553 rajveer 3531 
  def markOrderAsReceivedAtStore(self, orderId, deliveryTimestamp):
3532 
    """
3533 
    Parameters:
3534 
     - orderId
3535 
     - deliveryTimestamp
3536 
    """
3537 
    self.send_markOrderAsReceivedAtStore(orderId, deliveryTimestamp)
3538 
    self.recv_markOrderAsReceivedAtStore()
3539 
 
3540 
  def send_markOrderAsReceivedAtStore(self, orderId, deliveryTimestamp):
3541 
    self._oprot.writeMessageBegin('markOrderAsReceivedAtStore', TMessageType.CALL, self._seqid)
3542 
    args = markOrderAsReceivedAtStore_args()
3543 
    args.orderId = orderId
3544 
    args.deliveryTimestamp = deliveryTimestamp
3545 
    args.write(self._oprot)
3546 
    self._oprot.writeMessageEnd()
3547 
    self._oprot.trans.flush()
3548 
 
3549 
  def recv_markOrderAsReceivedAtStore(self, ):
3550 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3551 
    if mtype == TMessageType.EXCEPTION:
3552 
      x = TApplicationException()
3553 
      x.read(self._iprot)
3554 
      self._iprot.readMessageEnd()
3555 
      raise x
3556 
    result = markOrderAsReceivedAtStore_result()
3557 
    result.read(self._iprot)
3558 
    self._iprot.readMessageEnd()
3559 
    if result.ex is not None:
3560 
      raise result.ex
3561 
    return
3562 
 
4454 rajveer 3563 
  def markOrderDoaRequestReceived(self, orderId):
3564 
    """
3565 
    Once user raise the request for a DOA, order status will be changed from DELVIERY_SUCCESS to DOA_REQUEST_RECEIVED
3566 
 
3567 
    Parameters:
3568 
     - orderId
3569 
    """
3570 
    self.send_markOrderDoaRequestReceived(orderId)
3571 
    return self.recv_markOrderDoaRequestReceived()
3572 
 
3573 
  def send_markOrderDoaRequestReceived(self, orderId):
3574 
    self._oprot.writeMessageBegin('markOrderDoaRequestReceived', TMessageType.CALL, self._seqid)
3575 
    args = markOrderDoaRequestReceived_args()
3576 
    args.orderId = orderId
3577 
    args.write(self._oprot)
3578 
    self._oprot.writeMessageEnd()
3579 
    self._oprot.trans.flush()
3580 
 
3581 
  def recv_markOrderDoaRequestReceived(self, ):
3582 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3583 
    if mtype == TMessageType.EXCEPTION:
3584 
      x = TApplicationException()
3585 
      x.read(self._iprot)
3586 
      self._iprot.readMessageEnd()
3587 
      raise x
3588 
    result = markOrderDoaRequestReceived_result()
3589 
    result.read(self._iprot)
3590 
    self._iprot.readMessageEnd()
3591 
    if result.success is not None:
3592 
      return result.success
3593 
    if result.ex is not None:
3594 
      raise result.ex
3595 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderDoaRequestReceived failed: unknown result");
3596 
 
3597 
  def markOrderDoaRequestAuthorized(self, orderId, isAuthorized):
3598 
    """
3599 
    CRM person can authorize or deny the request reised by customer. If he authorizes order will change from DOA_REQUEST_RECEIVED
3600 
    to DOA_REQUEST_AUTHORIZED. If he denies, status will be changed back to DELVIERY_SUCCESS.
3601 
 
3602 
    Parameters:
3603 
     - orderId
3604 
     - isAuthorized
3605 
    """
3606 
    self.send_markOrderDoaRequestAuthorized(orderId, isAuthorized)
3607 
    return self.recv_markOrderDoaRequestAuthorized()
3608 
 
3609 
  def send_markOrderDoaRequestAuthorized(self, orderId, isAuthorized):
3610 
    self._oprot.writeMessageBegin('markOrderDoaRequestAuthorized', TMessageType.CALL, self._seqid)
3611 
    args = markOrderDoaRequestAuthorized_args()
3612 
    args.orderId = orderId
3613 
    args.isAuthorized = isAuthorized
3614 
    args.write(self._oprot)
3615 
    self._oprot.writeMessageEnd()
3616 
    self._oprot.trans.flush()
3617 
 
3618 
  def recv_markOrderDoaRequestAuthorized(self, ):
3619 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3620 
    if mtype == TMessageType.EXCEPTION:
3621 
      x = TApplicationException()
3622 
      x.read(self._iprot)
3623 
      self._iprot.readMessageEnd()
3624 
      raise x
3625 
    result = markOrderDoaRequestAuthorized_result()
3626 
    result.read(self._iprot)
3627 
    self._iprot.readMessageEnd()
3628 
    if result.success is not None:
3629 
      return result.success
3630 
    if result.ex is not None:
3631 
      raise result.ex
3632 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderDoaRequestAuthorized failed: unknown result");
3633 
 
4488 rajveer 3634 
  def markOrderReturnRequestReceived(self, orderId):
3635 
    """
3636 
    Once user raise the request for a RET, order status will be changed from DELVIERY_SUCCESS to RET_REQUEST_RECEIVED
3637 
 
3638 
    Parameters:
3639 
     - orderId
3640 
    """
3641 
    self.send_markOrderReturnRequestReceived(orderId)
3642 
    return self.recv_markOrderReturnRequestReceived()
3643 
 
3644 
  def send_markOrderReturnRequestReceived(self, orderId):
3645 
    self._oprot.writeMessageBegin('markOrderReturnRequestReceived', TMessageType.CALL, self._seqid)
3646 
    args = markOrderReturnRequestReceived_args()
3647 
    args.orderId = orderId
3648 
    args.write(self._oprot)
3649 
    self._oprot.writeMessageEnd()
3650 
    self._oprot.trans.flush()
3651 
 
3652 
  def recv_markOrderReturnRequestReceived(self, ):
3653 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3654 
    if mtype == TMessageType.EXCEPTION:
3655 
      x = TApplicationException()
3656 
      x.read(self._iprot)
3657 
      self._iprot.readMessageEnd()
3658 
      raise x
3659 
    result = markOrderReturnRequestReceived_result()
3660 
    result.read(self._iprot)
3661 
    self._iprot.readMessageEnd()
3662 
    if result.success is not None:
3663 
      return result.success
3664 
    if result.ex is not None:
3665 
      raise result.ex
3666 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderReturnRequestReceived failed: unknown result");
3667 
 
3668 
  def markOrderReturnRequestAuthorized(self, orderId, isAuthorized):
3669 
    """
3670 
    CRM person can authorize or deny the request reised by customer. If he authorizes order will change from RET_REQUEST_RECEIVED
3671 
    to RET_REQUEST_AUTHORIZED. If he denies, status will be changed back to DELVIERY_SUCCESS.
3672 
 
3673 
    Parameters:
3674 
     - orderId
3675 
     - isAuthorized
3676 
    """
3677 
    self.send_markOrderReturnRequestAuthorized(orderId, isAuthorized)
3678 
    return self.recv_markOrderReturnRequestAuthorized()
3679 
 
3680 
  def send_markOrderReturnRequestAuthorized(self, orderId, isAuthorized):
3681 
    self._oprot.writeMessageBegin('markOrderReturnRequestAuthorized', TMessageType.CALL, self._seqid)
3682 
    args = markOrderReturnRequestAuthorized_args()
3683 
    args.orderId = orderId
3684 
    args.isAuthorized = isAuthorized
3685 
    args.write(self._oprot)
3686 
    self._oprot.writeMessageEnd()
3687 
    self._oprot.trans.flush()
3688 
 
3689 
  def recv_markOrderReturnRequestAuthorized(self, ):
3690 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3691 
    if mtype == TMessageType.EXCEPTION:
3692 
      x = TApplicationException()
3693 
      x.read(self._iprot)
3694 
      self._iprot.readMessageEnd()
3695 
      raise x
3696 
    result = markOrderReturnRequestAuthorized_result()
3697 
    result.read(self._iprot)
3698 
    self._iprot.readMessageEnd()
3699 
    if result.success is not None:
3700 
      return result.success
3701 
    if result.ex is not None:
3702 
      raise result.ex
3703 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderReturnRequestAuthorized failed: unknown result");
3704 
 
4579 rajveer 3705 
  def requestPickupNumber(self, orderId, providerId):
2536 chandransh 3706 
    """
3707 
    Sends out an email to the account manager of the original courier provider used to ship the order.
4452 rajveer 3708 
    If the order status was DELIVERY_SUCCESS, it is changed to be DOA_PICKUP_REQUEST_RAISED.
3709 
    If the order status was DOA_PICKUP_REQUEST_RAISED, it is left unchanged.
2536 chandransh 3710 
    For any other status, it returns false.
3711 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 3712 
 
2536 chandransh 3713 
    Parameters:
3714 
     - orderId
4579 rajveer 3715 
     - providerId
2536 chandransh 3716 
    """
4579 rajveer 3717 
    self.send_requestPickupNumber(orderId, providerId)
2536 chandransh 3718 
    return self.recv_requestPickupNumber()
3719 
 
4579 rajveer 3720 
  def send_requestPickupNumber(self, orderId, providerId):
2536 chandransh 3721 
    self._oprot.writeMessageBegin('requestPickupNumber', TMessageType.CALL, self._seqid)
3722 
    args = requestPickupNumber_args()
3723 
    args.orderId = orderId
4579 rajveer 3724 
    args.providerId = providerId
2536 chandransh 3725 
    args.write(self._oprot)
3726 
    self._oprot.writeMessageEnd()
3727 
    self._oprot.trans.flush()
3728 
 
3729 
  def recv_requestPickupNumber(self, ):
3730 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3731 
    if mtype == TMessageType.EXCEPTION:
3732 
      x = TApplicationException()
3733 
      x.read(self._iprot)
3734 
      self._iprot.readMessageEnd()
3735 
      raise x
3736 
    result = requestPickupNumber_result()
3737 
    result.read(self._iprot)
3738 
    self._iprot.readMessageEnd()
3431 rajveer 3739 
    if result.success is not None:
2536 chandransh 3740 
      return result.success
3431 rajveer 3741 
    if result.ex is not None:
2536 chandransh 3742 
      raise result.ex
3743 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "requestPickupNumber failed: unknown result");
3744 
 
4602 rajveer 3745 
  def authorizePickup(self, orderId, pickupNumber, providerId):
2536 chandransh 3746 
    """
4452 rajveer 3747 
    If the order status is DOA_PICKUP_REQUEST_RAISED, it does the following
2536 chandransh 3748 
    	1. Sends out an email to the customer with the dispatch advice that he has to print as an attachment.
3749 
    	2. Changes order status to be DOA_PICKUP_AUTHORIZED.
3750 
    	3. Returns true
2591 chandransh 3751 
    If the order is in any other status, it returns false.
2536 chandransh 3752 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 3753 
 
2536 chandransh 3754 
    Parameters:
3755 
     - orderId
3756 
     - pickupNumber
4602 rajveer 3757 
     - providerId
2536 chandransh 3758 
    """
4602 rajveer 3759 
    self.send_authorizePickup(orderId, pickupNumber, providerId)
2536 chandransh 3760 
    return self.recv_authorizePickup()
3761 
 
4602 rajveer 3762 
  def send_authorizePickup(self, orderId, pickupNumber, providerId):
2536 chandransh 3763 
    self._oprot.writeMessageBegin('authorizePickup', TMessageType.CALL, self._seqid)
3764 
    args = authorizePickup_args()
3765 
    args.orderId = orderId
3766 
    args.pickupNumber = pickupNumber
4602 rajveer 3767 
    args.providerId = providerId
2536 chandransh 3768 
    args.write(self._oprot)
3769 
    self._oprot.writeMessageEnd()
3770 
    self._oprot.trans.flush()
3771 
 
3772 
  def recv_authorizePickup(self, ):
3773 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3774 
    if mtype == TMessageType.EXCEPTION:
3775 
      x = TApplicationException()
3776 
      x.read(self._iprot)
3777 
      self._iprot.readMessageEnd()
3778 
      raise x
3779 
    result = authorizePickup_result()
3780 
    result.read(self._iprot)
3781 
    self._iprot.readMessageEnd()
3431 rajveer 3782 
    if result.success is not None:
2536 chandransh 3783 
      return result.success
3431 rajveer 3784 
    if result.ex is not None:
2536 chandransh 3785 
      raise result.ex
3786 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "authorizePickup failed: unknown result");
3787 
 
2764 chandransh 3788 
  def markDoasAsPickedUp(self, providerId, pickupDetails):
3789 
    """
3790 
    Marks all DOA_PICKUP_AUTHORIZED orders of the previous day for a provider as DOA_RETURN_IN_TRANSIT.
3431 rajveer 3791 
 
2764 chandransh 3792 
    Parameters:
3793 
     - providerId
3794 
     - pickupDetails
3795 
    """
3796 
    self.send_markDoasAsPickedUp(providerId, pickupDetails)
4910 phani.kuma 3797 
    self.recv_markDoasAsPickedUp()
2764 chandransh 3798 
 
3799 
  def send_markDoasAsPickedUp(self, providerId, pickupDetails):
3800 
    self._oprot.writeMessageBegin('markDoasAsPickedUp', TMessageType.CALL, self._seqid)
3801 
    args = markDoasAsPickedUp_args()
3802 
    args.providerId = providerId
3803 
    args.pickupDetails = pickupDetails
3804 
    args.write(self._oprot)
3805 
    self._oprot.writeMessageEnd()
3806 
    self._oprot.trans.flush()
3807 
 
3808 
  def recv_markDoasAsPickedUp(self, ):
3809 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3810 
    if mtype == TMessageType.EXCEPTION:
3811 
      x = TApplicationException()
3812 
      x.read(self._iprot)
3813 
      self._iprot.readMessageEnd()
3814 
      raise x
3815 
    result = markDoasAsPickedUp_result()
3816 
    result.read(self._iprot)
3817 
    self._iprot.readMessageEnd()
4910 phani.kuma 3818 
    return
3819 
 
3820 
  def getDoasNotPickedUp(self, providerId):
3821 
    """
3822 
    Returns a list of orders that were authorized for pickup but did not appear in the pick-up report.
3823 
 
3824 
    Parameters:
3825 
     - providerId
3826 
    """
3827 
    self.send_getDoasNotPickedUp(providerId)
3828 
    return self.recv_getDoasNotPickedUp()
3829 
 
3830 
  def send_getDoasNotPickedUp(self, providerId):
3831 
    self._oprot.writeMessageBegin('getDoasNotPickedUp', TMessageType.CALL, self._seqid)
3832 
    args = getDoasNotPickedUp_args()
3833 
    args.providerId = providerId
3834 
    args.write(self._oprot)
3835 
    self._oprot.writeMessageEnd()
3836 
    self._oprot.trans.flush()
3837 
 
3838 
  def recv_getDoasNotPickedUp(self, ):
3839 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3840 
    if mtype == TMessageType.EXCEPTION:
3841 
      x = TApplicationException()
3842 
      x.read(self._iprot)
3843 
      self._iprot.readMessageEnd()
3844 
      raise x
3845 
    result = getDoasNotPickedUp_result()
3846 
    result.read(self._iprot)
3847 
    self._iprot.readMessageEnd()
3431 rajveer 3848 
    if result.success is not None:
2764 chandransh 3849 
      return result.success
4910 phani.kuma 3850 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getDoasNotPickedUp failed: unknown result");
2764 chandransh 3851 
 
4741 phani.kuma 3852 
  def markReturnOrdersAsPickedUp(self, providerId, pickupDetails):
3853 
    """
3854 
    Marks all RET_PICKUP_CONFIRMED orders of the previous day for a provider as RET_RETURN_IN_TRANSIT.
3855 
 
3856 
    Parameters:
3857 
     - providerId
3858 
     - pickupDetails
3859 
    """
3860 
    self.send_markReturnOrdersAsPickedUp(providerId, pickupDetails)
4910 phani.kuma 3861 
    self.recv_markReturnOrdersAsPickedUp()
4741 phani.kuma 3862 
 
3863 
  def send_markReturnOrdersAsPickedUp(self, providerId, pickupDetails):
3864 
    self._oprot.writeMessageBegin('markReturnOrdersAsPickedUp', TMessageType.CALL, self._seqid)
3865 
    args = markReturnOrdersAsPickedUp_args()
3866 
    args.providerId = providerId
3867 
    args.pickupDetails = pickupDetails
3868 
    args.write(self._oprot)
3869 
    self._oprot.writeMessageEnd()
3870 
    self._oprot.trans.flush()
3871 
 
3872 
  def recv_markReturnOrdersAsPickedUp(self, ):
3873 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3874 
    if mtype == TMessageType.EXCEPTION:
3875 
      x = TApplicationException()
3876 
      x.read(self._iprot)
3877 
      self._iprot.readMessageEnd()
3878 
      raise x
3879 
    result = markReturnOrdersAsPickedUp_result()
3880 
    result.read(self._iprot)
3881 
    self._iprot.readMessageEnd()
4910 phani.kuma 3882 
    return
3883 
 
3884 
  def getReturnOrdersNotPickedUp(self, providerId):
3885 
    """
3886 
    Returns a list of orders that were authorized for pickup but did not appear in the pick-up report.
3887 
 
3888 
    Parameters:
3889 
     - providerId
3890 
    """
3891 
    self.send_getReturnOrdersNotPickedUp(providerId)
3892 
    return self.recv_getReturnOrdersNotPickedUp()
3893 
 
3894 
  def send_getReturnOrdersNotPickedUp(self, providerId):
3895 
    self._oprot.writeMessageBegin('getReturnOrdersNotPickedUp', TMessageType.CALL, self._seqid)
3896 
    args = getReturnOrdersNotPickedUp_args()
3897 
    args.providerId = providerId
3898 
    args.write(self._oprot)
3899 
    self._oprot.writeMessageEnd()
3900 
    self._oprot.trans.flush()
3901 
 
3902 
  def recv_getReturnOrdersNotPickedUp(self, ):
3903 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3904 
    if mtype == TMessageType.EXCEPTION:
3905 
      x = TApplicationException()
3906 
      x.read(self._iprot)
3907 
      self._iprot.readMessageEnd()
3908 
      raise x
3909 
    result = getReturnOrdersNotPickedUp_result()
3910 
    result.read(self._iprot)
3911 
    self._iprot.readMessageEnd()
4741 phani.kuma 3912 
    if result.success is not None:
3913 
      return result.success
4910 phani.kuma 3914 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReturnOrdersNotPickedUp failed: unknown result");
4741 phani.kuma 3915 
 
4479 rajveer 3916 
  def receiveReturn(self, orderId, receiveCondition):
2591 chandransh 3917 
    """
4452 rajveer 3918 
    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 3919 
    If the order status is RTO_IN_TRANSIT, marks the order status as RTO_RECEIVED_PRESTINE and returns true.
2591 chandransh 3920 
    If the order is in any other state, it returns false.
3921 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 3922 
 
2591 chandransh 3923 
    Parameters:
3924 
     - orderId
4479 rajveer 3925 
     - receiveCondition
2591 chandransh 3926 
    """
4479 rajveer 3927 
    self.send_receiveReturn(orderId, receiveCondition)
2616 chandransh 3928 
    return self.recv_receiveReturn()
2536 chandransh 3929 
 
4479 rajveer 3930 
  def send_receiveReturn(self, orderId, receiveCondition):
2616 chandransh 3931 
    self._oprot.writeMessageBegin('receiveReturn', TMessageType.CALL, self._seqid)
3932 
    args = receiveReturn_args()
2591 chandransh 3933 
    args.orderId = orderId
4479 rajveer 3934 
    args.receiveCondition = receiveCondition
2591 chandransh 3935 
    args.write(self._oprot)
3936 
    self._oprot.writeMessageEnd()
3937 
    self._oprot.trans.flush()
3938 
 
2616 chandransh 3939 
  def recv_receiveReturn(self, ):
2591 chandransh 3940 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3941 
    if mtype == TMessageType.EXCEPTION:
3942 
      x = TApplicationException()
3943 
      x.read(self._iprot)
3944 
      self._iprot.readMessageEnd()
3945 
      raise x
2616 chandransh 3946 
    result = receiveReturn_result()
2591 chandransh 3947 
    result.read(self._iprot)
3948 
    self._iprot.readMessageEnd()
3431 rajveer 3949 
    if result.success is not None:
2591 chandransh 3950 
      return result.success
3431 rajveer 3951 
    if result.ex is not None:
2591 chandransh 3952 
      raise result.ex
2616 chandransh 3953 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "receiveReturn failed: unknown result");
2591 chandransh 3954 
 
3955 
  def validateDoa(self, orderId, isValid):
3956 
    """
4452 rajveer 3957 
    Used to validate the DOA certificate for an order in the DOA_RECEIVED_PRESTINE state. If the certificate is valid,
2616 chandransh 3958 
    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 3959 
    If the order is in any other state, it returns false.
3960 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 3961 
 
2591 chandransh 3962 
    Parameters:
3963 
     - orderId
3964 
     - isValid
3965 
    """
3966 
    self.send_validateDoa(orderId, isValid)
3967 
    return self.recv_validateDoa()
3968 
 
3969 
  def send_validateDoa(self, orderId, isValid):
3970 
    self._oprot.writeMessageBegin('validateDoa', TMessageType.CALL, self._seqid)
3971 
    args = validateDoa_args()
3972 
    args.orderId = orderId
3973 
    args.isValid = isValid
3974 
    args.write(self._oprot)
3975 
    self._oprot.writeMessageEnd()
3976 
    self._oprot.trans.flush()
3977 
 
3978 
  def recv_validateDoa(self, ):
3979 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3980 
    if mtype == TMessageType.EXCEPTION:
3981 
      x = TApplicationException()
3982 
      x.read(self._iprot)
3983 
      self._iprot.readMessageEnd()
3984 
      raise x
3985 
    result = validateDoa_result()
3986 
    result.read(self._iprot)
3987 
    self._iprot.readMessageEnd()
3431 rajveer 3988 
    if result.success is not None:
2591 chandransh 3989 
      return result.success
3431 rajveer 3990 
    if result.ex is not None:
2591 chandransh 3991 
      raise result.ex
3992 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "validateDoa failed: unknown result");
3993 
 
4495 rajveer 3994 
  def validateReturnProduct(self, orderId, isUsable):
3995 
    """
3996 
    Parameters:
3997 
     - orderId
3998 
     - isUsable
3999 
    """
4000 
    self.send_validateReturnProduct(orderId, isUsable)
4001 
    return self.recv_validateReturnProduct()
4002 
 
4003 
  def send_validateReturnProduct(self, orderId, isUsable):
4004 
    self._oprot.writeMessageBegin('validateReturnProduct', TMessageType.CALL, self._seqid)
4005 
    args = validateReturnProduct_args()
4006 
    args.orderId = orderId
4007 
    args.isUsable = isUsable
4008 
    args.write(self._oprot)
4009 
    self._oprot.writeMessageEnd()
4010 
    self._oprot.trans.flush()
4011 
 
4012 
  def recv_validateReturnProduct(self, ):
4013 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4014 
    if mtype == TMessageType.EXCEPTION:
4015 
      x = TApplicationException()
4016 
      x.read(self._iprot)
4017 
      self._iprot.readMessageEnd()
4018 
      raise x
4019 
    result = validateReturnProduct_result()
4020 
    result.read(self._iprot)
4021 
    self._iprot.readMessageEnd()
4022 
    if result.success is not None:
4023 
      return result.success
4024 
    if result.ex is not None:
4025 
      raise result.ex
4026 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "validateReturnProduct failed: unknown result");
4027 
 
2616 chandransh 4028 
  def reshipOrder(self, orderId):
4029 
    """
4484 rajveer 4030 
    If the order is in RTO_RECEIVED_PRESTINE or DOA_CERT_INVALID state, it does the following:
2616 chandransh 4031 
    	1. Creates a new order for processing in the BILLED state. All billing information is saved.
4484 rajveer 4032 
    	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 4033 
 
4034 
    If the order is in DOA_CERT_VALID state, it does the following:
4035 
    	1. Creates a new order for processing in the SUBMITTED_FOR_PROCESSING state.
4036 
    	2. Creates a return order for the warehouse executive to return the DOA material.
4452 rajveer 4037 
    	3. Marks the current order as the final DOA_VALID_RESHIPPED state.
3431 rajveer 4038 
 
2616 chandransh 4039 
    Returns the id of the newly created order.
3431 rajveer 4040 
 
2616 chandransh 4041 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 4042 
 
2616 chandransh 4043 
    Parameters:
4044 
     - orderId
4045 
    """
4046 
    self.send_reshipOrder(orderId)
4047 
    return self.recv_reshipOrder()
2591 chandransh 4048 
 
2616 chandransh 4049 
  def send_reshipOrder(self, orderId):
4050 
    self._oprot.writeMessageBegin('reshipOrder', TMessageType.CALL, self._seqid)
4051 
    args = reshipOrder_args()
4052 
    args.orderId = orderId
4053 
    args.write(self._oprot)
4054 
    self._oprot.writeMessageEnd()
4055 
    self._oprot.trans.flush()
4056 
 
4057 
  def recv_reshipOrder(self, ):
4058 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4059 
    if mtype == TMessageType.EXCEPTION:
4060 
      x = TApplicationException()
4061 
      x.read(self._iprot)
4062 
      self._iprot.readMessageEnd()
4063 
      raise x
4064 
    result = reshipOrder_result()
4065 
    result.read(self._iprot)
4066 
    self._iprot.readMessageEnd()
3431 rajveer 4067 
    if result.success is not None:
2616 chandransh 4068 
      return result.success
3431 rajveer 4069 
    if result.ex is not None:
2616 chandransh 4070 
      raise result.ex
4071 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "reshipOrder failed: unknown result");
4072 
 
3226 chandransh 4073 
  def refundOrder(self, orderId, refundedBy, reason):
2616 chandransh 4074 
    """
4484 rajveer 4075 
    If the order is in RTO_RECEIVED_PRESTINE, DOA_CERT_VALID or DOA_CERT_INVALID state, it does the following:
2616 chandransh 4076 
    	1. Creates a refund request for batch processing.
4077 
    	2. Creates a return order for the warehouse executive to return the shipped material.
4484 rajveer 4078 
    	3. Marks the current order as RTO_REFUNDED, DOA_VALID_REFUNDED or DOA_INVALID_REFUNDED final states.
3431 rajveer 4079 
 
2616 chandransh 4080 
    If the order is in SUBMITTED_FOR_PROCESSING or INVENTORY_LOW state, it does the following:
4081 
    	1. Creates a refund request for batch processing.
3226 chandransh 4082 
    	2. Cancels the reservation of the item in the warehouse.
4083 
    	3. Marks the current order as the REFUNDED final state.
3431 rajveer 4084 
 
3226 chandransh 4085 
    For all COD orders, if the order is in INIT, SUBMITTED_FOR_PROCESSING or INVENTORY_LOW state, it does the following:
4086 
    	1. Cancels the reservation of the item in the warehouse.
4087 
    	2. Marks the current order as CANCELED.
4088 
 
4089 
    In all cases, it updates the reason for cancellation or refund and the person who performed the action.
4090 
 
2616 chandransh 4091 
    Returns True if it is successful, False otherwise.
3431 rajveer 4092 
 
2616 chandransh 4093 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 4094 
 
2616 chandransh 4095 
    Parameters:
4096 
     - orderId
3226 chandransh 4097 
     - refundedBy
4098 
     - reason
2616 chandransh 4099 
    """
3226 chandransh 4100 
    self.send_refundOrder(orderId, refundedBy, reason)
2616 chandransh 4101 
    return self.recv_refundOrder()
4102 
 
3226 chandransh 4103 
  def send_refundOrder(self, orderId, refundedBy, reason):
2616 chandransh 4104 
    self._oprot.writeMessageBegin('refundOrder', TMessageType.CALL, self._seqid)
4105 
    args = refundOrder_args()
4106 
    args.orderId = orderId
3226 chandransh 4107 
    args.refundedBy = refundedBy
4108 
    args.reason = reason
2616 chandransh 4109 
    args.write(self._oprot)
4110 
    self._oprot.writeMessageEnd()
4111 
    self._oprot.trans.flush()
4112 
 
4113 
  def recv_refundOrder(self, ):
4114 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4115 
    if mtype == TMessageType.EXCEPTION:
4116 
      x = TApplicationException()
4117 
      x.read(self._iprot)
4118 
      self._iprot.readMessageEnd()
4119 
      raise x
4120 
    result = refundOrder_result()
4121 
    result.read(self._iprot)
4122 
    self._iprot.readMessageEnd()
3431 rajveer 4123 
    if result.success is not None:
2616 chandransh 4124 
      return result.success
3431 rajveer 4125 
    if result.ex is not None:
2616 chandransh 4126 
      raise result.ex
4127 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "refundOrder failed: unknown result");
4128 
 
2690 chandransh 4129 
  def getReturnOrders(self, warehouseId, fromDate, toDate):
4130 
    """
4131 
    Get all return orders created between the from and to dates for the given warehouse.
4132 
    Ignores the warehouse if it is passed as -1.
3431 rajveer 4133 
 
2690 chandransh 4134 
    Parameters:
4135 
     - warehouseId
4136 
     - fromDate
4137 
     - toDate
4138 
    """
4139 
    self.send_getReturnOrders(warehouseId, fromDate, toDate)
4140 
    return self.recv_getReturnOrders()
2616 chandransh 4141 
 
2690 chandransh 4142 
  def send_getReturnOrders(self, warehouseId, fromDate, toDate):
4143 
    self._oprot.writeMessageBegin('getReturnOrders', TMessageType.CALL, self._seqid)
4144 
    args = getReturnOrders_args()
4145 
    args.warehouseId = warehouseId
4146 
    args.fromDate = fromDate
4147 
    args.toDate = toDate
4148 
    args.write(self._oprot)
4149 
    self._oprot.writeMessageEnd()
4150 
    self._oprot.trans.flush()
4151 
 
4152 
  def recv_getReturnOrders(self, ):
4153 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4154 
    if mtype == TMessageType.EXCEPTION:
4155 
      x = TApplicationException()
4156 
      x.read(self._iprot)
4157 
      self._iprot.readMessageEnd()
4158 
      raise x
4159 
    result = getReturnOrders_result()
4160 
    result.read(self._iprot)
4161 
    self._iprot.readMessageEnd()
3431 rajveer 4162 
    if result.success is not None:
2690 chandransh 4163 
      return result.success
4164 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReturnOrders failed: unknown result");
4165 
 
5481 phani.kuma 4166 
  def getAllReturnOrders(self, onlyNotProcessed, fromDate, toDate):
4167 
    """
4168 
    Get all return orders created between the from and to dates.
4169 
 
4170 
    Parameters:
4171 
     - onlyNotProcessed
4172 
     - fromDate
4173 
     - toDate
4174 
    """
4175 
    self.send_getAllReturnOrders(onlyNotProcessed, fromDate, toDate)
4176 
    return self.recv_getAllReturnOrders()
4177 
 
4178 
  def send_getAllReturnOrders(self, onlyNotProcessed, fromDate, toDate):
4179 
    self._oprot.writeMessageBegin('getAllReturnOrders', TMessageType.CALL, self._seqid)
4180 
    args = getAllReturnOrders_args()
4181 
    args.onlyNotProcessed = onlyNotProcessed
4182 
    args.fromDate = fromDate
4183 
    args.toDate = toDate
4184 
    args.write(self._oprot)
4185 
    self._oprot.writeMessageEnd()
4186 
    self._oprot.trans.flush()
4187 
 
4188 
  def recv_getAllReturnOrders(self, ):
4189 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4190 
    if mtype == TMessageType.EXCEPTION:
4191 
      x = TApplicationException()
4192 
      x.read(self._iprot)
4193 
      self._iprot.readMessageEnd()
4194 
      raise x
4195 
    result = getAllReturnOrders_result()
4196 
    result.read(self._iprot)
4197 
    self._iprot.readMessageEnd()
4198 
    if result.success is not None:
4199 
      return result.success
4200 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllReturnOrders failed: unknown result");
4201 
 
2700 chandransh 4202 
  def getReturnOrder(self, id):
4203 
    """
4204 
    Returns the ReturnOrder corresponding to the given id.
4205 
    Throws an exception if the return order with the given id couldn't be found.
3431 rajveer 4206 
 
2700 chandransh 4207 
    Parameters:
4208 
     - id
4209 
    """
4210 
    self.send_getReturnOrder(id)
4211 
    return self.recv_getReturnOrder()
4212 
 
4213 
  def send_getReturnOrder(self, id):
4214 
    self._oprot.writeMessageBegin('getReturnOrder', TMessageType.CALL, self._seqid)
4215 
    args = getReturnOrder_args()
4216 
    args.id = id
4217 
    args.write(self._oprot)
4218 
    self._oprot.writeMessageEnd()
4219 
    self._oprot.trans.flush()
4220 
 
4221 
  def recv_getReturnOrder(self, ):
4222 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4223 
    if mtype == TMessageType.EXCEPTION:
4224 
      x = TApplicationException()
4225 
      x.read(self._iprot)
4226 
      self._iprot.readMessageEnd()
4227 
      raise x
4228 
    result = getReturnOrder_result()
4229 
    result.read(self._iprot)
4230 
    self._iprot.readMessageEnd()
3431 rajveer 4231 
    if result.success is not None:
2700 chandransh 4232 
      return result.success
3431 rajveer 4233 
    if result.ex is not None:
2700 chandransh 4234 
      raise result.ex
4235 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReturnOrder failed: unknown result");
4236 
 
2690 chandransh 4237 
  def processReturn(self, returnOrderId):
4238 
    """
4239 
    Marks the return order with the given id as processed. Raises an exception if no such return order exists.
3431 rajveer 4240 
 
2690 chandransh 4241 
    Parameters:
4242 
     - returnOrderId
4243 
    """
4244 
    self.send_processReturn(returnOrderId)
4245 
    self.recv_processReturn()
4246 
 
4247 
  def send_processReturn(self, returnOrderId):
4248 
    self._oprot.writeMessageBegin('processReturn', TMessageType.CALL, self._seqid)
4249 
    args = processReturn_args()
4250 
    args.returnOrderId = returnOrderId
4251 
    args.write(self._oprot)
4252 
    self._oprot.writeMessageEnd()
4253 
    self._oprot.trans.flush()
4254 
 
4255 
  def recv_processReturn(self, ):
4256 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4257 
    if mtype == TMessageType.EXCEPTION:
4258 
      x = TApplicationException()
4259 
      x.read(self._iprot)
4260 
      self._iprot.readMessageEnd()
4261 
      raise x
4262 
    result = processReturn_result()
4263 
    result.read(self._iprot)
4264 
    self._iprot.readMessageEnd()
3431 rajveer 4265 
    if result.ex is not None:
2690 chandransh 4266 
      raise result.ex
4267 
    return
4268 
 
3451 chandransh 4269 
  def updateWeight(self, orderId, weight):
4270 
    """
4271 
    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 4272 
 
3451 chandransh 4273 
    Parameters:
4274 
     - orderId
4275 
     - weight
4276 
    """
4277 
    self.send_updateWeight(orderId, weight)
4278 
    return self.recv_updateWeight()
4279 
 
4280 
  def send_updateWeight(self, orderId, weight):
4281 
    self._oprot.writeMessageBegin('updateWeight', TMessageType.CALL, self._seqid)
4282 
    args = updateWeight_args()
4283 
    args.orderId = orderId
4284 
    args.weight = weight
4285 
    args.write(self._oprot)
4286 
    self._oprot.writeMessageEnd()
4287 
    self._oprot.trans.flush()
4288 
 
4289 
  def recv_updateWeight(self, ):
4290 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4291 
    if mtype == TMessageType.EXCEPTION:
4292 
      x = TApplicationException()
4293 
      x.read(self._iprot)
4294 
      self._iprot.readMessageEnd()
4295 
      raise x
4296 
    result = updateWeight_result()
4297 
    result.read(self._iprot)
4298 
    self._iprot.readMessageEnd()
4299 
    if result.success is not None:
4300 
      return result.success
4301 
    if result.ex is not None:
4302 
      raise result.ex
4303 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updateWeight failed: unknown result");
4304 
 
3469 chandransh 4305 
  def changeItem(self, orderId, itemId):
4306 
    """
4307 
    Change the item to be shipped for this order. Also adjusts the reservation in the inventory accordingly.
4308 
    Currently, it also ensures that only a different color of the given item is shipped.
3451 chandransh 4309 
 
3469 chandransh 4310 
    Parameters:
4311 
     - orderId
4312 
     - itemId
4313 
    """
4314 
    self.send_changeItem(orderId, itemId)
4315 
    return self.recv_changeItem()
4316 
 
4317 
  def send_changeItem(self, orderId, itemId):
4318 
    self._oprot.writeMessageBegin('changeItem', TMessageType.CALL, self._seqid)
4319 
    args = changeItem_args()
4320 
    args.orderId = orderId
4321 
    args.itemId = itemId
4322 
    args.write(self._oprot)
4323 
    self._oprot.writeMessageEnd()
4324 
    self._oprot.trans.flush()
4325 
 
4326 
  def recv_changeItem(self, ):
4327 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4328 
    if mtype == TMessageType.EXCEPTION:
4329 
      x = TApplicationException()
4330 
      x.read(self._iprot)
4331 
      self._iprot.readMessageEnd()
4332 
      raise x
4333 
    result = changeItem_result()
4334 
    result.read(self._iprot)
4335 
    self._iprot.readMessageEnd()
4336 
    if result.success is not None:
4337 
      return result.success
4338 
    if result.ex is not None:
4339 
      raise result.ex
4340 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "changeItem failed: unknown result");
4341 
 
4342 
  def shiftToWarehouse(self, orderId, warehouseId):
4343 
    """
4344 
    Moves the given order to the given warehouse. Also adjusts the inventory reservations accordingly.
4345 
 
4346 
    Parameters:
4347 
     - orderId
4348 
     - warehouseId
4349 
    """
4350 
    self.send_shiftToWarehouse(orderId, warehouseId)
4351 
    return self.recv_shiftToWarehouse()
4352 
 
4353 
  def send_shiftToWarehouse(self, orderId, warehouseId):
4354 
    self._oprot.writeMessageBegin('shiftToWarehouse', TMessageType.CALL, self._seqid)
4355 
    args = shiftToWarehouse_args()
4356 
    args.orderId = orderId
4357 
    args.warehouseId = warehouseId
4358 
    args.write(self._oprot)
4359 
    self._oprot.writeMessageEnd()
4360 
    self._oprot.trans.flush()
4361 
 
4362 
  def recv_shiftToWarehouse(self, ):
4363 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4364 
    if mtype == TMessageType.EXCEPTION:
4365 
      x = TApplicationException()
4366 
      x.read(self._iprot)
4367 
      self._iprot.readMessageEnd()
4368 
      raise x
4369 
    result = shiftToWarehouse_result()
4370 
    result.read(self._iprot)
4371 
    self._iprot.readMessageEnd()
4372 
    if result.success is not None:
4373 
      return result.success
4374 
    if result.ex is not None:
4375 
      raise result.ex
4376 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "shiftToWarehouse failed: unknown result");
4377 
 
4647 rajveer 4378 
  def addDelayReason(self, orderId, delayReason, furtherDelay, delayReasonText):
3553 chandransh 4379 
    """
4380 
    Adds the given delay reason to the given order.
3986 chandransh 4381 
    Increases the expected delivery time of the given order by the given no. of days.
3553 chandransh 4382 
    Raises an exception if no order with the given id can be found.
3469 chandransh 4383 
 
3553 chandransh 4384 
    Parameters:
4385 
     - orderId
4386 
     - delayReason
3986 chandransh 4387 
     - furtherDelay
4647 rajveer 4388 
     - delayReasonText
3553 chandransh 4389 
    """
4647 rajveer 4390 
    self.send_addDelayReason(orderId, delayReason, furtherDelay, delayReasonText)
3553 chandransh 4391 
    return self.recv_addDelayReason()
4392 
 
4647 rajveer 4393 
  def send_addDelayReason(self, orderId, delayReason, furtherDelay, delayReasonText):
3553 chandransh 4394 
    self._oprot.writeMessageBegin('addDelayReason', TMessageType.CALL, self._seqid)
4395 
    args = addDelayReason_args()
4396 
    args.orderId = orderId
4397 
    args.delayReason = delayReason
3986 chandransh 4398 
    args.furtherDelay = furtherDelay
4647 rajveer 4399 
    args.delayReasonText = delayReasonText
3553 chandransh 4400 
    args.write(self._oprot)
4401 
    self._oprot.writeMessageEnd()
4402 
    self._oprot.trans.flush()
4403 
 
4404 
  def recv_addDelayReason(self, ):
4405 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4406 
    if mtype == TMessageType.EXCEPTION:
4407 
      x = TApplicationException()
4408 
      x.read(self._iprot)
4409 
      self._iprot.readMessageEnd()
4410 
      raise x
4411 
    result = addDelayReason_result()
4412 
    result.read(self._iprot)
4413 
    self._iprot.readMessageEnd()
4414 
    if result.success is not None:
4415 
      return result.success
4416 
    if result.ex is not None:
4417 
      raise result.ex
4418 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addDelayReason failed: unknown result");
4419 
 
3956 chandransh 4420 
  def reconcileCodCollection(self, collectedAmountMap, xferBy, xferTxnId, xferDate):
4421 
    """
4422 
    Marks the COD orders with given AWB nos. as having been processed.
4423 
    Updates the captured amount for the corresponding payment.
3553 chandransh 4424 
 
3956 chandransh 4425 
    Returns a map of AWBs which were not processed and the associated reason. An AWB is not processed if:
4426 
    1. There is no order corresponding to an AWB number.
4427 
    2. The captured amount for a payment exceeds the total payment.
4428 
    3. The order corresponding to an AWB no. is in a state prior to DELIVERY_SUCCESS.
4429 
 
4430 
    Parameters:
4431 
     - collectedAmountMap
4432 
     - xferBy
4433 
     - xferTxnId
4434 
     - xferDate
4435 
    """
4436 
    self.send_reconcileCodCollection(collectedAmountMap, xferBy, xferTxnId, xferDate)
4437 
    return self.recv_reconcileCodCollection()
4438 
 
4439 
  def send_reconcileCodCollection(self, collectedAmountMap, xferBy, xferTxnId, xferDate):
4440 
    self._oprot.writeMessageBegin('reconcileCodCollection', TMessageType.CALL, self._seqid)
4441 
    args = reconcileCodCollection_args()
4442 
    args.collectedAmountMap = collectedAmountMap
4443 
    args.xferBy = xferBy
4444 
    args.xferTxnId = xferTxnId
4445 
    args.xferDate = xferDate
4446 
    args.write(self._oprot)
4447 
    self._oprot.writeMessageEnd()
4448 
    self._oprot.trans.flush()
4449 
 
4450 
  def recv_reconcileCodCollection(self, ):
4451 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4452 
    if mtype == TMessageType.EXCEPTION:
4453 
      x = TApplicationException()
4454 
      x.read(self._iprot)
4455 
      self._iprot.readMessageEnd()
4456 
      raise x
4457 
    result = reconcileCodCollection_result()
4458 
    result.read(self._iprot)
4459 
    self._iprot.readMessageEnd()
4460 
    if result.success is not None:
4461 
      return result.success
4462 
    if result.ex is not None:
4463 
      raise result.ex
4464 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "reconcileCodCollection failed: unknown result");
4465 
 
4008 mandeep.dh 4466 
  def getTransactionsRequiringExtraProcessing(self, category):
4467 
    """
4065 mandeep.dh 4468 
    Returns the list of transaction ids that require some extra processing and
4008 mandeep.dh 4469 
    which belong to a particular category. This is currently used by CRM
4065 mandeep.dh 4470 
    application. If no such transaction ids are present, it returns an empty list.
3956 chandransh 4471 
 
4008 mandeep.dh 4472 
    Parameters:
4473 
     - category
4474 
    """
4475 
    self.send_getTransactionsRequiringExtraProcessing(category)
4476 
    return self.recv_getTransactionsRequiringExtraProcessing()
4477 
 
4478 
  def send_getTransactionsRequiringExtraProcessing(self, category):
4479 
    self._oprot.writeMessageBegin('getTransactionsRequiringExtraProcessing', TMessageType.CALL, self._seqid)
4480 
    args = getTransactionsRequiringExtraProcessing_args()
4481 
    args.category = category
4482 
    args.write(self._oprot)
4483 
    self._oprot.writeMessageEnd()
4484 
    self._oprot.trans.flush()
4485 
 
4486 
  def recv_getTransactionsRequiringExtraProcessing(self, ):
4487 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4488 
    if mtype == TMessageType.EXCEPTION:
4489 
      x = TApplicationException()
4490 
      x.read(self._iprot)
4491 
      self._iprot.readMessageEnd()
4492 
      raise x
4493 
    result = getTransactionsRequiringExtraProcessing_result()
4494 
    result.read(self._iprot)
4495 
    self._iprot.readMessageEnd()
4496 
    if result.success is not None:
4497 
      return result.success
4498 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransactionsRequiringExtraProcessing failed: unknown result");
4499 
 
4500 
  def markTransactionAsProcessed(self, transactionId, category):
4501 
    """
4502 
    Marks a particular transaction as processed for a particular cateogory.
4065 mandeep.dh 4503 
    It essentially deletes the transaction id record for a particular
4504 
    processing type category (if present) from DB.
4505 
    This is currently used by CRM application.
4008 mandeep.dh 4506 
 
4507 
    Parameters:
4508 
     - transactionId
4509 
     - category
4510 
    """
4511 
    self.send_markTransactionAsProcessed(transactionId, category)
4512 
    self.recv_markTransactionAsProcessed()
4513 
 
4514 
  def send_markTransactionAsProcessed(self, transactionId, category):
4515 
    self._oprot.writeMessageBegin('markTransactionAsProcessed', TMessageType.CALL, self._seqid)
4516 
    args = markTransactionAsProcessed_args()
4517 
    args.transactionId = transactionId
4518 
    args.category = category
4519 
    args.write(self._oprot)
4520 
    self._oprot.writeMessageEnd()
4521 
    self._oprot.trans.flush()
4522 
 
4523 
  def recv_markTransactionAsProcessed(self, ):
4524 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4525 
    if mtype == TMessageType.EXCEPTION:
4526 
      x = TApplicationException()
4527 
      x.read(self._iprot)
4528 
      self._iprot.readMessageEnd()
4529 
      raise x
4530 
    result = markTransactionAsProcessed_result()
4531 
    result.read(self._iprot)
4532 
    self._iprot.readMessageEnd()
4533 
    return
4534 
 
4018 chandransh 4535 
  def getItemWiseRiskyOrdersCount(self, ):
4536 
    """
4537 
    Returns a map containing the number of risky orders keyed by item id. A risky order
4538 
    is defined as one whose shipping date is about to expire.
4539 
    """
4540 
    self.send_getItemWiseRiskyOrdersCount()
4541 
    return self.recv_getItemWiseRiskyOrdersCount()
4008 mandeep.dh 4542 
 
4018 chandransh 4543 
  def send_getItemWiseRiskyOrdersCount(self, ):
4544 
    self._oprot.writeMessageBegin('getItemWiseRiskyOrdersCount', TMessageType.CALL, self._seqid)
4545 
    args = getItemWiseRiskyOrdersCount_args()
4546 
    args.write(self._oprot)
4547 
    self._oprot.writeMessageEnd()
4548 
    self._oprot.trans.flush()
4549 
 
4550 
  def recv_getItemWiseRiskyOrdersCount(self, ):
4551 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4552 
    if mtype == TMessageType.EXCEPTION:
4553 
      x = TApplicationException()
4554 
      x.read(self._iprot)
4555 
      self._iprot.readMessageEnd()
4556 
      raise x
4557 
    result = getItemWiseRiskyOrdersCount_result()
4558 
    result.read(self._iprot)
4559 
    self._iprot.readMessageEnd()
4560 
    if result.success is not None:
4561 
      return result.success
4562 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItemWiseRiskyOrdersCount failed: unknown result");
4563 
 
4295 varun.gupt 4564 
  def getOrdersForItemIds(self, itemIds):
4565 
    """
4566 
    Returns a list of all orders which have items with given id
4567 
 
4568 
    Parameters:
4569 
     - itemIds
4570 
    """
4571 
    self.send_getOrdersForItemIds(itemIds)
4572 
    return self.recv_getOrdersForItemIds()
4573 
 
4574 
  def send_getOrdersForItemIds(self, itemIds):
4575 
    self._oprot.writeMessageBegin('getOrdersForItemIds', TMessageType.CALL, self._seqid)
4576 
    args = getOrdersForItemIds_args()
4577 
    args.itemIds = itemIds
4578 
    args.write(self._oprot)
4579 
    self._oprot.writeMessageEnd()
4580 
    self._oprot.trans.flush()
4581 
 
4582 
  def recv_getOrdersForItemIds(self, ):
4583 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4584 
    if mtype == TMessageType.EXCEPTION:
4585 
      x = TApplicationException()
4586 
      x.read(self._iprot)
4587 
      self._iprot.readMessageEnd()
4588 
      raise x
4589 
    result = getOrdersForItemIds_result()
4590 
    result.read(self._iprot)
4591 
    self._iprot.readMessageEnd()
4592 
    if result.success is not None:
4593 
      return result.success
4594 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersForItemIds failed: unknown result");
4595 
 
4247 rajveer 4596 
  def markOrderCancellationRequestReceived(self, orderId):
4597 
    """
4598 
    Mark order as cancellation request received. If customer sends request of cancellation of
4599 
    a particular order, this method will be called. It will just change status of the order
4600 
    depending on its current status. It also records the previous status, so that we can move
4601 
    back to that status if cancellation request is denied.
4018 chandransh 4602 
 
4247 rajveer 4603 
    Parameters:
4604 
     - orderId
4605 
    """
4606 
    self.send_markOrderCancellationRequestReceived(orderId)
4607 
    self.recv_markOrderCancellationRequestReceived()
4608 
 
4609 
  def send_markOrderCancellationRequestReceived(self, orderId):
4610 
    self._oprot.writeMessageBegin('markOrderCancellationRequestReceived', TMessageType.CALL, self._seqid)
4611 
    args = markOrderCancellationRequestReceived_args()
4612 
    args.orderId = orderId
4613 
    args.write(self._oprot)
4614 
    self._oprot.writeMessageEnd()
4615 
    self._oprot.trans.flush()
4616 
 
4617 
  def recv_markOrderCancellationRequestReceived(self, ):
4618 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4619 
    if mtype == TMessageType.EXCEPTION:
4620 
      x = TApplicationException()
4621 
      x.read(self._iprot)
4622 
      self._iprot.readMessageEnd()
4623 
      raise x
4624 
    result = markOrderCancellationRequestReceived_result()
4625 
    result.read(self._iprot)
4626 
    self._iprot.readMessageEnd()
4627 
    if result.ex is not None:
4628 
      raise result.ex
4629 
    return
4630 
 
4631 
  def markOrderCancellationRequestConfirmed(self, orderId):
4632 
    """
4633 
    If we decide to to cancel order, CRM will call this method to move the status of order to
4634 
    cancellation request confirmed. After this OM will be able to cancel the order.
4635 
 
4636 
    Parameters:
4637 
     - orderId
4638 
    """
4639 
    self.send_markOrderCancellationRequestConfirmed(orderId)
4640 
    self.recv_markOrderCancellationRequestConfirmed()
4641 
 
4642 
  def send_markOrderCancellationRequestConfirmed(self, orderId):
4643 
    self._oprot.writeMessageBegin('markOrderCancellationRequestConfirmed', TMessageType.CALL, self._seqid)
4644 
    args = markOrderCancellationRequestConfirmed_args()
4645 
    args.orderId = orderId
4646 
    args.write(self._oprot)
4647 
    self._oprot.writeMessageEnd()
4648 
    self._oprot.trans.flush()
4649 
 
4650 
  def recv_markOrderCancellationRequestConfirmed(self, ):
4651 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4652 
    if mtype == TMessageType.EXCEPTION:
4653 
      x = TApplicationException()
4654 
      x.read(self._iprot)
4655 
      self._iprot.readMessageEnd()
4656 
      raise x
4657 
    result = markOrderCancellationRequestConfirmed_result()
4658 
    result.read(self._iprot)
4659 
    self._iprot.readMessageEnd()
4660 
    if result.ex is not None:
4661 
      raise result.ex
4662 
    return
4663 
 
4664 
  def markOrderCancellationRequestDenied(self, orderId):
4665 
    """
4666 
    If we decide to not to cancel order, we will move the order ro previous status.
4667 
 
4668 
    Parameters:
4669 
     - orderId
4670 
    """
4671 
    self.send_markOrderCancellationRequestDenied(orderId)
4672 
    self.recv_markOrderCancellationRequestDenied()
4673 
 
4674 
  def send_markOrderCancellationRequestDenied(self, orderId):
4675 
    self._oprot.writeMessageBegin('markOrderCancellationRequestDenied', TMessageType.CALL, self._seqid)
4676 
    args = markOrderCancellationRequestDenied_args()
4677 
    args.orderId = orderId
4678 
    args.write(self._oprot)
4679 
    self._oprot.writeMessageEnd()
4680 
    self._oprot.trans.flush()
4681 
 
4682 
  def recv_markOrderCancellationRequestDenied(self, ):
4683 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4684 
    if mtype == TMessageType.EXCEPTION:
4685 
      x = TApplicationException()
4686 
      x.read(self._iprot)
4687 
      self._iprot.readMessageEnd()
4688 
      raise x
4689 
    result = markOrderCancellationRequestDenied_result()
4690 
    result.read(self._iprot)
4691 
    self._iprot.readMessageEnd()
4692 
    if result.ex is not None:
4693 
      raise result.ex
4694 
    return
4695 
 
4258 rajveer 4696 
  def markTransactionAsPaymentFlagRemoved(self, transactionId):
4247 rajveer 4697 
    """
4258 rajveer 4698 
    If we and/or payment gateway has decided to accept the payment, this method needs to be called.
4699 
    Changed transaction and all orders status to payment accepted.
4247 rajveer 4700 
 
4701 
    Parameters:
4258 rajveer 4702 
     - transactionId
4247 rajveer 4703 
    """
4258 rajveer 4704 
    self.send_markTransactionAsPaymentFlagRemoved(transactionId)
4705 
    self.recv_markTransactionAsPaymentFlagRemoved()
4247 rajveer 4706 
 
4258 rajveer 4707 
  def send_markTransactionAsPaymentFlagRemoved(self, transactionId):
4708 
    self._oprot.writeMessageBegin('markTransactionAsPaymentFlagRemoved', TMessageType.CALL, self._seqid)
4709 
    args = markTransactionAsPaymentFlagRemoved_args()
4710 
    args.transactionId = transactionId
4247 rajveer 4711 
    args.write(self._oprot)
4712 
    self._oprot.writeMessageEnd()
4713 
    self._oprot.trans.flush()
4714 
 
4258 rajveer 4715 
  def recv_markTransactionAsPaymentFlagRemoved(self, ):
4247 rajveer 4716 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4717 
    if mtype == TMessageType.EXCEPTION:
4718 
      x = TApplicationException()
4719 
      x.read(self._iprot)
4720 
      self._iprot.readMessageEnd()
4721 
      raise x
4258 rajveer 4722 
    result = markTransactionAsPaymentFlagRemoved_result()
4247 rajveer 4723 
    result.read(self._iprot)
4724 
    self._iprot.readMessageEnd()
4725 
    if result.ex is not None:
4726 
      raise result.ex
4727 
    return
4728 
 
4259 anupam.sin 4729 
  def refundTransaction(self, transactionId, refundedBy, reason):
4730 
    """
4731 
    This method is called when a flagged payment is deemed unserviceable and the corresponding orders
4732 
    need to be cancelled
4247 rajveer 4733 
 
4259 anupam.sin 4734 
    Parameters:
4735 
     - transactionId
4736 
     - refundedBy
4737 
     - reason
4738 
    """
4739 
    self.send_refundTransaction(transactionId, refundedBy, reason)
4740 
    self.recv_refundTransaction()
4741 
 
4742 
  def send_refundTransaction(self, transactionId, refundedBy, reason):
4743 
    self._oprot.writeMessageBegin('refundTransaction', TMessageType.CALL, self._seqid)
4744 
    args = refundTransaction_args()
4745 
    args.transactionId = transactionId
4746 
    args.refundedBy = refundedBy
4747 
    args.reason = reason
4748 
    args.write(self._oprot)
4749 
    self._oprot.writeMessageEnd()
4750 
    self._oprot.trans.flush()
4751 
 
4752 
  def recv_refundTransaction(self, ):
4753 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4754 
    if mtype == TMessageType.EXCEPTION:
4755 
      x = TApplicationException()
4756 
      x.read(self._iprot)
4757 
      self._iprot.readMessageEnd()
4758 
      raise x
4759 
    result = refundTransaction_result()
4760 
    result.read(self._iprot)
4761 
    self._iprot.readMessageEnd()
4762 
    if result.ex is not None:
4763 
      raise result.ex
4764 
    return
4765 
 
4324 mandeep.dh 4766 
  def updateShipmentAddress(self, orderId, addressId):
4767 
    """
4768 
    Updates shipment address of an order. Delivery and shipping date estimates
4769 
    etc. are also updated here.
4770 
 
4771 
    Throws TransactionServiceException in case address change is not
4772 
    possible due to certain reasons such as new pincode in address is
4773 
    not serviceable etc.
4774 
 
4775 
    Parameters:
4776 
     - orderId
4777 
     - addressId
4778 
    """
4779 
    self.send_updateShipmentAddress(orderId, addressId)
4780 
    self.recv_updateShipmentAddress()
4781 
 
4782 
  def send_updateShipmentAddress(self, orderId, addressId):
4783 
    self._oprot.writeMessageBegin('updateShipmentAddress', TMessageType.CALL, self._seqid)
4784 
    args = updateShipmentAddress_args()
4785 
    args.orderId = orderId
4786 
    args.addressId = addressId
4787 
    args.write(self._oprot)
4788 
    self._oprot.writeMessageEnd()
4789 
    self._oprot.trans.flush()
4790 
 
4791 
  def recv_updateShipmentAddress(self, ):
4792 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4793 
    if mtype == TMessageType.EXCEPTION:
4794 
      x = TApplicationException()
4795 
      x.read(self._iprot)
4796 
      self._iprot.readMessageEnd()
4797 
      raise x
4798 
    result = updateShipmentAddress_result()
4799 
    result.read(self._iprot)
4800 
    self._iprot.readMessageEnd()
4801 
    if result.ex is not None:
4802 
      raise result.ex
4803 
    return
4804 
 
4285 rajveer 4805 
  def acceptOrdersForItemId(self, itemId, inventory):
4806 
    """
4807 
    Marks the orders as ACCEPTED for the given itemId and inventory. It also updates the accepted timestamp. If the
4808 
    given order is not a COD order, it also captures the payment if the same has not been captured.
4259 anupam.sin 4809 
 
4285 rajveer 4810 
    Parameters:
4811 
     - itemId
4812 
     - inventory
4813 
    """
4814 
    self.send_acceptOrdersForItemId(itemId, inventory)
4815 
    return self.recv_acceptOrdersForItemId()
4816 
 
4817 
  def send_acceptOrdersForItemId(self, itemId, inventory):
4818 
    self._oprot.writeMessageBegin('acceptOrdersForItemId', TMessageType.CALL, self._seqid)
4819 
    args = acceptOrdersForItemId_args()
4820 
    args.itemId = itemId
4821 
    args.inventory = inventory
4822 
    args.write(self._oprot)
4823 
    self._oprot.writeMessageEnd()
4824 
    self._oprot.trans.flush()
4825 
 
4826 
  def recv_acceptOrdersForItemId(self, ):
4827 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4828 
    if mtype == TMessageType.EXCEPTION:
4829 
      x = TApplicationException()
4830 
      x.read(self._iprot)
4831 
      self._iprot.readMessageEnd()
4832 
      raise x
4833 
    result = acceptOrdersForItemId_result()
4834 
    result.read(self._iprot)
4835 
    self._iprot.readMessageEnd()
4836 
    if result.success is not None:
4837 
      return result.success
4838 
    if result.ex is not None:
4839 
      raise result.ex
4840 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "acceptOrdersForItemId failed: unknown result");
4841 
 
4369 rajveer 4842 
  def markOrdersAsPORaised(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 4843 
    """
4844 
    Parameters:
4845 
     - vendorId
4846 
     - itemId
4847 
     - quantity
4848 
     - estimate
4369 rajveer 4849 
     - isReminder
4303 rajveer 4850 
    """
4369 rajveer 4851 
    self.send_markOrdersAsPORaised(vendorId, itemId, quantity, estimate, isReminder)
4303 rajveer 4852 
    self.recv_markOrdersAsPORaised()
4285 rajveer 4853 
 
4369 rajveer 4854 
  def send_markOrdersAsPORaised(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 4855 
    self._oprot.writeMessageBegin('markOrdersAsPORaised', TMessageType.CALL, self._seqid)
4856 
    args = markOrdersAsPORaised_args()
4857 
    args.vendorId = vendorId
4858 
    args.itemId = itemId
4859 
    args.quantity = quantity
4860 
    args.estimate = estimate
4369 rajveer 4861 
    args.isReminder = isReminder
4303 rajveer 4862 
    args.write(self._oprot)
4863 
    self._oprot.writeMessageEnd()
4864 
    self._oprot.trans.flush()
4865 
 
4866 
  def recv_markOrdersAsPORaised(self, ):
4867 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4868 
    if mtype == TMessageType.EXCEPTION:
4869 
      x = TApplicationException()
4870 
      x.read(self._iprot)
4871 
      self._iprot.readMessageEnd()
4872 
      raise x
4873 
    result = markOrdersAsPORaised_result()
4874 
    result.read(self._iprot)
4875 
    self._iprot.readMessageEnd()
4876 
    if result.ex is not None:
4877 
      raise result.ex
4878 
    return
4879 
 
4369 rajveer 4880 
  def markOrdersAsReversalInitiated(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 4881 
    """
4882 
    Parameters:
4883 
     - vendorId
4884 
     - itemId
4885 
     - quantity
4886 
     - estimate
4369 rajveer 4887 
     - isReminder
4303 rajveer 4888 
    """
4369 rajveer 4889 
    self.send_markOrdersAsReversalInitiated(vendorId, itemId, quantity, estimate, isReminder)
4303 rajveer 4890 
    self.recv_markOrdersAsReversalInitiated()
4891 
 
4369 rajveer 4892 
  def send_markOrdersAsReversalInitiated(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 4893 
    self._oprot.writeMessageBegin('markOrdersAsReversalInitiated', TMessageType.CALL, self._seqid)
4894 
    args = markOrdersAsReversalInitiated_args()
4895 
    args.vendorId = vendorId
4896 
    args.itemId = itemId
4897 
    args.quantity = quantity
4898 
    args.estimate = estimate
4369 rajveer 4899 
    args.isReminder = isReminder
4303 rajveer 4900 
    args.write(self._oprot)
4901 
    self._oprot.writeMessageEnd()
4902 
    self._oprot.trans.flush()
4903 
 
4904 
  def recv_markOrdersAsReversalInitiated(self, ):
4905 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4906 
    if mtype == TMessageType.EXCEPTION:
4907 
      x = TApplicationException()
4908 
      x.read(self._iprot)
4909 
      self._iprot.readMessageEnd()
4910 
      raise x
4911 
    result = markOrdersAsReversalInitiated_result()
4912 
    result.read(self._iprot)
4913 
    self._iprot.readMessageEnd()
4914 
    if result.ex is not None:
4915 
      raise result.ex
4916 
    return
4917 
 
4369 rajveer 4918 
  def markOrdersAsNotAvailabke(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 4919 
    """
4920 
    Parameters:
4921 
     - vendorId
4922 
     - itemId
4923 
     - quantity
4924 
     - estimate
4369 rajveer 4925 
     - isReminder
4303 rajveer 4926 
    """
4369 rajveer 4927 
    self.send_markOrdersAsNotAvailabke(vendorId, itemId, quantity, estimate, isReminder)
4303 rajveer 4928 
    self.recv_markOrdersAsNotAvailabke()
4929 
 
4369 rajveer 4930 
  def send_markOrdersAsNotAvailabke(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 4931 
    self._oprot.writeMessageBegin('markOrdersAsNotAvailabke', TMessageType.CALL, self._seqid)
4932 
    args = markOrdersAsNotAvailabke_args()
4933 
    args.vendorId = vendorId
4934 
    args.itemId = itemId
4935 
    args.quantity = quantity
4936 
    args.estimate = estimate
4369 rajveer 4937 
    args.isReminder = isReminder
4303 rajveer 4938 
    args.write(self._oprot)
4939 
    self._oprot.writeMessageEnd()
4940 
    self._oprot.trans.flush()
4941 
 
4942 
  def recv_markOrdersAsNotAvailabke(self, ):
4943 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4944 
    if mtype == TMessageType.EXCEPTION:
4945 
      x = TApplicationException()
4946 
      x.read(self._iprot)
4947 
      self._iprot.readMessageEnd()
4948 
      raise x
4949 
    result = markOrdersAsNotAvailabke_result()
4950 
    result.read(self._iprot)
4951 
    self._iprot.readMessageEnd()
4952 
    if result.ex is not None:
4953 
      raise result.ex
4954 
    return
4955 
 
4369 rajveer 4956 
  def markOrdersAsTimeout(self, vendorId):
4957 
    """
4958 
    Parameters:
4959 
     - vendorId
4960 
    """
4961 
    self.send_markOrdersAsTimeout(vendorId)
4962 
    return self.recv_markOrdersAsTimeout()
4303 rajveer 4963 
 
4369 rajveer 4964 
  def send_markOrdersAsTimeout(self, vendorId):
4965 
    self._oprot.writeMessageBegin('markOrdersAsTimeout', TMessageType.CALL, self._seqid)
4966 
    args = markOrdersAsTimeout_args()
4967 
    args.vendorId = vendorId
4968 
    args.write(self._oprot)
4969 
    self._oprot.writeMessageEnd()
4970 
    self._oprot.trans.flush()
4971 
 
4972 
  def recv_markOrdersAsTimeout(self, ):
4973 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4974 
    if mtype == TMessageType.EXCEPTION:
4975 
      x = TApplicationException()
4976 
      x.read(self._iprot)
4977 
      self._iprot.readMessageEnd()
4978 
      raise x
4979 
    result = markOrdersAsTimeout_result()
4980 
    result.read(self._iprot)
4981 
    self._iprot.readMessageEnd()
4982 
    if result.success is not None:
4983 
      return result.success
4984 
    if result.ex is not None:
4985 
      raise result.ex
4986 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrdersAsTimeout failed: unknown result");
4987 
 
4662 rajveer 4988 
  def markOrderAsLostInTransit(self, orderId):
4989 
    """
4990 
    Mark order as LOST_IN_TRANSIT
4991 
 
4992 
    Parameters:
4993 
     - orderId
4994 
    """
4995 
    self.send_markOrderAsLostInTransit(orderId)
4996 
    return self.recv_markOrderAsLostInTransit()
4997 
 
4998 
  def send_markOrderAsLostInTransit(self, orderId):
4999 
    self._oprot.writeMessageBegin('markOrderAsLostInTransit', TMessageType.CALL, self._seqid)
5000 
    args = markOrderAsLostInTransit_args()
5001 
    args.orderId = orderId
5002 
    args.write(self._oprot)
5003 
    self._oprot.writeMessageEnd()
5004 
    self._oprot.trans.flush()
5005 
 
5006 
  def recv_markOrderAsLostInTransit(self, ):
5007 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5008 
    if mtype == TMessageType.EXCEPTION:
5009 
      x = TApplicationException()
5010 
      x.read(self._iprot)
5011 
      self._iprot.readMessageEnd()
5012 
      raise x
5013 
    result = markOrderAsLostInTransit_result()
5014 
    result.read(self._iprot)
5015 
    self._iprot.readMessageEnd()
5016 
    if result.success is not None:
5017 
      return result.success
5018 
    if result.ex is not None:
5019 
      raise result.ex
5020 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderAsLostInTransit failed: unknown result");
5021 
 
4386 anupam.sin 5022 
  def getOrderForAwb(self, awb):
5023 
    """
5024 
    Returns the order corresponding to an AWB number
4369 rajveer 5025 
 
4386 anupam.sin 5026 
    Parameters:
5027 
     - awb
5028 
    """
5029 
    self.send_getOrderForAwb(awb)
5030 
    return self.recv_getOrderForAwb()
5031 
 
5032 
  def send_getOrderForAwb(self, awb):
5033 
    self._oprot.writeMessageBegin('getOrderForAwb', TMessageType.CALL, self._seqid)
5034 
    args = getOrderForAwb_args()
5035 
    args.awb = awb
5036 
    args.write(self._oprot)
5037 
    self._oprot.writeMessageEnd()
5038 
    self._oprot.trans.flush()
5039 
 
5040 
  def recv_getOrderForAwb(self, ):
5041 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5042 
    if mtype == TMessageType.EXCEPTION:
5043 
      x = TApplicationException()
5044 
      x.read(self._iprot)
5045 
      self._iprot.readMessageEnd()
5046 
      raise x
5047 
    result = getOrderForAwb_result()
5048 
    result.read(self._iprot)
5049 
    self._iprot.readMessageEnd()
5050 
    if result.success is not None:
5051 
      return result.success
5052 
    if result.ex is not None:
5053 
      raise result.ex
5054 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderForAwb failed: unknown result");
5055 
 
4910 phani.kuma 5056 
  def getOrdersForProviderForStatus(self, logistics_provider_id, order_status_list):
4506 phani.kuma 5057 
    """
4910 phani.kuma 5058 
    Returns the order corresponding to a logistics provider id for a given list of order status
4386 anupam.sin 5059 
 
4506 phani.kuma 5060 
    Parameters:
5061 
     - logistics_provider_id
4910 phani.kuma 5062 
     - order_status_list
4506 phani.kuma 5063 
    """
4910 phani.kuma 5064 
    self.send_getOrdersForProviderForStatus(logistics_provider_id, order_status_list)
4506 phani.kuma 5065 
    return self.recv_getOrdersForProviderForStatus()
5066 
 
4910 phani.kuma 5067 
  def send_getOrdersForProviderForStatus(self, logistics_provider_id, order_status_list):
4506 phani.kuma 5068 
    self._oprot.writeMessageBegin('getOrdersForProviderForStatus', TMessageType.CALL, self._seqid)
5069 
    args = getOrdersForProviderForStatus_args()
5070 
    args.logistics_provider_id = logistics_provider_id
4910 phani.kuma 5071 
    args.order_status_list = order_status_list
4506 phani.kuma 5072 
    args.write(self._oprot)
5073 
    self._oprot.writeMessageEnd()
5074 
    self._oprot.trans.flush()
5075 
 
5076 
  def recv_getOrdersForProviderForStatus(self, ):
5077 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5078 
    if mtype == TMessageType.EXCEPTION:
5079 
      x = TApplicationException()
5080 
      x.read(self._iprot)
5081 
      self._iprot.readMessageEnd()
5082 
      raise x
5083 
    result = getOrdersForProviderForStatus_result()
5084 
    result.read(self._iprot)
5085 
    self._iprot.readMessageEnd()
5086 
    if result.success is not None:
5087 
      return result.success
5088 
    if result.ex is not None:
5089 
      raise result.ex
5090 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersForProviderForStatus failed: unknown result");
5091 
 
4600 varun.gupt 5092 
  def getBilledOrdersForVendor(self, vendorId, billingDateFrom, billingDateTo):
5093 
    """
5094 
    Returns list of orders fullfiled from a certain vendor and billed in a given date range
4506 phani.kuma 5095 
 
4600 varun.gupt 5096 
    Parameters:
5097 
     - vendorId
5098 
     - billingDateFrom
5099 
     - billingDateTo
5100 
    """
5101 
    self.send_getBilledOrdersForVendor(vendorId, billingDateFrom, billingDateTo)
5102 
    return self.recv_getBilledOrdersForVendor()
5103 
 
5104 
  def send_getBilledOrdersForVendor(self, vendorId, billingDateFrom, billingDateTo):
5105 
    self._oprot.writeMessageBegin('getBilledOrdersForVendor', TMessageType.CALL, self._seqid)
5106 
    args = getBilledOrdersForVendor_args()
5107 
    args.vendorId = vendorId
5108 
    args.billingDateFrom = billingDateFrom
5109 
    args.billingDateTo = billingDateTo
5110 
    args.write(self._oprot)
5111 
    self._oprot.writeMessageEnd()
5112 
    self._oprot.trans.flush()
5113 
 
5114 
  def recv_getBilledOrdersForVendor(self, ):
5115 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5116 
    if mtype == TMessageType.EXCEPTION:
5117 
      x = TApplicationException()
5118 
      x.read(self._iprot)
5119 
      self._iprot.readMessageEnd()
5120 
      raise x
5121 
    result = getBilledOrdersForVendor_result()
5122 
    result.read(self._iprot)
5123 
    self._iprot.readMessageEnd()
5124 
    if result.success is not None:
5125 
      return result.success
5126 
    if result.ex is not None:
5127 
      raise result.ex
5128 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBilledOrdersForVendor failed: unknown result");
5129 
 
4607 rajveer 5130 
  def getSlippedSippingDateOrders(self, ):
5131 
    self.send_getSlippedSippingDateOrders()
5132 
    return self.recv_getSlippedSippingDateOrders()
5133 
 
5134 
  def send_getSlippedSippingDateOrders(self, ):
5135 
    self._oprot.writeMessageBegin('getSlippedSippingDateOrders', TMessageType.CALL, self._seqid)
5136 
    args = getSlippedSippingDateOrders_args()
5137 
    args.write(self._oprot)
5138 
    self._oprot.writeMessageEnd()
5139 
    self._oprot.trans.flush()
5140 
 
5141 
  def recv_getSlippedSippingDateOrders(self, ):
5142 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5143 
    if mtype == TMessageType.EXCEPTION:
5144 
      x = TApplicationException()
5145 
      x.read(self._iprot)
5146 
      self._iprot.readMessageEnd()
5147 
      raise x
5148 
    result = getSlippedSippingDateOrders_result()
5149 
    result.read(self._iprot)
5150 
    self._iprot.readMessageEnd()
5151 
    if result.success is not None:
5152 
      return result.success
5153 
    if result.ex is not None:
5154 
      raise result.ex
5155 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getSlippedSippingDateOrders failed: unknown result");
5156 
 
4709 rajveer 5157 
  def getCancelledOrders(self, cancelDateFrom, cancelDateTo):
5158 
    """
5159 
    Parameters:
5160 
     - cancelDateFrom
5161 
     - cancelDateTo
5162 
    """
5163 
    self.send_getCancelledOrders(cancelDateFrom, cancelDateTo)
5164 
    return self.recv_getCancelledOrders()
5165 
 
5166 
  def send_getCancelledOrders(self, cancelDateFrom, cancelDateTo):
5167 
    self._oprot.writeMessageBegin('getCancelledOrders', TMessageType.CALL, self._seqid)
5168 
    args = getCancelledOrders_args()
5169 
    args.cancelDateFrom = cancelDateFrom
5170 
    args.cancelDateTo = cancelDateTo
5171 
    args.write(self._oprot)
5172 
    self._oprot.writeMessageEnd()
5173 
    self._oprot.trans.flush()
5174 
 
5175 
  def recv_getCancelledOrders(self, ):
5176 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5177 
    if mtype == TMessageType.EXCEPTION:
5178 
      x = TApplicationException()
5179 
      x.read(self._iprot)
5180 
      self._iprot.readMessageEnd()
5181 
      raise x
5182 
    result = getCancelledOrders_result()
5183 
    result.read(self._iprot)
5184 
    self._iprot.readMessageEnd()
5185 
    if result.success is not None:
5186 
      return result.success
5187 
    if result.ex is not None:
5188 
      raise result.ex
5189 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCancelledOrders failed: unknown result");
5190 
 
4600 varun.gupt 5191 
  def saveBluedartSettlements(self, mapAWBAndAmount):
5192 
    """
5193 
    Parameters:
5194 
     - mapAWBAndAmount
5195 
    """
5196 
    self.send_saveBluedartSettlements(mapAWBAndAmount)
5197 
    self.recv_saveBluedartSettlements()
5198 
 
5199 
  def send_saveBluedartSettlements(self, mapAWBAndAmount):
5200 
    self._oprot.writeMessageBegin('saveBluedartSettlements', TMessageType.CALL, self._seqid)
5201 
    args = saveBluedartSettlements_args()
5202 
    args.mapAWBAndAmount = mapAWBAndAmount
5203 
    args.write(self._oprot)
5204 
    self._oprot.writeMessageEnd()
5205 
    self._oprot.trans.flush()
5206 
 
5207 
  def recv_saveBluedartSettlements(self, ):
5208 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5209 
    if mtype == TMessageType.EXCEPTION:
5210 
      x = TApplicationException()
5211 
      x.read(self._iprot)
5212 
      self._iprot.readMessageEnd()
5213 
      raise x
5214 
    result = saveBluedartSettlements_result()
5215 
    result.read(self._iprot)
5216 
    self._iprot.readMessageEnd()
5217 
    if result.ex is not None:
5218 
      raise result.ex
5219 
    return
5220 
 
4905 varun.gupt 5221 
  def savePaymentSettlements(self, settlementDate, paymentGatewayId, referenceId, serviceTax, otherCharges, netCollection):
4600 varun.gupt 5222 
    """
5223 
    Parameters:
5224 
     - settlementDate
5225 
     - paymentGatewayId
4905 varun.gupt 5226 
     - referenceId
4600 varun.gupt 5227 
     - serviceTax
5228 
     - otherCharges
5229 
     - netCollection
5230 
    """
4905 varun.gupt 5231 
    self.send_savePaymentSettlements(settlementDate, paymentGatewayId, referenceId, serviceTax, otherCharges, netCollection)
4600 varun.gupt 5232 
    self.recv_savePaymentSettlements()
5233 
 
4905 varun.gupt 5234 
  def send_savePaymentSettlements(self, settlementDate, paymentGatewayId, referenceId, serviceTax, otherCharges, netCollection):
4600 varun.gupt 5235 
    self._oprot.writeMessageBegin('savePaymentSettlements', TMessageType.CALL, self._seqid)
5236 
    args = savePaymentSettlements_args()
5237 
    args.settlementDate = settlementDate
5238 
    args.paymentGatewayId = paymentGatewayId
4905 varun.gupt 5239 
    args.referenceId = referenceId
4600 varun.gupt 5240 
    args.serviceTax = serviceTax
5241 
    args.otherCharges = otherCharges
5242 
    args.netCollection = netCollection
5243 
    args.write(self._oprot)
5244 
    self._oprot.writeMessageEnd()
5245 
    self._oprot.trans.flush()
5246 
 
5247 
  def recv_savePaymentSettlements(self, ):
5248 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5249 
    if mtype == TMessageType.EXCEPTION:
5250 
      x = TApplicationException()
5251 
      x.read(self._iprot)
5252 
      self._iprot.readMessageEnd()
5253 
      raise x
5254 
    result = savePaymentSettlements_result()
5255 
    result.read(self._iprot)
5256 
    self._iprot.readMessageEnd()
5257 
    if result.ex is not None:
5258 
      raise result.ex
5259 
    return
5260 
 
5261 
  def saveEBSSettlementSummary(self, settlementId, settlementDate, transactionDateFrom, transactionDateTo, amount):
5262 
    """
5263 
    Parameters:
5264 
     - settlementId
5265 
     - settlementDate
5266 
     - transactionDateFrom
5267 
     - transactionDateTo
5268 
     - amount
5269 
    """
5270 
    self.send_saveEBSSettlementSummary(settlementId, settlementDate, transactionDateFrom, transactionDateTo, amount)
5271 
    self.recv_saveEBSSettlementSummary()
5272 
 
5273 
  def send_saveEBSSettlementSummary(self, settlementId, settlementDate, transactionDateFrom, transactionDateTo, amount):
5274 
    self._oprot.writeMessageBegin('saveEBSSettlementSummary', TMessageType.CALL, self._seqid)
5275 
    args = saveEBSSettlementSummary_args()
5276 
    args.settlementId = settlementId
5277 
    args.settlementDate = settlementDate
5278 
    args.transactionDateFrom = transactionDateFrom
5279 
    args.transactionDateTo = transactionDateTo
5280 
    args.amount = amount
5281 
    args.write(self._oprot)
5282 
    self._oprot.writeMessageEnd()
5283 
    self._oprot.trans.flush()
5284 
 
5285 
  def recv_saveEBSSettlementSummary(self, ):
5286 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5287 
    if mtype == TMessageType.EXCEPTION:
5288 
      x = TApplicationException()
5289 
      x.read(self._iprot)
5290 
      self._iprot.readMessageEnd()
5291 
      raise x
5292 
    result = saveEBSSettlementSummary_result()
5293 
    result.read(self._iprot)
5294 
    self._iprot.readMessageEnd()
5295 
    if result.ex is not None:
5296 
      raise result.ex
5297 
    return
5298 
 
5386 phani.kuma 5299 
  def getSettlementForPrepaid(self, referenceId, isRefund):
4600 varun.gupt 5300 
    """
5301 
    Parameters:
5189 varun.gupt 5302 
     - referenceId
5303 
     - isRefund
4600 varun.gupt 5304 
    """
5386 phani.kuma 5305 
    self.send_getSettlementForPrepaid(referenceId, isRefund)
5306 
    return self.recv_getSettlementForPrepaid()
4600 varun.gupt 5307 
 
5386 phani.kuma 5308 
  def send_getSettlementForPrepaid(self, referenceId, isRefund):
5309 
    self._oprot.writeMessageBegin('getSettlementForPrepaid', TMessageType.CALL, self._seqid)
5310 
    args = getSettlementForPrepaid_args()
5189 varun.gupt 5311 
    args.referenceId = referenceId
5312 
    args.isRefund = isRefund
4600 varun.gupt 5313 
    args.write(self._oprot)
5314 
    self._oprot.writeMessageEnd()
5315 
    self._oprot.trans.flush()
5316 
 
5386 phani.kuma 5317 
  def recv_getSettlementForPrepaid(self, ):
4600 varun.gupt 5318 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5319 
    if mtype == TMessageType.EXCEPTION:
5320 
      x = TApplicationException()
5321 
      x.read(self._iprot)
5322 
      self._iprot.readMessageEnd()
5323 
      raise x
5386 phani.kuma 5324 
    result = getSettlementForPrepaid_result()
4600 varun.gupt 5325 
    result.read(self._iprot)
5326 
    self._iprot.readMessageEnd()
5327 
    if result.success is not None:
5328 
      return result.success
5329 
    if result.ex is not None:
5330 
      raise result.ex
5386 phani.kuma 5331 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getSettlementForPrepaid failed: unknown result");
4600 varun.gupt 5332 
 
5386 phani.kuma 5333 
  def getSettlementForCod(self, orderId, isRefund):
5334 
    """
5335 
    Parameters:
5336 
     - orderId
5337 
     - isRefund
5338 
    """
5339 
    self.send_getSettlementForCod(orderId, isRefund)
5340 
    return self.recv_getSettlementForCod()
5341 
 
5342 
  def send_getSettlementForCod(self, orderId, isRefund):
5343 
    self._oprot.writeMessageBegin('getSettlementForCod', TMessageType.CALL, self._seqid)
5344 
    args = getSettlementForCod_args()
5345 
    args.orderId = orderId
5346 
    args.isRefund = isRefund
5347 
    args.write(self._oprot)
5348 
    self._oprot.writeMessageEnd()
5349 
    self._oprot.trans.flush()
5350 
 
5351 
  def recv_getSettlementForCod(self, ):
5352 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5353 
    if mtype == TMessageType.EXCEPTION:
5354 
      x = TApplicationException()
5355 
      x.read(self._iprot)
5356 
      self._iprot.readMessageEnd()
5357 
      raise x
5358 
    result = getSettlementForCod_result()
5359 
    result.read(self._iprot)
5360 
    self._iprot.readMessageEnd()
5361 
    if result.success is not None:
5362 
      return result.success
5363 
    if result.ex is not None:
5364 
      raise result.ex
5365 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getSettlementForCod failed: unknown result");
5366 
 
4600 varun.gupt 5367 
  def getEBSSettlementSummaries(self, ):
5368 
    self.send_getEBSSettlementSummaries()
5369 
    return self.recv_getEBSSettlementSummaries()
5370 
 
5371 
  def send_getEBSSettlementSummaries(self, ):
5372 
    self._oprot.writeMessageBegin('getEBSSettlementSummaries', TMessageType.CALL, self._seqid)
5373 
    args = getEBSSettlementSummaries_args()
5374 
    args.write(self._oprot)
5375 
    self._oprot.writeMessageEnd()
5376 
    self._oprot.trans.flush()
5377 
 
5378 
  def recv_getEBSSettlementSummaries(self, ):
5379 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5380 
    if mtype == TMessageType.EXCEPTION:
5381 
      x = TApplicationException()
5382 
      x.read(self._iprot)
5383 
      self._iprot.readMessageEnd()
5384 
      raise x
5385 
    result = getEBSSettlementSummaries_result()
5386 
    result.read(self._iprot)
5387 
    self._iprot.readMessageEnd()
5388 
    if result.success is not None:
5389 
      return result.success
5390 
    if result.ex is not None:
5391 
      raise result.ex
5392 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getEBSSettlementSummaries failed: unknown result");
5393 
 
5394 
  def markEBSSettlementUploaded(self, settlementId):
5395 
    """
5396 
    Parameters:
5397 
     - settlementId
5398 
    """
5399 
    self.send_markEBSSettlementUploaded(settlementId)
5400 
    self.recv_markEBSSettlementUploaded()
5401 
 
5402 
  def send_markEBSSettlementUploaded(self, settlementId):
5403 
    self._oprot.writeMessageBegin('markEBSSettlementUploaded', TMessageType.CALL, self._seqid)
5404 
    args = markEBSSettlementUploaded_args()
5405 
    args.settlementId = settlementId
5406 
    args.write(self._oprot)
5407 
    self._oprot.writeMessageEnd()
5408 
    self._oprot.trans.flush()
5409 
 
5410 
  def recv_markEBSSettlementUploaded(self, ):
5411 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5412 
    if mtype == TMessageType.EXCEPTION:
5413 
      x = TApplicationException()
5414 
      x.read(self._iprot)
5415 
      self._iprot.readMessageEnd()
5416 
      raise x
5417 
    result = markEBSSettlementUploaded_result()
5418 
    result.read(self._iprot)
5419 
    self._iprot.readMessageEnd()
5420 
    if result.ex is not None:
5421 
      raise result.ex
5422 
    return
5423 
 
5424 
  def getEBSSettlementDate(self, settlementId):
5425 
    """
5426 
    Parameters:
5427 
     - settlementId
5428 
    """
5429 
    self.send_getEBSSettlementDate(settlementId)
5430 
    return self.recv_getEBSSettlementDate()
5431 
 
5432 
  def send_getEBSSettlementDate(self, settlementId):
5433 
    self._oprot.writeMessageBegin('getEBSSettlementDate', TMessageType.CALL, self._seqid)
5434 
    args = getEBSSettlementDate_args()
5435 
    args.settlementId = settlementId
5436 
    args.write(self._oprot)
5437 
    self._oprot.writeMessageEnd()
5438 
    self._oprot.trans.flush()
5439 
 
5440 
  def recv_getEBSSettlementDate(self, ):
5441 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5442 
    if mtype == TMessageType.EXCEPTION:
5443 
      x = TApplicationException()
5444 
      x.read(self._iprot)
5445 
      self._iprot.readMessageEnd()
5446 
      raise x
5447 
    result = getEBSSettlementDate_result()
5448 
    result.read(self._iprot)
5449 
    self._iprot.readMessageEnd()
5450 
    if result.success is not None:
5451 
      return result.success
5452 
    if result.ex is not None:
5453 
      raise result.ex
5454 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getEBSSettlementDate failed: unknown result");
5455 
 
4715 varun.gupt 5456 
  def getSettlementsByDate(self, settlementDateFrom, settlementDateTo, isRefund):
5457 
    """
5458 
    Parameters:
5459 
     - settlementDateFrom
5460 
     - settlementDateTo
5461 
     - isRefund
5462 
    """
5463 
    self.send_getSettlementsByDate(settlementDateFrom, settlementDateTo, isRefund)
5464 
    return self.recv_getSettlementsByDate()
4600 varun.gupt 5465 
 
4715 varun.gupt 5466 
  def send_getSettlementsByDate(self, settlementDateFrom, settlementDateTo, isRefund):
5467 
    self._oprot.writeMessageBegin('getSettlementsByDate', TMessageType.CALL, self._seqid)
5468 
    args = getSettlementsByDate_args()
5469 
    args.settlementDateFrom = settlementDateFrom
5470 
    args.settlementDateTo = settlementDateTo
5471 
    args.isRefund = isRefund
5472 
    args.write(self._oprot)
5473 
    self._oprot.writeMessageEnd()
5474 
    self._oprot.trans.flush()
5475 
 
5476 
  def recv_getSettlementsByDate(self, ):
5477 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5478 
    if mtype == TMessageType.EXCEPTION:
5479 
      x = TApplicationException()
5480 
      x.read(self._iprot)
5481 
      self._iprot.readMessageEnd()
5482 
      raise x
5483 
    result = getSettlementsByDate_result()
5484 
    result.read(self._iprot)
5485 
    self._iprot.readMessageEnd()
5486 
    if result.success is not None:
5487 
      return result.success
5488 
    if result.ex is not None:
5489 
      raise result.ex
5490 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getSettlementsByDate failed: unknown result");
5491 
 
5492 
  def getReshippedOrderIds(self, orderIds):
5493 
    """
5494 
    Returns list of Order Ids, which belong to reshiped orders, shortlisted from a given list of Order Ids
5495 
 
5496 
    Parameters:
5497 
     - orderIds
5498 
    """
5499 
    self.send_getReshippedOrderIds(orderIds)
5500 
    return self.recv_getReshippedOrderIds()
5501 
 
5502 
  def send_getReshippedOrderIds(self, orderIds):
5503 
    self._oprot.writeMessageBegin('getReshippedOrderIds', TMessageType.CALL, self._seqid)
5504 
    args = getReshippedOrderIds_args()
5505 
    args.orderIds = orderIds
5506 
    args.write(self._oprot)
5507 
    self._oprot.writeMessageEnd()
5508 
    self._oprot.trans.flush()
5509 
 
5510 
  def recv_getReshippedOrderIds(self, ):
5511 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5512 
    if mtype == TMessageType.EXCEPTION:
5513 
      x = TApplicationException()
5514 
      x.read(self._iprot)
5515 
      self._iprot.readMessageEnd()
5516 
      raise x
5517 
    result = getReshippedOrderIds_result()
5518 
    result.read(self._iprot)
5519 
    self._iprot.readMessageEnd()
5520 
    if result.success is not None:
5521 
      return result.success
5522 
    if result.ex is not None:
5523 
      raise result.ex
5524 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReshippedOrderIds failed: unknown result");
5525 
 
5481 phani.kuma 5526 
  def getBilledOrders(self, vendorId, onlyVendorNotPaid, billingDateFrom, billingDateTo):
4875 varun.gupt 5527 
    """
5528 
    Parameters:
5529 
     - vendorId
5481 phani.kuma 5530 
     - onlyVendorNotPaid
5531 
     - billingDateFrom
5532 
     - billingDateTo
4875 varun.gupt 5533 
    """
5481 phani.kuma 5534 
    self.send_getBilledOrders(vendorId, onlyVendorNotPaid, billingDateFrom, billingDateTo)
5535 
    return self.recv_getBilledOrders()
4757 mandeep.dh 5536 
 
5481 phani.kuma 5537 
  def send_getBilledOrders(self, vendorId, onlyVendorNotPaid, billingDateFrom, billingDateTo):
5538 
    self._oprot.writeMessageBegin('getBilledOrders', TMessageType.CALL, self._seqid)
5539 
    args = getBilledOrders_args()
4875 varun.gupt 5540 
    args.vendorId = vendorId
5481 phani.kuma 5541 
    args.onlyVendorNotPaid = onlyVendorNotPaid
5542 
    args.billingDateFrom = billingDateFrom
5543 
    args.billingDateTo = billingDateTo
4875 varun.gupt 5544 
    args.write(self._oprot)
5545 
    self._oprot.writeMessageEnd()
5546 
    self._oprot.trans.flush()
5547 
 
5481 phani.kuma 5548 
  def recv_getBilledOrders(self, ):
4875 varun.gupt 5549 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5550 
    if mtype == TMessageType.EXCEPTION:
5551 
      x = TApplicationException()
5552 
      x.read(self._iprot)
5553 
      self._iprot.readMessageEnd()
5554 
      raise x
5481 phani.kuma 5555 
    result = getBilledOrders_result()
4875 varun.gupt 5556 
    result.read(self._iprot)
5557 
    self._iprot.readMessageEnd()
5558 
    if result.success is not None:
5559 
      return result.success
5560 
    if result.ex is not None:
5561 
      raise result.ex
5481 phani.kuma 5562 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBilledOrders failed: unknown result");
4875 varun.gupt 5563 
 
5031 varun.gupt 5564 
  def getStatusDistributionOfOrders(self, startDate, endDate):
5565 
    """
5566 
    Parameters:
5567 
     - startDate
5568 
     - endDate
5569 
    """
5570 
    self.send_getStatusDistributionOfOrders(startDate, endDate)
5571 
    return self.recv_getStatusDistributionOfOrders()
4875 varun.gupt 5572 
 
5031 varun.gupt 5573 
  def send_getStatusDistributionOfOrders(self, startDate, endDate):
5574 
    self._oprot.writeMessageBegin('getStatusDistributionOfOrders', TMessageType.CALL, self._seqid)
5575 
    args = getStatusDistributionOfOrders_args()
5576 
    args.startDate = startDate
5577 
    args.endDate = endDate
5578 
    args.write(self._oprot)
5579 
    self._oprot.writeMessageEnd()
5580 
    self._oprot.trans.flush()
5581 
 
5582 
  def recv_getStatusDistributionOfOrders(self, ):
5583 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5584 
    if mtype == TMessageType.EXCEPTION:
5585 
      x = TApplicationException()
5586 
      x.read(self._iprot)
5587 
      self._iprot.readMessageEnd()
5588 
      raise x
5589 
    result = getStatusDistributionOfOrders_result()
5590 
    result.read(self._iprot)
5591 
    self._iprot.readMessageEnd()
5592 
    if result.success is not None:
5593 
      return result.success
5594 
    if result.ex is not None:
5595 
      raise result.ex
5596 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getStatusDistributionOfOrders failed: unknown result");
5597 
 
5067 varun.gupt 5598 
  def getOrderIdsForStatus(self, status, startDatetime, endDatetime):
5599 
    """
5600 
    Parameters:
5601 
     - status
5602 
     - startDatetime
5603 
     - endDatetime
5604 
    """
5605 
    self.send_getOrderIdsForStatus(status, startDatetime, endDatetime)
5606 
    return self.recv_getOrderIdsForStatus()
5031 varun.gupt 5607 
 
5067 varun.gupt 5608 
  def send_getOrderIdsForStatus(self, status, startDatetime, endDatetime):
5609 
    self._oprot.writeMessageBegin('getOrderIdsForStatus', TMessageType.CALL, self._seqid)
5610 
    args = getOrderIdsForStatus_args()
5611 
    args.status = status
5612 
    args.startDatetime = startDatetime
5613 
    args.endDatetime = endDatetime
5614 
    args.write(self._oprot)
5615 
    self._oprot.writeMessageEnd()
5616 
    self._oprot.trans.flush()
5617 
 
5618 
  def recv_getOrderIdsForStatus(self, ):
5619 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5620 
    if mtype == TMessageType.EXCEPTION:
5621 
      x = TApplicationException()
5622 
      x.read(self._iprot)
5623 
      self._iprot.readMessageEnd()
5624 
      raise x
5625 
    result = getOrderIdsForStatus_result()
5626 
    result.read(self._iprot)
5627 
    self._iprot.readMessageEnd()
5628 
    if result.success is not None:
5629 
      return result.success
5630 
    if result.ex is not None:
5631 
      raise result.ex
5632 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderIdsForStatus failed: unknown result");
5633 
 
5348 anupam.sin 5634 
  def updateCODAgent(self, agent, orderId):
5635 
    """
5636 
    Updates the agent who handled the COD verification call
5637 
 
5638 
    Parameters:
5639 
     - agent
5640 
     - orderId
5641 
    """
5642 
    self.send_updateCODAgent(agent, orderId)
5643 
    self.recv_updateCODAgent()
5644 
 
5645 
  def send_updateCODAgent(self, agent, orderId):
5646 
    self._oprot.writeMessageBegin('updateCODAgent', TMessageType.CALL, self._seqid)
5647 
    args = updateCODAgent_args()
5648 
    args.agent = agent
5649 
    args.orderId = orderId
5650 
    args.write(self._oprot)
5651 
    self._oprot.writeMessageEnd()
5652 
    self._oprot.trans.flush()
5653 
 
5654 
  def recv_updateCODAgent(self, ):
5655 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5656 
    if mtype == TMessageType.EXCEPTION:
5657 
      x = TApplicationException()
5658 
      x.read(self._iprot)
5659 
      self._iprot.readMessageEnd()
5660 
      raise x
5661 
    result = updateCODAgent_result()
5662 
    result.read(self._iprot)
5663 
    self._iprot.readMessageEnd()
5664 
    if result.ex is not None:
5665 
      raise result.ex
5666 
    return
5667 
 
5099 varun.gupt 5668 
  def updateOrderAsPaidToVendor(self, orderId):
5669 
    """
5670 
    Parameters:
5671 
     - orderId
5672 
    """
5673 
    self.send_updateOrderAsPaidToVendor(orderId)
5674 
    self.recv_updateOrderAsPaidToVendor()
5067 varun.gupt 5675 
 
5099 varun.gupt 5676 
  def send_updateOrderAsPaidToVendor(self, orderId):
5677 
    self._oprot.writeMessageBegin('updateOrderAsPaidToVendor', TMessageType.CALL, self._seqid)
5678 
    args = updateOrderAsPaidToVendor_args()
5679 
    args.orderId = orderId
5680 
    args.write(self._oprot)
5681 
    self._oprot.writeMessageEnd()
5682 
    self._oprot.trans.flush()
5683 
 
5684 
  def recv_updateOrderAsPaidToVendor(self, ):
5685 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5686 
    if mtype == TMessageType.EXCEPTION:
5687 
      x = TApplicationException()
5688 
      x.read(self._iprot)
5689 
      self._iprot.readMessageEnd()
5690 
      raise x
5691 
    result = updateOrderAsPaidToVendor_result()
5692 
    result.read(self._iprot)
5693 
    self._iprot.readMessageEnd()
5694 
    if result.ex is not None:
5695 
      raise result.ex
5696 
    return
5697 
 
5386 phani.kuma 5698 
  def updateOrderOnlyAsPaidToVendor(self, orderId):
5699 
    """
5700 
    Parameters:
5701 
     - orderId
5702 
    """
5703 
    self.send_updateOrderOnlyAsPaidToVendor(orderId)
5704 
    self.recv_updateOrderOnlyAsPaidToVendor()
5705 
 
5706 
  def send_updateOrderOnlyAsPaidToVendor(self, orderId):
5707 
    self._oprot.writeMessageBegin('updateOrderOnlyAsPaidToVendor', TMessageType.CALL, self._seqid)
5708 
    args = updateOrderOnlyAsPaidToVendor_args()
5709 
    args.orderId = orderId
5710 
    args.write(self._oprot)
5711 
    self._oprot.writeMessageEnd()
5712 
    self._oprot.trans.flush()
5713 
 
5714 
  def recv_updateOrderOnlyAsPaidToVendor(self, ):
5715 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5716 
    if mtype == TMessageType.EXCEPTION:
5717 
      x = TApplicationException()
5718 
      x.read(self._iprot)
5719 
      self._iprot.readMessageEnd()
5720 
      raise x
5721 
    result = updateOrderOnlyAsPaidToVendor_result()
5722 
    result.read(self._iprot)
5723 
    self._iprot.readMessageEnd()
5724 
    if result.ex is not None:
5725 
      raise result.ex
5726 
    return
5727 
 
5208 varun.gupt 5728 
  def getRefundedOrdersMarkedPaid(self, ):
5729 
    self.send_getRefundedOrdersMarkedPaid()
5730 
    return self.recv_getRefundedOrdersMarkedPaid()
5099 varun.gupt 5731 
 
5208 varun.gupt 5732 
  def send_getRefundedOrdersMarkedPaid(self, ):
5733 
    self._oprot.writeMessageBegin('getRefundedOrdersMarkedPaid', TMessageType.CALL, self._seqid)
5734 
    args = getRefundedOrdersMarkedPaid_args()
5735 
    args.write(self._oprot)
5736 
    self._oprot.writeMessageEnd()
5737 
    self._oprot.trans.flush()
5738 
 
5739 
  def recv_getRefundedOrdersMarkedPaid(self, ):
5740 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5741 
    if mtype == TMessageType.EXCEPTION:
5742 
      x = TApplicationException()
5743 
      x.read(self._iprot)
5744 
      self._iprot.readMessageEnd()
5745 
      raise x
5746 
    result = getRefundedOrdersMarkedPaid_result()
5747 
    result.read(self._iprot)
5748 
    self._iprot.readMessageEnd()
5749 
    if result.success is not None:
5750 
      return result.success
5751 
    if result.ex is not None:
5752 
      raise result.ex
5753 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getRefundedOrdersMarkedPaid failed: unknown result");
5754 
 
5447 anupam.sin 5755 
  def getAllVerificationAgents(self, minOrderId, maxOrderId):
5756 
    """
5757 
    gets all COD Verification Agents for all orderIds from a minId to maxId
5208 varun.gupt 5758 
 
5447 anupam.sin 5759 
 
5760 
    Parameters:
5761 
     - minOrderId
5762 
     - maxOrderId
5763 
    """
5764 
    self.send_getAllVerificationAgents(minOrderId, maxOrderId)
5765 
    return self.recv_getAllVerificationAgents()
5766 
 
5767 
  def send_getAllVerificationAgents(self, minOrderId, maxOrderId):
5768 
    self._oprot.writeMessageBegin('getAllVerificationAgents', TMessageType.CALL, self._seqid)
5769 
    args = getAllVerificationAgents_args()
5770 
    args.minOrderId = minOrderId
5771 
    args.maxOrderId = maxOrderId
5772 
    args.write(self._oprot)
5773 
    self._oprot.writeMessageEnd()
5774 
    self._oprot.trans.flush()
5775 
 
5776 
  def recv_getAllVerificationAgents(self, ):
5777 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5778 
    if mtype == TMessageType.EXCEPTION:
5779 
      x = TApplicationException()
5780 
      x.read(self._iprot)
5781 
      self._iprot.readMessageEnd()
5782 
      raise x
5783 
    result = getAllVerificationAgents_result()
5784 
    result.read(self._iprot)
5785 
    self._iprot.readMessageEnd()
5786 
    if result.success is not None:
5787 
      return result.success
5788 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllVerificationAgents failed: unknown result");
5789 
 
5527 anupam.sin 5790 
  def getAllAttributesForOrderId(self, orderId):
5791 
    """
5792 
    gets all attributes for a given orderId
5447 anupam.sin 5793 
 
5527 anupam.sin 5794 
    Parameters:
5795 
     - orderId
5796 
    """
5797 
    self.send_getAllAttributesForOrderId(orderId)
5798 
    return self.recv_getAllAttributesForOrderId()
5799 
 
5800 
  def send_getAllAttributesForOrderId(self, orderId):
5801 
    self._oprot.writeMessageBegin('getAllAttributesForOrderId', TMessageType.CALL, self._seqid)
5802 
    args = getAllAttributesForOrderId_args()
5803 
    args.orderId = orderId
5804 
    args.write(self._oprot)
5805 
    self._oprot.writeMessageEnd()
5806 
    self._oprot.trans.flush()
5807 
 
5808 
  def recv_getAllAttributesForOrderId(self, ):
5809 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5810 
    if mtype == TMessageType.EXCEPTION:
5811 
      x = TApplicationException()
5812 
      x.read(self._iprot)
5813 
      self._iprot.readMessageEnd()
5814 
      raise x
5815 
    result = getAllAttributesForOrderId_result()
5816 
    result.read(self._iprot)
5817 
    self._iprot.readMessageEnd()
5818 
    if result.success is not None:
5819 
      return result.success
5820 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllAttributesForOrderId failed: unknown result");
5821 
 
5676 rajveer 5822 
  def setOrderAttributes(self, orderId, attributes):
5823 
    """
5824 
    sets attributes for an order
5825 
 
5826 
    Parameters:
5827 
     - orderId
5828 
     - attributes
5829 
    """
5830 
    self.send_setOrderAttributes(orderId, attributes)
5831 
    self.recv_setOrderAttributes()
5832 
 
5833 
  def send_setOrderAttributes(self, orderId, attributes):
5834 
    self._oprot.writeMessageBegin('setOrderAttributes', TMessageType.CALL, self._seqid)
5835 
    args = setOrderAttributes_args()
5836 
    args.orderId = orderId
5837 
    args.attributes = attributes
5838 
    args.write(self._oprot)
5839 
    self._oprot.writeMessageEnd()
5840 
    self._oprot.trans.flush()
5841 
 
5842 
  def recv_setOrderAttributes(self, ):
5843 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5844 
    if mtype == TMessageType.EXCEPTION:
5845 
      x = TApplicationException()
5846 
      x.read(self._iprot)
5847 
      self._iprot.readMessageEnd()
5848 
      raise x
5849 
    result = setOrderAttributes_result()
5850 
    result.read(self._iprot)
5851 
    self._iprot.readMessageEnd()
5852 
    return
5853 
 
5527 anupam.sin 5854 
  def setOrderAttributeForTransaction(self, transactionId, attribute):
5855 
    """
5856 
    sets attributes for all orders in a transaction
5857 
 
5858 
    Parameters:
5859 
     - transactionId
5860 
     - attribute
5861 
    """
5862 
    self.send_setOrderAttributeForTransaction(transactionId, attribute)
5863 
    self.recv_setOrderAttributeForTransaction()
5864 
 
5865 
  def send_setOrderAttributeForTransaction(self, transactionId, attribute):
5866 
    self._oprot.writeMessageBegin('setOrderAttributeForTransaction', TMessageType.CALL, self._seqid)
5867 
    args = setOrderAttributeForTransaction_args()
5868 
    args.transactionId = transactionId
5869 
    args.attribute = attribute
5870 
    args.write(self._oprot)
5871 
    self._oprot.writeMessageEnd()
5872 
    self._oprot.trans.flush()
5873 
 
5874 
  def recv_setOrderAttributeForTransaction(self, ):
5875 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5876 
    if mtype == TMessageType.EXCEPTION:
5877 
      x = TApplicationException()
5878 
      x.read(self._iprot)
5879 
      self._iprot.readMessageEnd()
5880 
      raise x
5881 
    result = setOrderAttributeForTransaction_result()
5882 
    result.read(self._iprot)
5883 
    self._iprot.readMessageEnd()
5884 
    return
5885 
 
5553 rajveer 5886 
  def getReceivePendingOrders(self, storeId):
5887 
    """
5888 
    Parameters:
5889 
     - storeId
5890 
    """
5891 
    self.send_getReceivePendingOrders(storeId)
5892 
    return self.recv_getReceivePendingOrders()
5527 anupam.sin 5893 
 
5553 rajveer 5894 
  def send_getReceivePendingOrders(self, storeId):
5895 
    self._oprot.writeMessageBegin('getReceivePendingOrders', TMessageType.CALL, self._seqid)
5896 
    args = getReceivePendingOrders_args()
5897 
    args.storeId = storeId
5898 
    args.write(self._oprot)
5899 
    self._oprot.writeMessageEnd()
5900 
    self._oprot.trans.flush()
5901 
 
5902 
  def recv_getReceivePendingOrders(self, ):
5903 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5904 
    if mtype == TMessageType.EXCEPTION:
5905 
      x = TApplicationException()
5906 
      x.read(self._iprot)
5907 
      self._iprot.readMessageEnd()
5908 
      raise x
5909 
    result = getReceivePendingOrders_result()
5910 
    result.read(self._iprot)
5911 
    self._iprot.readMessageEnd()
5912 
    if result.success is not None:
5913 
      return result.success
5914 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReceivePendingOrders failed: unknown result");
5915 
 
5916 
  def getReceivedAtStoreOrders(self, storeId):
5917 
    """
5918 
    Parameters:
5919 
     - storeId
5920 
    """
5921 
    self.send_getReceivedAtStoreOrders(storeId)
5922 
    return self.recv_getReceivedAtStoreOrders()
5923 
 
5924 
  def send_getReceivedAtStoreOrders(self, storeId):
5925 
    self._oprot.writeMessageBegin('getReceivedAtStoreOrders', TMessageType.CALL, self._seqid)
5926 
    args = getReceivedAtStoreOrders_args()
5927 
    args.storeId = storeId
5928 
    args.write(self._oprot)
5929 
    self._oprot.writeMessageEnd()
5930 
    self._oprot.trans.flush()
5931 
 
5932 
  def recv_getReceivedAtStoreOrders(self, ):
5933 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5934 
    if mtype == TMessageType.EXCEPTION:
5935 
      x = TApplicationException()
5936 
      x.read(self._iprot)
5937 
      self._iprot.readMessageEnd()
5938 
      raise x
5939 
    result = getReceivedAtStoreOrders_result()
5940 
    result.read(self._iprot)
5941 
    self._iprot.readMessageEnd()
5942 
    if result.success is not None:
5943 
      return result.success
5944 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReceivedAtStoreOrders failed: unknown result");
5945 
 
5713 rajveer 5946 
  def getOrdersCollectionAtStore(self, storeId, fromDate, toDate, onlyCod):
5947 
    """
5948 
    Parameters:
5949 
     - storeId
5950 
     - fromDate
5951 
     - toDate
5952 
     - onlyCod
5953 
    """
5954 
    self.send_getOrdersCollectionAtStore(storeId, fromDate, toDate, onlyCod)
5955 
    return self.recv_getOrdersCollectionAtStore()
5956 
 
5957 
  def send_getOrdersCollectionAtStore(self, storeId, fromDate, toDate, onlyCod):
5958 
    self._oprot.writeMessageBegin('getOrdersCollectionAtStore', TMessageType.CALL, self._seqid)
5959 
    args = getOrdersCollectionAtStore_args()
5960 
    args.storeId = storeId
5961 
    args.fromDate = fromDate
5962 
    args.toDate = toDate
5963 
    args.onlyCod = onlyCod
5964 
    args.write(self._oprot)
5965 
    self._oprot.writeMessageEnd()
5966 
    self._oprot.trans.flush()
5967 
 
5968 
  def recv_getOrdersCollectionAtStore(self, ):
5969 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5970 
    if mtype == TMessageType.EXCEPTION:
5971 
      x = TApplicationException()
5972 
      x.read(self._iprot)
5973 
      self._iprot.readMessageEnd()
5974 
      raise x
5975 
    result = getOrdersCollectionAtStore_result()
5976 
    result.read(self._iprot)
5977 
    self._iprot.readMessageEnd()
5978 
    if result.success is not None:
5979 
      return result.success
5980 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersCollectionAtStore failed: unknown result");
5981 
 
5833 rajveer 5982 
  def getOrderAttributeValue(self, orderId, attributeName):
5983 
    """
5984 
    Parameters:
5985 
     - orderId
5986 
     - attributeName
5987 
    """
5988 
    self.send_getOrderAttributeValue(orderId, attributeName)
5989 
    return self.recv_getOrderAttributeValue()
5990 
 
5991 
  def send_getOrderAttributeValue(self, orderId, attributeName):
5992 
    self._oprot.writeMessageBegin('getOrderAttributeValue', TMessageType.CALL, self._seqid)
5993 
    args = getOrderAttributeValue_args()
5994 
    args.orderId = orderId
5995 
    args.attributeName = attributeName
5996 
    args.write(self._oprot)
5997 
    self._oprot.writeMessageEnd()
5998 
    self._oprot.trans.flush()
5999 
 
6000 
  def recv_getOrderAttributeValue(self, ):
6001 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6002 
    if mtype == TMessageType.EXCEPTION:
6003 
      x = TApplicationException()
6004 
      x.read(self._iprot)
6005 
      self._iprot.readMessageEnd()
6006 
      raise x
6007 
    result = getOrderAttributeValue_result()
6008 
    result.read(self._iprot)
6009 
    self._iprot.readMessageEnd()
6010 
    if result.success is not None:
6011 
      return result.success
6012 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderAttributeValue failed: unknown result");
6013 
 
6019 rajveer 6014 
  def changeJacketNumber(self, orderId, jacketNumber):
6015 
    """
6016 
    Parameters:
6017 
     - orderId
6018 
     - jacketNumber
6019 
    """
6020 
    self.send_changeJacketNumber(orderId, jacketNumber)
6021 
    return self.recv_changeJacketNumber()
6022 
 
6023 
  def send_changeJacketNumber(self, orderId, jacketNumber):
6024 
    self._oprot.writeMessageBegin('changeJacketNumber', TMessageType.CALL, self._seqid)
6025 
    args = changeJacketNumber_args()
6026 
    args.orderId = orderId
6027 
    args.jacketNumber = jacketNumber
6028 
    args.write(self._oprot)
6029 
    self._oprot.writeMessageEnd()
6030 
    self._oprot.trans.flush()
6031 
 
6032 
  def recv_changeJacketNumber(self, ):
6033 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6034 
    if mtype == TMessageType.EXCEPTION:
6035 
      x = TApplicationException()
6036 
      x.read(self._iprot)
6037 
      self._iprot.readMessageEnd()
6038 
      raise x
6039 
    result = changeJacketNumber_result()
6040 
    result.read(self._iprot)
6041 
    self._iprot.readMessageEnd()
6042 
    if result.success is not None:
6043 
      return result.success
6044 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "changeJacketNumber failed: unknown result");
6045 
 
6046 
  def markOrderAsRtoInTransit(self, orderId):
6047 
    """
6048 
    Parameters:
6049 
     - orderId
6050 
    """
6051 
    self.send_markOrderAsRtoInTransit(orderId)
6052 
    return self.recv_markOrderAsRtoInTransit()
6053 
 
6054 
  def send_markOrderAsRtoInTransit(self, orderId):
6055 
    self._oprot.writeMessageBegin('markOrderAsRtoInTransit', TMessageType.CALL, self._seqid)
6056 
    args = markOrderAsRtoInTransit_args()
6057 
    args.orderId = orderId
6058 
    args.write(self._oprot)
6059 
    self._oprot.writeMessageEnd()
6060 
    self._oprot.trans.flush()
6061 
 
6062 
  def recv_markOrderAsRtoInTransit(self, ):
6063 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6064 
    if mtype == TMessageType.EXCEPTION:
6065 
      x = TApplicationException()
6066 
      x.read(self._iprot)
6067 
      self._iprot.readMessageEnd()
6068 
      raise x
6069 
    result = markOrderAsRtoInTransit_result()
6070 
    result.read(self._iprot)
6071 
    self._iprot.readMessageEnd()
6072 
    if result.success is not None:
6073 
      return result.success
6074 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderAsRtoInTransit failed: unknown result");
6075 
 
5593 mandeep.dh 6076 
  def acceptOrderForItem(self, itemId, quantity, fulfilmentWarehouseId, billingWarehouseId):
6077 
    """
6078 
    Accepts appropriate order for an item in a given billingWarehouse. Usually
6079 
    invoked while scanning IN of items.
5553 rajveer 6080 
 
5593 mandeep.dh 6081 
    Parameters:
6082 
     - itemId
6083 
     - quantity
6084 
     - fulfilmentWarehouseId
6085 
     - billingWarehouseId
6086 
    """
6087 
    self.send_acceptOrderForItem(itemId, quantity, fulfilmentWarehouseId, billingWarehouseId)
6088 
    self.recv_acceptOrderForItem()
6089 
 
6090 
  def send_acceptOrderForItem(self, itemId, quantity, fulfilmentWarehouseId, billingWarehouseId):
6091 
    self._oprot.writeMessageBegin('acceptOrderForItem', TMessageType.CALL, self._seqid)
6092 
    args = acceptOrderForItem_args()
6093 
    args.itemId = itemId
6094 
    args.quantity = quantity
6095 
    args.fulfilmentWarehouseId = fulfilmentWarehouseId
6096 
    args.billingWarehouseId = billingWarehouseId
6097 
    args.write(self._oprot)
6098 
    self._oprot.writeMessageEnd()
6099 
    self._oprot.trans.flush()
6100 
 
6101 
  def recv_acceptOrderForItem(self, ):
6102 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6103 
    if mtype == TMessageType.EXCEPTION:
6104 
      x = TApplicationException()
6105 
      x.read(self._iprot)
6106 
      self._iprot.readMessageEnd()
6107 
      raise x
6108 
    result = acceptOrderForItem_result()
6109 
    result.read(self._iprot)
6110 
    self._iprot.readMessageEnd()
6111 
    return
6112 
 
6000 mandeep.dh 6113 
  def createRechargeOrder(self, rechargeOrder):
6114 
    """
6115 
    Parameters:
6116 
     - rechargeOrder
6117 
    """
6118 
    self.send_createRechargeOrder(rechargeOrder)
6119 
    return self.recv_createRechargeOrder()
5593 mandeep.dh 6120 
 
6000 mandeep.dh 6121 
  def send_createRechargeOrder(self, rechargeOrder):
6122 
    self._oprot.writeMessageBegin('createRechargeOrder', TMessageType.CALL, self._seqid)
6123 
    args = createRechargeOrder_args()
6124 
    args.rechargeOrder = rechargeOrder
6125 
    args.write(self._oprot)
6126 
    self._oprot.writeMessageEnd()
6127 
    self._oprot.trans.flush()
6128 
 
6129 
  def recv_createRechargeOrder(self, ):
6130 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6131 
    if mtype == TMessageType.EXCEPTION:
6132 
      x = TApplicationException()
6133 
      x.read(self._iprot)
6134 
      self._iprot.readMessageEnd()
6135 
      raise x
6136 
    result = createRechargeOrder_result()
6137 
    result.read(self._iprot)
6138 
    self._iprot.readMessageEnd()
6139 
    if result.success is not None:
6140 
      return result.success
6141 
    if result.ex is not None:
6142 
      raise result.ex
6143 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createRechargeOrder failed: unknown result");
6144 
 
6031 rajveer 6145 
  def getRechargeOrder(self, rechargeRrderId):
6146 
    """
6147 
    Parameters:
6148 
     - rechargeRrderId
6149 
    """
6150 
    self.send_getRechargeOrder(rechargeRrderId)
6151 
    return self.recv_getRechargeOrder()
6152 
 
6153 
  def send_getRechargeOrder(self, rechargeRrderId):
6154 
    self._oprot.writeMessageBegin('getRechargeOrder', TMessageType.CALL, self._seqid)
6155 
    args = getRechargeOrder_args()
6156 
    args.rechargeRrderId = rechargeRrderId
6157 
    args.write(self._oprot)
6158 
    self._oprot.writeMessageEnd()
6159 
    self._oprot.trans.flush()
6160 
 
6161 
  def recv_getRechargeOrder(self, ):
6162 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6163 
    if mtype == TMessageType.EXCEPTION:
6164 
      x = TApplicationException()
6165 
      x.read(self._iprot)
6166 
      self._iprot.readMessageEnd()
6167 
      raise x
6168 
    result = getRechargeOrder_result()
6169 
    result.read(self._iprot)
6170 
    self._iprot.readMessageEnd()
6171 
    if result.success is not None:
6172 
      return result.success
6173 
    if result.ex is not None:
6174 
      raise result.ex
6175 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getRechargeOrder failed: unknown result");
6176 
 
6177 
  def getRechargeOrders(self, userId):
6178 
    """
6179 
    Parameters:
6180 
     - userId
6181 
    """
6182 
    self.send_getRechargeOrders(userId)
6183 
    return self.recv_getRechargeOrders()
6184 
 
6185 
  def send_getRechargeOrders(self, userId):
6186 
    self._oprot.writeMessageBegin('getRechargeOrders', TMessageType.CALL, self._seqid)
6187 
    args = getRechargeOrders_args()
6188 
    args.userId = userId
6189 
    args.write(self._oprot)
6190 
    self._oprot.writeMessageEnd()
6191 
    self._oprot.trans.flush()
6192 
 
6193 
  def recv_getRechargeOrders(self, ):
6194 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6195 
    if mtype == TMessageType.EXCEPTION:
6196 
      x = TApplicationException()
6197 
      x.read(self._iprot)
6198 
      self._iprot.readMessageEnd()
6199 
      raise x
6200 
    result = getRechargeOrders_result()
6201 
    result.read(self._iprot)
6202 
    self._iprot.readMessageEnd()
6203 
    if result.success is not None:
6204 
      return result.success
6205 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getRechargeOrders failed: unknown result");
6206 
 
6000 mandeep.dh 6207 
  def updateRechargeOrderStatus(self, rechargeOrderId, rechargeOrderStatus):
6208 
    """
6209 
    Parameters:
6210 
     - rechargeOrderId
6211 
     - rechargeOrderStatus
6212 
    """
6213 
    self.send_updateRechargeOrderStatus(rechargeOrderId, rechargeOrderStatus)
6031 rajveer 6214 
    return self.recv_updateRechargeOrderStatus()
6000 mandeep.dh 6215 
 
6216 
  def send_updateRechargeOrderStatus(self, rechargeOrderId, rechargeOrderStatus):
6217 
    self._oprot.writeMessageBegin('updateRechargeOrderStatus', TMessageType.CALL, self._seqid)
6218 
    args = updateRechargeOrderStatus_args()
6219 
    args.rechargeOrderId = rechargeOrderId
6220 
    args.rechargeOrderStatus = rechargeOrderStatus
6221 
    args.write(self._oprot)
6222 
    self._oprot.writeMessageEnd()
6223 
    self._oprot.trans.flush()
6224 
 
6225 
  def recv_updateRechargeOrderStatus(self, ):
6226 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6227 
    if mtype == TMessageType.EXCEPTION:
6228 
      x = TApplicationException()
6229 
      x.read(self._iprot)
6230 
      self._iprot.readMessageEnd()
6231 
      raise x
6232 
    result = updateRechargeOrderStatus_result()
6233 
    result.read(self._iprot)
6234 
    self._iprot.readMessageEnd()
6031 rajveer 6235 
    if result.success is not None:
6236 
      return result.success
6000 mandeep.dh 6237 
    if result.ex is not None:
6238 
      raise result.ex
6031 rajveer 6239 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updateRechargeOrderStatus failed: unknown result");
6000 mandeep.dh 6240 
 
6031 rajveer 6241 
  def activateRechargeTxn(self, rechargeOrderId):
6000 mandeep.dh 6242 
    """
6243 
    Parameters:
6031 rajveer 6244 
     - rechargeOrderId
6000 mandeep.dh 6245 
    """
6031 rajveer 6246 
    self.send_activateRechargeTxn(rechargeOrderId)
6000 mandeep.dh 6247 
    return self.recv_activateRechargeTxn()
6248 
 
6031 rajveer 6249 
  def send_activateRechargeTxn(self, rechargeOrderId):
6000 mandeep.dh 6250 
    self._oprot.writeMessageBegin('activateRechargeTxn', TMessageType.CALL, self._seqid)
6251 
    args = activateRechargeTxn_args()
6031 rajveer 6252 
    args.rechargeOrderId = rechargeOrderId
6000 mandeep.dh 6253 
    args.write(self._oprot)
6254 
    self._oprot.writeMessageEnd()
6255 
    self._oprot.trans.flush()
6256 
 
6257 
  def recv_activateRechargeTxn(self, ):
6258 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6259 
    if mtype == TMessageType.EXCEPTION:
6260 
      x = TApplicationException()
6261 
      x.read(self._iprot)
6262 
      self._iprot.readMessageEnd()
6263 
      raise x
6264 
    result = activateRechargeTxn_result()
6265 
    result.read(self._iprot)
6266 
    self._iprot.readMessageEnd()
6267 
    if result.success is not None:
6268 
      return result.success
6269 
    if result.ex is not None:
6270 
      raise result.ex
6271 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "activateRechargeTxn failed: unknown result");
6272 
 
6031 rajveer 6273 
  def getUserWallet(self, userId):
6000 mandeep.dh 6274 
    """
6275 
    Parameters:
6031 rajveer 6276 
     - userId
6000 mandeep.dh 6277 
    """
6031 rajveer 6278 
    self.send_getUserWallet(userId)
6279 
    return self.recv_getUserWallet()
6000 mandeep.dh 6280 
 
6031 rajveer 6281 
  def send_getUserWallet(self, userId):
6282 
    self._oprot.writeMessageBegin('getUserWallet', TMessageType.CALL, self._seqid)
6283 
    args = getUserWallet_args()
6284 
    args.userId = userId
6000 mandeep.dh 6285 
    args.write(self._oprot)
6286 
    self._oprot.writeMessageEnd()
6287 
    self._oprot.trans.flush()
6288 
 
6031 rajveer 6289 
  def recv_getUserWallet(self, ):
6000 mandeep.dh 6290 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6291 
    if mtype == TMessageType.EXCEPTION:
6292 
      x = TApplicationException()
6293 
      x.read(self._iprot)
6294 
      self._iprot.readMessageEnd()
6295 
      raise x
6031 rajveer 6296 
    result = getUserWallet_result()
6000 mandeep.dh 6297 
    result.read(self._iprot)
6298 
    self._iprot.readMessageEnd()
6299 
    if result.success is not None:
6300 
      return result.success
6031 rajveer 6301 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUserWallet failed: unknown result");
6000 mandeep.dh 6302 
 
6031 rajveer 6303 
  def getUserWalletHistory(self, userId):
6000 mandeep.dh 6304 
    """
6305 
    Parameters:
6031 rajveer 6306 
     - userId
6000 mandeep.dh 6307 
    """
6031 rajveer 6308 
    self.send_getUserWalletHistory(userId)
6309 
    return self.recv_getUserWalletHistory()
6000 mandeep.dh 6310 
 
6031 rajveer 6311 
  def send_getUserWalletHistory(self, userId):
6312 
    self._oprot.writeMessageBegin('getUserWalletHistory', TMessageType.CALL, self._seqid)
6313 
    args = getUserWalletHistory_args()
6314 
    args.userId = userId
6000 mandeep.dh 6315 
    args.write(self._oprot)
6316 
    self._oprot.writeMessageEnd()
6317 
    self._oprot.trans.flush()
6318 
 
6031 rajveer 6319 
  def recv_getUserWalletHistory(self, ):
6000 mandeep.dh 6320 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6321 
    if mtype == TMessageType.EXCEPTION:
6322 
      x = TApplicationException()
6323 
      x.read(self._iprot)
6324 
      self._iprot.readMessageEnd()
6325 
      raise x
6031 rajveer 6326 
    result = getUserWalletHistory_result()
6000 mandeep.dh 6327 
    result.read(self._iprot)
6328 
    self._iprot.readMessageEnd()
6329 
    if result.success is not None:
6330 
      return result.success
6031 rajveer 6331 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUserWalletHistory failed: unknown result");
6000 mandeep.dh 6332 
 
6050 anupam.sin 6333 
  def getRechargeOrdersForTransaction(self, txnId):
6334 
    """
6335 
    Returns a recharge order for a given transactionId
6336 
 
6337 
    Parameters:
6338 
     - txnId
6339 
    """
6340 
    self.send_getRechargeOrdersForTransaction(txnId)
6341 
    return self.recv_getRechargeOrdersForTransaction()
6342 
 
6343 
  def send_getRechargeOrdersForTransaction(self, txnId):
6344 
    self._oprot.writeMessageBegin('getRechargeOrdersForTransaction', TMessageType.CALL, self._seqid)
6345 
    args = getRechargeOrdersForTransaction_args()
6346 
    args.txnId = txnId
6347 
    args.write(self._oprot)
6348 
    self._oprot.writeMessageEnd()
6349 
    self._oprot.trans.flush()
6350 
 
6351 
  def recv_getRechargeOrdersForTransaction(self, ):
6352 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6353 
    if mtype == TMessageType.EXCEPTION:
6354 
      x = TApplicationException()
6355 
      x.read(self._iprot)
6356 
      self._iprot.readMessageEnd()
6357 
      raise x
6358 
    result = getRechargeOrdersForTransaction_result()
6359 
    result.read(self._iprot)
6360 
    self._iprot.readMessageEnd()
6361 
    if result.success is not None:
6362 
      return result.success
6363 
    if result.ex is not None:
6364 
      raise result.ex
6365 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getRechargeOrdersForTransaction failed: unknown result");
6366 
 
6206 rajveer 6367 
  def getServiceProviders(self, rechargeType, onlyActive):
6048 rajveer 6368 
    """
6369 
    Parameters:
6370 
     - rechargeType
6206 rajveer 6371 
     - onlyActive
6048 rajveer 6372 
    """
6206 rajveer 6373 
    self.send_getServiceProviders(rechargeType, onlyActive)
6048 rajveer 6374 
    return self.recv_getServiceProviders()
6000 mandeep.dh 6375 
 
6206 rajveer 6376 
  def send_getServiceProviders(self, rechargeType, onlyActive):
6048 rajveer 6377 
    self._oprot.writeMessageBegin('getServiceProviders', TMessageType.CALL, self._seqid)
6378 
    args = getServiceProviders_args()
6379 
    args.rechargeType = rechargeType
6206 rajveer 6380 
    args.onlyActive = onlyActive
6048 rajveer 6381 
    args.write(self._oprot)
6382 
    self._oprot.writeMessageEnd()
6383 
    self._oprot.trans.flush()
6384 
 
6385 
  def recv_getServiceProviders(self, ):
6386 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6387 
    if mtype == TMessageType.EXCEPTION:
6388 
      x = TApplicationException()
6389 
      x.read(self._iprot)
6390 
      self._iprot.readMessageEnd()
6391 
      raise x
6392 
    result = getServiceProviders_result()
6393 
    result.read(self._iprot)
6394 
    self._iprot.readMessageEnd()
6395 
    if result.success is not None:
6396 
      return result.success
6397 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getServiceProviders failed: unknown result");
6398 
 
6049 rajveer 6399 
  def getServiceProviderForDevice(self, rechargeType, deviceNumber):
6048 rajveer 6400 
    """
6401 
    Parameters:
6049 rajveer 6402 
     - rechargeType
6048 rajveer 6403 
     - deviceNumber
6404 
    """
6049 rajveer 6405 
    self.send_getServiceProviderForDevice(rechargeType, deviceNumber)
6048 rajveer 6406 
    return self.recv_getServiceProviderForDevice()
6407 
 
6049 rajveer 6408 
  def send_getServiceProviderForDevice(self, rechargeType, deviceNumber):
6048 rajveer 6409 
    self._oprot.writeMessageBegin('getServiceProviderForDevice', TMessageType.CALL, self._seqid)
6410 
    args = getServiceProviderForDevice_args()
6049 rajveer 6411 
    args.rechargeType = rechargeType
6048 rajveer 6412 
    args.deviceNumber = deviceNumber
6413 
    args.write(self._oprot)
6414 
    self._oprot.writeMessageEnd()
6415 
    self._oprot.trans.flush()
6416 
 
6417 
  def recv_getServiceProviderForDevice(self, ):
6418 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6419 
    if mtype == TMessageType.EXCEPTION:
6420 
      x = TApplicationException()
6421 
      x.read(self._iprot)
6422 
      self._iprot.readMessageEnd()
6423 
      raise x
6424 
    result = getServiceProviderForDevice_result()
6425 
    result.read(self._iprot)
6426 
    self._iprot.readMessageEnd()
6427 
    if result.success is not None:
6428 
      return result.success
6429 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getServiceProviderForDevice failed: unknown result");
6430 
 
6591 anupam.sin 6431 
  def validateRecharge(self, rechargeType, deviceNumber, userSelectedProviderId, clientAddress):
6269 rajveer 6432 
    """
6433 
    Parameters:
6434 
     - rechargeType
6435 
     - deviceNumber
6307 anupam.sin 6436 
     - userSelectedProviderId
6591 anupam.sin 6437 
     - clientAddress
6269 rajveer 6438 
    """
6591 anupam.sin 6439 
    self.send_validateRecharge(rechargeType, deviceNumber, userSelectedProviderId, clientAddress)
6269 rajveer 6440 
    return self.recv_validateRecharge()
6441 
 
6591 anupam.sin 6442 
  def send_validateRecharge(self, rechargeType, deviceNumber, userSelectedProviderId, clientAddress):
6269 rajveer 6443 
    self._oprot.writeMessageBegin('validateRecharge', TMessageType.CALL, self._seqid)
6444 
    args = validateRecharge_args()
6445 
    args.rechargeType = rechargeType
6446 
    args.deviceNumber = deviceNumber
6307 anupam.sin 6447 
    args.userSelectedProviderId = userSelectedProviderId
6591 anupam.sin 6448 
    args.clientAddress = clientAddress
6269 rajveer 6449 
    args.write(self._oprot)
6450 
    self._oprot.writeMessageEnd()
6451 
    self._oprot.trans.flush()
6452 
 
6453 
  def recv_validateRecharge(self, ):
6454 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6455 
    if mtype == TMessageType.EXCEPTION:
6456 
      x = TApplicationException()
6457 
      x.read(self._iprot)
6458 
      self._iprot.readMessageEnd()
6459 
      raise x
6460 
    result = validateRecharge_result()
6461 
    result.read(self._iprot)
6462 
    self._iprot.readMessageEnd()
6463 
    if result.success is not None:
6464 
      return result.success
6465 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "validateRecharge failed: unknown result");
6466 
 
6094 rajveer 6467 
  def getRechargeOrdersForDevice(self, deviceNumber):
6468 
    """
6469 
    Parameters:
6470 
     - deviceNumber
6471 
    """
6472 
    self.send_getRechargeOrdersForDevice(deviceNumber)
6473 
    return self.recv_getRechargeOrdersForDevice()
6048 rajveer 6474 
 
6094 rajveer 6475 
  def send_getRechargeOrdersForDevice(self, deviceNumber):
6476 
    self._oprot.writeMessageBegin('getRechargeOrdersForDevice', TMessageType.CALL, self._seqid)
6477 
    args = getRechargeOrdersForDevice_args()
6478 
    args.deviceNumber = deviceNumber
6479 
    args.write(self._oprot)
6480 
    self._oprot.writeMessageEnd()
6481 
    self._oprot.trans.flush()
6482 
 
6483 
  def recv_getRechargeOrdersForDevice(self, ):
6484 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6485 
    if mtype == TMessageType.EXCEPTION:
6486 
      x = TApplicationException()
6487 
      x.read(self._iprot)
6488 
      self._iprot.readMessageEnd()
6489 
      raise x
6490 
    result = getRechargeOrdersForDevice_result()
6491 
    result.read(self._iprot)
6492 
    self._iprot.readMessageEnd()
6493 
    if result.success is not None:
6494 
      return result.success
6495 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getRechargeOrdersForDevice failed: unknown result");
6496 
 
6497 
  def addAmountToWallet(self, userId, orderId, amount):
6498 
    """
6499 
    Parameters:
6500 
     - userId
6501 
     - orderId
6502 
     - amount
6503 
    """
6504 
    self.send_addAmountToWallet(userId, orderId, amount)
6505 
    self.recv_addAmountToWallet()
6506 
 
6507 
  def send_addAmountToWallet(self, userId, orderId, amount):
6508 
    self._oprot.writeMessageBegin('addAmountToWallet', TMessageType.CALL, self._seqid)
6509 
    args = addAmountToWallet_args()
6510 
    args.userId = userId
6511 
    args.orderId = orderId
6512 
    args.amount = amount
6513 
    args.write(self._oprot)
6514 
    self._oprot.writeMessageEnd()
6515 
    self._oprot.trans.flush()
6516 
 
6517 
  def recv_addAmountToWallet(self, ):
6518 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6519 
    if mtype == TMessageType.EXCEPTION:
6520 
      x = TApplicationException()
6521 
      x.read(self._iprot)
6522 
      self._iprot.readMessageEnd()
6523 
      raise x
6524 
    result = addAmountToWallet_result()
6525 
    result.read(self._iprot)
6526 
    self._iprot.readMessageEnd()
6527 
    return
6528 
 
6188 rajveer 6529 
  def getRechargeStatistics(self, ):
6530 
    self.send_getRechargeStatistics()
6531 
    return self.recv_getRechargeStatistics()
6532 
 
6533 
  def send_getRechargeStatistics(self, ):
6534 
    self._oprot.writeMessageBegin('getRechargeStatistics', TMessageType.CALL, self._seqid)
6535 
    args = getRechargeStatistics_args()
6536 
    args.write(self._oprot)
6537 
    self._oprot.writeMessageEnd()
6538 
    self._oprot.trans.flush()
6539 
 
6540 
  def recv_getRechargeStatistics(self, ):
6541 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6542 
    if mtype == TMessageType.EXCEPTION:
6543 
      x = TApplicationException()
6544 
      x.read(self._iprot)
6545 
      self._iprot.readMessageEnd()
6546 
      raise x
6547 
    result = getRechargeStatistics_result()
6548 
    result.read(self._iprot)
6549 
    self._iprot.readMessageEnd()
6550 
    if result.success is not None:
6551 
      return result.success
6552 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getRechargeStatistics failed: unknown result");
6553 
 
6154 rajveer 6554 
  def getRechargeOrdersForStatus(self, status):
6555 
    """
6556 
    Parameters:
6557 
     - status
6558 
    """
6559 
    self.send_getRechargeOrdersForStatus(status)
6560 
    return self.recv_getRechargeOrdersForStatus()
6094 rajveer 6561 
 
6154 rajveer 6562 
  def send_getRechargeOrdersForStatus(self, status):
6563 
    self._oprot.writeMessageBegin('getRechargeOrdersForStatus', TMessageType.CALL, self._seqid)
6564 
    args = getRechargeOrdersForStatus_args()
6565 
    args.status = status
6566 
    args.write(self._oprot)
6567 
    self._oprot.writeMessageEnd()
6568 
    self._oprot.trans.flush()
6569 
 
6570 
  def recv_getRechargeOrdersForStatus(self, ):
6571 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6572 
    if mtype == TMessageType.EXCEPTION:
6573 
      x = TApplicationException()
6574 
      x.read(self._iprot)
6575 
      self._iprot.readMessageEnd()
6576 
      raise x
6577 
    result = getRechargeOrdersForStatus_result()
6578 
    result.read(self._iprot)
6579 
    self._iprot.readMessageEnd()
6580 
    if result.success is not None:
6581 
      return result.success
6582 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getRechargeOrdersForStatus failed: unknown result");
6583 
 
6159 rajveer 6584 
  def getPlansForOperator(self, operatorId):
6585 
    """
6586 
    Parameters:
6587 
     - operatorId
6588 
    """
6589 
    self.send_getPlansForOperator(operatorId)
6590 
    return self.recv_getPlansForOperator()
6154 rajveer 6591 
 
6159 rajveer 6592 
  def send_getPlansForOperator(self, operatorId):
6593 
    self._oprot.writeMessageBegin('getPlansForOperator', TMessageType.CALL, self._seqid)
6594 
    args = getPlansForOperator_args()
6595 
    args.operatorId = operatorId
6596 
    args.write(self._oprot)
6597 
    self._oprot.writeMessageEnd()
6598 
    self._oprot.trans.flush()
6599 
 
6600 
  def recv_getPlansForOperator(self, ):
6601 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6602 
    if mtype == TMessageType.EXCEPTION:
6603 
      x = TApplicationException()
6604 
      x.read(self._iprot)
6605 
      self._iprot.readMessageEnd()
6606 
      raise x
6607 
    result = getPlansForOperator_result()
6608 
    result.read(self._iprot)
6609 
    self._iprot.readMessageEnd()
6610 
    if result.success is not None:
6611 
      return result.success
6612 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getPlansForOperator failed: unknown result");
6613 
 
6307 anupam.sin 6614 
  def getRechargeDenominations(self, operatorId, circleCode, denominationType):
6289 anupam.sin 6615 
    """
6616 
    Returns denominations for a given operator and circle
6159 rajveer 6617 
 
6289 anupam.sin 6618 
    Parameters:
6619 
     - operatorId
6307 anupam.sin 6620 
     - circleCode
6289 anupam.sin 6621 
     - denominationType
6622 
    """
6307 anupam.sin 6623 
    self.send_getRechargeDenominations(operatorId, circleCode, denominationType)
6289 anupam.sin 6624 
    return self.recv_getRechargeDenominations()
6625 
 
6307 anupam.sin 6626 
  def send_getRechargeDenominations(self, operatorId, circleCode, denominationType):
6289 anupam.sin 6627 
    self._oprot.writeMessageBegin('getRechargeDenominations', TMessageType.CALL, self._seqid)
6628 
    args = getRechargeDenominations_args()
6629 
    args.operatorId = operatorId
6307 anupam.sin 6630 
    args.circleCode = circleCode
6289 anupam.sin 6631 
    args.denominationType = denominationType
6632 
    args.write(self._oprot)
6633 
    self._oprot.writeMessageEnd()
6634 
    self._oprot.trans.flush()
6635 
 
6636 
  def recv_getRechargeDenominations(self, ):
6637 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6638 
    if mtype == TMessageType.EXCEPTION:
6639 
      x = TApplicationException()
6640 
      x.read(self._iprot)
6641 
      self._iprot.readMessageEnd()
6642 
      raise x
6643 
    result = getRechargeDenominations_result()
6644 
    result.read(self._iprot)
6645 
    self._iprot.readMessageEnd()
6646 
    if result.success is not None:
6647 
      return result.success
6648 
    if result.ex is not None:
6649 
      raise result.ex
6650 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getRechargeDenominations failed: unknown result");
6651 
 
6371 rajveer 6652 
  def updateAvailabilityStatus(self, operatorId, circleId, isAvailable):
6653 
    """
6654 
    Parameters:
6655 
     - operatorId
6656 
     - circleId
6657 
     - isAvailable
6658 
    """
6659 
    self.send_updateAvailabilityStatus(operatorId, circleId, isAvailable)
6660 
    self.recv_updateAvailabilityStatus()
6289 anupam.sin 6661 
 
6371 rajveer 6662 
  def send_updateAvailabilityStatus(self, operatorId, circleId, isAvailable):
6663 
    self._oprot.writeMessageBegin('updateAvailabilityStatus', TMessageType.CALL, self._seqid)
6664 
    args = updateAvailabilityStatus_args()
6665 
    args.operatorId = operatorId
6666 
    args.circleId = circleId
6667 
    args.isAvailable = isAvailable
6668 
    args.write(self._oprot)
6669 
    self._oprot.writeMessageEnd()
6670 
    self._oprot.trans.flush()
6671 
 
6672 
  def recv_updateAvailabilityStatus(self, ):
6673 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6674 
    if mtype == TMessageType.EXCEPTION:
6675 
      x = TApplicationException()
6676 
      x.read(self._iprot)
6677 
      self._iprot.readMessageEnd()
6678 
      raise x
6679 
    result = updateAvailabilityStatus_result()
6680 
    result.read(self._iprot)
6681 
    self._iprot.readMessageEnd()
6682 
    return
6683 
 
6389 rajveer 6684 
  def getAvailableEmiSchemes(self, ):
6685 
    self.send_getAvailableEmiSchemes()
6686 
    return self.recv_getAvailableEmiSchemes()
6371 rajveer 6687 
 
6389 rajveer 6688 
  def send_getAvailableEmiSchemes(self, ):
6689 
    self._oprot.writeMessageBegin('getAvailableEmiSchemes', TMessageType.CALL, self._seqid)
6690 
    args = getAvailableEmiSchemes_args()
6691 
    args.write(self._oprot)
6692 
    self._oprot.writeMessageEnd()
6693 
    self._oprot.trans.flush()
6694 
 
6695 
  def recv_getAvailableEmiSchemes(self, ):
6696 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6697 
    if mtype == TMessageType.EXCEPTION:
6698 
      x = TApplicationException()
6699 
      x.read(self._iprot)
6700 
      self._iprot.readMessageEnd()
6701 
      raise x
6702 
    result = getAvailableEmiSchemes_result()
6703 
    result.read(self._iprot)
6704 
    self._iprot.readMessageEnd()
6705 
    if result.success is not None:
6706 
      return result.success
6707 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAvailableEmiSchemes failed: unknown result");
6708 
 
6709 
  def getMiscCharges(self, transactionId):
6710 
    """
6711 
    Parameters:
6712 
     - transactionId
6713 
    """
6714 
    self.send_getMiscCharges(transactionId)
6715 
    return self.recv_getMiscCharges()
6716 
 
6717 
  def send_getMiscCharges(self, transactionId):
6718 
    self._oprot.writeMessageBegin('getMiscCharges', TMessageType.CALL, self._seqid)
6719 
    args = getMiscCharges_args()
6720 
    args.transactionId = transactionId
6721 
    args.write(self._oprot)
6722 
    self._oprot.writeMessageEnd()
6723 
    self._oprot.trans.flush()
6724 
 
6725 
  def recv_getMiscCharges(self, ):
6726 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6727 
    if mtype == TMessageType.EXCEPTION:
6728 
      x = TApplicationException()
6729 
      x.read(self._iprot)
6730 
      self._iprot.readMessageEnd()
6731 
      raise x
6732 
    result = getMiscCharges_result()
6733 
    result.read(self._iprot)
6734 
    self._iprot.readMessageEnd()
6735 
    if result.success is not None:
6736 
      return result.success
6737 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getMiscCharges failed: unknown result");
6738 
 
6507 anupam.sin 6739 
  def refundRechargeOrder(self, rechargeOrderId):
6740 
    """
6741 
    Parameters:
6742 
     - rechargeOrderId
6743 
    """
6744 
    self.send_refundRechargeOrder(rechargeOrderId)
6745 
    return self.recv_refundRechargeOrder()
6389 rajveer 6746 
 
6507 anupam.sin 6747 
  def send_refundRechargeOrder(self, rechargeOrderId):
6748 
    self._oprot.writeMessageBegin('refundRechargeOrder', TMessageType.CALL, self._seqid)
6749 
    args = refundRechargeOrder_args()
6750 
    args.rechargeOrderId = rechargeOrderId
6751 
    args.write(self._oprot)
6752 
    self._oprot.writeMessageEnd()
6753 
    self._oprot.trans.flush()
6754 
 
6755 
  def recv_refundRechargeOrder(self, ):
6756 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6757 
    if mtype == TMessageType.EXCEPTION:
6758 
      x = TApplicationException()
6759 
      x.read(self._iprot)
6760 
      self._iprot.readMessageEnd()
6761 
      raise x
6762 
    result = refundRechargeOrder_result()
6763 
    result.read(self._iprot)
6764 
    self._iprot.readMessageEnd()
6765 
    if result.success is not None:
6766 
      return result.success
6767 
    if result.ex is not None:
6768 
      raise result.ex
6769 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "refundRechargeOrder failed: unknown result");
6770 
 
6821 amar.kumar 6771 
  def getPhysicalOrders(self, fromDate, toDate):
6772 
    """
6773 
    Parameters:
6774 
     - fromDate
6775 
     - toDate
6776 
    """
6777 
    self.send_getPhysicalOrders(fromDate, toDate)
6778 
    return self.recv_getPhysicalOrders()
6507 anupam.sin 6779 
 
6821 amar.kumar 6780 
  def send_getPhysicalOrders(self, fromDate, toDate):
6781 
    self._oprot.writeMessageBegin('getPhysicalOrders', TMessageType.CALL, self._seqid)
6782 
    args = getPhysicalOrders_args()
6783 
    args.fromDate = fromDate
6784 
    args.toDate = toDate
6785 
    args.write(self._oprot)
6786 
    self._oprot.writeMessageEnd()
6787 
    self._oprot.trans.flush()
6788 
 
6789 
  def recv_getPhysicalOrders(self, ):
6790 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6791 
    if mtype == TMessageType.EXCEPTION:
6792 
      x = TApplicationException()
6793 
      x.read(self._iprot)
6794 
      self._iprot.readMessageEnd()
6795 
      raise x
6796 
    result = getPhysicalOrders_result()
6797 
    result.read(self._iprot)
6798 
    self._iprot.readMessageEnd()
6799 
    if result.success is not None:
6800 
      return result.success
6801 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getPhysicalOrders failed: unknown result");
6802 
 
6906 rajveer 6803 
  def getDocument(self, docType, docSource):
6804 
    """
6805 
    Parameters:
6806 
     - docType
6807 
     - docSource
6808 
    """
6809 
    self.send_getDocument(docType, docSource)
6810 
    return self.recv_getDocument()
6821 amar.kumar 6811 
 
6906 rajveer 6812 
  def send_getDocument(self, docType, docSource):
6813 
    self._oprot.writeMessageBegin('getDocument', TMessageType.CALL, self._seqid)
6814 
    args = getDocument_args()
6815 
    args.docType = docType
6816 
    args.docSource = docSource
6817 
    args.write(self._oprot)
6818 
    self._oprot.writeMessageEnd()
6819 
    self._oprot.trans.flush()
6820 
 
6821 
  def recv_getDocument(self, ):
6822 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6823 
    if mtype == TMessageType.EXCEPTION:
6824 
      x = TApplicationException()
6825 
      x.read(self._iprot)
6826 
      self._iprot.readMessageEnd()
6827 
      raise x
6828 
    result = getDocument_result()
6829 
    result.read(self._iprot)
6830 
    self._iprot.readMessageEnd()
6831 
    if result.success is not None:
6832 
      return result.success
6833 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getDocument failed: unknown result");
6834 
 
6985 anupam.sin 6835 
  def changeShippingAddress(self, orderId, line1, line2, city, state, pin):
6836 
    """
6837 
    Parameters:
6838 
     - orderId
6839 
     - line1
6840 
     - line2
6841 
     - city
6842 
     - state
6843 
     - pin
6844 
    """
6845 
    self.send_changeShippingAddress(orderId, line1, line2, city, state, pin)
6846 
    return self.recv_changeShippingAddress()
6906 rajveer 6847 
 
6985 anupam.sin 6848 
  def send_changeShippingAddress(self, orderId, line1, line2, city, state, pin):
6849 
    self._oprot.writeMessageBegin('changeShippingAddress', TMessageType.CALL, self._seqid)
6850 
    args = changeShippingAddress_args()
6851 
    args.orderId = orderId
6852 
    args.line1 = line1
6853 
    args.line2 = line2
6854 
    args.city = city
6855 
    args.state = state
6856 
    args.pin = pin
6857 
    args.write(self._oprot)
6858 
    self._oprot.writeMessageEnd()
6859 
    self._oprot.trans.flush()
6860 
 
6861 
  def recv_changeShippingAddress(self, ):
6862 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6863 
    if mtype == TMessageType.EXCEPTION:
6864 
      x = TApplicationException()
6865 
      x.read(self._iprot)
6866 
      self._iprot.readMessageEnd()
6867 
      raise x
6868 
    result = changeShippingAddress_result()
6869 
    result.read(self._iprot)
6870 
    self._iprot.readMessageEnd()
6871 
    if result.success is not None:
6872 
      return result.success
6873 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "changeShippingAddress failed: unknown result");
6874 
 
7075 rajveer 6875 
  def retrieveInvoice(self, orderId, userId):
6988 rajveer 6876 
    """
6877 
    Parameters:
6878 
     - orderId
7075 rajveer 6879 
     - userId
6988 rajveer 6880 
    """
7075 rajveer 6881 
    self.send_retrieveInvoice(orderId, userId)
6988 rajveer 6882 
    return self.recv_retrieveInvoice()
6985 anupam.sin 6883 
 
7075 rajveer 6884 
  def send_retrieveInvoice(self, orderId, userId):
6988 rajveer 6885 
    self._oprot.writeMessageBegin('retrieveInvoice', TMessageType.CALL, self._seqid)
6886 
    args = retrieveInvoice_args()
6887 
    args.orderId = orderId
7075 rajveer 6888 
    args.userId = userId
6988 rajveer 6889 
    args.write(self._oprot)
6890 
    self._oprot.writeMessageEnd()
6891 
    self._oprot.trans.flush()
6892 
 
6893 
  def recv_retrieveInvoice(self, ):
6894 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6895 
    if mtype == TMessageType.EXCEPTION:
6896 
      x = TApplicationException()
6897 
      x.read(self._iprot)
6898 
      self._iprot.readMessageEnd()
6899 
      raise x
6900 
    result = retrieveInvoice_result()
6901 
    result.read(self._iprot)
6902 
    self._iprot.readMessageEnd()
6903 
    if result.success is not None:
6904 
      return result.success
6905 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "retrieveInvoice failed: unknown result");
6906 
 
7026 rajveer 6907 
  def receiveUpdatesForRedExpress(self, awbNumber):
6908 
    """
6909 
    Parameters:
6910 
     - awbNumber
6911 
    """
6912 
    self.send_receiveUpdatesForRedExpress(awbNumber)
6913 
    return self.recv_receiveUpdatesForRedExpress()
6988 rajveer 6914 
 
7026 rajveer 6915 
  def send_receiveUpdatesForRedExpress(self, awbNumber):
6916 
    self._oprot.writeMessageBegin('receiveUpdatesForRedExpress', TMessageType.CALL, self._seqid)
6917 
    args = receiveUpdatesForRedExpress_args()
6918 
    args.awbNumber = awbNumber
6919 
    args.write(self._oprot)
6920 
    self._oprot.writeMessageEnd()
6921 
    self._oprot.trans.flush()
6922 
 
6923 
  def recv_receiveUpdatesForRedExpress(self, ):
6924 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6925 
    if mtype == TMessageType.EXCEPTION:
6926 
      x = TApplicationException()
6927 
      x.read(self._iprot)
6928 
      self._iprot.readMessageEnd()
6929 
      raise x
6930 
    result = receiveUpdatesForRedExpress_result()
6931 
    result.read(self._iprot)
6932 
    self._iprot.readMessageEnd()
6933 
    if result.success is not None:
6934 
      return result.success
6935 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "receiveUpdatesForRedExpress failed: unknown result");
6936 
 
7073 anupam.sin 6937 
  def createRechargeTransaction(self, thriftRechargeTransaction):
6938 
    """
6939 
    Parameters:
6940 
     - thriftRechargeTransaction
6941 
    """
6942 
    self.send_createRechargeTransaction(thriftRechargeTransaction)
6943 
    return self.recv_createRechargeTransaction()
7026 rajveer 6944 
 
7073 anupam.sin 6945 
  def send_createRechargeTransaction(self, thriftRechargeTransaction):
6946 
    self._oprot.writeMessageBegin('createRechargeTransaction', TMessageType.CALL, self._seqid)
6947 
    args = createRechargeTransaction_args()
6948 
    args.thriftRechargeTransaction = thriftRechargeTransaction
6949 
    args.write(self._oprot)
6950 
    self._oprot.writeMessageEnd()
6951 
    self._oprot.trans.flush()
6952 
 
6953 
  def recv_createRechargeTransaction(self, ):
6954 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6955 
    if mtype == TMessageType.EXCEPTION:
6956 
      x = TApplicationException()
6957 
      x.read(self._iprot)
6958 
      self._iprot.readMessageEnd()
6959 
      raise x
6960 
    result = createRechargeTransaction_result()
6961 
    result.read(self._iprot)
6962 
    self._iprot.readMessageEnd()
6963 
    if result.success is not None:
6964 
      return result.success
6965 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createRechargeTransaction failed: unknown result");
6966 
 
7085 rajveer 6967 
  def getRechargeTransactions(self, storeId):
6968 
    """
6969 
    Parameters:
6970 
     - storeId
6971 
    """
6972 
    self.send_getRechargeTransactions(storeId)
6973 
    return self.recv_getRechargeTransactions()
6974 
 
6975 
  def send_getRechargeTransactions(self, storeId):
6976 
    self._oprot.writeMessageBegin('getRechargeTransactions', TMessageType.CALL, self._seqid)
6977 
    args = getRechargeTransactions_args()
6978 
    args.storeId = storeId
6979 
    args.write(self._oprot)
6980 
    self._oprot.writeMessageEnd()
6981 
    self._oprot.trans.flush()
6982 
 
6983 
  def recv_getRechargeTransactions(self, ):
6984 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6985 
    if mtype == TMessageType.EXCEPTION:
6986 
      x = TApplicationException()
6987 
      x.read(self._iprot)
6988 
      self._iprot.readMessageEnd()
6989 
      raise x
6990 
    result = getRechargeTransactions_result()
6991 
    result.read(self._iprot)
6992 
    self._iprot.readMessageEnd()
6993 
    if result.success is not None:
6994 
      return result.success
6995 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getRechargeTransactions failed: unknown result");
6996 
 
7151 amit.gupta 6997 
  def getRechargeTrans(self, storeId, startDate, endDate, status):
6998 
    """
6999 
    Parameters:
7000 
     - storeId
7001 
     - startDate
7002 
     - endDate
7003 
     - status
7004 
    """
7005 
    self.send_getRechargeTrans(storeId, startDate, endDate, status)
7006 
    return self.recv_getRechargeTrans()
7007 
 
7008 
  def send_getRechargeTrans(self, storeId, startDate, endDate, status):
7009 
    self._oprot.writeMessageBegin('getRechargeTrans', TMessageType.CALL, self._seqid)
7010 
    args = getRechargeTrans_args()
7011 
    args.storeId = storeId
7012 
    args.startDate = startDate
7013 
    args.endDate = endDate
7014 
    args.status = status
7015 
    args.write(self._oprot)
7016 
    self._oprot.writeMessageEnd()
7017 
    self._oprot.trans.flush()
7018 
 
7019 
  def recv_getRechargeTrans(self, ):
7020 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
7021 
    if mtype == TMessageType.EXCEPTION:
7022 
      x = TApplicationException()
7023 
      x.read(self._iprot)
7024 
      self._iprot.readMessageEnd()
7025 
      raise x
7026 
    result = getRechargeTrans_result()
7027 
    result.read(self._iprot)
7028 
    self._iprot.readMessageEnd()
7029 
    if result.success is not None:
7030 
      return result.success
7031 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getRechargeTrans failed: unknown result");
7032 
 
7080 anupam.sin 7033 
  def getRechargeTransaction(self, rechargeId):
7034 
    """
7035 
    Parameters:
7036 
     - rechargeId
7037 
    """
7038 
    self.send_getRechargeTransaction(rechargeId)
7039 
    return self.recv_getRechargeTransaction()
7073 anupam.sin 7040 
 
7080 anupam.sin 7041 
  def send_getRechargeTransaction(self, rechargeId):
7042 
    self._oprot.writeMessageBegin('getRechargeTransaction', TMessageType.CALL, self._seqid)
7043 
    args = getRechargeTransaction_args()
7044 
    args.rechargeId = rechargeId
7045 
    args.write(self._oprot)
7046 
    self._oprot.writeMessageEnd()
7047 
    self._oprot.trans.flush()
7048 
 
7049 
  def recv_getRechargeTransaction(self, ):
7050 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
7051 
    if mtype == TMessageType.EXCEPTION:
7052 
      x = TApplicationException()
7053 
      x.read(self._iprot)
7054 
      self._iprot.readMessageEnd()
7055 
      raise x
7056 
    result = getRechargeTransaction_result()
7057 
    result.read(self._iprot)
7058 
    self._iprot.readMessageEnd()
7059 
    if result.success is not None:
7060 
      return result.success
7061 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getRechargeTransaction failed: unknown result");
7062 
 
7063 
  def getFRCs(self, circleId, operatorId):
7064 
    """
7065 
    Parameters:
7066 
     - circleId
7067 
     - operatorId
7068 
    """
7069 
    self.send_getFRCs(circleId, operatorId)
7070 
    return self.recv_getFRCs()
7071 
 
7072 
  def send_getFRCs(self, circleId, operatorId):
7073 
    self._oprot.writeMessageBegin('getFRCs', TMessageType.CALL, self._seqid)
7074 
    args = getFRCs_args()
7075 
    args.circleId = circleId
7076 
    args.operatorId = operatorId
7077 
    args.write(self._oprot)
7078 
    self._oprot.writeMessageEnd()
7079 
    self._oprot.trans.flush()
7080 
 
7081 
  def recv_getFRCs(self, ):
7082 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
7083 
    if mtype == TMessageType.EXCEPTION:
7084 
      x = TApplicationException()
7085 
      x.read(self._iprot)
7086 
      self._iprot.readMessageEnd()
7087 
      raise x
7088 
    result = getFRCs_result()
7089 
    result.read(self._iprot)
7090 
    self._iprot.readMessageEnd()
7091 
    if result.success is not None:
7092 
      return result.success
7093 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getFRCs failed: unknown result");
7094 
 
7096 anupam.sin 7095 
  def getHotspotStore(self, id, hotspotid):
7096 
    """
7097 
    Parameters:
7098 
     - id
7099 
     - hotspotid
7100 
    """
7101 
    self.send_getHotspotStore(id, hotspotid)
7102 
    return self.recv_getHotspotStore()
7080 anupam.sin 7103 
 
7096 anupam.sin 7104 
  def send_getHotspotStore(self, id, hotspotid):
7105 
    self._oprot.writeMessageBegin('getHotspotStore', TMessageType.CALL, self._seqid)
7106 
    args = getHotspotStore_args()
7107 
    args.id = id
7108 
    args.hotspotid = hotspotid
7109 
    args.write(self._oprot)
7110 
    self._oprot.writeMessageEnd()
7111 
    self._oprot.trans.flush()
7112 
 
7113 
  def recv_getHotspotStore(self, ):
7114 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
7115 
    if mtype == TMessageType.EXCEPTION:
7116 
      x = TApplicationException()
7117 
      x.read(self._iprot)
7118 
      self._iprot.readMessageEnd()
7119 
      raise x
7120 
    result = getHotspotStore_result()
7121 
    result.read(self._iprot)
7122 
    self._iprot.readMessageEnd()
7123 
    if result.success is not None:
7124 
      return result.success
7125 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getHotspotStore failed: unknown result");
7126 
 
7127 
  def getTelecomCircle(self, id, code):
7128 
    """
7129 
    Parameters:
7130 
     - id
7131 
     - code
7132 
    """
7133 
    self.send_getTelecomCircle(id, code)
7134 
    return self.recv_getTelecomCircle()
7135 
 
7136 
  def send_getTelecomCircle(self, id, code):
7137 
    self._oprot.writeMessageBegin('getTelecomCircle', TMessageType.CALL, self._seqid)
7138 
    args = getTelecomCircle_args()
7139 
    args.id = id
7140 
    args.code = code
7141 
    args.write(self._oprot)
7142 
    self._oprot.writeMessageEnd()
7143 
    self._oprot.trans.flush()
7144 
 
7145 
  def recv_getTelecomCircle(self, ):
7146 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
7147 
    if mtype == TMessageType.EXCEPTION:
7148 
      x = TApplicationException()
7149 
      x.read(self._iprot)
7150 
      self._iprot.readMessageEnd()
7151 
      raise x
7152 
    result = getTelecomCircle_result()
7153 
    result.read(self._iprot)
7154 
    self._iprot.readMessageEnd()
7155 
    if result.success is not None:
7156 
      return result.success
7157 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTelecomCircle failed: unknown result");
7158 
 
7109 anupam.sin 7159 
  def retrieveHotspotRechargeInvoice(self, rechargeId):
7160 
    """
7161 
    Parameters:
7162 
     - rechargeId
7163 
    """
7164 
    self.send_retrieveHotspotRechargeInvoice(rechargeId)
7165 
    return self.recv_retrieveHotspotRechargeInvoice()
7096 anupam.sin 7166 
 
7109 anupam.sin 7167 
  def send_retrieveHotspotRechargeInvoice(self, rechargeId):
7168 
    self._oprot.writeMessageBegin('retrieveHotspotRechargeInvoice', TMessageType.CALL, self._seqid)
7169 
    args = retrieveHotspotRechargeInvoice_args()
7170 
    args.rechargeId = rechargeId
7171 
    args.write(self._oprot)
7172 
    self._oprot.writeMessageEnd()
7173 
    self._oprot.trans.flush()
7174 
 
7175 
  def recv_retrieveHotspotRechargeInvoice(self, ):
7176 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
7177 
    if mtype == TMessageType.EXCEPTION:
7178 
      x = TApplicationException()
7179 
      x.read(self._iprot)
7180 
      self._iprot.readMessageEnd()
7181 
      raise x
7182 
    result = retrieveHotspotRechargeInvoice_result()
7183 
    result.read(self._iprot)
7184 
    self._iprot.readMessageEnd()
7185 
    if result.success is not None:
7186 
      return result.success
7187 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "retrieveHotspotRechargeInvoice failed: unknown result");
7188 
 
7190 amar.kumar 7189 
  def splitFreebieOrder(self, orderId, splitReason, shippingDate):
7190 
    """
7191 
    Parameters:
7192 
     - orderId
7193 
     - splitReason
7194 
     - shippingDate
7195 
    """
7196 
    self.send_splitFreebieOrder(orderId, splitReason, shippingDate)
7197 
    return self.recv_splitFreebieOrder()
7198 
 
7199 
  def send_splitFreebieOrder(self, orderId, splitReason, shippingDate):
7200 
    self._oprot.writeMessageBegin('splitFreebieOrder', TMessageType.CALL, self._seqid)
7201 
    args = splitFreebieOrder_args()
7202 
    args.orderId = orderId
7203 
    args.splitReason = splitReason
7204 
    args.shippingDate = shippingDate
7205 
    args.write(self._oprot)
7206 
    self._oprot.writeMessageEnd()
7207 
    self._oprot.trans.flush()
7208 
 
7209 
  def recv_splitFreebieOrder(self, ):
7210 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
7211 
    if mtype == TMessageType.EXCEPTION:
7212 
      x = TApplicationException()
7213 
      x.read(self._iprot)
7214 
      self._iprot.readMessageEnd()
7215 
      raise x
7216 
    result = splitFreebieOrder_result()
7217 
    result.read(self._iprot)
7218 
    self._iprot.readMessageEnd()
7219 
    if result.success is not None:
7220 
      return result.success
7221 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "splitFreebieOrder failed: unknown result");
7222 
 
7172 anupam.sin 7223 
  def getRechargeTransactionsByNumber(self, number, storeId):
7169 anupam.sin 7224 
    """
7225 
    Parameters:
7226 
     - number
7172 anupam.sin 7227 
     - storeId
7169 anupam.sin 7228 
    """
7172 anupam.sin 7229 
    self.send_getRechargeTransactionsByNumber(number, storeId)
7169 anupam.sin 7230 
    return self.recv_getRechargeTransactionsByNumber()
7109 anupam.sin 7231 
 
7172 anupam.sin 7232 
  def send_getRechargeTransactionsByNumber(self, number, storeId):
7169 anupam.sin 7233 
    self._oprot.writeMessageBegin('getRechargeTransactionsByNumber', TMessageType.CALL, self._seqid)
7234 
    args = getRechargeTransactionsByNumber_args()
7235 
    args.number = number
7172 anupam.sin 7236 
    args.storeId = storeId
7169 anupam.sin 7237 
    args.write(self._oprot)
7238 
    self._oprot.writeMessageEnd()
7239 
    self._oprot.trans.flush()
7240 
 
7241 
  def recv_getRechargeTransactionsByNumber(self, ):
7242 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
7243 
    if mtype == TMessageType.EXCEPTION:
7244 
      x = TApplicationException()
7245 
      x.read(self._iprot)
7246 
      self._iprot.readMessageEnd()
7247 
      raise x
7248 
    result = getRechargeTransactionsByNumber_result()
7249 
    result.read(self._iprot)
7250 
    self._iprot.readMessageEnd()
7251 
    if result.success is not None:
7252 
      return result.success
7253 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getRechargeTransactionsByNumber failed: unknown result");
7254 
 
7255 
  def updateHotspotStorePassword(self, storeId, password):
7256 
    """
7257 
    Parameters:
7258 
     - storeId
7259 
     - password
7260 
    """
7261 
    self.send_updateHotspotStorePassword(storeId, password)
7262 
    return self.recv_updateHotspotStorePassword()
7263 
 
7264 
  def send_updateHotspotStorePassword(self, storeId, password):
7265 
    self._oprot.writeMessageBegin('updateHotspotStorePassword', TMessageType.CALL, self._seqid)
7266 
    args = updateHotspotStorePassword_args()
7267 
    args.storeId = storeId
7268 
    args.password = password
7269 
    args.write(self._oprot)
7270 
    self._oprot.writeMessageEnd()
7271 
    self._oprot.trans.flush()
7272 
 
7273 
  def recv_updateHotspotStorePassword(self, ):
7274 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
7275 
    if mtype == TMessageType.EXCEPTION:
7276 
      x = TApplicationException()
7277 
      x.read(self._iprot)
7278 
      self._iprot.readMessageEnd()
7279 
      raise x
7280 
    result = updateHotspotStorePassword_result()
7281 
    result.read(self._iprot)
7282 
    self._iprot.readMessageEnd()
7283 
    if result.success is not None:
7284 
      return result.success
7285 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updateHotspotStorePassword failed: unknown result");
7286 
 
7285 rajveer 7287 
  def topupCompanyWallet(self, companyId, amount):
7263 anupam.sin 7288 
    """
7289 
    Parameters:
7285 rajveer 7290 
     - companyId
7291 
     - amount
7263 anupam.sin 7292 
    """
7285 rajveer 7293 
    self.send_topupCompanyWallet(companyId, amount)
7294 
    return self.recv_topupCompanyWallet()
7169 anupam.sin 7295 
 
7285 rajveer 7296 
  def send_topupCompanyWallet(self, companyId, amount):
7297 
    self._oprot.writeMessageBegin('topupCompanyWallet', TMessageType.CALL, self._seqid)
7298 
    args = topupCompanyWallet_args()
7299 
    args.companyId = companyId
7300 
    args.amount = amount
7263 anupam.sin 7301 
    args.write(self._oprot)
7302 
    self._oprot.writeMessageEnd()
7303 
    self._oprot.trans.flush()
7304 
 
7285 rajveer 7305 
  def recv_topupCompanyWallet(self, ):
7263 anupam.sin 7306 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
7307 
    if mtype == TMessageType.EXCEPTION:
7308 
      x = TApplicationException()
7309 
      x.read(self._iprot)
7310 
      self._iprot.readMessageEnd()
7311 
      raise x
7285 rajveer 7312 
    result = topupCompanyWallet_result()
7263 anupam.sin 7313 
    result.read(self._iprot)
7314 
    self._iprot.readMessageEnd()
7315 
    if result.success is not None:
7316 
      return result.success
7285 rajveer 7317 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "topupCompanyWallet failed: unknown result");
7263 anupam.sin 7318 
 
7285 rajveer 7319 
  def getWalletBalanceForCompany(self, companyId):
7320 
    """
7321 
    Parameters:
7322 
     - companyId
7323 
    """
7324 
    self.send_getWalletBalanceForCompany(companyId)
7325 
    return self.recv_getWalletBalanceForCompany()
7263 anupam.sin 7326 
 
7285 rajveer 7327 
  def send_getWalletBalanceForCompany(self, companyId):
7328 
    self._oprot.writeMessageBegin('getWalletBalanceForCompany', TMessageType.CALL, self._seqid)
7329 
    args = getWalletBalanceForCompany_args()
7330 
    args.companyId = companyId
7267 anupam.sin 7331 
    args.write(self._oprot)
7332 
    self._oprot.writeMessageEnd()
7333 
    self._oprot.trans.flush()
7334 
 
7285 rajveer 7335 
  def recv_getWalletBalanceForCompany(self, ):
7267 anupam.sin 7336 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
7337 
    if mtype == TMessageType.EXCEPTION:
7338 
      x = TApplicationException()
7339 
      x.read(self._iprot)
7340 
      self._iprot.readMessageEnd()
7341 
      raise x
7285 rajveer 7342 
    result = getWalletBalanceForCompany_result()
7267 anupam.sin 7343 
    result.read(self._iprot)
7344 
    self._iprot.readMessageEnd()
7345 
    if result.success is not None:
7346 
      return result.success
7285 rajveer 7347 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getWalletBalanceForCompany failed: unknown result");
7267 anupam.sin 7348 
 
7285 rajveer 7349 
  def getSourceDetail(self, source):
7267 anupam.sin 7350 
    """
7351 
    Parameters:
7285 rajveer 7352 
     - source
7267 anupam.sin 7353 
    """
7285 rajveer 7354 
    self.send_getSourceDetail(source)
7355 
    return self.recv_getSourceDetail()
7267 anupam.sin 7356 
 
7285 rajveer 7357 
  def send_getSourceDetail(self, source):
7358 
    self._oprot.writeMessageBegin('getSourceDetail', TMessageType.CALL, self._seqid)
7359 
    args = getSourceDetail_args()
7360 
    args.source = source
7267 anupam.sin 7361 
    args.write(self._oprot)
7362 
    self._oprot.writeMessageEnd()
7363 
    self._oprot.trans.flush()
7364 
 
7285 rajveer 7365 
  def recv_getSourceDetail(self, ):
7267 anupam.sin 7366 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
7367 
    if mtype == TMessageType.EXCEPTION:
7368 
      x = TApplicationException()
7369 
      x.read(self._iprot)
7370 
      self._iprot.readMessageEnd()
7371 
      raise x
7285 rajveer 7372 
    result = getSourceDetail_result()
7267 anupam.sin 7373 
    result.read(self._iprot)
7374 
    self._iprot.readMessageEnd()
7375 
    if result.success is not None:
7376 
      return result.success
7285 rajveer 7377 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getSourceDetail failed: unknown result");
7267 anupam.sin 7378 
 
7308 rajveer 7379 
  def getAllCircles(self, ):
7380 
    self.send_getAllCircles()
7381 
    return self.recv_getAllCircles()
7267 anupam.sin 7382 
 
7308 rajveer 7383 
  def send_getAllCircles(self, ):
7384 
    self._oprot.writeMessageBegin('getAllCircles', TMessageType.CALL, self._seqid)
7385 
    args = getAllCircles_args()
7386 
    args.write(self._oprot)
7387 
    self._oprot.writeMessageEnd()
7388 
    self._oprot.trans.flush()
7389 
 
7390 
  def recv_getAllCircles(self, ):
7391 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
7392 
    if mtype == TMessageType.EXCEPTION:
7393 
      x = TApplicationException()
7394 
      x.read(self._iprot)
7395 
      self._iprot.readMessageEnd()
7396 
      raise x
7397 
    result = getAllCircles_result()
7398 
    result.read(self._iprot)
7399 
    self._iprot.readMessageEnd()
7400 
    if result.success is not None:
7401 
      return result.success
7402 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllCircles failed: unknown result");
7403 
 
7404 
  def deleteFrcs(self, frcIdsToDelete):
7405 
    """
7406 
    Parameters:
7407 
     - frcIdsToDelete
7408 
    """
7409 
    self.send_deleteFrcs(frcIdsToDelete)
7410 
    return self.recv_deleteFrcs()
7411 
 
7412 
  def send_deleteFrcs(self, frcIdsToDelete):
7413 
    self._oprot.writeMessageBegin('deleteFrcs', TMessageType.CALL, self._seqid)
7414 
    args = deleteFrcs_args()
7415 
    args.frcIdsToDelete = frcIdsToDelete
7416 
    args.write(self._oprot)
7417 
    self._oprot.writeMessageEnd()
7418 
    self._oprot.trans.flush()
7419 
 
7420 
  def recv_deleteFrcs(self, ):
7421 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
7422 
    if mtype == TMessageType.EXCEPTION:
7423 
      x = TApplicationException()
7424 
      x.read(self._iprot)
7425 
      self._iprot.readMessageEnd()
7426 
      raise x
7427 
    result = deleteFrcs_result()
7428 
    result.read(self._iprot)
7429 
    self._iprot.readMessageEnd()
7430 
    if result.success is not None:
7431 
      return result.success
7432 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "deleteFrcs failed: unknown result");
7433 
 
7311 kshitij.so 7434 
  def addAmazonOrder(self, amazonOrder):
7435 
    """
7436 
    Parameters:
7437 
     - amazonOrder
7438 
    """
7439 
    self.send_addAmazonOrder(amazonOrder)
7440 
    self.recv_addAmazonOrder()
7308 rajveer 7441 
 
7311 kshitij.so 7442 
  def send_addAmazonOrder(self, amazonOrder):
7443 
    self._oprot.writeMessageBegin('addAmazonOrder', TMessageType.CALL, self._seqid)
7444 
    args = addAmazonOrder_args()
7445 
    args.amazonOrder = amazonOrder
7446 
    args.write(self._oprot)
7447 
    self._oprot.writeMessageEnd()
7448 
    self._oprot.trans.flush()
7449 
 
7450 
  def recv_addAmazonOrder(self, ):
7451 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
7452 
    if mtype == TMessageType.EXCEPTION:
7453 
      x = TApplicationException()
7454 
      x.read(self._iprot)
7455 
      self._iprot.readMessageEnd()
7456 
      raise x
7457 
    result = addAmazonOrder_result()
7458 
    result.read(self._iprot)
7459 
    self._iprot.readMessageEnd()
7460 
    return
7461 
 
7322 vikram.rag 7462 
  def updateAmazonOrderStatus(self, orderId, status):
7311 kshitij.so 7463 
    """
7464 
    Parameters:
7465 
     - orderId
7466 
     - status
7467 
    """
7322 vikram.rag 7468 
    self.send_updateAmazonOrderStatus(orderId, status)
7469 
    return self.recv_updateAmazonOrderStatus()
7311 kshitij.so 7470 
 
7322 vikram.rag 7471 
  def send_updateAmazonOrderStatus(self, orderId, status):
7472 
    self._oprot.writeMessageBegin('updateAmazonOrderStatus', TMessageType.CALL, self._seqid)
7473 
    args = updateAmazonOrderStatus_args()
7311 kshitij.so 7474 
    args.orderId = orderId
7475 
    args.status = status
7476 
    args.write(self._oprot)
7477 
    self._oprot.writeMessageEnd()
7478 
    self._oprot.trans.flush()
7479 
 
7322 vikram.rag 7480 
  def recv_updateAmazonOrderStatus(self, ):
7311 kshitij.so 7481 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
7482 
    if mtype == TMessageType.EXCEPTION:
7483 
      x = TApplicationException()
7484 
      x.read(self._iprot)
7485 
      self._iprot.readMessageEnd()
7486 
      raise x
7322 vikram.rag 7487 
    result = updateAmazonOrderStatus_result()
7311 kshitij.so 7488 
    result.read(self._iprot)
7489 
    self._iprot.readMessageEnd()
7490 
    if result.success is not None:
7491 
      return result.success
7322 vikram.rag 7492 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updateAmazonOrderStatus failed: unknown result");
7311 kshitij.so 7493 
 
7494 
  def getAmazonOrdersShipped(self, interval):
7495 
    """
7496 
    Parameters:
7497 
     - interval
7498 
    """
7499 
    self.send_getAmazonOrdersShipped(interval)
7500 
    return self.recv_getAmazonOrdersShipped()
7501 
 
7502 
  def send_getAmazonOrdersShipped(self, interval):
7503 
    self._oprot.writeMessageBegin('getAmazonOrdersShipped', TMessageType.CALL, self._seqid)
7504 
    args = getAmazonOrdersShipped_args()
7505 
    args.interval = interval
7506 
    args.write(self._oprot)
7507 
    self._oprot.writeMessageEnd()
7508 
    self._oprot.trans.flush()
7509 
 
7510 
  def recv_getAmazonOrdersShipped(self, ):
7511 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
7512 
    if mtype == TMessageType.EXCEPTION:
7513 
      x = TApplicationException()
7514 
      x.read(self._iprot)
7515 
      self._iprot.readMessageEnd()
7516 
      raise x
7517 
    result = getAmazonOrdersShipped_result()
7518 
    result.read(self._iprot)
7519 
    self._iprot.readMessageEnd()
7520 
    if result.success is not None:
7521 
      return result.success
7522 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAmazonOrdersShipped failed: unknown result");
7523 
 
7524 
  def getAmazonOrdersCancelled(self, interval):
7525 
    """
7526 
    Parameters:
7527 
     - interval
7528 
    """
7529 
    self.send_getAmazonOrdersCancelled(interval)
7530 
    return self.recv_getAmazonOrdersCancelled()
7531 
 
7532 
  def send_getAmazonOrdersCancelled(self, interval):
7533 
    self._oprot.writeMessageBegin('getAmazonOrdersCancelled', TMessageType.CALL, self._seqid)
7534 
    args = getAmazonOrdersCancelled_args()
7535 
    args.interval = interval
7536 
    args.write(self._oprot)
7537 
    self._oprot.writeMessageEnd()
7538 
    self._oprot.trans.flush()
7539 
 
7540 
  def recv_getAmazonOrdersCancelled(self, ):
7541 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
7542 
    if mtype == TMessageType.EXCEPTION:
7543 
      x = TApplicationException()
7544 
      x.read(self._iprot)
7545 
      self._iprot.readMessageEnd()
7546 
      raise x
7547 
    result = getAmazonOrdersCancelled_result()
7548 
    result.read(self._iprot)
7549 
    self._iprot.readMessageEnd()
7550 
    if result.success is not None:
7551 
      return result.success
7552 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAmazonOrdersCancelled failed: unknown result");
7553 
 
7322 vikram.rag 7554 
  def getAmazonOrder(self, orderId):
7555 
    """
7556 
    Parameters:
7557 
     - orderId
7558 
    """
7559 
    self.send_getAmazonOrder(orderId)
7560 
    return self.recv_getAmazonOrder()
7311 kshitij.so 7561 
 
7322 vikram.rag 7562 
  def send_getAmazonOrder(self, orderId):
7563 
    self._oprot.writeMessageBegin('getAmazonOrder', TMessageType.CALL, self._seqid)
7564 
    args = getAmazonOrder_args()
7565 
    args.orderId = orderId
7566 
    args.write(self._oprot)
7567 
    self._oprot.writeMessageEnd()
7568 
    self._oprot.trans.flush()
7569 
 
7570 
  def recv_getAmazonOrder(self, ):
7571 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
7572 
    if mtype == TMessageType.EXCEPTION:
7573 
      x = TApplicationException()
7574 
      x.read(self._iprot)
7575 
      self._iprot.readMessageEnd()
7576 
      raise x
7577 
    result = getAmazonOrder_result()
7578 
    result.read(self._iprot)
7579 
    self._iprot.readMessageEnd()
7580 
    if result.success is not None:
7581 
      return result.success
7582 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAmazonOrder failed: unknown result");
7583 
 
7343 anupam.sin 7584 
  def getOrdersForStore(self, id, storeId, startDate, endDate, statuses):
7585 
    """
7586 
    Parameters:
7587 
     - id
7588 
     - storeId
7589 
     - startDate
7590 
     - endDate
7591 
     - statuses
7592 
    """
7593 
    self.send_getOrdersForStore(id, storeId, startDate, endDate, statuses)
7594 
    return self.recv_getOrdersForStore()
7322 vikram.rag 7595 
 
7343 anupam.sin 7596 
  def send_getOrdersForStore(self, id, storeId, startDate, endDate, statuses):
7597 
    self._oprot.writeMessageBegin('getOrdersForStore', TMessageType.CALL, self._seqid)
7598 
    args = getOrdersForStore_args()
7599 
    args.id = id
7600 
    args.storeId = storeId
7601 
    args.startDate = startDate
7602 
    args.endDate = endDate
7603 
    args.statuses = statuses
7604 
    args.write(self._oprot)
7605 
    self._oprot.writeMessageEnd()
7606 
    self._oprot.trans.flush()
7607 
 
7608 
  def recv_getOrdersForStore(self, ):
7609 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
7610 
    if mtype == TMessageType.EXCEPTION:
7611 
      x = TApplicationException()
7612 
      x.read(self._iprot)
7613 
      self._iprot.readMessageEnd()
7614 
      raise x
7615 
    result = getOrdersForStore_result()
7616 
    result.read(self._iprot)
7617 
    self._iprot.readMessageEnd()
7618 
    if result.success is not None:
7619 
      return result.success
7620 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersForStore failed: unknown result");
7621 
 
7622 
  def getStoreOrderAdvanceInvoice(self, orderId):
7623 
    """
7624 
    Parameters:
7625 
     - orderId
7626 
    """
7627 
    self.send_getStoreOrderAdvanceInvoice(orderId)
7628 
    return self.recv_getStoreOrderAdvanceInvoice()
7629 
 
7630 
  def send_getStoreOrderAdvanceInvoice(self, orderId):
7631 
    self._oprot.writeMessageBegin('getStoreOrderAdvanceInvoice', TMessageType.CALL, self._seqid)
7632 
    args = getStoreOrderAdvanceInvoice_args()
7633 
    args.orderId = orderId
7634 
    args.write(self._oprot)
7635 
    self._oprot.writeMessageEnd()
7636 
    self._oprot.trans.flush()
7637 
 
7638 
  def recv_getStoreOrderAdvanceInvoice(self, ):
7639 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
7640 
    if mtype == TMessageType.EXCEPTION:
7641 
      x = TApplicationException()
7642 
      x.read(self._iprot)
7643 
      self._iprot.readMessageEnd()
7644 
      raise x
7645 
    result = getStoreOrderAdvanceInvoice_result()
7646 
    result.read(self._iprot)
7647 
    self._iprot.readMessageEnd()
7648 
    if result.success is not None:
7649 
      return result.success
7650 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getStoreOrderAdvanceInvoice failed: unknown result");
7651 
 
7652 
 
3376 rajveer 7653 
class Processor(shop2020.thriftpy.generic.GenericService.Processor, Iface, TProcessor):
94 ashish 7654 
  def __init__(self, handler):
3376 rajveer 7655 
    shop2020.thriftpy.generic.GenericService.Processor.__init__(self, handler)
94 ashish 7656 
    self._processMap["createTransaction"] = Processor.process_createTransaction
7657 
    self._processMap["getTransaction"] = Processor.process_getTransaction
7658 
    self._processMap["getTransactionsForCustomer"] = Processor.process_getTransactionsForCustomer
132 ashish 7659 
    self._processMap["getTransactionsForShoppingCartId"] = Processor.process_getTransactionsForShoppingCartId
94 ashish 7660 
    self._processMap["getTransactionStatus"] = Processor.process_getTransactionStatus
7661 
    self._processMap["changeTransactionStatus"] = Processor.process_changeTransactionStatus
1398 varun.gupt 7662 
    self._processMap["enqueueTransactionInfoEmail"] = Processor.process_enqueueTransactionInfoEmail
483 rajveer 7663 
    self._processMap["getAllOrders"] = Processor.process_getAllOrders
4133 chandransh 7664 
    self._processMap["getOrdersInBatch"] = Processor.process_getOrdersInBatch
7665 
    self._processMap["getOrderCount"] = Processor.process_getOrderCount
999 varun.gupt 7666 
    self._processMap["getOrdersByBillingDate"] = Processor.process_getOrdersByBillingDate
3427 chandransh 7667 
    self._processMap["getOrdersByShippingDate"] = Processor.process_getOrdersByShippingDate
1382 varun.gupt 7668 
    self._processMap["getReturnableOrdersForCustomer"] = Processor.process_getReturnableOrdersForCustomer
7669 
    self._processMap["getCancellableOrdersForCustomer"] = Processor.process_getCancellableOrdersForCustomer
483 rajveer 7670 
    self._processMap["changeOrderStatus"] = Processor.process_changeOrderStatus
7671 
    self._processMap["getOrdersForTransaction"] = Processor.process_getOrdersForTransaction
7672 
    self._processMap["getOrdersForCustomer"] = Processor.process_getOrdersForCustomer
7673 
    self._processMap["createOrder"] = Processor.process_createOrder
7674 
    self._processMap["getOrder"] = Processor.process_getOrder
7675 
    self._processMap["getLineItemsForOrder"] = Processor.process_getLineItemsForOrder
4999 phani.kuma 7676 
    self._processMap["getOrderList"] = Processor.process_getOrderList
5386 phani.kuma 7677 
    self._processMap["getOrderListForVendor"] = Processor.process_getOrderListForVendor
1528 ankur.sing 7678 
    self._processMap["getOrderForCustomer"] = Processor.process_getOrderForCustomer
3064 chandransh 7679 
    self._processMap["getAlerts"] = Processor.process_getAlerts
4394 rajveer 7680 
    self._processMap["addAlert"] = Processor.process_addAlert
4444 rajveer 7681 
    self._processMap["markAlertsAsSeen"] = Processor.process_markAlertsAsSeen
3064 chandransh 7682 
    self._processMap["getValidOrderCount"] = Processor.process_getValidOrderCount
7683 
    self._processMap["getNoOfCustomersWithSuccessfulTransaction"] = Processor.process_getNoOfCustomersWithSuccessfulTransaction
7684 
    self._processMap["getValidOrdersAmountRange"] = Processor.process_getValidOrdersAmountRange
7685 
    self._processMap["getValidOrders"] = Processor.process_getValidOrders
1220 chandransh 7686 
    self._processMap["batchOrders"] = Processor.process_batchOrders
1208 chandransh 7687 
    self._processMap["markOrderAsOutOfStock"] = Processor.process_markOrderAsOutOfStock
3064 chandransh 7688 
    self._processMap["verifyOrder"] = Processor.process_verifyOrder
7689 
    self._processMap["acceptOrder"] = Processor.process_acceptOrder
7690 
    self._processMap["addBillingDetails"] = Processor.process_addBillingDetails
4579 rajveer 7691 
    self._processMap["addInvoiceNumber"] = Processor.process_addInvoiceNumber
4410 rajveer 7692 
    self._processMap["markOrdersAsShippedFromWarehouse"] = Processor.process_markOrdersAsShippedFromWarehouse
5676 rajveer 7693 
    self._processMap["markOrdersAsReturnedFromStore"] = Processor.process_markOrdersAsReturnedFromStore
1113 chandransh 7694 
    self._processMap["markOrdersAsPickedUp"] = Processor.process_markOrdersAsPickedUp
4910 phani.kuma 7695 
    self._processMap["getOrdersNotPickedUp"] = Processor.process_getOrdersNotPickedUp
1132 chandransh 7696 
    self._processMap["markOrdersAsDelivered"] = Processor.process_markOrdersAsDelivered
4910 phani.kuma 7697 
    self._processMap["markAsRTOrders"] = Processor.process_markAsRTOrders
7698 
    self._processMap["getRTOrders"] = Processor.process_getRTOrders
1246 chandransh 7699 
    self._processMap["updateNonDeliveryReason"] = Processor.process_updateNonDeliveryReason
4910 phani.kuma 7700 
    self._processMap["getNonDeliveredOrdersbyCourier"] = Processor.process_getNonDeliveredOrdersbyCourier
7701 
    self._processMap["markOrdersAsLocalConnected"] = Processor.process_markOrdersAsLocalConnected
7702 
    self._processMap["getOrdersNotLocalConnected"] = Processor.process_getOrdersNotLocalConnected
7703 
    self._processMap["markOrdersAsDestinationCityReached"] = Processor.process_markOrdersAsDestinationCityReached
7704 
    self._processMap["markOrdersAsFirstDeliveryAttempted"] = Processor.process_markOrdersAsFirstDeliveryAttempted
1408 ankur.sing 7705 
    self._processMap["getUndeliveredOrders"] = Processor.process_getUndeliveredOrders
4783 phani.kuma 7706 
    self._processMap["getUndeliveredOrdersExpectedDeliveryDateNotMet"] = Processor.process_getUndeliveredOrdersExpectedDeliveryDateNotMet
2536 chandransh 7707 
    self._processMap["toggleDOAFlag"] = Processor.process_toggleDOAFlag
4712 rajveer 7708 
    self._processMap["markOrderAsDelivered"] = Processor.process_markOrderAsDelivered
5553 rajveer 7709 
    self._processMap["markOrderAsReceivedAtStore"] = Processor.process_markOrderAsReceivedAtStore
4454 rajveer 7710 
    self._processMap["markOrderDoaRequestReceived"] = Processor.process_markOrderDoaRequestReceived
7711 
    self._processMap["markOrderDoaRequestAuthorized"] = Processor.process_markOrderDoaRequestAuthorized
4488 rajveer 7712 
    self._processMap["markOrderReturnRequestReceived"] = Processor.process_markOrderReturnRequestReceived
7713 
    self._processMap["markOrderReturnRequestAuthorized"] = Processor.process_markOrderReturnRequestAuthorized
2536 chandransh 7714 
    self._processMap["requestPickupNumber"] = Processor.process_requestPickupNumber
7715 
    self._processMap["authorizePickup"] = Processor.process_authorizePickup
2764 chandransh 7716 
    self._processMap["markDoasAsPickedUp"] = Processor.process_markDoasAsPickedUp
4910 phani.kuma 7717 
    self._processMap["getDoasNotPickedUp"] = Processor.process_getDoasNotPickedUp
4741 phani.kuma 7718 
    self._processMap["markReturnOrdersAsPickedUp"] = Processor.process_markReturnOrdersAsPickedUp
4910 phani.kuma 7719 
    self._processMap["getReturnOrdersNotPickedUp"] = Processor.process_getReturnOrdersNotPickedUp
2616 chandransh 7720 
    self._processMap["receiveReturn"] = Processor.process_receiveReturn
2591 chandransh 7721 
    self._processMap["validateDoa"] = Processor.process_validateDoa
4495 rajveer 7722 
    self._processMap["validateReturnProduct"] = Processor.process_validateReturnProduct
2616 chandransh 7723 
    self._processMap["reshipOrder"] = Processor.process_reshipOrder
7724 
    self._processMap["refundOrder"] = Processor.process_refundOrder
2690 chandransh 7725 
    self._processMap["getReturnOrders"] = Processor.process_getReturnOrders
5481 phani.kuma 7726 
    self._processMap["getAllReturnOrders"] = Processor.process_getAllReturnOrders
2700 chandransh 7727 
    self._processMap["getReturnOrder"] = Processor.process_getReturnOrder
2690 chandransh 7728 
    self._processMap["processReturn"] = Processor.process_processReturn
3451 chandransh 7729 
    self._processMap["updateWeight"] = Processor.process_updateWeight
3469 chandransh 7730 
    self._processMap["changeItem"] = Processor.process_changeItem
7731 
    self._processMap["shiftToWarehouse"] = Processor.process_shiftToWarehouse
3553 chandransh 7732 
    self._processMap["addDelayReason"] = Processor.process_addDelayReason
3956 chandransh 7733 
    self._processMap["reconcileCodCollection"] = Processor.process_reconcileCodCollection
4008 mandeep.dh 7734 
    self._processMap["getTransactionsRequiringExtraProcessing"] = Processor.process_getTransactionsRequiringExtraProcessing
7735 
    self._processMap["markTransactionAsProcessed"] = Processor.process_markTransactionAsProcessed
4018 chandransh 7736 
    self._processMap["getItemWiseRiskyOrdersCount"] = Processor.process_getItemWiseRiskyOrdersCount
4295 varun.gupt 7737 
    self._processMap["getOrdersForItemIds"] = Processor.process_getOrdersForItemIds
4247 rajveer 7738 
    self._processMap["markOrderCancellationRequestReceived"] = Processor.process_markOrderCancellationRequestReceived
7739 
    self._processMap["markOrderCancellationRequestConfirmed"] = Processor.process_markOrderCancellationRequestConfirmed
7740 
    self._processMap["markOrderCancellationRequestDenied"] = Processor.process_markOrderCancellationRequestDenied
4258 rajveer 7741 
    self._processMap["markTransactionAsPaymentFlagRemoved"] = Processor.process_markTransactionAsPaymentFlagRemoved
4259 anupam.sin 7742 
    self._processMap["refundTransaction"] = Processor.process_refundTransaction
4324 mandeep.dh 7743 
    self._processMap["updateShipmentAddress"] = Processor.process_updateShipmentAddress
4285 rajveer 7744 
    self._processMap["acceptOrdersForItemId"] = Processor.process_acceptOrdersForItemId
4303 rajveer 7745 
    self._processMap["markOrdersAsPORaised"] = Processor.process_markOrdersAsPORaised
7746 
    self._processMap["markOrdersAsReversalInitiated"] = Processor.process_markOrdersAsReversalInitiated
7747 
    self._processMap["markOrdersAsNotAvailabke"] = Processor.process_markOrdersAsNotAvailabke
4369 rajveer 7748 
    self._processMap["markOrdersAsTimeout"] = Processor.process_markOrdersAsTimeout
4662 rajveer 7749 
    self._processMap["markOrderAsLostInTransit"] = Processor.process_markOrderAsLostInTransit
4386 anupam.sin 7750 
    self._processMap["getOrderForAwb"] = Processor.process_getOrderForAwb
4506 phani.kuma 7751 
    self._processMap["getOrdersForProviderForStatus"] = Processor.process_getOrdersForProviderForStatus
4600 varun.gupt 7752 
    self._processMap["getBilledOrdersForVendor"] = Processor.process_getBilledOrdersForVendor
4607 rajveer 7753 
    self._processMap["getSlippedSippingDateOrders"] = Processor.process_getSlippedSippingDateOrders
4709 rajveer 7754 
    self._processMap["getCancelledOrders"] = Processor.process_getCancelledOrders
4600 varun.gupt 7755 
    self._processMap["saveBluedartSettlements"] = Processor.process_saveBluedartSettlements
7756 
    self._processMap["savePaymentSettlements"] = Processor.process_savePaymentSettlements
7757 
    self._processMap["saveEBSSettlementSummary"] = Processor.process_saveEBSSettlementSummary
5386 phani.kuma 7758 
    self._processMap["getSettlementForPrepaid"] = Processor.process_getSettlementForPrepaid
7759 
    self._processMap["getSettlementForCod"] = Processor.process_getSettlementForCod
4600 varun.gupt 7760 
    self._processMap["getEBSSettlementSummaries"] = Processor.process_getEBSSettlementSummaries
7761 
    self._processMap["markEBSSettlementUploaded"] = Processor.process_markEBSSettlementUploaded
7762 
    self._processMap["getEBSSettlementDate"] = Processor.process_getEBSSettlementDate
4715 varun.gupt 7763 
    self._processMap["getSettlementsByDate"] = Processor.process_getSettlementsByDate
7764 
    self._processMap["getReshippedOrderIds"] = Processor.process_getReshippedOrderIds
5481 phani.kuma 7765 
    self._processMap["getBilledOrders"] = Processor.process_getBilledOrders
5031 varun.gupt 7766 
    self._processMap["getStatusDistributionOfOrders"] = Processor.process_getStatusDistributionOfOrders
5067 varun.gupt 7767 
    self._processMap["getOrderIdsForStatus"] = Processor.process_getOrderIdsForStatus
5348 anupam.sin 7768 
    self._processMap["updateCODAgent"] = Processor.process_updateCODAgent
5099 varun.gupt 7769 
    self._processMap["updateOrderAsPaidToVendor"] = Processor.process_updateOrderAsPaidToVendor
5386 phani.kuma 7770 
    self._processMap["updateOrderOnlyAsPaidToVendor"] = Processor.process_updateOrderOnlyAsPaidToVendor
5208 varun.gupt 7771 
    self._processMap["getRefundedOrdersMarkedPaid"] = Processor.process_getRefundedOrdersMarkedPaid
5447 anupam.sin 7772 
    self._processMap["getAllVerificationAgents"] = Processor.process_getAllVerificationAgents
5527 anupam.sin 7773 
    self._processMap["getAllAttributesForOrderId"] = Processor.process_getAllAttributesForOrderId
5676 rajveer 7774 
    self._processMap["setOrderAttributes"] = Processor.process_setOrderAttributes
5527 anupam.sin 7775 
    self._processMap["setOrderAttributeForTransaction"] = Processor.process_setOrderAttributeForTransaction
5553 rajveer 7776 
    self._processMap["getReceivePendingOrders"] = Processor.process_getReceivePendingOrders
7777 
    self._processMap["getReceivedAtStoreOrders"] = Processor.process_getReceivedAtStoreOrders
5713 rajveer 7778 
    self._processMap["getOrdersCollectionAtStore"] = Processor.process_getOrdersCollectionAtStore
5833 rajveer 7779 
    self._processMap["getOrderAttributeValue"] = Processor.process_getOrderAttributeValue
6019 rajveer 7780 
    self._processMap["changeJacketNumber"] = Processor.process_changeJacketNumber
7781 
    self._processMap["markOrderAsRtoInTransit"] = Processor.process_markOrderAsRtoInTransit
5593 mandeep.dh 7782 
    self._processMap["acceptOrderForItem"] = Processor.process_acceptOrderForItem
6000 mandeep.dh 7783 
    self._processMap["createRechargeOrder"] = Processor.process_createRechargeOrder
6031 rajveer 7784 
    self._processMap["getRechargeOrder"] = Processor.process_getRechargeOrder
7785 
    self._processMap["getRechargeOrders"] = Processor.process_getRechargeOrders
6000 mandeep.dh 7786 
    self._processMap["updateRechargeOrderStatus"] = Processor.process_updateRechargeOrderStatus
7787 
    self._processMap["activateRechargeTxn"] = Processor.process_activateRechargeTxn
6031 rajveer 7788 
    self._processMap["getUserWallet"] = Processor.process_getUserWallet
7789 
    self._processMap["getUserWalletHistory"] = Processor.process_getUserWalletHistory
6050 anupam.sin 7790 
    self._processMap["getRechargeOrdersForTransaction"] = Processor.process_getRechargeOrdersForTransaction
6048 rajveer 7791 
    self._processMap["getServiceProviders"] = Processor.process_getServiceProviders
7792 
    self._processMap["getServiceProviderForDevice"] = Processor.process_getServiceProviderForDevice
6269 rajveer 7793 
    self._processMap["validateRecharge"] = Processor.process_validateRecharge
6094 rajveer 7794 
    self._processMap["getRechargeOrdersForDevice"] = Processor.process_getRechargeOrdersForDevice
7795 
    self._processMap["addAmountToWallet"] = Processor.process_addAmountToWallet
6188 rajveer 7796 
    self._processMap["getRechargeStatistics"] = Processor.process_getRechargeStatistics
6154 rajveer 7797 
    self._processMap["getRechargeOrdersForStatus"] = Processor.process_getRechargeOrdersForStatus
6159 rajveer 7798 
    self._processMap["getPlansForOperator"] = Processor.process_getPlansForOperator
6289 anupam.sin 7799 
    self._processMap["getRechargeDenominations"] = Processor.process_getRechargeDenominations
6371 rajveer 7800 
    self._processMap["updateAvailabilityStatus"] = Processor.process_updateAvailabilityStatus
6389 rajveer 7801 
    self._processMap["getAvailableEmiSchemes"] = Processor.process_getAvailableEmiSchemes
7802 
    self._processMap["getMiscCharges"] = Processor.process_getMiscCharges
6507 anupam.sin 7803 
    self._processMap["refundRechargeOrder"] = Processor.process_refundRechargeOrder
6821 amar.kumar 7804 
    self._processMap["getPhysicalOrders"] = Processor.process_getPhysicalOrders
6906 rajveer 7805 
    self._processMap["getDocument"] = Processor.process_getDocument
6985 anupam.sin 7806 
    self._processMap["changeShippingAddress"] = Processor.process_changeShippingAddress
6988 rajveer 7807 
    self._processMap["retrieveInvoice"] = Processor.process_retrieveInvoice
7026 rajveer 7808 
    self._processMap["receiveUpdatesForRedExpress"] = Processor.process_receiveUpdatesForRedExpress
7073 anupam.sin 7809 
    self._processMap["createRechargeTransaction"] = Processor.process_createRechargeTransaction
7085 rajveer 7810 
    self._processMap["getRechargeTransactions"] = Processor.process_getRechargeTransactions
7151 amit.gupta 7811 
    self._processMap["getRechargeTrans"] = Processor.process_getRechargeTrans
7080 anupam.sin 7812 
    self._processMap["getRechargeTransaction"] = Processor.process_getRechargeTransaction
7813 
    self._processMap["getFRCs"] = Processor.process_getFRCs
7096 anupam.sin 7814 
    self._processMap["getHotspotStore"] = Processor.process_getHotspotStore
7815 
    self._processMap["getTelecomCircle"] = Processor.process_getTelecomCircle
7109 anupam.sin 7816 
    self._processMap["retrieveHotspotRechargeInvoice"] = Processor.process_retrieveHotspotRechargeInvoice
7190 amar.kumar 7817 
    self._processMap["splitFreebieOrder"] = Processor.process_splitFreebieOrder
7169 anupam.sin 7818 
    self._processMap["getRechargeTransactionsByNumber"] = Processor.process_getRechargeTransactionsByNumber
7819 
    self._processMap["updateHotspotStorePassword"] = Processor.process_updateHotspotStorePassword
7285 rajveer 7820 
    self._processMap["topupCompanyWallet"] = Processor.process_topupCompanyWallet
7821 
    self._processMap["getWalletBalanceForCompany"] = Processor.process_getWalletBalanceForCompany
7263 anupam.sin 7822 
    self._processMap["getSourceDetail"] = Processor.process_getSourceDetail
7308 rajveer 7823 
    self._processMap["getAllCircles"] = Processor.process_getAllCircles
7824 
    self._processMap["deleteFrcs"] = Processor.process_deleteFrcs
7311 kshitij.so 7825 
    self._processMap["addAmazonOrder"] = Processor.process_addAmazonOrder
7322 vikram.rag 7826 
    self._processMap["updateAmazonOrderStatus"] = Processor.process_updateAmazonOrderStatus
7311 kshitij.so 7827 
    self._processMap["getAmazonOrdersShipped"] = Processor.process_getAmazonOrdersShipped
7828 
    self._processMap["getAmazonOrdersCancelled"] = Processor.process_getAmazonOrdersCancelled
7322 vikram.rag 7829 
    self._processMap["getAmazonOrder"] = Processor.process_getAmazonOrder
7343 anupam.sin 7830 
    self._processMap["getOrdersForStore"] = Processor.process_getOrdersForStore
7831 
    self._processMap["getStoreOrderAdvanceInvoice"] = Processor.process_getStoreOrderAdvanceInvoice
94 ashish 7832 
 
7833 
  def process(self, iprot, oprot):
7834 
    (name, type, seqid) = iprot.readMessageBegin()
7835 
    if name not in self._processMap:
7836 
      iprot.skip(TType.STRUCT)
7837 
      iprot.readMessageEnd()
7838 
      x = TApplicationException(TApplicationException.UNKNOWN_METHOD, 'Unknown function %s' % (name))
7839 
      oprot.writeMessageBegin(name, TMessageType.EXCEPTION, seqid)
7840 
      x.write(oprot)
7841 
      oprot.writeMessageEnd()
7842 
      oprot.trans.flush()
7843 
      return
7844 
    else:
7845 
      self._processMap[name](self, seqid, iprot, oprot)
7846 
    return True
7847 
 
7848 
  def process_createTransaction(self, seqid, iprot, oprot):
7849 
    args = createTransaction_args()
7850 
    args.read(iprot)
7851 
    iprot.readMessageEnd()
7852 
    result = createTransaction_result()
7853 
    try:
132 ashish 7854 
      result.success = self._handler.createTransaction(args.transaction)
94 ashish 7855 
    except TransactionServiceException, ex:
7856 
      result.ex = ex
7857 
    oprot.writeMessageBegin("createTransaction", TMessageType.REPLY, seqid)
7858 
    result.write(oprot)
7859 
    oprot.writeMessageEnd()
7860 
    oprot.trans.flush()
7861 
 
7862 
  def process_getTransaction(self, seqid, iprot, oprot):
7863 
    args = getTransaction_args()
7864 
    args.read(iprot)
7865 
    iprot.readMessageEnd()
7866 
    result = getTransaction_result()
7867 
    try:
7868 
      result.success = self._handler.getTransaction(args.id)
7869 
    except TransactionServiceException, ex:
7870 
      result.ex = ex
7871 
    oprot.writeMessageBegin("getTransaction", TMessageType.REPLY, seqid)
7872 
    result.write(oprot)
7873 
    oprot.writeMessageEnd()
7874 
    oprot.trans.flush()
7875 
 
7876 
  def process_getTransactionsForCustomer(self, seqid, iprot, oprot):
7877 
    args = getTransactionsForCustomer_args()
7878 
    args.read(iprot)
7879 
    iprot.readMessageEnd()
7880 
    result = getTransactionsForCustomer_result()
7881 
    try:
7882 
      result.success = self._handler.getTransactionsForCustomer(args.customerId, args.from_date, args.to_date, args.status)
7883 
    except TransactionServiceException, ex:
7884 
      result.ex = ex
7885 
    oprot.writeMessageBegin("getTransactionsForCustomer", TMessageType.REPLY, seqid)
7886 
    result.write(oprot)
7887 
    oprot.writeMessageEnd()
7888 
    oprot.trans.flush()
7889 
 
132 ashish 7890 
  def process_getTransactionsForShoppingCartId(self, seqid, iprot, oprot):
7891 
    args = getTransactionsForShoppingCartId_args()
7892 
    args.read(iprot)
7893 
    iprot.readMessageEnd()
7894 
    result = getTransactionsForShoppingCartId_result()
7895 
    try:
7896 
      result.success = self._handler.getTransactionsForShoppingCartId(args.shoppingCartId)
7897 
    except TransactionServiceException, ex:
7898 
      result.ex = ex
7899 
    oprot.writeMessageBegin("getTransactionsForShoppingCartId", TMessageType.REPLY, seqid)
7900 
    result.write(oprot)
7901 
    oprot.writeMessageEnd()
7902 
    oprot.trans.flush()
7903 
 
94 ashish 7904 
  def process_getTransactionStatus(self, seqid, iprot, oprot):
7905 
    args = getTransactionStatus_args()
7906 
    args.read(iprot)
7907 
    iprot.readMessageEnd()
7908 
    result = getTransactionStatus_result()
7909 
    try:
7910 
      result.success = self._handler.getTransactionStatus(args.transactionId)
7911 
    except TransactionServiceException, ex:
7912 
      result.ex = ex
7913 
    oprot.writeMessageBegin("getTransactionStatus", TMessageType.REPLY, seqid)
7914 
    result.write(oprot)
7915 
    oprot.writeMessageEnd()
7916 
    oprot.trans.flush()
7917 
 
7918 
  def process_changeTransactionStatus(self, seqid, iprot, oprot):
7919 
    args = changeTransactionStatus_args()
7920 
    args.read(iprot)
7921 
    iprot.readMessageEnd()
7922 
    result = changeTransactionStatus_result()
7923 
    try:
7293 anupam.sin 7924 
      result.success = self._handler.changeTransactionStatus(args.transactionId, args.status, args.description, args.pickUp, args.orderType, args.source)
94 ashish 7925 
    except TransactionServiceException, ex:
7926 
      result.ex = ex
7927 
    oprot.writeMessageBegin("changeTransactionStatus", TMessageType.REPLY, seqid)
7928 
    result.write(oprot)
7929 
    oprot.writeMessageEnd()
7930 
    oprot.trans.flush()
7931 
 
1398 varun.gupt 7932 
  def process_enqueueTransactionInfoEmail(self, seqid, iprot, oprot):
7933 
    args = enqueueTransactionInfoEmail_args()
1382 varun.gupt 7934 
    args.read(iprot)
7935 
    iprot.readMessageEnd()
1398 varun.gupt 7936 
    result = enqueueTransactionInfoEmail_result()
1382 varun.gupt 7937 
    try:
1398 varun.gupt 7938 
      result.success = self._handler.enqueueTransactionInfoEmail(args.transactionId)
1382 varun.gupt 7939 
    except TransactionServiceException, ex:
7940 
      result.ex = ex
1398 varun.gupt 7941 
    oprot.writeMessageBegin("enqueueTransactionInfoEmail", TMessageType.REPLY, seqid)
1382 varun.gupt 7942 
    result.write(oprot)
7943 
    oprot.writeMessageEnd()
7944 
    oprot.trans.flush()
7945 
 
483 rajveer 7946 
  def process_getAllOrders(self, seqid, iprot, oprot):
7947 
    args = getAllOrders_args()
94 ashish 7948 
    args.read(iprot)
7949 
    iprot.readMessageEnd()
483 rajveer 7950 
    result = getAllOrders_result()
94 ashish 7951 
    try:
4801 anupam.sin 7952 
      result.success = self._handler.getAllOrders(args.statuses, args.from_date, args.to_date, args.warehouse_id)
94 ashish 7953 
    except TransactionServiceException, ex:
7954 
      result.ex = ex
483 rajveer 7955 
    oprot.writeMessageBegin("getAllOrders", TMessageType.REPLY, seqid)
94 ashish 7956 
    result.write(oprot)
7957 
    oprot.writeMessageEnd()
7958 
    oprot.trans.flush()
7959 
 
4133 chandransh 7960 
  def process_getOrdersInBatch(self, seqid, iprot, oprot):
7961 
    args = getOrdersInBatch_args()
7962 
    args.read(iprot)
7963 
    iprot.readMessageEnd()
7964 
    result = getOrdersInBatch_result()
7965 
    try:
7966 
      result.success = self._handler.getOrdersInBatch(args.statuses, args.offset, args.limit, args.warehouse_id)
7967 
    except TransactionServiceException, ex:
7968 
      result.ex = ex
7969 
    oprot.writeMessageBegin("getOrdersInBatch", TMessageType.REPLY, seqid)
7970 
    result.write(oprot)
7971 
    oprot.writeMessageEnd()
7972 
    oprot.trans.flush()
7973 
 
7974 
  def process_getOrderCount(self, seqid, iprot, oprot):
7975 
    args = getOrderCount_args()
7976 
    args.read(iprot)
7977 
    iprot.readMessageEnd()
7978 
    result = getOrderCount_result()
7979 
    try:
7980 
      result.success = self._handler.getOrderCount(args.statuses, args.warehouseId)
7981 
    except TransactionServiceException, ex:
7982 
      result.ex = ex
7983 
    oprot.writeMessageBegin("getOrderCount", TMessageType.REPLY, seqid)
7984 
    result.write(oprot)
7985 
    oprot.writeMessageEnd()
7986 
    oprot.trans.flush()
7987 
 
999 varun.gupt 7988 
  def process_getOrdersByBillingDate(self, seqid, iprot, oprot):
7989 
    args = getOrdersByBillingDate_args()
7990 
    args.read(iprot)
7991 
    iprot.readMessageEnd()
7992 
    result = getOrdersByBillingDate_result()
7993 
    try:
7994 
      result.success = self._handler.getOrdersByBillingDate(args.status, args.start_billing_date, args.end_billing_date, args.warehouse_id)
7995 
    except TransactionServiceException, ex:
7996 
      result.ex = ex
7997 
    oprot.writeMessageBegin("getOrdersByBillingDate", TMessageType.REPLY, seqid)
7998 
    result.write(oprot)
7999 
    oprot.writeMessageEnd()
8000 
    oprot.trans.flush()
8001 
 
3427 chandransh 8002 
  def process_getOrdersByShippingDate(self, seqid, iprot, oprot):
8003 
    args = getOrdersByShippingDate_args()
8004 
    args.read(iprot)
8005 
    iprot.readMessageEnd()
8006 
    result = getOrdersByShippingDate_result()
8007 
    try:
3451 chandransh 8008 
      result.success = self._handler.getOrdersByShippingDate(args.fromShippingDate, args.toShippingDate, args.providerId, args.warehouseId, args.cod)
3427 chandransh 8009 
    except TransactionServiceException, ex:
8010 
      result.ex = ex
8011 
    oprot.writeMessageBegin("getOrdersByShippingDate", TMessageType.REPLY, seqid)
8012 
    result.write(oprot)
8013 
    oprot.writeMessageEnd()
8014 
    oprot.trans.flush()
8015 
 
1382 varun.gupt 8016 
  def process_getReturnableOrdersForCustomer(self, seqid, iprot, oprot):
8017 
    args = getReturnableOrdersForCustomer_args()
8018 
    args.read(iprot)
8019 
    iprot.readMessageEnd()
8020 
    result = getReturnableOrdersForCustomer_result()
8021 
    try:
8022 
      result.success = self._handler.getReturnableOrdersForCustomer(args.customer_id, args.limit)
8023 
    except TransactionServiceException, ex:
8024 
      result.ex = ex
8025 
    oprot.writeMessageBegin("getReturnableOrdersForCustomer", TMessageType.REPLY, seqid)
8026 
    result.write(oprot)
8027 
    oprot.writeMessageEnd()
8028 
    oprot.trans.flush()
8029 
 
8030 
  def process_getCancellableOrdersForCustomer(self, seqid, iprot, oprot):
8031 
    args = getCancellableOrdersForCustomer_args()
8032 
    args.read(iprot)
8033 
    iprot.readMessageEnd()
8034 
    result = getCancellableOrdersForCustomer_result()
8035 
    try:
8036 
      result.success = self._handler.getCancellableOrdersForCustomer(args.customer_id, args.limit)
8037 
    except TransactionServiceException, ex:
8038 
      result.ex = ex
8039 
    oprot.writeMessageBegin("getCancellableOrdersForCustomer", TMessageType.REPLY, seqid)
8040 
    result.write(oprot)
8041 
    oprot.writeMessageEnd()
8042 
    oprot.trans.flush()
8043 
 
483 rajveer 8044 
  def process_changeOrderStatus(self, seqid, iprot, oprot):
8045 
    args = changeOrderStatus_args()
94 ashish 8046 
    args.read(iprot)
8047 
    iprot.readMessageEnd()
483 rajveer 8048 
    result = changeOrderStatus_result()
94 ashish 8049 
    try:
483 rajveer 8050 
      result.success = self._handler.changeOrderStatus(args.orderId, args.status, args.description)
94 ashish 8051 
    except TransactionServiceException, ex:
8052 
      result.ex = ex
483 rajveer 8053 
    oprot.writeMessageBegin("changeOrderStatus", TMessageType.REPLY, seqid)
94 ashish 8054 
    result.write(oprot)
8055 
    oprot.writeMessageEnd()
8056 
    oprot.trans.flush()
8057 
 
483 rajveer 8058 
  def process_getOrdersForTransaction(self, seqid, iprot, oprot):
8059 
    args = getOrdersForTransaction_args()
94 ashish 8060 
    args.read(iprot)
8061 
    iprot.readMessageEnd()
483 rajveer 8062 
    result = getOrdersForTransaction_result()
94 ashish 8063 
    try:
1528 ankur.sing 8064 
      result.success = self._handler.getOrdersForTransaction(args.transactionId, args.customerId)
94 ashish 8065 
    except TransactionServiceException, ex:
8066 
      result.ex = ex
483 rajveer 8067 
    oprot.writeMessageBegin("getOrdersForTransaction", TMessageType.REPLY, seqid)
94 ashish 8068 
    result.write(oprot)
8069 
    oprot.writeMessageEnd()
8070 
    oprot.trans.flush()
8071 
 
483 rajveer 8072 
  def process_getOrdersForCustomer(self, seqid, iprot, oprot):
8073 
    args = getOrdersForCustomer_args()
94 ashish 8074 
    args.read(iprot)
8075 
    iprot.readMessageEnd()
483 rajveer 8076 
    result = getOrdersForCustomer_result()
94 ashish 8077 
    try:
3014 chandransh 8078 
      result.success = self._handler.getOrdersForCustomer(args.customerId, args.from_date, args.to_date, args.statuses)
94 ashish 8079 
    except TransactionServiceException, ex:
8080 
      result.ex = ex
483 rajveer 8081 
    oprot.writeMessageBegin("getOrdersForCustomer", TMessageType.REPLY, seqid)
94 ashish 8082 
    result.write(oprot)
8083 
    oprot.writeMessageEnd()
8084 
    oprot.trans.flush()
8085 
 
483 rajveer 8086 
  def process_createOrder(self, seqid, iprot, oprot):
8087 
    args = createOrder_args()
94 ashish 8088 
    args.read(iprot)
8089 
    iprot.readMessageEnd()
483 rajveer 8090 
    result = createOrder_result()
94 ashish 8091 
    try:
483 rajveer 8092 
      result.success = self._handler.createOrder(args.order)
94 ashish 8093 
    except TransactionServiceException, ex:
8094 
      result.ex = ex
483 rajveer 8095 
    oprot.writeMessageBegin("createOrder", TMessageType.REPLY, seqid)
94 ashish 8096 
    result.write(oprot)
8097 
    oprot.writeMessageEnd()
8098 
    oprot.trans.flush()
8099 
 
483 rajveer 8100 
  def process_getOrder(self, seqid, iprot, oprot):
8101 
    args = getOrder_args()
94 ashish 8102 
    args.read(iprot)
8103 
    iprot.readMessageEnd()
483 rajveer 8104 
    result = getOrder_result()
94 ashish 8105 
    try:
483 rajveer 8106 
      result.success = self._handler.getOrder(args.id)
94 ashish 8107 
    except TransactionServiceException, ex:
8108 
      result.ex = ex
483 rajveer 8109 
    oprot.writeMessageBegin("getOrder", TMessageType.REPLY, seqid)
94 ashish 8110 
    result.write(oprot)
8111 
    oprot.writeMessageEnd()
8112 
    oprot.trans.flush()
8113 
 
483 rajveer 8114 
  def process_getLineItemsForOrder(self, seqid, iprot, oprot):
8115 
    args = getLineItemsForOrder_args()
94 ashish 8116 
    args.read(iprot)
8117 
    iprot.readMessageEnd()
483 rajveer 8118 
    result = getLineItemsForOrder_result()
94 ashish 8119 
    try:
483 rajveer 8120 
      result.success = self._handler.getLineItemsForOrder(args.orderId)
94 ashish 8121 
    except TransactionServiceException, ex:
8122 
      result.ex = ex
483 rajveer 8123 
    oprot.writeMessageBegin("getLineItemsForOrder", TMessageType.REPLY, seqid)
94 ashish 8124 
    result.write(oprot)
8125 
    oprot.writeMessageEnd()
8126 
    oprot.trans.flush()
8127 
 
4999 phani.kuma 8128 
  def process_getOrderList(self, seqid, iprot, oprot):
8129 
    args = getOrderList_args()
8130 
    args.read(iprot)
8131 
    iprot.readMessageEnd()
8132 
    result = getOrderList_result()
8133 
    result.success = self._handler.getOrderList(args.order_ids)
8134 
    oprot.writeMessageBegin("getOrderList", TMessageType.REPLY, seqid)
8135 
    result.write(oprot)
8136 
    oprot.writeMessageEnd()
8137 
    oprot.trans.flush()
8138 
 
5386 phani.kuma 8139 
  def process_getOrderListForVendor(self, seqid, iprot, oprot):
8140 
    args = getOrderListForVendor_args()
8141 
    args.read(iprot)
8142 
    iprot.readMessageEnd()
8143 
    result = getOrderListForVendor_result()
8144 
    result.success = self._handler.getOrderListForVendor(args.order_ids, args.vendorId)
8145 
    oprot.writeMessageBegin("getOrderListForVendor", TMessageType.REPLY, seqid)
8146 
    result.write(oprot)
8147 
    oprot.writeMessageEnd()
8148 
    oprot.trans.flush()
8149 
 
1528 ankur.sing 8150 
  def process_getOrderForCustomer(self, seqid, iprot, oprot):
8151 
    args = getOrderForCustomer_args()
8152 
    args.read(iprot)
8153 
    iprot.readMessageEnd()
8154 
    result = getOrderForCustomer_result()
8155 
    try:
8156 
      result.success = self._handler.getOrderForCustomer(args.orderId, args.customerId)
8157 
    except TransactionServiceException, ex:
8158 
      result.ex = ex
8159 
    oprot.writeMessageBegin("getOrderForCustomer", TMessageType.REPLY, seqid)
8160 
    result.write(oprot)
8161 
    oprot.writeMessageEnd()
8162 
    oprot.trans.flush()
8163 
 
3064 chandransh 8164 
  def process_getAlerts(self, seqid, iprot, oprot):
8165 
    args = getAlerts_args()
8166 
    args.read(iprot)
8167 
    iprot.readMessageEnd()
8168 
    result = getAlerts_result()
4444 rajveer 8169 
    result.success = self._handler.getAlerts(args.type, args.warehouseId, args.status, args.timestamp)
3064 chandransh 8170 
    oprot.writeMessageBegin("getAlerts", TMessageType.REPLY, seqid)
8171 
    result.write(oprot)
8172 
    oprot.writeMessageEnd()
8173 
    oprot.trans.flush()
8174 
 
4394 rajveer 8175 
  def process_addAlert(self, seqid, iprot, oprot):
8176 
    args = addAlert_args()
3064 chandransh 8177 
    args.read(iprot)
8178 
    iprot.readMessageEnd()
4394 rajveer 8179 
    result = addAlert_result()
4444 rajveer 8180 
    self._handler.addAlert(args.type, args.warehouseId, args.description)
4394 rajveer 8181 
    oprot.writeMessageBegin("addAlert", TMessageType.REPLY, seqid)
3064 chandransh 8182 
    result.write(oprot)
8183 
    oprot.writeMessageEnd()
8184 
    oprot.trans.flush()
8185 
 
4444 rajveer 8186 
  def process_markAlertsAsSeen(self, seqid, iprot, oprot):
8187 
    args = markAlertsAsSeen_args()
8188 
    args.read(iprot)
8189 
    iprot.readMessageEnd()
8190 
    result = markAlertsAsSeen_result()
8191 
    self._handler.markAlertsAsSeen(args.warehouseId)
8192 
    oprot.writeMessageBegin("markAlertsAsSeen", TMessageType.REPLY, seqid)
8193 
    result.write(oprot)
8194 
    oprot.writeMessageEnd()
8195 
    oprot.trans.flush()
8196 
 
3064 chandransh 8197 
  def process_getValidOrderCount(self, seqid, iprot, oprot):
8198 
    args = getValidOrderCount_args()
8199 
    args.read(iprot)
8200 
    iprot.readMessageEnd()
8201 
    result = getValidOrderCount_result()
8202 
    result.success = self._handler.getValidOrderCount()
8203 
    oprot.writeMessageBegin("getValidOrderCount", TMessageType.REPLY, seqid)
8204 
    result.write(oprot)
8205 
    oprot.writeMessageEnd()
8206 
    oprot.trans.flush()
8207 
 
8208 
  def process_getNoOfCustomersWithSuccessfulTransaction(self, seqid, iprot, oprot):
8209 
    args = getNoOfCustomersWithSuccessfulTransaction_args()
8210 
    args.read(iprot)
8211 
    iprot.readMessageEnd()
8212 
    result = getNoOfCustomersWithSuccessfulTransaction_result()
8213 
    result.success = self._handler.getNoOfCustomersWithSuccessfulTransaction()
8214 
    oprot.writeMessageBegin("getNoOfCustomersWithSuccessfulTransaction", TMessageType.REPLY, seqid)
8215 
    result.write(oprot)
8216 
    oprot.writeMessageEnd()
8217 
    oprot.trans.flush()
8218 
 
8219 
  def process_getValidOrdersAmountRange(self, seqid, iprot, oprot):
8220 
    args = getValidOrdersAmountRange_args()
8221 
    args.read(iprot)
8222 
    iprot.readMessageEnd()
8223 
    result = getValidOrdersAmountRange_result()
8224 
    result.success = self._handler.getValidOrdersAmountRange()
8225 
    oprot.writeMessageBegin("getValidOrdersAmountRange", TMessageType.REPLY, seqid)
8226 
    result.write(oprot)
8227 
    oprot.writeMessageEnd()
8228 
    oprot.trans.flush()
8229 
 
8230 
  def process_getValidOrders(self, seqid, iprot, oprot):
8231 
    args = getValidOrders_args()
8232 
    args.read(iprot)
8233 
    iprot.readMessageEnd()
8234 
    result = getValidOrders_result()
5874 rajveer 8235 
    result.success = self._handler.getValidOrders(args.limit, args.onlyStore)
3064 chandransh 8236 
    oprot.writeMessageBegin("getValidOrders", TMessageType.REPLY, seqid)
8237 
    result.write(oprot)
8238 
    oprot.writeMessageEnd()
8239 
    oprot.trans.flush()
8240 
 
1220 chandransh 8241 
  def process_batchOrders(self, seqid, iprot, oprot):
8242 
    args = batchOrders_args()
8243 
    args.read(iprot)
8244 
    iprot.readMessageEnd()
8245 
    result = batchOrders_result()
8246 
    try:
8247 
      result.success = self._handler.batchOrders(args.warehouseId)
8248 
    except TransactionServiceException, ex:
8249 
      result.ex = ex
8250 
    oprot.writeMessageBegin("batchOrders", TMessageType.REPLY, seqid)
8251 
    result.write(oprot)
8252 
    oprot.writeMessageEnd()
8253 
    oprot.trans.flush()
8254 
 
1208 chandransh 8255 
  def process_markOrderAsOutOfStock(self, seqid, iprot, oprot):
8256 
    args = markOrderAsOutOfStock_args()
8257 
    args.read(iprot)
8258 
    iprot.readMessageEnd()
8259 
    result = markOrderAsOutOfStock_result()
8260 
    try:
8261 
      result.success = self._handler.markOrderAsOutOfStock(args.orderId)
8262 
    except TransactionServiceException, ex:
8263 
      result.ex = ex
8264 
    oprot.writeMessageBegin("markOrderAsOutOfStock", TMessageType.REPLY, seqid)
8265 
    result.write(oprot)
8266 
    oprot.writeMessageEnd()
8267 
    oprot.trans.flush()
8268 
 
3064 chandransh 8269 
  def process_verifyOrder(self, seqid, iprot, oprot):
8270 
    args = verifyOrder_args()
759 chandransh 8271 
    args.read(iprot)
8272 
    iprot.readMessageEnd()
3064 chandransh 8273 
    result = verifyOrder_result()
759 chandransh 8274 
    try:
3064 chandransh 8275 
      result.success = self._handler.verifyOrder(args.orderId)
759 chandransh 8276 
    except TransactionServiceException, ex:
8277 
      result.ex = ex
3064 chandransh 8278 
    oprot.writeMessageBegin("verifyOrder", TMessageType.REPLY, seqid)
759 chandransh 8279 
    result.write(oprot)
8280 
    oprot.writeMessageEnd()
8281 
    oprot.trans.flush()
8282 
 
3064 chandransh 8283 
  def process_acceptOrder(self, seqid, iprot, oprot):
8284 
    args = acceptOrder_args()
1113 chandransh 8285 
    args.read(iprot)
8286 
    iprot.readMessageEnd()
3064 chandransh 8287 
    result = acceptOrder_result()
1113 chandransh 8288 
    try:
3064 chandransh 8289 
      result.success = self._handler.acceptOrder(args.orderId)
1113 chandransh 8290 
    except TransactionServiceException, ex:
8291 
      result.ex = ex
3064 chandransh 8292 
    oprot.writeMessageBegin("acceptOrder", TMessageType.REPLY, seqid)
1113 chandransh 8293 
    result.write(oprot)
8294 
    oprot.writeMessageEnd()
8295 
    oprot.trans.flush()
8296 
 
3064 chandransh 8297 
  def process_addBillingDetails(self, seqid, iprot, oprot):
8298 
    args = addBillingDetails_args()
1135 chandransh 8299 
    args.read(iprot)
8300 
    iprot.readMessageEnd()
3064 chandransh 8301 
    result = addBillingDetails_result()
1135 chandransh 8302 
    try:
7190 amar.kumar 8303 
      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 8304 
    except TransactionServiceException, ex:
8305 
      result.ex = ex
3064 chandransh 8306 
    oprot.writeMessageBegin("addBillingDetails", TMessageType.REPLY, seqid)
1135 chandransh 8307 
    result.write(oprot)
8308 
    oprot.writeMessageEnd()
8309 
    oprot.trans.flush()
8310 
 
4579 rajveer 8311 
  def process_addInvoiceNumber(self, seqid, iprot, oprot):
8312 
    args = addInvoiceNumber_args()
8313 
    args.read(iprot)
8314 
    iprot.readMessageEnd()
8315 
    result = addInvoiceNumber_result()
8316 
    try:
6756 amar.kumar 8317 
      self._handler.addInvoiceNumber(args.orderId, args.invoiceNumber, args.color, args.serialNumber, args.itemNumber)
4579 rajveer 8318 
    except TransactionServiceException, ex:
8319 
      result.ex = ex
8320 
    oprot.writeMessageBegin("addInvoiceNumber", TMessageType.REPLY, seqid)
8321 
    result.write(oprot)
8322 
    oprot.writeMessageEnd()
8323 
    oprot.trans.flush()
8324 
 
4410 rajveer 8325 
  def process_markOrdersAsShippedFromWarehouse(self, seqid, iprot, oprot):
8326 
    args = markOrdersAsShippedFromWarehouse_args()
8327 
    args.read(iprot)
8328 
    iprot.readMessageEnd()
8329 
    result = markOrdersAsShippedFromWarehouse_result()
8330 
    try:
4789 rajveer 8331 
      result.success = self._handler.markOrdersAsShippedFromWarehouse(args.warehouseId, args.providerId, args.cod, args.orderIds)
4410 rajveer 8332 
    except TransactionServiceException, ex:
8333 
      result.ex = ex
8334 
    oprot.writeMessageBegin("markOrdersAsShippedFromWarehouse", TMessageType.REPLY, seqid)
8335 
    result.write(oprot)
8336 
    oprot.writeMessageEnd()
8337 
    oprot.trans.flush()
8338 
 
5676 rajveer 8339 
  def process_markOrdersAsReturnedFromStore(self, seqid, iprot, oprot):
8340 
    args = markOrdersAsReturnedFromStore_args()
8341 
    args.read(iprot)
8342 
    iprot.readMessageEnd()
8343 
    result = markOrdersAsReturnedFromStore_result()
8344 
    try:
5713 rajveer 8345 
      result.success = self._handler.markOrdersAsReturnedFromStore(args.providerId, args.orderIds, args.awbs)
5676 rajveer 8346 
    except TransactionServiceException, ex:
8347 
      result.ex = ex
8348 
    oprot.writeMessageBegin("markOrdersAsReturnedFromStore", TMessageType.REPLY, seqid)
8349 
    result.write(oprot)
8350 
    oprot.writeMessageEnd()
8351 
    oprot.trans.flush()
8352 
 
3064 chandransh 8353 
  def process_markOrdersAsPickedUp(self, seqid, iprot, oprot):
8354 
    args = markOrdersAsPickedUp_args()
304 ashish 8355 
    args.read(iprot)
8356 
    iprot.readMessageEnd()
3064 chandransh 8357 
    result = markOrdersAsPickedUp_result()
8358 
    try:
4910 phani.kuma 8359 
      self._handler.markOrdersAsPickedUp(args.providerId, args.pickupDetails)
3064 chandransh 8360 
    except TransactionServiceException, ex:
8361 
      result.ex = ex
8362 
    oprot.writeMessageBegin("markOrdersAsPickedUp", TMessageType.REPLY, seqid)
304 ashish 8363 
    result.write(oprot)
8364 
    oprot.writeMessageEnd()
8365 
    oprot.trans.flush()
94 ashish 8366 
 
4910 phani.kuma 8367 
  def process_getOrdersNotPickedUp(self, seqid, iprot, oprot):
8368 
    args = getOrdersNotPickedUp_args()
8369 
    args.read(iprot)
8370 
    iprot.readMessageEnd()
8371 
    result = getOrdersNotPickedUp_result()
8372 
    result.success = self._handler.getOrdersNotPickedUp(args.providerId)
8373 
    oprot.writeMessageBegin("getOrdersNotPickedUp", TMessageType.REPLY, seqid)
8374 
    result.write(oprot)
8375 
    oprot.writeMessageEnd()
8376 
    oprot.trans.flush()
8377 
 
3064 chandransh 8378 
  def process_markOrdersAsDelivered(self, seqid, iprot, oprot):
8379 
    args = markOrdersAsDelivered_args()
304 ashish 8380 
    args.read(iprot)
8381 
    iprot.readMessageEnd()
3064 chandransh 8382 
    result = markOrdersAsDelivered_result()
8383 
    try:
8384 
      self._handler.markOrdersAsDelivered(args.providerId, args.deliveredOrders)
8385 
    except TransactionServiceException, ex:
8386 
      result.ex = ex
8387 
    oprot.writeMessageBegin("markOrdersAsDelivered", TMessageType.REPLY, seqid)
304 ashish 8388 
    result.write(oprot)
8389 
    oprot.writeMessageEnd()
8390 
    oprot.trans.flush()
8391 
 
4910 phani.kuma 8392 
  def process_markAsRTOrders(self, seqid, iprot, oprot):
8393 
    args = markAsRTOrders_args()
1596 ankur.sing 8394 
    args.read(iprot)
8395 
    iprot.readMessageEnd()
4910 phani.kuma 8396 
    result = markAsRTOrders_result()
3064 chandransh 8397 
    try:
4910 phani.kuma 8398 
      self._handler.markAsRTOrders(args.providerId, args.returnedOrders)
3064 chandransh 8399 
    except TransactionServiceException, ex:
8400 
      result.ex = ex
4910 phani.kuma 8401 
    oprot.writeMessageBegin("markAsRTOrders", TMessageType.REPLY, seqid)
1596 ankur.sing 8402 
    result.write(oprot)
8403 
    oprot.writeMessageEnd()
8404 
    oprot.trans.flush()
304 ashish 8405 
 
4910 phani.kuma 8406 
  def process_getRTOrders(self, seqid, iprot, oprot):
8407 
    args = getRTOrders_args()
8408 
    args.read(iprot)
8409 
    iprot.readMessageEnd()
8410 
    result = getRTOrders_result()
8411 
    result.success = self._handler.getRTOrders(args.providerId)
8412 
    oprot.writeMessageBegin("getRTOrders", TMessageType.REPLY, seqid)
8413 
    result.write(oprot)
8414 
    oprot.writeMessageEnd()
8415 
    oprot.trans.flush()
8416 
 
3064 chandransh 8417 
  def process_updateNonDeliveryReason(self, seqid, iprot, oprot):
8418 
    args = updateNonDeliveryReason_args()
1627 ankur.sing 8419 
    args.read(iprot)
8420 
    iprot.readMessageEnd()
3064 chandransh 8421 
    result = updateNonDeliveryReason_result()
8422 
    try:
4910 phani.kuma 8423 
      self._handler.updateNonDeliveryReason(args.providerId, args.undeliveredOrders)
3064 chandransh 8424 
    except TransactionServiceException, ex:
8425 
      result.ex = ex
8426 
    oprot.writeMessageBegin("updateNonDeliveryReason", TMessageType.REPLY, seqid)
1627 ankur.sing 8427 
    result.write(oprot)
8428 
    oprot.writeMessageEnd()
8429 
    oprot.trans.flush()
1596 ankur.sing 8430 
 
4910 phani.kuma 8431 
  def process_getNonDeliveredOrdersbyCourier(self, seqid, iprot, oprot):
8432 
    args = getNonDeliveredOrdersbyCourier_args()
8433 
    args.read(iprot)
8434 
    iprot.readMessageEnd()
8435 
    result = getNonDeliveredOrdersbyCourier_result()
8436 
    result.success = self._handler.getNonDeliveredOrdersbyCourier(args.providerId)
8437 
    oprot.writeMessageBegin("getNonDeliveredOrdersbyCourier", TMessageType.REPLY, seqid)
8438 
    result.write(oprot)
8439 
    oprot.writeMessageEnd()
8440 
    oprot.trans.flush()
8441 
 
8442 
  def process_markOrdersAsLocalConnected(self, seqid, iprot, oprot):
8443 
    args = markOrdersAsLocalConnected_args()
8444 
    args.read(iprot)
8445 
    iprot.readMessageEnd()
8446 
    result = markOrdersAsLocalConnected_result()
8447 
    try:
8448 
      self._handler.markOrdersAsLocalConnected(args.providerId, args.local_connected_orders)
8449 
    except TransactionServiceException, ex:
8450 
      result.ex = ex
8451 
    oprot.writeMessageBegin("markOrdersAsLocalConnected", TMessageType.REPLY, seqid)
8452 
    result.write(oprot)
8453 
    oprot.writeMessageEnd()
8454 
    oprot.trans.flush()
8455 
 
8456 
  def process_getOrdersNotLocalConnected(self, seqid, iprot, oprot):
8457 
    args = getOrdersNotLocalConnected_args()
8458 
    args.read(iprot)
8459 
    iprot.readMessageEnd()
8460 
    result = getOrdersNotLocalConnected_result()
8461 
    result.success = self._handler.getOrdersNotLocalConnected(args.providerId)
8462 
    oprot.writeMessageBegin("getOrdersNotLocalConnected", TMessageType.REPLY, seqid)
8463 
    result.write(oprot)
8464 
    oprot.writeMessageEnd()
8465 
    oprot.trans.flush()
8466 
 
8467 
  def process_markOrdersAsDestinationCityReached(self, seqid, iprot, oprot):
8468 
    args = markOrdersAsDestinationCityReached_args()
8469 
    args.read(iprot)
8470 
    iprot.readMessageEnd()
8471 
    result = markOrdersAsDestinationCityReached_result()
8472 
    try:
8473 
      self._handler.markOrdersAsDestinationCityReached(args.providerId, args.destination_city_reached_orders)
8474 
    except TransactionServiceException, ex:
8475 
      result.ex = ex
8476 
    oprot.writeMessageBegin("markOrdersAsDestinationCityReached", TMessageType.REPLY, seqid)
8477 
    result.write(oprot)
8478 
    oprot.writeMessageEnd()
8479 
    oprot.trans.flush()
8480 
 
8481 
  def process_markOrdersAsFirstDeliveryAttempted(self, seqid, iprot, oprot):
8482 
    args = markOrdersAsFirstDeliveryAttempted_args()
8483 
    args.read(iprot)
8484 
    iprot.readMessageEnd()
8485 
    result = markOrdersAsFirstDeliveryAttempted_result()
8486 
    try:
8487 
      self._handler.markOrdersAsFirstDeliveryAttempted(args.providerId, args.first_atdl_orders)
8488 
    except TransactionServiceException, ex:
8489 
      result.ex = ex
8490 
    oprot.writeMessageBegin("markOrdersAsFirstDeliveryAttempted", TMessageType.REPLY, seqid)
8491 
    result.write(oprot)
8492 
    oprot.writeMessageEnd()
8493 
    oprot.trans.flush()
8494 
 
3064 chandransh 8495 
  def process_getUndeliveredOrders(self, seqid, iprot, oprot):
8496 
    args = getUndeliveredOrders_args()
1627 ankur.sing 8497 
    args.read(iprot)
8498 
    iprot.readMessageEnd()
3064 chandransh 8499 
    result = getUndeliveredOrders_result()
8500 
    result.success = self._handler.getUndeliveredOrders(args.providerId, args.warehouseId)
8501 
    oprot.writeMessageBegin("getUndeliveredOrders", TMessageType.REPLY, seqid)
1627 ankur.sing 8502 
    result.write(oprot)
8503 
    oprot.writeMessageEnd()
8504 
    oprot.trans.flush()
8505 
 
4783 phani.kuma 8506 
  def process_getUndeliveredOrdersExpectedDeliveryDateNotMet(self, seqid, iprot, oprot):
8507 
    args = getUndeliveredOrdersExpectedDeliveryDateNotMet_args()
8508 
    args.read(iprot)
8509 
    iprot.readMessageEnd()
8510 
    result = getUndeliveredOrdersExpectedDeliveryDateNotMet_result()
8511 
    result.success = self._handler.getUndeliveredOrdersExpectedDeliveryDateNotMet()
8512 
    oprot.writeMessageBegin("getUndeliveredOrdersExpectedDeliveryDateNotMet", TMessageType.REPLY, seqid)
8513 
    result.write(oprot)
8514 
    oprot.writeMessageEnd()
8515 
    oprot.trans.flush()
8516 
 
2536 chandransh 8517 
  def process_toggleDOAFlag(self, seqid, iprot, oprot):
8518 
    args = toggleDOAFlag_args()
8519 
    args.read(iprot)
8520 
    iprot.readMessageEnd()
8521 
    result = toggleDOAFlag_result()
8522 
    try:
8523 
      result.success = self._handler.toggleDOAFlag(args.orderId)
8524 
    except TransactionServiceException, ex:
8525 
      result.ex = ex
8526 
    oprot.writeMessageBegin("toggleDOAFlag", TMessageType.REPLY, seqid)
8527 
    result.write(oprot)
8528 
    oprot.writeMessageEnd()
8529 
    oprot.trans.flush()
1886 ankur.sing 8530 
 
4712 rajveer 8531 
  def process_markOrderAsDelivered(self, seqid, iprot, oprot):
8532 
    args = markOrderAsDelivered_args()
8533 
    args.read(iprot)
8534 
    iprot.readMessageEnd()
8535 
    result = markOrderAsDelivered_result()
8536 
    try:
8537 
      self._handler.markOrderAsDelivered(args.orderId, args.deliveryTimestamp, args.receiver)
8538 
    except TransactionServiceException, ex:
8539 
      result.ex = ex
8540 
    oprot.writeMessageBegin("markOrderAsDelivered", TMessageType.REPLY, seqid)
8541 
    result.write(oprot)
8542 
    oprot.writeMessageEnd()
8543 
    oprot.trans.flush()
8544 
 
5553 rajveer 8545 
  def process_markOrderAsReceivedAtStore(self, seqid, iprot, oprot):
8546 
    args = markOrderAsReceivedAtStore_args()
8547 
    args.read(iprot)
8548 
    iprot.readMessageEnd()
8549 
    result = markOrderAsReceivedAtStore_result()
8550 
    try:
8551 
      self._handler.markOrderAsReceivedAtStore(args.orderId, args.deliveryTimestamp)
8552 
    except TransactionServiceException, ex:
8553 
      result.ex = ex
8554 
    oprot.writeMessageBegin("markOrderAsReceivedAtStore", TMessageType.REPLY, seqid)
8555 
    result.write(oprot)
8556 
    oprot.writeMessageEnd()
8557 
    oprot.trans.flush()
8558 
 
4454 rajveer 8559 
  def process_markOrderDoaRequestReceived(self, seqid, iprot, oprot):
8560 
    args = markOrderDoaRequestReceived_args()
8561 
    args.read(iprot)
8562 
    iprot.readMessageEnd()
8563 
    result = markOrderDoaRequestReceived_result()
8564 
    try:
8565 
      result.success = self._handler.markOrderDoaRequestReceived(args.orderId)
8566 
    except TransactionServiceException, ex:
8567 
      result.ex = ex
8568 
    oprot.writeMessageBegin("markOrderDoaRequestReceived", TMessageType.REPLY, seqid)
8569 
    result.write(oprot)
8570 
    oprot.writeMessageEnd()
8571 
    oprot.trans.flush()
8572 
 
8573 
  def process_markOrderDoaRequestAuthorized(self, seqid, iprot, oprot):
8574 
    args = markOrderDoaRequestAuthorized_args()
8575 
    args.read(iprot)
8576 
    iprot.readMessageEnd()
8577 
    result = markOrderDoaRequestAuthorized_result()
8578 
    try:
8579 
      result.success = self._handler.markOrderDoaRequestAuthorized(args.orderId, args.isAuthorized)
8580 
    except TransactionServiceException, ex:
8581 
      result.ex = ex
8582 
    oprot.writeMessageBegin("markOrderDoaRequestAuthorized", TMessageType.REPLY, seqid)
8583 
    result.write(oprot)
8584 
    oprot.writeMessageEnd()
8585 
    oprot.trans.flush()
8586 
 
4488 rajveer 8587 
  def process_markOrderReturnRequestReceived(self, seqid, iprot, oprot):
8588 
    args = markOrderReturnRequestReceived_args()
8589 
    args.read(iprot)
8590 
    iprot.readMessageEnd()
8591 
    result = markOrderReturnRequestReceived_result()
8592 
    try:
8593 
      result.success = self._handler.markOrderReturnRequestReceived(args.orderId)
8594 
    except TransactionServiceException, ex:
8595 
      result.ex = ex
8596 
    oprot.writeMessageBegin("markOrderReturnRequestReceived", TMessageType.REPLY, seqid)
8597 
    result.write(oprot)
8598 
    oprot.writeMessageEnd()
8599 
    oprot.trans.flush()
8600 
 
8601 
  def process_markOrderReturnRequestAuthorized(self, seqid, iprot, oprot):
8602 
    args = markOrderReturnRequestAuthorized_args()
8603 
    args.read(iprot)
8604 
    iprot.readMessageEnd()
8605 
    result = markOrderReturnRequestAuthorized_result()
8606 
    try:
8607 
      result.success = self._handler.markOrderReturnRequestAuthorized(args.orderId, args.isAuthorized)
8608 
    except TransactionServiceException, ex:
8609 
      result.ex = ex
8610 
    oprot.writeMessageBegin("markOrderReturnRequestAuthorized", TMessageType.REPLY, seqid)
8611 
    result.write(oprot)
8612 
    oprot.writeMessageEnd()
8613 
    oprot.trans.flush()
8614 
 
2536 chandransh 8615 
  def process_requestPickupNumber(self, seqid, iprot, oprot):
8616 
    args = requestPickupNumber_args()
8617 
    args.read(iprot)
8618 
    iprot.readMessageEnd()
8619 
    result = requestPickupNumber_result()
8620 
    try:
4579 rajveer 8621 
      result.success = self._handler.requestPickupNumber(args.orderId, args.providerId)
2536 chandransh 8622 
    except TransactionServiceException, ex:
8623 
      result.ex = ex
8624 
    oprot.writeMessageBegin("requestPickupNumber", TMessageType.REPLY, seqid)
8625 
    result.write(oprot)
8626 
    oprot.writeMessageEnd()
8627 
    oprot.trans.flush()
8628 
 
8629 
  def process_authorizePickup(self, seqid, iprot, oprot):
8630 
    args = authorizePickup_args()
8631 
    args.read(iprot)
8632 
    iprot.readMessageEnd()
8633 
    result = authorizePickup_result()
8634 
    try:
4602 rajveer 8635 
      result.success = self._handler.authorizePickup(args.orderId, args.pickupNumber, args.providerId)
2536 chandransh 8636 
    except TransactionServiceException, ex:
8637 
      result.ex = ex
8638 
    oprot.writeMessageBegin("authorizePickup", TMessageType.REPLY, seqid)
8639 
    result.write(oprot)
8640 
    oprot.writeMessageEnd()
8641 
    oprot.trans.flush()
8642 
 
2764 chandransh 8643 
  def process_markDoasAsPickedUp(self, seqid, iprot, oprot):
8644 
    args = markDoasAsPickedUp_args()
8645 
    args.read(iprot)
8646 
    iprot.readMessageEnd()
8647 
    result = markDoasAsPickedUp_result()
4910 phani.kuma 8648 
    self._handler.markDoasAsPickedUp(args.providerId, args.pickupDetails)
2764 chandransh 8649 
    oprot.writeMessageBegin("markDoasAsPickedUp", TMessageType.REPLY, seqid)
8650 
    result.write(oprot)
8651 
    oprot.writeMessageEnd()
8652 
    oprot.trans.flush()
8653 
 
4910 phani.kuma 8654 
  def process_getDoasNotPickedUp(self, seqid, iprot, oprot):
8655 
    args = getDoasNotPickedUp_args()
8656 
    args.read(iprot)
8657 
    iprot.readMessageEnd()
8658 
    result = getDoasNotPickedUp_result()
8659 
    result.success = self._handler.getDoasNotPickedUp(args.providerId)
8660 
    oprot.writeMessageBegin("getDoasNotPickedUp", TMessageType.REPLY, seqid)
8661 
    result.write(oprot)
8662 
    oprot.writeMessageEnd()
8663 
    oprot.trans.flush()
8664 
 
4741 phani.kuma 8665 
  def process_markReturnOrdersAsPickedUp(self, seqid, iprot, oprot):
8666 
    args = markReturnOrdersAsPickedUp_args()
8667 
    args.read(iprot)
8668 
    iprot.readMessageEnd()
8669 
    result = markReturnOrdersAsPickedUp_result()
4910 phani.kuma 8670 
    self._handler.markReturnOrdersAsPickedUp(args.providerId, args.pickupDetails)
4741 phani.kuma 8671 
    oprot.writeMessageBegin("markReturnOrdersAsPickedUp", TMessageType.REPLY, seqid)
8672 
    result.write(oprot)
8673 
    oprot.writeMessageEnd()
8674 
    oprot.trans.flush()
8675 
 
4910 phani.kuma 8676 
  def process_getReturnOrdersNotPickedUp(self, seqid, iprot, oprot):
8677 
    args = getReturnOrdersNotPickedUp_args()
8678 
    args.read(iprot)
8679 
    iprot.readMessageEnd()
8680 
    result = getReturnOrdersNotPickedUp_result()
8681 
    result.success = self._handler.getReturnOrdersNotPickedUp(args.providerId)
8682 
    oprot.writeMessageBegin("getReturnOrdersNotPickedUp", TMessageType.REPLY, seqid)
8683 
    result.write(oprot)
8684 
    oprot.writeMessageEnd()
8685 
    oprot.trans.flush()
8686 
 
2616 chandransh 8687 
  def process_receiveReturn(self, seqid, iprot, oprot):
8688 
    args = receiveReturn_args()
2591 chandransh 8689 
    args.read(iprot)
8690 
    iprot.readMessageEnd()
2616 chandransh 8691 
    result = receiveReturn_result()
2591 chandransh 8692 
    try:
4479 rajveer 8693 
      result.success = self._handler.receiveReturn(args.orderId, args.receiveCondition)
2591 chandransh 8694 
    except TransactionServiceException, ex:
8695 
      result.ex = ex
2616 chandransh 8696 
    oprot.writeMessageBegin("receiveReturn", TMessageType.REPLY, seqid)
2591 chandransh 8697 
    result.write(oprot)
8698 
    oprot.writeMessageEnd()
8699 
    oprot.trans.flush()
2536 chandransh 8700 
 
2591 chandransh 8701 
  def process_validateDoa(self, seqid, iprot, oprot):
8702 
    args = validateDoa_args()
8703 
    args.read(iprot)
8704 
    iprot.readMessageEnd()
8705 
    result = validateDoa_result()
8706 
    try:
8707 
      result.success = self._handler.validateDoa(args.orderId, args.isValid)
8708 
    except TransactionServiceException, ex:
8709 
      result.ex = ex
8710 
    oprot.writeMessageBegin("validateDoa", TMessageType.REPLY, seqid)
8711 
    result.write(oprot)
8712 
    oprot.writeMessageEnd()
8713 
    oprot.trans.flush()
8714 
 
4495 rajveer 8715 
  def process_validateReturnProduct(self, seqid, iprot, oprot):
8716 
    args = validateReturnProduct_args()
8717 
    args.read(iprot)
8718 
    iprot.readMessageEnd()
8719 
    result = validateReturnProduct_result()
8720 
    try:
8721 
      result.success = self._handler.validateReturnProduct(args.orderId, args.isUsable)
8722 
    except TransactionServiceException, ex:
8723 
      result.ex = ex
8724 
    oprot.writeMessageBegin("validateReturnProduct", TMessageType.REPLY, seqid)
8725 
    result.write(oprot)
8726 
    oprot.writeMessageEnd()
8727 
    oprot.trans.flush()
8728 
 
2616 chandransh 8729 
  def process_reshipOrder(self, seqid, iprot, oprot):
8730 
    args = reshipOrder_args()
8731 
    args.read(iprot)
8732 
    iprot.readMessageEnd()
8733 
    result = reshipOrder_result()
8734 
    try:
8735 
      result.success = self._handler.reshipOrder(args.orderId)
8736 
    except TransactionServiceException, ex:
8737 
      result.ex = ex
8738 
    oprot.writeMessageBegin("reshipOrder", TMessageType.REPLY, seqid)
8739 
    result.write(oprot)
8740 
    oprot.writeMessageEnd()
8741 
    oprot.trans.flush()
2591 chandransh 8742 
 
2616 chandransh 8743 
  def process_refundOrder(self, seqid, iprot, oprot):
8744 
    args = refundOrder_args()
8745 
    args.read(iprot)
8746 
    iprot.readMessageEnd()
8747 
    result = refundOrder_result()
8748 
    try:
3226 chandransh 8749 
      result.success = self._handler.refundOrder(args.orderId, args.refundedBy, args.reason)
2616 chandransh 8750 
    except TransactionServiceException, ex:
8751 
      result.ex = ex
8752 
    oprot.writeMessageBegin("refundOrder", TMessageType.REPLY, seqid)
8753 
    result.write(oprot)
8754 
    oprot.writeMessageEnd()
8755 
    oprot.trans.flush()
8756 
 
2690 chandransh 8757 
  def process_getReturnOrders(self, seqid, iprot, oprot):
8758 
    args = getReturnOrders_args()
8759 
    args.read(iprot)
8760 
    iprot.readMessageEnd()
8761 
    result = getReturnOrders_result()
8762 
    result.success = self._handler.getReturnOrders(args.warehouseId, args.fromDate, args.toDate)
8763 
    oprot.writeMessageBegin("getReturnOrders", TMessageType.REPLY, seqid)
8764 
    result.write(oprot)
8765 
    oprot.writeMessageEnd()
8766 
    oprot.trans.flush()
2616 chandransh 8767 
 
5481 phani.kuma 8768 
  def process_getAllReturnOrders(self, seqid, iprot, oprot):
8769 
    args = getAllReturnOrders_args()
8770 
    args.read(iprot)
8771 
    iprot.readMessageEnd()
8772 
    result = getAllReturnOrders_result()
8773 
    result.success = self._handler.getAllReturnOrders(args.onlyNotProcessed, args.fromDate, args.toDate)
8774 
    oprot.writeMessageBegin("getAllReturnOrders", TMessageType.REPLY, seqid)
8775 
    result.write(oprot)
8776 
    oprot.writeMessageEnd()
8777 
    oprot.trans.flush()
8778 
 
2700 chandransh 8779 
  def process_getReturnOrder(self, seqid, iprot, oprot):
8780 
    args = getReturnOrder_args()
8781 
    args.read(iprot)
8782 
    iprot.readMessageEnd()
8783 
    result = getReturnOrder_result()
8784 
    try:
8785 
      result.success = self._handler.getReturnOrder(args.id)
8786 
    except TransactionServiceException, ex:
8787 
      result.ex = ex
8788 
    oprot.writeMessageBegin("getReturnOrder", TMessageType.REPLY, seqid)
8789 
    result.write(oprot)
8790 
    oprot.writeMessageEnd()
8791 
    oprot.trans.flush()
8792 
 
2690 chandransh 8793 
  def process_processReturn(self, seqid, iprot, oprot):
8794 
    args = processReturn_args()
8795 
    args.read(iprot)
8796 
    iprot.readMessageEnd()
8797 
    result = processReturn_result()
8798 
    try:
8799 
      self._handler.processReturn(args.returnOrderId)
8800 
    except TransactionServiceException, ex:
8801 
      result.ex = ex
8802 
    oprot.writeMessageBegin("processReturn", TMessageType.REPLY, seqid)
8803 
    result.write(oprot)
8804 
    oprot.writeMessageEnd()
8805 
    oprot.trans.flush()
8806 
 
3451 chandransh 8807 
  def process_updateWeight(self, seqid, iprot, oprot):
8808 
    args = updateWeight_args()
8809 
    args.read(iprot)
8810 
    iprot.readMessageEnd()
8811 
    result = updateWeight_result()
8812 
    try:
8813 
      result.success = self._handler.updateWeight(args.orderId, args.weight)
8814 
    except TransactionServiceException, ex:
8815 
      result.ex = ex
8816 
    oprot.writeMessageBegin("updateWeight", TMessageType.REPLY, seqid)
8817 
    result.write(oprot)
8818 
    oprot.writeMessageEnd()
8819 
    oprot.trans.flush()
2819 chandransh 8820 
 
3469 chandransh 8821 
  def process_changeItem(self, seqid, iprot, oprot):
8822 
    args = changeItem_args()
8823 
    args.read(iprot)
8824 
    iprot.readMessageEnd()
8825 
    result = changeItem_result()
8826 
    try:
8827 
      result.success = self._handler.changeItem(args.orderId, args.itemId)
8828 
    except TransactionServiceException, ex:
8829 
      result.ex = ex
8830 
    oprot.writeMessageBegin("changeItem", TMessageType.REPLY, seqid)
8831 
    result.write(oprot)
8832 
    oprot.writeMessageEnd()
8833 
    oprot.trans.flush()
3451 chandransh 8834 
 
3469 chandransh 8835 
  def process_shiftToWarehouse(self, seqid, iprot, oprot):
8836 
    args = shiftToWarehouse_args()
8837 
    args.read(iprot)
8838 
    iprot.readMessageEnd()
8839 
    result = shiftToWarehouse_result()
8840 
    try:
8841 
      result.success = self._handler.shiftToWarehouse(args.orderId, args.warehouseId)
8842 
    except TransactionServiceException, ex:
8843 
      result.ex = ex
8844 
    oprot.writeMessageBegin("shiftToWarehouse", TMessageType.REPLY, seqid)
8845 
    result.write(oprot)
8846 
    oprot.writeMessageEnd()
8847 
    oprot.trans.flush()
8848 
 
3553 chandransh 8849 
  def process_addDelayReason(self, seqid, iprot, oprot):
8850 
    args = addDelayReason_args()
8851 
    args.read(iprot)
8852 
    iprot.readMessageEnd()
8853 
    result = addDelayReason_result()
8854 
    try:
4647 rajveer 8855 
      result.success = self._handler.addDelayReason(args.orderId, args.delayReason, args.furtherDelay, args.delayReasonText)
3553 chandransh 8856 
    except TransactionServiceException, ex:
8857 
      result.ex = ex
8858 
    oprot.writeMessageBegin("addDelayReason", TMessageType.REPLY, seqid)
8859 
    result.write(oprot)
8860 
    oprot.writeMessageEnd()
8861 
    oprot.trans.flush()
3469 chandransh 8862 
 
3956 chandransh 8863 
  def process_reconcileCodCollection(self, seqid, iprot, oprot):
8864 
    args = reconcileCodCollection_args()
8865 
    args.read(iprot)
8866 
    iprot.readMessageEnd()
8867 
    result = reconcileCodCollection_result()
8868 
    try:
8869 
      result.success = self._handler.reconcileCodCollection(args.collectedAmountMap, args.xferBy, args.xferTxnId, args.xferDate)
8870 
    except TransactionServiceException, ex:
8871 
      result.ex = ex
8872 
    oprot.writeMessageBegin("reconcileCodCollection", TMessageType.REPLY, seqid)
8873 
    result.write(oprot)
8874 
    oprot.writeMessageEnd()
8875 
    oprot.trans.flush()
3553 chandransh 8876 
 
4008 mandeep.dh 8877 
  def process_getTransactionsRequiringExtraProcessing(self, seqid, iprot, oprot):
8878 
    args = getTransactionsRequiringExtraProcessing_args()
8879 
    args.read(iprot)
8880 
    iprot.readMessageEnd()
8881 
    result = getTransactionsRequiringExtraProcessing_result()
8882 
    result.success = self._handler.getTransactionsRequiringExtraProcessing(args.category)
8883 
    oprot.writeMessageBegin("getTransactionsRequiringExtraProcessing", TMessageType.REPLY, seqid)
8884 
    result.write(oprot)
8885 
    oprot.writeMessageEnd()
8886 
    oprot.trans.flush()
3956 chandransh 8887 
 
4008 mandeep.dh 8888 
  def process_markTransactionAsProcessed(self, seqid, iprot, oprot):
8889 
    args = markTransactionAsProcessed_args()
8890 
    args.read(iprot)
8891 
    iprot.readMessageEnd()
8892 
    result = markTransactionAsProcessed_result()
8893 
    self._handler.markTransactionAsProcessed(args.transactionId, args.category)
8894 
    oprot.writeMessageBegin("markTransactionAsProcessed", TMessageType.REPLY, seqid)
8895 
    result.write(oprot)
8896 
    oprot.writeMessageEnd()
8897 
    oprot.trans.flush()
8898 
 
4018 chandransh 8899 
  def process_getItemWiseRiskyOrdersCount(self, seqid, iprot, oprot):
8900 
    args = getItemWiseRiskyOrdersCount_args()
8901 
    args.read(iprot)
8902 
    iprot.readMessageEnd()
8903 
    result = getItemWiseRiskyOrdersCount_result()
8904 
    result.success = self._handler.getItemWiseRiskyOrdersCount()
8905 
    oprot.writeMessageBegin("getItemWiseRiskyOrdersCount", TMessageType.REPLY, seqid)
8906 
    result.write(oprot)
8907 
    oprot.writeMessageEnd()
8908 
    oprot.trans.flush()
4008 mandeep.dh 8909 
 
4295 varun.gupt 8910 
  def process_getOrdersForItemIds(self, seqid, iprot, oprot):
8911 
    args = getOrdersForItemIds_args()
8912 
    args.read(iprot)
8913 
    iprot.readMessageEnd()
8914 
    result = getOrdersForItemIds_result()
8915 
    result.success = self._handler.getOrdersForItemIds(args.itemIds)
8916 
    oprot.writeMessageBegin("getOrdersForItemIds", TMessageType.REPLY, seqid)
8917 
    result.write(oprot)
8918 
    oprot.writeMessageEnd()
8919 
    oprot.trans.flush()
8920 
 
4247 rajveer 8921 
  def process_markOrderCancellationRequestReceived(self, seqid, iprot, oprot):
8922 
    args = markOrderCancellationRequestReceived_args()
8923 
    args.read(iprot)
8924 
    iprot.readMessageEnd()
8925 
    result = markOrderCancellationRequestReceived_result()
8926 
    try:
8927 
      self._handler.markOrderCancellationRequestReceived(args.orderId)
8928 
    except TransactionServiceException, ex:
8929 
      result.ex = ex
8930 
    oprot.writeMessageBegin("markOrderCancellationRequestReceived", TMessageType.REPLY, seqid)
8931 
    result.write(oprot)
8932 
    oprot.writeMessageEnd()
8933 
    oprot.trans.flush()
4018 chandransh 8934 
 
4247 rajveer 8935 
  def process_markOrderCancellationRequestConfirmed(self, seqid, iprot, oprot):
8936 
    args = markOrderCancellationRequestConfirmed_args()
8937 
    args.read(iprot)
8938 
    iprot.readMessageEnd()
8939 
    result = markOrderCancellationRequestConfirmed_result()
8940 
    try:
8941 
      self._handler.markOrderCancellationRequestConfirmed(args.orderId)
8942 
    except TransactionServiceException, ex:
8943 
      result.ex = ex
8944 
    oprot.writeMessageBegin("markOrderCancellationRequestConfirmed", TMessageType.REPLY, seqid)
8945 
    result.write(oprot)
8946 
    oprot.writeMessageEnd()
8947 
    oprot.trans.flush()
8948 
 
8949 
  def process_markOrderCancellationRequestDenied(self, seqid, iprot, oprot):
8950 
    args = markOrderCancellationRequestDenied_args()
8951 
    args.read(iprot)
8952 
    iprot.readMessageEnd()
8953 
    result = markOrderCancellationRequestDenied_result()
8954 
    try:
8955 
      self._handler.markOrderCancellationRequestDenied(args.orderId)
8956 
    except TransactionServiceException, ex:
8957 
      result.ex = ex
8958 
    oprot.writeMessageBegin("markOrderCancellationRequestDenied", TMessageType.REPLY, seqid)
8959 
    result.write(oprot)
8960 
    oprot.writeMessageEnd()
8961 
    oprot.trans.flush()
8962 
 
4258 rajveer 8963 
  def process_markTransactionAsPaymentFlagRemoved(self, seqid, iprot, oprot):
8964 
    args = markTransactionAsPaymentFlagRemoved_args()
4247 rajveer 8965 
    args.read(iprot)
8966 
    iprot.readMessageEnd()
4258 rajveer 8967 
    result = markTransactionAsPaymentFlagRemoved_result()
4247 rajveer 8968 
    try:
4258 rajveer 8969 
      self._handler.markTransactionAsPaymentFlagRemoved(args.transactionId)
4247 rajveer 8970 
    except TransactionServiceException, ex:
8971 
      result.ex = ex
4258 rajveer 8972 
    oprot.writeMessageBegin("markTransactionAsPaymentFlagRemoved", TMessageType.REPLY, seqid)
4247 rajveer 8973 
    result.write(oprot)
8974 
    oprot.writeMessageEnd()
8975 
    oprot.trans.flush()
8976 
 
4259 anupam.sin 8977 
  def process_refundTransaction(self, seqid, iprot, oprot):
8978 
    args = refundTransaction_args()
8979 
    args.read(iprot)
8980 
    iprot.readMessageEnd()
8981 
    result = refundTransaction_result()
8982 
    try:
8983 
      self._handler.refundTransaction(args.transactionId, args.refundedBy, args.reason)
8984 
    except TransactionServiceException, ex:
8985 
      result.ex = ex
8986 
    oprot.writeMessageBegin("refundTransaction", TMessageType.REPLY, seqid)
8987 
    result.write(oprot)
8988 
    oprot.writeMessageEnd()
8989 
    oprot.trans.flush()
4247 rajveer 8990 
 
4324 mandeep.dh 8991 
  def process_updateShipmentAddress(self, seqid, iprot, oprot):
8992 
    args = updateShipmentAddress_args()
8993 
    args.read(iprot)
8994 
    iprot.readMessageEnd()
8995 
    result = updateShipmentAddress_result()
8996 
    try:
8997 
      self._handler.updateShipmentAddress(args.orderId, args.addressId)
8998 
    except TransactionServiceException, ex:
8999 
      result.ex = ex
9000 
    oprot.writeMessageBegin("updateShipmentAddress", TMessageType.REPLY, seqid)
9001 
    result.write(oprot)
9002 
    oprot.writeMessageEnd()
9003 
    oprot.trans.flush()
9004 
 
4285 rajveer 9005 
  def process_acceptOrdersForItemId(self, seqid, iprot, oprot):
9006 
    args = acceptOrdersForItemId_args()
9007 
    args.read(iprot)
9008 
    iprot.readMessageEnd()
9009 
    result = acceptOrdersForItemId_result()
9010 
    try:
9011 
      result.success = self._handler.acceptOrdersForItemId(args.itemId, args.inventory)
9012 
    except TransactionServiceException, ex:
9013 
      result.ex = ex
9014 
    oprot.writeMessageBegin("acceptOrdersForItemId", TMessageType.REPLY, seqid)
9015 
    result.write(oprot)
9016 
    oprot.writeMessageEnd()
9017 
    oprot.trans.flush()
4259 anupam.sin 9018 
 
4303 rajveer 9019 
  def process_markOrdersAsPORaised(self, seqid, iprot, oprot):
9020 
    args = markOrdersAsPORaised_args()
9021 
    args.read(iprot)
9022 
    iprot.readMessageEnd()
9023 
    result = markOrdersAsPORaised_result()
9024 
    try:
4369 rajveer 9025 
      self._handler.markOrdersAsPORaised(args.vendorId, args.itemId, args.quantity, args.estimate, args.isReminder)
4303 rajveer 9026 
    except TransactionServiceException, ex:
9027 
      result.ex = ex
9028 
    oprot.writeMessageBegin("markOrdersAsPORaised", TMessageType.REPLY, seqid)
9029 
    result.write(oprot)
9030 
    oprot.writeMessageEnd()
9031 
    oprot.trans.flush()
4285 rajveer 9032 
 
4303 rajveer 9033 
  def process_markOrdersAsReversalInitiated(self, seqid, iprot, oprot):
9034 
    args = markOrdersAsReversalInitiated_args()
9035 
    args.read(iprot)
9036 
    iprot.readMessageEnd()
9037 
    result = markOrdersAsReversalInitiated_result()
9038 
    try:
4369 rajveer 9039 
      self._handler.markOrdersAsReversalInitiated(args.vendorId, args.itemId, args.quantity, args.estimate, args.isReminder)
4303 rajveer 9040 
    except TransactionServiceException, ex:
9041 
      result.ex = ex
9042 
    oprot.writeMessageBegin("markOrdersAsReversalInitiated", TMessageType.REPLY, seqid)
9043 
    result.write(oprot)
9044 
    oprot.writeMessageEnd()
9045 
    oprot.trans.flush()
9046 
 
9047 
  def process_markOrdersAsNotAvailabke(self, seqid, iprot, oprot):
9048 
    args = markOrdersAsNotAvailabke_args()
9049 
    args.read(iprot)
9050 
    iprot.readMessageEnd()
9051 
    result = markOrdersAsNotAvailabke_result()
9052 
    try:
4369 rajveer 9053 
      self._handler.markOrdersAsNotAvailabke(args.vendorId, args.itemId, args.quantity, args.estimate, args.isReminder)
4303 rajveer 9054 
    except TransactionServiceException, ex:
9055 
      result.ex = ex
9056 
    oprot.writeMessageBegin("markOrdersAsNotAvailabke", TMessageType.REPLY, seqid)
9057 
    result.write(oprot)
9058 
    oprot.writeMessageEnd()
9059 
    oprot.trans.flush()
9060 
 
4369 rajveer 9061 
  def process_markOrdersAsTimeout(self, seqid, iprot, oprot):
9062 
    args = markOrdersAsTimeout_args()
9063 
    args.read(iprot)
9064 
    iprot.readMessageEnd()
9065 
    result = markOrdersAsTimeout_result()
9066 
    try:
9067 
      result.success = self._handler.markOrdersAsTimeout(args.vendorId)
9068 
    except TransactionServiceException, ex:
9069 
      result.ex = ex
9070 
    oprot.writeMessageBegin("markOrdersAsTimeout", TMessageType.REPLY, seqid)
9071 
    result.write(oprot)
9072 
    oprot.writeMessageEnd()
9073 
    oprot.trans.flush()
4303 rajveer 9074 
 
4662 rajveer 9075 
  def process_markOrderAsLostInTransit(self, seqid, iprot, oprot):
9076 
    args = markOrderAsLostInTransit_args()
9077 
    args.read(iprot)
9078 
    iprot.readMessageEnd()
9079 
    result = markOrderAsLostInTransit_result()
9080 
    try:
9081 
      result.success = self._handler.markOrderAsLostInTransit(args.orderId)
9082 
    except TransactionServiceException, ex:
9083 
      result.ex = ex
9084 
    oprot.writeMessageBegin("markOrderAsLostInTransit", TMessageType.REPLY, seqid)
9085 
    result.write(oprot)
9086 
    oprot.writeMessageEnd()
9087 
    oprot.trans.flush()
9088 
 
4386 anupam.sin 9089 
  def process_getOrderForAwb(self, seqid, iprot, oprot):
9090 
    args = getOrderForAwb_args()
9091 
    args.read(iprot)
9092 
    iprot.readMessageEnd()
9093 
    result = getOrderForAwb_result()
9094 
    try:
9095 
      result.success = self._handler.getOrderForAwb(args.awb)
9096 
    except TransactionServiceException, ex:
9097 
      result.ex = ex
9098 
    oprot.writeMessageBegin("getOrderForAwb", TMessageType.REPLY, seqid)
9099 
    result.write(oprot)
9100 
    oprot.writeMessageEnd()
9101 
    oprot.trans.flush()
4369 rajveer 9102 
 
4506 phani.kuma 9103 
  def process_getOrdersForProviderForStatus(self, seqid, iprot, oprot):
9104 
    args = getOrdersForProviderForStatus_args()
9105 
    args.read(iprot)
9106 
    iprot.readMessageEnd()
9107 
    result = getOrdersForProviderForStatus_result()
9108 
    try:
4910 phani.kuma 9109 
      result.success = self._handler.getOrdersForProviderForStatus(args.logistics_provider_id, args.order_status_list)
4506 phani.kuma 9110 
    except TransactionServiceException, ex:
9111 
      result.ex = ex
9112 
    oprot.writeMessageBegin("getOrdersForProviderForStatus", TMessageType.REPLY, seqid)
9113 
    result.write(oprot)
9114 
    oprot.writeMessageEnd()
9115 
    oprot.trans.flush()
4386 anupam.sin 9116 
 
4600 varun.gupt 9117 
  def process_getBilledOrdersForVendor(self, seqid, iprot, oprot):
9118 
    args = getBilledOrdersForVendor_args()
9119 
    args.read(iprot)
9120 
    iprot.readMessageEnd()
9121 
    result = getBilledOrdersForVendor_result()
9122 
    try:
9123 
      result.success = self._handler.getBilledOrdersForVendor(args.vendorId, args.billingDateFrom, args.billingDateTo)
9124 
    except TransactionServiceException, ex:
9125 
      result.ex = ex
9126 
    oprot.writeMessageBegin("getBilledOrdersForVendor", TMessageType.REPLY, seqid)
9127 
    result.write(oprot)
9128 
    oprot.writeMessageEnd()
9129 
    oprot.trans.flush()
4506 phani.kuma 9130 
 
4607 rajveer 9131 
  def process_getSlippedSippingDateOrders(self, seqid, iprot, oprot):
9132 
    args = getSlippedSippingDateOrders_args()
9133 
    args.read(iprot)
9134 
    iprot.readMessageEnd()
9135 
    result = getSlippedSippingDateOrders_result()
9136 
    try:
9137 
      result.success = self._handler.getSlippedSippingDateOrders()
9138 
    except TransactionServiceException, ex:
9139 
      result.ex = ex
9140 
    oprot.writeMessageBegin("getSlippedSippingDateOrders", TMessageType.REPLY, seqid)
9141 
    result.write(oprot)
9142 
    oprot.writeMessageEnd()
9143 
    oprot.trans.flush()
9144 
 
4709 rajveer 9145 
  def process_getCancelledOrders(self, seqid, iprot, oprot):
9146 
    args = getCancelledOrders_args()
9147 
    args.read(iprot)
9148 
    iprot.readMessageEnd()
9149 
    result = getCancelledOrders_result()
9150 
    try:
9151 
      result.success = self._handler.getCancelledOrders(args.cancelDateFrom, args.cancelDateTo)
9152 
    except TransactionServiceException, ex:
9153 
      result.ex = ex
9154 
    oprot.writeMessageBegin("getCancelledOrders", TMessageType.REPLY, seqid)
9155 
    result.write(oprot)
9156 
    oprot.writeMessageEnd()
9157 
    oprot.trans.flush()
9158 
 
4600 varun.gupt 9159 
  def process_saveBluedartSettlements(self, seqid, iprot, oprot):
9160 
    args = saveBluedartSettlements_args()
9161 
    args.read(iprot)
9162 
    iprot.readMessageEnd()
9163 
    result = saveBluedartSettlements_result()
9164 
    try:
9165 
      self._handler.saveBluedartSettlements(args.mapAWBAndAmount)
9166 
    except TransactionServiceException, ex:
9167 
      result.ex = ex
9168 
    oprot.writeMessageBegin("saveBluedartSettlements", TMessageType.REPLY, seqid)
9169 
    result.write(oprot)
9170 
    oprot.writeMessageEnd()
9171 
    oprot.trans.flush()
9172 
 
9173 
  def process_savePaymentSettlements(self, seqid, iprot, oprot):
9174 
    args = savePaymentSettlements_args()
9175 
    args.read(iprot)
9176 
    iprot.readMessageEnd()
9177 
    result = savePaymentSettlements_result()
9178 
    try:
4905 varun.gupt 9179 
      self._handler.savePaymentSettlements(args.settlementDate, args.paymentGatewayId, args.referenceId, args.serviceTax, args.otherCharges, args.netCollection)
4600 varun.gupt 9180 
    except TransactionServiceException, ex:
9181 
      result.ex = ex
9182 
    oprot.writeMessageBegin("savePaymentSettlements", TMessageType.REPLY, seqid)
9183 
    result.write(oprot)
9184 
    oprot.writeMessageEnd()
9185 
    oprot.trans.flush()
9186 
 
9187 
  def process_saveEBSSettlementSummary(self, seqid, iprot, oprot):
9188 
    args = saveEBSSettlementSummary_args()
9189 
    args.read(iprot)
9190 
    iprot.readMessageEnd()
9191 
    result = saveEBSSettlementSummary_result()
9192 
    try:
9193 
      self._handler.saveEBSSettlementSummary(args.settlementId, args.settlementDate, args.transactionDateFrom, args.transactionDateTo, args.amount)
9194 
    except TransactionServiceException, ex:
9195 
      result.ex = ex
9196 
    oprot.writeMessageBegin("saveEBSSettlementSummary", TMessageType.REPLY, seqid)
9197 
    result.write(oprot)
9198 
    oprot.writeMessageEnd()
9199 
    oprot.trans.flush()
9200 
 
5386 phani.kuma 9201 
  def process_getSettlementForPrepaid(self, seqid, iprot, oprot):
9202 
    args = getSettlementForPrepaid_args()
4600 varun.gupt 9203 
    args.read(iprot)
9204 
    iprot.readMessageEnd()
5386 phani.kuma 9205 
    result = getSettlementForPrepaid_result()
4600 varun.gupt 9206 
    try:
5386 phani.kuma 9207 
      result.success = self._handler.getSettlementForPrepaid(args.referenceId, args.isRefund)
4600 varun.gupt 9208 
    except TransactionServiceException, ex:
9209 
      result.ex = ex
5386 phani.kuma 9210 
    oprot.writeMessageBegin("getSettlementForPrepaid", TMessageType.REPLY, seqid)
4600 varun.gupt 9211 
    result.write(oprot)
9212 
    oprot.writeMessageEnd()
9213 
    oprot.trans.flush()
9214 
 
5386 phani.kuma 9215 
  def process_getSettlementForCod(self, seqid, iprot, oprot):
9216 
    args = getSettlementForCod_args()
9217 
    args.read(iprot)
9218 
    iprot.readMessageEnd()
9219 
    result = getSettlementForCod_result()
9220 
    try:
9221 
      result.success = self._handler.getSettlementForCod(args.orderId, args.isRefund)
9222 
    except TransactionServiceException, ex:
9223 
      result.ex = ex
9224 
    oprot.writeMessageBegin("getSettlementForCod", TMessageType.REPLY, seqid)
9225 
    result.write(oprot)
9226 
    oprot.writeMessageEnd()
9227 
    oprot.trans.flush()
9228 
 
4600 varun.gupt 9229 
  def process_getEBSSettlementSummaries(self, seqid, iprot, oprot):
9230 
    args = getEBSSettlementSummaries_args()
9231 
    args.read(iprot)
9232 
    iprot.readMessageEnd()
9233 
    result = getEBSSettlementSummaries_result()
9234 
    try:
9235 
      result.success = self._handler.getEBSSettlementSummaries()
9236 
    except TransactionServiceException, ex:
9237 
      result.ex = ex
9238 
    oprot.writeMessageBegin("getEBSSettlementSummaries", TMessageType.REPLY, seqid)
9239 
    result.write(oprot)
9240 
    oprot.writeMessageEnd()
9241 
    oprot.trans.flush()
9242 
 
9243 
  def process_markEBSSettlementUploaded(self, seqid, iprot, oprot):
9244 
    args = markEBSSettlementUploaded_args()
9245 
    args.read(iprot)
9246 
    iprot.readMessageEnd()
9247 
    result = markEBSSettlementUploaded_result()
9248 
    try:
9249 
      self._handler.markEBSSettlementUploaded(args.settlementId)
9250 
    except TransactionServiceException, ex:
9251 
      result.ex = ex
9252 
    oprot.writeMessageBegin("markEBSSettlementUploaded", TMessageType.REPLY, seqid)
9253 
    result.write(oprot)
9254 
    oprot.writeMessageEnd()
9255 
    oprot.trans.flush()
9256 
 
9257 
  def process_getEBSSettlementDate(self, seqid, iprot, oprot):
9258 
    args = getEBSSettlementDate_args()
9259 
    args.read(iprot)
9260 
    iprot.readMessageEnd()
9261 
    result = getEBSSettlementDate_result()
9262 
    try:
9263 
      result.success = self._handler.getEBSSettlementDate(args.settlementId)
9264 
    except TransactionServiceException, ex:
9265 
      result.ex = ex
9266 
    oprot.writeMessageBegin("getEBSSettlementDate", TMessageType.REPLY, seqid)
9267 
    result.write(oprot)
9268 
    oprot.writeMessageEnd()
9269 
    oprot.trans.flush()
9270 
 
4715 varun.gupt 9271 
  def process_getSettlementsByDate(self, seqid, iprot, oprot):
9272 
    args = getSettlementsByDate_args()
9273 
    args.read(iprot)
9274 
    iprot.readMessageEnd()
9275 
    result = getSettlementsByDate_result()
9276 
    try:
9277 
      result.success = self._handler.getSettlementsByDate(args.settlementDateFrom, args.settlementDateTo, args.isRefund)
9278 
    except TransactionServiceException, ex:
9279 
      result.ex = ex
9280 
    oprot.writeMessageBegin("getSettlementsByDate", TMessageType.REPLY, seqid)
9281 
    result.write(oprot)
9282 
    oprot.writeMessageEnd()
9283 
    oprot.trans.flush()
4600 varun.gupt 9284 
 
4715 varun.gupt 9285 
  def process_getReshippedOrderIds(self, seqid, iprot, oprot):
9286 
    args = getReshippedOrderIds_args()
9287 
    args.read(iprot)
9288 
    iprot.readMessageEnd()
9289 
    result = getReshippedOrderIds_result()
9290 
    try:
9291 
      result.success = self._handler.getReshippedOrderIds(args.orderIds)
9292 
    except TransactionServiceException, ex:
9293 
      result.ex = ex
9294 
    oprot.writeMessageBegin("getReshippedOrderIds", TMessageType.REPLY, seqid)
9295 
    result.write(oprot)
9296 
    oprot.writeMessageEnd()
9297 
    oprot.trans.flush()
9298 
 
5481 phani.kuma 9299 
  def process_getBilledOrders(self, seqid, iprot, oprot):
9300 
    args = getBilledOrders_args()
4875 varun.gupt 9301 
    args.read(iprot)
9302 
    iprot.readMessageEnd()
5481 phani.kuma 9303 
    result = getBilledOrders_result()
4875 varun.gupt 9304 
    try:
5481 phani.kuma 9305 
      result.success = self._handler.getBilledOrders(args.vendorId, args.onlyVendorNotPaid, args.billingDateFrom, args.billingDateTo)
4875 varun.gupt 9306 
    except TransactionServiceException, ex:
9307 
      result.ex = ex
5481 phani.kuma 9308 
    oprot.writeMessageBegin("getBilledOrders", TMessageType.REPLY, seqid)
4875 varun.gupt 9309 
    result.write(oprot)
9310 
    oprot.writeMessageEnd()
9311 
    oprot.trans.flush()
4757 mandeep.dh 9312 
 
5031 varun.gupt 9313 
  def process_getStatusDistributionOfOrders(self, seqid, iprot, oprot):
9314 
    args = getStatusDistributionOfOrders_args()
9315 
    args.read(iprot)
9316 
    iprot.readMessageEnd()
9317 
    result = getStatusDistributionOfOrders_result()
9318 
    try:
9319 
      result.success = self._handler.getStatusDistributionOfOrders(args.startDate, args.endDate)
9320 
    except TransactionServiceException, ex:
9321 
      result.ex = ex
9322 
    oprot.writeMessageBegin("getStatusDistributionOfOrders", TMessageType.REPLY, seqid)
9323 
    result.write(oprot)
9324 
    oprot.writeMessageEnd()
9325 
    oprot.trans.flush()
4875 varun.gupt 9326 
 
5067 varun.gupt 9327 
  def process_getOrderIdsForStatus(self, seqid, iprot, oprot):
9328 
    args = getOrderIdsForStatus_args()
9329 
    args.read(iprot)
9330 
    iprot.readMessageEnd()
9331 
    result = getOrderIdsForStatus_result()
9332 
    try:
9333 
      result.success = self._handler.getOrderIdsForStatus(args.status, args.startDatetime, args.endDatetime)
9334 
    except TransactionServiceException, ex:
9335 
      result.ex = ex
9336 
    oprot.writeMessageBegin("getOrderIdsForStatus", TMessageType.REPLY, seqid)
9337 
    result.write(oprot)
9338 
    oprot.writeMessageEnd()
9339 
    oprot.trans.flush()
5031 varun.gupt 9340 
 
5348 anupam.sin 9341 
  def process_updateCODAgent(self, seqid, iprot, oprot):
9342 
    args = updateCODAgent_args()
9343 
    args.read(iprot)
9344 
    iprot.readMessageEnd()
9345 
    result = updateCODAgent_result()
9346 
    try:
9347 
      self._handler.updateCODAgent(args.agent, args.orderId)
9348 
    except TransactionServiceException, ex:
9349 
      result.ex = ex
9350 
    oprot.writeMessageBegin("updateCODAgent", TMessageType.REPLY, seqid)
9351 
    result.write(oprot)
9352 
    oprot.writeMessageEnd()
9353 
    oprot.trans.flush()
9354 
 
5099 varun.gupt 9355 
  def process_updateOrderAsPaidToVendor(self, seqid, iprot, oprot):
9356 
    args = updateOrderAsPaidToVendor_args()
9357 
    args.read(iprot)
9358 
    iprot.readMessageEnd()
9359 
    result = updateOrderAsPaidToVendor_result()
9360 
    try:
9361 
      self._handler.updateOrderAsPaidToVendor(args.orderId)
9362 
    except TransactionServiceException, ex:
9363 
      result.ex = ex
9364 
    oprot.writeMessageBegin("updateOrderAsPaidToVendor", TMessageType.REPLY, seqid)
9365 
    result.write(oprot)
9366 
    oprot.writeMessageEnd()
9367 
    oprot.trans.flush()
5067 varun.gupt 9368 
 
5386 phani.kuma 9369 
  def process_updateOrderOnlyAsPaidToVendor(self, seqid, iprot, oprot):
9370 
    args = updateOrderOnlyAsPaidToVendor_args()
9371 
    args.read(iprot)
9372 
    iprot.readMessageEnd()
9373 
    result = updateOrderOnlyAsPaidToVendor_result()
9374 
    try:
9375 
      self._handler.updateOrderOnlyAsPaidToVendor(args.orderId)
9376 
    except TransactionServiceException, ex:
9377 
      result.ex = ex
9378 
    oprot.writeMessageBegin("updateOrderOnlyAsPaidToVendor", TMessageType.REPLY, seqid)
9379 
    result.write(oprot)
9380 
    oprot.writeMessageEnd()
9381 
    oprot.trans.flush()
9382 
 
5208 varun.gupt 9383 
  def process_getRefundedOrdersMarkedPaid(self, seqid, iprot, oprot):
9384 
    args = getRefundedOrdersMarkedPaid_args()
9385 
    args.read(iprot)
9386 
    iprot.readMessageEnd()
9387 
    result = getRefundedOrdersMarkedPaid_result()
9388 
    try:
9389 
      result.success = self._handler.getRefundedOrdersMarkedPaid()
9390 
    except TransactionServiceException, ex:
9391 
      result.ex = ex
9392 
    oprot.writeMessageBegin("getRefundedOrdersMarkedPaid", TMessageType.REPLY, seqid)
9393 
    result.write(oprot)
9394 
    oprot.writeMessageEnd()
9395 
    oprot.trans.flush()
5099 varun.gupt 9396 
 
5447 anupam.sin 9397 
  def process_getAllVerificationAgents(self, seqid, iprot, oprot):
9398 
    args = getAllVerificationAgents_args()
9399 
    args.read(iprot)
9400 
    iprot.readMessageEnd()
9401 
    result = getAllVerificationAgents_result()
9402 
    result.success = self._handler.getAllVerificationAgents(args.minOrderId, args.maxOrderId)
9403 
    oprot.writeMessageBegin("getAllVerificationAgents", TMessageType.REPLY, seqid)
9404 
    result.write(oprot)
9405 
    oprot.writeMessageEnd()
9406 
    oprot.trans.flush()
5208 varun.gupt 9407 
 
5527 anupam.sin 9408 
  def process_getAllAttributesForOrderId(self, seqid, iprot, oprot):
9409 
    args = getAllAttributesForOrderId_args()
9410 
    args.read(iprot)
9411 
    iprot.readMessageEnd()
9412 
    result = getAllAttributesForOrderId_result()
9413 
    result.success = self._handler.getAllAttributesForOrderId(args.orderId)
9414 
    oprot.writeMessageBegin("getAllAttributesForOrderId", TMessageType.REPLY, seqid)
9415 
    result.write(oprot)
9416 
    oprot.writeMessageEnd()
9417 
    oprot.trans.flush()
5447 anupam.sin 9418 
 
5676 rajveer 9419 
  def process_setOrderAttributes(self, seqid, iprot, oprot):
9420 
    args = setOrderAttributes_args()
9421 
    args.read(iprot)
9422 
    iprot.readMessageEnd()
9423 
    result = setOrderAttributes_result()
9424 
    self._handler.setOrderAttributes(args.orderId, args.attributes)
9425 
    oprot.writeMessageBegin("setOrderAttributes", TMessageType.REPLY, seqid)
9426 
    result.write(oprot)
9427 
    oprot.writeMessageEnd()
9428 
    oprot.trans.flush()
9429 
 
5527 anupam.sin 9430 
  def process_setOrderAttributeForTransaction(self, seqid, iprot, oprot):
9431 
    args = setOrderAttributeForTransaction_args()
9432 
    args.read(iprot)
9433 
    iprot.readMessageEnd()
9434 
    result = setOrderAttributeForTransaction_result()
9435 
    self._handler.setOrderAttributeForTransaction(args.transactionId, args.attribute)
9436 
    oprot.writeMessageBegin("setOrderAttributeForTransaction", TMessageType.REPLY, seqid)
9437 
    result.write(oprot)
9438 
    oprot.writeMessageEnd()
9439 
    oprot.trans.flush()
9440 
 
5553 rajveer 9441 
  def process_getReceivePendingOrders(self, seqid, iprot, oprot):
9442 
    args = getReceivePendingOrders_args()
9443 
    args.read(iprot)
9444 
    iprot.readMessageEnd()
9445 
    result = getReceivePendingOrders_result()
9446 
    result.success = self._handler.getReceivePendingOrders(args.storeId)
9447 
    oprot.writeMessageBegin("getReceivePendingOrders", TMessageType.REPLY, seqid)
9448 
    result.write(oprot)
9449 
    oprot.writeMessageEnd()
9450 
    oprot.trans.flush()
5527 anupam.sin 9451 
 
5553 rajveer 9452 
  def process_getReceivedAtStoreOrders(self, seqid, iprot, oprot):
9453 
    args = getReceivedAtStoreOrders_args()
9454 
    args.read(iprot)
9455 
    iprot.readMessageEnd()
9456 
    result = getReceivedAtStoreOrders_result()
9457 
    result.success = self._handler.getReceivedAtStoreOrders(args.storeId)
9458 
    oprot.writeMessageBegin("getReceivedAtStoreOrders", TMessageType.REPLY, seqid)
9459 
    result.write(oprot)
9460 
    oprot.writeMessageEnd()
9461 
    oprot.trans.flush()
9462 
 
5713 rajveer 9463 
  def process_getOrdersCollectionAtStore(self, seqid, iprot, oprot):
9464 
    args = getOrdersCollectionAtStore_args()
9465 
    args.read(iprot)
9466 
    iprot.readMessageEnd()
9467 
    result = getOrdersCollectionAtStore_result()
9468 
    result.success = self._handler.getOrdersCollectionAtStore(args.storeId, args.fromDate, args.toDate, args.onlyCod)
9469 
    oprot.writeMessageBegin("getOrdersCollectionAtStore", TMessageType.REPLY, seqid)
9470 
    result.write(oprot)
9471 
    oprot.writeMessageEnd()
9472 
    oprot.trans.flush()
9473 
 
5833 rajveer 9474 
  def process_getOrderAttributeValue(self, seqid, iprot, oprot):
9475 
    args = getOrderAttributeValue_args()
9476 
    args.read(iprot)
9477 
    iprot.readMessageEnd()
9478 
    result = getOrderAttributeValue_result()
9479 
    result.success = self._handler.getOrderAttributeValue(args.orderId, args.attributeName)
9480 
    oprot.writeMessageBegin("getOrderAttributeValue", TMessageType.REPLY, seqid)
9481 
    result.write(oprot)
9482 
    oprot.writeMessageEnd()
9483 
    oprot.trans.flush()
9484 
 
6019 rajveer 9485 
  def process_changeJacketNumber(self, seqid, iprot, oprot):
9486 
    args = changeJacketNumber_args()
9487 
    args.read(iprot)
9488 
    iprot.readMessageEnd()
9489 
    result = changeJacketNumber_result()
9490 
    result.success = self._handler.changeJacketNumber(args.orderId, args.jacketNumber)
9491 
    oprot.writeMessageBegin("changeJacketNumber", TMessageType.REPLY, seqid)
9492 
    result.write(oprot)
9493 
    oprot.writeMessageEnd()
9494 
    oprot.trans.flush()
9495 
 
9496 
  def process_markOrderAsRtoInTransit(self, seqid, iprot, oprot):
9497 
    args = markOrderAsRtoInTransit_args()
9498 
    args.read(iprot)
9499 
    iprot.readMessageEnd()
9500 
    result = markOrderAsRtoInTransit_result()
9501 
    result.success = self._handler.markOrderAsRtoInTransit(args.orderId)
9502 
    oprot.writeMessageBegin("markOrderAsRtoInTransit", TMessageType.REPLY, seqid)
9503 
    result.write(oprot)
9504 
    oprot.writeMessageEnd()
9505 
    oprot.trans.flush()
9506 
 
5593 mandeep.dh 9507 
  def process_acceptOrderForItem(self, seqid, iprot, oprot):
9508 
    args = acceptOrderForItem_args()
9509 
    args.read(iprot)
9510 
    iprot.readMessageEnd()
9511 
    result = acceptOrderForItem_result()
9512 
    self._handler.acceptOrderForItem(args.itemId, args.quantity, args.fulfilmentWarehouseId, args.billingWarehouseId)
9513 
    oprot.writeMessageBegin("acceptOrderForItem", TMessageType.REPLY, seqid)
9514 
    result.write(oprot)
9515 
    oprot.writeMessageEnd()
9516 
    oprot.trans.flush()
5553 rajveer 9517 
 
6000 mandeep.dh 9518 
  def process_createRechargeOrder(self, seqid, iprot, oprot):
9519 
    args = createRechargeOrder_args()
9520 
    args.read(iprot)
9521 
    iprot.readMessageEnd()
9522 
    result = createRechargeOrder_result()
9523 
    try:
9524 
      result.success = self._handler.createRechargeOrder(args.rechargeOrder)
9525 
    except TransactionServiceException, ex:
9526 
      result.ex = ex
9527 
    oprot.writeMessageBegin("createRechargeOrder", TMessageType.REPLY, seqid)
9528 
    result.write(oprot)
9529 
    oprot.writeMessageEnd()
9530 
    oprot.trans.flush()
5593 mandeep.dh 9531 
 
6031 rajveer 9532 
  def process_getRechargeOrder(self, seqid, iprot, oprot):
9533 
    args = getRechargeOrder_args()
9534 
    args.read(iprot)
9535 
    iprot.readMessageEnd()
9536 
    result = getRechargeOrder_result()
9537 
    try:
9538 
      result.success = self._handler.getRechargeOrder(args.rechargeRrderId)
9539 
    except TransactionServiceException, ex:
9540 
      result.ex = ex
9541 
    oprot.writeMessageBegin("getRechargeOrder", TMessageType.REPLY, seqid)
9542 
    result.write(oprot)
9543 
    oprot.writeMessageEnd()
9544 
    oprot.trans.flush()
9545 
 
9546 
  def process_getRechargeOrders(self, seqid, iprot, oprot):
9547 
    args = getRechargeOrders_args()
9548 
    args.read(iprot)
9549 
    iprot.readMessageEnd()
9550 
    result = getRechargeOrders_result()
9551 
    result.success = self._handler.getRechargeOrders(args.userId)
9552 
    oprot.writeMessageBegin("getRechargeOrders", TMessageType.REPLY, seqid)
9553 
    result.write(oprot)
9554 
    oprot.writeMessageEnd()
9555 
    oprot.trans.flush()
9556 
 
6000 mandeep.dh 9557 
  def process_updateRechargeOrderStatus(self, seqid, iprot, oprot):
9558 
    args = updateRechargeOrderStatus_args()
9559 
    args.read(iprot)
9560 
    iprot.readMessageEnd()
9561 
    result = updateRechargeOrderStatus_result()
9562 
    try:
6031 rajveer 9563 
      result.success = self._handler.updateRechargeOrderStatus(args.rechargeOrderId, args.rechargeOrderStatus)
6000 mandeep.dh 9564 
    except TransactionServiceException, ex:
9565 
      result.ex = ex
9566 
    oprot.writeMessageBegin("updateRechargeOrderStatus", TMessageType.REPLY, seqid)
9567 
    result.write(oprot)
9568 
    oprot.writeMessageEnd()
9569 
    oprot.trans.flush()
9570 
 
9571 
  def process_activateRechargeTxn(self, seqid, iprot, oprot):
9572 
    args = activateRechargeTxn_args()
9573 
    args.read(iprot)
9574 
    iprot.readMessageEnd()
9575 
    result = activateRechargeTxn_result()
9576 
    try:
6031 rajveer 9577 
      result.success = self._handler.activateRechargeTxn(args.rechargeOrderId)
6000 mandeep.dh 9578 
    except TransactionServiceException, ex:
9579 
      result.ex = ex
9580 
    oprot.writeMessageBegin("activateRechargeTxn", TMessageType.REPLY, seqid)
9581 
    result.write(oprot)
9582 
    oprot.writeMessageEnd()
9583 
    oprot.trans.flush()
9584 
 
6031 rajveer 9585 
  def process_getUserWallet(self, seqid, iprot, oprot):
9586 
    args = getUserWallet_args()
6000 mandeep.dh 9587 
    args.read(iprot)
9588 
    iprot.readMessageEnd()
6031 rajveer 9589 
    result = getUserWallet_result()
9590 
    result.success = self._handler.getUserWallet(args.userId)
9591 
    oprot.writeMessageBegin("getUserWallet", TMessageType.REPLY, seqid)
6000 mandeep.dh 9592 
    result.write(oprot)
9593 
    oprot.writeMessageEnd()
9594 
    oprot.trans.flush()
9595 
 
6031 rajveer 9596 
  def process_getUserWalletHistory(self, seqid, iprot, oprot):
9597 
    args = getUserWalletHistory_args()
6000 mandeep.dh 9598 
    args.read(iprot)
9599 
    iprot.readMessageEnd()
6031 rajveer 9600 
    result = getUserWalletHistory_result()
9601 
    result.success = self._handler.getUserWalletHistory(args.userId)
9602 
    oprot.writeMessageBegin("getUserWalletHistory", TMessageType.REPLY, seqid)
6000 mandeep.dh 9603 
    result.write(oprot)
9604 
    oprot.writeMessageEnd()
9605 
    oprot.trans.flush()
9606 
 
6050 anupam.sin 9607 
  def process_getRechargeOrdersForTransaction(self, seqid, iprot, oprot):
9608 
    args = getRechargeOrdersForTransaction_args()
9609 
    args.read(iprot)
9610 
    iprot.readMessageEnd()
9611 
    result = getRechargeOrdersForTransaction_result()
9612 
    try:
9613 
      result.success = self._handler.getRechargeOrdersForTransaction(args.txnId)
9614 
    except TransactionServiceException, ex:
9615 
      result.ex = ex
9616 
    oprot.writeMessageBegin("getRechargeOrdersForTransaction", TMessageType.REPLY, seqid)
9617 
    result.write(oprot)
9618 
    oprot.writeMessageEnd()
9619 
    oprot.trans.flush()
9620 
 
6048 rajveer 9621 
  def process_getServiceProviders(self, seqid, iprot, oprot):
9622 
    args = getServiceProviders_args()
9623 
    args.read(iprot)
9624 
    iprot.readMessageEnd()
9625 
    result = getServiceProviders_result()
6206 rajveer 9626 
    result.success = self._handler.getServiceProviders(args.rechargeType, args.onlyActive)
6048 rajveer 9627 
    oprot.writeMessageBegin("getServiceProviders", TMessageType.REPLY, seqid)
9628 
    result.write(oprot)
9629 
    oprot.writeMessageEnd()
9630 
    oprot.trans.flush()
6000 mandeep.dh 9631 
 
6048 rajveer 9632 
  def process_getServiceProviderForDevice(self, seqid, iprot, oprot):
9633 
    args = getServiceProviderForDevice_args()
9634 
    args.read(iprot)
9635 
    iprot.readMessageEnd()
9636 
    result = getServiceProviderForDevice_result()
6049 rajveer 9637 
    result.success = self._handler.getServiceProviderForDevice(args.rechargeType, args.deviceNumber)
6048 rajveer 9638 
    oprot.writeMessageBegin("getServiceProviderForDevice", TMessageType.REPLY, seqid)
9639 
    result.write(oprot)
9640 
    oprot.writeMessageEnd()
9641 
    oprot.trans.flush()
9642 
 
6269 rajveer 9643 
  def process_validateRecharge(self, seqid, iprot, oprot):
9644 
    args = validateRecharge_args()
9645 
    args.read(iprot)
9646 
    iprot.readMessageEnd()
9647 
    result = validateRecharge_result()
6591 anupam.sin 9648 
    result.success = self._handler.validateRecharge(args.rechargeType, args.deviceNumber, args.userSelectedProviderId, args.clientAddress)
6269 rajveer 9649 
    oprot.writeMessageBegin("validateRecharge", TMessageType.REPLY, seqid)
9650 
    result.write(oprot)
9651 
    oprot.writeMessageEnd()
9652 
    oprot.trans.flush()
9653 
 
6094 rajveer 9654 
  def process_getRechargeOrdersForDevice(self, seqid, iprot, oprot):
9655 
    args = getRechargeOrdersForDevice_args()
9656 
    args.read(iprot)
9657 
    iprot.readMessageEnd()
9658 
    result = getRechargeOrdersForDevice_result()
9659 
    result.success = self._handler.getRechargeOrdersForDevice(args.deviceNumber)
9660 
    oprot.writeMessageBegin("getRechargeOrdersForDevice", TMessageType.REPLY, seqid)
9661 
    result.write(oprot)
9662 
    oprot.writeMessageEnd()
9663 
    oprot.trans.flush()
6048 rajveer 9664 
 
6094 rajveer 9665 
  def process_addAmountToWallet(self, seqid, iprot, oprot):
9666 
    args = addAmountToWallet_args()
9667 
    args.read(iprot)
9668 
    iprot.readMessageEnd()
9669 
    result = addAmountToWallet_result()
9670 
    self._handler.addAmountToWallet(args.userId, args.orderId, args.amount)
9671 
    oprot.writeMessageBegin("addAmountToWallet", TMessageType.REPLY, seqid)
9672 
    result.write(oprot)
9673 
    oprot.writeMessageEnd()
9674 
    oprot.trans.flush()
9675 
 
6188 rajveer 9676 
  def process_getRechargeStatistics(self, seqid, iprot, oprot):
9677 
    args = getRechargeStatistics_args()
9678 
    args.read(iprot)
9679 
    iprot.readMessageEnd()
9680 
    result = getRechargeStatistics_result()
9681 
    result.success = self._handler.getRechargeStatistics()
9682 
    oprot.writeMessageBegin("getRechargeStatistics", TMessageType.REPLY, seqid)
9683 
    result.write(oprot)
9684 
    oprot.writeMessageEnd()
9685 
    oprot.trans.flush()
9686 
 
6154 rajveer 9687 
  def process_getRechargeOrdersForStatus(self, seqid, iprot, oprot):
9688 
    args = getRechargeOrdersForStatus_args()
9689 
    args.read(iprot)
9690 
    iprot.readMessageEnd()
9691 
    result = getRechargeOrdersForStatus_result()
9692 
    result.success = self._handler.getRechargeOrdersForStatus(args.status)
9693 
    oprot.writeMessageBegin("getRechargeOrdersForStatus", TMessageType.REPLY, seqid)
9694 
    result.write(oprot)
9695 
    oprot.writeMessageEnd()
9696 
    oprot.trans.flush()
6094 rajveer 9697 
 
6159 rajveer 9698 
  def process_getPlansForOperator(self, seqid, iprot, oprot):
9699 
    args = getPlansForOperator_args()
9700 
    args.read(iprot)
9701 
    iprot.readMessageEnd()
9702 
    result = getPlansForOperator_result()
9703 
    result.success = self._handler.getPlansForOperator(args.operatorId)
9704 
    oprot.writeMessageBegin("getPlansForOperator", TMessageType.REPLY, seqid)
9705 
    result.write(oprot)
9706 
    oprot.writeMessageEnd()
9707 
    oprot.trans.flush()
6154 rajveer 9708 
 
6289 anupam.sin 9709 
  def process_getRechargeDenominations(self, seqid, iprot, oprot):
9710 
    args = getRechargeDenominations_args()
9711 
    args.read(iprot)
9712 
    iprot.readMessageEnd()
9713 
    result = getRechargeDenominations_result()
9714 
    try:
6307 anupam.sin 9715 
      result.success = self._handler.getRechargeDenominations(args.operatorId, args.circleCode, args.denominationType)
6289 anupam.sin 9716 
    except TransactionServiceException, ex:
9717 
      result.ex = ex
9718 
    oprot.writeMessageBegin("getRechargeDenominations", TMessageType.REPLY, seqid)
9719 
    result.write(oprot)
9720 
    oprot.writeMessageEnd()
9721 
    oprot.trans.flush()
6159 rajveer 9722 
 
6371 rajveer 9723 
  def process_updateAvailabilityStatus(self, seqid, iprot, oprot):
9724 
    args = updateAvailabilityStatus_args()
9725 
    args.read(iprot)
9726 
    iprot.readMessageEnd()
9727 
    result = updateAvailabilityStatus_result()
9728 
    self._handler.updateAvailabilityStatus(args.operatorId, args.circleId, args.isAvailable)
9729 
    oprot.writeMessageBegin("updateAvailabilityStatus", TMessageType.REPLY, seqid)
9730 
    result.write(oprot)
9731 
    oprot.writeMessageEnd()
9732 
    oprot.trans.flush()
6289 anupam.sin 9733 
 
6389 rajveer 9734 
  def process_getAvailableEmiSchemes(self, seqid, iprot, oprot):
9735 
    args = getAvailableEmiSchemes_args()
9736 
    args.read(iprot)
9737 
    iprot.readMessageEnd()
9738 
    result = getAvailableEmiSchemes_result()
9739 
    result.success = self._handler.getAvailableEmiSchemes()
9740 
    oprot.writeMessageBegin("getAvailableEmiSchemes", TMessageType.REPLY, seqid)
9741 
    result.write(oprot)
9742 
    oprot.writeMessageEnd()
9743 
    oprot.trans.flush()
6371 rajveer 9744 
 
6389 rajveer 9745 
  def process_getMiscCharges(self, seqid, iprot, oprot):
9746 
    args = getMiscCharges_args()
9747 
    args.read(iprot)
9748 
    iprot.readMessageEnd()
9749 
    result = getMiscCharges_result()
9750 
    result.success = self._handler.getMiscCharges(args.transactionId)
9751 
    oprot.writeMessageBegin("getMiscCharges", TMessageType.REPLY, seqid)
9752 
    result.write(oprot)
9753 
    oprot.writeMessageEnd()
9754 
    oprot.trans.flush()
9755 
 
6507 anupam.sin 9756 
  def process_refundRechargeOrder(self, seqid, iprot, oprot):
9757 
    args = refundRechargeOrder_args()
9758 
    args.read(iprot)
9759 
    iprot.readMessageEnd()
9760 
    result = refundRechargeOrder_result()
9761 
    try:
9762 
      result.success = self._handler.refundRechargeOrder(args.rechargeOrderId)
9763 
    except TransactionServiceException, ex:
9764 
      result.ex = ex
9765 
    oprot.writeMessageBegin("refundRechargeOrder", TMessageType.REPLY, seqid)
9766 
    result.write(oprot)
9767 
    oprot.writeMessageEnd()
9768 
    oprot.trans.flush()
6389 rajveer 9769 
 
6821 amar.kumar 9770 
  def process_getPhysicalOrders(self, seqid, iprot, oprot):
9771 
    args = getPhysicalOrders_args()
9772 
    args.read(iprot)
9773 
    iprot.readMessageEnd()
9774 
    result = getPhysicalOrders_result()
9775 
    result.success = self._handler.getPhysicalOrders(args.fromDate, args.toDate)
9776 
    oprot.writeMessageBegin("getPhysicalOrders", TMessageType.REPLY, seqid)
9777 
    result.write(oprot)
9778 
    oprot.writeMessageEnd()
9779 
    oprot.trans.flush()
6507 anupam.sin 9780 
 
6906 rajveer 9781 
  def process_getDocument(self, seqid, iprot, oprot):
9782 
    args = getDocument_args()
9783 
    args.read(iprot)
9784 
    iprot.readMessageEnd()
9785 
    result = getDocument_result()
9786 
    result.success = self._handler.getDocument(args.docType, args.docSource)
9787 
    oprot.writeMessageBegin("getDocument", TMessageType.REPLY, seqid)
9788 
    result.write(oprot)
9789 
    oprot.writeMessageEnd()
9790 
    oprot.trans.flush()
6821 amar.kumar 9791 
 
6985 anupam.sin 9792 
  def process_changeShippingAddress(self, seqid, iprot, oprot):
9793 
    args = changeShippingAddress_args()
9794 
    args.read(iprot)
9795 
    iprot.readMessageEnd()
9796 
    result = changeShippingAddress_result()
9797 
    result.success = self._handler.changeShippingAddress(args.orderId, args.line1, args.line2, args.city, args.state, args.pin)
9798 
    oprot.writeMessageBegin("changeShippingAddress", TMessageType.REPLY, seqid)
9799 
    result.write(oprot)
9800 
    oprot.writeMessageEnd()
9801 
    oprot.trans.flush()
6906 rajveer 9802 
 
6988 rajveer 9803 
  def process_retrieveInvoice(self, seqid, iprot, oprot):
9804 
    args = retrieveInvoice_args()
9805 
    args.read(iprot)
9806 
    iprot.readMessageEnd()
9807 
    result = retrieveInvoice_result()
7075 rajveer 9808 
    result.success = self._handler.retrieveInvoice(args.orderId, args.userId)
6988 rajveer 9809 
    oprot.writeMessageBegin("retrieveInvoice", TMessageType.REPLY, seqid)
9810 
    result.write(oprot)
9811 
    oprot.writeMessageEnd()
9812 
    oprot.trans.flush()
6985 anupam.sin 9813 
 
7026 rajveer 9814 
  def process_receiveUpdatesForRedExpress(self, seqid, iprot, oprot):
9815 
    args = receiveUpdatesForRedExpress_args()
9816 
    args.read(iprot)
9817 
    iprot.readMessageEnd()
9818 
    result = receiveUpdatesForRedExpress_result()
9819 
    result.success = self._handler.receiveUpdatesForRedExpress(args.awbNumber)
9820 
    oprot.writeMessageBegin("receiveUpdatesForRedExpress", TMessageType.REPLY, seqid)
9821 
    result.write(oprot)
9822 
    oprot.writeMessageEnd()
9823 
    oprot.trans.flush()
6988 rajveer 9824 
 
7073 anupam.sin 9825 
  def process_createRechargeTransaction(self, seqid, iprot, oprot):
9826 
    args = createRechargeTransaction_args()
9827 
    args.read(iprot)
9828 
    iprot.readMessageEnd()
9829 
    result = createRechargeTransaction_result()
9830 
    result.success = self._handler.createRechargeTransaction(args.thriftRechargeTransaction)
9831 
    oprot.writeMessageBegin("createRechargeTransaction", TMessageType.REPLY, seqid)
9832 
    result.write(oprot)
9833 
    oprot.writeMessageEnd()
9834 
    oprot.trans.flush()
7026 rajveer 9835 
 
7085 rajveer 9836 
  def process_getRechargeTransactions(self, seqid, iprot, oprot):
9837 
    args = getRechargeTransactions_args()
9838 
    args.read(iprot)
9839 
    iprot.readMessageEnd()
9840 
    result = getRechargeTransactions_result()
9841 
    result.success = self._handler.getRechargeTransactions(args.storeId)
9842 
    oprot.writeMessageBegin("getRechargeTransactions", TMessageType.REPLY, seqid)
9843 
    result.write(oprot)
9844 
    oprot.writeMessageEnd()
9845 
    oprot.trans.flush()
9846 
 
7151 amit.gupta 9847 
  def process_getRechargeTrans(self, seqid, iprot, oprot):
9848 
    args = getRechargeTrans_args()
9849 
    args.read(iprot)
9850 
    iprot.readMessageEnd()
9851 
    result = getRechargeTrans_result()
9852 
    result.success = self._handler.getRechargeTrans(args.storeId, args.startDate, args.endDate, args.status)
9853 
    oprot.writeMessageBegin("getRechargeTrans", TMessageType.REPLY, seqid)
9854 
    result.write(oprot)
9855 
    oprot.writeMessageEnd()
9856 
    oprot.trans.flush()
9857 
 
7080 anupam.sin 9858 
  def process_getRechargeTransaction(self, seqid, iprot, oprot):
9859 
    args = getRechargeTransaction_args()
9860 
    args.read(iprot)
9861 
    iprot.readMessageEnd()
9862 
    result = getRechargeTransaction_result()
9863 
    result.success = self._handler.getRechargeTransaction(args.rechargeId)
9864 
    oprot.writeMessageBegin("getRechargeTransaction", TMessageType.REPLY, seqid)
9865 
    result.write(oprot)
9866 
    oprot.writeMessageEnd()
9867 
    oprot.trans.flush()
7073 anupam.sin 9868 
 
7080 anupam.sin 9869 
  def process_getFRCs(self, seqid, iprot, oprot):
9870 
    args = getFRCs_args()
9871 
    args.read(iprot)
9872 
    iprot.readMessageEnd()
9873 
    result = getFRCs_result()
9874 
    result.success = self._handler.getFRCs(args.circleId, args.operatorId)
9875 
    oprot.writeMessageBegin("getFRCs", TMessageType.REPLY, seqid)
9876 
    result.write(oprot)
9877 
    oprot.writeMessageEnd()
9878 
    oprot.trans.flush()
9879 
 
7096 anupam.sin 9880 
  def process_getHotspotStore(self, seqid, iprot, oprot):
9881 
    args = getHotspotStore_args()
9882 
    args.read(iprot)
9883 
    iprot.readMessageEnd()
9884 
    result = getHotspotStore_result()
9885 
    result.success = self._handler.getHotspotStore(args.id, args.hotspotid)
9886 
    oprot.writeMessageBegin("getHotspotStore", TMessageType.REPLY, seqid)
9887 
    result.write(oprot)
9888 
    oprot.writeMessageEnd()
9889 
    oprot.trans.flush()
7080 anupam.sin 9890 
 
7096 anupam.sin 9891 
  def process_getTelecomCircle(self, seqid, iprot, oprot):
9892 
    args = getTelecomCircle_args()
9893 
    args.read(iprot)
9894 
    iprot.readMessageEnd()
9895 
    result = getTelecomCircle_result()
9896 
    result.success = self._handler.getTelecomCircle(args.id, args.code)
9897 
    oprot.writeMessageBegin("getTelecomCircle", TMessageType.REPLY, seqid)
9898 
    result.write(oprot)
9899 
    oprot.writeMessageEnd()
9900 
    oprot.trans.flush()
9901 
 
7109 anupam.sin 9902 
  def process_retrieveHotspotRechargeInvoice(self, seqid, iprot, oprot):
9903 
    args = retrieveHotspotRechargeInvoice_args()
9904 
    args.read(iprot)
9905 
    iprot.readMessageEnd()
9906 
    result = retrieveHotspotRechargeInvoice_result()
9907 
    result.success = self._handler.retrieveHotspotRechargeInvoice(args.rechargeId)
9908 
    oprot.writeMessageBegin("retrieveHotspotRechargeInvoice", TMessageType.REPLY, seqid)
9909 
    result.write(oprot)
9910 
    oprot.writeMessageEnd()
9911 
    oprot.trans.flush()
7096 anupam.sin 9912 
 
7190 amar.kumar 9913 
  def process_splitFreebieOrder(self, seqid, iprot, oprot):
9914 
    args = splitFreebieOrder_args()
9915 
    args.read(iprot)
9916 
    iprot.readMessageEnd()
9917 
    result = splitFreebieOrder_result()
9918 
    result.success = self._handler.splitFreebieOrder(args.orderId, args.splitReason, args.shippingDate)
9919 
    oprot.writeMessageBegin("splitFreebieOrder", TMessageType.REPLY, seqid)
9920 
    result.write(oprot)
9921 
    oprot.writeMessageEnd()
9922 
    oprot.trans.flush()
9923 
 
7169 anupam.sin 9924 
  def process_getRechargeTransactionsByNumber(self, seqid, iprot, oprot):
9925 
    args = getRechargeTransactionsByNumber_args()
9926 
    args.read(iprot)
9927 
    iprot.readMessageEnd()
9928 
    result = getRechargeTransactionsByNumber_result()
7172 anupam.sin 9929 
    result.success = self._handler.getRechargeTransactionsByNumber(args.number, args.storeId)
7169 anupam.sin 9930 
    oprot.writeMessageBegin("getRechargeTransactionsByNumber", TMessageType.REPLY, seqid)
9931 
    result.write(oprot)
9932 
    oprot.writeMessageEnd()
9933 
    oprot.trans.flush()
7109 anupam.sin 9934 
 
7169 anupam.sin 9935 
  def process_updateHotspotStorePassword(self, seqid, iprot, oprot):
9936 
    args = updateHotspotStorePassword_args()
9937 
    args.read(iprot)
9938 
    iprot.readMessageEnd()
9939 
    result = updateHotspotStorePassword_result()
9940 
    result.success = self._handler.updateHotspotStorePassword(args.storeId, args.password)
9941 
    oprot.writeMessageBegin("updateHotspotStorePassword", TMessageType.REPLY, seqid)
9942 
    result.write(oprot)
9943 
    oprot.writeMessageEnd()
9944 
    oprot.trans.flush()
9945 
 
7285 rajveer 9946 
  def process_topupCompanyWallet(self, seqid, iprot, oprot):
9947 
    args = topupCompanyWallet_args()
7263 anupam.sin 9948 
    args.read(iprot)
9949 
    iprot.readMessageEnd()
7285 rajveer 9950 
    result = topupCompanyWallet_result()
9951 
    result.success = self._handler.topupCompanyWallet(args.companyId, args.amount)
9952 
    oprot.writeMessageBegin("topupCompanyWallet", TMessageType.REPLY, seqid)
7263 anupam.sin 9953 
    result.write(oprot)
9954 
    oprot.writeMessageEnd()
9955 
    oprot.trans.flush()
7169 anupam.sin 9956 
 
7285 rajveer 9957 
  def process_getWalletBalanceForCompany(self, seqid, iprot, oprot):
9958 
    args = getWalletBalanceForCompany_args()
7267 anupam.sin 9959 
    args.read(iprot)
9960 
    iprot.readMessageEnd()
7285 rajveer 9961 
    result = getWalletBalanceForCompany_result()
9962 
    result.success = self._handler.getWalletBalanceForCompany(args.companyId)
9963 
    oprot.writeMessageBegin("getWalletBalanceForCompany", TMessageType.REPLY, seqid)
7267 anupam.sin 9964 
    result.write(oprot)
9965 
    oprot.writeMessageEnd()
9966 
    oprot.trans.flush()
7263 anupam.sin 9967 
 
7285 rajveer 9968 
  def process_getSourceDetail(self, seqid, iprot, oprot):
9969 
    args = getSourceDetail_args()
7267 anupam.sin 9970 
    args.read(iprot)
9971 
    iprot.readMessageEnd()
7285 rajveer 9972 
    result = getSourceDetail_result()
9973 
    result.success = self._handler.getSourceDetail(args.source)
9974 
    oprot.writeMessageBegin("getSourceDetail", TMessageType.REPLY, seqid)
7267 anupam.sin 9975 
    result.write(oprot)
9976 
    oprot.writeMessageEnd()
9977 
    oprot.trans.flush()
9978 
 
7308 rajveer 9979 
  def process_getAllCircles(self, seqid, iprot, oprot):
9980 
    args = getAllCircles_args()
9981 
    args.read(iprot)
9982 
    iprot.readMessageEnd()
9983 
    result = getAllCircles_result()
9984 
    result.success = self._handler.getAllCircles()
9985 
    oprot.writeMessageBegin("getAllCircles", TMessageType.REPLY, seqid)
9986 
    result.write(oprot)
9987 
    oprot.writeMessageEnd()
9988 
    oprot.trans.flush()
7267 anupam.sin 9989 
 
7308 rajveer 9990 
  def process_deleteFrcs(self, seqid, iprot, oprot):
9991 
    args = deleteFrcs_args()
9992 
    args.read(iprot)
9993 
    iprot.readMessageEnd()
9994 
    result = deleteFrcs_result()
9995 
    result.success = self._handler.deleteFrcs(args.frcIdsToDelete)
9996 
    oprot.writeMessageBegin("deleteFrcs", TMessageType.REPLY, seqid)
9997 
    result.write(oprot)
9998 
    oprot.writeMessageEnd()
9999 
    oprot.trans.flush()
10000 
 
7311 kshitij.so 10001 
  def process_addAmazonOrder(self, seqid, iprot, oprot):
10002 
    args = addAmazonOrder_args()
10003 
    args.read(iprot)
10004 
    iprot.readMessageEnd()
10005 
    result = addAmazonOrder_result()
10006 
    self._handler.addAmazonOrder(args.amazonOrder)
10007 
    oprot.writeMessageBegin("addAmazonOrder", TMessageType.REPLY, seqid)
10008 
    result.write(oprot)
10009 
    oprot.writeMessageEnd()
10010 
    oprot.trans.flush()
7308 rajveer 10011 
 
7322 vikram.rag 10012 
  def process_updateAmazonOrderStatus(self, seqid, iprot, oprot):
10013 
    args = updateAmazonOrderStatus_args()
7311 kshitij.so 10014 
    args.read(iprot)
10015 
    iprot.readMessageEnd()
7322 vikram.rag 10016 
    result = updateAmazonOrderStatus_result()
10017 
    result.success = self._handler.updateAmazonOrderStatus(args.orderId, args.status)
10018 
    oprot.writeMessageBegin("updateAmazonOrderStatus", TMessageType.REPLY, seqid)
7311 kshitij.so 10019 
    result.write(oprot)
10020 
    oprot.writeMessageEnd()
10021 
    oprot.trans.flush()
10022 
 
10023 
  def process_getAmazonOrdersShipped(self, seqid, iprot, oprot):
10024 
    args = getAmazonOrdersShipped_args()
10025 
    args.read(iprot)
10026 
    iprot.readMessageEnd()
10027 
    result = getAmazonOrdersShipped_result()
10028 
    result.success = self._handler.getAmazonOrdersShipped(args.interval)
10029 
    oprot.writeMessageBegin("getAmazonOrdersShipped", TMessageType.REPLY, seqid)
10030 
    result.write(oprot)
10031 
    oprot.writeMessageEnd()
10032 
    oprot.trans.flush()
10033 
 
10034 
  def process_getAmazonOrdersCancelled(self, seqid, iprot, oprot):
10035 
    args = getAmazonOrdersCancelled_args()
10036 
    args.read(iprot)
10037 
    iprot.readMessageEnd()
10038 
    result = getAmazonOrdersCancelled_result()
10039 
    result.success = self._handler.getAmazonOrdersCancelled(args.interval)
10040 
    oprot.writeMessageBegin("getAmazonOrdersCancelled", TMessageType.REPLY, seqid)
10041 
    result.write(oprot)
10042 
    oprot.writeMessageEnd()
10043 
    oprot.trans.flush()
10044 
 
7322 vikram.rag 10045 
  def process_getAmazonOrder(self, seqid, iprot, oprot):
10046 
    args = getAmazonOrder_args()
10047 
    args.read(iprot)
10048 
    iprot.readMessageEnd()
10049 
    result = getAmazonOrder_result()
10050 
    result.success = self._handler.getAmazonOrder(args.orderId)
10051 
    oprot.writeMessageBegin("getAmazonOrder", TMessageType.REPLY, seqid)
10052 
    result.write(oprot)
10053 
    oprot.writeMessageEnd()
10054 
    oprot.trans.flush()
7311 kshitij.so 10055 
 
7343 anupam.sin 10056 
  def process_getOrdersForStore(self, seqid, iprot, oprot):
10057 
    args = getOrdersForStore_args()
10058 
    args.read(iprot)
10059 
    iprot.readMessageEnd()
10060 
    result = getOrdersForStore_result()
10061 
    result.success = self._handler.getOrdersForStore(args.id, args.storeId, args.startDate, args.endDate, args.statuses)
10062 
    oprot.writeMessageBegin("getOrdersForStore", TMessageType.REPLY, seqid)
10063 
    result.write(oprot)
10064 
    oprot.writeMessageEnd()
10065 
    oprot.trans.flush()
7322 vikram.rag 10066 
 
7343 anupam.sin 10067 
  def process_getStoreOrderAdvanceInvoice(self, seqid, iprot, oprot):
10068 
    args = getStoreOrderAdvanceInvoice_args()
10069 
    args.read(iprot)
10070 
    iprot.readMessageEnd()
10071 
    result = getStoreOrderAdvanceInvoice_result()
10072 
    result.success = self._handler.getStoreOrderAdvanceInvoice(args.orderId)
10073 
    oprot.writeMessageBegin("getStoreOrderAdvanceInvoice", TMessageType.REPLY, seqid)
10074 
    result.write(oprot)
10075 
    oprot.writeMessageEnd()
10076 
    oprot.trans.flush()
10077 
 
10078 
 
94 ashish 10079 
# HELPER FUNCTIONS AND STRUCTURES
10080 
 
10081 
class createTransaction_args:
10082 
  """
10083 
  Attributes:
10084 
   - transaction
10085 
  """
10086 
 
10087 
  thrift_spec = (
10088 
    None, # 0
10089 
    (1, TType.STRUCT, 'transaction', (Transaction, Transaction.thrift_spec), None, ), # 1
10090 
  )
10091 
 
10092 
  def __init__(self, transaction=None,):
10093 
    self.transaction = transaction
10094 
 
10095 
  def read(self, iprot):
10096 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10097 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10098 
      return
10099 
    iprot.readStructBegin()
10100 
    while True:
10101 
      (fname, ftype, fid) = iprot.readFieldBegin()
10102 
      if ftype == TType.STOP:
10103 
        break
10104 
      if fid == 1:
10105 
        if ftype == TType.STRUCT:
10106 
          self.transaction = Transaction()
10107 
          self.transaction.read(iprot)
10108 
        else:
10109 
          iprot.skip(ftype)
10110 
      else:
10111 
        iprot.skip(ftype)
10112 
      iprot.readFieldEnd()
10113 
    iprot.readStructEnd()
10114 
 
10115 
  def write(self, oprot):
10116 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10117 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10118 
      return
10119 
    oprot.writeStructBegin('createTransaction_args')
3431 rajveer 10120 
    if self.transaction is not None:
94 ashish 10121 
      oprot.writeFieldBegin('transaction', TType.STRUCT, 1)
10122 
      self.transaction.write(oprot)
10123 
      oprot.writeFieldEnd()
10124 
    oprot.writeFieldStop()
10125 
    oprot.writeStructEnd()
10126 
 
3431 rajveer 10127 
  def validate(self):
10128 
    return
10129 
 
10130 
 
94 ashish 10131 
  def __repr__(self):
10132 
    L = ['%s=%r' % (key, value)
10133 
      for key, value in self.__dict__.iteritems()]
10134 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10135 
 
10136 
  def __eq__(self, other):
10137 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10138 
 
10139 
  def __ne__(self, other):
10140 
    return not (self == other)
10141 
 
10142 
class createTransaction_result:
10143 
  """
10144 
  Attributes:
132 ashish 10145 
   - success
94 ashish 10146 
   - ex
10147 
  """
10148 
 
10149 
  thrift_spec = (
132 ashish 10150 
    (0, TType.I64, 'success', None, None, ), # 0
94 ashish 10151 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
10152 
  )
10153 
 
132 ashish 10154 
  def __init__(self, success=None, ex=None,):
10155 
    self.success = success
94 ashish 10156 
    self.ex = ex
10157 
 
10158 
  def read(self, iprot):
10159 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10160 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10161 
      return
10162 
    iprot.readStructBegin()
10163 
    while True:
10164 
      (fname, ftype, fid) = iprot.readFieldBegin()
10165 
      if ftype == TType.STOP:
10166 
        break
132 ashish 10167 
      if fid == 0:
10168 
        if ftype == TType.I64:
10169 
          self.success = iprot.readI64();
10170 
        else:
10171 
          iprot.skip(ftype)
10172 
      elif fid == 1:
94 ashish 10173 
        if ftype == TType.STRUCT:
10174 
          self.ex = TransactionServiceException()
10175 
          self.ex.read(iprot)
10176 
        else:
10177 
          iprot.skip(ftype)
10178 
      else:
10179 
        iprot.skip(ftype)
10180 
      iprot.readFieldEnd()
10181 
    iprot.readStructEnd()
10182 
 
10183 
  def write(self, oprot):
10184 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10185 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10186 
      return
10187 
    oprot.writeStructBegin('createTransaction_result')
3431 rajveer 10188 
    if self.success is not None:
132 ashish 10189 
      oprot.writeFieldBegin('success', TType.I64, 0)
10190 
      oprot.writeI64(self.success)
10191 
      oprot.writeFieldEnd()
3431 rajveer 10192 
    if self.ex is not None:
94 ashish 10193 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10194 
      self.ex.write(oprot)
10195 
      oprot.writeFieldEnd()
10196 
    oprot.writeFieldStop()
10197 
    oprot.writeStructEnd()
10198 
 
3431 rajveer 10199 
  def validate(self):
10200 
    return
10201 
 
10202 
 
94 ashish 10203 
  def __repr__(self):
10204 
    L = ['%s=%r' % (key, value)
10205 
      for key, value in self.__dict__.iteritems()]
10206 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10207 
 
10208 
  def __eq__(self, other):
10209 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10210 
 
10211 
  def __ne__(self, other):
10212 
    return not (self == other)
10213 
 
10214 
class getTransaction_args:
10215 
  """
10216 
  Attributes:
10217 
   - id
10218 
  """
10219 
 
10220 
  thrift_spec = (
10221 
    None, # 0
10222 
    (1, TType.I64, 'id', None, None, ), # 1
10223 
  )
10224 
 
10225 
  def __init__(self, id=None,):
10226 
    self.id = id
10227 
 
10228 
  def read(self, iprot):
10229 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10230 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10231 
      return
10232 
    iprot.readStructBegin()
10233 
    while True:
10234 
      (fname, ftype, fid) = iprot.readFieldBegin()
10235 
      if ftype == TType.STOP:
10236 
        break
10237 
      if fid == 1:
10238 
        if ftype == TType.I64:
10239 
          self.id = iprot.readI64();
10240 
        else:
10241 
          iprot.skip(ftype)
10242 
      else:
10243 
        iprot.skip(ftype)
10244 
      iprot.readFieldEnd()
10245 
    iprot.readStructEnd()
10246 
 
10247 
  def write(self, oprot):
10248 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10249 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10250 
      return
10251 
    oprot.writeStructBegin('getTransaction_args')
3431 rajveer 10252 
    if self.id is not None:
94 ashish 10253 
      oprot.writeFieldBegin('id', TType.I64, 1)
10254 
      oprot.writeI64(self.id)
10255 
      oprot.writeFieldEnd()
10256 
    oprot.writeFieldStop()
10257 
    oprot.writeStructEnd()
10258 
 
3431 rajveer 10259 
  def validate(self):
10260 
    return
10261 
 
10262 
 
94 ashish 10263 
  def __repr__(self):
10264 
    L = ['%s=%r' % (key, value)
10265 
      for key, value in self.__dict__.iteritems()]
10266 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10267 
 
10268 
  def __eq__(self, other):
10269 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10270 
 
10271 
  def __ne__(self, other):
10272 
    return not (self == other)
10273 
 
10274 
class getTransaction_result:
10275 
  """
10276 
  Attributes:
10277 
   - success
10278 
   - ex
10279 
  """
10280 
 
10281 
  thrift_spec = (
10282 
    (0, TType.STRUCT, 'success', (Transaction, Transaction.thrift_spec), None, ), # 0
10283 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
10284 
  )
10285 
 
10286 
  def __init__(self, success=None, ex=None,):
10287 
    self.success = success
10288 
    self.ex = ex
10289 
 
10290 
  def read(self, iprot):
10291 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10292 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10293 
      return
10294 
    iprot.readStructBegin()
10295 
    while True:
10296 
      (fname, ftype, fid) = iprot.readFieldBegin()
10297 
      if ftype == TType.STOP:
10298 
        break
10299 
      if fid == 0:
10300 
        if ftype == TType.STRUCT:
10301 
          self.success = Transaction()
10302 
          self.success.read(iprot)
10303 
        else:
10304 
          iprot.skip(ftype)
10305 
      elif fid == 1:
10306 
        if ftype == TType.STRUCT:
10307 
          self.ex = TransactionServiceException()
10308 
          self.ex.read(iprot)
10309 
        else:
10310 
          iprot.skip(ftype)
10311 
      else:
10312 
        iprot.skip(ftype)
10313 
      iprot.readFieldEnd()
10314 
    iprot.readStructEnd()
10315 
 
10316 
  def write(self, oprot):
10317 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10318 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10319 
      return
10320 
    oprot.writeStructBegin('getTransaction_result')
3431 rajveer 10321 
    if self.success is not None:
94 ashish 10322 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
10323 
      self.success.write(oprot)
10324 
      oprot.writeFieldEnd()
3431 rajveer 10325 
    if self.ex is not None:
94 ashish 10326 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10327 
      self.ex.write(oprot)
10328 
      oprot.writeFieldEnd()
10329 
    oprot.writeFieldStop()
10330 
    oprot.writeStructEnd()
10331 
 
3431 rajveer 10332 
  def validate(self):
10333 
    return
10334 
 
10335 
 
94 ashish 10336 
  def __repr__(self):
10337 
    L = ['%s=%r' % (key, value)
10338 
      for key, value in self.__dict__.iteritems()]
10339 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10340 
 
10341 
  def __eq__(self, other):
10342 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10343 
 
10344 
  def __ne__(self, other):
10345 
    return not (self == other)
10346 
 
10347 
class getTransactionsForCustomer_args:
10348 
  """
10349 
  Attributes:
10350 
   - customerId
10351 
   - from_date
10352 
   - to_date
10353 
   - status
10354 
  """
10355 
 
10356 
  thrift_spec = (
10357 
    None, # 0
10358 
    (1, TType.I64, 'customerId', None, None, ), # 1
10359 
    (2, TType.I64, 'from_date', None, None, ), # 2
10360 
    (3, TType.I64, 'to_date', None, None, ), # 3
10361 
    (4, TType.I32, 'status', None, None, ), # 4
10362 
  )
10363 
 
10364 
  def __init__(self, customerId=None, from_date=None, to_date=None, status=None,):
10365 
    self.customerId = customerId
10366 
    self.from_date = from_date
10367 
    self.to_date = to_date
10368 
    self.status = status
10369 
 
10370 
  def read(self, iprot):
10371 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10372 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10373 
      return
10374 
    iprot.readStructBegin()
10375 
    while True:
10376 
      (fname, ftype, fid) = iprot.readFieldBegin()
10377 
      if ftype == TType.STOP:
10378 
        break
10379 
      if fid == 1:
10380 
        if ftype == TType.I64:
10381 
          self.customerId = iprot.readI64();
10382 
        else:
10383 
          iprot.skip(ftype)
10384 
      elif fid == 2:
10385 
        if ftype == TType.I64:
10386 
          self.from_date = iprot.readI64();
10387 
        else:
10388 
          iprot.skip(ftype)
10389 
      elif fid == 3:
10390 
        if ftype == TType.I64:
10391 
          self.to_date = iprot.readI64();
10392 
        else:
10393 
          iprot.skip(ftype)
10394 
      elif fid == 4:
10395 
        if ftype == TType.I32:
10396 
          self.status = iprot.readI32();
10397 
        else:
10398 
          iprot.skip(ftype)
10399 
      else:
10400 
        iprot.skip(ftype)
10401 
      iprot.readFieldEnd()
10402 
    iprot.readStructEnd()
10403 
 
10404 
  def write(self, oprot):
10405 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10406 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10407 
      return
10408 
    oprot.writeStructBegin('getTransactionsForCustomer_args')
3431 rajveer 10409 
    if self.customerId is not None:
94 ashish 10410 
      oprot.writeFieldBegin('customerId', TType.I64, 1)
10411 
      oprot.writeI64(self.customerId)
10412 
      oprot.writeFieldEnd()
3431 rajveer 10413 
    if self.from_date is not None:
94 ashish 10414 
      oprot.writeFieldBegin('from_date', TType.I64, 2)
10415 
      oprot.writeI64(self.from_date)
10416 
      oprot.writeFieldEnd()
3431 rajveer 10417 
    if self.to_date is not None:
94 ashish 10418 
      oprot.writeFieldBegin('to_date', TType.I64, 3)
10419 
      oprot.writeI64(self.to_date)
10420 
      oprot.writeFieldEnd()
3431 rajveer 10421 
    if self.status is not None:
94 ashish 10422 
      oprot.writeFieldBegin('status', TType.I32, 4)
10423 
      oprot.writeI32(self.status)
10424 
      oprot.writeFieldEnd()
10425 
    oprot.writeFieldStop()
10426 
    oprot.writeStructEnd()
10427 
 
3431 rajveer 10428 
  def validate(self):
10429 
    return
10430 
 
10431 
 
94 ashish 10432 
  def __repr__(self):
10433 
    L = ['%s=%r' % (key, value)
10434 
      for key, value in self.__dict__.iteritems()]
10435 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10436 
 
10437 
  def __eq__(self, other):
10438 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10439 
 
10440 
  def __ne__(self, other):
10441 
    return not (self == other)
10442 
 
10443 
class getTransactionsForCustomer_result:
10444 
  """
10445 
  Attributes:
10446 
   - success
10447 
   - ex
10448 
  """
10449 
 
10450 
  thrift_spec = (
10451 
    (0, TType.LIST, 'success', (TType.STRUCT,(Transaction, Transaction.thrift_spec)), None, ), # 0
10452 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
10453 
  )
10454 
 
10455 
  def __init__(self, success=None, ex=None,):
10456 
    self.success = success
10457 
    self.ex = ex
10458 
 
10459 
  def read(self, iprot):
10460 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10461 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10462 
      return
10463 
    iprot.readStructBegin()
10464 
    while True:
10465 
      (fname, ftype, fid) = iprot.readFieldBegin()
10466 
      if ftype == TType.STOP:
10467 
        break
10468 
      if fid == 0:
10469 
        if ftype == TType.LIST:
10470 
          self.success = []
6188 rajveer 10471 
          (_etype109, _size106) = iprot.readListBegin()
10472 
          for _i110 in xrange(_size106):
10473 
            _elem111 = Transaction()
10474 
            _elem111.read(iprot)
10475 
            self.success.append(_elem111)
94 ashish 10476 
          iprot.readListEnd()
10477 
        else:
10478 
          iprot.skip(ftype)
10479 
      elif fid == 1:
10480 
        if ftype == TType.STRUCT:
10481 
          self.ex = TransactionServiceException()
10482 
          self.ex.read(iprot)
10483 
        else:
10484 
          iprot.skip(ftype)
10485 
      else:
10486 
        iprot.skip(ftype)
10487 
      iprot.readFieldEnd()
10488 
    iprot.readStructEnd()
10489 
 
10490 
  def write(self, oprot):
10491 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10492 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10493 
      return
10494 
    oprot.writeStructBegin('getTransactionsForCustomer_result')
3431 rajveer 10495 
    if self.success is not None:
94 ashish 10496 
      oprot.writeFieldBegin('success', TType.LIST, 0)
10497 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 10498 
      for iter112 in self.success:
10499 
        iter112.write(oprot)
94 ashish 10500 
      oprot.writeListEnd()
10501 
      oprot.writeFieldEnd()
3431 rajveer 10502 
    if self.ex is not None:
94 ashish 10503 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10504 
      self.ex.write(oprot)
10505 
      oprot.writeFieldEnd()
10506 
    oprot.writeFieldStop()
10507 
    oprot.writeStructEnd()
10508 
 
3431 rajveer 10509 
  def validate(self):
10510 
    return
10511 
 
10512 
 
94 ashish 10513 
  def __repr__(self):
10514 
    L = ['%s=%r' % (key, value)
10515 
      for key, value in self.__dict__.iteritems()]
10516 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10517 
 
10518 
  def __eq__(self, other):
10519 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10520 
 
10521 
  def __ne__(self, other):
10522 
    return not (self == other)
10523 
 
132 ashish 10524 
class getTransactionsForShoppingCartId_args:
10525 
  """
10526 
  Attributes:
10527 
   - shoppingCartId
10528 
  """
10529 
 
10530 
  thrift_spec = (
10531 
    None, # 0
10532 
    (1, TType.I64, 'shoppingCartId', None, None, ), # 1
10533 
  )
10534 
 
10535 
  def __init__(self, shoppingCartId=None,):
10536 
    self.shoppingCartId = shoppingCartId
10537 
 
10538 
  def read(self, iprot):
10539 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10540 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10541 
      return
10542 
    iprot.readStructBegin()
10543 
    while True:
10544 
      (fname, ftype, fid) = iprot.readFieldBegin()
10545 
      if ftype == TType.STOP:
10546 
        break
10547 
      if fid == 1:
10548 
        if ftype == TType.I64:
10549 
          self.shoppingCartId = iprot.readI64();
10550 
        else:
10551 
          iprot.skip(ftype)
10552 
      else:
10553 
        iprot.skip(ftype)
10554 
      iprot.readFieldEnd()
10555 
    iprot.readStructEnd()
10556 
 
10557 
  def write(self, oprot):
10558 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10559 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10560 
      return
10561 
    oprot.writeStructBegin('getTransactionsForShoppingCartId_args')
3431 rajveer 10562 
    if self.shoppingCartId is not None:
132 ashish 10563 
      oprot.writeFieldBegin('shoppingCartId', TType.I64, 1)
10564 
      oprot.writeI64(self.shoppingCartId)
10565 
      oprot.writeFieldEnd()
10566 
    oprot.writeFieldStop()
10567 
    oprot.writeStructEnd()
10568 
 
3431 rajveer 10569 
  def validate(self):
10570 
    return
10571 
 
10572 
 
132 ashish 10573 
  def __repr__(self):
10574 
    L = ['%s=%r' % (key, value)
10575 
      for key, value in self.__dict__.iteritems()]
10576 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10577 
 
10578 
  def __eq__(self, other):
10579 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10580 
 
10581 
  def __ne__(self, other):
10582 
    return not (self == other)
10583 
 
10584 
class getTransactionsForShoppingCartId_result:
10585 
  """
10586 
  Attributes:
10587 
   - success
10588 
   - ex
10589 
  """
10590 
 
10591 
  thrift_spec = (
10592 
    (0, TType.LIST, 'success', (TType.STRUCT,(Transaction, Transaction.thrift_spec)), None, ), # 0
10593 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
10594 
  )
10595 
 
10596 
  def __init__(self, success=None, ex=None,):
10597 
    self.success = success
10598 
    self.ex = ex
10599 
 
10600 
  def read(self, iprot):
10601 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10602 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10603 
      return
10604 
    iprot.readStructBegin()
10605 
    while True:
10606 
      (fname, ftype, fid) = iprot.readFieldBegin()
10607 
      if ftype == TType.STOP:
10608 
        break
10609 
      if fid == 0:
10610 
        if ftype == TType.LIST:
10611 
          self.success = []
6188 rajveer 10612 
          (_etype116, _size113) = iprot.readListBegin()
10613 
          for _i117 in xrange(_size113):
10614 
            _elem118 = Transaction()
10615 
            _elem118.read(iprot)
10616 
            self.success.append(_elem118)
132 ashish 10617 
          iprot.readListEnd()
10618 
        else:
10619 
          iprot.skip(ftype)
10620 
      elif fid == 1:
10621 
        if ftype == TType.STRUCT:
10622 
          self.ex = TransactionServiceException()
10623 
          self.ex.read(iprot)
10624 
        else:
10625 
          iprot.skip(ftype)
10626 
      else:
10627 
        iprot.skip(ftype)
10628 
      iprot.readFieldEnd()
10629 
    iprot.readStructEnd()
10630 
 
10631 
  def write(self, oprot):
10632 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10633 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10634 
      return
10635 
    oprot.writeStructBegin('getTransactionsForShoppingCartId_result')
3431 rajveer 10636 
    if self.success is not None:
132 ashish 10637 
      oprot.writeFieldBegin('success', TType.LIST, 0)
10638 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 10639 
      for iter119 in self.success:
10640 
        iter119.write(oprot)
132 ashish 10641 
      oprot.writeListEnd()
10642 
      oprot.writeFieldEnd()
3431 rajveer 10643 
    if self.ex is not None:
132 ashish 10644 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10645 
      self.ex.write(oprot)
10646 
      oprot.writeFieldEnd()
10647 
    oprot.writeFieldStop()
10648 
    oprot.writeStructEnd()
10649 
 
3431 rajveer 10650 
  def validate(self):
10651 
    return
10652 
 
10653 
 
132 ashish 10654 
  def __repr__(self):
10655 
    L = ['%s=%r' % (key, value)
10656 
      for key, value in self.__dict__.iteritems()]
10657 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10658 
 
10659 
  def __eq__(self, other):
10660 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10661 
 
10662 
  def __ne__(self, other):
10663 
    return not (self == other)
10664 
 
94 ashish 10665 
class getTransactionStatus_args:
10666 
  """
10667 
  Attributes:
10668 
   - transactionId
10669 
  """
10670 
 
10671 
  thrift_spec = (
10672 
    None, # 0
10673 
    (1, TType.I64, 'transactionId', None, None, ), # 1
10674 
  )
10675 
 
10676 
  def __init__(self, transactionId=None,):
10677 
    self.transactionId = transactionId
10678 
 
10679 
  def read(self, iprot):
10680 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10681 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10682 
      return
10683 
    iprot.readStructBegin()
10684 
    while True:
10685 
      (fname, ftype, fid) = iprot.readFieldBegin()
10686 
      if ftype == TType.STOP:
10687 
        break
10688 
      if fid == 1:
10689 
        if ftype == TType.I64:
10690 
          self.transactionId = iprot.readI64();
10691 
        else:
10692 
          iprot.skip(ftype)
10693 
      else:
10694 
        iprot.skip(ftype)
10695 
      iprot.readFieldEnd()
10696 
    iprot.readStructEnd()
10697 
 
10698 
  def write(self, oprot):
10699 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10700 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10701 
      return
10702 
    oprot.writeStructBegin('getTransactionStatus_args')
3431 rajveer 10703 
    if self.transactionId is not None:
94 ashish 10704 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
10705 
      oprot.writeI64(self.transactionId)
10706 
      oprot.writeFieldEnd()
10707 
    oprot.writeFieldStop()
10708 
    oprot.writeStructEnd()
10709 
 
3431 rajveer 10710 
  def validate(self):
10711 
    return
10712 
 
10713 
 
94 ashish 10714 
  def __repr__(self):
10715 
    L = ['%s=%r' % (key, value)
10716 
      for key, value in self.__dict__.iteritems()]
10717 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10718 
 
10719 
  def __eq__(self, other):
10720 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10721 
 
10722 
  def __ne__(self, other):
10723 
    return not (self == other)
10724 
 
10725 
class getTransactionStatus_result:
10726 
  """
10727 
  Attributes:
10728 
   - success
10729 
   - ex
10730 
  """
10731 
 
10732 
  thrift_spec = (
10733 
    (0, TType.I32, 'success', None, None, ), # 0
10734 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
10735 
  )
10736 
 
10737 
  def __init__(self, success=None, ex=None,):
10738 
    self.success = success
10739 
    self.ex = ex
10740 
 
10741 
  def read(self, iprot):
10742 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10743 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10744 
      return
10745 
    iprot.readStructBegin()
10746 
    while True:
10747 
      (fname, ftype, fid) = iprot.readFieldBegin()
10748 
      if ftype == TType.STOP:
10749 
        break
10750 
      if fid == 0:
10751 
        if ftype == TType.I32:
10752 
          self.success = iprot.readI32();
10753 
        else:
10754 
          iprot.skip(ftype)
10755 
      elif fid == 1:
10756 
        if ftype == TType.STRUCT:
10757 
          self.ex = TransactionServiceException()
10758 
          self.ex.read(iprot)
10759 
        else:
10760 
          iprot.skip(ftype)
10761 
      else:
10762 
        iprot.skip(ftype)
10763 
      iprot.readFieldEnd()
10764 
    iprot.readStructEnd()
10765 
 
10766 
  def write(self, oprot):
10767 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10768 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10769 
      return
10770 
    oprot.writeStructBegin('getTransactionStatus_result')
3431 rajveer 10771 
    if self.success is not None:
94 ashish 10772 
      oprot.writeFieldBegin('success', TType.I32, 0)
10773 
      oprot.writeI32(self.success)
10774 
      oprot.writeFieldEnd()
3431 rajveer 10775 
    if self.ex is not None:
94 ashish 10776 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10777 
      self.ex.write(oprot)
10778 
      oprot.writeFieldEnd()
10779 
    oprot.writeFieldStop()
10780 
    oprot.writeStructEnd()
10781 
 
3431 rajveer 10782 
  def validate(self):
10783 
    return
10784 
 
10785 
 
94 ashish 10786 
  def __repr__(self):
10787 
    L = ['%s=%r' % (key, value)
10788 
      for key, value in self.__dict__.iteritems()]
10789 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10790 
 
10791 
  def __eq__(self, other):
10792 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10793 
 
10794 
  def __ne__(self, other):
10795 
    return not (self == other)
10796 
 
10797 
class changeTransactionStatus_args:
10798 
  """
10799 
  Attributes:
10800 
   - transactionId
10801 
   - status
10802 
   - description
5527 anupam.sin 10803 
   - pickUp
10804 
   - orderType
7293 anupam.sin 10805 
   - source
94 ashish 10806 
  """
10807 
 
10808 
  thrift_spec = (
10809 
    None, # 0
10810 
    (1, TType.I64, 'transactionId', None, None, ), # 1
10811 
    (2, TType.I32, 'status', None, None, ), # 2
10812 
    (3, TType.STRING, 'description', None, None, ), # 3
5527 anupam.sin 10813 
    (4, TType.I64, 'pickUp', None, None, ), # 4
10814 
    (5, TType.I32, 'orderType', None, None, ), # 5
7293 anupam.sin 10815 
    (6, TType.I32, 'source', None, None, ), # 6
94 ashish 10816 
  )
10817 
 
7293 anupam.sin 10818 
  def __init__(self, transactionId=None, status=None, description=None, pickUp=None, orderType=None, source=None,):
94 ashish 10819 
    self.transactionId = transactionId
10820 
    self.status = status
10821 
    self.description = description
5527 anupam.sin 10822 
    self.pickUp = pickUp
10823 
    self.orderType = orderType
7293 anupam.sin 10824 
    self.source = source
94 ashish 10825 
 
10826 
  def read(self, iprot):
10827 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10828 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10829 
      return
10830 
    iprot.readStructBegin()
10831 
    while True:
10832 
      (fname, ftype, fid) = iprot.readFieldBegin()
10833 
      if ftype == TType.STOP:
10834 
        break
10835 
      if fid == 1:
10836 
        if ftype == TType.I64:
10837 
          self.transactionId = iprot.readI64();
10838 
        else:
10839 
          iprot.skip(ftype)
10840 
      elif fid == 2:
10841 
        if ftype == TType.I32:
10842 
          self.status = iprot.readI32();
10843 
        else:
10844 
          iprot.skip(ftype)
10845 
      elif fid == 3:
10846 
        if ftype == TType.STRING:
10847 
          self.description = iprot.readString();
10848 
        else:
10849 
          iprot.skip(ftype)
5387 rajveer 10850 
      elif fid == 4:
5527 anupam.sin 10851 
        if ftype == TType.I64:
10852 
          self.pickUp = iprot.readI64();
5387 rajveer 10853 
        else:
10854 
          iprot.skip(ftype)
5527 anupam.sin 10855 
      elif fid == 5:
10856 
        if ftype == TType.I32:
10857 
          self.orderType = iprot.readI32();
10858 
        else:
10859 
          iprot.skip(ftype)
7293 anupam.sin 10860 
      elif fid == 6:
10861 
        if ftype == TType.I32:
10862 
          self.source = iprot.readI32();
10863 
        else:
10864 
          iprot.skip(ftype)
94 ashish 10865 
      else:
10866 
        iprot.skip(ftype)
10867 
      iprot.readFieldEnd()
10868 
    iprot.readStructEnd()
10869 
 
10870 
  def write(self, oprot):
10871 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10872 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10873 
      return
10874 
    oprot.writeStructBegin('changeTransactionStatus_args')
3431 rajveer 10875 
    if self.transactionId is not None:
94 ashish 10876 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
10877 
      oprot.writeI64(self.transactionId)
10878 
      oprot.writeFieldEnd()
3431 rajveer 10879 
    if self.status is not None:
94 ashish 10880 
      oprot.writeFieldBegin('status', TType.I32, 2)
10881 
      oprot.writeI32(self.status)
10882 
      oprot.writeFieldEnd()
3431 rajveer 10883 
    if self.description is not None:
94 ashish 10884 
      oprot.writeFieldBegin('description', TType.STRING, 3)
10885 
      oprot.writeString(self.description)
10886 
      oprot.writeFieldEnd()
5527 anupam.sin 10887 
    if self.pickUp is not None:
10888 
      oprot.writeFieldBegin('pickUp', TType.I64, 4)
10889 
      oprot.writeI64(self.pickUp)
5387 rajveer 10890 
      oprot.writeFieldEnd()
5527 anupam.sin 10891 
    if self.orderType is not None:
10892 
      oprot.writeFieldBegin('orderType', TType.I32, 5)
10893 
      oprot.writeI32(self.orderType)
10894 
      oprot.writeFieldEnd()
7293 anupam.sin 10895 
    if self.source is not None:
10896 
      oprot.writeFieldBegin('source', TType.I32, 6)
10897 
      oprot.writeI32(self.source)
10898 
      oprot.writeFieldEnd()
94 ashish 10899 
    oprot.writeFieldStop()
10900 
    oprot.writeStructEnd()
10901 
 
3431 rajveer 10902 
  def validate(self):
10903 
    return
10904 
 
10905 
 
94 ashish 10906 
  def __repr__(self):
10907 
    L = ['%s=%r' % (key, value)
10908 
      for key, value in self.__dict__.iteritems()]
10909 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10910 
 
10911 
  def __eq__(self, other):
10912 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10913 
 
10914 
  def __ne__(self, other):
10915 
    return not (self == other)
10916 
 
10917 
class changeTransactionStatus_result:
10918 
  """
10919 
  Attributes:
10920 
   - success
10921 
   - ex
10922 
  """
10923 
 
10924 
  thrift_spec = (
10925 
    (0, TType.BOOL, 'success', None, None, ), # 0
10926 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
10927 
  )
10928 
 
10929 
  def __init__(self, success=None, ex=None,):
10930 
    self.success = success
10931 
    self.ex = ex
10932 
 
10933 
  def read(self, iprot):
10934 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10935 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10936 
      return
10937 
    iprot.readStructBegin()
10938 
    while True:
10939 
      (fname, ftype, fid) = iprot.readFieldBegin()
10940 
      if ftype == TType.STOP:
10941 
        break
10942 
      if fid == 0:
10943 
        if ftype == TType.BOOL:
10944 
          self.success = iprot.readBool();
10945 
        else:
10946 
          iprot.skip(ftype)
10947 
      elif fid == 1:
10948 
        if ftype == TType.STRUCT:
10949 
          self.ex = TransactionServiceException()
10950 
          self.ex.read(iprot)
10951 
        else:
10952 
          iprot.skip(ftype)
10953 
      else:
10954 
        iprot.skip(ftype)
10955 
      iprot.readFieldEnd()
10956 
    iprot.readStructEnd()
10957 
 
10958 
  def write(self, oprot):
10959 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10960 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10961 
      return
10962 
    oprot.writeStructBegin('changeTransactionStatus_result')
3431 rajveer 10963 
    if self.success is not None:
94 ashish 10964 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
10965 
      oprot.writeBool(self.success)
10966 
      oprot.writeFieldEnd()
3431 rajveer 10967 
    if self.ex is not None:
94 ashish 10968 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10969 
      self.ex.write(oprot)
10970 
      oprot.writeFieldEnd()
10971 
    oprot.writeFieldStop()
10972 
    oprot.writeStructEnd()
10973 
 
3431 rajveer 10974 
  def validate(self):
10975 
    return
10976 
 
10977 
 
94 ashish 10978 
  def __repr__(self):
10979 
    L = ['%s=%r' % (key, value)
10980 
      for key, value in self.__dict__.iteritems()]
10981 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10982 
 
10983 
  def __eq__(self, other):
10984 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10985 
 
10986 
  def __ne__(self, other):
10987 
    return not (self == other)
10988 
 
1398 varun.gupt 10989 
class enqueueTransactionInfoEmail_args:
1382 varun.gupt 10990 
  """
10991 
  Attributes:
10992 
   - transactionId
10993 
  """
10994 
 
10995 
  thrift_spec = (
10996 
    None, # 0
10997 
    (1, TType.I64, 'transactionId', None, None, ), # 1
10998 
  )
10999 
 
11000 
  def __init__(self, transactionId=None,):
11001 
    self.transactionId = transactionId
11002 
 
11003 
  def read(self, iprot):
11004 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11005 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11006 
      return
11007 
    iprot.readStructBegin()
11008 
    while True:
11009 
      (fname, ftype, fid) = iprot.readFieldBegin()
11010 
      if ftype == TType.STOP:
11011 
        break
11012 
      if fid == 1:
11013 
        if ftype == TType.I64:
11014 
          self.transactionId = iprot.readI64();
11015 
        else:
11016 
          iprot.skip(ftype)
11017 
      else:
11018 
        iprot.skip(ftype)
11019 
      iprot.readFieldEnd()
11020 
    iprot.readStructEnd()
11021 
 
11022 
  def write(self, oprot):
11023 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11024 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11025 
      return
1398 varun.gupt 11026 
    oprot.writeStructBegin('enqueueTransactionInfoEmail_args')
3431 rajveer 11027 
    if self.transactionId is not None:
1382 varun.gupt 11028 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
11029 
      oprot.writeI64(self.transactionId)
11030 
      oprot.writeFieldEnd()
11031 
    oprot.writeFieldStop()
11032 
    oprot.writeStructEnd()
11033 
 
3431 rajveer 11034 
  def validate(self):
11035 
    return
11036 
 
11037 
 
1382 varun.gupt 11038 
  def __repr__(self):
11039 
    L = ['%s=%r' % (key, value)
11040 
      for key, value in self.__dict__.iteritems()]
11041 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11042 
 
11043 
  def __eq__(self, other):
11044 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11045 
 
11046 
  def __ne__(self, other):
11047 
    return not (self == other)
11048 
 
1398 varun.gupt 11049 
class enqueueTransactionInfoEmail_result:
1382 varun.gupt 11050 
  """
11051 
  Attributes:
11052 
   - success
11053 
   - ex
11054 
  """
11055 
 
11056 
  thrift_spec = (
11057 
    (0, TType.BOOL, 'success', None, None, ), # 0
11058 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
11059 
  )
11060 
 
11061 
  def __init__(self, success=None, ex=None,):
11062 
    self.success = success
11063 
    self.ex = ex
11064 
 
11065 
  def read(self, iprot):
11066 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11067 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11068 
      return
11069 
    iprot.readStructBegin()
11070 
    while True:
11071 
      (fname, ftype, fid) = iprot.readFieldBegin()
11072 
      if ftype == TType.STOP:
11073 
        break
11074 
      if fid == 0:
11075 
        if ftype == TType.BOOL:
11076 
          self.success = iprot.readBool();
11077 
        else:
11078 
          iprot.skip(ftype)
11079 
      elif fid == 1:
11080 
        if ftype == TType.STRUCT:
11081 
          self.ex = TransactionServiceException()
11082 
          self.ex.read(iprot)
11083 
        else:
11084 
          iprot.skip(ftype)
11085 
      else:
11086 
        iprot.skip(ftype)
11087 
      iprot.readFieldEnd()
11088 
    iprot.readStructEnd()
11089 
 
11090 
  def write(self, oprot):
11091 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11092 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11093 
      return
1398 varun.gupt 11094 
    oprot.writeStructBegin('enqueueTransactionInfoEmail_result')
3431 rajveer 11095 
    if self.success is not None:
1382 varun.gupt 11096 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
11097 
      oprot.writeBool(self.success)
11098 
      oprot.writeFieldEnd()
3431 rajveer 11099 
    if self.ex is not None:
1382 varun.gupt 11100 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11101 
      self.ex.write(oprot)
11102 
      oprot.writeFieldEnd()
11103 
    oprot.writeFieldStop()
11104 
    oprot.writeStructEnd()
11105 
 
3431 rajveer 11106 
  def validate(self):
11107 
    return
11108 
 
11109 
 
1382 varun.gupt 11110 
  def __repr__(self):
11111 
    L = ['%s=%r' % (key, value)
11112 
      for key, value in self.__dict__.iteritems()]
11113 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11114 
 
11115 
  def __eq__(self, other):
11116 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11117 
 
11118 
  def __ne__(self, other):
11119 
    return not (self == other)
11120 
 
483 rajveer 11121 
class getAllOrders_args:
94 ashish 11122 
  """
11123 
  Attributes:
4801 anupam.sin 11124 
   - statuses
483 rajveer 11125 
   - from_date
11126 
   - to_date
11127 
   - warehouse_id
94 ashish 11128 
  """
11129 
 
11130 
  thrift_spec = (
11131 
    None, # 0
4801 anupam.sin 11132 
    (1, TType.LIST, 'statuses', (TType.I32,None), None, ), # 1
483 rajveer 11133 
    (2, TType.I64, 'from_date', None, None, ), # 2
11134 
    (3, TType.I64, 'to_date', None, None, ), # 3
11135 
    (4, TType.I64, 'warehouse_id', None, None, ), # 4
94 ashish 11136 
  )
11137 
 
4801 anupam.sin 11138 
  def __init__(self, statuses=None, from_date=None, to_date=None, warehouse_id=None,):
11139 
    self.statuses = statuses
483 rajveer 11140 
    self.from_date = from_date
11141 
    self.to_date = to_date
11142 
    self.warehouse_id = warehouse_id
94 ashish 11143 
 
11144 
  def read(self, iprot):
11145 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11146 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11147 
      return
11148 
    iprot.readStructBegin()
11149 
    while True:
11150 
      (fname, ftype, fid) = iprot.readFieldBegin()
11151 
      if ftype == TType.STOP:
11152 
        break
11153 
      if fid == 1:
4801 anupam.sin 11154 
        if ftype == TType.LIST:
11155 
          self.statuses = []
6188 rajveer 11156 
          (_etype123, _size120) = iprot.readListBegin()
11157 
          for _i124 in xrange(_size120):
11158 
            _elem125 = iprot.readI32();
11159 
            self.statuses.append(_elem125)
4801 anupam.sin 11160 
          iprot.readListEnd()
94 ashish 11161 
        else:
11162 
          iprot.skip(ftype)
483 rajveer 11163 
      elif fid == 2:
11164 
        if ftype == TType.I64:
11165 
          self.from_date = iprot.readI64();
94 ashish 11166 
        else:
11167 
          iprot.skip(ftype)
483 rajveer 11168 
      elif fid == 3:
11169 
        if ftype == TType.I64:
11170 
          self.to_date = iprot.readI64();
94 ashish 11171 
        else:
11172 
          iprot.skip(ftype)
483 rajveer 11173 
      elif fid == 4:
94 ashish 11174 
        if ftype == TType.I64:
483 rajveer 11175 
          self.warehouse_id = iprot.readI64();
94 ashish 11176 
        else:
11177 
          iprot.skip(ftype)
11178 
      else:
11179 
        iprot.skip(ftype)
11180 
      iprot.readFieldEnd()
11181 
    iprot.readStructEnd()
11182 
 
11183 
  def write(self, oprot):
11184 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11185 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11186 
      return
483 rajveer 11187 
    oprot.writeStructBegin('getAllOrders_args')
4801 anupam.sin 11188 
    if self.statuses is not None:
11189 
      oprot.writeFieldBegin('statuses', TType.LIST, 1)
11190 
      oprot.writeListBegin(TType.I32, len(self.statuses))
6188 rajveer 11191 
      for iter126 in self.statuses:
11192 
        oprot.writeI32(iter126)
4801 anupam.sin 11193 
      oprot.writeListEnd()
94 ashish 11194 
      oprot.writeFieldEnd()
3431 rajveer 11195 
    if self.from_date is not None:
483 rajveer 11196 
      oprot.writeFieldBegin('from_date', TType.I64, 2)
11197 
      oprot.writeI64(self.from_date)
94 ashish 11198 
      oprot.writeFieldEnd()
3431 rajveer 11199 
    if self.to_date is not None:
483 rajveer 11200 
      oprot.writeFieldBegin('to_date', TType.I64, 3)
11201 
      oprot.writeI64(self.to_date)
94 ashish 11202 
      oprot.writeFieldEnd()
3431 rajveer 11203 
    if self.warehouse_id is not None:
483 rajveer 11204 
      oprot.writeFieldBegin('warehouse_id', TType.I64, 4)
11205 
      oprot.writeI64(self.warehouse_id)
94 ashish 11206 
      oprot.writeFieldEnd()
11207 
    oprot.writeFieldStop()
11208 
    oprot.writeStructEnd()
11209 
 
3431 rajveer 11210 
  def validate(self):
11211 
    return
11212 
 
11213 
 
94 ashish 11214 
  def __repr__(self):
11215 
    L = ['%s=%r' % (key, value)
11216 
      for key, value in self.__dict__.iteritems()]
11217 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11218 
 
11219 
  def __eq__(self, other):
11220 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11221 
 
11222 
  def __ne__(self, other):
11223 
    return not (self == other)
11224 
 
483 rajveer 11225 
class getAllOrders_result:
94 ashish 11226 
  """
11227 
  Attributes:
11228 
   - success
11229 
   - ex
11230 
  """
11231 
 
11232 
  thrift_spec = (
483 rajveer 11233 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
94 ashish 11234 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
11235 
  )
11236 
 
11237 
  def __init__(self, success=None, ex=None,):
11238 
    self.success = success
11239 
    self.ex = ex
11240 
 
11241 
  def read(self, iprot):
11242 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11243 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11244 
      return
11245 
    iprot.readStructBegin()
11246 
    while True:
11247 
      (fname, ftype, fid) = iprot.readFieldBegin()
11248 
      if ftype == TType.STOP:
11249 
        break
11250 
      if fid == 0:
483 rajveer 11251 
        if ftype == TType.LIST:
11252 
          self.success = []
6188 rajveer 11253 
          (_etype130, _size127) = iprot.readListBegin()
11254 
          for _i131 in xrange(_size127):
11255 
            _elem132 = Order()
11256 
            _elem132.read(iprot)
11257 
            self.success.append(_elem132)
483 rajveer 11258 
          iprot.readListEnd()
94 ashish 11259 
        else:
11260 
          iprot.skip(ftype)
11261 
      elif fid == 1:
11262 
        if ftype == TType.STRUCT:
11263 
          self.ex = TransactionServiceException()
11264 
          self.ex.read(iprot)
11265 
        else:
11266 
          iprot.skip(ftype)
11267 
      else:
11268 
        iprot.skip(ftype)
11269 
      iprot.readFieldEnd()
11270 
    iprot.readStructEnd()
11271 
 
11272 
  def write(self, oprot):
11273 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11274 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11275 
      return
483 rajveer 11276 
    oprot.writeStructBegin('getAllOrders_result')
3431 rajveer 11277 
    if self.success is not None:
483 rajveer 11278 
      oprot.writeFieldBegin('success', TType.LIST, 0)
11279 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 11280 
      for iter133 in self.success:
11281 
        iter133.write(oprot)
483 rajveer 11282 
      oprot.writeListEnd()
94 ashish 11283 
      oprot.writeFieldEnd()
3431 rajveer 11284 
    if self.ex is not None:
94 ashish 11285 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11286 
      self.ex.write(oprot)
11287 
      oprot.writeFieldEnd()
11288 
    oprot.writeFieldStop()
11289 
    oprot.writeStructEnd()
11290 
 
3431 rajveer 11291 
  def validate(self):
11292 
    return
11293 
 
11294 
 
94 ashish 11295 
  def __repr__(self):
11296 
    L = ['%s=%r' % (key, value)
11297 
      for key, value in self.__dict__.iteritems()]
11298 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11299 
 
11300 
  def __eq__(self, other):
11301 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11302 
 
11303 
  def __ne__(self, other):
11304 
    return not (self == other)
11305 
 
4133 chandransh 11306 
class getOrdersInBatch_args:
11307 
  """
11308 
  Attributes:
11309 
   - statuses
11310 
   - offset
11311 
   - limit
11312 
   - warehouse_id
11313 
  """
11314 
 
11315 
  thrift_spec = (
11316 
    None, # 0
11317 
    (1, TType.LIST, 'statuses', (TType.I32,None), None, ), # 1
11318 
    (2, TType.I64, 'offset', None, None, ), # 2
11319 
    (3, TType.I64, 'limit', None, None, ), # 3
11320 
    (4, TType.I64, 'warehouse_id', None, None, ), # 4
11321 
  )
11322 
 
11323 
  def __init__(self, statuses=None, offset=None, limit=None, warehouse_id=None,):
11324 
    self.statuses = statuses
11325 
    self.offset = offset
11326 
    self.limit = limit
11327 
    self.warehouse_id = warehouse_id
11328 
 
11329 
  def read(self, iprot):
11330 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11331 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11332 
      return
11333 
    iprot.readStructBegin()
11334 
    while True:
11335 
      (fname, ftype, fid) = iprot.readFieldBegin()
11336 
      if ftype == TType.STOP:
11337 
        break
11338 
      if fid == 1:
11339 
        if ftype == TType.LIST:
11340 
          self.statuses = []
6188 rajveer 11341 
          (_etype137, _size134) = iprot.readListBegin()
11342 
          for _i138 in xrange(_size134):
11343 
            _elem139 = iprot.readI32();
11344 
            self.statuses.append(_elem139)
4133 chandransh 11345 
          iprot.readListEnd()
11346 
        else:
11347 
          iprot.skip(ftype)
11348 
      elif fid == 2:
11349 
        if ftype == TType.I64:
11350 
          self.offset = iprot.readI64();
11351 
        else:
11352 
          iprot.skip(ftype)
11353 
      elif fid == 3:
11354 
        if ftype == TType.I64:
11355 
          self.limit = iprot.readI64();
11356 
        else:
11357 
          iprot.skip(ftype)
11358 
      elif fid == 4:
11359 
        if ftype == TType.I64:
11360 
          self.warehouse_id = iprot.readI64();
11361 
        else:
11362 
          iprot.skip(ftype)
11363 
      else:
11364 
        iprot.skip(ftype)
11365 
      iprot.readFieldEnd()
11366 
    iprot.readStructEnd()
11367 
 
11368 
  def write(self, oprot):
11369 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11370 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11371 
      return
11372 
    oprot.writeStructBegin('getOrdersInBatch_args')
11373 
    if self.statuses is not None:
11374 
      oprot.writeFieldBegin('statuses', TType.LIST, 1)
11375 
      oprot.writeListBegin(TType.I32, len(self.statuses))
6188 rajveer 11376 
      for iter140 in self.statuses:
11377 
        oprot.writeI32(iter140)
4133 chandransh 11378 
      oprot.writeListEnd()
11379 
      oprot.writeFieldEnd()
11380 
    if self.offset is not None:
11381 
      oprot.writeFieldBegin('offset', TType.I64, 2)
11382 
      oprot.writeI64(self.offset)
11383 
      oprot.writeFieldEnd()
11384 
    if self.limit is not None:
11385 
      oprot.writeFieldBegin('limit', TType.I64, 3)
11386 
      oprot.writeI64(self.limit)
11387 
      oprot.writeFieldEnd()
11388 
    if self.warehouse_id is not None:
11389 
      oprot.writeFieldBegin('warehouse_id', TType.I64, 4)
11390 
      oprot.writeI64(self.warehouse_id)
11391 
      oprot.writeFieldEnd()
11392 
    oprot.writeFieldStop()
11393 
    oprot.writeStructEnd()
11394 
 
11395 
  def validate(self):
11396 
    return
11397 
 
11398 
 
11399 
  def __repr__(self):
11400 
    L = ['%s=%r' % (key, value)
11401 
      for key, value in self.__dict__.iteritems()]
11402 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11403 
 
11404 
  def __eq__(self, other):
11405 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11406 
 
11407 
  def __ne__(self, other):
11408 
    return not (self == other)
11409 
 
11410 
class getOrdersInBatch_result:
11411 
  """
11412 
  Attributes:
11413 
   - success
11414 
   - ex
11415 
  """
11416 
 
11417 
  thrift_spec = (
11418 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
11419 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
11420 
  )
11421 
 
11422 
  def __init__(self, success=None, ex=None,):
11423 
    self.success = success
11424 
    self.ex = ex
11425 
 
11426 
  def read(self, iprot):
11427 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11428 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11429 
      return
11430 
    iprot.readStructBegin()
11431 
    while True:
11432 
      (fname, ftype, fid) = iprot.readFieldBegin()
11433 
      if ftype == TType.STOP:
11434 
        break
11435 
      if fid == 0:
11436 
        if ftype == TType.LIST:
11437 
          self.success = []
6188 rajveer 11438 
          (_etype144, _size141) = iprot.readListBegin()
11439 
          for _i145 in xrange(_size141):
11440 
            _elem146 = Order()
11441 
            _elem146.read(iprot)
11442 
            self.success.append(_elem146)
4133 chandransh 11443 
          iprot.readListEnd()
11444 
        else:
11445 
          iprot.skip(ftype)
11446 
      elif fid == 1:
11447 
        if ftype == TType.STRUCT:
11448 
          self.ex = TransactionServiceException()
11449 
          self.ex.read(iprot)
11450 
        else:
11451 
          iprot.skip(ftype)
11452 
      else:
11453 
        iprot.skip(ftype)
11454 
      iprot.readFieldEnd()
11455 
    iprot.readStructEnd()
11456 
 
11457 
  def write(self, oprot):
11458 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11459 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11460 
      return
11461 
    oprot.writeStructBegin('getOrdersInBatch_result')
11462 
    if self.success is not None:
11463 
      oprot.writeFieldBegin('success', TType.LIST, 0)
11464 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 11465 
      for iter147 in self.success:
11466 
        iter147.write(oprot)
4133 chandransh 11467 
      oprot.writeListEnd()
11468 
      oprot.writeFieldEnd()
11469 
    if self.ex is not None:
11470 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11471 
      self.ex.write(oprot)
11472 
      oprot.writeFieldEnd()
11473 
    oprot.writeFieldStop()
11474 
    oprot.writeStructEnd()
11475 
 
11476 
  def validate(self):
11477 
    return
11478 
 
11479 
 
11480 
  def __repr__(self):
11481 
    L = ['%s=%r' % (key, value)
11482 
      for key, value in self.__dict__.iteritems()]
11483 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11484 
 
11485 
  def __eq__(self, other):
11486 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11487 
 
11488 
  def __ne__(self, other):
11489 
    return not (self == other)
11490 
 
11491 
class getOrderCount_args:
11492 
  """
11493 
  Attributes:
11494 
   - statuses
11495 
   - warehouseId
11496 
  """
11497 
 
11498 
  thrift_spec = (
11499 
    None, # 0
11500 
    (1, TType.LIST, 'statuses', (TType.I32,None), None, ), # 1
11501 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
11502 
  )
11503 
 
11504 
  def __init__(self, statuses=None, warehouseId=None,):
11505 
    self.statuses = statuses
11506 
    self.warehouseId = warehouseId
11507 
 
11508 
  def read(self, iprot):
11509 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11510 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11511 
      return
11512 
    iprot.readStructBegin()
11513 
    while True:
11514 
      (fname, ftype, fid) = iprot.readFieldBegin()
11515 
      if ftype == TType.STOP:
11516 
        break
11517 
      if fid == 1:
11518 
        if ftype == TType.LIST:
11519 
          self.statuses = []
6188 rajveer 11520 
          (_etype151, _size148) = iprot.readListBegin()
11521 
          for _i152 in xrange(_size148):
11522 
            _elem153 = iprot.readI32();
11523 
            self.statuses.append(_elem153)
4133 chandransh 11524 
          iprot.readListEnd()
11525 
        else:
11526 
          iprot.skip(ftype)
11527 
      elif fid == 2:
11528 
        if ftype == TType.I64:
11529 
          self.warehouseId = iprot.readI64();
11530 
        else:
11531 
          iprot.skip(ftype)
11532 
      else:
11533 
        iprot.skip(ftype)
11534 
      iprot.readFieldEnd()
11535 
    iprot.readStructEnd()
11536 
 
11537 
  def write(self, oprot):
11538 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11539 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11540 
      return
11541 
    oprot.writeStructBegin('getOrderCount_args')
11542 
    if self.statuses is not None:
11543 
      oprot.writeFieldBegin('statuses', TType.LIST, 1)
11544 
      oprot.writeListBegin(TType.I32, len(self.statuses))
6188 rajveer 11545 
      for iter154 in self.statuses:
11546 
        oprot.writeI32(iter154)
4133 chandransh 11547 
      oprot.writeListEnd()
11548 
      oprot.writeFieldEnd()
11549 
    if self.warehouseId is not None:
11550 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
11551 
      oprot.writeI64(self.warehouseId)
11552 
      oprot.writeFieldEnd()
11553 
    oprot.writeFieldStop()
11554 
    oprot.writeStructEnd()
11555 
 
11556 
  def validate(self):
11557 
    return
11558 
 
11559 
 
11560 
  def __repr__(self):
11561 
    L = ['%s=%r' % (key, value)
11562 
      for key, value in self.__dict__.iteritems()]
11563 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11564 
 
11565 
  def __eq__(self, other):
11566 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11567 
 
11568 
  def __ne__(self, other):
11569 
    return not (self == other)
11570 
 
11571 
class getOrderCount_result:
11572 
  """
11573 
  Attributes:
11574 
   - success
11575 
   - ex
11576 
  """
11577 
 
11578 
  thrift_spec = (
11579 
    (0, TType.I32, 'success', None, None, ), # 0
11580 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
11581 
  )
11582 
 
11583 
  def __init__(self, success=None, ex=None,):
11584 
    self.success = success
11585 
    self.ex = ex
11586 
 
11587 
  def read(self, iprot):
11588 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11589 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11590 
      return
11591 
    iprot.readStructBegin()
11592 
    while True:
11593 
      (fname, ftype, fid) = iprot.readFieldBegin()
11594 
      if ftype == TType.STOP:
11595 
        break
11596 
      if fid == 0:
11597 
        if ftype == TType.I32:
11598 
          self.success = iprot.readI32();
11599 
        else:
11600 
          iprot.skip(ftype)
11601 
      elif fid == 1:
11602 
        if ftype == TType.STRUCT:
11603 
          self.ex = TransactionServiceException()
11604 
          self.ex.read(iprot)
11605 
        else:
11606 
          iprot.skip(ftype)
11607 
      else:
11608 
        iprot.skip(ftype)
11609 
      iprot.readFieldEnd()
11610 
    iprot.readStructEnd()
11611 
 
11612 
  def write(self, oprot):
11613 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11614 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11615 
      return
11616 
    oprot.writeStructBegin('getOrderCount_result')
11617 
    if self.success is not None:
11618 
      oprot.writeFieldBegin('success', TType.I32, 0)
11619 
      oprot.writeI32(self.success)
11620 
      oprot.writeFieldEnd()
11621 
    if self.ex is not None:
11622 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11623 
      self.ex.write(oprot)
11624 
      oprot.writeFieldEnd()
11625 
    oprot.writeFieldStop()
11626 
    oprot.writeStructEnd()
11627 
 
11628 
  def validate(self):
11629 
    return
11630 
 
11631 
 
11632 
  def __repr__(self):
11633 
    L = ['%s=%r' % (key, value)
11634 
      for key, value in self.__dict__.iteritems()]
11635 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11636 
 
11637 
  def __eq__(self, other):
11638 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11639 
 
11640 
  def __ne__(self, other):
11641 
    return not (self == other)
11642 
 
999 varun.gupt 11643 
class getOrdersByBillingDate_args:
11644 
  """
11645 
  Attributes:
11646 
   - status
11647 
   - start_billing_date
11648 
   - end_billing_date
11649 
   - warehouse_id
11650 
  """
11651 
 
11652 
  thrift_spec = (
11653 
    None, # 0
11654 
    (1, TType.I32, 'status', None, None, ), # 1
11655 
    (2, TType.I64, 'start_billing_date', None, None, ), # 2
11656 
    (3, TType.I64, 'end_billing_date', None, None, ), # 3
11657 
    (4, TType.I64, 'warehouse_id', None, None, ), # 4
11658 
  )
11659 
 
11660 
  def __init__(self, status=None, start_billing_date=None, end_billing_date=None, warehouse_id=None,):
11661 
    self.status = status
11662 
    self.start_billing_date = start_billing_date
11663 
    self.end_billing_date = end_billing_date
11664 
    self.warehouse_id = warehouse_id
11665 
 
11666 
  def read(self, iprot):
11667 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11668 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11669 
      return
11670 
    iprot.readStructBegin()
11671 
    while True:
11672 
      (fname, ftype, fid) = iprot.readFieldBegin()
11673 
      if ftype == TType.STOP:
11674 
        break
11675 
      if fid == 1:
11676 
        if ftype == TType.I32:
11677 
          self.status = iprot.readI32();
11678 
        else:
11679 
          iprot.skip(ftype)
11680 
      elif fid == 2:
11681 
        if ftype == TType.I64:
11682 
          self.start_billing_date = iprot.readI64();
11683 
        else:
11684 
          iprot.skip(ftype)
11685 
      elif fid == 3:
11686 
        if ftype == TType.I64:
11687 
          self.end_billing_date = iprot.readI64();
11688 
        else:
11689 
          iprot.skip(ftype)
11690 
      elif fid == 4:
11691 
        if ftype == TType.I64:
11692 
          self.warehouse_id = iprot.readI64();
11693 
        else:
11694 
          iprot.skip(ftype)
11695 
      else:
11696 
        iprot.skip(ftype)
11697 
      iprot.readFieldEnd()
11698 
    iprot.readStructEnd()
11699 
 
11700 
  def write(self, oprot):
11701 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11702 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11703 
      return
11704 
    oprot.writeStructBegin('getOrdersByBillingDate_args')
3431 rajveer 11705 
    if self.status is not None:
999 varun.gupt 11706 
      oprot.writeFieldBegin('status', TType.I32, 1)
11707 
      oprot.writeI32(self.status)
11708 
      oprot.writeFieldEnd()
3431 rajveer 11709 
    if self.start_billing_date is not None:
999 varun.gupt 11710 
      oprot.writeFieldBegin('start_billing_date', TType.I64, 2)
11711 
      oprot.writeI64(self.start_billing_date)
11712 
      oprot.writeFieldEnd()
3431 rajveer 11713 
    if self.end_billing_date is not None:
999 varun.gupt 11714 
      oprot.writeFieldBegin('end_billing_date', TType.I64, 3)
11715 
      oprot.writeI64(self.end_billing_date)
11716 
      oprot.writeFieldEnd()
3431 rajveer 11717 
    if self.warehouse_id is not None:
999 varun.gupt 11718 
      oprot.writeFieldBegin('warehouse_id', TType.I64, 4)
11719 
      oprot.writeI64(self.warehouse_id)
11720 
      oprot.writeFieldEnd()
11721 
    oprot.writeFieldStop()
11722 
    oprot.writeStructEnd()
11723 
 
3431 rajveer 11724 
  def validate(self):
11725 
    return
11726 
 
11727 
 
999 varun.gupt 11728 
  def __repr__(self):
11729 
    L = ['%s=%r' % (key, value)
11730 
      for key, value in self.__dict__.iteritems()]
11731 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11732 
 
11733 
  def __eq__(self, other):
11734 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11735 
 
11736 
  def __ne__(self, other):
11737 
    return not (self == other)
11738 
 
11739 
class getOrdersByBillingDate_result:
11740 
  """
11741 
  Attributes:
11742 
   - success
11743 
   - ex
11744 
  """
11745 
 
11746 
  thrift_spec = (
11747 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
11748 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
11749 
  )
11750 
 
11751 
  def __init__(self, success=None, ex=None,):
11752 
    self.success = success
11753 
    self.ex = ex
11754 
 
11755 
  def read(self, iprot):
11756 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11757 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11758 
      return
11759 
    iprot.readStructBegin()
11760 
    while True:
11761 
      (fname, ftype, fid) = iprot.readFieldBegin()
11762 
      if ftype == TType.STOP:
11763 
        break
11764 
      if fid == 0:
11765 
        if ftype == TType.LIST:
11766 
          self.success = []
6188 rajveer 11767 
          (_etype158, _size155) = iprot.readListBegin()
11768 
          for _i159 in xrange(_size155):
11769 
            _elem160 = Order()
11770 
            _elem160.read(iprot)
11771 
            self.success.append(_elem160)
999 varun.gupt 11772 
          iprot.readListEnd()
11773 
        else:
11774 
          iprot.skip(ftype)
11775 
      elif fid == 1:
11776 
        if ftype == TType.STRUCT:
11777 
          self.ex = TransactionServiceException()
11778 
          self.ex.read(iprot)
11779 
        else:
11780 
          iprot.skip(ftype)
11781 
      else:
11782 
        iprot.skip(ftype)
11783 
      iprot.readFieldEnd()
11784 
    iprot.readStructEnd()
11785 
 
11786 
  def write(self, oprot):
11787 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11788 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11789 
      return
11790 
    oprot.writeStructBegin('getOrdersByBillingDate_result')
3431 rajveer 11791 
    if self.success is not None:
999 varun.gupt 11792 
      oprot.writeFieldBegin('success', TType.LIST, 0)
11793 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 11794 
      for iter161 in self.success:
11795 
        iter161.write(oprot)
999 varun.gupt 11796 
      oprot.writeListEnd()
11797 
      oprot.writeFieldEnd()
3431 rajveer 11798 
    if self.ex is not None:
999 varun.gupt 11799 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11800 
      self.ex.write(oprot)
11801 
      oprot.writeFieldEnd()
11802 
    oprot.writeFieldStop()
11803 
    oprot.writeStructEnd()
11804 
 
3431 rajveer 11805 
  def validate(self):
11806 
    return
11807 
 
11808 
 
999 varun.gupt 11809 
  def __repr__(self):
11810 
    L = ['%s=%r' % (key, value)
11811 
      for key, value in self.__dict__.iteritems()]
11812 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11813 
 
11814 
  def __eq__(self, other):
11815 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11816 
 
11817 
  def __ne__(self, other):
11818 
    return not (self == other)
11819 
 
3427 chandransh 11820 
class getOrdersByShippingDate_args:
11821 
  """
11822 
  Attributes:
11823 
   - fromShippingDate
11824 
   - toShippingDate
11825 
   - providerId
11826 
   - warehouseId
3451 chandransh 11827 
   - cod
3427 chandransh 11828 
  """
11829 
 
11830 
  thrift_spec = (
11831 
    None, # 0
11832 
    (1, TType.I64, 'fromShippingDate', None, None, ), # 1
11833 
    (2, TType.I64, 'toShippingDate', None, None, ), # 2
11834 
    (3, TType.I64, 'providerId', None, None, ), # 3
11835 
    (4, TType.I64, 'warehouseId', None, None, ), # 4
3451 chandransh 11836 
    (5, TType.BOOL, 'cod', None, None, ), # 5
3427 chandransh 11837 
  )
11838 
 
3451 chandransh 11839 
  def __init__(self, fromShippingDate=None, toShippingDate=None, providerId=None, warehouseId=None, cod=None,):
3427 chandransh 11840 
    self.fromShippingDate = fromShippingDate
11841 
    self.toShippingDate = toShippingDate
11842 
    self.providerId = providerId
11843 
    self.warehouseId = warehouseId
3451 chandransh 11844 
    self.cod = cod
3427 chandransh 11845 
 
11846 
  def read(self, iprot):
11847 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11848 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11849 
      return
11850 
    iprot.readStructBegin()
11851 
    while True:
11852 
      (fname, ftype, fid) = iprot.readFieldBegin()
11853 
      if ftype == TType.STOP:
11854 
        break
11855 
      if fid == 1:
11856 
        if ftype == TType.I64:
11857 
          self.fromShippingDate = iprot.readI64();
11858 
        else:
11859 
          iprot.skip(ftype)
11860 
      elif fid == 2:
11861 
        if ftype == TType.I64:
11862 
          self.toShippingDate = iprot.readI64();
11863 
        else:
11864 
          iprot.skip(ftype)
11865 
      elif fid == 3:
11866 
        if ftype == TType.I64:
11867 
          self.providerId = iprot.readI64();
11868 
        else:
11869 
          iprot.skip(ftype)
11870 
      elif fid == 4:
11871 
        if ftype == TType.I64:
11872 
          self.warehouseId = iprot.readI64();
11873 
        else:
11874 
          iprot.skip(ftype)
3451 chandransh 11875 
      elif fid == 5:
11876 
        if ftype == TType.BOOL:
11877 
          self.cod = iprot.readBool();
11878 
        else:
11879 
          iprot.skip(ftype)
3427 chandransh 11880 
      else:
11881 
        iprot.skip(ftype)
11882 
      iprot.readFieldEnd()
11883 
    iprot.readStructEnd()
11884 
 
11885 
  def write(self, oprot):
11886 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11887 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11888 
      return
11889 
    oprot.writeStructBegin('getOrdersByShippingDate_args')
3431 rajveer 11890 
    if self.fromShippingDate is not None:
3427 chandransh 11891 
      oprot.writeFieldBegin('fromShippingDate', TType.I64, 1)
11892 
      oprot.writeI64(self.fromShippingDate)
11893 
      oprot.writeFieldEnd()
3431 rajveer 11894 
    if self.toShippingDate is not None:
3427 chandransh 11895 
      oprot.writeFieldBegin('toShippingDate', TType.I64, 2)
11896 
      oprot.writeI64(self.toShippingDate)
11897 
      oprot.writeFieldEnd()
3431 rajveer 11898 
    if self.providerId is not None:
3427 chandransh 11899 
      oprot.writeFieldBegin('providerId', TType.I64, 3)
11900 
      oprot.writeI64(self.providerId)
11901 
      oprot.writeFieldEnd()
3431 rajveer 11902 
    if self.warehouseId is not None:
3427 chandransh 11903 
      oprot.writeFieldBegin('warehouseId', TType.I64, 4)
11904 
      oprot.writeI64(self.warehouseId)
11905 
      oprot.writeFieldEnd()
3451 chandransh 11906 
    if self.cod is not None:
11907 
      oprot.writeFieldBegin('cod', TType.BOOL, 5)
11908 
      oprot.writeBool(self.cod)
11909 
      oprot.writeFieldEnd()
3427 chandransh 11910 
    oprot.writeFieldStop()
11911 
    oprot.writeStructEnd()
11912 
 
3431 rajveer 11913 
  def validate(self):
11914 
    return
11915 
 
11916 
 
3427 chandransh 11917 
  def __repr__(self):
11918 
    L = ['%s=%r' % (key, value)
11919 
      for key, value in self.__dict__.iteritems()]
11920 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11921 
 
11922 
  def __eq__(self, other):
11923 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11924 
 
11925 
  def __ne__(self, other):
11926 
    return not (self == other)
11927 
 
11928 
class getOrdersByShippingDate_result:
11929 
  """
11930 
  Attributes:
11931 
   - success
11932 
   - ex
11933 
  """
11934 
 
11935 
  thrift_spec = (
11936 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
11937 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
11938 
  )
11939 
 
11940 
  def __init__(self, success=None, ex=None,):
11941 
    self.success = success
11942 
    self.ex = ex
11943 
 
11944 
  def read(self, iprot):
11945 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11946 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11947 
      return
11948 
    iprot.readStructBegin()
11949 
    while True:
11950 
      (fname, ftype, fid) = iprot.readFieldBegin()
11951 
      if ftype == TType.STOP:
11952 
        break
11953 
      if fid == 0:
11954 
        if ftype == TType.LIST:
11955 
          self.success = []
6188 rajveer 11956 
          (_etype165, _size162) = iprot.readListBegin()
11957 
          for _i166 in xrange(_size162):
11958 
            _elem167 = Order()
11959 
            _elem167.read(iprot)
11960 
            self.success.append(_elem167)
3427 chandransh 11961 
          iprot.readListEnd()
11962 
        else:
11963 
          iprot.skip(ftype)
11964 
      elif fid == 1:
11965 
        if ftype == TType.STRUCT:
11966 
          self.ex = TransactionServiceException()
11967 
          self.ex.read(iprot)
11968 
        else:
11969 
          iprot.skip(ftype)
11970 
      else:
11971 
        iprot.skip(ftype)
11972 
      iprot.readFieldEnd()
11973 
    iprot.readStructEnd()
11974 
 
11975 
  def write(self, oprot):
11976 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11977 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11978 
      return
11979 
    oprot.writeStructBegin('getOrdersByShippingDate_result')
3431 rajveer 11980 
    if self.success is not None:
3427 chandransh 11981 
      oprot.writeFieldBegin('success', TType.LIST, 0)
11982 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 11983 
      for iter168 in self.success:
11984 
        iter168.write(oprot)
3427 chandransh 11985 
      oprot.writeListEnd()
11986 
      oprot.writeFieldEnd()
3431 rajveer 11987 
    if self.ex is not None:
3427 chandransh 11988 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11989 
      self.ex.write(oprot)
11990 
      oprot.writeFieldEnd()
11991 
    oprot.writeFieldStop()
11992 
    oprot.writeStructEnd()
11993 
 
3431 rajveer 11994 
  def validate(self):
11995 
    return
11996 
 
11997 
 
3427 chandransh 11998 
  def __repr__(self):
11999 
    L = ['%s=%r' % (key, value)
12000 
      for key, value in self.__dict__.iteritems()]
12001 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12002 
 
12003 
  def __eq__(self, other):
12004 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12005 
 
12006 
  def __ne__(self, other):
12007 
    return not (self == other)
12008 
 
1382 varun.gupt 12009 
class getReturnableOrdersForCustomer_args:
12010 
  """
12011 
  Attributes:
12012 
   - customer_id
12013 
   - limit
12014 
  """
12015 
 
12016 
  thrift_spec = (
12017 
    None, # 0
12018 
    (1, TType.I64, 'customer_id', None, None, ), # 1
12019 
    (2, TType.I64, 'limit', None, None, ), # 2
12020 
  )
12021 
 
12022 
  def __init__(self, customer_id=None, limit=None,):
12023 
    self.customer_id = customer_id
12024 
    self.limit = limit
12025 
 
12026 
  def read(self, iprot):
12027 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12028 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12029 
      return
12030 
    iprot.readStructBegin()
12031 
    while True:
12032 
      (fname, ftype, fid) = iprot.readFieldBegin()
12033 
      if ftype == TType.STOP:
12034 
        break
12035 
      if fid == 1:
12036 
        if ftype == TType.I64:
12037 
          self.customer_id = iprot.readI64();
12038 
        else:
12039 
          iprot.skip(ftype)
12040 
      elif fid == 2:
12041 
        if ftype == TType.I64:
12042 
          self.limit = iprot.readI64();
12043 
        else:
12044 
          iprot.skip(ftype)
12045 
      else:
12046 
        iprot.skip(ftype)
12047 
      iprot.readFieldEnd()
12048 
    iprot.readStructEnd()
12049 
 
12050 
  def write(self, oprot):
12051 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12052 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12053 
      return
12054 
    oprot.writeStructBegin('getReturnableOrdersForCustomer_args')
3431 rajveer 12055 
    if self.customer_id is not None:
1382 varun.gupt 12056 
      oprot.writeFieldBegin('customer_id', TType.I64, 1)
12057 
      oprot.writeI64(self.customer_id)
12058 
      oprot.writeFieldEnd()
3431 rajveer 12059 
    if self.limit is not None:
1382 varun.gupt 12060 
      oprot.writeFieldBegin('limit', TType.I64, 2)
12061 
      oprot.writeI64(self.limit)
12062 
      oprot.writeFieldEnd()
12063 
    oprot.writeFieldStop()
12064 
    oprot.writeStructEnd()
12065 
 
3431 rajveer 12066 
  def validate(self):
12067 
    return
12068 
 
12069 
 
1382 varun.gupt 12070 
  def __repr__(self):
12071 
    L = ['%s=%r' % (key, value)
12072 
      for key, value in self.__dict__.iteritems()]
12073 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12074 
 
12075 
  def __eq__(self, other):
12076 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12077 
 
12078 
  def __ne__(self, other):
12079 
    return not (self == other)
12080 
 
12081 
class getReturnableOrdersForCustomer_result:
12082 
  """
12083 
  Attributes:
12084 
   - success
12085 
   - ex
12086 
  """
12087 
 
12088 
  thrift_spec = (
12089 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
12090 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
12091 
  )
12092 
 
12093 
  def __init__(self, success=None, ex=None,):
12094 
    self.success = success
12095 
    self.ex = ex
12096 
 
12097 
  def read(self, iprot):
12098 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12099 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12100 
      return
12101 
    iprot.readStructBegin()
12102 
    while True:
12103 
      (fname, ftype, fid) = iprot.readFieldBegin()
12104 
      if ftype == TType.STOP:
12105 
        break
12106 
      if fid == 0:
12107 
        if ftype == TType.LIST:
12108 
          self.success = []
6188 rajveer 12109 
          (_etype172, _size169) = iprot.readListBegin()
12110 
          for _i173 in xrange(_size169):
12111 
            _elem174 = iprot.readI64();
12112 
            self.success.append(_elem174)
1382 varun.gupt 12113 
          iprot.readListEnd()
12114 
        else:
12115 
          iprot.skip(ftype)
12116 
      elif fid == 1:
12117 
        if ftype == TType.STRUCT:
12118 
          self.ex = TransactionServiceException()
12119 
          self.ex.read(iprot)
12120 
        else:
12121 
          iprot.skip(ftype)
12122 
      else:
12123 
        iprot.skip(ftype)
12124 
      iprot.readFieldEnd()
12125 
    iprot.readStructEnd()
12126 
 
12127 
  def write(self, oprot):
12128 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12129 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12130 
      return
12131 
    oprot.writeStructBegin('getReturnableOrdersForCustomer_result')
3431 rajveer 12132 
    if self.success is not None:
1382 varun.gupt 12133 
      oprot.writeFieldBegin('success', TType.LIST, 0)
12134 
      oprot.writeListBegin(TType.I64, len(self.success))
6188 rajveer 12135 
      for iter175 in self.success:
12136 
        oprot.writeI64(iter175)
1382 varun.gupt 12137 
      oprot.writeListEnd()
12138 
      oprot.writeFieldEnd()
3431 rajveer 12139 
    if self.ex is not None:
1382 varun.gupt 12140 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
12141 
      self.ex.write(oprot)
12142 
      oprot.writeFieldEnd()
12143 
    oprot.writeFieldStop()
12144 
    oprot.writeStructEnd()
12145 
 
3431 rajveer 12146 
  def validate(self):
12147 
    return
12148 
 
12149 
 
1382 varun.gupt 12150 
  def __repr__(self):
12151 
    L = ['%s=%r' % (key, value)
12152 
      for key, value in self.__dict__.iteritems()]
12153 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12154 
 
12155 
  def __eq__(self, other):
12156 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12157 
 
12158 
  def __ne__(self, other):
12159 
    return not (self == other)
12160 
 
12161 
class getCancellableOrdersForCustomer_args:
12162 
  """
12163 
  Attributes:
12164 
   - customer_id
12165 
   - limit
12166 
  """
12167 
 
12168 
  thrift_spec = (
12169 
    None, # 0
12170 
    (1, TType.I64, 'customer_id', None, None, ), # 1
12171 
    (2, TType.I64, 'limit', None, None, ), # 2
12172 
  )
12173 
 
12174 
  def __init__(self, customer_id=None, limit=None,):
12175 
    self.customer_id = customer_id
12176 
    self.limit = limit
12177 
 
12178 
  def read(self, iprot):
12179 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12180 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12181 
      return
12182 
    iprot.readStructBegin()
12183 
    while True:
12184 
      (fname, ftype, fid) = iprot.readFieldBegin()
12185 
      if ftype == TType.STOP:
12186 
        break
12187 
      if fid == 1:
12188 
        if ftype == TType.I64:
12189 
          self.customer_id = iprot.readI64();
12190 
        else:
12191 
          iprot.skip(ftype)
12192 
      elif fid == 2:
12193 
        if ftype == TType.I64:
12194 
          self.limit = iprot.readI64();
12195 
        else:
12196 
          iprot.skip(ftype)
12197 
      else:
12198 
        iprot.skip(ftype)
12199 
      iprot.readFieldEnd()
12200 
    iprot.readStructEnd()
12201 
 
12202 
  def write(self, oprot):
12203 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12204 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12205 
      return
12206 
    oprot.writeStructBegin('getCancellableOrdersForCustomer_args')
3431 rajveer 12207 
    if self.customer_id is not None:
1382 varun.gupt 12208 
      oprot.writeFieldBegin('customer_id', TType.I64, 1)
12209 
      oprot.writeI64(self.customer_id)
12210 
      oprot.writeFieldEnd()
3431 rajveer 12211 
    if self.limit is not None:
1382 varun.gupt 12212 
      oprot.writeFieldBegin('limit', TType.I64, 2)
12213 
      oprot.writeI64(self.limit)
12214 
      oprot.writeFieldEnd()
12215 
    oprot.writeFieldStop()
12216 
    oprot.writeStructEnd()
12217 
 
3431 rajveer 12218 
  def validate(self):
12219 
    return
12220 
 
12221 
 
1382 varun.gupt 12222 
  def __repr__(self):
12223 
    L = ['%s=%r' % (key, value)
12224 
      for key, value in self.__dict__.iteritems()]
12225 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12226 
 
12227 
  def __eq__(self, other):
12228 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12229 
 
12230 
  def __ne__(self, other):
12231 
    return not (self == other)
12232 
 
12233 
class getCancellableOrdersForCustomer_result:
12234 
  """
12235 
  Attributes:
12236 
   - success
12237 
   - ex
12238 
  """
12239 
 
12240 
  thrift_spec = (
12241 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
12242 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
12243 
  )
12244 
 
12245 
  def __init__(self, success=None, ex=None,):
12246 
    self.success = success
12247 
    self.ex = ex
12248 
 
12249 
  def read(self, iprot):
12250 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12251 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12252 
      return
12253 
    iprot.readStructBegin()
12254 
    while True:
12255 
      (fname, ftype, fid) = iprot.readFieldBegin()
12256 
      if ftype == TType.STOP:
12257 
        break
12258 
      if fid == 0:
12259 
        if ftype == TType.LIST:
12260 
          self.success = []
6188 rajveer 12261 
          (_etype179, _size176) = iprot.readListBegin()
12262 
          for _i180 in xrange(_size176):
12263 
            _elem181 = iprot.readI64();
12264 
            self.success.append(_elem181)
1382 varun.gupt 12265 
          iprot.readListEnd()
12266 
        else:
12267 
          iprot.skip(ftype)
12268 
      elif fid == 1:
12269 
        if ftype == TType.STRUCT:
12270 
          self.ex = TransactionServiceException()
12271 
          self.ex.read(iprot)
12272 
        else:
12273 
          iprot.skip(ftype)
12274 
      else:
12275 
        iprot.skip(ftype)
12276 
      iprot.readFieldEnd()
12277 
    iprot.readStructEnd()
12278 
 
12279 
  def write(self, oprot):
12280 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12281 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12282 
      return
12283 
    oprot.writeStructBegin('getCancellableOrdersForCustomer_result')
3431 rajveer 12284 
    if self.success is not None:
1382 varun.gupt 12285 
      oprot.writeFieldBegin('success', TType.LIST, 0)
12286 
      oprot.writeListBegin(TType.I64, len(self.success))
6188 rajveer 12287 
      for iter182 in self.success:
12288 
        oprot.writeI64(iter182)
1382 varun.gupt 12289 
      oprot.writeListEnd()
12290 
      oprot.writeFieldEnd()
3431 rajveer 12291 
    if self.ex is not None:
1382 varun.gupt 12292 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
12293 
      self.ex.write(oprot)
12294 
      oprot.writeFieldEnd()
12295 
    oprot.writeFieldStop()
12296 
    oprot.writeStructEnd()
12297 
 
3431 rajveer 12298 
  def validate(self):
12299 
    return
12300 
 
12301 
 
1382 varun.gupt 12302 
  def __repr__(self):
12303 
    L = ['%s=%r' % (key, value)
12304 
      for key, value in self.__dict__.iteritems()]
12305 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12306 
 
12307 
  def __eq__(self, other):
12308 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12309 
 
12310 
  def __ne__(self, other):
12311 
    return not (self == other)
12312 
 
483 rajveer 12313 
class changeOrderStatus_args:
94 ashish 12314 
  """
12315 
  Attributes:
483 rajveer 12316 
   - orderId
12317 
   - status
12318 
   - description
94 ashish 12319 
  """
12320 
 
12321 
  thrift_spec = (
12322 
    None, # 0
483 rajveer 12323 
    (1, TType.I64, 'orderId', None, None, ), # 1
12324 
    (2, TType.I32, 'status', None, None, ), # 2
12325 
    (3, TType.STRING, 'description', None, None, ), # 3
94 ashish 12326 
  )
12327 
 
483 rajveer 12328 
  def __init__(self, orderId=None, status=None, description=None,):
12329 
    self.orderId = orderId
12330 
    self.status = status
12331 
    self.description = description
94 ashish 12332 
 
12333 
  def read(self, iprot):
12334 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12335 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12336 
      return
12337 
    iprot.readStructBegin()
12338 
    while True:
12339 
      (fname, ftype, fid) = iprot.readFieldBegin()
12340 
      if ftype == TType.STOP:
12341 
        break
12342 
      if fid == 1:
12343 
        if ftype == TType.I64:
483 rajveer 12344 
          self.orderId = iprot.readI64();
94 ashish 12345 
        else:
12346 
          iprot.skip(ftype)
12347 
      elif fid == 2:
483 rajveer 12348 
        if ftype == TType.I32:
12349 
          self.status = iprot.readI32();
94 ashish 12350 
        else:
12351 
          iprot.skip(ftype)
483 rajveer 12352 
      elif fid == 3:
12353 
        if ftype == TType.STRING:
12354 
          self.description = iprot.readString();
12355 
        else:
12356 
          iprot.skip(ftype)
94 ashish 12357 
      else:
12358 
        iprot.skip(ftype)
12359 
      iprot.readFieldEnd()
12360 
    iprot.readStructEnd()
12361 
 
12362 
  def write(self, oprot):
12363 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12364 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12365 
      return
483 rajveer 12366 
    oprot.writeStructBegin('changeOrderStatus_args')
3431 rajveer 12367 
    if self.orderId is not None:
483 rajveer 12368 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
12369 
      oprot.writeI64(self.orderId)
94 ashish 12370 
      oprot.writeFieldEnd()
3431 rajveer 12371 
    if self.status is not None:
483 rajveer 12372 
      oprot.writeFieldBegin('status', TType.I32, 2)
12373 
      oprot.writeI32(self.status)
94 ashish 12374 
      oprot.writeFieldEnd()
3431 rajveer 12375 
    if self.description is not None:
483 rajveer 12376 
      oprot.writeFieldBegin('description', TType.STRING, 3)
12377 
      oprot.writeString(self.description)
12378 
      oprot.writeFieldEnd()
94 ashish 12379 
    oprot.writeFieldStop()
12380 
    oprot.writeStructEnd()
12381 
 
3431 rajveer 12382 
  def validate(self):
12383 
    return
12384 
 
12385 
 
94 ashish 12386 
  def __repr__(self):
12387 
    L = ['%s=%r' % (key, value)
12388 
      for key, value in self.__dict__.iteritems()]
12389 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12390 
 
12391 
  def __eq__(self, other):
12392 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12393 
 
12394 
  def __ne__(self, other):
12395 
    return not (self == other)
12396 
 
483 rajveer 12397 
class changeOrderStatus_result:
94 ashish 12398 
  """
12399 
  Attributes:
12400 
   - success
12401 
   - ex
12402 
  """
12403 
 
12404 
  thrift_spec = (
12405 
    (0, TType.BOOL, 'success', None, None, ), # 0
12406 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
12407 
  )
12408 
 
12409 
  def __init__(self, success=None, ex=None,):
12410 
    self.success = success
12411 
    self.ex = ex
12412 
 
12413 
  def read(self, iprot):
12414 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12415 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12416 
      return
12417 
    iprot.readStructBegin()
12418 
    while True:
12419 
      (fname, ftype, fid) = iprot.readFieldBegin()
12420 
      if ftype == TType.STOP:
12421 
        break
12422 
      if fid == 0:
12423 
        if ftype == TType.BOOL:
12424 
          self.success = iprot.readBool();
12425 
        else:
12426 
          iprot.skip(ftype)
12427 
      elif fid == 1:
12428 
        if ftype == TType.STRUCT:
12429 
          self.ex = TransactionServiceException()
12430 
          self.ex.read(iprot)
12431 
        else:
12432 
          iprot.skip(ftype)
12433 
      else:
12434 
        iprot.skip(ftype)
12435 
      iprot.readFieldEnd()
12436 
    iprot.readStructEnd()
12437 
 
12438 
  def write(self, oprot):
12439 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12440 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12441 
      return
483 rajveer 12442 
    oprot.writeStructBegin('changeOrderStatus_result')
3431 rajveer 12443 
    if self.success is not None:
94 ashish 12444 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
12445 
      oprot.writeBool(self.success)
12446 
      oprot.writeFieldEnd()
3431 rajveer 12447 
    if self.ex is not None:
94 ashish 12448 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
12449 
      self.ex.write(oprot)
12450 
      oprot.writeFieldEnd()
12451 
    oprot.writeFieldStop()
12452 
    oprot.writeStructEnd()
12453 
 
3431 rajveer 12454 
  def validate(self):
12455 
    return
12456 
 
12457 
 
94 ashish 12458 
  def __repr__(self):
12459 
    L = ['%s=%r' % (key, value)
12460 
      for key, value in self.__dict__.iteritems()]
12461 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12462 
 
12463 
  def __eq__(self, other):
12464 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12465 
 
12466 
  def __ne__(self, other):
12467 
    return not (self == other)
12468 
 
3064 chandransh 12469 
class getOrdersForTransaction_args:
494 rajveer 12470 
  """
12471 
  Attributes:
3064 chandransh 12472 
   - transactionId
12473 
   - customerId
494 rajveer 12474 
  """
12475 
 
12476 
  thrift_spec = (
12477 
    None, # 0
3064 chandransh 12478 
    (1, TType.I64, 'transactionId', None, None, ), # 1
12479 
    (2, TType.I64, 'customerId', None, None, ), # 2
494 rajveer 12480 
  )
12481 
 
3064 chandransh 12482 
  def __init__(self, transactionId=None, customerId=None,):
12483 
    self.transactionId = transactionId
12484 
    self.customerId = customerId
494 rajveer 12485 
 
12486 
  def read(self, iprot):
12487 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12488 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12489 
      return
12490 
    iprot.readStructBegin()
12491 
    while True:
12492 
      (fname, ftype, fid) = iprot.readFieldBegin()
12493 
      if ftype == TType.STOP:
12494 
        break
12495 
      if fid == 1:
12496 
        if ftype == TType.I64:
3064 chandransh 12497 
          self.transactionId = iprot.readI64();
494 rajveer 12498 
        else:
12499 
          iprot.skip(ftype)
12500 
      elif fid == 2:
3064 chandransh 12501 
        if ftype == TType.I64:
12502 
          self.customerId = iprot.readI64();
494 rajveer 12503 
        else:
12504 
          iprot.skip(ftype)
12505 
      else:
12506 
        iprot.skip(ftype)
12507 
      iprot.readFieldEnd()
12508 
    iprot.readStructEnd()
12509 
 
12510 
  def write(self, oprot):
12511 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12512 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12513 
      return
3064 chandransh 12514 
    oprot.writeStructBegin('getOrdersForTransaction_args')
3431 rajveer 12515 
    if self.transactionId is not None:
3064 chandransh 12516 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
12517 
      oprot.writeI64(self.transactionId)
494 rajveer 12518 
      oprot.writeFieldEnd()
3431 rajveer 12519 
    if self.customerId is not None:
3064 chandransh 12520 
      oprot.writeFieldBegin('customerId', TType.I64, 2)
12521 
      oprot.writeI64(self.customerId)
494 rajveer 12522 
      oprot.writeFieldEnd()
12523 
    oprot.writeFieldStop()
12524 
    oprot.writeStructEnd()
12525 
 
3431 rajveer 12526 
  def validate(self):
12527 
    return
12528 
 
12529 
 
494 rajveer 12530 
  def __repr__(self):
12531 
    L = ['%s=%r' % (key, value)
12532 
      for key, value in self.__dict__.iteritems()]
12533 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12534 
 
12535 
  def __eq__(self, other):
12536 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12537 
 
12538 
  def __ne__(self, other):
12539 
    return not (self == other)
12540 
 
3064 chandransh 12541 
class getOrdersForTransaction_result:
494 rajveer 12542 
  """
12543 
  Attributes:
12544 
   - success
12545 
   - ex
12546 
  """
12547 
 
12548 
  thrift_spec = (
3064 chandransh 12549 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
494 rajveer 12550 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
12551 
  )
12552 
 
12553 
  def __init__(self, success=None, ex=None,):
12554 
    self.success = success
12555 
    self.ex = ex
12556 
 
12557 
  def read(self, iprot):
12558 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12559 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12560 
      return
12561 
    iprot.readStructBegin()
12562 
    while True:
12563 
      (fname, ftype, fid) = iprot.readFieldBegin()
12564 
      if ftype == TType.STOP:
12565 
        break
12566 
      if fid == 0:
3064 chandransh 12567 
        if ftype == TType.LIST:
12568 
          self.success = []
6188 rajveer 12569 
          (_etype186, _size183) = iprot.readListBegin()
12570 
          for _i187 in xrange(_size183):
12571 
            _elem188 = Order()
12572 
            _elem188.read(iprot)
12573 
            self.success.append(_elem188)
3064 chandransh 12574 
          iprot.readListEnd()
494 rajveer 12575 
        else:
12576 
          iprot.skip(ftype)
12577 
      elif fid == 1:
12578 
        if ftype == TType.STRUCT:
12579 
          self.ex = TransactionServiceException()
12580 
          self.ex.read(iprot)
12581 
        else:
12582 
          iprot.skip(ftype)
12583 
      else:
12584 
        iprot.skip(ftype)
12585 
      iprot.readFieldEnd()
12586 
    iprot.readStructEnd()
12587 
 
12588 
  def write(self, oprot):
12589 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12590 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12591 
      return
3064 chandransh 12592 
    oprot.writeStructBegin('getOrdersForTransaction_result')
3431 rajveer 12593 
    if self.success is not None:
3064 chandransh 12594 
      oprot.writeFieldBegin('success', TType.LIST, 0)
12595 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 12596 
      for iter189 in self.success:
12597 
        iter189.write(oprot)
3064 chandransh 12598 
      oprot.writeListEnd()
494 rajveer 12599 
      oprot.writeFieldEnd()
3431 rajveer 12600 
    if self.ex is not None:
494 rajveer 12601 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
12602 
      self.ex.write(oprot)
12603 
      oprot.writeFieldEnd()
12604 
    oprot.writeFieldStop()
12605 
    oprot.writeStructEnd()
12606 
 
3431 rajveer 12607 
  def validate(self):
12608 
    return
12609 
 
12610 
 
494 rajveer 12611 
  def __repr__(self):
12612 
    L = ['%s=%r' % (key, value)
12613 
      for key, value in self.__dict__.iteritems()]
12614 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12615 
 
12616 
  def __eq__(self, other):
12617 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12618 
 
12619 
  def __ne__(self, other):
12620 
    return not (self == other)
12621 
 
3064 chandransh 12622 
class getOrdersForCustomer_args:
1149 chandransh 12623 
  """
12624 
  Attributes:
3064 chandransh 12625 
   - customerId
12626 
   - from_date
12627 
   - to_date
12628 
   - statuses
1149 chandransh 12629 
  """
12630 
 
12631 
  thrift_spec = (
12632 
    None, # 0
3064 chandransh 12633 
    (1, TType.I64, 'customerId', None, None, ), # 1
12634 
    (2, TType.I64, 'from_date', None, None, ), # 2
12635 
    (3, TType.I64, 'to_date', None, None, ), # 3
12636 
    (4, TType.LIST, 'statuses', (TType.I32,None), None, ), # 4
1149 chandransh 12637 
  )
12638 
 
3064 chandransh 12639 
  def __init__(self, customerId=None, from_date=None, to_date=None, statuses=None,):
12640 
    self.customerId = customerId
12641 
    self.from_date = from_date
12642 
    self.to_date = to_date
12643 
    self.statuses = statuses
1149 chandransh 12644 
 
12645 
  def read(self, iprot):
12646 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12647 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12648 
      return
12649 
    iprot.readStructBegin()
12650 
    while True:
12651 
      (fname, ftype, fid) = iprot.readFieldBegin()
12652 
      if ftype == TType.STOP:
12653 
        break
12654 
      if fid == 1:
12655 
        if ftype == TType.I64:
3064 chandransh 12656 
          self.customerId = iprot.readI64();
1149 chandransh 12657 
        else:
12658 
          iprot.skip(ftype)
12659 
      elif fid == 2:
12660 
        if ftype == TType.I64:
3064 chandransh 12661 
          self.from_date = iprot.readI64();
1149 chandransh 12662 
        else:
12663 
          iprot.skip(ftype)
2783 chandransh 12664 
      elif fid == 3:
12665 
        if ftype == TType.I64:
3064 chandransh 12666 
          self.to_date = iprot.readI64();
2783 chandransh 12667 
        else:
12668 
          iprot.skip(ftype)
12669 
      elif fid == 4:
3064 chandransh 12670 
        if ftype == TType.LIST:
12671 
          self.statuses = []
6188 rajveer 12672 
          (_etype193, _size190) = iprot.readListBegin()
12673 
          for _i194 in xrange(_size190):
12674 
            _elem195 = iprot.readI32();
12675 
            self.statuses.append(_elem195)
3064 chandransh 12676 
          iprot.readListEnd()
2783 chandransh 12677 
        else:
12678 
          iprot.skip(ftype)
1149 chandransh 12679 
      else:
12680 
        iprot.skip(ftype)
12681 
      iprot.readFieldEnd()
12682 
    iprot.readStructEnd()
12683 
 
12684 
  def write(self, oprot):
12685 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12686 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12687 
      return
3064 chandransh 12688 
    oprot.writeStructBegin('getOrdersForCustomer_args')
3431 rajveer 12689 
    if self.customerId is not None:
3064 chandransh 12690 
      oprot.writeFieldBegin('customerId', TType.I64, 1)
12691 
      oprot.writeI64(self.customerId)
1149 chandransh 12692 
      oprot.writeFieldEnd()
3431 rajveer 12693 
    if self.from_date is not None:
3064 chandransh 12694 
      oprot.writeFieldBegin('from_date', TType.I64, 2)
12695 
      oprot.writeI64(self.from_date)
1149 chandransh 12696 
      oprot.writeFieldEnd()
3431 rajveer 12697 
    if self.to_date is not None:
3064 chandransh 12698 
      oprot.writeFieldBegin('to_date', TType.I64, 3)
12699 
      oprot.writeI64(self.to_date)
2783 chandransh 12700 
      oprot.writeFieldEnd()
3431 rajveer 12701 
    if self.statuses is not None:
3064 chandransh 12702 
      oprot.writeFieldBegin('statuses', TType.LIST, 4)
12703 
      oprot.writeListBegin(TType.I32, len(self.statuses))
6188 rajveer 12704 
      for iter196 in self.statuses:
12705 
        oprot.writeI32(iter196)
3064 chandransh 12706 
      oprot.writeListEnd()
2783 chandransh 12707 
      oprot.writeFieldEnd()
1149 chandransh 12708 
    oprot.writeFieldStop()
12709 
    oprot.writeStructEnd()
12710 
 
3431 rajveer 12711 
  def validate(self):
12712 
    return
12713 
 
12714 
 
1149 chandransh 12715 
  def __repr__(self):
12716 
    L = ['%s=%r' % (key, value)
12717 
      for key, value in self.__dict__.iteritems()]
12718 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12719 
 
12720 
  def __eq__(self, other):
12721 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12722 
 
12723 
  def __ne__(self, other):
12724 
    return not (self == other)
12725 
 
3064 chandransh 12726 
class getOrdersForCustomer_result:
1149 chandransh 12727 
  """
12728 
  Attributes:
12729 
   - success
12730 
   - ex
12731 
  """
12732 
 
12733 
  thrift_spec = (
3064 chandransh 12734 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
1149 chandransh 12735 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
12736 
  )
12737 
 
12738 
  def __init__(self, success=None, ex=None,):
12739 
    self.success = success
12740 
    self.ex = ex
12741 
 
12742 
  def read(self, iprot):
12743 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12744 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12745 
      return
12746 
    iprot.readStructBegin()
12747 
    while True:
12748 
      (fname, ftype, fid) = iprot.readFieldBegin()
12749 
      if ftype == TType.STOP:
12750 
        break
12751 
      if fid == 0:
3064 chandransh 12752 
        if ftype == TType.LIST:
12753 
          self.success = []
6188 rajveer 12754 
          (_etype200, _size197) = iprot.readListBegin()
12755 
          for _i201 in xrange(_size197):
12756 
            _elem202 = Order()
12757 
            _elem202.read(iprot)
12758 
            self.success.append(_elem202)
3064 chandransh 12759 
          iprot.readListEnd()
1149 chandransh 12760 
        else:
12761 
          iprot.skip(ftype)
12762 
      elif fid == 1:
12763 
        if ftype == TType.STRUCT:
12764 
          self.ex = TransactionServiceException()
12765 
          self.ex.read(iprot)
12766 
        else:
12767 
          iprot.skip(ftype)
12768 
      else:
12769 
        iprot.skip(ftype)
12770 
      iprot.readFieldEnd()
12771 
    iprot.readStructEnd()
12772 
 
12773 
  def write(self, oprot):
12774 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12775 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12776 
      return
3064 chandransh 12777 
    oprot.writeStructBegin('getOrdersForCustomer_result')
3431 rajveer 12778 
    if self.success is not None:
3064 chandransh 12779 
      oprot.writeFieldBegin('success', TType.LIST, 0)
12780 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 12781 
      for iter203 in self.success:
12782 
        iter203.write(oprot)
3064 chandransh 12783 
      oprot.writeListEnd()
1149 chandransh 12784 
      oprot.writeFieldEnd()
3431 rajveer 12785 
    if self.ex is not None:
1149 chandransh 12786 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
12787 
      self.ex.write(oprot)
12788 
      oprot.writeFieldEnd()
12789 
    oprot.writeFieldStop()
12790 
    oprot.writeStructEnd()
12791 
 
3431 rajveer 12792 
  def validate(self):
12793 
    return
12794 
 
12795 
 
1149 chandransh 12796 
  def __repr__(self):
12797 
    L = ['%s=%r' % (key, value)
12798 
      for key, value in self.__dict__.iteritems()]
12799 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12800 
 
12801 
  def __eq__(self, other):
12802 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12803 
 
12804 
  def __ne__(self, other):
12805 
    return not (self == other)
12806 
 
3064 chandransh 12807 
class createOrder_args:
921 rajveer 12808 
  """
12809 
  Attributes:
3064 chandransh 12810 
   - order
921 rajveer 12811 
  """
12812 
 
12813 
  thrift_spec = (
12814 
    None, # 0
3064 chandransh 12815 
    (1, TType.STRUCT, 'order', (Order, Order.thrift_spec), None, ), # 1
921 rajveer 12816 
  )
12817 
 
3064 chandransh 12818 
  def __init__(self, order=None,):
12819 
    self.order = order
921 rajveer 12820 
 
12821 
  def read(self, iprot):
12822 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12823 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12824 
      return
12825 
    iprot.readStructBegin()
12826 
    while True:
12827 
      (fname, ftype, fid) = iprot.readFieldBegin()
12828 
      if ftype == TType.STOP:
12829 
        break
12830 
      if fid == 1:
3064 chandransh 12831 
        if ftype == TType.STRUCT:
12832 
          self.order = Order()
12833 
          self.order.read(iprot)
921 rajveer 12834 
        else:
12835 
          iprot.skip(ftype)
12836 
      else:
12837 
        iprot.skip(ftype)
12838 
      iprot.readFieldEnd()
12839 
    iprot.readStructEnd()
12840 
 
12841 
  def write(self, oprot):
12842 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12843 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12844 
      return
3064 chandransh 12845 
    oprot.writeStructBegin('createOrder_args')
3431 rajveer 12846 
    if self.order is not None:
3064 chandransh 12847 
      oprot.writeFieldBegin('order', TType.STRUCT, 1)
12848 
      self.order.write(oprot)
921 rajveer 12849 
      oprot.writeFieldEnd()
12850 
    oprot.writeFieldStop()
12851 
    oprot.writeStructEnd()
12852 
 
3431 rajveer 12853 
  def validate(self):
12854 
    return
12855 
 
12856 
 
921 rajveer 12857 
  def __repr__(self):
12858 
    L = ['%s=%r' % (key, value)
12859 
      for key, value in self.__dict__.iteritems()]
12860 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12861 
 
12862 
  def __eq__(self, other):
12863 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12864 
 
12865 
  def __ne__(self, other):
12866 
    return not (self == other)
12867 
 
3064 chandransh 12868 
class createOrder_result:
921 rajveer 12869 
  """
12870 
  Attributes:
12871 
   - success
12872 
   - ex
12873 
  """
12874 
 
12875 
  thrift_spec = (
3064 chandransh 12876 
    (0, TType.I64, 'success', None, None, ), # 0
921 rajveer 12877 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
12878 
  )
12879 
 
12880 
  def __init__(self, success=None, ex=None,):
12881 
    self.success = success
12882 
    self.ex = ex
12883 
 
12884 
  def read(self, iprot):
12885 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12886 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12887 
      return
12888 
    iprot.readStructBegin()
12889 
    while True:
12890 
      (fname, ftype, fid) = iprot.readFieldBegin()
12891 
      if ftype == TType.STOP:
12892 
        break
12893 
      if fid == 0:
3064 chandransh 12894 
        if ftype == TType.I64:
12895 
          self.success = iprot.readI64();
921 rajveer 12896 
        else:
12897 
          iprot.skip(ftype)
12898 
      elif fid == 1:
12899 
        if ftype == TType.STRUCT:
12900 
          self.ex = TransactionServiceException()
12901 
          self.ex.read(iprot)
12902 
        else:
12903 
          iprot.skip(ftype)
12904 
      else:
12905 
        iprot.skip(ftype)
12906 
      iprot.readFieldEnd()
12907 
    iprot.readStructEnd()
12908 
 
12909 
  def write(self, oprot):
12910 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12911 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12912 
      return
3064 chandransh 12913 
    oprot.writeStructBegin('createOrder_result')
3431 rajveer 12914 
    if self.success is not None:
3064 chandransh 12915 
      oprot.writeFieldBegin('success', TType.I64, 0)
12916 
      oprot.writeI64(self.success)
921 rajveer 12917 
      oprot.writeFieldEnd()
3431 rajveer 12918 
    if self.ex is not None:
921 rajveer 12919 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
12920 
      self.ex.write(oprot)
12921 
      oprot.writeFieldEnd()
12922 
    oprot.writeFieldStop()
12923 
    oprot.writeStructEnd()
12924 
 
3431 rajveer 12925 
  def validate(self):
12926 
    return
12927 
 
12928 
 
921 rajveer 12929 
  def __repr__(self):
12930 
    L = ['%s=%r' % (key, value)
12931 
      for key, value in self.__dict__.iteritems()]
12932 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12933 
 
12934 
  def __eq__(self, other):
12935 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12936 
 
12937 
  def __ne__(self, other):
12938 
    return not (self == other)
12939 
 
3064 chandransh 12940 
class getOrder_args:
921 rajveer 12941 
  """
12942 
  Attributes:
3064 chandransh 12943 
   - id
921 rajveer 12944 
  """
12945 
 
12946 
  thrift_spec = (
12947 
    None, # 0
3064 chandransh 12948 
    (1, TType.I64, 'id', None, None, ), # 1
921 rajveer 12949 
  )
12950 
 
3064 chandransh 12951 
  def __init__(self, id=None,):
12952 
    self.id = id
921 rajveer 12953 
 
12954 
  def read(self, iprot):
12955 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12956 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12957 
      return
12958 
    iprot.readStructBegin()
12959 
    while True:
12960 
      (fname, ftype, fid) = iprot.readFieldBegin()
12961 
      if ftype == TType.STOP:
12962 
        break
12963 
      if fid == 1:
12964 
        if ftype == TType.I64:
3064 chandransh 12965 
          self.id = iprot.readI64();
921 rajveer 12966 
        else:
12967 
          iprot.skip(ftype)
12968 
      else:
12969 
        iprot.skip(ftype)
12970 
      iprot.readFieldEnd()
12971 
    iprot.readStructEnd()
12972 
 
12973 
  def write(self, oprot):
12974 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12975 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12976 
      return
3064 chandransh 12977 
    oprot.writeStructBegin('getOrder_args')
3431 rajveer 12978 
    if self.id is not None:
3064 chandransh 12979 
      oprot.writeFieldBegin('id', TType.I64, 1)
12980 
      oprot.writeI64(self.id)
921 rajveer 12981 
      oprot.writeFieldEnd()
12982 
    oprot.writeFieldStop()
12983 
    oprot.writeStructEnd()
12984 
 
3431 rajveer 12985 
  def validate(self):
12986 
    return
12987 
 
12988 
 
921 rajveer 12989 
  def __repr__(self):
12990 
    L = ['%s=%r' % (key, value)
12991 
      for key, value in self.__dict__.iteritems()]
12992 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12993 
 
12994 
  def __eq__(self, other):
12995 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12996 
 
12997 
  def __ne__(self, other):
12998 
    return not (self == other)
12999 
 
3064 chandransh 13000 
class getOrder_result:
921 rajveer 13001 
  """
13002 
  Attributes:
13003 
   - success
13004 
   - ex
13005 
  """
13006 
 
13007 
  thrift_spec = (
3064 chandransh 13008 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
921 rajveer 13009 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
13010 
  )
13011 
 
13012 
  def __init__(self, success=None, ex=None,):
13013 
    self.success = success
13014 
    self.ex = ex
13015 
 
13016 
  def read(self, iprot):
13017 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13018 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13019 
      return
13020 
    iprot.readStructBegin()
13021 
    while True:
13022 
      (fname, ftype, fid) = iprot.readFieldBegin()
13023 
      if ftype == TType.STOP:
13024 
        break
13025 
      if fid == 0:
3064 chandransh 13026 
        if ftype == TType.STRUCT:
13027 
          self.success = Order()
13028 
          self.success.read(iprot)
921 rajveer 13029 
        else:
13030 
          iprot.skip(ftype)
13031 
      elif fid == 1:
13032 
        if ftype == TType.STRUCT:
13033 
          self.ex = TransactionServiceException()
13034 
          self.ex.read(iprot)
13035 
        else:
13036 
          iprot.skip(ftype)
13037 
      else:
13038 
        iprot.skip(ftype)
13039 
      iprot.readFieldEnd()
13040 
    iprot.readStructEnd()
13041 
 
13042 
  def write(self, oprot):
13043 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13044 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13045 
      return
3064 chandransh 13046 
    oprot.writeStructBegin('getOrder_result')
3431 rajveer 13047 
    if self.success is not None:
3064 chandransh 13048 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
13049 
      self.success.write(oprot)
921 rajveer 13050 
      oprot.writeFieldEnd()
3431 rajveer 13051 
    if self.ex is not None:
921 rajveer 13052 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
13053 
      self.ex.write(oprot)
13054 
      oprot.writeFieldEnd()
13055 
    oprot.writeFieldStop()
13056 
    oprot.writeStructEnd()
13057 
 
3431 rajveer 13058 
  def validate(self):
13059 
    return
13060 
 
13061 
 
921 rajveer 13062 
  def __repr__(self):
13063 
    L = ['%s=%r' % (key, value)
13064 
      for key, value in self.__dict__.iteritems()]
13065 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13066 
 
13067 
  def __eq__(self, other):
13068 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13069 
 
13070 
  def __ne__(self, other):
13071 
    return not (self == other)
13072 
 
3064 chandransh 13073 
class getLineItemsForOrder_args:
94 ashish 13074 
  """
13075 
  Attributes:
3064 chandransh 13076 
   - orderId
94 ashish 13077 
  """
13078 
 
13079 
  thrift_spec = (
13080 
    None, # 0
3064 chandransh 13081 
    (1, TType.I64, 'orderId', None, None, ), # 1
94 ashish 13082 
  )
13083 
 
3064 chandransh 13084 
  def __init__(self, orderId=None,):
13085 
    self.orderId = orderId
94 ashish 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 == 1:
13097 
        if ftype == TType.I64:
3064 chandransh 13098 
          self.orderId = iprot.readI64();
94 ashish 13099 
        else:
13100 
          iprot.skip(ftype)
13101 
      else:
13102 
        iprot.skip(ftype)
13103 
      iprot.readFieldEnd()
13104 
    iprot.readStructEnd()
13105 
 
13106 
  def write(self, oprot):
13107 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13108 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13109 
      return
3064 chandransh 13110 
    oprot.writeStructBegin('getLineItemsForOrder_args')
3431 rajveer 13111 
    if self.orderId is not None:
3064 chandransh 13112 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
13113 
      oprot.writeI64(self.orderId)
94 ashish 13114 
      oprot.writeFieldEnd()
13115 
    oprot.writeFieldStop()
13116 
    oprot.writeStructEnd()
13117 
 
3431 rajveer 13118 
  def validate(self):
13119 
    return
13120 
 
13121 
 
94 ashish 13122 
  def __repr__(self):
13123 
    L = ['%s=%r' % (key, value)
13124 
      for key, value in self.__dict__.iteritems()]
13125 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13126 
 
13127 
  def __eq__(self, other):
13128 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13129 
 
13130 
  def __ne__(self, other):
13131 
    return not (self == other)
13132 
 
3064 chandransh 13133 
class getLineItemsForOrder_result:
94 ashish 13134 
  """
13135 
  Attributes:
13136 
   - success
13137 
   - ex
13138 
  """
13139 
 
13140 
  thrift_spec = (
3064 chandransh 13141 
    (0, TType.LIST, 'success', (TType.STRUCT,(LineItem, LineItem.thrift_spec)), None, ), # 0
94 ashish 13142 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
13143 
  )
13144 
 
13145 
  def __init__(self, success=None, ex=None,):
13146 
    self.success = success
13147 
    self.ex = ex
13148 
 
13149 
  def read(self, iprot):
13150 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13151 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13152 
      return
13153 
    iprot.readStructBegin()
13154 
    while True:
13155 
      (fname, ftype, fid) = iprot.readFieldBegin()
13156 
      if ftype == TType.STOP:
13157 
        break
13158 
      if fid == 0:
483 rajveer 13159 
        if ftype == TType.LIST:
13160 
          self.success = []
6188 rajveer 13161 
          (_etype207, _size204) = iprot.readListBegin()
13162 
          for _i208 in xrange(_size204):
13163 
            _elem209 = LineItem()
13164 
            _elem209.read(iprot)
13165 
            self.success.append(_elem209)
483 rajveer 13166 
          iprot.readListEnd()
94 ashish 13167 
        else:
13168 
          iprot.skip(ftype)
13169 
      elif fid == 1:
13170 
        if ftype == TType.STRUCT:
13171 
          self.ex = TransactionServiceException()
13172 
          self.ex.read(iprot)
13173 
        else:
13174 
          iprot.skip(ftype)
13175 
      else:
13176 
        iprot.skip(ftype)
13177 
      iprot.readFieldEnd()
13178 
    iprot.readStructEnd()
13179 
 
13180 
  def write(self, oprot):
13181 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13182 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13183 
      return
3064 chandransh 13184 
    oprot.writeStructBegin('getLineItemsForOrder_result')
3431 rajveer 13185 
    if self.success is not None:
483 rajveer 13186 
      oprot.writeFieldBegin('success', TType.LIST, 0)
13187 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 13188 
      for iter210 in self.success:
13189 
        iter210.write(oprot)
483 rajveer 13190 
      oprot.writeListEnd()
94 ashish 13191 
      oprot.writeFieldEnd()
3431 rajveer 13192 
    if self.ex is not None:
94 ashish 13193 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
13194 
      self.ex.write(oprot)
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 
 
4999 phani.kuma 13214 
class getOrderList_args:
13215 
  """
13216 
  Attributes:
13217 
   - order_ids
13218 
  """
13219 
 
13220 
  thrift_spec = (
13221 
    None, # 0
13222 
    (1, TType.LIST, 'order_ids', (TType.I64,None), None, ), # 1
13223 
  )
13224 
 
13225 
  def __init__(self, order_ids=None,):
13226 
    self.order_ids = order_ids
13227 
 
13228 
  def read(self, iprot):
13229 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13230 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13231 
      return
13232 
    iprot.readStructBegin()
13233 
    while True:
13234 
      (fname, ftype, fid) = iprot.readFieldBegin()
13235 
      if ftype == TType.STOP:
13236 
        break
13237 
      if fid == 1:
13238 
        if ftype == TType.LIST:
13239 
          self.order_ids = []
6188 rajveer 13240 
          (_etype214, _size211) = iprot.readListBegin()
13241 
          for _i215 in xrange(_size211):
13242 
            _elem216 = iprot.readI64();
13243 
            self.order_ids.append(_elem216)
4999 phani.kuma 13244 
          iprot.readListEnd()
13245 
        else:
13246 
          iprot.skip(ftype)
13247 
      else:
13248 
        iprot.skip(ftype)
13249 
      iprot.readFieldEnd()
13250 
    iprot.readStructEnd()
13251 
 
13252 
  def write(self, oprot):
13253 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13254 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13255 
      return
13256 
    oprot.writeStructBegin('getOrderList_args')
13257 
    if self.order_ids is not None:
13258 
      oprot.writeFieldBegin('order_ids', TType.LIST, 1)
13259 
      oprot.writeListBegin(TType.I64, len(self.order_ids))
6188 rajveer 13260 
      for iter217 in self.order_ids:
13261 
        oprot.writeI64(iter217)
4999 phani.kuma 13262 
      oprot.writeListEnd()
13263 
      oprot.writeFieldEnd()
13264 
    oprot.writeFieldStop()
13265 
    oprot.writeStructEnd()
13266 
 
13267 
  def validate(self):
13268 
    return
13269 
 
13270 
 
13271 
  def __repr__(self):
13272 
    L = ['%s=%r' % (key, value)
13273 
      for key, value in self.__dict__.iteritems()]
13274 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13275 
 
13276 
  def __eq__(self, other):
13277 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13278 
 
13279 
  def __ne__(self, other):
13280 
    return not (self == other)
13281 
 
13282 
class getOrderList_result:
13283 
  """
13284 
  Attributes:
13285 
   - success
13286 
  """
13287 
 
13288 
  thrift_spec = (
13289 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
13290 
  )
13291 
 
13292 
  def __init__(self, success=None,):
13293 
    self.success = success
13294 
 
13295 
  def read(self, iprot):
13296 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13297 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13298 
      return
13299 
    iprot.readStructBegin()
13300 
    while True:
13301 
      (fname, ftype, fid) = iprot.readFieldBegin()
13302 
      if ftype == TType.STOP:
13303 
        break
13304 
      if fid == 0:
13305 
        if ftype == TType.LIST:
13306 
          self.success = []
6188 rajveer 13307 
          (_etype221, _size218) = iprot.readListBegin()
13308 
          for _i222 in xrange(_size218):
13309 
            _elem223 = Order()
13310 
            _elem223.read(iprot)
13311 
            self.success.append(_elem223)
4999 phani.kuma 13312 
          iprot.readListEnd()
13313 
        else:
13314 
          iprot.skip(ftype)
13315 
      else:
13316 
        iprot.skip(ftype)
13317 
      iprot.readFieldEnd()
13318 
    iprot.readStructEnd()
13319 
 
13320 
  def write(self, oprot):
13321 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13322 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13323 
      return
13324 
    oprot.writeStructBegin('getOrderList_result')
13325 
    if self.success is not None:
13326 
      oprot.writeFieldBegin('success', TType.LIST, 0)
13327 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 13328 
      for iter224 in self.success:
13329 
        iter224.write(oprot)
4999 phani.kuma 13330 
      oprot.writeListEnd()
13331 
      oprot.writeFieldEnd()
13332 
    oprot.writeFieldStop()
13333 
    oprot.writeStructEnd()
13334 
 
13335 
  def validate(self):
13336 
    return
13337 
 
13338 
 
13339 
  def __repr__(self):
13340 
    L = ['%s=%r' % (key, value)
13341 
      for key, value in self.__dict__.iteritems()]
13342 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13343 
 
13344 
  def __eq__(self, other):
13345 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13346 
 
13347 
  def __ne__(self, other):
13348 
    return not (self == other)
13349 
 
5386 phani.kuma 13350 
class getOrderListForVendor_args:
13351 
  """
13352 
  Attributes:
13353 
   - order_ids
13354 
   - vendorId
13355 
  """
13356 
 
13357 
  thrift_spec = (
13358 
    None, # 0
13359 
    (1, TType.LIST, 'order_ids', (TType.I64,None), None, ), # 1
13360 
    (2, TType.I64, 'vendorId', None, None, ), # 2
13361 
  )
13362 
 
13363 
  def __init__(self, order_ids=None, vendorId=None,):
13364 
    self.order_ids = order_ids
13365 
    self.vendorId = vendorId
13366 
 
13367 
  def read(self, iprot):
13368 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13369 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13370 
      return
13371 
    iprot.readStructBegin()
13372 
    while True:
13373 
      (fname, ftype, fid) = iprot.readFieldBegin()
13374 
      if ftype == TType.STOP:
13375 
        break
13376 
      if fid == 1:
13377 
        if ftype == TType.LIST:
13378 
          self.order_ids = []
6188 rajveer 13379 
          (_etype228, _size225) = iprot.readListBegin()
13380 
          for _i229 in xrange(_size225):
13381 
            _elem230 = iprot.readI64();
13382 
            self.order_ids.append(_elem230)
5386 phani.kuma 13383 
          iprot.readListEnd()
13384 
        else:
13385 
          iprot.skip(ftype)
13386 
      elif fid == 2:
13387 
        if ftype == TType.I64:
13388 
          self.vendorId = iprot.readI64();
13389 
        else:
13390 
          iprot.skip(ftype)
13391 
      else:
13392 
        iprot.skip(ftype)
13393 
      iprot.readFieldEnd()
13394 
    iprot.readStructEnd()
13395 
 
13396 
  def write(self, oprot):
13397 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13398 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13399 
      return
13400 
    oprot.writeStructBegin('getOrderListForVendor_args')
13401 
    if self.order_ids is not None:
13402 
      oprot.writeFieldBegin('order_ids', TType.LIST, 1)
13403 
      oprot.writeListBegin(TType.I64, len(self.order_ids))
6188 rajveer 13404 
      for iter231 in self.order_ids:
13405 
        oprot.writeI64(iter231)
5386 phani.kuma 13406 
      oprot.writeListEnd()
13407 
      oprot.writeFieldEnd()
13408 
    if self.vendorId is not None:
13409 
      oprot.writeFieldBegin('vendorId', TType.I64, 2)
13410 
      oprot.writeI64(self.vendorId)
13411 
      oprot.writeFieldEnd()
13412 
    oprot.writeFieldStop()
13413 
    oprot.writeStructEnd()
13414 
 
13415 
  def validate(self):
13416 
    return
13417 
 
13418 
 
13419 
  def __repr__(self):
13420 
    L = ['%s=%r' % (key, value)
13421 
      for key, value in self.__dict__.iteritems()]
13422 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13423 
 
13424 
  def __eq__(self, other):
13425 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13426 
 
13427 
  def __ne__(self, other):
13428 
    return not (self == other)
13429 
 
13430 
class getOrderListForVendor_result:
13431 
  """
13432 
  Attributes:
13433 
   - success
13434 
  """
13435 
 
13436 
  thrift_spec = (
13437 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
13438 
  )
13439 
 
13440 
  def __init__(self, success=None,):
13441 
    self.success = success
13442 
 
13443 
  def read(self, iprot):
13444 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13445 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13446 
      return
13447 
    iprot.readStructBegin()
13448 
    while True:
13449 
      (fname, ftype, fid) = iprot.readFieldBegin()
13450 
      if ftype == TType.STOP:
13451 
        break
13452 
      if fid == 0:
13453 
        if ftype == TType.LIST:
13454 
          self.success = []
6188 rajveer 13455 
          (_etype235, _size232) = iprot.readListBegin()
13456 
          for _i236 in xrange(_size232):
13457 
            _elem237 = Order()
13458 
            _elem237.read(iprot)
13459 
            self.success.append(_elem237)
5386 phani.kuma 13460 
          iprot.readListEnd()
13461 
        else:
13462 
          iprot.skip(ftype)
13463 
      else:
13464 
        iprot.skip(ftype)
13465 
      iprot.readFieldEnd()
13466 
    iprot.readStructEnd()
13467 
 
13468 
  def write(self, oprot):
13469 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13470 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13471 
      return
13472 
    oprot.writeStructBegin('getOrderListForVendor_result')
13473 
    if self.success is not None:
13474 
      oprot.writeFieldBegin('success', TType.LIST, 0)
13475 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 13476 
      for iter238 in self.success:
13477 
        iter238.write(oprot)
5386 phani.kuma 13478 
      oprot.writeListEnd()
13479 
      oprot.writeFieldEnd()
13480 
    oprot.writeFieldStop()
13481 
    oprot.writeStructEnd()
13482 
 
13483 
  def validate(self):
13484 
    return
13485 
 
13486 
 
13487 
  def __repr__(self):
13488 
    L = ['%s=%r' % (key, value)
13489 
      for key, value in self.__dict__.iteritems()]
13490 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13491 
 
13492 
  def __eq__(self, other):
13493 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13494 
 
13495 
  def __ne__(self, other):
13496 
    return not (self == other)
13497 
 
3064 chandransh 13498 
class getOrderForCustomer_args:
94 ashish 13499 
  """
13500 
  Attributes:
3064 chandransh 13501 
   - orderId
483 rajveer 13502 
   - customerId
94 ashish 13503 
  """
13504 
 
13505 
  thrift_spec = (
13506 
    None, # 0
3064 chandransh 13507 
    (1, TType.I64, 'orderId', None, None, ), # 1
13508 
    (2, TType.I64, 'customerId', None, None, ), # 2
94 ashish 13509 
  )
13510 
 
3064 chandransh 13511 
  def __init__(self, orderId=None, customerId=None,):
13512 
    self.orderId = orderId
483 rajveer 13513 
    self.customerId = customerId
94 ashish 13514 
 
13515 
  def read(self, iprot):
13516 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13517 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13518 
      return
13519 
    iprot.readStructBegin()
13520 
    while True:
13521 
      (fname, ftype, fid) = iprot.readFieldBegin()
13522 
      if ftype == TType.STOP:
13523 
        break
13524 
      if fid == 1:
13525 
        if ftype == TType.I64:
3064 chandransh 13526 
          self.orderId = iprot.readI64();
94 ashish 13527 
        else:
13528 
          iprot.skip(ftype)
13529 
      elif fid == 2:
13530 
        if ftype == TType.I64:
3064 chandransh 13531 
          self.customerId = iprot.readI64();
94 ashish 13532 
        else:
13533 
          iprot.skip(ftype)
13534 
      else:
13535 
        iprot.skip(ftype)
13536 
      iprot.readFieldEnd()
13537 
    iprot.readStructEnd()
13538 
 
13539 
  def write(self, oprot):
13540 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13541 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13542 
      return
3064 chandransh 13543 
    oprot.writeStructBegin('getOrderForCustomer_args')
3431 rajveer 13544 
    if self.orderId is not None:
3064 chandransh 13545 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
13546 
      oprot.writeI64(self.orderId)
13547 
      oprot.writeFieldEnd()
3431 rajveer 13548 
    if self.customerId is not None:
3064 chandransh 13549 
      oprot.writeFieldBegin('customerId', TType.I64, 2)
483 rajveer 13550 
      oprot.writeI64(self.customerId)
94 ashish 13551 
      oprot.writeFieldEnd()
13552 
    oprot.writeFieldStop()
13553 
    oprot.writeStructEnd()
13554 
 
3431 rajveer 13555 
  def validate(self):
13556 
    return
13557 
 
13558 
 
94 ashish 13559 
  def __repr__(self):
13560 
    L = ['%s=%r' % (key, value)
13561 
      for key, value in self.__dict__.iteritems()]
13562 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13563 
 
13564 
  def __eq__(self, other):
13565 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13566 
 
13567 
  def __ne__(self, other):
13568 
    return not (self == other)
13569 
 
3064 chandransh 13570 
class getOrderForCustomer_result:
94 ashish 13571 
  """
13572 
  Attributes:
13573 
   - success
13574 
   - ex
13575 
  """
13576 
 
13577 
  thrift_spec = (
3064 chandransh 13578 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
94 ashish 13579 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
13580 
  )
13581 
 
13582 
  def __init__(self, success=None, ex=None,):
13583 
    self.success = success
13584 
    self.ex = ex
13585 
 
13586 
  def read(self, iprot):
13587 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13588 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13589 
      return
13590 
    iprot.readStructBegin()
13591 
    while True:
13592 
      (fname, ftype, fid) = iprot.readFieldBegin()
13593 
      if ftype == TType.STOP:
13594 
        break
13595 
      if fid == 0:
3064 chandransh 13596 
        if ftype == TType.STRUCT:
13597 
          self.success = Order()
13598 
          self.success.read(iprot)
94 ashish 13599 
        else:
13600 
          iprot.skip(ftype)
13601 
      elif fid == 1:
13602 
        if ftype == TType.STRUCT:
13603 
          self.ex = TransactionServiceException()
13604 
          self.ex.read(iprot)
13605 
        else:
13606 
          iprot.skip(ftype)
13607 
      else:
13608 
        iprot.skip(ftype)
13609 
      iprot.readFieldEnd()
13610 
    iprot.readStructEnd()
13611 
 
13612 
  def write(self, oprot):
13613 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13614 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13615 
      return
3064 chandransh 13616 
    oprot.writeStructBegin('getOrderForCustomer_result')
3431 rajveer 13617 
    if self.success is not None:
3064 chandransh 13618 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
13619 
      self.success.write(oprot)
94 ashish 13620 
      oprot.writeFieldEnd()
3431 rajveer 13621 
    if self.ex is not None:
94 ashish 13622 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
13623 
      self.ex.write(oprot)
13624 
      oprot.writeFieldEnd()
13625 
    oprot.writeFieldStop()
13626 
    oprot.writeStructEnd()
13627 
 
3431 rajveer 13628 
  def validate(self):
13629 
    return
13630 
 
13631 
 
94 ashish 13632 
  def __repr__(self):
13633 
    L = ['%s=%r' % (key, value)
13634 
      for key, value in self.__dict__.iteritems()]
13635 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13636 
 
13637 
  def __eq__(self, other):
13638 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13639 
 
13640 
  def __ne__(self, other):
13641 
    return not (self == other)
13642 
 
3064 chandransh 13643 
class getAlerts_args:
94 ashish 13644 
  """
13645 
  Attributes:
4394 rajveer 13646 
   - type
4444 rajveer 13647 
   - warehouseId
4394 rajveer 13648 
   - status
13649 
   - timestamp
94 ashish 13650 
  """
13651 
 
13652 
  thrift_spec = (
13653 
    None, # 0
4394 rajveer 13654 
    (1, TType.I64, 'type', None, None, ), # 1
4444 rajveer 13655 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
13656 
    (3, TType.I64, 'status', None, None, ), # 3
13657 
    (4, TType.I64, 'timestamp', None, None, ), # 4
94 ashish 13658 
  )
13659 
 
4444 rajveer 13660 
  def __init__(self, type=None, warehouseId=None, status=None, timestamp=None,):
4394 rajveer 13661 
    self.type = type
4444 rajveer 13662 
    self.warehouseId = warehouseId
4394 rajveer 13663 
    self.status = status
13664 
    self.timestamp = timestamp
94 ashish 13665 
 
13666 
  def read(self, iprot):
13667 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13668 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13669 
      return
13670 
    iprot.readStructBegin()
13671 
    while True:
13672 
      (fname, ftype, fid) = iprot.readFieldBegin()
13673 
      if ftype == TType.STOP:
13674 
        break
13675 
      if fid == 1:
3064 chandransh 13676 
        if ftype == TType.I64:
4394 rajveer 13677 
          self.type = iprot.readI64();
94 ashish 13678 
        else:
13679 
          iprot.skip(ftype)
3064 chandransh 13680 
      elif fid == 2:
4394 rajveer 13681 
        if ftype == TType.I64:
4444 rajveer 13682 
          self.warehouseId = iprot.readI64();
3064 chandransh 13683 
        else:
13684 
          iprot.skip(ftype)
4394 rajveer 13685 
      elif fid == 3:
13686 
        if ftype == TType.I64:
4444 rajveer 13687 
          self.status = iprot.readI64();
13688 
        else:
13689 
          iprot.skip(ftype)
13690 
      elif fid == 4:
13691 
        if ftype == TType.I64:
4394 rajveer 13692 
          self.timestamp = iprot.readI64();
13693 
        else:
13694 
          iprot.skip(ftype)
94 ashish 13695 
      else:
13696 
        iprot.skip(ftype)
13697 
      iprot.readFieldEnd()
13698 
    iprot.readStructEnd()
13699 
 
13700 
  def write(self, oprot):
13701 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13702 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13703 
      return
3064 chandransh 13704 
    oprot.writeStructBegin('getAlerts_args')
4394 rajveer 13705 
    if self.type is not None:
13706 
      oprot.writeFieldBegin('type', TType.I64, 1)
13707 
      oprot.writeI64(self.type)
94 ashish 13708 
      oprot.writeFieldEnd()
4444 rajveer 13709 
    if self.warehouseId is not None:
13710 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
13711 
      oprot.writeI64(self.warehouseId)
13712 
      oprot.writeFieldEnd()
4394 rajveer 13713 
    if self.status is not None:
4444 rajveer 13714 
      oprot.writeFieldBegin('status', TType.I64, 3)
4394 rajveer 13715 
      oprot.writeI64(self.status)
3064 chandransh 13716 
      oprot.writeFieldEnd()
4394 rajveer 13717 
    if self.timestamp is not None:
4444 rajveer 13718 
      oprot.writeFieldBegin('timestamp', TType.I64, 4)
4394 rajveer 13719 
      oprot.writeI64(self.timestamp)
13720 
      oprot.writeFieldEnd()
94 ashish 13721 
    oprot.writeFieldStop()
13722 
    oprot.writeStructEnd()
13723 
 
3431 rajveer 13724 
  def validate(self):
13725 
    return
13726 
 
13727 
 
94 ashish 13728 
  def __repr__(self):
13729 
    L = ['%s=%r' % (key, value)
13730 
      for key, value in self.__dict__.iteritems()]
13731 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13732 
 
13733 
  def __eq__(self, other):
13734 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13735 
 
13736 
  def __ne__(self, other):
13737 
    return not (self == other)
13738 
 
3064 chandransh 13739 
class getAlerts_result:
94 ashish 13740 
  """
13741 
  Attributes:
13742 
   - success
13743 
  """
13744 
 
13745 
  thrift_spec = (
3064 chandransh 13746 
    (0, TType.LIST, 'success', (TType.STRUCT,(Alert, Alert.thrift_spec)), None, ), # 0
94 ashish 13747 
  )
13748 
 
3064 chandransh 13749 
  def __init__(self, success=None,):
94 ashish 13750 
    self.success = success
13751 
 
13752 
  def read(self, iprot):
13753 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13754 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13755 
      return
13756 
    iprot.readStructBegin()
13757 
    while True:
13758 
      (fname, ftype, fid) = iprot.readFieldBegin()
13759 
      if ftype == TType.STOP:
13760 
        break
13761 
      if fid == 0:
3064 chandransh 13762 
        if ftype == TType.LIST:
13763 
          self.success = []
6188 rajveer 13764 
          (_etype242, _size239) = iprot.readListBegin()
13765 
          for _i243 in xrange(_size239):
13766 
            _elem244 = Alert()
13767 
            _elem244.read(iprot)
13768 
            self.success.append(_elem244)
3064 chandransh 13769 
          iprot.readListEnd()
94 ashish 13770 
        else:
13771 
          iprot.skip(ftype)
13772 
      else:
13773 
        iprot.skip(ftype)
13774 
      iprot.readFieldEnd()
13775 
    iprot.readStructEnd()
13776 
 
13777 
  def write(self, oprot):
13778 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13779 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13780 
      return
3064 chandransh 13781 
    oprot.writeStructBegin('getAlerts_result')
3431 rajveer 13782 
    if self.success is not None:
3064 chandransh 13783 
      oprot.writeFieldBegin('success', TType.LIST, 0)
13784 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 13785 
      for iter245 in self.success:
13786 
        iter245.write(oprot)
3064 chandransh 13787 
      oprot.writeListEnd()
94 ashish 13788 
      oprot.writeFieldEnd()
13789 
    oprot.writeFieldStop()
13790 
    oprot.writeStructEnd()
13791 
 
3431 rajveer 13792 
  def validate(self):
13793 
    return
13794 
 
13795 
 
94 ashish 13796 
  def __repr__(self):
13797 
    L = ['%s=%r' % (key, value)
13798 
      for key, value in self.__dict__.iteritems()]
13799 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13800 
 
13801 
  def __eq__(self, other):
13802 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13803 
 
13804 
  def __ne__(self, other):
13805 
    return not (self == other)
13806 
 
4394 rajveer 13807 
class addAlert_args:
94 ashish 13808 
  """
13809 
  Attributes:
3064 chandransh 13810 
   - type
4444 rajveer 13811 
   - warehouseId
4394 rajveer 13812 
   - description
94 ashish 13813 
  """
13814 
 
13815 
  thrift_spec = (
13816 
    None, # 0
4394 rajveer 13817 
    (1, TType.I64, 'type', None, None, ), # 1
4444 rajveer 13818 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
13819 
    (3, TType.STRING, 'description', None, None, ), # 3
94 ashish 13820 
  )
13821 
 
4444 rajveer 13822 
  def __init__(self, type=None, warehouseId=None, description=None,):
3064 chandransh 13823 
    self.type = type
4444 rajveer 13824 
    self.warehouseId = warehouseId
4394 rajveer 13825 
    self.description = description
94 ashish 13826 
 
13827 
  def read(self, iprot):
13828 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13829 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13830 
      return
13831 
    iprot.readStructBegin()
13832 
    while True:
13833 
      (fname, ftype, fid) = iprot.readFieldBegin()
13834 
      if ftype == TType.STOP:
13835 
        break
13836 
      if fid == 1:
13837 
        if ftype == TType.I64:
4394 rajveer 13838 
          self.type = iprot.readI64();
94 ashish 13839 
        else:
13840 
          iprot.skip(ftype)
3064 chandransh 13841 
      elif fid == 2:
4444 rajveer 13842 
        if ftype == TType.I64:
13843 
          self.warehouseId = iprot.readI64();
13844 
        else:
13845 
          iprot.skip(ftype)
13846 
      elif fid == 3:
3064 chandransh 13847 
        if ftype == TType.STRING:
4394 rajveer 13848 
          self.description = iprot.readString();
3064 chandransh 13849 
        else:
13850 
          iprot.skip(ftype)
94 ashish 13851 
      else:
13852 
        iprot.skip(ftype)
13853 
      iprot.readFieldEnd()
13854 
    iprot.readStructEnd()
13855 
 
13856 
  def write(self, oprot):
13857 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13858 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13859 
      return
4394 rajveer 13860 
    oprot.writeStructBegin('addAlert_args')
3431 rajveer 13861 
    if self.type is not None:
4394 rajveer 13862 
      oprot.writeFieldBegin('type', TType.I64, 1)
3064 chandransh 13863 
      oprot.writeI64(self.type)
13864 
      oprot.writeFieldEnd()
4444 rajveer 13865 
    if self.warehouseId is not None:
13866 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
13867 
      oprot.writeI64(self.warehouseId)
13868 
      oprot.writeFieldEnd()
4394 rajveer 13869 
    if self.description is not None:
4444 rajveer 13870 
      oprot.writeFieldBegin('description', TType.STRING, 3)
4394 rajveer 13871 
      oprot.writeString(self.description)
3064 chandransh 13872 
      oprot.writeFieldEnd()
94 ashish 13873 
    oprot.writeFieldStop()
13874 
    oprot.writeStructEnd()
13875 
 
3431 rajveer 13876 
  def validate(self):
13877 
    return
13878 
 
13879 
 
94 ashish 13880 
  def __repr__(self):
13881 
    L = ['%s=%r' % (key, value)
13882 
      for key, value in self.__dict__.iteritems()]
13883 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13884 
 
13885 
  def __eq__(self, other):
13886 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13887 
 
13888 
  def __ne__(self, other):
13889 
    return not (self == other)
13890 
 
4394 rajveer 13891 
class addAlert_result:
3064 chandransh 13892 
 
13893 
  thrift_spec = (
13894 
  )
13895 
 
13896 
  def read(self, iprot):
13897 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13898 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13899 
      return
13900 
    iprot.readStructBegin()
13901 
    while True:
13902 
      (fname, ftype, fid) = iprot.readFieldBegin()
13903 
      if ftype == TType.STOP:
13904 
        break
13905 
      else:
13906 
        iprot.skip(ftype)
13907 
      iprot.readFieldEnd()
13908 
    iprot.readStructEnd()
13909 
 
13910 
  def write(self, oprot):
13911 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13912 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13913 
      return
4394 rajveer 13914 
    oprot.writeStructBegin('addAlert_result')
3064 chandransh 13915 
    oprot.writeFieldStop()
13916 
    oprot.writeStructEnd()
13917 
 
3431 rajveer 13918 
  def validate(self):
13919 
    return
13920 
 
13921 
 
3064 chandransh 13922 
  def __repr__(self):
13923 
    L = ['%s=%r' % (key, value)
13924 
      for key, value in self.__dict__.iteritems()]
13925 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13926 
 
13927 
  def __eq__(self, other):
13928 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13929 
 
13930 
  def __ne__(self, other):
13931 
    return not (self == other)
13932 
 
4444 rajveer 13933 
class markAlertsAsSeen_args:
13934 
  """
13935 
  Attributes:
13936 
   - warehouseId
13937 
  """
13938 
 
13939 
  thrift_spec = (
13940 
    None, # 0
13941 
    (1, TType.I64, 'warehouseId', None, None, ), # 1
13942 
  )
13943 
 
13944 
  def __init__(self, warehouseId=None,):
13945 
    self.warehouseId = warehouseId
13946 
 
13947 
  def read(self, iprot):
13948 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13949 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13950 
      return
13951 
    iprot.readStructBegin()
13952 
    while True:
13953 
      (fname, ftype, fid) = iprot.readFieldBegin()
13954 
      if ftype == TType.STOP:
13955 
        break
13956 
      if fid == 1:
13957 
        if ftype == TType.I64:
13958 
          self.warehouseId = iprot.readI64();
13959 
        else:
13960 
          iprot.skip(ftype)
13961 
      else:
13962 
        iprot.skip(ftype)
13963 
      iprot.readFieldEnd()
13964 
    iprot.readStructEnd()
13965 
 
13966 
  def write(self, oprot):
13967 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13968 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13969 
      return
13970 
    oprot.writeStructBegin('markAlertsAsSeen_args')
13971 
    if self.warehouseId is not None:
13972 
      oprot.writeFieldBegin('warehouseId', TType.I64, 1)
13973 
      oprot.writeI64(self.warehouseId)
13974 
      oprot.writeFieldEnd()
13975 
    oprot.writeFieldStop()
13976 
    oprot.writeStructEnd()
13977 
 
13978 
  def validate(self):
13979 
    return
13980 
 
13981 
 
13982 
  def __repr__(self):
13983 
    L = ['%s=%r' % (key, value)
13984 
      for key, value in self.__dict__.iteritems()]
13985 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13986 
 
13987 
  def __eq__(self, other):
13988 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13989 
 
13990 
  def __ne__(self, other):
13991 
    return not (self == other)
13992 
 
13993 
class markAlertsAsSeen_result:
13994 
 
13995 
  thrift_spec = (
13996 
  )
13997 
 
13998 
  def read(self, iprot):
13999 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14000 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14001 
      return
14002 
    iprot.readStructBegin()
14003 
    while True:
14004 
      (fname, ftype, fid) = iprot.readFieldBegin()
14005 
      if ftype == TType.STOP:
14006 
        break
14007 
      else:
14008 
        iprot.skip(ftype)
14009 
      iprot.readFieldEnd()
14010 
    iprot.readStructEnd()
14011 
 
14012 
  def write(self, oprot):
14013 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14014 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14015 
      return
14016 
    oprot.writeStructBegin('markAlertsAsSeen_result')
14017 
    oprot.writeFieldStop()
14018 
    oprot.writeStructEnd()
14019 
 
14020 
  def validate(self):
14021 
    return
14022 
 
14023 
 
14024 
  def __repr__(self):
14025 
    L = ['%s=%r' % (key, value)
14026 
      for key, value in self.__dict__.iteritems()]
14027 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14028 
 
14029 
  def __eq__(self, other):
14030 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14031 
 
14032 
  def __ne__(self, other):
14033 
    return not (self == other)
14034 
 
3064 chandransh 14035 
class getValidOrderCount_args:
14036 
 
14037 
  thrift_spec = (
14038 
  )
14039 
 
14040 
  def read(self, iprot):
14041 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14042 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14043 
      return
14044 
    iprot.readStructBegin()
14045 
    while True:
14046 
      (fname, ftype, fid) = iprot.readFieldBegin()
14047 
      if ftype == TType.STOP:
14048 
        break
14049 
      else:
14050 
        iprot.skip(ftype)
14051 
      iprot.readFieldEnd()
14052 
    iprot.readStructEnd()
14053 
 
14054 
  def write(self, oprot):
14055 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14056 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14057 
      return
14058 
    oprot.writeStructBegin('getValidOrderCount_args')
14059 
    oprot.writeFieldStop()
14060 
    oprot.writeStructEnd()
14061 
 
3431 rajveer 14062 
  def validate(self):
14063 
    return
14064 
 
14065 
 
3064 chandransh 14066 
  def __repr__(self):
14067 
    L = ['%s=%r' % (key, value)
14068 
      for key, value in self.__dict__.iteritems()]
14069 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14070 
 
14071 
  def __eq__(self, other):
14072 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14073 
 
14074 
  def __ne__(self, other):
14075 
    return not (self == other)
14076 
 
14077 
class getValidOrderCount_result:
94 ashish 14078 
  """
14079 
  Attributes:
14080 
   - success
14081 
  """
14082 
 
14083 
  thrift_spec = (
3064 chandransh 14084 
    (0, TType.I64, 'success', None, None, ), # 0
94 ashish 14085 
  )
14086 
 
3064 chandransh 14087 
  def __init__(self, success=None,):
94 ashish 14088 
    self.success = success
14089 
 
14090 
  def read(self, iprot):
14091 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14092 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14093 
      return
14094 
    iprot.readStructBegin()
14095 
    while True:
14096 
      (fname, ftype, fid) = iprot.readFieldBegin()
14097 
      if ftype == TType.STOP:
14098 
        break
14099 
      if fid == 0:
3064 chandransh 14100 
        if ftype == TType.I64:
14101 
          self.success = iprot.readI64();
94 ashish 14102 
        else:
14103 
          iprot.skip(ftype)
14104 
      else:
14105 
        iprot.skip(ftype)
14106 
      iprot.readFieldEnd()
14107 
    iprot.readStructEnd()
14108 
 
14109 
  def write(self, oprot):
14110 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14111 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14112 
      return
3064 chandransh 14113 
    oprot.writeStructBegin('getValidOrderCount_result')
3431 rajveer 14114 
    if self.success is not None:
3064 chandransh 14115 
      oprot.writeFieldBegin('success', TType.I64, 0)
14116 
      oprot.writeI64(self.success)
94 ashish 14117 
      oprot.writeFieldEnd()
14118 
    oprot.writeFieldStop()
14119 
    oprot.writeStructEnd()
14120 
 
3431 rajveer 14121 
  def validate(self):
14122 
    return
14123 
 
14124 
 
94 ashish 14125 
  def __repr__(self):
14126 
    L = ['%s=%r' % (key, value)
14127 
      for key, value in self.__dict__.iteritems()]
14128 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14129 
 
14130 
  def __eq__(self, other):
14131 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14132 
 
14133 
  def __ne__(self, other):
14134 
    return not (self == other)
14135 
 
3064 chandransh 14136 
class getNoOfCustomersWithSuccessfulTransaction_args:
14137 
 
14138 
  thrift_spec = (
14139 
  )
14140 
 
14141 
  def read(self, iprot):
14142 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14143 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14144 
      return
14145 
    iprot.readStructBegin()
14146 
    while True:
14147 
      (fname, ftype, fid) = iprot.readFieldBegin()
14148 
      if ftype == TType.STOP:
14149 
        break
14150 
      else:
14151 
        iprot.skip(ftype)
14152 
      iprot.readFieldEnd()
14153 
    iprot.readStructEnd()
14154 
 
14155 
  def write(self, oprot):
14156 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14157 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14158 
      return
14159 
    oprot.writeStructBegin('getNoOfCustomersWithSuccessfulTransaction_args')
14160 
    oprot.writeFieldStop()
14161 
    oprot.writeStructEnd()
14162 
 
3431 rajveer 14163 
  def validate(self):
14164 
    return
14165 
 
14166 
 
3064 chandransh 14167 
  def __repr__(self):
14168 
    L = ['%s=%r' % (key, value)
14169 
      for key, value in self.__dict__.iteritems()]
14170 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14171 
 
14172 
  def __eq__(self, other):
14173 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14174 
 
14175 
  def __ne__(self, other):
14176 
    return not (self == other)
14177 
 
14178 
class getNoOfCustomersWithSuccessfulTransaction_result:
94 ashish 14179 
  """
14180 
  Attributes:
3064 chandransh 14181 
   - success
94 ashish 14182 
  """
14183 
 
14184 
  thrift_spec = (
3064 chandransh 14185 
    (0, TType.I64, 'success', None, None, ), # 0
94 ashish 14186 
  )
14187 
 
3064 chandransh 14188 
  def __init__(self, success=None,):
14189 
    self.success = success
94 ashish 14190 
 
14191 
  def read(self, iprot):
14192 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14193 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14194 
      return
14195 
    iprot.readStructBegin()
14196 
    while True:
14197 
      (fname, ftype, fid) = iprot.readFieldBegin()
14198 
      if ftype == TType.STOP:
14199 
        break
3064 chandransh 14200 
      if fid == 0:
94 ashish 14201 
        if ftype == TType.I64:
3064 chandransh 14202 
          self.success = iprot.readI64();
94 ashish 14203 
        else:
14204 
          iprot.skip(ftype)
14205 
      else:
14206 
        iprot.skip(ftype)
14207 
      iprot.readFieldEnd()
14208 
    iprot.readStructEnd()
14209 
 
14210 
  def write(self, oprot):
14211 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14212 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14213 
      return
3064 chandransh 14214 
    oprot.writeStructBegin('getNoOfCustomersWithSuccessfulTransaction_result')
3431 rajveer 14215 
    if self.success is not None:
3064 chandransh 14216 
      oprot.writeFieldBegin('success', TType.I64, 0)
14217 
      oprot.writeI64(self.success)
94 ashish 14218 
      oprot.writeFieldEnd()
14219 
    oprot.writeFieldStop()
14220 
    oprot.writeStructEnd()
14221 
 
3431 rajveer 14222 
  def validate(self):
14223 
    return
14224 
 
14225 
 
94 ashish 14226 
  def __repr__(self):
14227 
    L = ['%s=%r' % (key, value)
14228 
      for key, value in self.__dict__.iteritems()]
14229 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14230 
 
14231 
  def __eq__(self, other):
14232 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14233 
 
14234 
  def __ne__(self, other):
14235 
    return not (self == other)
14236 
 
3064 chandransh 14237 
class getValidOrdersAmountRange_args:
14238 
 
14239 
  thrift_spec = (
14240 
  )
14241 
 
14242 
  def read(self, iprot):
14243 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14244 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14245 
      return
14246 
    iprot.readStructBegin()
14247 
    while True:
14248 
      (fname, ftype, fid) = iprot.readFieldBegin()
14249 
      if ftype == TType.STOP:
14250 
        break
14251 
      else:
14252 
        iprot.skip(ftype)
14253 
      iprot.readFieldEnd()
14254 
    iprot.readStructEnd()
14255 
 
14256 
  def write(self, oprot):
14257 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14258 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14259 
      return
14260 
    oprot.writeStructBegin('getValidOrdersAmountRange_args')
14261 
    oprot.writeFieldStop()
14262 
    oprot.writeStructEnd()
14263 
 
3431 rajveer 14264 
  def validate(self):
14265 
    return
14266 
 
14267 
 
3064 chandransh 14268 
  def __repr__(self):
14269 
    L = ['%s=%r' % (key, value)
14270 
      for key, value in self.__dict__.iteritems()]
14271 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14272 
 
14273 
  def __eq__(self, other):
14274 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14275 
 
14276 
  def __ne__(self, other):
14277 
    return not (self == other)
14278 
 
14279 
class getValidOrdersAmountRange_result:
94 ashish 14280 
  """
14281 
  Attributes:
14282 
   - success
14283 
  """
14284 
 
14285 
  thrift_spec = (
3064 chandransh 14286 
    (0, TType.LIST, 'success', (TType.DOUBLE,None), None, ), # 0
94 ashish 14287 
  )
14288 
 
3064 chandransh 14289 
  def __init__(self, success=None,):
94 ashish 14290 
    self.success = success
14291 
 
14292 
  def read(self, iprot):
14293 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14294 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14295 
      return
14296 
    iprot.readStructBegin()
14297 
    while True:
14298 
      (fname, ftype, fid) = iprot.readFieldBegin()
14299 
      if ftype == TType.STOP:
14300 
        break
14301 
      if fid == 0:
483 rajveer 14302 
        if ftype == TType.LIST:
14303 
          self.success = []
6188 rajveer 14304 
          (_etype249, _size246) = iprot.readListBegin()
14305 
          for _i250 in xrange(_size246):
14306 
            _elem251 = iprot.readDouble();
14307 
            self.success.append(_elem251)
483 rajveer 14308 
          iprot.readListEnd()
94 ashish 14309 
        else:
14310 
          iprot.skip(ftype)
14311 
      else:
14312 
        iprot.skip(ftype)
14313 
      iprot.readFieldEnd()
14314 
    iprot.readStructEnd()
14315 
 
14316 
  def write(self, oprot):
14317 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14318 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14319 
      return
3064 chandransh 14320 
    oprot.writeStructBegin('getValidOrdersAmountRange_result')
3431 rajveer 14321 
    if self.success is not None:
483 rajveer 14322 
      oprot.writeFieldBegin('success', TType.LIST, 0)
3064 chandransh 14323 
      oprot.writeListBegin(TType.DOUBLE, len(self.success))
6188 rajveer 14324 
      for iter252 in self.success:
14325 
        oprot.writeDouble(iter252)
483 rajveer 14326 
      oprot.writeListEnd()
94 ashish 14327 
      oprot.writeFieldEnd()
14328 
    oprot.writeFieldStop()
14329 
    oprot.writeStructEnd()
14330 
 
3431 rajveer 14331 
  def validate(self):
14332 
    return
14333 
 
14334 
 
94 ashish 14335 
  def __repr__(self):
14336 
    L = ['%s=%r' % (key, value)
14337 
      for key, value in self.__dict__.iteritems()]
14338 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14339 
 
14340 
  def __eq__(self, other):
14341 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14342 
 
14343 
  def __ne__(self, other):
14344 
    return not (self == other)
14345 
 
3064 chandransh 14346 
class getValidOrders_args:
1528 ankur.sing 14347 
  """
14348 
  Attributes:
3064 chandransh 14349 
   - limit
5874 rajveer 14350 
   - onlyStore
1528 ankur.sing 14351 
  """
14352 
 
14353 
  thrift_spec = (
14354 
    None, # 0
3064 chandransh 14355 
    (1, TType.I64, 'limit', None, None, ), # 1
5874 rajveer 14356 
    (2, TType.BOOL, 'onlyStore', None, None, ), # 2
1528 ankur.sing 14357 
  )
14358 
 
5874 rajveer 14359 
  def __init__(self, limit=None, onlyStore=None,):
3064 chandransh 14360 
    self.limit = limit
5874 rajveer 14361 
    self.onlyStore = onlyStore
1528 ankur.sing 14362 
 
14363 
  def read(self, iprot):
14364 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14365 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14366 
      return
14367 
    iprot.readStructBegin()
14368 
    while True:
14369 
      (fname, ftype, fid) = iprot.readFieldBegin()
14370 
      if ftype == TType.STOP:
14371 
        break
14372 
      if fid == 1:
14373 
        if ftype == TType.I64:
3064 chandransh 14374 
          self.limit = iprot.readI64();
1528 ankur.sing 14375 
        else:
14376 
          iprot.skip(ftype)
5874 rajveer 14377 
      elif fid == 2:
14378 
        if ftype == TType.BOOL:
14379 
          self.onlyStore = iprot.readBool();
14380 
        else:
14381 
          iprot.skip(ftype)
1528 ankur.sing 14382 
      else:
14383 
        iprot.skip(ftype)
14384 
      iprot.readFieldEnd()
14385 
    iprot.readStructEnd()
14386 
 
14387 
  def write(self, oprot):
14388 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14389 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14390 
      return
3064 chandransh 14391 
    oprot.writeStructBegin('getValidOrders_args')
3431 rajveer 14392 
    if self.limit is not None:
3064 chandransh 14393 
      oprot.writeFieldBegin('limit', TType.I64, 1)
14394 
      oprot.writeI64(self.limit)
1528 ankur.sing 14395 
      oprot.writeFieldEnd()
5874 rajveer 14396 
    if self.onlyStore is not None:
14397 
      oprot.writeFieldBegin('onlyStore', TType.BOOL, 2)
14398 
      oprot.writeBool(self.onlyStore)
14399 
      oprot.writeFieldEnd()
1528 ankur.sing 14400 
    oprot.writeFieldStop()
14401 
    oprot.writeStructEnd()
14402 
 
3431 rajveer 14403 
  def validate(self):
14404 
    return
14405 
 
14406 
 
1528 ankur.sing 14407 
  def __repr__(self):
14408 
    L = ['%s=%r' % (key, value)
14409 
      for key, value in self.__dict__.iteritems()]
14410 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14411 
 
14412 
  def __eq__(self, other):
14413 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14414 
 
14415 
  def __ne__(self, other):
14416 
    return not (self == other)
14417 
 
3064 chandransh 14418 
class getValidOrders_result:
1528 ankur.sing 14419 
  """
14420 
  Attributes:
14421 
   - success
14422 
  """
14423 
 
14424 
  thrift_spec = (
3064 chandransh 14425 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
1528 ankur.sing 14426 
  )
14427 
 
3064 chandransh 14428 
  def __init__(self, success=None,):
1528 ankur.sing 14429 
    self.success = success
14430 
 
14431 
  def read(self, iprot):
14432 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14433 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14434 
      return
14435 
    iprot.readStructBegin()
14436 
    while True:
14437 
      (fname, ftype, fid) = iprot.readFieldBegin()
14438 
      if ftype == TType.STOP:
14439 
        break
14440 
      if fid == 0:
3064 chandransh 14441 
        if ftype == TType.LIST:
14442 
          self.success = []
6188 rajveer 14443 
          (_etype256, _size253) = iprot.readListBegin()
14444 
          for _i257 in xrange(_size253):
14445 
            _elem258 = Order()
14446 
            _elem258.read(iprot)
14447 
            self.success.append(_elem258)
3064 chandransh 14448 
          iprot.readListEnd()
1528 ankur.sing 14449 
        else:
14450 
          iprot.skip(ftype)
14451 
      else:
14452 
        iprot.skip(ftype)
14453 
      iprot.readFieldEnd()
14454 
    iprot.readStructEnd()
14455 
 
14456 
  def write(self, oprot):
14457 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14458 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14459 
      return
3064 chandransh 14460 
    oprot.writeStructBegin('getValidOrders_result')
3431 rajveer 14461 
    if self.success is not None:
3064 chandransh 14462 
      oprot.writeFieldBegin('success', TType.LIST, 0)
14463 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 14464 
      for iter259 in self.success:
14465 
        iter259.write(oprot)
3064 chandransh 14466 
      oprot.writeListEnd()
1528 ankur.sing 14467 
      oprot.writeFieldEnd()
14468 
    oprot.writeFieldStop()
14469 
    oprot.writeStructEnd()
14470 
 
3431 rajveer 14471 
  def validate(self):
14472 
    return
14473 
 
14474 
 
1528 ankur.sing 14475 
  def __repr__(self):
14476 
    L = ['%s=%r' % (key, value)
14477 
      for key, value in self.__dict__.iteritems()]
14478 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14479 
 
14480 
  def __eq__(self, other):
14481 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14482 
 
14483 
  def __ne__(self, other):
14484 
    return not (self == other)
14485 
 
1220 chandransh 14486 
class batchOrders_args:
14487 
  """
14488 
  Attributes:
14489 
   - warehouseId
14490 
  """
14491 
 
14492 
  thrift_spec = (
14493 
    None, # 0
14494 
    (1, TType.I64, 'warehouseId', None, None, ), # 1
14495 
  )
14496 
 
14497 
  def __init__(self, warehouseId=None,):
14498 
    self.warehouseId = warehouseId
14499 
 
14500 
  def read(self, iprot):
14501 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14502 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14503 
      return
14504 
    iprot.readStructBegin()
14505 
    while True:
14506 
      (fname, ftype, fid) = iprot.readFieldBegin()
14507 
      if ftype == TType.STOP:
14508 
        break
14509 
      if fid == 1:
14510 
        if ftype == TType.I64:
14511 
          self.warehouseId = iprot.readI64();
14512 
        else:
14513 
          iprot.skip(ftype)
14514 
      else:
14515 
        iprot.skip(ftype)
14516 
      iprot.readFieldEnd()
14517 
    iprot.readStructEnd()
14518 
 
14519 
  def write(self, oprot):
14520 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14521 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14522 
      return
14523 
    oprot.writeStructBegin('batchOrders_args')
3431 rajveer 14524 
    if self.warehouseId is not None:
1220 chandransh 14525 
      oprot.writeFieldBegin('warehouseId', TType.I64, 1)
14526 
      oprot.writeI64(self.warehouseId)
14527 
      oprot.writeFieldEnd()
14528 
    oprot.writeFieldStop()
14529 
    oprot.writeStructEnd()
14530 
 
3431 rajveer 14531 
  def validate(self):
14532 
    return
14533 
 
14534 
 
1220 chandransh 14535 
  def __repr__(self):
14536 
    L = ['%s=%r' % (key, value)
14537 
      for key, value in self.__dict__.iteritems()]
14538 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14539 
 
14540 
  def __eq__(self, other):
14541 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14542 
 
14543 
  def __ne__(self, other):
14544 
    return not (self == other)
14545 
 
14546 
class batchOrders_result:
14547 
  """
14548 
  Attributes:
14549 
   - success
14550 
   - ex
14551 
  """
14552 
 
14553 
  thrift_spec = (
14554 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
14555 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
14556 
  )
14557 
 
14558 
  def __init__(self, success=None, ex=None,):
14559 
    self.success = success
14560 
    self.ex = ex
14561 
 
14562 
  def read(self, iprot):
14563 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14564 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14565 
      return
14566 
    iprot.readStructBegin()
14567 
    while True:
14568 
      (fname, ftype, fid) = iprot.readFieldBegin()
14569 
      if ftype == TType.STOP:
14570 
        break
14571 
      if fid == 0:
14572 
        if ftype == TType.LIST:
14573 
          self.success = []
6188 rajveer 14574 
          (_etype263, _size260) = iprot.readListBegin()
14575 
          for _i264 in xrange(_size260):
14576 
            _elem265 = Order()
14577 
            _elem265.read(iprot)
14578 
            self.success.append(_elem265)
1220 chandransh 14579 
          iprot.readListEnd()
14580 
        else:
14581 
          iprot.skip(ftype)
14582 
      elif fid == 1:
14583 
        if ftype == TType.STRUCT:
14584 
          self.ex = TransactionServiceException()
14585 
          self.ex.read(iprot)
14586 
        else:
14587 
          iprot.skip(ftype)
14588 
      else:
14589 
        iprot.skip(ftype)
14590 
      iprot.readFieldEnd()
14591 
    iprot.readStructEnd()
14592 
 
14593 
  def write(self, oprot):
14594 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14595 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14596 
      return
14597 
    oprot.writeStructBegin('batchOrders_result')
3431 rajveer 14598 
    if self.success is not None:
1220 chandransh 14599 
      oprot.writeFieldBegin('success', TType.LIST, 0)
14600 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 14601 
      for iter266 in self.success:
14602 
        iter266.write(oprot)
1220 chandransh 14603 
      oprot.writeListEnd()
14604 
      oprot.writeFieldEnd()
3431 rajveer 14605 
    if self.ex is not None:
1220 chandransh 14606 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
14607 
      self.ex.write(oprot)
14608 
      oprot.writeFieldEnd()
14609 
    oprot.writeFieldStop()
14610 
    oprot.writeStructEnd()
14611 
 
3431 rajveer 14612 
  def validate(self):
14613 
    return
14614 
 
14615 
 
1220 chandransh 14616 
  def __repr__(self):
14617 
    L = ['%s=%r' % (key, value)
14618 
      for key, value in self.__dict__.iteritems()]
14619 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14620 
 
14621 
  def __eq__(self, other):
14622 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14623 
 
14624 
  def __ne__(self, other):
14625 
    return not (self == other)
14626 
 
1208 chandransh 14627 
class markOrderAsOutOfStock_args:
14628 
  """
14629 
  Attributes:
14630 
   - orderId
14631 
  """
14632 
 
14633 
  thrift_spec = (
14634 
    None, # 0
14635 
    (1, TType.I64, 'orderId', None, None, ), # 1
14636 
  )
14637 
 
14638 
  def __init__(self, orderId=None,):
14639 
    self.orderId = orderId
14640 
 
14641 
  def read(self, iprot):
14642 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14643 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14644 
      return
14645 
    iprot.readStructBegin()
14646 
    while True:
14647 
      (fname, ftype, fid) = iprot.readFieldBegin()
14648 
      if ftype == TType.STOP:
14649 
        break
14650 
      if fid == 1:
14651 
        if ftype == TType.I64:
14652 
          self.orderId = iprot.readI64();
14653 
        else:
14654 
          iprot.skip(ftype)
14655 
      else:
14656 
        iprot.skip(ftype)
14657 
      iprot.readFieldEnd()
14658 
    iprot.readStructEnd()
14659 
 
14660 
  def write(self, oprot):
14661 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14662 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14663 
      return
14664 
    oprot.writeStructBegin('markOrderAsOutOfStock_args')
3431 rajveer 14665 
    if self.orderId is not None:
1208 chandransh 14666 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
14667 
      oprot.writeI64(self.orderId)
14668 
      oprot.writeFieldEnd()
14669 
    oprot.writeFieldStop()
14670 
    oprot.writeStructEnd()
14671 
 
3431 rajveer 14672 
  def validate(self):
14673 
    return
14674 
 
14675 
 
1208 chandransh 14676 
  def __repr__(self):
14677 
    L = ['%s=%r' % (key, value)
14678 
      for key, value in self.__dict__.iteritems()]
14679 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14680 
 
14681 
  def __eq__(self, other):
14682 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14683 
 
14684 
  def __ne__(self, other):
14685 
    return not (self == other)
14686 
 
14687 
class markOrderAsOutOfStock_result:
14688 
  """
14689 
  Attributes:
14690 
   - success
14691 
   - ex
14692 
  """
14693 
 
14694 
  thrift_spec = (
14695 
    (0, TType.BOOL, 'success', None, None, ), # 0
14696 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
14697 
  )
14698 
 
14699 
  def __init__(self, success=None, ex=None,):
14700 
    self.success = success
14701 
    self.ex = ex
14702 
 
14703 
  def read(self, iprot):
14704 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14705 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14706 
      return
14707 
    iprot.readStructBegin()
14708 
    while True:
14709 
      (fname, ftype, fid) = iprot.readFieldBegin()
14710 
      if ftype == TType.STOP:
14711 
        break
14712 
      if fid == 0:
14713 
        if ftype == TType.BOOL:
14714 
          self.success = iprot.readBool();
14715 
        else:
14716 
          iprot.skip(ftype)
14717 
      elif fid == 1:
14718 
        if ftype == TType.STRUCT:
14719 
          self.ex = TransactionServiceException()
14720 
          self.ex.read(iprot)
14721 
        else:
14722 
          iprot.skip(ftype)
14723 
      else:
14724 
        iprot.skip(ftype)
14725 
      iprot.readFieldEnd()
14726 
    iprot.readStructEnd()
14727 
 
14728 
  def write(self, oprot):
14729 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14730 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14731 
      return
14732 
    oprot.writeStructBegin('markOrderAsOutOfStock_result')
3431 rajveer 14733 
    if self.success is not None:
1208 chandransh 14734 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
14735 
      oprot.writeBool(self.success)
14736 
      oprot.writeFieldEnd()
3431 rajveer 14737 
    if self.ex is not None:
1208 chandransh 14738 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
14739 
      self.ex.write(oprot)
14740 
      oprot.writeFieldEnd()
14741 
    oprot.writeFieldStop()
14742 
    oprot.writeStructEnd()
14743 
 
3431 rajveer 14744 
  def validate(self):
14745 
    return
14746 
 
14747 
 
1208 chandransh 14748 
  def __repr__(self):
14749 
    L = ['%s=%r' % (key, value)
14750 
      for key, value in self.__dict__.iteritems()]
14751 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14752 
 
14753 
  def __eq__(self, other):
14754 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14755 
 
14756 
  def __ne__(self, other):
14757 
    return not (self == other)
14758 
 
3064 chandransh 14759 
class verifyOrder_args:
759 chandransh 14760 
  """
14761 
  Attributes:
3064 chandransh 14762 
   - orderId
759 chandransh 14763 
  """
14764 
 
14765 
  thrift_spec = (
14766 
    None, # 0
3064 chandransh 14767 
    (1, TType.I64, 'orderId', None, None, ), # 1
759 chandransh 14768 
  )
14769 
 
3064 chandransh 14770 
  def __init__(self, orderId=None,):
14771 
    self.orderId = orderId
759 chandransh 14772 
 
14773 
  def read(self, iprot):
14774 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14775 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14776 
      return
14777 
    iprot.readStructBegin()
14778 
    while True:
14779 
      (fname, ftype, fid) = iprot.readFieldBegin()
14780 
      if ftype == TType.STOP:
14781 
        break
14782 
      if fid == 1:
14783 
        if ftype == TType.I64:
3064 chandransh 14784 
          self.orderId = iprot.readI64();
759 chandransh 14785 
        else:
14786 
          iprot.skip(ftype)
14787 
      else:
14788 
        iprot.skip(ftype)
14789 
      iprot.readFieldEnd()
14790 
    iprot.readStructEnd()
14791 
 
14792 
  def write(self, oprot):
14793 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14794 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14795 
      return
3064 chandransh 14796 
    oprot.writeStructBegin('verifyOrder_args')
3431 rajveer 14797 
    if self.orderId is not None:
3064 chandransh 14798 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
14799 
      oprot.writeI64(self.orderId)
759 chandransh 14800 
      oprot.writeFieldEnd()
14801 
    oprot.writeFieldStop()
14802 
    oprot.writeStructEnd()
14803 
 
3431 rajveer 14804 
  def validate(self):
14805 
    return
14806 
 
14807 
 
759 chandransh 14808 
  def __repr__(self):
14809 
    L = ['%s=%r' % (key, value)
14810 
      for key, value in self.__dict__.iteritems()]
14811 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14812 
 
14813 
  def __eq__(self, other):
14814 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14815 
 
14816 
  def __ne__(self, other):
14817 
    return not (self == other)
14818 
 
3064 chandransh 14819 
class verifyOrder_result:
759 chandransh 14820 
  """
14821 
  Attributes:
14822 
   - success
14823 
   - ex
14824 
  """
14825 
 
14826 
  thrift_spec = (
14827 
    (0, TType.BOOL, 'success', None, None, ), # 0
14828 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
14829 
  )
14830 
 
14831 
  def __init__(self, success=None, ex=None,):
14832 
    self.success = success
14833 
    self.ex = ex
14834 
 
14835 
  def read(self, iprot):
14836 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14837 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14838 
      return
14839 
    iprot.readStructBegin()
14840 
    while True:
14841 
      (fname, ftype, fid) = iprot.readFieldBegin()
14842 
      if ftype == TType.STOP:
14843 
        break
14844 
      if fid == 0:
14845 
        if ftype == TType.BOOL:
14846 
          self.success = iprot.readBool();
14847 
        else:
14848 
          iprot.skip(ftype)
14849 
      elif fid == 1:
14850 
        if ftype == TType.STRUCT:
14851 
          self.ex = TransactionServiceException()
14852 
          self.ex.read(iprot)
14853 
        else:
14854 
          iprot.skip(ftype)
14855 
      else:
14856 
        iprot.skip(ftype)
14857 
      iprot.readFieldEnd()
14858 
    iprot.readStructEnd()
14859 
 
14860 
  def write(self, oprot):
14861 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14862 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14863 
      return
3064 chandransh 14864 
    oprot.writeStructBegin('verifyOrder_result')
3431 rajveer 14865 
    if self.success is not None:
759 chandransh 14866 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
14867 
      oprot.writeBool(self.success)
14868 
      oprot.writeFieldEnd()
3431 rajveer 14869 
    if self.ex is not None:
759 chandransh 14870 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
14871 
      self.ex.write(oprot)
14872 
      oprot.writeFieldEnd()
14873 
    oprot.writeFieldStop()
14874 
    oprot.writeStructEnd()
14875 
 
3431 rajveer 14876 
  def validate(self):
14877 
    return
14878 
 
14879 
 
759 chandransh 14880 
  def __repr__(self):
14881 
    L = ['%s=%r' % (key, value)
14882 
      for key, value in self.__dict__.iteritems()]
14883 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14884 
 
14885 
  def __eq__(self, other):
14886 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14887 
 
14888 
  def __ne__(self, other):
14889 
    return not (self == other)
14890 
 
3064 chandransh 14891 
class acceptOrder_args:
1113 chandransh 14892 
  """
14893 
  Attributes:
3064 chandransh 14894 
   - orderId
1113 chandransh 14895 
  """
14896 
 
14897 
  thrift_spec = (
14898 
    None, # 0
3064 chandransh 14899 
    (1, TType.I64, 'orderId', None, None, ), # 1
1113 chandransh 14900 
  )
14901 
 
3064 chandransh 14902 
  def __init__(self, orderId=None,):
14903 
    self.orderId = orderId
1113 chandransh 14904 
 
14905 
  def read(self, iprot):
14906 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14907 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14908 
      return
14909 
    iprot.readStructBegin()
14910 
    while True:
14911 
      (fname, ftype, fid) = iprot.readFieldBegin()
14912 
      if ftype == TType.STOP:
14913 
        break
14914 
      if fid == 1:
14915 
        if ftype == TType.I64:
3064 chandransh 14916 
          self.orderId = iprot.readI64();
1113 chandransh 14917 
        else:
14918 
          iprot.skip(ftype)
14919 
      else:
14920 
        iprot.skip(ftype)
14921 
      iprot.readFieldEnd()
14922 
    iprot.readStructEnd()
14923 
 
14924 
  def write(self, oprot):
14925 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14926 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14927 
      return
3064 chandransh 14928 
    oprot.writeStructBegin('acceptOrder_args')
3431 rajveer 14929 
    if self.orderId is not None:
3064 chandransh 14930 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
14931 
      oprot.writeI64(self.orderId)
1113 chandransh 14932 
      oprot.writeFieldEnd()
14933 
    oprot.writeFieldStop()
14934 
    oprot.writeStructEnd()
14935 
 
3431 rajveer 14936 
  def validate(self):
14937 
    return
14938 
 
14939 
 
1113 chandransh 14940 
  def __repr__(self):
14941 
    L = ['%s=%r' % (key, value)
14942 
      for key, value in self.__dict__.iteritems()]
14943 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14944 
 
14945 
  def __eq__(self, other):
14946 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14947 
 
14948 
  def __ne__(self, other):
14949 
    return not (self == other)
14950 
 
3064 chandransh 14951 
class acceptOrder_result:
1113 chandransh 14952 
  """
14953 
  Attributes:
14954 
   - success
14955 
   - ex
14956 
  """
14957 
 
14958 
  thrift_spec = (
3064 chandransh 14959 
    (0, TType.BOOL, 'success', None, None, ), # 0
1113 chandransh 14960 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
14961 
  )
14962 
 
14963 
  def __init__(self, success=None, ex=None,):
14964 
    self.success = success
14965 
    self.ex = ex
14966 
 
14967 
  def read(self, iprot):
14968 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14969 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14970 
      return
14971 
    iprot.readStructBegin()
14972 
    while True:
14973 
      (fname, ftype, fid) = iprot.readFieldBegin()
14974 
      if ftype == TType.STOP:
14975 
        break
14976 
      if fid == 0:
3064 chandransh 14977 
        if ftype == TType.BOOL:
14978 
          self.success = iprot.readBool();
1113 chandransh 14979 
        else:
14980 
          iprot.skip(ftype)
14981 
      elif fid == 1:
14982 
        if ftype == TType.STRUCT:
14983 
          self.ex = TransactionServiceException()
14984 
          self.ex.read(iprot)
14985 
        else:
14986 
          iprot.skip(ftype)
14987 
      else:
14988 
        iprot.skip(ftype)
14989 
      iprot.readFieldEnd()
14990 
    iprot.readStructEnd()
14991 
 
14992 
  def write(self, oprot):
14993 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14994 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14995 
      return
3064 chandransh 14996 
    oprot.writeStructBegin('acceptOrder_result')
3431 rajveer 14997 
    if self.success is not None:
3064 chandransh 14998 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
14999 
      oprot.writeBool(self.success)
1113 chandransh 15000 
      oprot.writeFieldEnd()
3431 rajveer 15001 
    if self.ex is not None:
1113 chandransh 15002 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
15003 
      self.ex.write(oprot)
15004 
      oprot.writeFieldEnd()
15005 
    oprot.writeFieldStop()
15006 
    oprot.writeStructEnd()
15007 
 
3431 rajveer 15008 
  def validate(self):
15009 
    return
15010 
 
15011 
 
1113 chandransh 15012 
  def __repr__(self):
15013 
    L = ['%s=%r' % (key, value)
15014 
      for key, value in self.__dict__.iteritems()]
15015 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15016 
 
15017 
  def __eq__(self, other):
15018 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15019 
 
15020 
  def __ne__(self, other):
15021 
    return not (self == other)
15022 
 
3064 chandransh 15023 
class addBillingDetails_args:
1135 chandransh 15024 
  """
15025 
  Attributes:
3064 chandransh 15026 
   - orderId
15027 
   - invoice_number
4658 mandeep.dh 15028 
   - serialNumber
4283 anupam.sin 15029 
   - itemNumber
7190 amar.kumar 15030 
   - freebieWarehouseId
3064 chandransh 15031 
   - billed_by
4264 rajveer 15032 
   - jacketNumber
4283 anupam.sin 15033 
   - billingType
5110 mandeep.dh 15034 
   - fulfilmentWarehouseId
4763 rajveer 15035 
   - authorize
1135 chandransh 15036 
  """
15037 
 
15038 
  thrift_spec = (
15039 
    None, # 0
3064 chandransh 15040 
    (1, TType.I64, 'orderId', None, None, ), # 1
15041 
    (2, TType.STRING, 'invoice_number', None, None, ), # 2
5411 rajveer 15042 
    (3, TType.LIST, 'serialNumber', (TType.STRING,None), None, ), # 3
15043 
    (4, TType.LIST, 'itemNumber', (TType.STRING,None), None, ), # 4
7190 amar.kumar 15044 
    (5, TType.I64, 'freebieWarehouseId', None, None, ), # 5
15045 
    (6, TType.STRING, 'billed_by', None, None, ), # 6
15046 
    (7, TType.I64, 'jacketNumber', None, None, ), # 7
15047 
    (8, TType.I64, 'billingType', None, None, ), # 8
15048 
    (9, TType.I64, 'fulfilmentWarehouseId', None, None, ), # 9
15049 
    (10, TType.BOOL, 'authorize', None, None, ), # 10
1135 chandransh 15050 
  )
15051 
 
7190 amar.kumar 15052 
  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 15053 
    self.orderId = orderId
15054 
    self.invoice_number = invoice_number
4658 mandeep.dh 15055 
    self.serialNumber = serialNumber
4283 anupam.sin 15056 
    self.itemNumber = itemNumber
7190 amar.kumar 15057 
    self.freebieWarehouseId = freebieWarehouseId
3064 chandransh 15058 
    self.billed_by = billed_by
4264 rajveer 15059 
    self.jacketNumber = jacketNumber
4283 anupam.sin 15060 
    self.billingType = billingType
5110 mandeep.dh 15061 
    self.fulfilmentWarehouseId = fulfilmentWarehouseId
4763 rajveer 15062 
    self.authorize = authorize
1135 chandransh 15063 
 
15064 
  def read(self, iprot):
15065 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15066 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15067 
      return
15068 
    iprot.readStructBegin()
15069 
    while True:
15070 
      (fname, ftype, fid) = iprot.readFieldBegin()
15071 
      if ftype == TType.STOP:
15072 
        break
15073 
      if fid == 1:
15074 
        if ftype == TType.I64:
3064 chandransh 15075 
          self.orderId = iprot.readI64();
1135 chandransh 15076 
        else:
15077 
          iprot.skip(ftype)
15078 
      elif fid == 2:
3064 chandransh 15079 
        if ftype == TType.STRING:
15080 
          self.invoice_number = iprot.readString();
1135 chandransh 15081 
        else:
15082 
          iprot.skip(ftype)
3064 chandransh 15083 
      elif fid == 3:
5411 rajveer 15084 
        if ftype == TType.LIST:
15085 
          self.serialNumber = []
6188 rajveer 15086 
          (_etype270, _size267) = iprot.readListBegin()
15087 
          for _i271 in xrange(_size267):
15088 
            _elem272 = iprot.readString();
15089 
            self.serialNumber.append(_elem272)
5411 rajveer 15090 
          iprot.readListEnd()
3064 chandransh 15091 
        else:
15092 
          iprot.skip(ftype)
15093 
      elif fid == 4:
5411 rajveer 15094 
        if ftype == TType.LIST:
15095 
          self.itemNumber = []
6188 rajveer 15096 
          (_etype276, _size273) = iprot.readListBegin()
15097 
          for _i277 in xrange(_size273):
15098 
            _elem278 = iprot.readString();
15099 
            self.itemNumber.append(_elem278)
5411 rajveer 15100 
          iprot.readListEnd()
3064 chandransh 15101 
        else:
15102 
          iprot.skip(ftype)
15103 
      elif fid == 5:
7190 amar.kumar 15104 
        if ftype == TType.I64:
15105 
          self.freebieWarehouseId = iprot.readI64();
15106 
        else:
15107 
          iprot.skip(ftype)
15108 
      elif fid == 6:
3064 chandransh 15109 
        if ftype == TType.STRING:
4283 anupam.sin 15110 
          self.billed_by = iprot.readString();
3064 chandransh 15111 
        else:
15112 
          iprot.skip(ftype)
7190 amar.kumar 15113 
      elif fid == 7:
3064 chandransh 15114 
        if ftype == TType.I64:
4283 anupam.sin 15115 
          self.jacketNumber = iprot.readI64();
15116 
        else:
15117 
          iprot.skip(ftype)
7190 amar.kumar 15118 
      elif fid == 8:
4283 anupam.sin 15119 
        if ftype == TType.I64:
3064 chandransh 15120 
          self.billingType = iprot.readI64();
15121 
        else:
15122 
          iprot.skip(ftype)
7190 amar.kumar 15123 
      elif fid == 9:
4283 anupam.sin 15124 
        if ftype == TType.I64:
5110 mandeep.dh 15125 
          self.fulfilmentWarehouseId = iprot.readI64();
4283 anupam.sin 15126 
        else:
15127 
          iprot.skip(ftype)
7190 amar.kumar 15128 
      elif fid == 10:
4763 rajveer 15129 
        if ftype == TType.BOOL:
15130 
          self.authorize = iprot.readBool();
15131 
        else:
15132 
          iprot.skip(ftype)
1246 chandransh 15133 
      else:
15134 
        iprot.skip(ftype)
15135 
      iprot.readFieldEnd()
15136 
    iprot.readStructEnd()
15137 
 
15138 
  def write(self, oprot):
15139 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15140 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15141 
      return
4283 anupam.sin 15142 
    oprot.writeStructBegin('addBillingDetails_args')
3431 rajveer 15143 
    if self.orderId is not None:
3064 chandransh 15144 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
15145 
      oprot.writeI64(self.orderId)
1246 chandransh 15146 
      oprot.writeFieldEnd()
4283 anupam.sin 15147 
    if self.invoice_number is not None:
15148 
      oprot.writeFieldBegin('invoice_number', TType.STRING, 2)
15149 
      oprot.writeString(self.invoice_number)
1246 chandransh 15150 
      oprot.writeFieldEnd()
4658 mandeep.dh 15151 
    if self.serialNumber is not None:
5411 rajveer 15152 
      oprot.writeFieldBegin('serialNumber', TType.LIST, 3)
15153 
      oprot.writeListBegin(TType.STRING, len(self.serialNumber))
6188 rajveer 15154 
      for iter279 in self.serialNumber:
15155 
        oprot.writeString(iter279)
5411 rajveer 15156 
      oprot.writeListEnd()
3064 chandransh 15157 
      oprot.writeFieldEnd()
3431 rajveer 15158 
    if self.itemNumber is not None:
5411 rajveer 15159 
      oprot.writeFieldBegin('itemNumber', TType.LIST, 4)
15160 
      oprot.writeListBegin(TType.STRING, len(self.itemNumber))
6188 rajveer 15161 
      for iter280 in self.itemNumber:
15162 
        oprot.writeString(iter280)
5411 rajveer 15163 
      oprot.writeListEnd()
3064 chandransh 15164 
      oprot.writeFieldEnd()
7190 amar.kumar 15165 
    if self.freebieWarehouseId is not None:
15166 
      oprot.writeFieldBegin('freebieWarehouseId', TType.I64, 5)
15167 
      oprot.writeI64(self.freebieWarehouseId)
15168 
      oprot.writeFieldEnd()
4283 anupam.sin 15169 
    if self.billed_by is not None:
7190 amar.kumar 15170 
      oprot.writeFieldBegin('billed_by', TType.STRING, 6)
4283 anupam.sin 15171 
      oprot.writeString(self.billed_by)
3064 chandransh 15172 
      oprot.writeFieldEnd()
4283 anupam.sin 15173 
    if self.jacketNumber is not None:
7190 amar.kumar 15174 
      oprot.writeFieldBegin('jacketNumber', TType.I64, 7)
4283 anupam.sin 15175 
      oprot.writeI64(self.jacketNumber)
15176 
      oprot.writeFieldEnd()
3431 rajveer 15177 
    if self.billingType is not None:
7190 amar.kumar 15178 
      oprot.writeFieldBegin('billingType', TType.I64, 8)
3064 chandransh 15179 
      oprot.writeI64(self.billingType)
15180 
      oprot.writeFieldEnd()
5110 mandeep.dh 15181 
    if self.fulfilmentWarehouseId is not None:
7190 amar.kumar 15182 
      oprot.writeFieldBegin('fulfilmentWarehouseId', TType.I64, 9)
5110 mandeep.dh 15183 
      oprot.writeI64(self.fulfilmentWarehouseId)
4283 anupam.sin 15184 
      oprot.writeFieldEnd()
4763 rajveer 15185 
    if self.authorize is not None:
7190 amar.kumar 15186 
      oprot.writeFieldBegin('authorize', TType.BOOL, 10)
4763 rajveer 15187 
      oprot.writeBool(self.authorize)
15188 
      oprot.writeFieldEnd()
1246 chandransh 15189 
    oprot.writeFieldStop()
15190 
    oprot.writeStructEnd()
15191 
 
3431 rajveer 15192 
  def validate(self):
15193 
    return
15194 
 
15195 
 
1246 chandransh 15196 
  def __repr__(self):
15197 
    L = ['%s=%r' % (key, value)
15198 
      for key, value in self.__dict__.iteritems()]
15199 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15200 
 
15201 
  def __eq__(self, other):
15202 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15203 
 
15204 
  def __ne__(self, other):
15205 
    return not (self == other)
15206 
 
4283 anupam.sin 15207 
class addBillingDetails_result:
1246 chandransh 15208 
  """
15209 
  Attributes:
3064 chandransh 15210 
   - success
1246 chandransh 15211 
   - ex
15212 
  """
15213 
 
15214 
  thrift_spec = (
3064 chandransh 15215 
    (0, TType.BOOL, 'success', None, None, ), # 0
1246 chandransh 15216 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
15217 
  )
15218 
 
3064 chandransh 15219 
  def __init__(self, success=None, ex=None,):
15220 
    self.success = success
1246 chandransh 15221 
    self.ex = ex
15222 
 
15223 
  def read(self, iprot):
15224 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15225 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15226 
      return
15227 
    iprot.readStructBegin()
15228 
    while True:
15229 
      (fname, ftype, fid) = iprot.readFieldBegin()
15230 
      if ftype == TType.STOP:
15231 
        break
3064 chandransh 15232 
      if fid == 0:
15233 
        if ftype == TType.BOOL:
15234 
          self.success = iprot.readBool();
15235 
        else:
15236 
          iprot.skip(ftype)
15237 
      elif fid == 1:
1246 chandransh 15238 
        if ftype == TType.STRUCT:
15239 
          self.ex = TransactionServiceException()
15240 
          self.ex.read(iprot)
15241 
        else:
15242 
          iprot.skip(ftype)
15243 
      else:
15244 
        iprot.skip(ftype)
15245 
      iprot.readFieldEnd()
15246 
    iprot.readStructEnd()
15247 
 
15248 
  def write(self, oprot):
15249 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15250 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15251 
      return
4283 anupam.sin 15252 
    oprot.writeStructBegin('addBillingDetails_result')
3431 rajveer 15253 
    if self.success is not None:
3064 chandransh 15254 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
15255 
      oprot.writeBool(self.success)
15256 
      oprot.writeFieldEnd()
3431 rajveer 15257 
    if self.ex is not None:
1246 chandransh 15258 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
15259 
      self.ex.write(oprot)
15260 
      oprot.writeFieldEnd()
15261 
    oprot.writeFieldStop()
15262 
    oprot.writeStructEnd()
15263 
 
3431 rajveer 15264 
  def validate(self):
15265 
    return
15266 
 
15267 
 
1246 chandransh 15268 
  def __repr__(self):
15269 
    L = ['%s=%r' % (key, value)
15270 
      for key, value in self.__dict__.iteritems()]
15271 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15272 
 
15273 
  def __eq__(self, other):
15274 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15275 
 
15276 
  def __ne__(self, other):
15277 
    return not (self == other)
15278 
 
4579 rajveer 15279 
class addInvoiceNumber_args:
15280 
  """
15281 
  Attributes:
15282 
   - orderId
15283 
   - invoiceNumber
4763 rajveer 15284 
   - color
6756 amar.kumar 15285 
   - serialNumber
15286 
   - itemNumber
4579 rajveer 15287 
  """
15288 
 
15289 
  thrift_spec = (
15290 
    None, # 0
15291 
    (1, TType.I64, 'orderId', None, None, ), # 1
15292 
    (2, TType.STRING, 'invoiceNumber', None, None, ), # 2
4763 rajveer 15293 
    (3, TType.STRING, 'color', None, None, ), # 3
6756 amar.kumar 15294 
    (4, TType.STRING, 'serialNumber', None, None, ), # 4
15295 
    (5, TType.STRING, 'itemNumber', None, None, ), # 5
4579 rajveer 15296 
  )
15297 
 
6756 amar.kumar 15298 
  def __init__(self, orderId=None, invoiceNumber=None, color=None, serialNumber=None, itemNumber=None,):
4579 rajveer 15299 
    self.orderId = orderId
15300 
    self.invoiceNumber = invoiceNumber
4763 rajveer 15301 
    self.color = color
6756 amar.kumar 15302 
    self.serialNumber = serialNumber
15303 
    self.itemNumber = itemNumber
4579 rajveer 15304 
 
15305 
  def read(self, iprot):
15306 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15307 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15308 
      return
15309 
    iprot.readStructBegin()
15310 
    while True:
15311 
      (fname, ftype, fid) = iprot.readFieldBegin()
15312 
      if ftype == TType.STOP:
15313 
        break
15314 
      if fid == 1:
15315 
        if ftype == TType.I64:
15316 
          self.orderId = iprot.readI64();
15317 
        else:
15318 
          iprot.skip(ftype)
15319 
      elif fid == 2:
15320 
        if ftype == TType.STRING:
15321 
          self.invoiceNumber = iprot.readString();
15322 
        else:
15323 
          iprot.skip(ftype)
4763 rajveer 15324 
      elif fid == 3:
15325 
        if ftype == TType.STRING:
15326 
          self.color = iprot.readString();
15327 
        else:
15328 
          iprot.skip(ftype)
6756 amar.kumar 15329 
      elif fid == 4:
15330 
        if ftype == TType.STRING:
15331 
          self.serialNumber = iprot.readString();
15332 
        else:
15333 
          iprot.skip(ftype)
15334 
      elif fid == 5:
15335 
        if ftype == TType.STRING:
15336 
          self.itemNumber = iprot.readString();
15337 
        else:
15338 
          iprot.skip(ftype)
4579 rajveer 15339 
      else:
15340 
        iprot.skip(ftype)
15341 
      iprot.readFieldEnd()
15342 
    iprot.readStructEnd()
15343 
 
15344 
  def write(self, oprot):
15345 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15346 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15347 
      return
15348 
    oprot.writeStructBegin('addInvoiceNumber_args')
15349 
    if self.orderId is not None:
15350 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
15351 
      oprot.writeI64(self.orderId)
15352 
      oprot.writeFieldEnd()
15353 
    if self.invoiceNumber is not None:
15354 
      oprot.writeFieldBegin('invoiceNumber', TType.STRING, 2)
15355 
      oprot.writeString(self.invoiceNumber)
15356 
      oprot.writeFieldEnd()
4763 rajveer 15357 
    if self.color is not None:
15358 
      oprot.writeFieldBegin('color', TType.STRING, 3)
15359 
      oprot.writeString(self.color)
15360 
      oprot.writeFieldEnd()
6756 amar.kumar 15361 
    if self.serialNumber is not None:
15362 
      oprot.writeFieldBegin('serialNumber', TType.STRING, 4)
15363 
      oprot.writeString(self.serialNumber)
15364 
      oprot.writeFieldEnd()
15365 
    if self.itemNumber is not None:
15366 
      oprot.writeFieldBegin('itemNumber', TType.STRING, 5)
15367 
      oprot.writeString(self.itemNumber)
15368 
      oprot.writeFieldEnd()
4579 rajveer 15369 
    oprot.writeFieldStop()
15370 
    oprot.writeStructEnd()
15371 
 
15372 
  def validate(self):
15373 
    return
15374 
 
15375 
 
15376 
  def __repr__(self):
15377 
    L = ['%s=%r' % (key, value)
15378 
      for key, value in self.__dict__.iteritems()]
15379 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15380 
 
15381 
  def __eq__(self, other):
15382 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15383 
 
15384 
  def __ne__(self, other):
15385 
    return not (self == other)
15386 
 
15387 
class addInvoiceNumber_result:
15388 
  """
15389 
  Attributes:
15390 
   - ex
15391 
  """
15392 
 
15393 
  thrift_spec = (
15394 
    None, # 0
15395 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
15396 
  )
15397 
 
15398 
  def __init__(self, ex=None,):
15399 
    self.ex = ex
15400 
 
15401 
  def read(self, iprot):
15402 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15403 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15404 
      return
15405 
    iprot.readStructBegin()
15406 
    while True:
15407 
      (fname, ftype, fid) = iprot.readFieldBegin()
15408 
      if ftype == TType.STOP:
15409 
        break
15410 
      if fid == 1:
15411 
        if ftype == TType.STRUCT:
15412 
          self.ex = TransactionServiceException()
15413 
          self.ex.read(iprot)
15414 
        else:
15415 
          iprot.skip(ftype)
15416 
      else:
15417 
        iprot.skip(ftype)
15418 
      iprot.readFieldEnd()
15419 
    iprot.readStructEnd()
15420 
 
15421 
  def write(self, oprot):
15422 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15423 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15424 
      return
15425 
    oprot.writeStructBegin('addInvoiceNumber_result')
15426 
    if self.ex is not None:
15427 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
15428 
      self.ex.write(oprot)
15429 
      oprot.writeFieldEnd()
15430 
    oprot.writeFieldStop()
15431 
    oprot.writeStructEnd()
15432 
 
15433 
  def validate(self):
15434 
    return
15435 
 
15436 
 
15437 
  def __repr__(self):
15438 
    L = ['%s=%r' % (key, value)
15439 
      for key, value in self.__dict__.iteritems()]
15440 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15441 
 
15442 
  def __eq__(self, other):
15443 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15444 
 
15445 
  def __ne__(self, other):
15446 
    return not (self == other)
15447 
 
4910 phani.kuma 15448 
class markOrdersAsShippedFromWarehouse_args:
1408 ankur.sing 15449 
  """
15450 
  Attributes:
3064 chandransh 15451 
   - warehouseId
1408 ankur.sing 15452 
   - providerId
3064 chandransh 15453 
   - cod
4910 phani.kuma 15454 
   - orderIds
1408 ankur.sing 15455 
  """
15456 
 
15457 
  thrift_spec = (
15458 
    None, # 0
3064 chandransh 15459 
    (1, TType.I64, 'warehouseId', None, None, ), # 1
15460 
    (2, TType.I64, 'providerId', None, None, ), # 2
15461 
    (3, TType.BOOL, 'cod', None, None, ), # 3
4910 phani.kuma 15462 
    (4, TType.LIST, 'orderIds', (TType.I64,None), None, ), # 4
1408 ankur.sing 15463 
  )
15464 
 
4910 phani.kuma 15465 
  def __init__(self, warehouseId=None, providerId=None, cod=None, orderIds=None,):
3064 chandransh 15466 
    self.warehouseId = warehouseId
1408 ankur.sing 15467 
    self.providerId = providerId
3064 chandransh 15468 
    self.cod = cod
4910 phani.kuma 15469 
    self.orderIds = orderIds
1408 ankur.sing 15470 
 
15471 
  def read(self, iprot):
15472 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15473 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15474 
      return
15475 
    iprot.readStructBegin()
15476 
    while True:
15477 
      (fname, ftype, fid) = iprot.readFieldBegin()
15478 
      if ftype == TType.STOP:
15479 
        break
15480 
      if fid == 1:
15481 
        if ftype == TType.I64:
3064 chandransh 15482 
          self.warehouseId = iprot.readI64();
1408 ankur.sing 15483 
        else:
15484 
          iprot.skip(ftype)
15485 
      elif fid == 2:
15486 
        if ftype == TType.I64:
3064 chandransh 15487 
          self.providerId = iprot.readI64();
1408 ankur.sing 15488 
        else:
15489 
          iprot.skip(ftype)
3064 chandransh 15490 
      elif fid == 3:
15491 
        if ftype == TType.BOOL:
15492 
          self.cod = iprot.readBool();
15493 
        else:
15494 
          iprot.skip(ftype)
4910 phani.kuma 15495 
      elif fid == 4:
15496 
        if ftype == TType.LIST:
15497 
          self.orderIds = []
6188 rajveer 15498 
          (_etype284, _size281) = iprot.readListBegin()
15499 
          for _i285 in xrange(_size281):
15500 
            _elem286 = iprot.readI64();
15501 
            self.orderIds.append(_elem286)
4910 phani.kuma 15502 
          iprot.readListEnd()
15503 
        else:
15504 
          iprot.skip(ftype)
1408 ankur.sing 15505 
      else:
15506 
        iprot.skip(ftype)
15507 
      iprot.readFieldEnd()
15508 
    iprot.readStructEnd()
15509 
 
15510 
  def write(self, oprot):
15511 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15512 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15513 
      return
4910 phani.kuma 15514 
    oprot.writeStructBegin('markOrdersAsShippedFromWarehouse_args')
3431 rajveer 15515 
    if self.warehouseId is not None:
3064 chandransh 15516 
      oprot.writeFieldBegin('warehouseId', TType.I64, 1)
15517 
      oprot.writeI64(self.warehouseId)
15518 
      oprot.writeFieldEnd()
3431 rajveer 15519 
    if self.providerId is not None:
3064 chandransh 15520 
      oprot.writeFieldBegin('providerId', TType.I64, 2)
1408 ankur.sing 15521 
      oprot.writeI64(self.providerId)
15522 
      oprot.writeFieldEnd()
3431 rajveer 15523 
    if self.cod is not None:
3064 chandransh 15524 
      oprot.writeFieldBegin('cod', TType.BOOL, 3)
15525 
      oprot.writeBool(self.cod)
1408 ankur.sing 15526 
      oprot.writeFieldEnd()
4910 phani.kuma 15527 
    if self.orderIds is not None:
15528 
      oprot.writeFieldBegin('orderIds', TType.LIST, 4)
15529 
      oprot.writeListBegin(TType.I64, len(self.orderIds))
6188 rajveer 15530 
      for iter287 in self.orderIds:
15531 
        oprot.writeI64(iter287)
4910 phani.kuma 15532 
      oprot.writeListEnd()
15533 
      oprot.writeFieldEnd()
1408 ankur.sing 15534 
    oprot.writeFieldStop()
15535 
    oprot.writeStructEnd()
15536 
 
3431 rajveer 15537 
  def validate(self):
15538 
    return
15539 
 
15540 
 
1408 ankur.sing 15541 
  def __repr__(self):
15542 
    L = ['%s=%r' % (key, value)
15543 
      for key, value in self.__dict__.iteritems()]
15544 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15545 
 
15546 
  def __eq__(self, other):
15547 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15548 
 
15549 
  def __ne__(self, other):
15550 
    return not (self == other)
15551 
 
4910 phani.kuma 15552 
class markOrdersAsShippedFromWarehouse_result:
1408 ankur.sing 15553 
  """
15554 
  Attributes:
15555 
   - success
3064 chandransh 15556 
   - ex
1408 ankur.sing 15557 
  """
15558 
 
15559 
  thrift_spec = (
3064 chandransh 15560 
    (0, TType.BOOL, 'success', None, None, ), # 0
15561 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
1408 ankur.sing 15562 
  )
15563 
 
3064 chandransh 15564 
  def __init__(self, success=None, ex=None,):
1408 ankur.sing 15565 
    self.success = success
3064 chandransh 15566 
    self.ex = ex
1408 ankur.sing 15567 
 
15568 
  def read(self, iprot):
15569 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15570 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15571 
      return
15572 
    iprot.readStructBegin()
15573 
    while True:
15574 
      (fname, ftype, fid) = iprot.readFieldBegin()
15575 
      if ftype == TType.STOP:
15576 
        break
15577 
      if fid == 0:
3064 chandransh 15578 
        if ftype == TType.BOOL:
15579 
          self.success = iprot.readBool();
1408 ankur.sing 15580 
        else:
15581 
          iprot.skip(ftype)
3064 chandransh 15582 
      elif fid == 1:
15583 
        if ftype == TType.STRUCT:
15584 
          self.ex = TransactionServiceException()
15585 
          self.ex.read(iprot)
15586 
        else:
15587 
          iprot.skip(ftype)
1408 ankur.sing 15588 
      else:
15589 
        iprot.skip(ftype)
15590 
      iprot.readFieldEnd()
15591 
    iprot.readStructEnd()
15592 
 
15593 
  def write(self, oprot):
15594 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15595 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15596 
      return
4910 phani.kuma 15597 
    oprot.writeStructBegin('markOrdersAsShippedFromWarehouse_result')
3431 rajveer 15598 
    if self.success is not None:
3064 chandransh 15599 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
15600 
      oprot.writeBool(self.success)
1408 ankur.sing 15601 
      oprot.writeFieldEnd()
3431 rajveer 15602 
    if self.ex is not None:
3064 chandransh 15603 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
15604 
      self.ex.write(oprot)
15605 
      oprot.writeFieldEnd()
1408 ankur.sing 15606 
    oprot.writeFieldStop()
15607 
    oprot.writeStructEnd()
15608 
 
3431 rajveer 15609 
  def validate(self):
15610 
    return
15611 
 
15612 
 
1408 ankur.sing 15613 
  def __repr__(self):
15614 
    L = ['%s=%r' % (key, value)
15615 
      for key, value in self.__dict__.iteritems()]
15616 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15617 
 
15618 
  def __eq__(self, other):
15619 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15620 
 
15621 
  def __ne__(self, other):
15622 
    return not (self == other)
15623 
 
5676 rajveer 15624 
class markOrdersAsReturnedFromStore_args:
15625 
  """
15626 
  Attributes:
15627 
   - providerId
15628 
   - orderIds
5713 rajveer 15629 
   - awbs
5676 rajveer 15630 
  """
15631 
 
15632 
  thrift_spec = (
15633 
    None, # 0
15634 
    (1, TType.I64, 'providerId', None, None, ), # 1
15635 
    (2, TType.LIST, 'orderIds', (TType.I64,None), None, ), # 2
5713 rajveer 15636 
    (3, TType.LIST, 'awbs', (TType.STRING,None), None, ), # 3
5676 rajveer 15637 
  )
15638 
 
5713 rajveer 15639 
  def __init__(self, providerId=None, orderIds=None, awbs=None,):
5676 rajveer 15640 
    self.providerId = providerId
15641 
    self.orderIds = orderIds
5713 rajveer 15642 
    self.awbs = awbs
5676 rajveer 15643 
 
15644 
  def read(self, iprot):
15645 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15646 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15647 
      return
15648 
    iprot.readStructBegin()
15649 
    while True:
15650 
      (fname, ftype, fid) = iprot.readFieldBegin()
15651 
      if ftype == TType.STOP:
15652 
        break
15653 
      if fid == 1:
15654 
        if ftype == TType.I64:
15655 
          self.providerId = iprot.readI64();
15656 
        else:
15657 
          iprot.skip(ftype)
15658 
      elif fid == 2:
15659 
        if ftype == TType.LIST:
15660 
          self.orderIds = []
6188 rajveer 15661 
          (_etype291, _size288) = iprot.readListBegin()
15662 
          for _i292 in xrange(_size288):
15663 
            _elem293 = iprot.readI64();
15664 
            self.orderIds.append(_elem293)
5676 rajveer 15665 
          iprot.readListEnd()
15666 
        else:
15667 
          iprot.skip(ftype)
5713 rajveer 15668 
      elif fid == 3:
15669 
        if ftype == TType.LIST:
15670 
          self.awbs = []
6188 rajveer 15671 
          (_etype297, _size294) = iprot.readListBegin()
15672 
          for _i298 in xrange(_size294):
15673 
            _elem299 = iprot.readString();
15674 
            self.awbs.append(_elem299)
5713 rajveer 15675 
          iprot.readListEnd()
15676 
        else:
15677 
          iprot.skip(ftype)
5676 rajveer 15678 
      else:
15679 
        iprot.skip(ftype)
15680 
      iprot.readFieldEnd()
15681 
    iprot.readStructEnd()
15682 
 
15683 
  def write(self, oprot):
15684 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15685 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15686 
      return
15687 
    oprot.writeStructBegin('markOrdersAsReturnedFromStore_args')
15688 
    if self.providerId is not None:
15689 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
15690 
      oprot.writeI64(self.providerId)
15691 
      oprot.writeFieldEnd()
15692 
    if self.orderIds is not None:
15693 
      oprot.writeFieldBegin('orderIds', TType.LIST, 2)
15694 
      oprot.writeListBegin(TType.I64, len(self.orderIds))
6188 rajveer 15695 
      for iter300 in self.orderIds:
15696 
        oprot.writeI64(iter300)
5676 rajveer 15697 
      oprot.writeListEnd()
15698 
      oprot.writeFieldEnd()
5713 rajveer 15699 
    if self.awbs is not None:
15700 
      oprot.writeFieldBegin('awbs', TType.LIST, 3)
15701 
      oprot.writeListBegin(TType.STRING, len(self.awbs))
6188 rajveer 15702 
      for iter301 in self.awbs:
15703 
        oprot.writeString(iter301)
5713 rajveer 15704 
      oprot.writeListEnd()
15705 
      oprot.writeFieldEnd()
5676 rajveer 15706 
    oprot.writeFieldStop()
15707 
    oprot.writeStructEnd()
15708 
 
15709 
  def validate(self):
15710 
    return
15711 
 
15712 
 
15713 
  def __repr__(self):
15714 
    L = ['%s=%r' % (key, value)
15715 
      for key, value in self.__dict__.iteritems()]
15716 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15717 
 
15718 
  def __eq__(self, other):
15719 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15720 
 
15721 
  def __ne__(self, other):
15722 
    return not (self == other)
15723 
 
15724 
class markOrdersAsReturnedFromStore_result:
15725 
  """
15726 
  Attributes:
15727 
   - success
15728 
   - ex
15729 
  """
15730 
 
15731 
  thrift_spec = (
15732 
    (0, TType.BOOL, 'success', None, None, ), # 0
15733 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
15734 
  )
15735 
 
15736 
  def __init__(self, success=None, ex=None,):
15737 
    self.success = success
15738 
    self.ex = ex
15739 
 
15740 
  def read(self, iprot):
15741 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15742 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15743 
      return
15744 
    iprot.readStructBegin()
15745 
    while True:
15746 
      (fname, ftype, fid) = iprot.readFieldBegin()
15747 
      if ftype == TType.STOP:
15748 
        break
15749 
      if fid == 0:
15750 
        if ftype == TType.BOOL:
15751 
          self.success = iprot.readBool();
15752 
        else:
15753 
          iprot.skip(ftype)
15754 
      elif fid == 1:
15755 
        if ftype == TType.STRUCT:
15756 
          self.ex = TransactionServiceException()
15757 
          self.ex.read(iprot)
15758 
        else:
15759 
          iprot.skip(ftype)
15760 
      else:
15761 
        iprot.skip(ftype)
15762 
      iprot.readFieldEnd()
15763 
    iprot.readStructEnd()
15764 
 
15765 
  def write(self, oprot):
15766 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15767 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15768 
      return
15769 
    oprot.writeStructBegin('markOrdersAsReturnedFromStore_result')
15770 
    if self.success is not None:
15771 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
15772 
      oprot.writeBool(self.success)
15773 
      oprot.writeFieldEnd()
15774 
    if self.ex is not None:
15775 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
15776 
      self.ex.write(oprot)
15777 
      oprot.writeFieldEnd()
15778 
    oprot.writeFieldStop()
15779 
    oprot.writeStructEnd()
15780 
 
15781 
  def validate(self):
15782 
    return
15783 
 
15784 
 
15785 
  def __repr__(self):
15786 
    L = ['%s=%r' % (key, value)
15787 
      for key, value in self.__dict__.iteritems()]
15788 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15789 
 
15790 
  def __eq__(self, other):
15791 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15792 
 
15793 
  def __ne__(self, other):
15794 
    return not (self == other)
15795 
 
4910 phani.kuma 15796 
class markOrdersAsPickedUp_args:
4410 rajveer 15797 
  """
15798 
  Attributes:
15799 
   - providerId
4910 phani.kuma 15800 
   - pickupDetails
4410 rajveer 15801 
  """
15802 
 
15803 
  thrift_spec = (
15804 
    None, # 0
4910 phani.kuma 15805 
    (1, TType.I64, 'providerId', None, None, ), # 1
15806 
    (2, TType.MAP, 'pickupDetails', (TType.STRING,None,TType.STRING,None), None, ), # 2
4410 rajveer 15807 
  )
15808 
 
4910 phani.kuma 15809 
  def __init__(self, providerId=None, pickupDetails=None,):
4410 rajveer 15810 
    self.providerId = providerId
4910 phani.kuma 15811 
    self.pickupDetails = pickupDetails
4410 rajveer 15812 
 
15813 
  def read(self, iprot):
15814 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15815 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15816 
      return
15817 
    iprot.readStructBegin()
15818 
    while True:
15819 
      (fname, ftype, fid) = iprot.readFieldBegin()
15820 
      if ftype == TType.STOP:
15821 
        break
15822 
      if fid == 1:
15823 
        if ftype == TType.I64:
4910 phani.kuma 15824 
          self.providerId = iprot.readI64();
4410 rajveer 15825 
        else:
15826 
          iprot.skip(ftype)
15827 
      elif fid == 2:
4910 phani.kuma 15828 
        if ftype == TType.MAP:
15829 
          self.pickupDetails = {}
6188 rajveer 15830 
          (_ktype303, _vtype304, _size302 ) = iprot.readMapBegin()
15831 
          for _i306 in xrange(_size302):
15832 
            _key307 = iprot.readString();
15833 
            _val308 = iprot.readString();
15834 
            self.pickupDetails[_key307] = _val308
4910 phani.kuma 15835 
          iprot.readMapEnd()
4410 rajveer 15836 
        else:
15837 
          iprot.skip(ftype)
15838 
      else:
15839 
        iprot.skip(ftype)
15840 
      iprot.readFieldEnd()
15841 
    iprot.readStructEnd()
15842 
 
15843 
  def write(self, oprot):
15844 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15845 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15846 
      return
4910 phani.kuma 15847 
    oprot.writeStructBegin('markOrdersAsPickedUp_args')
4410 rajveer 15848 
    if self.providerId is not None:
4910 phani.kuma 15849 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
4410 rajveer 15850 
      oprot.writeI64(self.providerId)
15851 
      oprot.writeFieldEnd()
4910 phani.kuma 15852 
    if self.pickupDetails is not None:
15853 
      oprot.writeFieldBegin('pickupDetails', TType.MAP, 2)
15854 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.pickupDetails))
6188 rajveer 15855 
      for kiter309,viter310 in self.pickupDetails.items():
15856 
        oprot.writeString(kiter309)
15857 
        oprot.writeString(viter310)
4910 phani.kuma 15858 
      oprot.writeMapEnd()
4410 rajveer 15859 
      oprot.writeFieldEnd()
15860 
    oprot.writeFieldStop()
15861 
    oprot.writeStructEnd()
15862 
 
15863 
  def validate(self):
15864 
    return
15865 
 
15866 
 
15867 
  def __repr__(self):
15868 
    L = ['%s=%r' % (key, value)
15869 
      for key, value in self.__dict__.iteritems()]
15870 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15871 
 
15872 
  def __eq__(self, other):
15873 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15874 
 
15875 
  def __ne__(self, other):
15876 
    return not (self == other)
15877 
 
4910 phani.kuma 15878 
class markOrdersAsPickedUp_result:
4410 rajveer 15879 
  """
15880 
  Attributes:
15881 
   - ex
15882 
  """
15883 
 
15884 
  thrift_spec = (
4910 phani.kuma 15885 
    None, # 0
4410 rajveer 15886 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
15887 
  )
15888 
 
4910 phani.kuma 15889 
  def __init__(self, ex=None,):
4410 rajveer 15890 
    self.ex = ex
15891 
 
15892 
  def read(self, iprot):
15893 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15894 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15895 
      return
15896 
    iprot.readStructBegin()
15897 
    while True:
15898 
      (fname, ftype, fid) = iprot.readFieldBegin()
15899 
      if ftype == TType.STOP:
15900 
        break
4910 phani.kuma 15901 
      if fid == 1:
4410 rajveer 15902 
        if ftype == TType.STRUCT:
15903 
          self.ex = TransactionServiceException()
15904 
          self.ex.read(iprot)
15905 
        else:
15906 
          iprot.skip(ftype)
15907 
      else:
15908 
        iprot.skip(ftype)
15909 
      iprot.readFieldEnd()
15910 
    iprot.readStructEnd()
15911 
 
15912 
  def write(self, oprot):
15913 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15914 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15915 
      return
4910 phani.kuma 15916 
    oprot.writeStructBegin('markOrdersAsPickedUp_result')
4410 rajveer 15917 
    if self.ex is not None:
15918 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
15919 
      self.ex.write(oprot)
15920 
      oprot.writeFieldEnd()
15921 
    oprot.writeFieldStop()
15922 
    oprot.writeStructEnd()
15923 
 
15924 
  def validate(self):
15925 
    return
15926 
 
15927 
 
15928 
  def __repr__(self):
15929 
    L = ['%s=%r' % (key, value)
15930 
      for key, value in self.__dict__.iteritems()]
15931 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15932 
 
15933 
  def __eq__(self, other):
15934 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15935 
 
15936 
  def __ne__(self, other):
15937 
    return not (self == other)
15938 
 
4910 phani.kuma 15939 
class getOrdersNotPickedUp_args:
304 ashish 15940 
  """
15941 
  Attributes:
3064 chandransh 15942 
   - providerId
304 ashish 15943 
  """
94 ashish 15944 
 
304 ashish 15945 
  thrift_spec = (
15946 
    None, # 0
3064 chandransh 15947 
    (1, TType.I64, 'providerId', None, None, ), # 1
304 ashish 15948 
  )
15949 
 
4910 phani.kuma 15950 
  def __init__(self, providerId=None,):
3064 chandransh 15951 
    self.providerId = providerId
304 ashish 15952 
 
15953 
  def read(self, iprot):
15954 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15955 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15956 
      return
15957 
    iprot.readStructBegin()
15958 
    while True:
15959 
      (fname, ftype, fid) = iprot.readFieldBegin()
15960 
      if ftype == TType.STOP:
15961 
        break
15962 
      if fid == 1:
15963 
        if ftype == TType.I64:
3064 chandransh 15964 
          self.providerId = iprot.readI64();
304 ashish 15965 
        else:
15966 
          iprot.skip(ftype)
15967 
      else:
15968 
        iprot.skip(ftype)
15969 
      iprot.readFieldEnd()
15970 
    iprot.readStructEnd()
15971 
 
15972 
  def write(self, oprot):
15973 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15974 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15975 
      return
4910 phani.kuma 15976 
    oprot.writeStructBegin('getOrdersNotPickedUp_args')
3431 rajveer 15977 
    if self.providerId is not None:
3064 chandransh 15978 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
15979 
      oprot.writeI64(self.providerId)
304 ashish 15980 
      oprot.writeFieldEnd()
15981 
    oprot.writeFieldStop()
15982 
    oprot.writeStructEnd()
15983 
 
3431 rajveer 15984 
  def validate(self):
15985 
    return
15986 
 
15987 
 
304 ashish 15988 
  def __repr__(self):
15989 
    L = ['%s=%r' % (key, value)
15990 
      for key, value in self.__dict__.iteritems()]
15991 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15992 
 
15993 
  def __eq__(self, other):
15994 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15995 
 
15996 
  def __ne__(self, other):
15997 
    return not (self == other)
15998 
 
4910 phani.kuma 15999 
class getOrdersNotPickedUp_result:
304 ashish 16000 
  """
16001 
  Attributes:
16002 
   - success
16003 
  """
16004 
 
16005 
  thrift_spec = (
3064 chandransh 16006 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
304 ashish 16007 
  )
16008 
 
4910 phani.kuma 16009 
  def __init__(self, success=None,):
304 ashish 16010 
    self.success = success
16011 
 
16012 
  def read(self, iprot):
16013 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16014 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16015 
      return
16016 
    iprot.readStructBegin()
16017 
    while True:
16018 
      (fname, ftype, fid) = iprot.readFieldBegin()
16019 
      if ftype == TType.STOP:
16020 
        break
16021 
      if fid == 0:
16022 
        if ftype == TType.LIST:
16023 
          self.success = []
6188 rajveer 16024 
          (_etype314, _size311) = iprot.readListBegin()
16025 
          for _i315 in xrange(_size311):
16026 
            _elem316 = Order()
16027 
            _elem316.read(iprot)
16028 
            self.success.append(_elem316)
304 ashish 16029 
          iprot.readListEnd()
16030 
        else:
16031 
          iprot.skip(ftype)
16032 
      else:
16033 
        iprot.skip(ftype)
16034 
      iprot.readFieldEnd()
16035 
    iprot.readStructEnd()
16036 
 
16037 
  def write(self, oprot):
16038 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16039 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16040 
      return
4910 phani.kuma 16041 
    oprot.writeStructBegin('getOrdersNotPickedUp_result')
3431 rajveer 16042 
    if self.success is not None:
304 ashish 16043 
      oprot.writeFieldBegin('success', TType.LIST, 0)
16044 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 16045 
      for iter317 in self.success:
16046 
        iter317.write(oprot)
304 ashish 16047 
      oprot.writeListEnd()
16048 
      oprot.writeFieldEnd()
16049 
    oprot.writeFieldStop()
16050 
    oprot.writeStructEnd()
16051 
 
3431 rajveer 16052 
  def validate(self):
16053 
    return
16054 
 
16055 
 
304 ashish 16056 
  def __repr__(self):
16057 
    L = ['%s=%r' % (key, value)
16058 
      for key, value in self.__dict__.iteritems()]
16059 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16060 
 
16061 
  def __eq__(self, other):
16062 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16063 
 
16064 
  def __ne__(self, other):
16065 
    return not (self == other)
16066 
 
3064 chandransh 16067 
class markOrdersAsDelivered_args:
304 ashish 16068 
  """
16069 
  Attributes:
3064 chandransh 16070 
   - providerId
16071 
   - deliveredOrders
304 ashish 16072 
  """
16073 
 
16074 
  thrift_spec = (
16075 
    None, # 0
3064 chandransh 16076 
    (1, TType.I64, 'providerId', None, None, ), # 1
16077 
    (2, TType.MAP, 'deliveredOrders', (TType.STRING,None,TType.STRING,None), None, ), # 2
304 ashish 16078 
  )
16079 
 
3064 chandransh 16080 
  def __init__(self, providerId=None, deliveredOrders=None,):
16081 
    self.providerId = providerId
16082 
    self.deliveredOrders = deliveredOrders
304 ashish 16083 
 
16084 
  def read(self, iprot):
16085 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16086 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16087 
      return
16088 
    iprot.readStructBegin()
16089 
    while True:
16090 
      (fname, ftype, fid) = iprot.readFieldBegin()
16091 
      if ftype == TType.STOP:
16092 
        break
16093 
      if fid == 1:
16094 
        if ftype == TType.I64:
3064 chandransh 16095 
          self.providerId = iprot.readI64();
304 ashish 16096 
        else:
16097 
          iprot.skip(ftype)
16098 
      elif fid == 2:
3064 chandransh 16099 
        if ftype == TType.MAP:
16100 
          self.deliveredOrders = {}
6188 rajveer 16101 
          (_ktype319, _vtype320, _size318 ) = iprot.readMapBegin()
16102 
          for _i322 in xrange(_size318):
16103 
            _key323 = iprot.readString();
16104 
            _val324 = iprot.readString();
16105 
            self.deliveredOrders[_key323] = _val324
3064 chandransh 16106 
          iprot.readMapEnd()
304 ashish 16107 
        else:
16108 
          iprot.skip(ftype)
16109 
      else:
16110 
        iprot.skip(ftype)
16111 
      iprot.readFieldEnd()
16112 
    iprot.readStructEnd()
16113 
 
16114 
  def write(self, oprot):
16115 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16116 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16117 
      return
3064 chandransh 16118 
    oprot.writeStructBegin('markOrdersAsDelivered_args')
3431 rajveer 16119 
    if self.providerId is not None:
3064 chandransh 16120 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
16121 
      oprot.writeI64(self.providerId)
304 ashish 16122 
      oprot.writeFieldEnd()
3431 rajveer 16123 
    if self.deliveredOrders is not None:
3064 chandransh 16124 
      oprot.writeFieldBegin('deliveredOrders', TType.MAP, 2)
16125 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.deliveredOrders))
6188 rajveer 16126 
      for kiter325,viter326 in self.deliveredOrders.items():
16127 
        oprot.writeString(kiter325)
16128 
        oprot.writeString(viter326)
3064 chandransh 16129 
      oprot.writeMapEnd()
304 ashish 16130 
      oprot.writeFieldEnd()
16131 
    oprot.writeFieldStop()
16132 
    oprot.writeStructEnd()
16133 
 
3431 rajveer 16134 
  def validate(self):
16135 
    return
16136 
 
16137 
 
304 ashish 16138 
  def __repr__(self):
16139 
    L = ['%s=%r' % (key, value)
16140 
      for key, value in self.__dict__.iteritems()]
16141 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16142 
 
16143 
  def __eq__(self, other):
16144 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16145 
 
16146 
  def __ne__(self, other):
16147 
    return not (self == other)
16148 
 
3064 chandransh 16149 
class markOrdersAsDelivered_result:
16150 
  """
16151 
  Attributes:
16152 
   - ex
16153 
  """
304 ashish 16154 
 
16155 
  thrift_spec = (
3064 chandransh 16156 
    None, # 0
16157 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
304 ashish 16158 
  )
16159 
 
3064 chandransh 16160 
  def __init__(self, ex=None,):
16161 
    self.ex = ex
304 ashish 16162 
 
1596 ankur.sing 16163 
  def read(self, iprot):
16164 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16165 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16166 
      return
16167 
    iprot.readStructBegin()
16168 
    while True:
16169 
      (fname, ftype, fid) = iprot.readFieldBegin()
16170 
      if ftype == TType.STOP:
16171 
        break
3064 chandransh 16172 
      if fid == 1:
16173 
        if ftype == TType.STRUCT:
16174 
          self.ex = TransactionServiceException()
16175 
          self.ex.read(iprot)
16176 
        else:
16177 
          iprot.skip(ftype)
1596 ankur.sing 16178 
      else:
16179 
        iprot.skip(ftype)
16180 
      iprot.readFieldEnd()
16181 
    iprot.readStructEnd()
16182 
 
16183 
  def write(self, oprot):
16184 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16185 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16186 
      return
3064 chandransh 16187 
    oprot.writeStructBegin('markOrdersAsDelivered_result')
3431 rajveer 16188 
    if self.ex is not None:
3064 chandransh 16189 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
16190 
      self.ex.write(oprot)
16191 
      oprot.writeFieldEnd()
1596 ankur.sing 16192 
    oprot.writeFieldStop()
16193 
    oprot.writeStructEnd()
16194 
 
3431 rajveer 16195 
  def validate(self):
16196 
    return
16197 
 
16198 
 
1596 ankur.sing 16199 
  def __repr__(self):
16200 
    L = ['%s=%r' % (key, value)
16201 
      for key, value in self.__dict__.iteritems()]
16202 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16203 
 
16204 
  def __eq__(self, other):
16205 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16206 
 
16207 
  def __ne__(self, other):
16208 
    return not (self == other)
16209 
 
4910 phani.kuma 16210 
class markAsRTOrders_args:
1596 ankur.sing 16211 
  """
16212 
  Attributes:
3064 chandransh 16213 
   - providerId
16214 
   - returnedOrders
1596 ankur.sing 16215 
  """
16216 
 
16217 
  thrift_spec = (
3064 chandransh 16218 
    None, # 0
16219 
    (1, TType.I64, 'providerId', None, None, ), # 1
16220 
    (2, TType.MAP, 'returnedOrders', (TType.STRING,None,TType.STRING,None), None, ), # 2
1596 ankur.sing 16221 
  )
16222 
 
3064 chandransh 16223 
  def __init__(self, providerId=None, returnedOrders=None,):
16224 
    self.providerId = providerId
16225 
    self.returnedOrders = returnedOrders
1596 ankur.sing 16226 
 
16227 
  def read(self, iprot):
16228 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16229 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16230 
      return
16231 
    iprot.readStructBegin()
16232 
    while True:
16233 
      (fname, ftype, fid) = iprot.readFieldBegin()
16234 
      if ftype == TType.STOP:
16235 
        break
3064 chandransh 16236 
      if fid == 1:
1596 ankur.sing 16237 
        if ftype == TType.I64:
3064 chandransh 16238 
          self.providerId = iprot.readI64();
1596 ankur.sing 16239 
        else:
16240 
          iprot.skip(ftype)
3064 chandransh 16241 
      elif fid == 2:
16242 
        if ftype == TType.MAP:
16243 
          self.returnedOrders = {}
6188 rajveer 16244 
          (_ktype328, _vtype329, _size327 ) = iprot.readMapBegin()
16245 
          for _i331 in xrange(_size327):
16246 
            _key332 = iprot.readString();
16247 
            _val333 = iprot.readString();
16248 
            self.returnedOrders[_key332] = _val333
3064 chandransh 16249 
          iprot.readMapEnd()
16250 
        else:
16251 
          iprot.skip(ftype)
1596 ankur.sing 16252 
      else:
16253 
        iprot.skip(ftype)
16254 
      iprot.readFieldEnd()
16255 
    iprot.readStructEnd()
16256 
 
16257 
  def write(self, oprot):
16258 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16259 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16260 
      return
4910 phani.kuma 16261 
    oprot.writeStructBegin('markAsRTOrders_args')
3431 rajveer 16262 
    if self.providerId is not None:
3064 chandransh 16263 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
16264 
      oprot.writeI64(self.providerId)
1596 ankur.sing 16265 
      oprot.writeFieldEnd()
3431 rajveer 16266 
    if self.returnedOrders is not None:
3064 chandransh 16267 
      oprot.writeFieldBegin('returnedOrders', TType.MAP, 2)
16268 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.returnedOrders))
6188 rajveer 16269 
      for kiter334,viter335 in self.returnedOrders.items():
16270 
        oprot.writeString(kiter334)
16271 
        oprot.writeString(viter335)
3064 chandransh 16272 
      oprot.writeMapEnd()
16273 
      oprot.writeFieldEnd()
1596 ankur.sing 16274 
    oprot.writeFieldStop()
16275 
    oprot.writeStructEnd()
16276 
 
3431 rajveer 16277 
  def validate(self):
16278 
    return
16279 
 
16280 
 
1596 ankur.sing 16281 
  def __repr__(self):
16282 
    L = ['%s=%r' % (key, value)
16283 
      for key, value in self.__dict__.iteritems()]
16284 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16285 
 
16286 
  def __eq__(self, other):
16287 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16288 
 
16289 
  def __ne__(self, other):
16290 
    return not (self == other)
16291 
 
4910 phani.kuma 16292 
class markAsRTOrders_result:
3064 chandransh 16293 
  """
16294 
  Attributes:
16295 
   - ex
16296 
  """
1596 ankur.sing 16297 
 
1627 ankur.sing 16298 
  thrift_spec = (
3064 chandransh 16299 
    None, # 0
16300 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
1627 ankur.sing 16301 
  )
16302 
 
3064 chandransh 16303 
  def __init__(self, ex=None,):
16304 
    self.ex = ex
16305 
 
1627 ankur.sing 16306 
  def read(self, iprot):
16307 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16308 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16309 
      return
16310 
    iprot.readStructBegin()
16311 
    while True:
16312 
      (fname, ftype, fid) = iprot.readFieldBegin()
16313 
      if ftype == TType.STOP:
16314 
        break
3064 chandransh 16315 
      if fid == 1:
16316 
        if ftype == TType.STRUCT:
16317 
          self.ex = TransactionServiceException()
16318 
          self.ex.read(iprot)
16319 
        else:
16320 
          iprot.skip(ftype)
1627 ankur.sing 16321 
      else:
16322 
        iprot.skip(ftype)
16323 
      iprot.readFieldEnd()
16324 
    iprot.readStructEnd()
16325 
 
16326 
  def write(self, oprot):
16327 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16328 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16329 
      return
4910 phani.kuma 16330 
    oprot.writeStructBegin('markAsRTOrders_result')
3431 rajveer 16331 
    if self.ex is not None:
3064 chandransh 16332 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
16333 
      self.ex.write(oprot)
16334 
      oprot.writeFieldEnd()
1627 ankur.sing 16335 
    oprot.writeFieldStop()
16336 
    oprot.writeStructEnd()
16337 
 
3431 rajveer 16338 
  def validate(self):
16339 
    return
16340 
 
16341 
 
1627 ankur.sing 16342 
  def __repr__(self):
16343 
    L = ['%s=%r' % (key, value)
16344 
      for key, value in self.__dict__.iteritems()]
16345 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16346 
 
16347 
  def __eq__(self, other):
16348 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16349 
 
16350 
  def __ne__(self, other):
16351 
    return not (self == other)
16352 
 
4910 phani.kuma 16353 
class getRTOrders_args:
16354 
  """
16355 
  Attributes:
16356 
   - providerId
16357 
  """
16358 
 
16359 
  thrift_spec = (
16360 
    None, # 0
16361 
    (1, TType.I64, 'providerId', None, None, ), # 1
16362 
  )
16363 
 
16364 
  def __init__(self, providerId=None,):
16365 
    self.providerId = providerId
16366 
 
16367 
  def read(self, iprot):
16368 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16369 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16370 
      return
16371 
    iprot.readStructBegin()
16372 
    while True:
16373 
      (fname, ftype, fid) = iprot.readFieldBegin()
16374 
      if ftype == TType.STOP:
16375 
        break
16376 
      if fid == 1:
16377 
        if ftype == TType.I64:
16378 
          self.providerId = iprot.readI64();
16379 
        else:
16380 
          iprot.skip(ftype)
16381 
      else:
16382 
        iprot.skip(ftype)
16383 
      iprot.readFieldEnd()
16384 
    iprot.readStructEnd()
16385 
 
16386 
  def write(self, oprot):
16387 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16388 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16389 
      return
16390 
    oprot.writeStructBegin('getRTOrders_args')
16391 
    if self.providerId is not None:
16392 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
16393 
      oprot.writeI64(self.providerId)
16394 
      oprot.writeFieldEnd()
16395 
    oprot.writeFieldStop()
16396 
    oprot.writeStructEnd()
16397 
 
16398 
  def validate(self):
16399 
    return
16400 
 
16401 
 
16402 
  def __repr__(self):
16403 
    L = ['%s=%r' % (key, value)
16404 
      for key, value in self.__dict__.iteritems()]
16405 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16406 
 
16407 
  def __eq__(self, other):
16408 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16409 
 
16410 
  def __ne__(self, other):
16411 
    return not (self == other)
16412 
 
16413 
class getRTOrders_result:
16414 
  """
16415 
  Attributes:
16416 
   - success
16417 
  """
16418 
 
16419 
  thrift_spec = (
16420 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
16421 
  )
16422 
 
16423 
  def __init__(self, success=None,):
16424 
    self.success = success
16425 
 
16426 
  def read(self, iprot):
16427 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16428 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16429 
      return
16430 
    iprot.readStructBegin()
16431 
    while True:
16432 
      (fname, ftype, fid) = iprot.readFieldBegin()
16433 
      if ftype == TType.STOP:
16434 
        break
16435 
      if fid == 0:
16436 
        if ftype == TType.LIST:
16437 
          self.success = []
6188 rajveer 16438 
          (_etype339, _size336) = iprot.readListBegin()
16439 
          for _i340 in xrange(_size336):
16440 
            _elem341 = Order()
16441 
            _elem341.read(iprot)
16442 
            self.success.append(_elem341)
4910 phani.kuma 16443 
          iprot.readListEnd()
16444 
        else:
16445 
          iprot.skip(ftype)
16446 
      else:
16447 
        iprot.skip(ftype)
16448 
      iprot.readFieldEnd()
16449 
    iprot.readStructEnd()
16450 
 
16451 
  def write(self, oprot):
16452 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16453 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16454 
      return
16455 
    oprot.writeStructBegin('getRTOrders_result')
16456 
    if self.success is not None:
16457 
      oprot.writeFieldBegin('success', TType.LIST, 0)
16458 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 16459 
      for iter342 in self.success:
16460 
        iter342.write(oprot)
4910 phani.kuma 16461 
      oprot.writeListEnd()
16462 
      oprot.writeFieldEnd()
16463 
    oprot.writeFieldStop()
16464 
    oprot.writeStructEnd()
16465 
 
16466 
  def validate(self):
16467 
    return
16468 
 
16469 
 
16470 
  def __repr__(self):
16471 
    L = ['%s=%r' % (key, value)
16472 
      for key, value in self.__dict__.iteritems()]
16473 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16474 
 
16475 
  def __eq__(self, other):
16476 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16477 
 
16478 
  def __ne__(self, other):
16479 
    return not (self == other)
16480 
 
3064 chandransh 16481 
class updateNonDeliveryReason_args:
1627 ankur.sing 16482 
  """
16483 
  Attributes:
3064 chandransh 16484 
   - providerId
16485 
   - undeliveredOrders
1627 ankur.sing 16486 
  """
16487 
 
16488 
  thrift_spec = (
3064 chandransh 16489 
    None, # 0
16490 
    (1, TType.I64, 'providerId', None, None, ), # 1
16491 
    (2, TType.MAP, 'undeliveredOrders', (TType.STRING,None,TType.STRING,None), None, ), # 2
1627 ankur.sing 16492 
  )
16493 
 
3064 chandransh 16494 
  def __init__(self, providerId=None, undeliveredOrders=None,):
16495 
    self.providerId = providerId
16496 
    self.undeliveredOrders = undeliveredOrders
1627 ankur.sing 16497 
 
16498 
  def read(self, iprot):
16499 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16500 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16501 
      return
16502 
    iprot.readStructBegin()
16503 
    while True:
16504 
      (fname, ftype, fid) = iprot.readFieldBegin()
16505 
      if ftype == TType.STOP:
16506 
        break
3064 chandransh 16507 
      if fid == 1:
1627 ankur.sing 16508 
        if ftype == TType.I64:
3064 chandransh 16509 
          self.providerId = iprot.readI64();
1627 ankur.sing 16510 
        else:
16511 
          iprot.skip(ftype)
3064 chandransh 16512 
      elif fid == 2:
16513 
        if ftype == TType.MAP:
16514 
          self.undeliveredOrders = {}
6188 rajveer 16515 
          (_ktype344, _vtype345, _size343 ) = iprot.readMapBegin()
16516 
          for _i347 in xrange(_size343):
16517 
            _key348 = iprot.readString();
16518 
            _val349 = iprot.readString();
16519 
            self.undeliveredOrders[_key348] = _val349
3064 chandransh 16520 
          iprot.readMapEnd()
16521 
        else:
16522 
          iprot.skip(ftype)
1627 ankur.sing 16523 
      else:
16524 
        iprot.skip(ftype)
16525 
      iprot.readFieldEnd()
16526 
    iprot.readStructEnd()
16527 
 
16528 
  def write(self, oprot):
16529 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16530 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16531 
      return
3064 chandransh 16532 
    oprot.writeStructBegin('updateNonDeliveryReason_args')
3431 rajveer 16533 
    if self.providerId is not None:
3064 chandransh 16534 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
16535 
      oprot.writeI64(self.providerId)
1627 ankur.sing 16536 
      oprot.writeFieldEnd()
3431 rajveer 16537 
    if self.undeliveredOrders is not None:
3064 chandransh 16538 
      oprot.writeFieldBegin('undeliveredOrders', TType.MAP, 2)
16539 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.undeliveredOrders))
6188 rajveer 16540 
      for kiter350,viter351 in self.undeliveredOrders.items():
16541 
        oprot.writeString(kiter350)
16542 
        oprot.writeString(viter351)
3064 chandransh 16543 
      oprot.writeMapEnd()
16544 
      oprot.writeFieldEnd()
1627 ankur.sing 16545 
    oprot.writeFieldStop()
16546 
    oprot.writeStructEnd()
16547 
 
3431 rajveer 16548 
  def validate(self):
16549 
    return
16550 
 
16551 
 
1627 ankur.sing 16552 
  def __repr__(self):
16553 
    L = ['%s=%r' % (key, value)
16554 
      for key, value in self.__dict__.iteritems()]
16555 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16556 
 
16557 
  def __eq__(self, other):
16558 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16559 
 
16560 
  def __ne__(self, other):
16561 
    return not (self == other)
16562 
 
3064 chandransh 16563 
class updateNonDeliveryReason_result:
1627 ankur.sing 16564 
  """
16565 
  Attributes:
3064 chandransh 16566 
   - ex
1627 ankur.sing 16567 
  """
16568 
 
16569 
  thrift_spec = (
4910 phani.kuma 16570 
    None, # 0
3064 chandransh 16571 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
1627 ankur.sing 16572 
  )
16573 
 
4910 phani.kuma 16574 
  def __init__(self, ex=None,):
3064 chandransh 16575 
    self.ex = ex
1627 ankur.sing 16576 
 
16577 
  def read(self, iprot):
16578 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16579 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16580 
      return
16581 
    iprot.readStructBegin()
16582 
    while True:
16583 
      (fname, ftype, fid) = iprot.readFieldBegin()
16584 
      if ftype == TType.STOP:
16585 
        break
4910 phani.kuma 16586 
      if fid == 1:
16587 
        if ftype == TType.STRUCT:
16588 
          self.ex = TransactionServiceException()
16589 
          self.ex.read(iprot)
16590 
        else:
16591 
          iprot.skip(ftype)
16592 
      else:
16593 
        iprot.skip(ftype)
16594 
      iprot.readFieldEnd()
16595 
    iprot.readStructEnd()
16596 
 
16597 
  def write(self, oprot):
16598 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16599 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16600 
      return
16601 
    oprot.writeStructBegin('updateNonDeliveryReason_result')
16602 
    if self.ex is not None:
16603 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
16604 
      self.ex.write(oprot)
16605 
      oprot.writeFieldEnd()
16606 
    oprot.writeFieldStop()
16607 
    oprot.writeStructEnd()
16608 
 
16609 
  def validate(self):
16610 
    return
16611 
 
16612 
 
16613 
  def __repr__(self):
16614 
    L = ['%s=%r' % (key, value)
16615 
      for key, value in self.__dict__.iteritems()]
16616 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16617 
 
16618 
  def __eq__(self, other):
16619 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16620 
 
16621 
  def __ne__(self, other):
16622 
    return not (self == other)
16623 
 
16624 
class getNonDeliveredOrdersbyCourier_args:
16625 
  """
16626 
  Attributes:
16627 
   - providerId
16628 
  """
16629 
 
16630 
  thrift_spec = (
16631 
    None, # 0
16632 
    (1, TType.I64, 'providerId', None, None, ), # 1
16633 
  )
16634 
 
16635 
  def __init__(self, providerId=None,):
16636 
    self.providerId = providerId
16637 
 
16638 
  def read(self, iprot):
16639 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16640 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16641 
      return
16642 
    iprot.readStructBegin()
16643 
    while True:
16644 
      (fname, ftype, fid) = iprot.readFieldBegin()
16645 
      if ftype == TType.STOP:
16646 
        break
16647 
      if fid == 1:
16648 
        if ftype == TType.I64:
16649 
          self.providerId = iprot.readI64();
16650 
        else:
16651 
          iprot.skip(ftype)
16652 
      else:
16653 
        iprot.skip(ftype)
16654 
      iprot.readFieldEnd()
16655 
    iprot.readStructEnd()
16656 
 
16657 
  def write(self, oprot):
16658 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16659 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16660 
      return
16661 
    oprot.writeStructBegin('getNonDeliveredOrdersbyCourier_args')
16662 
    if self.providerId is not None:
16663 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
16664 
      oprot.writeI64(self.providerId)
16665 
      oprot.writeFieldEnd()
16666 
    oprot.writeFieldStop()
16667 
    oprot.writeStructEnd()
16668 
 
16669 
  def validate(self):
16670 
    return
16671 
 
16672 
 
16673 
  def __repr__(self):
16674 
    L = ['%s=%r' % (key, value)
16675 
      for key, value in self.__dict__.iteritems()]
16676 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16677 
 
16678 
  def __eq__(self, other):
16679 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16680 
 
16681 
  def __ne__(self, other):
16682 
    return not (self == other)
16683 
 
16684 
class getNonDeliveredOrdersbyCourier_result:
16685 
  """
16686 
  Attributes:
16687 
   - success
16688 
  """
16689 
 
16690 
  thrift_spec = (
16691 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
16692 
  )
16693 
 
16694 
  def __init__(self, success=None,):
16695 
    self.success = success
16696 
 
16697 
  def read(self, iprot):
16698 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16699 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16700 
      return
16701 
    iprot.readStructBegin()
16702 
    while True:
16703 
      (fname, ftype, fid) = iprot.readFieldBegin()
16704 
      if ftype == TType.STOP:
16705 
        break
4581 phani.kuma 16706 
      if fid == 0:
16707 
        if ftype == TType.LIST:
16708 
          self.success = []
6188 rajveer 16709 
          (_etype355, _size352) = iprot.readListBegin()
16710 
          for _i356 in xrange(_size352):
16711 
            _elem357 = Order()
16712 
            _elem357.read(iprot)
16713 
            self.success.append(_elem357)
4581 phani.kuma 16714 
          iprot.readListEnd()
16715 
        else:
16716 
          iprot.skip(ftype)
4910 phani.kuma 16717 
      else:
16718 
        iprot.skip(ftype)
16719 
      iprot.readFieldEnd()
16720 
    iprot.readStructEnd()
16721 
 
16722 
  def write(self, oprot):
16723 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16724 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16725 
      return
16726 
    oprot.writeStructBegin('getNonDeliveredOrdersbyCourier_result')
16727 
    if self.success is not None:
16728 
      oprot.writeFieldBegin('success', TType.LIST, 0)
16729 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 16730 
      for iter358 in self.success:
16731 
        iter358.write(oprot)
4910 phani.kuma 16732 
      oprot.writeListEnd()
16733 
      oprot.writeFieldEnd()
16734 
    oprot.writeFieldStop()
16735 
    oprot.writeStructEnd()
16736 
 
16737 
  def validate(self):
16738 
    return
16739 
 
16740 
 
16741 
  def __repr__(self):
16742 
    L = ['%s=%r' % (key, value)
16743 
      for key, value in self.__dict__.iteritems()]
16744 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16745 
 
16746 
  def __eq__(self, other):
16747 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16748 
 
16749 
  def __ne__(self, other):
16750 
    return not (self == other)
16751 
 
16752 
class markOrdersAsLocalConnected_args:
16753 
  """
16754 
  Attributes:
16755 
   - providerId
16756 
   - local_connected_orders
16757 
  """
16758 
 
16759 
  thrift_spec = (
16760 
    None, # 0
16761 
    (1, TType.I64, 'providerId', None, None, ), # 1
16762 
    (2, TType.MAP, 'local_connected_orders', (TType.STRING,None,TType.STRING,None), None, ), # 2
16763 
  )
16764 
 
16765 
  def __init__(self, providerId=None, local_connected_orders=None,):
16766 
    self.providerId = providerId
16767 
    self.local_connected_orders = local_connected_orders
16768 
 
16769 
  def read(self, iprot):
16770 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16771 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16772 
      return
16773 
    iprot.readStructBegin()
16774 
    while True:
16775 
      (fname, ftype, fid) = iprot.readFieldBegin()
16776 
      if ftype == TType.STOP:
16777 
        break
16778 
      if fid == 1:
16779 
        if ftype == TType.I64:
16780 
          self.providerId = iprot.readI64();
16781 
        else:
16782 
          iprot.skip(ftype)
16783 
      elif fid == 2:
16784 
        if ftype == TType.MAP:
16785 
          self.local_connected_orders = {}
6188 rajveer 16786 
          (_ktype360, _vtype361, _size359 ) = iprot.readMapBegin()
16787 
          for _i363 in xrange(_size359):
16788 
            _key364 = iprot.readString();
16789 
            _val365 = iprot.readString();
16790 
            self.local_connected_orders[_key364] = _val365
4910 phani.kuma 16791 
          iprot.readMapEnd()
16792 
        else:
16793 
          iprot.skip(ftype)
16794 
      else:
16795 
        iprot.skip(ftype)
16796 
      iprot.readFieldEnd()
16797 
    iprot.readStructEnd()
16798 
 
16799 
  def write(self, oprot):
16800 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16801 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16802 
      return
16803 
    oprot.writeStructBegin('markOrdersAsLocalConnected_args')
16804 
    if self.providerId is not None:
16805 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
16806 
      oprot.writeI64(self.providerId)
16807 
      oprot.writeFieldEnd()
16808 
    if self.local_connected_orders is not None:
16809 
      oprot.writeFieldBegin('local_connected_orders', TType.MAP, 2)
16810 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.local_connected_orders))
6188 rajveer 16811 
      for kiter366,viter367 in self.local_connected_orders.items():
16812 
        oprot.writeString(kiter366)
16813 
        oprot.writeString(viter367)
4910 phani.kuma 16814 
      oprot.writeMapEnd()
16815 
      oprot.writeFieldEnd()
16816 
    oprot.writeFieldStop()
16817 
    oprot.writeStructEnd()
16818 
 
16819 
  def validate(self):
16820 
    return
16821 
 
16822 
 
16823 
  def __repr__(self):
16824 
    L = ['%s=%r' % (key, value)
16825 
      for key, value in self.__dict__.iteritems()]
16826 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16827 
 
16828 
  def __eq__(self, other):
16829 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16830 
 
16831 
  def __ne__(self, other):
16832 
    return not (self == other)
16833 
 
16834 
class markOrdersAsLocalConnected_result:
16835 
  """
16836 
  Attributes:
16837 
   - ex
16838 
  """
16839 
 
16840 
  thrift_spec = (
16841 
    None, # 0
16842 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
16843 
  )
16844 
 
16845 
  def __init__(self, ex=None,):
16846 
    self.ex = ex
16847 
 
16848 
  def read(self, iprot):
16849 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16850 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16851 
      return
16852 
    iprot.readStructBegin()
16853 
    while True:
16854 
      (fname, ftype, fid) = iprot.readFieldBegin()
16855 
      if ftype == TType.STOP:
16856 
        break
16857 
      if fid == 1:
3064 chandransh 16858 
        if ftype == TType.STRUCT:
16859 
          self.ex = TransactionServiceException()
16860 
          self.ex.read(iprot)
1627 ankur.sing 16861 
        else:
16862 
          iprot.skip(ftype)
16863 
      else:
16864 
        iprot.skip(ftype)
16865 
      iprot.readFieldEnd()
16866 
    iprot.readStructEnd()
16867 
 
16868 
  def write(self, oprot):
16869 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16870 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16871 
      return
4910 phani.kuma 16872 
    oprot.writeStructBegin('markOrdersAsLocalConnected_result')
16873 
    if self.ex is not None:
16874 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
16875 
      self.ex.write(oprot)
16876 
      oprot.writeFieldEnd()
16877 
    oprot.writeFieldStop()
16878 
    oprot.writeStructEnd()
16879 
 
16880 
  def validate(self):
16881 
    return
16882 
 
16883 
 
16884 
  def __repr__(self):
16885 
    L = ['%s=%r' % (key, value)
16886 
      for key, value in self.__dict__.iteritems()]
16887 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16888 
 
16889 
  def __eq__(self, other):
16890 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16891 
 
16892 
  def __ne__(self, other):
16893 
    return not (self == other)
16894 
 
16895 
class getOrdersNotLocalConnected_args:
16896 
  """
16897 
  Attributes:
16898 
   - providerId
16899 
  """
16900 
 
16901 
  thrift_spec = (
16902 
    None, # 0
16903 
    (1, TType.I64, 'providerId', None, None, ), # 1
16904 
  )
16905 
 
16906 
  def __init__(self, providerId=None,):
16907 
    self.providerId = providerId
16908 
 
16909 
  def read(self, iprot):
16910 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16911 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16912 
      return
16913 
    iprot.readStructBegin()
16914 
    while True:
16915 
      (fname, ftype, fid) = iprot.readFieldBegin()
16916 
      if ftype == TType.STOP:
16917 
        break
16918 
      if fid == 1:
16919 
        if ftype == TType.I64:
16920 
          self.providerId = iprot.readI64();
16921 
        else:
16922 
          iprot.skip(ftype)
16923 
      else:
16924 
        iprot.skip(ftype)
16925 
      iprot.readFieldEnd()
16926 
    iprot.readStructEnd()
16927 
 
16928 
  def write(self, oprot):
16929 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16930 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16931 
      return
16932 
    oprot.writeStructBegin('getOrdersNotLocalConnected_args')
16933 
    if self.providerId is not None:
16934 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
16935 
      oprot.writeI64(self.providerId)
16936 
      oprot.writeFieldEnd()
16937 
    oprot.writeFieldStop()
16938 
    oprot.writeStructEnd()
16939 
 
16940 
  def validate(self):
16941 
    return
16942 
 
16943 
 
16944 
  def __repr__(self):
16945 
    L = ['%s=%r' % (key, value)
16946 
      for key, value in self.__dict__.iteritems()]
16947 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16948 
 
16949 
  def __eq__(self, other):
16950 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16951 
 
16952 
  def __ne__(self, other):
16953 
    return not (self == other)
16954 
 
16955 
class getOrdersNotLocalConnected_result:
16956 
  """
16957 
  Attributes:
16958 
   - success
16959 
  """
16960 
 
16961 
  thrift_spec = (
16962 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
16963 
  )
16964 
 
16965 
  def __init__(self, success=None,):
16966 
    self.success = success
16967 
 
16968 
  def read(self, iprot):
16969 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16970 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16971 
      return
16972 
    iprot.readStructBegin()
16973 
    while True:
16974 
      (fname, ftype, fid) = iprot.readFieldBegin()
16975 
      if ftype == TType.STOP:
16976 
        break
16977 
      if fid == 0:
16978 
        if ftype == TType.LIST:
16979 
          self.success = []
6188 rajveer 16980 
          (_etype371, _size368) = iprot.readListBegin()
16981 
          for _i372 in xrange(_size368):
16982 
            _elem373 = Order()
16983 
            _elem373.read(iprot)
16984 
            self.success.append(_elem373)
4910 phani.kuma 16985 
          iprot.readListEnd()
16986 
        else:
16987 
          iprot.skip(ftype)
16988 
      else:
16989 
        iprot.skip(ftype)
16990 
      iprot.readFieldEnd()
16991 
    iprot.readStructEnd()
16992 
 
16993 
  def write(self, oprot):
16994 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16995 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16996 
      return
16997 
    oprot.writeStructBegin('getOrdersNotLocalConnected_result')
4581 phani.kuma 16998 
    if self.success is not None:
16999 
      oprot.writeFieldBegin('success', TType.LIST, 0)
17000 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 17001 
      for iter374 in self.success:
17002 
        iter374.write(oprot)
4581 phani.kuma 17003 
      oprot.writeListEnd()
17004 
      oprot.writeFieldEnd()
4910 phani.kuma 17005 
    oprot.writeFieldStop()
17006 
    oprot.writeStructEnd()
17007 
 
17008 
  def validate(self):
17009 
    return
17010 
 
17011 
 
17012 
  def __repr__(self):
17013 
    L = ['%s=%r' % (key, value)
17014 
      for key, value in self.__dict__.iteritems()]
17015 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17016 
 
17017 
  def __eq__(self, other):
17018 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17019 
 
17020 
  def __ne__(self, other):
17021 
    return not (self == other)
17022 
 
17023 
class markOrdersAsDestinationCityReached_args:
17024 
  """
17025 
  Attributes:
17026 
   - providerId
17027 
   - destination_city_reached_orders
17028 
  """
17029 
 
17030 
  thrift_spec = (
17031 
    None, # 0
17032 
    (1, TType.I64, 'providerId', None, None, ), # 1
17033 
    (2, TType.MAP, 'destination_city_reached_orders', (TType.STRING,None,TType.STRING,None), None, ), # 2
17034 
  )
17035 
 
17036 
  def __init__(self, providerId=None, destination_city_reached_orders=None,):
17037 
    self.providerId = providerId
17038 
    self.destination_city_reached_orders = destination_city_reached_orders
17039 
 
17040 
  def read(self, iprot):
17041 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17042 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17043 
      return
17044 
    iprot.readStructBegin()
17045 
    while True:
17046 
      (fname, ftype, fid) = iprot.readFieldBegin()
17047 
      if ftype == TType.STOP:
17048 
        break
17049 
      if fid == 1:
17050 
        if ftype == TType.I64:
17051 
          self.providerId = iprot.readI64();
17052 
        else:
17053 
          iprot.skip(ftype)
17054 
      elif fid == 2:
17055 
        if ftype == TType.MAP:
17056 
          self.destination_city_reached_orders = {}
6188 rajveer 17057 
          (_ktype376, _vtype377, _size375 ) = iprot.readMapBegin()
17058 
          for _i379 in xrange(_size375):
17059 
            _key380 = iprot.readString();
17060 
            _val381 = iprot.readString();
17061 
            self.destination_city_reached_orders[_key380] = _val381
4910 phani.kuma 17062 
          iprot.readMapEnd()
17063 
        else:
17064 
          iprot.skip(ftype)
17065 
      else:
17066 
        iprot.skip(ftype)
17067 
      iprot.readFieldEnd()
17068 
    iprot.readStructEnd()
17069 
 
17070 
  def write(self, oprot):
17071 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17072 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17073 
      return
17074 
    oprot.writeStructBegin('markOrdersAsDestinationCityReached_args')
17075 
    if self.providerId is not None:
17076 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
17077 
      oprot.writeI64(self.providerId)
17078 
      oprot.writeFieldEnd()
17079 
    if self.destination_city_reached_orders is not None:
17080 
      oprot.writeFieldBegin('destination_city_reached_orders', TType.MAP, 2)
17081 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.destination_city_reached_orders))
6188 rajveer 17082 
      for kiter382,viter383 in self.destination_city_reached_orders.items():
17083 
        oprot.writeString(kiter382)
17084 
        oprot.writeString(viter383)
4910 phani.kuma 17085 
      oprot.writeMapEnd()
17086 
      oprot.writeFieldEnd()
17087 
    oprot.writeFieldStop()
17088 
    oprot.writeStructEnd()
17089 
 
17090 
  def validate(self):
17091 
    return
17092 
 
17093 
 
17094 
  def __repr__(self):
17095 
    L = ['%s=%r' % (key, value)
17096 
      for key, value in self.__dict__.iteritems()]
17097 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17098 
 
17099 
  def __eq__(self, other):
17100 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17101 
 
17102 
  def __ne__(self, other):
17103 
    return not (self == other)
17104 
 
17105 
class markOrdersAsDestinationCityReached_result:
17106 
  """
17107 
  Attributes:
17108 
   - ex
17109 
  """
17110 
 
17111 
  thrift_spec = (
17112 
    None, # 0
17113 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
17114 
  )
17115 
 
17116 
  def __init__(self, ex=None,):
17117 
    self.ex = ex
17118 
 
17119 
  def read(self, iprot):
17120 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17121 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17122 
      return
17123 
    iprot.readStructBegin()
17124 
    while True:
17125 
      (fname, ftype, fid) = iprot.readFieldBegin()
17126 
      if ftype == TType.STOP:
17127 
        break
17128 
      if fid == 1:
17129 
        if ftype == TType.STRUCT:
17130 
          self.ex = TransactionServiceException()
17131 
          self.ex.read(iprot)
17132 
        else:
17133 
          iprot.skip(ftype)
17134 
      else:
17135 
        iprot.skip(ftype)
17136 
      iprot.readFieldEnd()
17137 
    iprot.readStructEnd()
17138 
 
17139 
  def write(self, oprot):
17140 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17141 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17142 
      return
17143 
    oprot.writeStructBegin('markOrdersAsDestinationCityReached_result')
3431 rajveer 17144 
    if self.ex is not None:
3064 chandransh 17145 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
17146 
      self.ex.write(oprot)
1627 ankur.sing 17147 
      oprot.writeFieldEnd()
17148 
    oprot.writeFieldStop()
17149 
    oprot.writeStructEnd()
17150 
 
3431 rajveer 17151 
  def validate(self):
17152 
    return
17153 
 
17154 
 
1627 ankur.sing 17155 
  def __repr__(self):
17156 
    L = ['%s=%r' % (key, value)
17157 
      for key, value in self.__dict__.iteritems()]
17158 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17159 
 
17160 
  def __eq__(self, other):
17161 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17162 
 
17163 
  def __ne__(self, other):
17164 
    return not (self == other)
17165 
 
4910 phani.kuma 17166 
class markOrdersAsFirstDeliveryAttempted_args:
17167 
  """
17168 
  Attributes:
17169 
   - providerId
17170 
   - first_atdl_orders
17171 
  """
17172 
 
17173 
  thrift_spec = (
17174 
    None, # 0
17175 
    (1, TType.I64, 'providerId', None, None, ), # 1
17176 
    (2, TType.MAP, 'first_atdl_orders', (TType.STRING,None,TType.STRING,None), None, ), # 2
17177 
  )
17178 
 
17179 
  def __init__(self, providerId=None, first_atdl_orders=None,):
17180 
    self.providerId = providerId
17181 
    self.first_atdl_orders = first_atdl_orders
17182 
 
17183 
  def read(self, iprot):
17184 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17185 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17186 
      return
17187 
    iprot.readStructBegin()
17188 
    while True:
17189 
      (fname, ftype, fid) = iprot.readFieldBegin()
17190 
      if ftype == TType.STOP:
17191 
        break
17192 
      if fid == 1:
17193 
        if ftype == TType.I64:
17194 
          self.providerId = iprot.readI64();
17195 
        else:
17196 
          iprot.skip(ftype)
17197 
      elif fid == 2:
17198 
        if ftype == TType.MAP:
17199 
          self.first_atdl_orders = {}
6188 rajveer 17200 
          (_ktype385, _vtype386, _size384 ) = iprot.readMapBegin()
17201 
          for _i388 in xrange(_size384):
17202 
            _key389 = iprot.readString();
17203 
            _val390 = iprot.readString();
17204 
            self.first_atdl_orders[_key389] = _val390
4910 phani.kuma 17205 
          iprot.readMapEnd()
17206 
        else:
17207 
          iprot.skip(ftype)
17208 
      else:
17209 
        iprot.skip(ftype)
17210 
      iprot.readFieldEnd()
17211 
    iprot.readStructEnd()
17212 
 
17213 
  def write(self, oprot):
17214 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17215 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17216 
      return
17217 
    oprot.writeStructBegin('markOrdersAsFirstDeliveryAttempted_args')
17218 
    if self.providerId is not None:
17219 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
17220 
      oprot.writeI64(self.providerId)
17221 
      oprot.writeFieldEnd()
17222 
    if self.first_atdl_orders is not None:
17223 
      oprot.writeFieldBegin('first_atdl_orders', TType.MAP, 2)
17224 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.first_atdl_orders))
6188 rajveer 17225 
      for kiter391,viter392 in self.first_atdl_orders.items():
17226 
        oprot.writeString(kiter391)
17227 
        oprot.writeString(viter392)
4910 phani.kuma 17228 
      oprot.writeMapEnd()
17229 
      oprot.writeFieldEnd()
17230 
    oprot.writeFieldStop()
17231 
    oprot.writeStructEnd()
17232 
 
17233 
  def validate(self):
17234 
    return
17235 
 
17236 
 
17237 
  def __repr__(self):
17238 
    L = ['%s=%r' % (key, value)
17239 
      for key, value in self.__dict__.iteritems()]
17240 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17241 
 
17242 
  def __eq__(self, other):
17243 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17244 
 
17245 
  def __ne__(self, other):
17246 
    return not (self == other)
17247 
 
17248 
class markOrdersAsFirstDeliveryAttempted_result:
17249 
  """
17250 
  Attributes:
17251 
   - ex
17252 
  """
17253 
 
17254 
  thrift_spec = (
17255 
    None, # 0
17256 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
17257 
  )
17258 
 
17259 
  def __init__(self, ex=None,):
17260 
    self.ex = ex
17261 
 
17262 
  def read(self, iprot):
17263 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17264 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17265 
      return
17266 
    iprot.readStructBegin()
17267 
    while True:
17268 
      (fname, ftype, fid) = iprot.readFieldBegin()
17269 
      if ftype == TType.STOP:
17270 
        break
17271 
      if fid == 1:
17272 
        if ftype == TType.STRUCT:
17273 
          self.ex = TransactionServiceException()
17274 
          self.ex.read(iprot)
17275 
        else:
17276 
          iprot.skip(ftype)
17277 
      else:
17278 
        iprot.skip(ftype)
17279 
      iprot.readFieldEnd()
17280 
    iprot.readStructEnd()
17281 
 
17282 
  def write(self, oprot):
17283 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17284 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17285 
      return
17286 
    oprot.writeStructBegin('markOrdersAsFirstDeliveryAttempted_result')
17287 
    if self.ex is not None:
17288 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
17289 
      self.ex.write(oprot)
17290 
      oprot.writeFieldEnd()
17291 
    oprot.writeFieldStop()
17292 
    oprot.writeStructEnd()
17293 
 
17294 
  def validate(self):
17295 
    return
17296 
 
17297 
 
17298 
  def __repr__(self):
17299 
    L = ['%s=%r' % (key, value)
17300 
      for key, value in self.__dict__.iteritems()]
17301 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17302 
 
17303 
  def __eq__(self, other):
17304 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17305 
 
17306 
  def __ne__(self, other):
17307 
    return not (self == other)
17308 
 
3064 chandransh 17309 
class getUndeliveredOrders_args:
1886 ankur.sing 17310 
  """
17311 
  Attributes:
3064 chandransh 17312 
   - providerId
17313 
   - warehouseId
1886 ankur.sing 17314 
  """
1627 ankur.sing 17315 
 
1886 ankur.sing 17316 
  thrift_spec = (
17317 
    None, # 0
3064 chandransh 17318 
    (1, TType.I64, 'providerId', None, None, ), # 1
17319 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
1886 ankur.sing 17320 
  )
17321 
 
3064 chandransh 17322 
  def __init__(self, providerId=None, warehouseId=None,):
17323 
    self.providerId = providerId
17324 
    self.warehouseId = warehouseId
1886 ankur.sing 17325 
 
17326 
  def read(self, iprot):
17327 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17328 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17329 
      return
17330 
    iprot.readStructBegin()
17331 
    while True:
17332 
      (fname, ftype, fid) = iprot.readFieldBegin()
17333 
      if ftype == TType.STOP:
17334 
        break
17335 
      if fid == 1:
17336 
        if ftype == TType.I64:
3064 chandransh 17337 
          self.providerId = iprot.readI64();
1886 ankur.sing 17338 
        else:
17339 
          iprot.skip(ftype)
3064 chandransh 17340 
      elif fid == 2:
17341 
        if ftype == TType.I64:
17342 
          self.warehouseId = iprot.readI64();
17343 
        else:
17344 
          iprot.skip(ftype)
1886 ankur.sing 17345 
      else:
17346 
        iprot.skip(ftype)
17347 
      iprot.readFieldEnd()
17348 
    iprot.readStructEnd()
17349 
 
17350 
  def write(self, oprot):
17351 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17352 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17353 
      return
3064 chandransh 17354 
    oprot.writeStructBegin('getUndeliveredOrders_args')
3431 rajveer 17355 
    if self.providerId is not None:
3064 chandransh 17356 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
17357 
      oprot.writeI64(self.providerId)
1886 ankur.sing 17358 
      oprot.writeFieldEnd()
3431 rajveer 17359 
    if self.warehouseId is not None:
3064 chandransh 17360 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
17361 
      oprot.writeI64(self.warehouseId)
17362 
      oprot.writeFieldEnd()
1886 ankur.sing 17363 
    oprot.writeFieldStop()
17364 
    oprot.writeStructEnd()
17365 
 
3431 rajveer 17366 
  def validate(self):
17367 
    return
17368 
 
17369 
 
1886 ankur.sing 17370 
  def __repr__(self):
17371 
    L = ['%s=%r' % (key, value)
17372 
      for key, value in self.__dict__.iteritems()]
17373 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17374 
 
17375 
  def __eq__(self, other):
17376 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17377 
 
17378 
  def __ne__(self, other):
17379 
    return not (self == other)
17380 
 
3064 chandransh 17381 
class getUndeliveredOrders_result:
1886 ankur.sing 17382 
  """
17383 
  Attributes:
17384 
   - success
17385 
  """
17386 
 
17387 
  thrift_spec = (
17388 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
17389 
  )
17390 
 
17391 
  def __init__(self, success=None,):
17392 
    self.success = success
17393 
 
17394 
  def read(self, iprot):
17395 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17396 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17397 
      return
17398 
    iprot.readStructBegin()
17399 
    while True:
17400 
      (fname, ftype, fid) = iprot.readFieldBegin()
17401 
      if ftype == TType.STOP:
17402 
        break
17403 
      if fid == 0:
17404 
        if ftype == TType.LIST:
17405 
          self.success = []
6188 rajveer 17406 
          (_etype396, _size393) = iprot.readListBegin()
17407 
          for _i397 in xrange(_size393):
17408 
            _elem398 = Order()
17409 
            _elem398.read(iprot)
17410 
            self.success.append(_elem398)
1886 ankur.sing 17411 
          iprot.readListEnd()
17412 
        else:
17413 
          iprot.skip(ftype)
17414 
      else:
17415 
        iprot.skip(ftype)
17416 
      iprot.readFieldEnd()
17417 
    iprot.readStructEnd()
17418 
 
17419 
  def write(self, oprot):
17420 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17421 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17422 
      return
3064 chandransh 17423 
    oprot.writeStructBegin('getUndeliveredOrders_result')
3431 rajveer 17424 
    if self.success is not None:
1886 ankur.sing 17425 
      oprot.writeFieldBegin('success', TType.LIST, 0)
17426 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 17427 
      for iter399 in self.success:
17428 
        iter399.write(oprot)
1886 ankur.sing 17429 
      oprot.writeListEnd()
17430 
      oprot.writeFieldEnd()
17431 
    oprot.writeFieldStop()
17432 
    oprot.writeStructEnd()
17433 
 
3431 rajveer 17434 
  def validate(self):
17435 
    return
17436 
 
17437 
 
1886 ankur.sing 17438 
  def __repr__(self):
17439 
    L = ['%s=%r' % (key, value)
17440 
      for key, value in self.__dict__.iteritems()]
17441 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17442 
 
17443 
  def __eq__(self, other):
17444 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17445 
 
17446 
  def __ne__(self, other):
17447 
    return not (self == other)
17448 
 
4783 phani.kuma 17449 
class getUndeliveredOrdersExpectedDeliveryDateNotMet_args:
17450 
 
17451 
  thrift_spec = (
17452 
  )
17453 
 
17454 
  def read(self, iprot):
17455 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17456 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17457 
      return
17458 
    iprot.readStructBegin()
17459 
    while True:
17460 
      (fname, ftype, fid) = iprot.readFieldBegin()
17461 
      if ftype == TType.STOP:
17462 
        break
17463 
      else:
17464 
        iprot.skip(ftype)
17465 
      iprot.readFieldEnd()
17466 
    iprot.readStructEnd()
17467 
 
17468 
  def write(self, oprot):
17469 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17470 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17471 
      return
17472 
    oprot.writeStructBegin('getUndeliveredOrdersExpectedDeliveryDateNotMet_args')
17473 
    oprot.writeFieldStop()
17474 
    oprot.writeStructEnd()
17475 
 
17476 
  def validate(self):
17477 
    return
17478 
 
17479 
 
17480 
  def __repr__(self):
17481 
    L = ['%s=%r' % (key, value)
17482 
      for key, value in self.__dict__.iteritems()]
17483 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17484 
 
17485 
  def __eq__(self, other):
17486 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17487 
 
17488 
  def __ne__(self, other):
17489 
    return not (self == other)
17490 
 
17491 
class getUndeliveredOrdersExpectedDeliveryDateNotMet_result:
17492 
  """
17493 
  Attributes:
17494 
   - success
17495 
  """
17496 
 
17497 
  thrift_spec = (
17498 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
17499 
  )
17500 
 
17501 
  def __init__(self, success=None,):
17502 
    self.success = success
17503 
 
17504 
  def read(self, iprot):
17505 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17506 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17507 
      return
17508 
    iprot.readStructBegin()
17509 
    while True:
17510 
      (fname, ftype, fid) = iprot.readFieldBegin()
17511 
      if ftype == TType.STOP:
17512 
        break
17513 
      if fid == 0:
17514 
        if ftype == TType.LIST:
17515 
          self.success = []
6188 rajveer 17516 
          (_etype403, _size400) = iprot.readListBegin()
17517 
          for _i404 in xrange(_size400):
17518 
            _elem405 = Order()
17519 
            _elem405.read(iprot)
17520 
            self.success.append(_elem405)
4783 phani.kuma 17521 
          iprot.readListEnd()
17522 
        else:
17523 
          iprot.skip(ftype)
17524 
      else:
17525 
        iprot.skip(ftype)
17526 
      iprot.readFieldEnd()
17527 
    iprot.readStructEnd()
17528 
 
17529 
  def write(self, oprot):
17530 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17531 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17532 
      return
17533 
    oprot.writeStructBegin('getUndeliveredOrdersExpectedDeliveryDateNotMet_result')
17534 
    if self.success is not None:
17535 
      oprot.writeFieldBegin('success', TType.LIST, 0)
17536 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 17537 
      for iter406 in self.success:
17538 
        iter406.write(oprot)
4783 phani.kuma 17539 
      oprot.writeListEnd()
17540 
      oprot.writeFieldEnd()
17541 
    oprot.writeFieldStop()
17542 
    oprot.writeStructEnd()
17543 
 
17544 
  def validate(self):
17545 
    return
17546 
 
17547 
 
17548 
  def __repr__(self):
17549 
    L = ['%s=%r' % (key, value)
17550 
      for key, value in self.__dict__.iteritems()]
17551 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17552 
 
17553 
  def __eq__(self, other):
17554 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17555 
 
17556 
  def __ne__(self, other):
17557 
    return not (self == other)
17558 
 
2536 chandransh 17559 
class toggleDOAFlag_args:
17560 
  """
17561 
  Attributes:
17562 
   - orderId
17563 
  """
1886 ankur.sing 17564 
 
2536 chandransh 17565 
  thrift_spec = (
17566 
    None, # 0
17567 
    (1, TType.I64, 'orderId', None, None, ), # 1
17568 
  )
17569 
 
17570 
  def __init__(self, orderId=None,):
17571 
    self.orderId = orderId
17572 
 
17573 
  def read(self, iprot):
17574 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17575 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17576 
      return
17577 
    iprot.readStructBegin()
17578 
    while True:
17579 
      (fname, ftype, fid) = iprot.readFieldBegin()
17580 
      if ftype == TType.STOP:
17581 
        break
17582 
      if fid == 1:
17583 
        if ftype == TType.I64:
17584 
          self.orderId = iprot.readI64();
17585 
        else:
17586 
          iprot.skip(ftype)
17587 
      else:
17588 
        iprot.skip(ftype)
17589 
      iprot.readFieldEnd()
17590 
    iprot.readStructEnd()
17591 
 
17592 
  def write(self, oprot):
17593 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17594 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17595 
      return
17596 
    oprot.writeStructBegin('toggleDOAFlag_args')
3431 rajveer 17597 
    if self.orderId is not None:
2536 chandransh 17598 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
17599 
      oprot.writeI64(self.orderId)
17600 
      oprot.writeFieldEnd()
17601 
    oprot.writeFieldStop()
17602 
    oprot.writeStructEnd()
17603 
 
3431 rajveer 17604 
  def validate(self):
17605 
    return
17606 
 
17607 
 
2536 chandransh 17608 
  def __repr__(self):
17609 
    L = ['%s=%r' % (key, value)
17610 
      for key, value in self.__dict__.iteritems()]
17611 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17612 
 
17613 
  def __eq__(self, other):
17614 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17615 
 
17616 
  def __ne__(self, other):
17617 
    return not (self == other)
17618 
 
17619 
class toggleDOAFlag_result:
17620 
  """
17621 
  Attributes:
17622 
   - success
17623 
   - ex
17624 
  """
17625 
 
17626 
  thrift_spec = (
17627 
    (0, TType.BOOL, 'success', None, None, ), # 0
17628 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
17629 
  )
17630 
 
17631 
  def __init__(self, success=None, ex=None,):
17632 
    self.success = success
17633 
    self.ex = ex
17634 
 
17635 
  def read(self, iprot):
17636 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17637 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17638 
      return
17639 
    iprot.readStructBegin()
17640 
    while True:
17641 
      (fname, ftype, fid) = iprot.readFieldBegin()
17642 
      if ftype == TType.STOP:
17643 
        break
17644 
      if fid == 0:
17645 
        if ftype == TType.BOOL:
17646 
          self.success = iprot.readBool();
17647 
        else:
17648 
          iprot.skip(ftype)
17649 
      elif fid == 1:
17650 
        if ftype == TType.STRUCT:
17651 
          self.ex = TransactionServiceException()
17652 
          self.ex.read(iprot)
17653 
        else:
17654 
          iprot.skip(ftype)
17655 
      else:
17656 
        iprot.skip(ftype)
17657 
      iprot.readFieldEnd()
17658 
    iprot.readStructEnd()
17659 
 
17660 
  def write(self, oprot):
17661 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17662 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17663 
      return
17664 
    oprot.writeStructBegin('toggleDOAFlag_result')
3431 rajveer 17665 
    if self.success is not None:
2536 chandransh 17666 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
17667 
      oprot.writeBool(self.success)
17668 
      oprot.writeFieldEnd()
3431 rajveer 17669 
    if self.ex is not None:
2536 chandransh 17670 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
17671 
      self.ex.write(oprot)
17672 
      oprot.writeFieldEnd()
17673 
    oprot.writeFieldStop()
17674 
    oprot.writeStructEnd()
17675 
 
3431 rajveer 17676 
  def validate(self):
17677 
    return
17678 
 
17679 
 
2536 chandransh 17680 
  def __repr__(self):
17681 
    L = ['%s=%r' % (key, value)
17682 
      for key, value in self.__dict__.iteritems()]
17683 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17684 
 
17685 
  def __eq__(self, other):
17686 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17687 
 
17688 
  def __ne__(self, other):
17689 
    return not (self == other)
17690 
 
4712 rajveer 17691 
class markOrderAsDelivered_args:
17692 
  """
17693 
  Attributes:
17694 
   - orderId
17695 
   - deliveryTimestamp
17696 
   - receiver
17697 
  """
17698 
 
17699 
  thrift_spec = None
17700 
  def __init__(self, orderId=None, deliveryTimestamp=None, receiver=None,):
17701 
    self.orderId = orderId
17702 
    self.deliveryTimestamp = deliveryTimestamp
17703 
    self.receiver = receiver
17704 
 
17705 
  def read(self, iprot):
17706 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17707 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17708 
      return
17709 
    iprot.readStructBegin()
17710 
    while True:
17711 
      (fname, ftype, fid) = iprot.readFieldBegin()
17712 
      if ftype == TType.STOP:
17713 
        break
17714 
      if fid == 1:
17715 
        if ftype == TType.I64:
17716 
          self.orderId = iprot.readI64();
17717 
        else:
17718 
          iprot.skip(ftype)
17719 
      elif fid == 2:
17720 
        if ftype == TType.I64:
17721 
          self.deliveryTimestamp = iprot.readI64();
17722 
        else:
17723 
          iprot.skip(ftype)
17724 
      elif fid == -1:
17725 
        if ftype == TType.STRING:
17726 
          self.receiver = iprot.readString();
17727 
        else:
17728 
          iprot.skip(ftype)
17729 
      else:
17730 
        iprot.skip(ftype)
17731 
      iprot.readFieldEnd()
17732 
    iprot.readStructEnd()
17733 
 
17734 
  def write(self, oprot):
17735 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17736 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17737 
      return
17738 
    oprot.writeStructBegin('markOrderAsDelivered_args')
17739 
    if self.receiver is not None:
17740 
      oprot.writeFieldBegin('receiver', TType.STRING, -1)
17741 
      oprot.writeString(self.receiver)
17742 
      oprot.writeFieldEnd()
17743 
    if self.orderId is not None:
17744 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
17745 
      oprot.writeI64(self.orderId)
17746 
      oprot.writeFieldEnd()
17747 
    if self.deliveryTimestamp is not None:
17748 
      oprot.writeFieldBegin('deliveryTimestamp', TType.I64, 2)
17749 
      oprot.writeI64(self.deliveryTimestamp)
17750 
      oprot.writeFieldEnd()
17751 
    oprot.writeFieldStop()
17752 
    oprot.writeStructEnd()
17753 
 
17754 
  def validate(self):
17755 
    return
17756 
 
17757 
 
17758 
  def __repr__(self):
17759 
    L = ['%s=%r' % (key, value)
17760 
      for key, value in self.__dict__.iteritems()]
17761 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17762 
 
17763 
  def __eq__(self, other):
17764 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17765 
 
17766 
  def __ne__(self, other):
17767 
    return not (self == other)
17768 
 
17769 
class markOrderAsDelivered_result:
17770 
  """
17771 
  Attributes:
17772 
   - ex
17773 
  """
17774 
 
17775 
  thrift_spec = (
17776 
    None, # 0
17777 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
17778 
  )
17779 
 
17780 
  def __init__(self, ex=None,):
17781 
    self.ex = ex
17782 
 
17783 
  def read(self, iprot):
17784 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17785 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17786 
      return
17787 
    iprot.readStructBegin()
17788 
    while True:
17789 
      (fname, ftype, fid) = iprot.readFieldBegin()
17790 
      if ftype == TType.STOP:
17791 
        break
17792 
      if fid == 1:
17793 
        if ftype == TType.STRUCT:
17794 
          self.ex = TransactionServiceException()
17795 
          self.ex.read(iprot)
17796 
        else:
17797 
          iprot.skip(ftype)
17798 
      else:
17799 
        iprot.skip(ftype)
17800 
      iprot.readFieldEnd()
17801 
    iprot.readStructEnd()
17802 
 
17803 
  def write(self, oprot):
17804 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17805 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17806 
      return
17807 
    oprot.writeStructBegin('markOrderAsDelivered_result')
17808 
    if self.ex is not None:
17809 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
17810 
      self.ex.write(oprot)
17811 
      oprot.writeFieldEnd()
17812 
    oprot.writeFieldStop()
17813 
    oprot.writeStructEnd()
17814 
 
17815 
  def validate(self):
17816 
    return
17817 
 
17818 
 
17819 
  def __repr__(self):
17820 
    L = ['%s=%r' % (key, value)
17821 
      for key, value in self.__dict__.iteritems()]
17822 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17823 
 
17824 
  def __eq__(self, other):
17825 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17826 
 
17827 
  def __ne__(self, other):
17828 
    return not (self == other)
17829 
 
5553 rajveer 17830 
class markOrderAsReceivedAtStore_args:
17831 
  """
17832 
  Attributes:
17833 
   - orderId
17834 
   - deliveryTimestamp
17835 
  """
17836 
 
17837 
  thrift_spec = (
17838 
    None, # 0
17839 
    (1, TType.I64, 'orderId', None, None, ), # 1
17840 
    (2, TType.I64, 'deliveryTimestamp', None, None, ), # 2
17841 
  )
17842 
 
17843 
  def __init__(self, orderId=None, deliveryTimestamp=None,):
17844 
    self.orderId = orderId
17845 
    self.deliveryTimestamp = deliveryTimestamp
17846 
 
17847 
  def read(self, iprot):
17848 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17849 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17850 
      return
17851 
    iprot.readStructBegin()
17852 
    while True:
17853 
      (fname, ftype, fid) = iprot.readFieldBegin()
17854 
      if ftype == TType.STOP:
17855 
        break
17856 
      if fid == 1:
17857 
        if ftype == TType.I64:
17858 
          self.orderId = iprot.readI64();
17859 
        else:
17860 
          iprot.skip(ftype)
17861 
      elif fid == 2:
17862 
        if ftype == TType.I64:
17863 
          self.deliveryTimestamp = iprot.readI64();
17864 
        else:
17865 
          iprot.skip(ftype)
17866 
      else:
17867 
        iprot.skip(ftype)
17868 
      iprot.readFieldEnd()
17869 
    iprot.readStructEnd()
17870 
 
17871 
  def write(self, oprot):
17872 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17873 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17874 
      return
17875 
    oprot.writeStructBegin('markOrderAsReceivedAtStore_args')
17876 
    if self.orderId is not None:
17877 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
17878 
      oprot.writeI64(self.orderId)
17879 
      oprot.writeFieldEnd()
17880 
    if self.deliveryTimestamp is not None:
17881 
      oprot.writeFieldBegin('deliveryTimestamp', TType.I64, 2)
17882 
      oprot.writeI64(self.deliveryTimestamp)
17883 
      oprot.writeFieldEnd()
17884 
    oprot.writeFieldStop()
17885 
    oprot.writeStructEnd()
17886 
 
17887 
  def validate(self):
17888 
    return
17889 
 
17890 
 
17891 
  def __repr__(self):
17892 
    L = ['%s=%r' % (key, value)
17893 
      for key, value in self.__dict__.iteritems()]
17894 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17895 
 
17896 
  def __eq__(self, other):
17897 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17898 
 
17899 
  def __ne__(self, other):
17900 
    return not (self == other)
17901 
 
17902 
class markOrderAsReceivedAtStore_result:
17903 
  """
17904 
  Attributes:
17905 
   - ex
17906 
  """
17907 
 
17908 
  thrift_spec = (
17909 
    None, # 0
17910 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
17911 
  )
17912 
 
17913 
  def __init__(self, ex=None,):
17914 
    self.ex = ex
17915 
 
17916 
  def read(self, iprot):
17917 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17918 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17919 
      return
17920 
    iprot.readStructBegin()
17921 
    while True:
17922 
      (fname, ftype, fid) = iprot.readFieldBegin()
17923 
      if ftype == TType.STOP:
17924 
        break
17925 
      if fid == 1:
17926 
        if ftype == TType.STRUCT:
17927 
          self.ex = TransactionServiceException()
17928 
          self.ex.read(iprot)
17929 
        else:
17930 
          iprot.skip(ftype)
17931 
      else:
17932 
        iprot.skip(ftype)
17933 
      iprot.readFieldEnd()
17934 
    iprot.readStructEnd()
17935 
 
17936 
  def write(self, oprot):
17937 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17938 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17939 
      return
17940 
    oprot.writeStructBegin('markOrderAsReceivedAtStore_result')
17941 
    if self.ex is not None:
17942 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
17943 
      self.ex.write(oprot)
17944 
      oprot.writeFieldEnd()
17945 
    oprot.writeFieldStop()
17946 
    oprot.writeStructEnd()
17947 
 
17948 
  def validate(self):
17949 
    return
17950 
 
17951 
 
17952 
  def __repr__(self):
17953 
    L = ['%s=%r' % (key, value)
17954 
      for key, value in self.__dict__.iteritems()]
17955 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17956 
 
17957 
  def __eq__(self, other):
17958 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17959 
 
17960 
  def __ne__(self, other):
17961 
    return not (self == other)
17962 
 
4454 rajveer 17963 
class markOrderDoaRequestReceived_args:
17964 
  """
17965 
  Attributes:
17966 
   - orderId
17967 
  """
17968 
 
17969 
  thrift_spec = (
17970 
    None, # 0
17971 
    (1, TType.I64, 'orderId', None, None, ), # 1
17972 
  )
17973 
 
17974 
  def __init__(self, orderId=None,):
17975 
    self.orderId = orderId
17976 
 
17977 
  def read(self, iprot):
17978 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17979 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17980 
      return
17981 
    iprot.readStructBegin()
17982 
    while True:
17983 
      (fname, ftype, fid) = iprot.readFieldBegin()
17984 
      if ftype == TType.STOP:
17985 
        break
17986 
      if fid == 1:
17987 
        if ftype == TType.I64:
17988 
          self.orderId = iprot.readI64();
17989 
        else:
17990 
          iprot.skip(ftype)
17991 
      else:
17992 
        iprot.skip(ftype)
17993 
      iprot.readFieldEnd()
17994 
    iprot.readStructEnd()
17995 
 
17996 
  def write(self, oprot):
17997 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17998 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17999 
      return
18000 
    oprot.writeStructBegin('markOrderDoaRequestReceived_args')
18001 
    if self.orderId is not None:
18002 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
18003 
      oprot.writeI64(self.orderId)
18004 
      oprot.writeFieldEnd()
18005 
    oprot.writeFieldStop()
18006 
    oprot.writeStructEnd()
18007 
 
18008 
  def validate(self):
18009 
    return
18010 
 
18011 
 
18012 
  def __repr__(self):
18013 
    L = ['%s=%r' % (key, value)
18014 
      for key, value in self.__dict__.iteritems()]
18015 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18016 
 
18017 
  def __eq__(self, other):
18018 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18019 
 
18020 
  def __ne__(self, other):
18021 
    return not (self == other)
18022 
 
18023 
class markOrderDoaRequestReceived_result:
18024 
  """
18025 
  Attributes:
18026 
   - success
18027 
   - ex
18028 
  """
18029 
 
18030 
  thrift_spec = (
18031 
    (0, TType.BOOL, 'success', None, None, ), # 0
18032 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
18033 
  )
18034 
 
18035 
  def __init__(self, success=None, ex=None,):
18036 
    self.success = success
18037 
    self.ex = ex
18038 
 
18039 
  def read(self, iprot):
18040 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18041 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18042 
      return
18043 
    iprot.readStructBegin()
18044 
    while True:
18045 
      (fname, ftype, fid) = iprot.readFieldBegin()
18046 
      if ftype == TType.STOP:
18047 
        break
18048 
      if fid == 0:
18049 
        if ftype == TType.BOOL:
18050 
          self.success = iprot.readBool();
18051 
        else:
18052 
          iprot.skip(ftype)
18053 
      elif fid == 1:
18054 
        if ftype == TType.STRUCT:
18055 
          self.ex = TransactionServiceException()
18056 
          self.ex.read(iprot)
18057 
        else:
18058 
          iprot.skip(ftype)
18059 
      else:
18060 
        iprot.skip(ftype)
18061 
      iprot.readFieldEnd()
18062 
    iprot.readStructEnd()
18063 
 
18064 
  def write(self, oprot):
18065 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18066 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18067 
      return
18068 
    oprot.writeStructBegin('markOrderDoaRequestReceived_result')
18069 
    if self.success is not None:
18070 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
18071 
      oprot.writeBool(self.success)
18072 
      oprot.writeFieldEnd()
18073 
    if self.ex is not None:
18074 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
18075 
      self.ex.write(oprot)
18076 
      oprot.writeFieldEnd()
18077 
    oprot.writeFieldStop()
18078 
    oprot.writeStructEnd()
18079 
 
18080 
  def validate(self):
18081 
    return
18082 
 
18083 
 
18084 
  def __repr__(self):
18085 
    L = ['%s=%r' % (key, value)
18086 
      for key, value in self.__dict__.iteritems()]
18087 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18088 
 
18089 
  def __eq__(self, other):
18090 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18091 
 
18092 
  def __ne__(self, other):
18093 
    return not (self == other)
18094 
 
18095 
class markOrderDoaRequestAuthorized_args:
18096 
  """
18097 
  Attributes:
18098 
   - orderId
18099 
   - isAuthorized
18100 
  """
18101 
 
18102 
  thrift_spec = (
18103 
    None, # 0
18104 
    (1, TType.I64, 'orderId', None, None, ), # 1
18105 
    (2, TType.BOOL, 'isAuthorized', None, None, ), # 2
18106 
  )
18107 
 
18108 
  def __init__(self, orderId=None, isAuthorized=None,):
18109 
    self.orderId = orderId
18110 
    self.isAuthorized = isAuthorized
18111 
 
18112 
  def read(self, iprot):
18113 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18114 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18115 
      return
18116 
    iprot.readStructBegin()
18117 
    while True:
18118 
      (fname, ftype, fid) = iprot.readFieldBegin()
18119 
      if ftype == TType.STOP:
18120 
        break
18121 
      if fid == 1:
18122 
        if ftype == TType.I64:
18123 
          self.orderId = iprot.readI64();
18124 
        else:
18125 
          iprot.skip(ftype)
18126 
      elif fid == 2:
18127 
        if ftype == TType.BOOL:
18128 
          self.isAuthorized = iprot.readBool();
18129 
        else:
18130 
          iprot.skip(ftype)
18131 
      else:
18132 
        iprot.skip(ftype)
18133 
      iprot.readFieldEnd()
18134 
    iprot.readStructEnd()
18135 
 
18136 
  def write(self, oprot):
18137 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18138 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18139 
      return
18140 
    oprot.writeStructBegin('markOrderDoaRequestAuthorized_args')
18141 
    if self.orderId is not None:
18142 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
18143 
      oprot.writeI64(self.orderId)
18144 
      oprot.writeFieldEnd()
18145 
    if self.isAuthorized is not None:
18146 
      oprot.writeFieldBegin('isAuthorized', TType.BOOL, 2)
18147 
      oprot.writeBool(self.isAuthorized)
18148 
      oprot.writeFieldEnd()
18149 
    oprot.writeFieldStop()
18150 
    oprot.writeStructEnd()
18151 
 
18152 
  def validate(self):
18153 
    return
18154 
 
18155 
 
18156 
  def __repr__(self):
18157 
    L = ['%s=%r' % (key, value)
18158 
      for key, value in self.__dict__.iteritems()]
18159 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18160 
 
18161 
  def __eq__(self, other):
18162 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18163 
 
18164 
  def __ne__(self, other):
18165 
    return not (self == other)
18166 
 
18167 
class markOrderDoaRequestAuthorized_result:
18168 
  """
18169 
  Attributes:
18170 
   - success
18171 
   - ex
18172 
  """
18173 
 
18174 
  thrift_spec = (
18175 
    (0, TType.BOOL, 'success', None, None, ), # 0
18176 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
18177 
  )
18178 
 
18179 
  def __init__(self, success=None, ex=None,):
18180 
    self.success = success
18181 
    self.ex = ex
18182 
 
18183 
  def read(self, iprot):
18184 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18185 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18186 
      return
18187 
    iprot.readStructBegin()
18188 
    while True:
18189 
      (fname, ftype, fid) = iprot.readFieldBegin()
18190 
      if ftype == TType.STOP:
18191 
        break
18192 
      if fid == 0:
18193 
        if ftype == TType.BOOL:
18194 
          self.success = iprot.readBool();
18195 
        else:
18196 
          iprot.skip(ftype)
18197 
      elif fid == 1:
18198 
        if ftype == TType.STRUCT:
18199 
          self.ex = TransactionServiceException()
18200 
          self.ex.read(iprot)
18201 
        else:
18202 
          iprot.skip(ftype)
18203 
      else:
18204 
        iprot.skip(ftype)
18205 
      iprot.readFieldEnd()
18206 
    iprot.readStructEnd()
18207 
 
18208 
  def write(self, oprot):
18209 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18210 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18211 
      return
18212 
    oprot.writeStructBegin('markOrderDoaRequestAuthorized_result')
18213 
    if self.success is not None:
18214 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
18215 
      oprot.writeBool(self.success)
18216 
      oprot.writeFieldEnd()
18217 
    if self.ex is not None:
18218 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
18219 
      self.ex.write(oprot)
18220 
      oprot.writeFieldEnd()
18221 
    oprot.writeFieldStop()
18222 
    oprot.writeStructEnd()
18223 
 
18224 
  def validate(self):
18225 
    return
18226 
 
18227 
 
18228 
  def __repr__(self):
18229 
    L = ['%s=%r' % (key, value)
18230 
      for key, value in self.__dict__.iteritems()]
18231 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18232 
 
18233 
  def __eq__(self, other):
18234 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18235 
 
18236 
  def __ne__(self, other):
18237 
    return not (self == other)
18238 
 
4488 rajveer 18239 
class markOrderReturnRequestReceived_args:
18240 
  """
18241 
  Attributes:
18242 
   - orderId
18243 
  """
18244 
 
18245 
  thrift_spec = (
18246 
    None, # 0
18247 
    (1, TType.I64, 'orderId', None, None, ), # 1
18248 
  )
18249 
 
18250 
  def __init__(self, orderId=None,):
18251 
    self.orderId = orderId
18252 
 
18253 
  def read(self, iprot):
18254 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18255 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18256 
      return
18257 
    iprot.readStructBegin()
18258 
    while True:
18259 
      (fname, ftype, fid) = iprot.readFieldBegin()
18260 
      if ftype == TType.STOP:
18261 
        break
18262 
      if fid == 1:
18263 
        if ftype == TType.I64:
18264 
          self.orderId = iprot.readI64();
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('markOrderReturnRequestReceived_args')
18277 
    if self.orderId is not None:
18278 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
18279 
      oprot.writeI64(self.orderId)
18280 
      oprot.writeFieldEnd()
18281 
    oprot.writeFieldStop()
18282 
    oprot.writeStructEnd()
18283 
 
18284 
  def validate(self):
18285 
    return
18286 
 
18287 
 
18288 
  def __repr__(self):
18289 
    L = ['%s=%r' % (key, value)
18290 
      for key, value in self.__dict__.iteritems()]
18291 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18292 
 
18293 
  def __eq__(self, other):
18294 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18295 
 
18296 
  def __ne__(self, other):
18297 
    return not (self == other)
18298 
 
18299 
class markOrderReturnRequestReceived_result:
18300 
  """
18301 
  Attributes:
18302 
   - success
18303 
   - ex
18304 
  """
18305 
 
18306 
  thrift_spec = (
18307 
    (0, TType.BOOL, 'success', None, None, ), # 0
18308 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
18309 
  )
18310 
 
18311 
  def __init__(self, success=None, ex=None,):
18312 
    self.success = success
18313 
    self.ex = ex
18314 
 
18315 
  def read(self, iprot):
18316 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18317 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18318 
      return
18319 
    iprot.readStructBegin()
18320 
    while True:
18321 
      (fname, ftype, fid) = iprot.readFieldBegin()
18322 
      if ftype == TType.STOP:
18323 
        break
18324 
      if fid == 0:
18325 
        if ftype == TType.BOOL:
18326 
          self.success = iprot.readBool();
18327 
        else:
18328 
          iprot.skip(ftype)
18329 
      elif fid == 1:
18330 
        if ftype == TType.STRUCT:
18331 
          self.ex = TransactionServiceException()
18332 
          self.ex.read(iprot)
18333 
        else:
18334 
          iprot.skip(ftype)
18335 
      else:
18336 
        iprot.skip(ftype)
18337 
      iprot.readFieldEnd()
18338 
    iprot.readStructEnd()
18339 
 
18340 
  def write(self, oprot):
18341 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18342 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18343 
      return
18344 
    oprot.writeStructBegin('markOrderReturnRequestReceived_result')
18345 
    if self.success is not None:
18346 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
18347 
      oprot.writeBool(self.success)
18348 
      oprot.writeFieldEnd()
18349 
    if self.ex is not None:
18350 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
18351 
      self.ex.write(oprot)
18352 
      oprot.writeFieldEnd()
18353 
    oprot.writeFieldStop()
18354 
    oprot.writeStructEnd()
18355 
 
18356 
  def validate(self):
18357 
    return
18358 
 
18359 
 
18360 
  def __repr__(self):
18361 
    L = ['%s=%r' % (key, value)
18362 
      for key, value in self.__dict__.iteritems()]
18363 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18364 
 
18365 
  def __eq__(self, other):
18366 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18367 
 
18368 
  def __ne__(self, other):
18369 
    return not (self == other)
18370 
 
18371 
class markOrderReturnRequestAuthorized_args:
18372 
  """
18373 
  Attributes:
18374 
   - orderId
18375 
   - isAuthorized
18376 
  """
18377 
 
18378 
  thrift_spec = (
18379 
    None, # 0
18380 
    (1, TType.I64, 'orderId', None, None, ), # 1
18381 
    (2, TType.BOOL, 'isAuthorized', None, None, ), # 2
18382 
  )
18383 
 
18384 
  def __init__(self, orderId=None, isAuthorized=None,):
18385 
    self.orderId = orderId
18386 
    self.isAuthorized = isAuthorized
18387 
 
18388 
  def read(self, iprot):
18389 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18390 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18391 
      return
18392 
    iprot.readStructBegin()
18393 
    while True:
18394 
      (fname, ftype, fid) = iprot.readFieldBegin()
18395 
      if ftype == TType.STOP:
18396 
        break
18397 
      if fid == 1:
18398 
        if ftype == TType.I64:
18399 
          self.orderId = iprot.readI64();
18400 
        else:
18401 
          iprot.skip(ftype)
18402 
      elif fid == 2:
18403 
        if ftype == TType.BOOL:
18404 
          self.isAuthorized = iprot.readBool();
18405 
        else:
18406 
          iprot.skip(ftype)
18407 
      else:
18408 
        iprot.skip(ftype)
18409 
      iprot.readFieldEnd()
18410 
    iprot.readStructEnd()
18411 
 
18412 
  def write(self, oprot):
18413 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18414 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18415 
      return
18416 
    oprot.writeStructBegin('markOrderReturnRequestAuthorized_args')
18417 
    if self.orderId is not None:
18418 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
18419 
      oprot.writeI64(self.orderId)
18420 
      oprot.writeFieldEnd()
18421 
    if self.isAuthorized is not None:
18422 
      oprot.writeFieldBegin('isAuthorized', TType.BOOL, 2)
18423 
      oprot.writeBool(self.isAuthorized)
18424 
      oprot.writeFieldEnd()
18425 
    oprot.writeFieldStop()
18426 
    oprot.writeStructEnd()
18427 
 
18428 
  def validate(self):
18429 
    return
18430 
 
18431 
 
18432 
  def __repr__(self):
18433 
    L = ['%s=%r' % (key, value)
18434 
      for key, value in self.__dict__.iteritems()]
18435 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18436 
 
18437 
  def __eq__(self, other):
18438 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18439 
 
18440 
  def __ne__(self, other):
18441 
    return not (self == other)
18442 
 
18443 
class markOrderReturnRequestAuthorized_result:
18444 
  """
18445 
  Attributes:
18446 
   - success
18447 
   - ex
18448 
  """
18449 
 
18450 
  thrift_spec = (
18451 
    (0, TType.BOOL, 'success', None, None, ), # 0
18452 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
18453 
  )
18454 
 
18455 
  def __init__(self, success=None, ex=None,):
18456 
    self.success = success
18457 
    self.ex = ex
18458 
 
18459 
  def read(self, iprot):
18460 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18461 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18462 
      return
18463 
    iprot.readStructBegin()
18464 
    while True:
18465 
      (fname, ftype, fid) = iprot.readFieldBegin()
18466 
      if ftype == TType.STOP:
18467 
        break
18468 
      if fid == 0:
18469 
        if ftype == TType.BOOL:
18470 
          self.success = iprot.readBool();
18471 
        else:
18472 
          iprot.skip(ftype)
18473 
      elif fid == 1:
18474 
        if ftype == TType.STRUCT:
18475 
          self.ex = TransactionServiceException()
18476 
          self.ex.read(iprot)
18477 
        else:
18478 
          iprot.skip(ftype)
18479 
      else:
18480 
        iprot.skip(ftype)
18481 
      iprot.readFieldEnd()
18482 
    iprot.readStructEnd()
18483 
 
18484 
  def write(self, oprot):
18485 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18486 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18487 
      return
18488 
    oprot.writeStructBegin('markOrderReturnRequestAuthorized_result')
18489 
    if self.success is not None:
18490 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
18491 
      oprot.writeBool(self.success)
18492 
      oprot.writeFieldEnd()
18493 
    if self.ex is not None:
18494 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
18495 
      self.ex.write(oprot)
18496 
      oprot.writeFieldEnd()
18497 
    oprot.writeFieldStop()
18498 
    oprot.writeStructEnd()
18499 
 
18500 
  def validate(self):
18501 
    return
18502 
 
18503 
 
18504 
  def __repr__(self):
18505 
    L = ['%s=%r' % (key, value)
18506 
      for key, value in self.__dict__.iteritems()]
18507 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18508 
 
18509 
  def __eq__(self, other):
18510 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18511 
 
18512 
  def __ne__(self, other):
18513 
    return not (self == other)
18514 
 
2536 chandransh 18515 
class requestPickupNumber_args:
18516 
  """
18517 
  Attributes:
18518 
   - orderId
4579 rajveer 18519 
   - providerId
2536 chandransh 18520 
  """
18521 
 
18522 
  thrift_spec = (
18523 
    None, # 0
18524 
    (1, TType.I64, 'orderId', None, None, ), # 1
4579 rajveer 18525 
    (2, TType.I64, 'providerId', None, None, ), # 2
2536 chandransh 18526 
  )
18527 
 
4579 rajveer 18528 
  def __init__(self, orderId=None, providerId=None,):
2536 chandransh 18529 
    self.orderId = orderId
4579 rajveer 18530 
    self.providerId = providerId
2536 chandransh 18531 
 
18532 
  def read(self, iprot):
18533 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18534 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18535 
      return
18536 
    iprot.readStructBegin()
18537 
    while True:
18538 
      (fname, ftype, fid) = iprot.readFieldBegin()
18539 
      if ftype == TType.STOP:
18540 
        break
18541 
      if fid == 1:
18542 
        if ftype == TType.I64:
18543 
          self.orderId = iprot.readI64();
18544 
        else:
18545 
          iprot.skip(ftype)
4579 rajveer 18546 
      elif fid == 2:
18547 
        if ftype == TType.I64:
18548 
          self.providerId = iprot.readI64();
18549 
        else:
18550 
          iprot.skip(ftype)
2536 chandransh 18551 
      else:
18552 
        iprot.skip(ftype)
18553 
      iprot.readFieldEnd()
18554 
    iprot.readStructEnd()
18555 
 
18556 
  def write(self, oprot):
18557 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18558 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18559 
      return
18560 
    oprot.writeStructBegin('requestPickupNumber_args')
3431 rajveer 18561 
    if self.orderId is not None:
2536 chandransh 18562 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
18563 
      oprot.writeI64(self.orderId)
18564 
      oprot.writeFieldEnd()
4579 rajveer 18565 
    if self.providerId is not None:
18566 
      oprot.writeFieldBegin('providerId', TType.I64, 2)
18567 
      oprot.writeI64(self.providerId)
18568 
      oprot.writeFieldEnd()
2536 chandransh 18569 
    oprot.writeFieldStop()
18570 
    oprot.writeStructEnd()
18571 
 
3431 rajveer 18572 
  def validate(self):
18573 
    return
18574 
 
18575 
 
2536 chandransh 18576 
  def __repr__(self):
18577 
    L = ['%s=%r' % (key, value)
18578 
      for key, value in self.__dict__.iteritems()]
18579 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18580 
 
18581 
  def __eq__(self, other):
18582 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18583 
 
18584 
  def __ne__(self, other):
18585 
    return not (self == other)
18586 
 
18587 
class requestPickupNumber_result:
18588 
  """
18589 
  Attributes:
18590 
   - success
18591 
   - ex
18592 
  """
18593 
 
18594 
  thrift_spec = (
18595 
    (0, TType.BOOL, 'success', None, None, ), # 0
18596 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
18597 
  )
18598 
 
18599 
  def __init__(self, success=None, ex=None,):
18600 
    self.success = success
18601 
    self.ex = ex
18602 
 
18603 
  def read(self, iprot):
18604 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18605 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18606 
      return
18607 
    iprot.readStructBegin()
18608 
    while True:
18609 
      (fname, ftype, fid) = iprot.readFieldBegin()
18610 
      if ftype == TType.STOP:
18611 
        break
18612 
      if fid == 0:
18613 
        if ftype == TType.BOOL:
18614 
          self.success = iprot.readBool();
18615 
        else:
18616 
          iprot.skip(ftype)
18617 
      elif fid == 1:
18618 
        if ftype == TType.STRUCT:
18619 
          self.ex = TransactionServiceException()
18620 
          self.ex.read(iprot)
18621 
        else:
18622 
          iprot.skip(ftype)
18623 
      else:
18624 
        iprot.skip(ftype)
18625 
      iprot.readFieldEnd()
18626 
    iprot.readStructEnd()
18627 
 
18628 
  def write(self, oprot):
18629 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18630 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18631 
      return
18632 
    oprot.writeStructBegin('requestPickupNumber_result')
3431 rajveer 18633 
    if self.success is not None:
2536 chandransh 18634 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
18635 
      oprot.writeBool(self.success)
18636 
      oprot.writeFieldEnd()
3431 rajveer 18637 
    if self.ex is not None:
2536 chandransh 18638 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
18639 
      self.ex.write(oprot)
18640 
      oprot.writeFieldEnd()
18641 
    oprot.writeFieldStop()
18642 
    oprot.writeStructEnd()
18643 
 
3431 rajveer 18644 
  def validate(self):
18645 
    return
18646 
 
18647 
 
2536 chandransh 18648 
  def __repr__(self):
18649 
    L = ['%s=%r' % (key, value)
18650 
      for key, value in self.__dict__.iteritems()]
18651 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18652 
 
18653 
  def __eq__(self, other):
18654 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18655 
 
18656 
  def __ne__(self, other):
18657 
    return not (self == other)
18658 
 
18659 
class authorizePickup_args:
18660 
  """
18661 
  Attributes:
18662 
   - orderId
18663 
   - pickupNumber
4602 rajveer 18664 
   - providerId
2536 chandransh 18665 
  """
18666 
 
18667 
  thrift_spec = (
18668 
    None, # 0
18669 
    (1, TType.I64, 'orderId', None, None, ), # 1
18670 
    (2, TType.STRING, 'pickupNumber', None, None, ), # 2
4602 rajveer 18671 
    (3, TType.I64, 'providerId', None, None, ), # 3
2536 chandransh 18672 
  )
18673 
 
4602 rajveer 18674 
  def __init__(self, orderId=None, pickupNumber=None, providerId=None,):
2536 chandransh 18675 
    self.orderId = orderId
18676 
    self.pickupNumber = pickupNumber
4602 rajveer 18677 
    self.providerId = providerId
2536 chandransh 18678 
 
18679 
  def read(self, iprot):
18680 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18681 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18682 
      return
18683 
    iprot.readStructBegin()
18684 
    while True:
18685 
      (fname, ftype, fid) = iprot.readFieldBegin()
18686 
      if ftype == TType.STOP:
18687 
        break
18688 
      if fid == 1:
18689 
        if ftype == TType.I64:
18690 
          self.orderId = iprot.readI64();
18691 
        else:
18692 
          iprot.skip(ftype)
18693 
      elif fid == 2:
18694 
        if ftype == TType.STRING:
18695 
          self.pickupNumber = iprot.readString();
18696 
        else:
18697 
          iprot.skip(ftype)
4602 rajveer 18698 
      elif fid == 3:
18699 
        if ftype == TType.I64:
18700 
          self.providerId = iprot.readI64();
18701 
        else:
18702 
          iprot.skip(ftype)
2536 chandransh 18703 
      else:
18704 
        iprot.skip(ftype)
18705 
      iprot.readFieldEnd()
18706 
    iprot.readStructEnd()
18707 
 
18708 
  def write(self, oprot):
18709 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18710 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18711 
      return
18712 
    oprot.writeStructBegin('authorizePickup_args')
3431 rajveer 18713 
    if self.orderId is not None:
2536 chandransh 18714 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
18715 
      oprot.writeI64(self.orderId)
18716 
      oprot.writeFieldEnd()
3431 rajveer 18717 
    if self.pickupNumber is not None:
2536 chandransh 18718 
      oprot.writeFieldBegin('pickupNumber', TType.STRING, 2)
18719 
      oprot.writeString(self.pickupNumber)
18720 
      oprot.writeFieldEnd()
4602 rajveer 18721 
    if self.providerId is not None:
18722 
      oprot.writeFieldBegin('providerId', TType.I64, 3)
18723 
      oprot.writeI64(self.providerId)
18724 
      oprot.writeFieldEnd()
2536 chandransh 18725 
    oprot.writeFieldStop()
18726 
    oprot.writeStructEnd()
18727 
 
3431 rajveer 18728 
  def validate(self):
18729 
    return
18730 
 
18731 
 
2536 chandransh 18732 
  def __repr__(self):
18733 
    L = ['%s=%r' % (key, value)
18734 
      for key, value in self.__dict__.iteritems()]
18735 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18736 
 
18737 
  def __eq__(self, other):
18738 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18739 
 
18740 
  def __ne__(self, other):
18741 
    return not (self == other)
18742 
 
18743 
class authorizePickup_result:
18744 
  """
18745 
  Attributes:
18746 
   - success
18747 
   - ex
18748 
  """
18749 
 
18750 
  thrift_spec = (
18751 
    (0, TType.BOOL, 'success', None, None, ), # 0
18752 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
18753 
  )
18754 
 
18755 
  def __init__(self, success=None, ex=None,):
18756 
    self.success = success
18757 
    self.ex = ex
18758 
 
18759 
  def read(self, iprot):
18760 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18761 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18762 
      return
18763 
    iprot.readStructBegin()
18764 
    while True:
18765 
      (fname, ftype, fid) = iprot.readFieldBegin()
18766 
      if ftype == TType.STOP:
18767 
        break
18768 
      if fid == 0:
18769 
        if ftype == TType.BOOL:
18770 
          self.success = iprot.readBool();
18771 
        else:
18772 
          iprot.skip(ftype)
18773 
      elif fid == 1:
18774 
        if ftype == TType.STRUCT:
18775 
          self.ex = TransactionServiceException()
18776 
          self.ex.read(iprot)
18777 
        else:
18778 
          iprot.skip(ftype)
18779 
      else:
18780 
        iprot.skip(ftype)
18781 
      iprot.readFieldEnd()
18782 
    iprot.readStructEnd()
18783 
 
18784 
  def write(self, oprot):
18785 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18786 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18787 
      return
18788 
    oprot.writeStructBegin('authorizePickup_result')
3431 rajveer 18789 
    if self.success is not None:
2536 chandransh 18790 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
18791 
      oprot.writeBool(self.success)
18792 
      oprot.writeFieldEnd()
3431 rajveer 18793 
    if self.ex is not None:
2536 chandransh 18794 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
18795 
      self.ex.write(oprot)
18796 
      oprot.writeFieldEnd()
18797 
    oprot.writeFieldStop()
18798 
    oprot.writeStructEnd()
18799 
 
3431 rajveer 18800 
  def validate(self):
18801 
    return
18802 
 
18803 
 
2536 chandransh 18804 
  def __repr__(self):
18805 
    L = ['%s=%r' % (key, value)
18806 
      for key, value in self.__dict__.iteritems()]
18807 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18808 
 
18809 
  def __eq__(self, other):
18810 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18811 
 
18812 
  def __ne__(self, other):
18813 
    return not (self == other)
18814 
 
2764 chandransh 18815 
class markDoasAsPickedUp_args:
18816 
  """
18817 
  Attributes:
18818 
   - providerId
18819 
   - pickupDetails
18820 
  """
18821 
 
18822 
  thrift_spec = (
18823 
    None, # 0
18824 
    (1, TType.I64, 'providerId', None, None, ), # 1
18825 
    (2, TType.MAP, 'pickupDetails', (TType.STRING,None,TType.STRING,None), None, ), # 2
18826 
  )
18827 
 
18828 
  def __init__(self, providerId=None, pickupDetails=None,):
18829 
    self.providerId = providerId
18830 
    self.pickupDetails = pickupDetails
18831 
 
18832 
  def read(self, iprot):
18833 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18834 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18835 
      return
18836 
    iprot.readStructBegin()
18837 
    while True:
18838 
      (fname, ftype, fid) = iprot.readFieldBegin()
18839 
      if ftype == TType.STOP:
18840 
        break
18841 
      if fid == 1:
18842 
        if ftype == TType.I64:
18843 
          self.providerId = iprot.readI64();
18844 
        else:
18845 
          iprot.skip(ftype)
18846 
      elif fid == 2:
18847 
        if ftype == TType.MAP:
18848 
          self.pickupDetails = {}
6188 rajveer 18849 
          (_ktype408, _vtype409, _size407 ) = iprot.readMapBegin()
18850 
          for _i411 in xrange(_size407):
18851 
            _key412 = iprot.readString();
18852 
            _val413 = iprot.readString();
18853 
            self.pickupDetails[_key412] = _val413
2764 chandransh 18854 
          iprot.readMapEnd()
18855 
        else:
18856 
          iprot.skip(ftype)
18857 
      else:
18858 
        iprot.skip(ftype)
18859 
      iprot.readFieldEnd()
18860 
    iprot.readStructEnd()
18861 
 
18862 
  def write(self, oprot):
18863 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18864 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18865 
      return
18866 
    oprot.writeStructBegin('markDoasAsPickedUp_args')
3431 rajveer 18867 
    if self.providerId is not None:
2764 chandransh 18868 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
18869 
      oprot.writeI64(self.providerId)
18870 
      oprot.writeFieldEnd()
3431 rajveer 18871 
    if self.pickupDetails is not None:
2764 chandransh 18872 
      oprot.writeFieldBegin('pickupDetails', TType.MAP, 2)
18873 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.pickupDetails))
6188 rajveer 18874 
      for kiter414,viter415 in self.pickupDetails.items():
18875 
        oprot.writeString(kiter414)
18876 
        oprot.writeString(viter415)
2764 chandransh 18877 
      oprot.writeMapEnd()
18878 
      oprot.writeFieldEnd()
18879 
    oprot.writeFieldStop()
18880 
    oprot.writeStructEnd()
18881 
 
3431 rajveer 18882 
  def validate(self):
18883 
    return
18884 
 
18885 
 
2764 chandransh 18886 
  def __repr__(self):
18887 
    L = ['%s=%r' % (key, value)
18888 
      for key, value in self.__dict__.iteritems()]
18889 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18890 
 
18891 
  def __eq__(self, other):
18892 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18893 
 
18894 
  def __ne__(self, other):
18895 
    return not (self == other)
18896 
 
18897 
class markDoasAsPickedUp_result:
4910 phani.kuma 18898 
 
18899 
  thrift_spec = (
18900 
  )
18901 
 
18902 
  def read(self, iprot):
18903 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18904 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18905 
      return
18906 
    iprot.readStructBegin()
18907 
    while True:
18908 
      (fname, ftype, fid) = iprot.readFieldBegin()
18909 
      if ftype == TType.STOP:
18910 
        break
18911 
      else:
18912 
        iprot.skip(ftype)
18913 
      iprot.readFieldEnd()
18914 
    iprot.readStructEnd()
18915 
 
18916 
  def write(self, oprot):
18917 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18918 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18919 
      return
18920 
    oprot.writeStructBegin('markDoasAsPickedUp_result')
18921 
    oprot.writeFieldStop()
18922 
    oprot.writeStructEnd()
18923 
 
18924 
  def validate(self):
18925 
    return
18926 
 
18927 
 
18928 
  def __repr__(self):
18929 
    L = ['%s=%r' % (key, value)
18930 
      for key, value in self.__dict__.iteritems()]
18931 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18932 
 
18933 
  def __eq__(self, other):
18934 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18935 
 
18936 
  def __ne__(self, other):
18937 
    return not (self == other)
18938 
 
18939 
class getDoasNotPickedUp_args:
2764 chandransh 18940 
  """
18941 
  Attributes:
4910 phani.kuma 18942 
   - providerId
18943 
  """
18944 
 
18945 
  thrift_spec = (
18946 
    None, # 0
18947 
    (1, TType.I64, 'providerId', None, None, ), # 1
18948 
  )
18949 
 
18950 
  def __init__(self, providerId=None,):
18951 
    self.providerId = providerId
18952 
 
18953 
  def read(self, iprot):
18954 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18955 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18956 
      return
18957 
    iprot.readStructBegin()
18958 
    while True:
18959 
      (fname, ftype, fid) = iprot.readFieldBegin()
18960 
      if ftype == TType.STOP:
18961 
        break
18962 
      if fid == 1:
18963 
        if ftype == TType.I64:
18964 
          self.providerId = iprot.readI64();
18965 
        else:
18966 
          iprot.skip(ftype)
18967 
      else:
18968 
        iprot.skip(ftype)
18969 
      iprot.readFieldEnd()
18970 
    iprot.readStructEnd()
18971 
 
18972 
  def write(self, oprot):
18973 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18974 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18975 
      return
18976 
    oprot.writeStructBegin('getDoasNotPickedUp_args')
18977 
    if self.providerId is not None:
18978 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
18979 
      oprot.writeI64(self.providerId)
18980 
      oprot.writeFieldEnd()
18981 
    oprot.writeFieldStop()
18982 
    oprot.writeStructEnd()
18983 
 
18984 
  def validate(self):
18985 
    return
18986 
 
18987 
 
18988 
  def __repr__(self):
18989 
    L = ['%s=%r' % (key, value)
18990 
      for key, value in self.__dict__.iteritems()]
18991 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18992 
 
18993 
  def __eq__(self, other):
18994 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18995 
 
18996 
  def __ne__(self, other):
18997 
    return not (self == other)
18998 
 
18999 
class getDoasNotPickedUp_result:
19000 
  """
19001 
  Attributes:
2764 chandransh 19002 
   - success
19003 
  """
19004 
 
19005 
  thrift_spec = (
19006 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
19007 
  )
19008 
 
19009 
  def __init__(self, success=None,):
19010 
    self.success = success
19011 
 
19012 
  def read(self, iprot):
19013 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19014 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19015 
      return
19016 
    iprot.readStructBegin()
19017 
    while True:
19018 
      (fname, ftype, fid) = iprot.readFieldBegin()
19019 
      if ftype == TType.STOP:
19020 
        break
19021 
      if fid == 0:
19022 
        if ftype == TType.LIST:
19023 
          self.success = []
6188 rajveer 19024 
          (_etype419, _size416) = iprot.readListBegin()
19025 
          for _i420 in xrange(_size416):
19026 
            _elem421 = Order()
19027 
            _elem421.read(iprot)
19028 
            self.success.append(_elem421)
2764 chandransh 19029 
          iprot.readListEnd()
19030 
        else:
19031 
          iprot.skip(ftype)
19032 
      else:
19033 
        iprot.skip(ftype)
19034 
      iprot.readFieldEnd()
19035 
    iprot.readStructEnd()
19036 
 
19037 
  def write(self, oprot):
19038 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19039 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19040 
      return
4910 phani.kuma 19041 
    oprot.writeStructBegin('getDoasNotPickedUp_result')
3431 rajveer 19042 
    if self.success is not None:
2764 chandransh 19043 
      oprot.writeFieldBegin('success', TType.LIST, 0)
19044 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 19045 
      for iter422 in self.success:
19046 
        iter422.write(oprot)
2764 chandransh 19047 
      oprot.writeListEnd()
19048 
      oprot.writeFieldEnd()
19049 
    oprot.writeFieldStop()
19050 
    oprot.writeStructEnd()
19051 
 
3431 rajveer 19052 
  def validate(self):
19053 
    return
19054 
 
19055 
 
2764 chandransh 19056 
  def __repr__(self):
19057 
    L = ['%s=%r' % (key, value)
19058 
      for key, value in self.__dict__.iteritems()]
19059 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19060 
 
19061 
  def __eq__(self, other):
19062 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19063 
 
19064 
  def __ne__(self, other):
19065 
    return not (self == other)
19066 
 
4741 phani.kuma 19067 
class markReturnOrdersAsPickedUp_args:
19068 
  """
19069 
  Attributes:
19070 
   - providerId
19071 
   - pickupDetails
19072 
  """
19073 
 
19074 
  thrift_spec = (
19075 
    None, # 0
19076 
    (1, TType.I64, 'providerId', None, None, ), # 1
19077 
    (2, TType.MAP, 'pickupDetails', (TType.STRING,None,TType.STRING,None), None, ), # 2
19078 
  )
19079 
 
19080 
  def __init__(self, providerId=None, pickupDetails=None,):
19081 
    self.providerId = providerId
19082 
    self.pickupDetails = pickupDetails
19083 
 
19084 
  def read(self, iprot):
19085 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19086 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19087 
      return
19088 
    iprot.readStructBegin()
19089 
    while True:
19090 
      (fname, ftype, fid) = iprot.readFieldBegin()
19091 
      if ftype == TType.STOP:
19092 
        break
19093 
      if fid == 1:
19094 
        if ftype == TType.I64:
19095 
          self.providerId = iprot.readI64();
19096 
        else:
19097 
          iprot.skip(ftype)
19098 
      elif fid == 2:
19099 
        if ftype == TType.MAP:
19100 
          self.pickupDetails = {}
6188 rajveer 19101 
          (_ktype424, _vtype425, _size423 ) = iprot.readMapBegin()
19102 
          for _i427 in xrange(_size423):
19103 
            _key428 = iprot.readString();
19104 
            _val429 = iprot.readString();
19105 
            self.pickupDetails[_key428] = _val429
4741 phani.kuma 19106 
          iprot.readMapEnd()
19107 
        else:
19108 
          iprot.skip(ftype)
19109 
      else:
19110 
        iprot.skip(ftype)
19111 
      iprot.readFieldEnd()
19112 
    iprot.readStructEnd()
19113 
 
19114 
  def write(self, oprot):
19115 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19116 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19117 
      return
19118 
    oprot.writeStructBegin('markReturnOrdersAsPickedUp_args')
19119 
    if self.providerId is not None:
19120 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
19121 
      oprot.writeI64(self.providerId)
19122 
      oprot.writeFieldEnd()
19123 
    if self.pickupDetails is not None:
19124 
      oprot.writeFieldBegin('pickupDetails', TType.MAP, 2)
19125 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.pickupDetails))
6188 rajveer 19126 
      for kiter430,viter431 in self.pickupDetails.items():
19127 
        oprot.writeString(kiter430)
19128 
        oprot.writeString(viter431)
4741 phani.kuma 19129 
      oprot.writeMapEnd()
19130 
      oprot.writeFieldEnd()
19131 
    oprot.writeFieldStop()
19132 
    oprot.writeStructEnd()
19133 
 
19134 
  def validate(self):
19135 
    return
19136 
 
19137 
 
19138 
  def __repr__(self):
19139 
    L = ['%s=%r' % (key, value)
19140 
      for key, value in self.__dict__.iteritems()]
19141 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19142 
 
19143 
  def __eq__(self, other):
19144 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19145 
 
19146 
  def __ne__(self, other):
19147 
    return not (self == other)
19148 
 
19149 
class markReturnOrdersAsPickedUp_result:
4910 phani.kuma 19150 
 
19151 
  thrift_spec = (
19152 
  )
19153 
 
19154 
  def read(self, iprot):
19155 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19156 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19157 
      return
19158 
    iprot.readStructBegin()
19159 
    while True:
19160 
      (fname, ftype, fid) = iprot.readFieldBegin()
19161 
      if ftype == TType.STOP:
19162 
        break
19163 
      else:
19164 
        iprot.skip(ftype)
19165 
      iprot.readFieldEnd()
19166 
    iprot.readStructEnd()
19167 
 
19168 
  def write(self, oprot):
19169 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19170 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19171 
      return
19172 
    oprot.writeStructBegin('markReturnOrdersAsPickedUp_result')
19173 
    oprot.writeFieldStop()
19174 
    oprot.writeStructEnd()
19175 
 
19176 
  def validate(self):
19177 
    return
19178 
 
19179 
 
19180 
  def __repr__(self):
19181 
    L = ['%s=%r' % (key, value)
19182 
      for key, value in self.__dict__.iteritems()]
19183 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19184 
 
19185 
  def __eq__(self, other):
19186 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19187 
 
19188 
  def __ne__(self, other):
19189 
    return not (self == other)
19190 
 
19191 
class getReturnOrdersNotPickedUp_args:
4741 phani.kuma 19192 
  """
19193 
  Attributes:
4910 phani.kuma 19194 
   - providerId
19195 
  """
19196 
 
19197 
  thrift_spec = (
19198 
    None, # 0
19199 
    (1, TType.I64, 'providerId', None, None, ), # 1
19200 
  )
19201 
 
19202 
  def __init__(self, providerId=None,):
19203 
    self.providerId = providerId
19204 
 
19205 
  def read(self, iprot):
19206 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19207 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19208 
      return
19209 
    iprot.readStructBegin()
19210 
    while True:
19211 
      (fname, ftype, fid) = iprot.readFieldBegin()
19212 
      if ftype == TType.STOP:
19213 
        break
19214 
      if fid == 1:
19215 
        if ftype == TType.I64:
19216 
          self.providerId = iprot.readI64();
19217 
        else:
19218 
          iprot.skip(ftype)
19219 
      else:
19220 
        iprot.skip(ftype)
19221 
      iprot.readFieldEnd()
19222 
    iprot.readStructEnd()
19223 
 
19224 
  def write(self, oprot):
19225 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19226 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19227 
      return
19228 
    oprot.writeStructBegin('getReturnOrdersNotPickedUp_args')
19229 
    if self.providerId is not None:
19230 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
19231 
      oprot.writeI64(self.providerId)
19232 
      oprot.writeFieldEnd()
19233 
    oprot.writeFieldStop()
19234 
    oprot.writeStructEnd()
19235 
 
19236 
  def validate(self):
19237 
    return
19238 
 
19239 
 
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 
 
19251 
class getReturnOrdersNotPickedUp_result:
19252 
  """
19253 
  Attributes:
4741 phani.kuma 19254 
   - success
19255 
  """
19256 
 
19257 
  thrift_spec = (
19258 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
19259 
  )
19260 
 
19261 
  def __init__(self, success=None,):
19262 
    self.success = success
19263 
 
19264 
  def read(self, iprot):
19265 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19266 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19267 
      return
19268 
    iprot.readStructBegin()
19269 
    while True:
19270 
      (fname, ftype, fid) = iprot.readFieldBegin()
19271 
      if ftype == TType.STOP:
19272 
        break
19273 
      if fid == 0:
19274 
        if ftype == TType.LIST:
19275 
          self.success = []
6188 rajveer 19276 
          (_etype435, _size432) = iprot.readListBegin()
19277 
          for _i436 in xrange(_size432):
19278 
            _elem437 = Order()
19279 
            _elem437.read(iprot)
19280 
            self.success.append(_elem437)
4741 phani.kuma 19281 
          iprot.readListEnd()
19282 
        else:
19283 
          iprot.skip(ftype)
19284 
      else:
19285 
        iprot.skip(ftype)
19286 
      iprot.readFieldEnd()
19287 
    iprot.readStructEnd()
19288 
 
19289 
  def write(self, oprot):
19290 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19291 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19292 
      return
4910 phani.kuma 19293 
    oprot.writeStructBegin('getReturnOrdersNotPickedUp_result')
4741 phani.kuma 19294 
    if self.success is not None:
19295 
      oprot.writeFieldBegin('success', TType.LIST, 0)
19296 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 19297 
      for iter438 in self.success:
19298 
        iter438.write(oprot)
4741 phani.kuma 19299 
      oprot.writeListEnd()
19300 
      oprot.writeFieldEnd()
19301 
    oprot.writeFieldStop()
19302 
    oprot.writeStructEnd()
19303 
 
19304 
  def validate(self):
19305 
    return
19306 
 
19307 
 
19308 
  def __repr__(self):
19309 
    L = ['%s=%r' % (key, value)
19310 
      for key, value in self.__dict__.iteritems()]
19311 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19312 
 
19313 
  def __eq__(self, other):
19314 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19315 
 
19316 
  def __ne__(self, other):
19317 
    return not (self == other)
19318 
 
2616 chandransh 19319 
class receiveReturn_args:
2591 chandransh 19320 
  """
19321 
  Attributes:
19322 
   - orderId
4479 rajveer 19323 
   - receiveCondition
2591 chandransh 19324 
  """
2536 chandransh 19325 
 
2591 chandransh 19326 
  thrift_spec = (
19327 
    None, # 0
19328 
    (1, TType.I64, 'orderId', None, None, ), # 1
4479 rajveer 19329 
    (2, TType.I64, 'receiveCondition', None, None, ), # 2
2591 chandransh 19330 
  )
19331 
 
4479 rajveer 19332 
  def __init__(self, orderId=None, receiveCondition=None,):
2591 chandransh 19333 
    self.orderId = orderId
4479 rajveer 19334 
    self.receiveCondition = receiveCondition
2591 chandransh 19335 
 
19336 
  def read(self, iprot):
19337 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19338 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19339 
      return
19340 
    iprot.readStructBegin()
19341 
    while True:
19342 
      (fname, ftype, fid) = iprot.readFieldBegin()
19343 
      if ftype == TType.STOP:
19344 
        break
19345 
      if fid == 1:
19346 
        if ftype == TType.I64:
19347 
          self.orderId = iprot.readI64();
19348 
        else:
19349 
          iprot.skip(ftype)
4479 rajveer 19350 
      elif fid == 2:
19351 
        if ftype == TType.I64:
19352 
          self.receiveCondition = iprot.readI64();
19353 
        else:
19354 
          iprot.skip(ftype)
2591 chandransh 19355 
      else:
19356 
        iprot.skip(ftype)
19357 
      iprot.readFieldEnd()
19358 
    iprot.readStructEnd()
19359 
 
19360 
  def write(self, oprot):
19361 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19362 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19363 
      return
2616 chandransh 19364 
    oprot.writeStructBegin('receiveReturn_args')
3431 rajveer 19365 
    if self.orderId is not None:
2591 chandransh 19366 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
19367 
      oprot.writeI64(self.orderId)
19368 
      oprot.writeFieldEnd()
4479 rajveer 19369 
    if self.receiveCondition is not None:
19370 
      oprot.writeFieldBegin('receiveCondition', TType.I64, 2)
19371 
      oprot.writeI64(self.receiveCondition)
19372 
      oprot.writeFieldEnd()
2591 chandransh 19373 
    oprot.writeFieldStop()
19374 
    oprot.writeStructEnd()
19375 
 
3431 rajveer 19376 
  def validate(self):
19377 
    return
19378 
 
19379 
 
2591 chandransh 19380 
  def __repr__(self):
19381 
    L = ['%s=%r' % (key, value)
19382 
      for key, value in self.__dict__.iteritems()]
19383 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19384 
 
19385 
  def __eq__(self, other):
19386 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19387 
 
19388 
  def __ne__(self, other):
19389 
    return not (self == other)
19390 
 
2616 chandransh 19391 
class receiveReturn_result:
2591 chandransh 19392 
  """
19393 
  Attributes:
19394 
   - success
19395 
   - ex
19396 
  """
19397 
 
19398 
  thrift_spec = (
19399 
    (0, TType.BOOL, 'success', None, None, ), # 0
19400 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
19401 
  )
19402 
 
19403 
  def __init__(self, success=None, ex=None,):
19404 
    self.success = success
19405 
    self.ex = ex
19406 
 
19407 
  def read(self, iprot):
19408 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19409 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19410 
      return
19411 
    iprot.readStructBegin()
19412 
    while True:
19413 
      (fname, ftype, fid) = iprot.readFieldBegin()
19414 
      if ftype == TType.STOP:
19415 
        break
19416 
      if fid == 0:
19417 
        if ftype == TType.BOOL:
19418 
          self.success = iprot.readBool();
19419 
        else:
19420 
          iprot.skip(ftype)
19421 
      elif fid == 1:
19422 
        if ftype == TType.STRUCT:
19423 
          self.ex = TransactionServiceException()
19424 
          self.ex.read(iprot)
19425 
        else:
19426 
          iprot.skip(ftype)
19427 
      else:
19428 
        iprot.skip(ftype)
19429 
      iprot.readFieldEnd()
19430 
    iprot.readStructEnd()
19431 
 
19432 
  def write(self, oprot):
19433 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19434 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19435 
      return
2616 chandransh 19436 
    oprot.writeStructBegin('receiveReturn_result')
3431 rajveer 19437 
    if self.success is not None:
2591 chandransh 19438 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
19439 
      oprot.writeBool(self.success)
19440 
      oprot.writeFieldEnd()
3431 rajveer 19441 
    if self.ex is not None:
2591 chandransh 19442 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
19443 
      self.ex.write(oprot)
19444 
      oprot.writeFieldEnd()
19445 
    oprot.writeFieldStop()
19446 
    oprot.writeStructEnd()
19447 
 
3431 rajveer 19448 
  def validate(self):
19449 
    return
19450 
 
19451 
 
2591 chandransh 19452 
  def __repr__(self):
19453 
    L = ['%s=%r' % (key, value)
19454 
      for key, value in self.__dict__.iteritems()]
19455 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19456 
 
19457 
  def __eq__(self, other):
19458 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19459 
 
19460 
  def __ne__(self, other):
19461 
    return not (self == other)
19462 
 
19463 
class validateDoa_args:
19464 
  """
19465 
  Attributes:
19466 
   - orderId
19467 
   - isValid
19468 
  """
19469 
 
19470 
  thrift_spec = (
19471 
    None, # 0
19472 
    (1, TType.I64, 'orderId', None, None, ), # 1
19473 
    (2, TType.BOOL, 'isValid', None, None, ), # 2
19474 
  )
19475 
 
19476 
  def __init__(self, orderId=None, isValid=None,):
19477 
    self.orderId = orderId
19478 
    self.isValid = isValid
19479 
 
19480 
  def read(self, iprot):
19481 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19482 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19483 
      return
19484 
    iprot.readStructBegin()
19485 
    while True:
19486 
      (fname, ftype, fid) = iprot.readFieldBegin()
19487 
      if ftype == TType.STOP:
19488 
        break
19489 
      if fid == 1:
19490 
        if ftype == TType.I64:
19491 
          self.orderId = iprot.readI64();
19492 
        else:
19493 
          iprot.skip(ftype)
19494 
      elif fid == 2:
19495 
        if ftype == TType.BOOL:
19496 
          self.isValid = iprot.readBool();
19497 
        else:
19498 
          iprot.skip(ftype)
19499 
      else:
19500 
        iprot.skip(ftype)
19501 
      iprot.readFieldEnd()
19502 
    iprot.readStructEnd()
19503 
 
19504 
  def write(self, oprot):
19505 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19506 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19507 
      return
19508 
    oprot.writeStructBegin('validateDoa_args')
3431 rajveer 19509 
    if self.orderId is not None:
2591 chandransh 19510 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
19511 
      oprot.writeI64(self.orderId)
19512 
      oprot.writeFieldEnd()
3431 rajveer 19513 
    if self.isValid is not None:
2591 chandransh 19514 
      oprot.writeFieldBegin('isValid', TType.BOOL, 2)
19515 
      oprot.writeBool(self.isValid)
19516 
      oprot.writeFieldEnd()
19517 
    oprot.writeFieldStop()
19518 
    oprot.writeStructEnd()
19519 
 
3431 rajveer 19520 
  def validate(self):
19521 
    return
19522 
 
19523 
 
2591 chandransh 19524 
  def __repr__(self):
19525 
    L = ['%s=%r' % (key, value)
19526 
      for key, value in self.__dict__.iteritems()]
19527 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19528 
 
19529 
  def __eq__(self, other):
19530 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19531 
 
19532 
  def __ne__(self, other):
19533 
    return not (self == other)
19534 
 
19535 
class validateDoa_result:
19536 
  """
19537 
  Attributes:
19538 
   - success
19539 
   - ex
19540 
  """
19541 
 
19542 
  thrift_spec = (
19543 
    (0, TType.BOOL, 'success', None, None, ), # 0
19544 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
19545 
  )
19546 
 
19547 
  def __init__(self, success=None, ex=None,):
19548 
    self.success = success
19549 
    self.ex = ex
19550 
 
19551 
  def read(self, iprot):
19552 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19553 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19554 
      return
19555 
    iprot.readStructBegin()
19556 
    while True:
19557 
      (fname, ftype, fid) = iprot.readFieldBegin()
19558 
      if ftype == TType.STOP:
19559 
        break
19560 
      if fid == 0:
19561 
        if ftype == TType.BOOL:
19562 
          self.success = iprot.readBool();
19563 
        else:
19564 
          iprot.skip(ftype)
19565 
      elif fid == 1:
19566 
        if ftype == TType.STRUCT:
19567 
          self.ex = TransactionServiceException()
19568 
          self.ex.read(iprot)
19569 
        else:
19570 
          iprot.skip(ftype)
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('validateDoa_result')
3431 rajveer 19581 
    if self.success is not None:
2591 chandransh 19582 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
19583 
      oprot.writeBool(self.success)
19584 
      oprot.writeFieldEnd()
3431 rajveer 19585 
    if self.ex is not None:
2591 chandransh 19586 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
19587 
      self.ex.write(oprot)
19588 
      oprot.writeFieldEnd()
19589 
    oprot.writeFieldStop()
19590 
    oprot.writeStructEnd()
19591 
 
3431 rajveer 19592 
  def validate(self):
19593 
    return
19594 
 
19595 
 
2591 chandransh 19596 
  def __repr__(self):
19597 
    L = ['%s=%r' % (key, value)
19598 
      for key, value in self.__dict__.iteritems()]
19599 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19600 
 
19601 
  def __eq__(self, other):
19602 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19603 
 
19604 
  def __ne__(self, other):
19605 
    return not (self == other)
19606 
 
4495 rajveer 19607 
class validateReturnProduct_args:
19608 
  """
19609 
  Attributes:
19610 
   - orderId
19611 
   - isUsable
19612 
  """
19613 
 
19614 
  thrift_spec = (
19615 
    None, # 0
19616 
    (1, TType.I64, 'orderId', None, None, ), # 1
19617 
    (2, TType.BOOL, 'isUsable', None, None, ), # 2
19618 
  )
19619 
 
19620 
  def __init__(self, orderId=None, isUsable=None,):
19621 
    self.orderId = orderId
19622 
    self.isUsable = isUsable
19623 
 
19624 
  def read(self, iprot):
19625 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19626 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19627 
      return
19628 
    iprot.readStructBegin()
19629 
    while True:
19630 
      (fname, ftype, fid) = iprot.readFieldBegin()
19631 
      if ftype == TType.STOP:
19632 
        break
19633 
      if fid == 1:
19634 
        if ftype == TType.I64:
19635 
          self.orderId = iprot.readI64();
19636 
        else:
19637 
          iprot.skip(ftype)
19638 
      elif fid == 2:
19639 
        if ftype == TType.BOOL:
19640 
          self.isUsable = iprot.readBool();
19641 
        else:
19642 
          iprot.skip(ftype)
19643 
      else:
19644 
        iprot.skip(ftype)
19645 
      iprot.readFieldEnd()
19646 
    iprot.readStructEnd()
19647 
 
19648 
  def write(self, oprot):
19649 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19650 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19651 
      return
19652 
    oprot.writeStructBegin('validateReturnProduct_args')
19653 
    if self.orderId is not None:
19654 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
19655 
      oprot.writeI64(self.orderId)
19656 
      oprot.writeFieldEnd()
19657 
    if self.isUsable is not None:
19658 
      oprot.writeFieldBegin('isUsable', TType.BOOL, 2)
19659 
      oprot.writeBool(self.isUsable)
19660 
      oprot.writeFieldEnd()
19661 
    oprot.writeFieldStop()
19662 
    oprot.writeStructEnd()
19663 
 
19664 
  def validate(self):
19665 
    return
19666 
 
19667 
 
19668 
  def __repr__(self):
19669 
    L = ['%s=%r' % (key, value)
19670 
      for key, value in self.__dict__.iteritems()]
19671 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19672 
 
19673 
  def __eq__(self, other):
19674 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19675 
 
19676 
  def __ne__(self, other):
19677 
    return not (self == other)
19678 
 
19679 
class validateReturnProduct_result:
19680 
  """
19681 
  Attributes:
19682 
   - success
19683 
   - ex
19684 
  """
19685 
 
19686 
  thrift_spec = (
19687 
    (0, TType.BOOL, 'success', None, None, ), # 0
19688 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
19689 
  )
19690 
 
19691 
  def __init__(self, success=None, ex=None,):
19692 
    self.success = success
19693 
    self.ex = ex
19694 
 
19695 
  def read(self, iprot):
19696 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19697 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19698 
      return
19699 
    iprot.readStructBegin()
19700 
    while True:
19701 
      (fname, ftype, fid) = iprot.readFieldBegin()
19702 
      if ftype == TType.STOP:
19703 
        break
19704 
      if fid == 0:
19705 
        if ftype == TType.BOOL:
19706 
          self.success = iprot.readBool();
19707 
        else:
19708 
          iprot.skip(ftype)
19709 
      elif fid == 1:
19710 
        if ftype == TType.STRUCT:
19711 
          self.ex = TransactionServiceException()
19712 
          self.ex.read(iprot)
19713 
        else:
19714 
          iprot.skip(ftype)
19715 
      else:
19716 
        iprot.skip(ftype)
19717 
      iprot.readFieldEnd()
19718 
    iprot.readStructEnd()
19719 
 
19720 
  def write(self, oprot):
19721 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19722 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19723 
      return
19724 
    oprot.writeStructBegin('validateReturnProduct_result')
19725 
    if self.success is not None:
19726 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
19727 
      oprot.writeBool(self.success)
19728 
      oprot.writeFieldEnd()
19729 
    if self.ex is not None:
19730 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
19731 
      self.ex.write(oprot)
19732 
      oprot.writeFieldEnd()
19733 
    oprot.writeFieldStop()
19734 
    oprot.writeStructEnd()
19735 
 
19736 
  def validate(self):
19737 
    return
19738 
 
19739 
 
19740 
  def __repr__(self):
19741 
    L = ['%s=%r' % (key, value)
19742 
      for key, value in self.__dict__.iteritems()]
19743 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19744 
 
19745 
  def __eq__(self, other):
19746 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19747 
 
19748 
  def __ne__(self, other):
19749 
    return not (self == other)
19750 
 
2616 chandransh 19751 
class reshipOrder_args:
19752 
  """
19753 
  Attributes:
19754 
   - orderId
19755 
  """
2591 chandransh 19756 
 
2616 chandransh 19757 
  thrift_spec = (
19758 
    None, # 0
19759 
    (1, TType.I64, 'orderId', None, None, ), # 1
19760 
  )
19761 
 
19762 
  def __init__(self, orderId=None,):
19763 
    self.orderId = orderId
19764 
 
19765 
  def read(self, iprot):
19766 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19767 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19768 
      return
19769 
    iprot.readStructBegin()
19770 
    while True:
19771 
      (fname, ftype, fid) = iprot.readFieldBegin()
19772 
      if ftype == TType.STOP:
19773 
        break
19774 
      if fid == 1:
19775 
        if ftype == TType.I64:
19776 
          self.orderId = iprot.readI64();
19777 
        else:
19778 
          iprot.skip(ftype)
19779 
      else:
19780 
        iprot.skip(ftype)
19781 
      iprot.readFieldEnd()
19782 
    iprot.readStructEnd()
19783 
 
19784 
  def write(self, oprot):
19785 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19786 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19787 
      return
19788 
    oprot.writeStructBegin('reshipOrder_args')
3431 rajveer 19789 
    if self.orderId is not None:
2616 chandransh 19790 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
19791 
      oprot.writeI64(self.orderId)
19792 
      oprot.writeFieldEnd()
19793 
    oprot.writeFieldStop()
19794 
    oprot.writeStructEnd()
19795 
 
3431 rajveer 19796 
  def validate(self):
19797 
    return
19798 
 
19799 
 
2616 chandransh 19800 
  def __repr__(self):
19801 
    L = ['%s=%r' % (key, value)
19802 
      for key, value in self.__dict__.iteritems()]
19803 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19804 
 
19805 
  def __eq__(self, other):
19806 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19807 
 
19808 
  def __ne__(self, other):
19809 
    return not (self == other)
19810 
 
19811 
class reshipOrder_result:
19812 
  """
19813 
  Attributes:
19814 
   - success
19815 
   - ex
19816 
  """
19817 
 
19818 
  thrift_spec = (
19819 
    (0, TType.I64, 'success', None, None, ), # 0
19820 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
19821 
  )
19822 
 
19823 
  def __init__(self, success=None, ex=None,):
19824 
    self.success = success
19825 
    self.ex = ex
19826 
 
19827 
  def read(self, iprot):
19828 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19829 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19830 
      return
19831 
    iprot.readStructBegin()
19832 
    while True:
19833 
      (fname, ftype, fid) = iprot.readFieldBegin()
19834 
      if ftype == TType.STOP:
19835 
        break
19836 
      if fid == 0:
19837 
        if ftype == TType.I64:
19838 
          self.success = iprot.readI64();
19839 
        else:
19840 
          iprot.skip(ftype)
19841 
      elif fid == 1:
19842 
        if ftype == TType.STRUCT:
19843 
          self.ex = TransactionServiceException()
19844 
          self.ex.read(iprot)
19845 
        else:
19846 
          iprot.skip(ftype)
19847 
      else:
19848 
        iprot.skip(ftype)
19849 
      iprot.readFieldEnd()
19850 
    iprot.readStructEnd()
19851 
 
19852 
  def write(self, oprot):
19853 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19854 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19855 
      return
19856 
    oprot.writeStructBegin('reshipOrder_result')
3431 rajveer 19857 
    if self.success is not None:
2616 chandransh 19858 
      oprot.writeFieldBegin('success', TType.I64, 0)
19859 
      oprot.writeI64(self.success)
19860 
      oprot.writeFieldEnd()
3431 rajveer 19861 
    if self.ex is not None:
2616 chandransh 19862 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
19863 
      self.ex.write(oprot)
19864 
      oprot.writeFieldEnd()
19865 
    oprot.writeFieldStop()
19866 
    oprot.writeStructEnd()
19867 
 
3431 rajveer 19868 
  def validate(self):
19869 
    return
19870 
 
19871 
 
2616 chandransh 19872 
  def __repr__(self):
19873 
    L = ['%s=%r' % (key, value)
19874 
      for key, value in self.__dict__.iteritems()]
19875 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19876 
 
19877 
  def __eq__(self, other):
19878 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19879 
 
19880 
  def __ne__(self, other):
19881 
    return not (self == other)
19882 
 
19883 
class refundOrder_args:
19884 
  """
19885 
  Attributes:
19886 
   - orderId
3226 chandransh 19887 
   - refundedBy
19888 
   - reason
2616 chandransh 19889 
  """
19890 
 
19891 
  thrift_spec = (
19892 
    None, # 0
19893 
    (1, TType.I64, 'orderId', None, None, ), # 1
3226 chandransh 19894 
    (2, TType.STRING, 'refundedBy', None, None, ), # 2
19895 
    (3, TType.STRING, 'reason', None, None, ), # 3
2616 chandransh 19896 
  )
19897 
 
3226 chandransh 19898 
  def __init__(self, orderId=None, refundedBy=None, reason=None,):
2616 chandransh 19899 
    self.orderId = orderId
3226 chandransh 19900 
    self.refundedBy = refundedBy
19901 
    self.reason = reason
2616 chandransh 19902 
 
19903 
  def read(self, iprot):
19904 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19905 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19906 
      return
19907 
    iprot.readStructBegin()
19908 
    while True:
19909 
      (fname, ftype, fid) = iprot.readFieldBegin()
19910 
      if ftype == TType.STOP:
19911 
        break
19912 
      if fid == 1:
19913 
        if ftype == TType.I64:
19914 
          self.orderId = iprot.readI64();
19915 
        else:
19916 
          iprot.skip(ftype)
3226 chandransh 19917 
      elif fid == 2:
19918 
        if ftype == TType.STRING:
19919 
          self.refundedBy = iprot.readString();
19920 
        else:
19921 
          iprot.skip(ftype)
19922 
      elif fid == 3:
19923 
        if ftype == TType.STRING:
19924 
          self.reason = iprot.readString();
19925 
        else:
19926 
          iprot.skip(ftype)
2616 chandransh 19927 
      else:
19928 
        iprot.skip(ftype)
19929 
      iprot.readFieldEnd()
19930 
    iprot.readStructEnd()
19931 
 
19932 
  def write(self, oprot):
19933 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19934 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19935 
      return
19936 
    oprot.writeStructBegin('refundOrder_args')
3431 rajveer 19937 
    if self.orderId is not None:
2616 chandransh 19938 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
19939 
      oprot.writeI64(self.orderId)
19940 
      oprot.writeFieldEnd()
3431 rajveer 19941 
    if self.refundedBy is not None:
3226 chandransh 19942 
      oprot.writeFieldBegin('refundedBy', TType.STRING, 2)
19943 
      oprot.writeString(self.refundedBy)
19944 
      oprot.writeFieldEnd()
3431 rajveer 19945 
    if self.reason is not None:
3226 chandransh 19946 
      oprot.writeFieldBegin('reason', TType.STRING, 3)
19947 
      oprot.writeString(self.reason)
19948 
      oprot.writeFieldEnd()
2616 chandransh 19949 
    oprot.writeFieldStop()
19950 
    oprot.writeStructEnd()
19951 
 
3431 rajveer 19952 
  def validate(self):
19953 
    return
19954 
 
19955 
 
2616 chandransh 19956 
  def __repr__(self):
19957 
    L = ['%s=%r' % (key, value)
19958 
      for key, value in self.__dict__.iteritems()]
19959 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19960 
 
19961 
  def __eq__(self, other):
19962 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19963 
 
19964 
  def __ne__(self, other):
19965 
    return not (self == other)
19966 
 
19967 
class refundOrder_result:
19968 
  """
19969 
  Attributes:
19970 
   - success
19971 
   - ex
19972 
  """
19973 
 
19974 
  thrift_spec = (
19975 
    (0, TType.BOOL, 'success', None, None, ), # 0
19976 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
19977 
  )
19978 
 
19979 
  def __init__(self, success=None, ex=None,):
19980 
    self.success = success
19981 
    self.ex = ex
19982 
 
19983 
  def read(self, iprot):
19984 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19985 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19986 
      return
19987 
    iprot.readStructBegin()
19988 
    while True:
19989 
      (fname, ftype, fid) = iprot.readFieldBegin()
19990 
      if ftype == TType.STOP:
19991 
        break
19992 
      if fid == 0:
19993 
        if ftype == TType.BOOL:
19994 
          self.success = iprot.readBool();
19995 
        else:
19996 
          iprot.skip(ftype)
19997 
      elif fid == 1:
19998 
        if ftype == TType.STRUCT:
19999 
          self.ex = TransactionServiceException()
20000 
          self.ex.read(iprot)
20001 
        else:
20002 
          iprot.skip(ftype)
20003 
      else:
20004 
        iprot.skip(ftype)
20005 
      iprot.readFieldEnd()
20006 
    iprot.readStructEnd()
20007 
 
20008 
  def write(self, oprot):
20009 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20010 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20011 
      return
20012 
    oprot.writeStructBegin('refundOrder_result')
3431 rajveer 20013 
    if self.success is not None:
2616 chandransh 20014 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
20015 
      oprot.writeBool(self.success)
20016 
      oprot.writeFieldEnd()
3431 rajveer 20017 
    if self.ex is not None:
2616 chandransh 20018 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
20019 
      self.ex.write(oprot)
20020 
      oprot.writeFieldEnd()
20021 
    oprot.writeFieldStop()
20022 
    oprot.writeStructEnd()
20023 
 
3431 rajveer 20024 
  def validate(self):
20025 
    return
20026 
 
20027 
 
2616 chandransh 20028 
  def __repr__(self):
20029 
    L = ['%s=%r' % (key, value)
20030 
      for key, value in self.__dict__.iteritems()]
20031 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20032 
 
20033 
  def __eq__(self, other):
20034 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20035 
 
20036 
  def __ne__(self, other):
20037 
    return not (self == other)
20038 
 
2690 chandransh 20039 
class getReturnOrders_args:
20040 
  """
20041 
  Attributes:
20042 
   - warehouseId
20043 
   - fromDate
20044 
   - toDate
20045 
  """
2616 chandransh 20046 
 
2690 chandransh 20047 
  thrift_spec = (
20048 
    None, # 0
20049 
    (1, TType.I64, 'warehouseId', None, None, ), # 1
20050 
    (2, TType.I64, 'fromDate', None, None, ), # 2
20051 
    (3, TType.I64, 'toDate', None, None, ), # 3
20052 
  )
20053 
 
20054 
  def __init__(self, warehouseId=None, fromDate=None, toDate=None,):
20055 
    self.warehouseId = warehouseId
20056 
    self.fromDate = fromDate
20057 
    self.toDate = toDate
20058 
 
20059 
  def read(self, iprot):
20060 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20061 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20062 
      return
20063 
    iprot.readStructBegin()
20064 
    while True:
20065 
      (fname, ftype, fid) = iprot.readFieldBegin()
20066 
      if ftype == TType.STOP:
20067 
        break
20068 
      if fid == 1:
20069 
        if ftype == TType.I64:
20070 
          self.warehouseId = iprot.readI64();
20071 
        else:
20072 
          iprot.skip(ftype)
20073 
      elif fid == 2:
20074 
        if ftype == TType.I64:
20075 
          self.fromDate = iprot.readI64();
20076 
        else:
20077 
          iprot.skip(ftype)
20078 
      elif fid == 3:
20079 
        if ftype == TType.I64:
20080 
          self.toDate = iprot.readI64();
20081 
        else:
20082 
          iprot.skip(ftype)
20083 
      else:
20084 
        iprot.skip(ftype)
20085 
      iprot.readFieldEnd()
20086 
    iprot.readStructEnd()
20087 
 
20088 
  def write(self, oprot):
20089 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20090 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20091 
      return
20092 
    oprot.writeStructBegin('getReturnOrders_args')
3431 rajveer 20093 
    if self.warehouseId is not None:
2690 chandransh 20094 
      oprot.writeFieldBegin('warehouseId', TType.I64, 1)
20095 
      oprot.writeI64(self.warehouseId)
20096 
      oprot.writeFieldEnd()
3431 rajveer 20097 
    if self.fromDate is not None:
2690 chandransh 20098 
      oprot.writeFieldBegin('fromDate', TType.I64, 2)
20099 
      oprot.writeI64(self.fromDate)
20100 
      oprot.writeFieldEnd()
3431 rajveer 20101 
    if self.toDate is not None:
2690 chandransh 20102 
      oprot.writeFieldBegin('toDate', TType.I64, 3)
20103 
      oprot.writeI64(self.toDate)
20104 
      oprot.writeFieldEnd()
20105 
    oprot.writeFieldStop()
20106 
    oprot.writeStructEnd()
20107 
 
3431 rajveer 20108 
  def validate(self):
20109 
    return
20110 
 
20111 
 
2690 chandransh 20112 
  def __repr__(self):
20113 
    L = ['%s=%r' % (key, value)
20114 
      for key, value in self.__dict__.iteritems()]
20115 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20116 
 
20117 
  def __eq__(self, other):
20118 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20119 
 
20120 
  def __ne__(self, other):
20121 
    return not (self == other)
20122 
 
20123 
class getReturnOrders_result:
20124 
  """
20125 
  Attributes:
20126 
   - success
20127 
  """
20128 
 
20129 
  thrift_spec = (
20130 
    (0, TType.LIST, 'success', (TType.STRUCT,(ReturnOrder, ReturnOrder.thrift_spec)), None, ), # 0
20131 
  )
20132 
 
20133 
  def __init__(self, success=None,):
20134 
    self.success = success
20135 
 
20136 
  def read(self, iprot):
20137 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20138 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20139 
      return
20140 
    iprot.readStructBegin()
20141 
    while True:
20142 
      (fname, ftype, fid) = iprot.readFieldBegin()
20143 
      if ftype == TType.STOP:
20144 
        break
20145 
      if fid == 0:
20146 
        if ftype == TType.LIST:
20147 
          self.success = []
6188 rajveer 20148 
          (_etype442, _size439) = iprot.readListBegin()
20149 
          for _i443 in xrange(_size439):
20150 
            _elem444 = ReturnOrder()
20151 
            _elem444.read(iprot)
20152 
            self.success.append(_elem444)
2690 chandransh 20153 
          iprot.readListEnd()
20154 
        else:
20155 
          iprot.skip(ftype)
20156 
      else:
20157 
        iprot.skip(ftype)
20158 
      iprot.readFieldEnd()
20159 
    iprot.readStructEnd()
20160 
 
20161 
  def write(self, oprot):
20162 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20163 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20164 
      return
20165 
    oprot.writeStructBegin('getReturnOrders_result')
3431 rajveer 20166 
    if self.success is not None:
2690 chandransh 20167 
      oprot.writeFieldBegin('success', TType.LIST, 0)
20168 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 20169 
      for iter445 in self.success:
20170 
        iter445.write(oprot)
2690 chandransh 20171 
      oprot.writeListEnd()
20172 
      oprot.writeFieldEnd()
20173 
    oprot.writeFieldStop()
20174 
    oprot.writeStructEnd()
20175 
 
3431 rajveer 20176 
  def validate(self):
20177 
    return
20178 
 
20179 
 
2690 chandransh 20180 
  def __repr__(self):
20181 
    L = ['%s=%r' % (key, value)
20182 
      for key, value in self.__dict__.iteritems()]
20183 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20184 
 
20185 
  def __eq__(self, other):
20186 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20187 
 
20188 
  def __ne__(self, other):
20189 
    return not (self == other)
20190 
 
5481 phani.kuma 20191 
class getAllReturnOrders_args:
20192 
  """
20193 
  Attributes:
20194 
   - onlyNotProcessed
20195 
   - fromDate
20196 
   - toDate
20197 
  """
20198 
 
20199 
  thrift_spec = (
20200 
    None, # 0
20201 
    (1, TType.BOOL, 'onlyNotProcessed', None, None, ), # 1
20202 
    (2, TType.I64, 'fromDate', None, None, ), # 2
20203 
    (3, TType.I64, 'toDate', None, None, ), # 3
20204 
  )
20205 
 
20206 
  def __init__(self, onlyNotProcessed=None, fromDate=None, toDate=None,):
20207 
    self.onlyNotProcessed = onlyNotProcessed
20208 
    self.fromDate = fromDate
20209 
    self.toDate = toDate
20210 
 
20211 
  def read(self, iprot):
20212 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20213 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20214 
      return
20215 
    iprot.readStructBegin()
20216 
    while True:
20217 
      (fname, ftype, fid) = iprot.readFieldBegin()
20218 
      if ftype == TType.STOP:
20219 
        break
20220 
      if fid == 1:
20221 
        if ftype == TType.BOOL:
20222 
          self.onlyNotProcessed = iprot.readBool();
20223 
        else:
20224 
          iprot.skip(ftype)
20225 
      elif fid == 2:
20226 
        if ftype == TType.I64:
20227 
          self.fromDate = iprot.readI64();
20228 
        else:
20229 
          iprot.skip(ftype)
20230 
      elif fid == 3:
20231 
        if ftype == TType.I64:
20232 
          self.toDate = iprot.readI64();
20233 
        else:
20234 
          iprot.skip(ftype)
20235 
      else:
20236 
        iprot.skip(ftype)
20237 
      iprot.readFieldEnd()
20238 
    iprot.readStructEnd()
20239 
 
20240 
  def write(self, oprot):
20241 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20242 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20243 
      return
20244 
    oprot.writeStructBegin('getAllReturnOrders_args')
20245 
    if self.onlyNotProcessed is not None:
20246 
      oprot.writeFieldBegin('onlyNotProcessed', TType.BOOL, 1)
20247 
      oprot.writeBool(self.onlyNotProcessed)
20248 
      oprot.writeFieldEnd()
20249 
    if self.fromDate is not None:
20250 
      oprot.writeFieldBegin('fromDate', TType.I64, 2)
20251 
      oprot.writeI64(self.fromDate)
20252 
      oprot.writeFieldEnd()
20253 
    if self.toDate is not None:
20254 
      oprot.writeFieldBegin('toDate', TType.I64, 3)
20255 
      oprot.writeI64(self.toDate)
20256 
      oprot.writeFieldEnd()
20257 
    oprot.writeFieldStop()
20258 
    oprot.writeStructEnd()
20259 
 
20260 
  def validate(self):
20261 
    return
20262 
 
20263 
 
20264 
  def __repr__(self):
20265 
    L = ['%s=%r' % (key, value)
20266 
      for key, value in self.__dict__.iteritems()]
20267 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20268 
 
20269 
  def __eq__(self, other):
20270 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20271 
 
20272 
  def __ne__(self, other):
20273 
    return not (self == other)
20274 
 
20275 
class getAllReturnOrders_result:
20276 
  """
20277 
  Attributes:
20278 
   - success
20279 
  """
20280 
 
20281 
  thrift_spec = (
20282 
    (0, TType.LIST, 'success', (TType.STRUCT,(ReturnOrder, ReturnOrder.thrift_spec)), None, ), # 0
20283 
  )
20284 
 
20285 
  def __init__(self, success=None,):
20286 
    self.success = success
20287 
 
20288 
  def read(self, iprot):
20289 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20290 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20291 
      return
20292 
    iprot.readStructBegin()
20293 
    while True:
20294 
      (fname, ftype, fid) = iprot.readFieldBegin()
20295 
      if ftype == TType.STOP:
20296 
        break
20297 
      if fid == 0:
20298 
        if ftype == TType.LIST:
20299 
          self.success = []
6188 rajveer 20300 
          (_etype449, _size446) = iprot.readListBegin()
20301 
          for _i450 in xrange(_size446):
20302 
            _elem451 = ReturnOrder()
20303 
            _elem451.read(iprot)
20304 
            self.success.append(_elem451)
5481 phani.kuma 20305 
          iprot.readListEnd()
20306 
        else:
20307 
          iprot.skip(ftype)
20308 
      else:
20309 
        iprot.skip(ftype)
20310 
      iprot.readFieldEnd()
20311 
    iprot.readStructEnd()
20312 
 
20313 
  def write(self, oprot):
20314 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20315 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20316 
      return
20317 
    oprot.writeStructBegin('getAllReturnOrders_result')
20318 
    if self.success is not None:
20319 
      oprot.writeFieldBegin('success', TType.LIST, 0)
20320 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 20321 
      for iter452 in self.success:
20322 
        iter452.write(oprot)
5481 phani.kuma 20323 
      oprot.writeListEnd()
20324 
      oprot.writeFieldEnd()
20325 
    oprot.writeFieldStop()
20326 
    oprot.writeStructEnd()
20327 
 
20328 
  def validate(self):
20329 
    return
20330 
 
20331 
 
20332 
  def __repr__(self):
20333 
    L = ['%s=%r' % (key, value)
20334 
      for key, value in self.__dict__.iteritems()]
20335 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20336 
 
20337 
  def __eq__(self, other):
20338 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20339 
 
20340 
  def __ne__(self, other):
20341 
    return not (self == other)
20342 
 
2700 chandransh 20343 
class getReturnOrder_args:
20344 
  """
20345 
  Attributes:
20346 
   - id
20347 
  """
20348 
 
20349 
  thrift_spec = (
20350 
    None, # 0
20351 
    (1, TType.I64, 'id', None, None, ), # 1
20352 
  )
20353 
 
20354 
  def __init__(self, id=None,):
20355 
    self.id = id
20356 
 
20357 
  def read(self, iprot):
20358 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20359 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20360 
      return
20361 
    iprot.readStructBegin()
20362 
    while True:
20363 
      (fname, ftype, fid) = iprot.readFieldBegin()
20364 
      if ftype == TType.STOP:
20365 
        break
20366 
      if fid == 1:
20367 
        if ftype == TType.I64:
20368 
          self.id = iprot.readI64();
20369 
        else:
20370 
          iprot.skip(ftype)
20371 
      else:
20372 
        iprot.skip(ftype)
20373 
      iprot.readFieldEnd()
20374 
    iprot.readStructEnd()
20375 
 
20376 
  def write(self, oprot):
20377 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20378 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20379 
      return
20380 
    oprot.writeStructBegin('getReturnOrder_args')
3431 rajveer 20381 
    if self.id is not None:
2700 chandransh 20382 
      oprot.writeFieldBegin('id', TType.I64, 1)
20383 
      oprot.writeI64(self.id)
20384 
      oprot.writeFieldEnd()
20385 
    oprot.writeFieldStop()
20386 
    oprot.writeStructEnd()
20387 
 
3431 rajveer 20388 
  def validate(self):
20389 
    return
20390 
 
20391 
 
2700 chandransh 20392 
  def __repr__(self):
20393 
    L = ['%s=%r' % (key, value)
20394 
      for key, value in self.__dict__.iteritems()]
20395 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20396 
 
20397 
  def __eq__(self, other):
20398 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20399 
 
20400 
  def __ne__(self, other):
20401 
    return not (self == other)
20402 
 
20403 
class getReturnOrder_result:
20404 
  """
20405 
  Attributes:
20406 
   - success
20407 
   - ex
20408 
  """
20409 
 
20410 
  thrift_spec = (
20411 
    (0, TType.STRUCT, 'success', (ReturnOrder, ReturnOrder.thrift_spec), None, ), # 0
20412 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
20413 
  )
20414 
 
20415 
  def __init__(self, success=None, ex=None,):
20416 
    self.success = success
20417 
    self.ex = ex
20418 
 
20419 
  def read(self, iprot):
20420 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20421 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20422 
      return
20423 
    iprot.readStructBegin()
20424 
    while True:
20425 
      (fname, ftype, fid) = iprot.readFieldBegin()
20426 
      if ftype == TType.STOP:
20427 
        break
20428 
      if fid == 0:
20429 
        if ftype == TType.STRUCT:
20430 
          self.success = ReturnOrder()
20431 
          self.success.read(iprot)
20432 
        else:
20433 
          iprot.skip(ftype)
20434 
      elif fid == 1:
20435 
        if ftype == TType.STRUCT:
20436 
          self.ex = TransactionServiceException()
20437 
          self.ex.read(iprot)
20438 
        else:
20439 
          iprot.skip(ftype)
20440 
      else:
20441 
        iprot.skip(ftype)
20442 
      iprot.readFieldEnd()
20443 
    iprot.readStructEnd()
20444 
 
20445 
  def write(self, oprot):
20446 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20447 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20448 
      return
20449 
    oprot.writeStructBegin('getReturnOrder_result')
3431 rajveer 20450 
    if self.success is not None:
2700 chandransh 20451 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
20452 
      self.success.write(oprot)
20453 
      oprot.writeFieldEnd()
3431 rajveer 20454 
    if self.ex is not None:
2700 chandransh 20455 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
20456 
      self.ex.write(oprot)
20457 
      oprot.writeFieldEnd()
20458 
    oprot.writeFieldStop()
20459 
    oprot.writeStructEnd()
20460 
 
3431 rajveer 20461 
  def validate(self):
20462 
    return
20463 
 
20464 
 
2700 chandransh 20465 
  def __repr__(self):
20466 
    L = ['%s=%r' % (key, value)
20467 
      for key, value in self.__dict__.iteritems()]
20468 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20469 
 
20470 
  def __eq__(self, other):
20471 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20472 
 
20473 
  def __ne__(self, other):
20474 
    return not (self == other)
20475 
 
2690 chandransh 20476 
class processReturn_args:
20477 
  """
20478 
  Attributes:
20479 
   - returnOrderId
20480 
  """
20481 
 
20482 
  thrift_spec = (
20483 
    None, # 0
20484 
    (1, TType.I64, 'returnOrderId', None, None, ), # 1
20485 
  )
20486 
 
20487 
  def __init__(self, returnOrderId=None,):
20488 
    self.returnOrderId = returnOrderId
20489 
 
20490 
  def read(self, iprot):
20491 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20492 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20493 
      return
20494 
    iprot.readStructBegin()
20495 
    while True:
20496 
      (fname, ftype, fid) = iprot.readFieldBegin()
20497 
      if ftype == TType.STOP:
20498 
        break
20499 
      if fid == 1:
20500 
        if ftype == TType.I64:
20501 
          self.returnOrderId = iprot.readI64();
20502 
        else:
20503 
          iprot.skip(ftype)
20504 
      else:
20505 
        iprot.skip(ftype)
20506 
      iprot.readFieldEnd()
20507 
    iprot.readStructEnd()
20508 
 
20509 
  def write(self, oprot):
20510 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20511 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20512 
      return
20513 
    oprot.writeStructBegin('processReturn_args')
3431 rajveer 20514 
    if self.returnOrderId is not None:
2690 chandransh 20515 
      oprot.writeFieldBegin('returnOrderId', TType.I64, 1)
20516 
      oprot.writeI64(self.returnOrderId)
20517 
      oprot.writeFieldEnd()
20518 
    oprot.writeFieldStop()
20519 
    oprot.writeStructEnd()
20520 
 
3431 rajveer 20521 
  def validate(self):
20522 
    return
20523 
 
20524 
 
2690 chandransh 20525 
  def __repr__(self):
20526 
    L = ['%s=%r' % (key, value)
20527 
      for key, value in self.__dict__.iteritems()]
20528 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20529 
 
20530 
  def __eq__(self, other):
20531 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20532 
 
20533 
  def __ne__(self, other):
20534 
    return not (self == other)
20535 
 
20536 
class processReturn_result:
20537 
  """
20538 
  Attributes:
20539 
   - ex
20540 
  """
20541 
 
20542 
  thrift_spec = (
20543 
    None, # 0
20544 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
20545 
  )
20546 
 
20547 
  def __init__(self, ex=None,):
20548 
    self.ex = ex
20549 
 
20550 
  def read(self, iprot):
20551 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20552 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20553 
      return
20554 
    iprot.readStructBegin()
20555 
    while True:
20556 
      (fname, ftype, fid) = iprot.readFieldBegin()
20557 
      if ftype == TType.STOP:
20558 
        break
20559 
      if fid == 1:
20560 
        if ftype == TType.STRUCT:
20561 
          self.ex = TransactionServiceException()
20562 
          self.ex.read(iprot)
20563 
        else:
20564 
          iprot.skip(ftype)
20565 
      else:
20566 
        iprot.skip(ftype)
20567 
      iprot.readFieldEnd()
20568 
    iprot.readStructEnd()
20569 
 
20570 
  def write(self, oprot):
20571 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20572 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20573 
      return
20574 
    oprot.writeStructBegin('processReturn_result')
3431 rajveer 20575 
    if self.ex is not None:
2690 chandransh 20576 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
20577 
      self.ex.write(oprot)
20578 
      oprot.writeFieldEnd()
20579 
    oprot.writeFieldStop()
20580 
    oprot.writeStructEnd()
20581 
 
3431 rajveer 20582 
  def validate(self):
20583 
    return
20584 
 
20585 
 
2690 chandransh 20586 
  def __repr__(self):
20587 
    L = ['%s=%r' % (key, value)
20588 
      for key, value in self.__dict__.iteritems()]
20589 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20590 
 
20591 
  def __eq__(self, other):
20592 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20593 
 
20594 
  def __ne__(self, other):
20595 
    return not (self == other)
20596 
 
3451 chandransh 20597 
class updateWeight_args:
20598 
  """
20599 
  Attributes:
20600 
   - orderId
20601 
   - weight
20602 
  """
20603 
 
20604 
  thrift_spec = (
20605 
    None, # 0
20606 
    (1, TType.I64, 'orderId', None, None, ), # 1
20607 
    (2, TType.DOUBLE, 'weight', None, None, ), # 2
20608 
  )
20609 
 
20610 
  def __init__(self, orderId=None, weight=None,):
20611 
    self.orderId = orderId
20612 
    self.weight = weight
20613 
 
20614 
  def read(self, iprot):
20615 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20616 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20617 
      return
20618 
    iprot.readStructBegin()
20619 
    while True:
20620 
      (fname, ftype, fid) = iprot.readFieldBegin()
20621 
      if ftype == TType.STOP:
20622 
        break
20623 
      if fid == 1:
20624 
        if ftype == TType.I64:
20625 
          self.orderId = iprot.readI64();
20626 
        else:
20627 
          iprot.skip(ftype)
20628 
      elif fid == 2:
20629 
        if ftype == TType.DOUBLE:
20630 
          self.weight = iprot.readDouble();
20631 
        else:
20632 
          iprot.skip(ftype)
20633 
      else:
20634 
        iprot.skip(ftype)
20635 
      iprot.readFieldEnd()
20636 
    iprot.readStructEnd()
20637 
 
20638 
  def write(self, oprot):
20639 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20640 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20641 
      return
20642 
    oprot.writeStructBegin('updateWeight_args')
20643 
    if self.orderId is not None:
20644 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
20645 
      oprot.writeI64(self.orderId)
20646 
      oprot.writeFieldEnd()
20647 
    if self.weight is not None:
20648 
      oprot.writeFieldBegin('weight', TType.DOUBLE, 2)
20649 
      oprot.writeDouble(self.weight)
20650 
      oprot.writeFieldEnd()
20651 
    oprot.writeFieldStop()
20652 
    oprot.writeStructEnd()
20653 
 
20654 
  def validate(self):
20655 
    return
20656 
 
20657 
 
20658 
  def __repr__(self):
20659 
    L = ['%s=%r' % (key, value)
20660 
      for key, value in self.__dict__.iteritems()]
20661 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20662 
 
20663 
  def __eq__(self, other):
20664 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20665 
 
20666 
  def __ne__(self, other):
20667 
    return not (self == other)
20668 
 
20669 
class updateWeight_result:
20670 
  """
20671 
  Attributes:
20672 
   - success
20673 
   - ex
20674 
  """
20675 
 
20676 
  thrift_spec = (
20677 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
20678 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
20679 
  )
20680 
 
20681 
  def __init__(self, success=None, ex=None,):
20682 
    self.success = success
20683 
    self.ex = ex
20684 
 
20685 
  def read(self, iprot):
20686 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20687 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20688 
      return
20689 
    iprot.readStructBegin()
20690 
    while True:
20691 
      (fname, ftype, fid) = iprot.readFieldBegin()
20692 
      if ftype == TType.STOP:
20693 
        break
20694 
      if fid == 0:
20695 
        if ftype == TType.STRUCT:
20696 
          self.success = Order()
20697 
          self.success.read(iprot)
20698 
        else:
20699 
          iprot.skip(ftype)
20700 
      elif fid == 1:
20701 
        if ftype == TType.STRUCT:
20702 
          self.ex = TransactionServiceException()
20703 
          self.ex.read(iprot)
20704 
        else:
20705 
          iprot.skip(ftype)
20706 
      else:
20707 
        iprot.skip(ftype)
20708 
      iprot.readFieldEnd()
20709 
    iprot.readStructEnd()
20710 
 
20711 
  def write(self, oprot):
20712 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20713 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20714 
      return
20715 
    oprot.writeStructBegin('updateWeight_result')
20716 
    if self.success is not None:
20717 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
20718 
      self.success.write(oprot)
20719 
      oprot.writeFieldEnd()
20720 
    if self.ex is not None:
20721 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
20722 
      self.ex.write(oprot)
20723 
      oprot.writeFieldEnd()
20724 
    oprot.writeFieldStop()
20725 
    oprot.writeStructEnd()
20726 
 
20727 
  def validate(self):
20728 
    return
20729 
 
20730 
 
20731 
  def __repr__(self):
20732 
    L = ['%s=%r' % (key, value)
20733 
      for key, value in self.__dict__.iteritems()]
20734 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20735 
 
20736 
  def __eq__(self, other):
20737 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20738 
 
20739 
  def __ne__(self, other):
20740 
    return not (self == other)
3469 chandransh 20741 
 
20742 
class changeItem_args:
20743 
  """
20744 
  Attributes:
20745 
   - orderId
20746 
   - itemId
20747 
  """
20748 
 
20749 
  thrift_spec = (
20750 
    None, # 0
20751 
    (1, TType.I64, 'orderId', None, None, ), # 1
20752 
    (2, TType.I64, 'itemId', None, None, ), # 2
20753 
  )
20754 
 
20755 
  def __init__(self, orderId=None, itemId=None,):
20756 
    self.orderId = orderId
20757 
    self.itemId = itemId
20758 
 
20759 
  def read(self, iprot):
20760 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20761 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20762 
      return
20763 
    iprot.readStructBegin()
20764 
    while True:
20765 
      (fname, ftype, fid) = iprot.readFieldBegin()
20766 
      if ftype == TType.STOP:
20767 
        break
20768 
      if fid == 1:
20769 
        if ftype == TType.I64:
20770 
          self.orderId = iprot.readI64();
20771 
        else:
20772 
          iprot.skip(ftype)
20773 
      elif fid == 2:
20774 
        if ftype == TType.I64:
20775 
          self.itemId = iprot.readI64();
20776 
        else:
20777 
          iprot.skip(ftype)
20778 
      else:
20779 
        iprot.skip(ftype)
20780 
      iprot.readFieldEnd()
20781 
    iprot.readStructEnd()
20782 
 
20783 
  def write(self, oprot):
20784 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20785 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20786 
      return
20787 
    oprot.writeStructBegin('changeItem_args')
20788 
    if self.orderId is not None:
20789 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
20790 
      oprot.writeI64(self.orderId)
20791 
      oprot.writeFieldEnd()
20792 
    if self.itemId is not None:
20793 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
20794 
      oprot.writeI64(self.itemId)
20795 
      oprot.writeFieldEnd()
20796 
    oprot.writeFieldStop()
20797 
    oprot.writeStructEnd()
20798 
 
20799 
  def validate(self):
20800 
    return
20801 
 
20802 
 
20803 
  def __repr__(self):
20804 
    L = ['%s=%r' % (key, value)
20805 
      for key, value in self.__dict__.iteritems()]
20806 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20807 
 
20808 
  def __eq__(self, other):
20809 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20810 
 
20811 
  def __ne__(self, other):
20812 
    return not (self == other)
20813 
 
20814 
class changeItem_result:
20815 
  """
20816 
  Attributes:
20817 
   - success
20818 
   - ex
20819 
  """
20820 
 
20821 
  thrift_spec = (
20822 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
20823 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
20824 
  )
20825 
 
20826 
  def __init__(self, success=None, ex=None,):
20827 
    self.success = success
20828 
    self.ex = ex
20829 
 
20830 
  def read(self, iprot):
20831 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20832 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20833 
      return
20834 
    iprot.readStructBegin()
20835 
    while True:
20836 
      (fname, ftype, fid) = iprot.readFieldBegin()
20837 
      if ftype == TType.STOP:
20838 
        break
20839 
      if fid == 0:
20840 
        if ftype == TType.STRUCT:
20841 
          self.success = Order()
20842 
          self.success.read(iprot)
20843 
        else:
20844 
          iprot.skip(ftype)
20845 
      elif fid == 1:
20846 
        if ftype == TType.STRUCT:
20847 
          self.ex = TransactionServiceException()
20848 
          self.ex.read(iprot)
20849 
        else:
20850 
          iprot.skip(ftype)
20851 
      else:
20852 
        iprot.skip(ftype)
20853 
      iprot.readFieldEnd()
20854 
    iprot.readStructEnd()
20855 
 
20856 
  def write(self, oprot):
20857 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20858 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20859 
      return
20860 
    oprot.writeStructBegin('changeItem_result')
20861 
    if self.success is not None:
20862 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
20863 
      self.success.write(oprot)
20864 
      oprot.writeFieldEnd()
20865 
    if self.ex is not None:
20866 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
20867 
      self.ex.write(oprot)
20868 
      oprot.writeFieldEnd()
20869 
    oprot.writeFieldStop()
20870 
    oprot.writeStructEnd()
20871 
 
20872 
  def validate(self):
20873 
    return
20874 
 
20875 
 
20876 
  def __repr__(self):
20877 
    L = ['%s=%r' % (key, value)
20878 
      for key, value in self.__dict__.iteritems()]
20879 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20880 
 
20881 
  def __eq__(self, other):
20882 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20883 
 
20884 
  def __ne__(self, other):
20885 
    return not (self == other)
20886 
 
20887 
class shiftToWarehouse_args:
20888 
  """
20889 
  Attributes:
20890 
   - orderId
20891 
   - warehouseId
20892 
  """
20893 
 
20894 
  thrift_spec = (
20895 
    None, # 0
20896 
    (1, TType.I64, 'orderId', None, None, ), # 1
20897 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
20898 
  )
20899 
 
20900 
  def __init__(self, orderId=None, warehouseId=None,):
20901 
    self.orderId = orderId
20902 
    self.warehouseId = warehouseId
20903 
 
20904 
  def read(self, iprot):
20905 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20906 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20907 
      return
20908 
    iprot.readStructBegin()
20909 
    while True:
20910 
      (fname, ftype, fid) = iprot.readFieldBegin()
20911 
      if ftype == TType.STOP:
20912 
        break
20913 
      if fid == 1:
20914 
        if ftype == TType.I64:
20915 
          self.orderId = iprot.readI64();
20916 
        else:
20917 
          iprot.skip(ftype)
20918 
      elif fid == 2:
20919 
        if ftype == TType.I64:
20920 
          self.warehouseId = iprot.readI64();
20921 
        else:
20922 
          iprot.skip(ftype)
20923 
      else:
20924 
        iprot.skip(ftype)
20925 
      iprot.readFieldEnd()
20926 
    iprot.readStructEnd()
20927 
 
20928 
  def write(self, oprot):
20929 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20930 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20931 
      return
20932 
    oprot.writeStructBegin('shiftToWarehouse_args')
20933 
    if self.orderId is not None:
20934 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
20935 
      oprot.writeI64(self.orderId)
20936 
      oprot.writeFieldEnd()
20937 
    if self.warehouseId is not None:
20938 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
20939 
      oprot.writeI64(self.warehouseId)
20940 
      oprot.writeFieldEnd()
20941 
    oprot.writeFieldStop()
20942 
    oprot.writeStructEnd()
20943 
 
20944 
  def validate(self):
20945 
    return
20946 
 
20947 
 
20948 
  def __repr__(self):
20949 
    L = ['%s=%r' % (key, value)
20950 
      for key, value in self.__dict__.iteritems()]
20951 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20952 
 
20953 
  def __eq__(self, other):
20954 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20955 
 
20956 
  def __ne__(self, other):
20957 
    return not (self == other)
20958 
 
20959 
class shiftToWarehouse_result:
20960 
  """
20961 
  Attributes:
20962 
   - success
20963 
   - ex
20964 
  """
20965 
 
20966 
  thrift_spec = (
20967 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
20968 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
20969 
  )
20970 
 
20971 
  def __init__(self, success=None, ex=None,):
20972 
    self.success = success
20973 
    self.ex = ex
20974 
 
20975 
  def read(self, iprot):
20976 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20977 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20978 
      return
20979 
    iprot.readStructBegin()
20980 
    while True:
20981 
      (fname, ftype, fid) = iprot.readFieldBegin()
20982 
      if ftype == TType.STOP:
20983 
        break
20984 
      if fid == 0:
20985 
        if ftype == TType.STRUCT:
20986 
          self.success = Order()
20987 
          self.success.read(iprot)
20988 
        else:
20989 
          iprot.skip(ftype)
20990 
      elif fid == 1:
20991 
        if ftype == TType.STRUCT:
20992 
          self.ex = TransactionServiceException()
20993 
          self.ex.read(iprot)
20994 
        else:
20995 
          iprot.skip(ftype)
20996 
      else:
20997 
        iprot.skip(ftype)
20998 
      iprot.readFieldEnd()
20999 
    iprot.readStructEnd()
21000 
 
21001 
  def write(self, oprot):
21002 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21003 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21004 
      return
21005 
    oprot.writeStructBegin('shiftToWarehouse_result')
21006 
    if self.success is not None:
21007 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
21008 
      self.success.write(oprot)
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)
3553 chandransh 21031 
 
21032 
class addDelayReason_args:
21033 
  """
21034 
  Attributes:
21035 
   - orderId
21036 
   - delayReason
3986 chandransh 21037 
   - furtherDelay
4647 rajveer 21038 
   - delayReasonText
3553 chandransh 21039 
  """
21040 
 
21041 
  thrift_spec = (
21042 
    None, # 0
21043 
    (1, TType.I64, 'orderId', None, None, ), # 1
21044 
    (2, TType.I32, 'delayReason', None, None, ), # 2
3986 chandransh 21045 
    (3, TType.I64, 'furtherDelay', None, None, ), # 3
4647 rajveer 21046 
    (4, TType.STRING, 'delayReasonText', None, None, ), # 4
3553 chandransh 21047 
  )
21048 
 
4647 rajveer 21049 
  def __init__(self, orderId=None, delayReason=None, furtherDelay=None, delayReasonText=None,):
3553 chandransh 21050 
    self.orderId = orderId
21051 
    self.delayReason = delayReason
3986 chandransh 21052 
    self.furtherDelay = furtherDelay
4647 rajveer 21053 
    self.delayReasonText = delayReasonText
3553 chandransh 21054 
 
21055 
  def read(self, iprot):
21056 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21057 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21058 
      return
21059 
    iprot.readStructBegin()
21060 
    while True:
21061 
      (fname, ftype, fid) = iprot.readFieldBegin()
21062 
      if ftype == TType.STOP:
21063 
        break
21064 
      if fid == 1:
21065 
        if ftype == TType.I64:
21066 
          self.orderId = iprot.readI64();
21067 
        else:
21068 
          iprot.skip(ftype)
21069 
      elif fid == 2:
21070 
        if ftype == TType.I32:
21071 
          self.delayReason = iprot.readI32();
21072 
        else:
21073 
          iprot.skip(ftype)
3986 chandransh 21074 
      elif fid == 3:
21075 
        if ftype == TType.I64:
21076 
          self.furtherDelay = iprot.readI64();
21077 
        else:
21078 
          iprot.skip(ftype)
4647 rajveer 21079 
      elif fid == 4:
21080 
        if ftype == TType.STRING:
21081 
          self.delayReasonText = iprot.readString();
21082 
        else:
21083 
          iprot.skip(ftype)
3553 chandransh 21084 
      else:
21085 
        iprot.skip(ftype)
21086 
      iprot.readFieldEnd()
21087 
    iprot.readStructEnd()
21088 
 
21089 
  def write(self, oprot):
21090 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21091 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21092 
      return
21093 
    oprot.writeStructBegin('addDelayReason_args')
21094 
    if self.orderId is not None:
21095 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
21096 
      oprot.writeI64(self.orderId)
21097 
      oprot.writeFieldEnd()
21098 
    if self.delayReason is not None:
21099 
      oprot.writeFieldBegin('delayReason', TType.I32, 2)
21100 
      oprot.writeI32(self.delayReason)
21101 
      oprot.writeFieldEnd()
3986 chandransh 21102 
    if self.furtherDelay is not None:
21103 
      oprot.writeFieldBegin('furtherDelay', TType.I64, 3)
21104 
      oprot.writeI64(self.furtherDelay)
21105 
      oprot.writeFieldEnd()
4647 rajveer 21106 
    if self.delayReasonText is not None:
21107 
      oprot.writeFieldBegin('delayReasonText', TType.STRING, 4)
21108 
      oprot.writeString(self.delayReasonText)
21109 
      oprot.writeFieldEnd()
3553 chandransh 21110 
    oprot.writeFieldStop()
21111 
    oprot.writeStructEnd()
21112 
 
21113 
  def validate(self):
21114 
    return
21115 
 
21116 
 
21117 
  def __repr__(self):
21118 
    L = ['%s=%r' % (key, value)
21119 
      for key, value in self.__dict__.iteritems()]
21120 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21121 
 
21122 
  def __eq__(self, other):
21123 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21124 
 
21125 
  def __ne__(self, other):
21126 
    return not (self == other)
21127 
 
21128 
class addDelayReason_result:
21129 
  """
21130 
  Attributes:
21131 
   - success
21132 
   - ex
21133 
  """
21134 
 
21135 
  thrift_spec = (
21136 
    (0, TType.BOOL, 'success', None, None, ), # 0
21137 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
21138 
  )
21139 
 
21140 
  def __init__(self, success=None, ex=None,):
21141 
    self.success = success
21142 
    self.ex = ex
21143 
 
21144 
  def read(self, iprot):
21145 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21146 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21147 
      return
21148 
    iprot.readStructBegin()
21149 
    while True:
21150 
      (fname, ftype, fid) = iprot.readFieldBegin()
21151 
      if ftype == TType.STOP:
21152 
        break
21153 
      if fid == 0:
21154 
        if ftype == TType.BOOL:
21155 
          self.success = iprot.readBool();
21156 
        else:
21157 
          iprot.skip(ftype)
21158 
      elif fid == 1:
21159 
        if ftype == TType.STRUCT:
21160 
          self.ex = TransactionServiceException()
21161 
          self.ex.read(iprot)
21162 
        else:
21163 
          iprot.skip(ftype)
21164 
      else:
21165 
        iprot.skip(ftype)
21166 
      iprot.readFieldEnd()
21167 
    iprot.readStructEnd()
21168 
 
21169 
  def write(self, oprot):
21170 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21171 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21172 
      return
21173 
    oprot.writeStructBegin('addDelayReason_result')
21174 
    if self.success is not None:
21175 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
21176 
      oprot.writeBool(self.success)
21177 
      oprot.writeFieldEnd()
21178 
    if self.ex is not None:
21179 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
21180 
      self.ex.write(oprot)
21181 
      oprot.writeFieldEnd()
21182 
    oprot.writeFieldStop()
21183 
    oprot.writeStructEnd()
21184 
 
21185 
  def validate(self):
21186 
    return
21187 
 
21188 
 
21189 
  def __repr__(self):
21190 
    L = ['%s=%r' % (key, value)
21191 
      for key, value in self.__dict__.iteritems()]
21192 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21193 
 
21194 
  def __eq__(self, other):
21195 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21196 
 
21197 
  def __ne__(self, other):
21198 
    return not (self == other)
3956 chandransh 21199 
 
21200 
class reconcileCodCollection_args:
21201 
  """
21202 
  Attributes:
21203 
   - collectedAmountMap
21204 
   - xferBy
21205 
   - xferTxnId
21206 
   - xferDate
21207 
  """
21208 
 
21209 
  thrift_spec = (
21210 
    None, # 0
21211 
    (1, TType.MAP, 'collectedAmountMap', (TType.STRING,None,TType.DOUBLE,None), None, ), # 1
21212 
    (2, TType.STRING, 'xferBy', None, None, ), # 2
21213 
    (3, TType.STRING, 'xferTxnId', None, None, ), # 3
21214 
    (4, TType.I64, 'xferDate', None, None, ), # 4
21215 
  )
21216 
 
21217 
  def __init__(self, collectedAmountMap=None, xferBy=None, xferTxnId=None, xferDate=None,):
21218 
    self.collectedAmountMap = collectedAmountMap
21219 
    self.xferBy = xferBy
21220 
    self.xferTxnId = xferTxnId
21221 
    self.xferDate = xferDate
21222 
 
21223 
  def read(self, iprot):
21224 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21225 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21226 
      return
21227 
    iprot.readStructBegin()
21228 
    while True:
21229 
      (fname, ftype, fid) = iprot.readFieldBegin()
21230 
      if ftype == TType.STOP:
21231 
        break
21232 
      if fid == 1:
21233 
        if ftype == TType.MAP:
21234 
          self.collectedAmountMap = {}
6188 rajveer 21235 
          (_ktype454, _vtype455, _size453 ) = iprot.readMapBegin()
21236 
          for _i457 in xrange(_size453):
21237 
            _key458 = iprot.readString();
21238 
            _val459 = iprot.readDouble();
21239 
            self.collectedAmountMap[_key458] = _val459
3956 chandransh 21240 
          iprot.readMapEnd()
21241 
        else:
21242 
          iprot.skip(ftype)
21243 
      elif fid == 2:
21244 
        if ftype == TType.STRING:
21245 
          self.xferBy = iprot.readString();
21246 
        else:
21247 
          iprot.skip(ftype)
21248 
      elif fid == 3:
21249 
        if ftype == TType.STRING:
21250 
          self.xferTxnId = iprot.readString();
21251 
        else:
21252 
          iprot.skip(ftype)
21253 
      elif fid == 4:
21254 
        if ftype == TType.I64:
21255 
          self.xferDate = iprot.readI64();
21256 
        else:
21257 
          iprot.skip(ftype)
21258 
      else:
21259 
        iprot.skip(ftype)
21260 
      iprot.readFieldEnd()
21261 
    iprot.readStructEnd()
21262 
 
21263 
  def write(self, oprot):
21264 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21265 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21266 
      return
21267 
    oprot.writeStructBegin('reconcileCodCollection_args')
21268 
    if self.collectedAmountMap is not None:
21269 
      oprot.writeFieldBegin('collectedAmountMap', TType.MAP, 1)
21270 
      oprot.writeMapBegin(TType.STRING, TType.DOUBLE, len(self.collectedAmountMap))
6188 rajveer 21271 
      for kiter460,viter461 in self.collectedAmountMap.items():
21272 
        oprot.writeString(kiter460)
21273 
        oprot.writeDouble(viter461)
3956 chandransh 21274 
      oprot.writeMapEnd()
21275 
      oprot.writeFieldEnd()
21276 
    if self.xferBy is not None:
21277 
      oprot.writeFieldBegin('xferBy', TType.STRING, 2)
21278 
      oprot.writeString(self.xferBy)
21279 
      oprot.writeFieldEnd()
21280 
    if self.xferTxnId is not None:
21281 
      oprot.writeFieldBegin('xferTxnId', TType.STRING, 3)
21282 
      oprot.writeString(self.xferTxnId)
21283 
      oprot.writeFieldEnd()
21284 
    if self.xferDate is not None:
21285 
      oprot.writeFieldBegin('xferDate', TType.I64, 4)
21286 
      oprot.writeI64(self.xferDate)
21287 
      oprot.writeFieldEnd()
21288 
    oprot.writeFieldStop()
21289 
    oprot.writeStructEnd()
21290 
 
21291 
  def validate(self):
21292 
    return
21293 
 
21294 
 
21295 
  def __repr__(self):
21296 
    L = ['%s=%r' % (key, value)
21297 
      for key, value in self.__dict__.iteritems()]
21298 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21299 
 
21300 
  def __eq__(self, other):
21301 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21302 
 
21303 
  def __ne__(self, other):
21304 
    return not (self == other)
21305 
 
21306 
class reconcileCodCollection_result:
21307 
  """
21308 
  Attributes:
21309 
   - success
21310 
   - ex
21311 
  """
21312 
 
21313 
  thrift_spec = (
21314 
    (0, TType.MAP, 'success', (TType.STRING,None,TType.STRING,None), None, ), # 0
21315 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
21316 
  )
21317 
 
21318 
  def __init__(self, success=None, ex=None,):
21319 
    self.success = success
21320 
    self.ex = ex
21321 
 
21322 
  def read(self, iprot):
21323 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21324 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21325 
      return
21326 
    iprot.readStructBegin()
21327 
    while True:
21328 
      (fname, ftype, fid) = iprot.readFieldBegin()
21329 
      if ftype == TType.STOP:
21330 
        break
21331 
      if fid == 0:
21332 
        if ftype == TType.MAP:
21333 
          self.success = {}
6188 rajveer 21334 
          (_ktype463, _vtype464, _size462 ) = iprot.readMapBegin()
21335 
          for _i466 in xrange(_size462):
21336 
            _key467 = iprot.readString();
21337 
            _val468 = iprot.readString();
21338 
            self.success[_key467] = _val468
3956 chandransh 21339 
          iprot.readMapEnd()
21340 
        else:
21341 
          iprot.skip(ftype)
21342 
      elif fid == 1:
21343 
        if ftype == TType.STRUCT:
21344 
          self.ex = TransactionServiceException()
21345 
          self.ex.read(iprot)
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('reconcileCodCollection_result')
21358 
    if self.success is not None:
21359 
      oprot.writeFieldBegin('success', TType.MAP, 0)
21360 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.success))
6188 rajveer 21361 
      for kiter469,viter470 in self.success.items():
21362 
        oprot.writeString(kiter469)
21363 
        oprot.writeString(viter470)
3956 chandransh 21364 
      oprot.writeMapEnd()
21365 
      oprot.writeFieldEnd()
21366 
    if self.ex is not None:
21367 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
21368 
      self.ex.write(oprot)
21369 
      oprot.writeFieldEnd()
21370 
    oprot.writeFieldStop()
21371 
    oprot.writeStructEnd()
21372 
 
21373 
  def validate(self):
21374 
    return
21375 
 
21376 
 
21377 
  def __repr__(self):
21378 
    L = ['%s=%r' % (key, value)
21379 
      for key, value in self.__dict__.iteritems()]
21380 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21381 
 
21382 
  def __eq__(self, other):
21383 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21384 
 
21385 
  def __ne__(self, other):
21386 
    return not (self == other)
4008 mandeep.dh 21387 
 
21388 
class getTransactionsRequiringExtraProcessing_args:
21389 
  """
21390 
  Attributes:
21391 
   - category
21392 
  """
21393 
 
21394 
  thrift_spec = (
21395 
    None, # 0
21396 
    (1, TType.I32, 'category', None, None, ), # 1
21397 
  )
21398 
 
21399 
  def __init__(self, category=None,):
21400 
    self.category = category
21401 
 
21402 
  def read(self, iprot):
21403 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21404 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21405 
      return
21406 
    iprot.readStructBegin()
21407 
    while True:
21408 
      (fname, ftype, fid) = iprot.readFieldBegin()
21409 
      if ftype == TType.STOP:
21410 
        break
21411 
      if fid == 1:
21412 
        if ftype == TType.I32:
21413 
          self.category = iprot.readI32();
21414 
        else:
21415 
          iprot.skip(ftype)
21416 
      else:
21417 
        iprot.skip(ftype)
21418 
      iprot.readFieldEnd()
21419 
    iprot.readStructEnd()
21420 
 
21421 
  def write(self, oprot):
21422 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21423 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21424 
      return
21425 
    oprot.writeStructBegin('getTransactionsRequiringExtraProcessing_args')
21426 
    if self.category is not None:
21427 
      oprot.writeFieldBegin('category', TType.I32, 1)
21428 
      oprot.writeI32(self.category)
21429 
      oprot.writeFieldEnd()
21430 
    oprot.writeFieldStop()
21431 
    oprot.writeStructEnd()
21432 
 
21433 
  def validate(self):
21434 
    return
21435 
 
21436 
 
21437 
  def __repr__(self):
21438 
    L = ['%s=%r' % (key, value)
21439 
      for key, value in self.__dict__.iteritems()]
21440 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21441 
 
21442 
  def __eq__(self, other):
21443 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21444 
 
21445 
  def __ne__(self, other):
21446 
    return not (self == other)
21447 
 
21448 
class getTransactionsRequiringExtraProcessing_result:
21449 
  """
21450 
  Attributes:
21451 
   - success
21452 
  """
21453 
 
21454 
  thrift_spec = (
21455 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
21456 
  )
21457 
 
21458 
  def __init__(self, success=None,):
21459 
    self.success = success
21460 
 
21461 
  def read(self, iprot):
21462 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21463 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21464 
      return
21465 
    iprot.readStructBegin()
21466 
    while True:
21467 
      (fname, ftype, fid) = iprot.readFieldBegin()
21468 
      if ftype == TType.STOP:
21469 
        break
21470 
      if fid == 0:
21471 
        if ftype == TType.LIST:
21472 
          self.success = []
6188 rajveer 21473 
          (_etype474, _size471) = iprot.readListBegin()
21474 
          for _i475 in xrange(_size471):
21475 
            _elem476 = iprot.readI64();
21476 
            self.success.append(_elem476)
4008 mandeep.dh 21477 
          iprot.readListEnd()
21478 
        else:
21479 
          iprot.skip(ftype)
21480 
      else:
21481 
        iprot.skip(ftype)
21482 
      iprot.readFieldEnd()
21483 
    iprot.readStructEnd()
21484 
 
21485 
  def write(self, oprot):
21486 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21487 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21488 
      return
21489 
    oprot.writeStructBegin('getTransactionsRequiringExtraProcessing_result')
21490 
    if self.success is not None:
21491 
      oprot.writeFieldBegin('success', TType.LIST, 0)
21492 
      oprot.writeListBegin(TType.I64, len(self.success))
6188 rajveer 21493 
      for iter477 in self.success:
21494 
        oprot.writeI64(iter477)
4008 mandeep.dh 21495 
      oprot.writeListEnd()
21496 
      oprot.writeFieldEnd()
21497 
    oprot.writeFieldStop()
21498 
    oprot.writeStructEnd()
21499 
 
21500 
  def validate(self):
21501 
    return
21502 
 
21503 
 
21504 
  def __repr__(self):
21505 
    L = ['%s=%r' % (key, value)
21506 
      for key, value in self.__dict__.iteritems()]
21507 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21508 
 
21509 
  def __eq__(self, other):
21510 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21511 
 
21512 
  def __ne__(self, other):
21513 
    return not (self == other)
21514 
 
21515 
class markTransactionAsProcessed_args:
21516 
  """
21517 
  Attributes:
21518 
   - transactionId
21519 
   - category
21520 
  """
21521 
 
21522 
  thrift_spec = (
21523 
    None, # 0
21524 
    (1, TType.I64, 'transactionId', None, None, ), # 1
21525 
    (2, TType.I32, 'category', None, None, ), # 2
21526 
  )
21527 
 
21528 
  def __init__(self, transactionId=None, category=None,):
21529 
    self.transactionId = transactionId
21530 
    self.category = category
21531 
 
21532 
  def read(self, iprot):
21533 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21534 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21535 
      return
21536 
    iprot.readStructBegin()
21537 
    while True:
21538 
      (fname, ftype, fid) = iprot.readFieldBegin()
21539 
      if ftype == TType.STOP:
21540 
        break
21541 
      if fid == 1:
21542 
        if ftype == TType.I64:
21543 
          self.transactionId = iprot.readI64();
21544 
        else:
21545 
          iprot.skip(ftype)
21546 
      elif fid == 2:
21547 
        if ftype == TType.I32:
21548 
          self.category = iprot.readI32();
21549 
        else:
21550 
          iprot.skip(ftype)
21551 
      else:
21552 
        iprot.skip(ftype)
21553 
      iprot.readFieldEnd()
21554 
    iprot.readStructEnd()
21555 
 
21556 
  def write(self, oprot):
21557 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21558 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21559 
      return
21560 
    oprot.writeStructBegin('markTransactionAsProcessed_args')
21561 
    if self.transactionId is not None:
21562 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
21563 
      oprot.writeI64(self.transactionId)
21564 
      oprot.writeFieldEnd()
21565 
    if self.category is not None:
21566 
      oprot.writeFieldBegin('category', TType.I32, 2)
21567 
      oprot.writeI32(self.category)
21568 
      oprot.writeFieldEnd()
21569 
    oprot.writeFieldStop()
21570 
    oprot.writeStructEnd()
21571 
 
21572 
  def validate(self):
21573 
    return
21574 
 
21575 
 
21576 
  def __repr__(self):
21577 
    L = ['%s=%r' % (key, value)
21578 
      for key, value in self.__dict__.iteritems()]
21579 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21580 
 
21581 
  def __eq__(self, other):
21582 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21583 
 
21584 
  def __ne__(self, other):
21585 
    return not (self == other)
21586 
 
21587 
class markTransactionAsProcessed_result:
21588 
 
21589 
  thrift_spec = (
21590 
  )
21591 
 
21592 
  def read(self, iprot):
21593 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21594 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21595 
      return
21596 
    iprot.readStructBegin()
21597 
    while True:
21598 
      (fname, ftype, fid) = iprot.readFieldBegin()
21599 
      if ftype == TType.STOP:
21600 
        break
21601 
      else:
21602 
        iprot.skip(ftype)
21603 
      iprot.readFieldEnd()
21604 
    iprot.readStructEnd()
21605 
 
21606 
  def write(self, oprot):
21607 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21608 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21609 
      return
21610 
    oprot.writeStructBegin('markTransactionAsProcessed_result')
21611 
    oprot.writeFieldStop()
21612 
    oprot.writeStructEnd()
21613 
 
21614 
  def validate(self):
21615 
    return
21616 
 
21617 
 
21618 
  def __repr__(self):
21619 
    L = ['%s=%r' % (key, value)
21620 
      for key, value in self.__dict__.iteritems()]
21621 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21622 
 
21623 
  def __eq__(self, other):
21624 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21625 
 
21626 
  def __ne__(self, other):
21627 
    return not (self == other)
4018 chandransh 21628 
 
21629 
class getItemWiseRiskyOrdersCount_args:
21630 
 
21631 
  thrift_spec = (
21632 
  )
21633 
 
21634 
  def read(self, iprot):
21635 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21636 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21637 
      return
21638 
    iprot.readStructBegin()
21639 
    while True:
21640 
      (fname, ftype, fid) = iprot.readFieldBegin()
21641 
      if ftype == TType.STOP:
21642 
        break
21643 
      else:
21644 
        iprot.skip(ftype)
21645 
      iprot.readFieldEnd()
21646 
    iprot.readStructEnd()
21647 
 
21648 
  def write(self, oprot):
21649 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21650 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21651 
      return
21652 
    oprot.writeStructBegin('getItemWiseRiskyOrdersCount_args')
21653 
    oprot.writeFieldStop()
21654 
    oprot.writeStructEnd()
21655 
 
21656 
  def validate(self):
21657 
    return
21658 
 
21659 
 
21660 
  def __repr__(self):
21661 
    L = ['%s=%r' % (key, value)
21662 
      for key, value in self.__dict__.iteritems()]
21663 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21664 
 
21665 
  def __eq__(self, other):
21666 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21667 
 
21668 
  def __ne__(self, other):
21669 
    return not (self == other)
21670 
 
21671 
class getItemWiseRiskyOrdersCount_result:
21672 
  """
21673 
  Attributes:
21674 
   - success
21675 
  """
21676 
 
21677 
  thrift_spec = (
21678 
    (0, TType.MAP, 'success', (TType.I64,None,TType.I64,None), None, ), # 0
21679 
  )
21680 
 
21681 
  def __init__(self, success=None,):
21682 
    self.success = success
21683 
 
21684 
  def read(self, iprot):
21685 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21686 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21687 
      return
21688 
    iprot.readStructBegin()
21689 
    while True:
21690 
      (fname, ftype, fid) = iprot.readFieldBegin()
21691 
      if ftype == TType.STOP:
21692 
        break
21693 
      if fid == 0:
21694 
        if ftype == TType.MAP:
21695 
          self.success = {}
6188 rajveer 21696 
          (_ktype479, _vtype480, _size478 ) = iprot.readMapBegin()
21697 
          for _i482 in xrange(_size478):
21698 
            _key483 = iprot.readI64();
21699 
            _val484 = iprot.readI64();
21700 
            self.success[_key483] = _val484
4018 chandransh 21701 
          iprot.readMapEnd()
21702 
        else:
21703 
          iprot.skip(ftype)
21704 
      else:
21705 
        iprot.skip(ftype)
21706 
      iprot.readFieldEnd()
21707 
    iprot.readStructEnd()
21708 
 
21709 
  def write(self, oprot):
21710 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21711 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21712 
      return
21713 
    oprot.writeStructBegin('getItemWiseRiskyOrdersCount_result')
21714 
    if self.success is not None:
21715 
      oprot.writeFieldBegin('success', TType.MAP, 0)
21716 
      oprot.writeMapBegin(TType.I64, TType.I64, len(self.success))
6188 rajveer 21717 
      for kiter485,viter486 in self.success.items():
21718 
        oprot.writeI64(kiter485)
21719 
        oprot.writeI64(viter486)
4018 chandransh 21720 
      oprot.writeMapEnd()
21721 
      oprot.writeFieldEnd()
21722 
    oprot.writeFieldStop()
21723 
    oprot.writeStructEnd()
21724 
 
21725 
  def validate(self):
21726 
    return
21727 
 
21728 
 
21729 
  def __repr__(self):
21730 
    L = ['%s=%r' % (key, value)
21731 
      for key, value in self.__dict__.iteritems()]
21732 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21733 
 
21734 
  def __eq__(self, other):
21735 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21736 
 
21737 
  def __ne__(self, other):
21738 
    return not (self == other)
4247 rajveer 21739 
 
4295 varun.gupt 21740 
class getOrdersForItemIds_args:
21741 
  """
21742 
  Attributes:
21743 
   - itemIds
21744 
  """
21745 
 
21746 
  thrift_spec = (
21747 
    None, # 0
21748 
    (1, TType.LIST, 'itemIds', (TType.I64,None), None, ), # 1
21749 
  )
21750 
 
21751 
  def __init__(self, itemIds=None,):
21752 
    self.itemIds = itemIds
21753 
 
21754 
  def read(self, iprot):
21755 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21756 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21757 
      return
21758 
    iprot.readStructBegin()
21759 
    while True:
21760 
      (fname, ftype, fid) = iprot.readFieldBegin()
21761 
      if ftype == TType.STOP:
21762 
        break
21763 
      if fid == 1:
21764 
        if ftype == TType.LIST:
21765 
          self.itemIds = []
6188 rajveer 21766 
          (_etype490, _size487) = iprot.readListBegin()
21767 
          for _i491 in xrange(_size487):
21768 
            _elem492 = iprot.readI64();
21769 
            self.itemIds.append(_elem492)
4295 varun.gupt 21770 
          iprot.readListEnd()
21771 
        else:
21772 
          iprot.skip(ftype)
21773 
      else:
21774 
        iprot.skip(ftype)
21775 
      iprot.readFieldEnd()
21776 
    iprot.readStructEnd()
21777 
 
21778 
  def write(self, oprot):
21779 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21780 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21781 
      return
21782 
    oprot.writeStructBegin('getOrdersForItemIds_args')
21783 
    if self.itemIds is not None:
21784 
      oprot.writeFieldBegin('itemIds', TType.LIST, 1)
21785 
      oprot.writeListBegin(TType.I64, len(self.itemIds))
6188 rajveer 21786 
      for iter493 in self.itemIds:
21787 
        oprot.writeI64(iter493)
4295 varun.gupt 21788 
      oprot.writeListEnd()
21789 
      oprot.writeFieldEnd()
21790 
    oprot.writeFieldStop()
21791 
    oprot.writeStructEnd()
21792 
 
21793 
  def validate(self):
21794 
    return
21795 
 
21796 
 
21797 
  def __repr__(self):
21798 
    L = ['%s=%r' % (key, value)
21799 
      for key, value in self.__dict__.iteritems()]
21800 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21801 
 
21802 
  def __eq__(self, other):
21803 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21804 
 
21805 
  def __ne__(self, other):
21806 
    return not (self == other)
21807 
 
21808 
class getOrdersForItemIds_result:
21809 
  """
21810 
  Attributes:
21811 
   - success
21812 
  """
21813 
 
21814 
  thrift_spec = (
21815 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
21816 
  )
21817 
 
21818 
  def __init__(self, success=None,):
21819 
    self.success = success
21820 
 
21821 
  def read(self, iprot):
21822 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21823 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21824 
      return
21825 
    iprot.readStructBegin()
21826 
    while True:
21827 
      (fname, ftype, fid) = iprot.readFieldBegin()
21828 
      if ftype == TType.STOP:
21829 
        break
21830 
      if fid == 0:
21831 
        if ftype == TType.LIST:
21832 
          self.success = []
6188 rajveer 21833 
          (_etype497, _size494) = iprot.readListBegin()
21834 
          for _i498 in xrange(_size494):
21835 
            _elem499 = Order()
21836 
            _elem499.read(iprot)
21837 
            self.success.append(_elem499)
4295 varun.gupt 21838 
          iprot.readListEnd()
21839 
        else:
21840 
          iprot.skip(ftype)
21841 
      else:
21842 
        iprot.skip(ftype)
21843 
      iprot.readFieldEnd()
21844 
    iprot.readStructEnd()
21845 
 
21846 
  def write(self, oprot):
21847 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21848 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21849 
      return
21850 
    oprot.writeStructBegin('getOrdersForItemIds_result')
21851 
    if self.success is not None:
21852 
      oprot.writeFieldBegin('success', TType.LIST, 0)
21853 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 21854 
      for iter500 in self.success:
21855 
        iter500.write(oprot)
4295 varun.gupt 21856 
      oprot.writeListEnd()
21857 
      oprot.writeFieldEnd()
21858 
    oprot.writeFieldStop()
21859 
    oprot.writeStructEnd()
21860 
 
21861 
  def validate(self):
21862 
    return
21863 
 
21864 
 
21865 
  def __repr__(self):
21866 
    L = ['%s=%r' % (key, value)
21867 
      for key, value in self.__dict__.iteritems()]
21868 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21869 
 
21870 
  def __eq__(self, other):
21871 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21872 
 
21873 
  def __ne__(self, other):
21874 
    return not (self == other)
21875 
 
4247 rajveer 21876 
class markOrderCancellationRequestReceived_args:
21877 
  """
21878 
  Attributes:
21879 
   - orderId
21880 
  """
21881 
 
21882 
  thrift_spec = (
21883 
    None, # 0
21884 
    (1, TType.I64, 'orderId', None, None, ), # 1
21885 
  )
21886 
 
21887 
  def __init__(self, orderId=None,):
21888 
    self.orderId = orderId
21889 
 
21890 
  def read(self, iprot):
21891 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21892 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21893 
      return
21894 
    iprot.readStructBegin()
21895 
    while True:
21896 
      (fname, ftype, fid) = iprot.readFieldBegin()
21897 
      if ftype == TType.STOP:
21898 
        break
21899 
      if fid == 1:
21900 
        if ftype == TType.I64:
21901 
          self.orderId = iprot.readI64();
21902 
        else:
21903 
          iprot.skip(ftype)
21904 
      else:
21905 
        iprot.skip(ftype)
21906 
      iprot.readFieldEnd()
21907 
    iprot.readStructEnd()
21908 
 
21909 
  def write(self, oprot):
21910 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21911 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21912 
      return
21913 
    oprot.writeStructBegin('markOrderCancellationRequestReceived_args')
21914 
    if self.orderId is not None:
21915 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
21916 
      oprot.writeI64(self.orderId)
21917 
      oprot.writeFieldEnd()
21918 
    oprot.writeFieldStop()
21919 
    oprot.writeStructEnd()
21920 
 
21921 
  def validate(self):
21922 
    return
21923 
 
21924 
 
21925 
  def __repr__(self):
21926 
    L = ['%s=%r' % (key, value)
21927 
      for key, value in self.__dict__.iteritems()]
21928 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21929 
 
21930 
  def __eq__(self, other):
21931 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21932 
 
21933 
  def __ne__(self, other):
21934 
    return not (self == other)
21935 
 
21936 
class markOrderCancellationRequestReceived_result:
21937 
  """
21938 
  Attributes:
21939 
   - ex
21940 
  """
21941 
 
21942 
  thrift_spec = (
21943 
    None, # 0
21944 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
21945 
  )
21946 
 
21947 
  def __init__(self, ex=None,):
21948 
    self.ex = ex
21949 
 
21950 
  def read(self, iprot):
21951 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21952 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21953 
      return
21954 
    iprot.readStructBegin()
21955 
    while True:
21956 
      (fname, ftype, fid) = iprot.readFieldBegin()
21957 
      if ftype == TType.STOP:
21958 
        break
21959 
      if fid == 1:
21960 
        if ftype == TType.STRUCT:
21961 
          self.ex = TransactionServiceException()
21962 
          self.ex.read(iprot)
21963 
        else:
21964 
          iprot.skip(ftype)
21965 
      else:
21966 
        iprot.skip(ftype)
21967 
      iprot.readFieldEnd()
21968 
    iprot.readStructEnd()
21969 
 
21970 
  def write(self, oprot):
21971 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21972 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21973 
      return
21974 
    oprot.writeStructBegin('markOrderCancellationRequestReceived_result')
21975 
    if self.ex is not None:
21976 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
21977 
      self.ex.write(oprot)
21978 
      oprot.writeFieldEnd()
21979 
    oprot.writeFieldStop()
21980 
    oprot.writeStructEnd()
21981 
 
21982 
  def validate(self):
21983 
    return
21984 
 
21985 
 
21986 
  def __repr__(self):
21987 
    L = ['%s=%r' % (key, value)
21988 
      for key, value in self.__dict__.iteritems()]
21989 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21990 
 
21991 
  def __eq__(self, other):
21992 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21993 
 
21994 
  def __ne__(self, other):
21995 
    return not (self == other)
21996 
 
21997 
class markOrderCancellationRequestConfirmed_args:
21998 
  """
21999 
  Attributes:
22000 
   - orderId
22001 
  """
22002 
 
22003 
  thrift_spec = (
22004 
    None, # 0
22005 
    (1, TType.I64, 'orderId', None, None, ), # 1
22006 
  )
22007 
 
22008 
  def __init__(self, orderId=None,):
22009 
    self.orderId = orderId
22010 
 
22011 
  def read(self, iprot):
22012 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22013 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22014 
      return
22015 
    iprot.readStructBegin()
22016 
    while True:
22017 
      (fname, ftype, fid) = iprot.readFieldBegin()
22018 
      if ftype == TType.STOP:
22019 
        break
22020 
      if fid == 1:
22021 
        if ftype == TType.I64:
22022 
          self.orderId = iprot.readI64();
22023 
        else:
22024 
          iprot.skip(ftype)
22025 
      else:
22026 
        iprot.skip(ftype)
22027 
      iprot.readFieldEnd()
22028 
    iprot.readStructEnd()
22029 
 
22030 
  def write(self, oprot):
22031 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22032 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22033 
      return
22034 
    oprot.writeStructBegin('markOrderCancellationRequestConfirmed_args')
22035 
    if self.orderId is not None:
22036 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
22037 
      oprot.writeI64(self.orderId)
22038 
      oprot.writeFieldEnd()
22039 
    oprot.writeFieldStop()
22040 
    oprot.writeStructEnd()
22041 
 
22042 
  def validate(self):
22043 
    return
22044 
 
22045 
 
22046 
  def __repr__(self):
22047 
    L = ['%s=%r' % (key, value)
22048 
      for key, value in self.__dict__.iteritems()]
22049 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22050 
 
22051 
  def __eq__(self, other):
22052 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22053 
 
22054 
  def __ne__(self, other):
22055 
    return not (self == other)
22056 
 
22057 
class markOrderCancellationRequestConfirmed_result:
22058 
  """
22059 
  Attributes:
22060 
   - ex
22061 
  """
22062 
 
22063 
  thrift_spec = (
22064 
    None, # 0
22065 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
22066 
  )
22067 
 
22068 
  def __init__(self, ex=None,):
22069 
    self.ex = ex
22070 
 
22071 
  def read(self, iprot):
22072 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22073 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22074 
      return
22075 
    iprot.readStructBegin()
22076 
    while True:
22077 
      (fname, ftype, fid) = iprot.readFieldBegin()
22078 
      if ftype == TType.STOP:
22079 
        break
22080 
      if fid == 1:
22081 
        if ftype == TType.STRUCT:
22082 
          self.ex = TransactionServiceException()
22083 
          self.ex.read(iprot)
22084 
        else:
22085 
          iprot.skip(ftype)
22086 
      else:
22087 
        iprot.skip(ftype)
22088 
      iprot.readFieldEnd()
22089 
    iprot.readStructEnd()
22090 
 
22091 
  def write(self, oprot):
22092 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22093 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22094 
      return
22095 
    oprot.writeStructBegin('markOrderCancellationRequestConfirmed_result')
22096 
    if self.ex is not None:
22097 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
22098 
      self.ex.write(oprot)
22099 
      oprot.writeFieldEnd()
22100 
    oprot.writeFieldStop()
22101 
    oprot.writeStructEnd()
22102 
 
22103 
  def validate(self):
22104 
    return
22105 
 
22106 
 
22107 
  def __repr__(self):
22108 
    L = ['%s=%r' % (key, value)
22109 
      for key, value in self.__dict__.iteritems()]
22110 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22111 
 
22112 
  def __eq__(self, other):
22113 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22114 
 
22115 
  def __ne__(self, other):
22116 
    return not (self == other)
22117 
 
22118 
class markOrderCancellationRequestDenied_args:
22119 
  """
22120 
  Attributes:
22121 
   - orderId
22122 
  """
22123 
 
22124 
  thrift_spec = (
22125 
    None, # 0
22126 
    (1, TType.I64, 'orderId', None, None, ), # 1
22127 
  )
22128 
 
22129 
  def __init__(self, orderId=None,):
22130 
    self.orderId = orderId
22131 
 
22132 
  def read(self, iprot):
22133 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22134 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22135 
      return
22136 
    iprot.readStructBegin()
22137 
    while True:
22138 
      (fname, ftype, fid) = iprot.readFieldBegin()
22139 
      if ftype == TType.STOP:
22140 
        break
22141 
      if fid == 1:
22142 
        if ftype == TType.I64:
22143 
          self.orderId = iprot.readI64();
22144 
        else:
22145 
          iprot.skip(ftype)
22146 
      else:
22147 
        iprot.skip(ftype)
22148 
      iprot.readFieldEnd()
22149 
    iprot.readStructEnd()
22150 
 
22151 
  def write(self, oprot):
22152 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22153 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22154 
      return
22155 
    oprot.writeStructBegin('markOrderCancellationRequestDenied_args')
22156 
    if self.orderId is not None:
22157 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
22158 
      oprot.writeI64(self.orderId)
22159 
      oprot.writeFieldEnd()
22160 
    oprot.writeFieldStop()
22161 
    oprot.writeStructEnd()
22162 
 
22163 
  def validate(self):
22164 
    return
22165 
 
22166 
 
22167 
  def __repr__(self):
22168 
    L = ['%s=%r' % (key, value)
22169 
      for key, value in self.__dict__.iteritems()]
22170 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22171 
 
22172 
  def __eq__(self, other):
22173 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22174 
 
22175 
  def __ne__(self, other):
22176 
    return not (self == other)
22177 
 
22178 
class markOrderCancellationRequestDenied_result:
22179 
  """
22180 
  Attributes:
22181 
   - ex
22182 
  """
22183 
 
22184 
  thrift_spec = (
22185 
    None, # 0
22186 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
22187 
  )
22188 
 
22189 
  def __init__(self, ex=None,):
22190 
    self.ex = ex
22191 
 
22192 
  def read(self, iprot):
22193 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22194 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22195 
      return
22196 
    iprot.readStructBegin()
22197 
    while True:
22198 
      (fname, ftype, fid) = iprot.readFieldBegin()
22199 
      if ftype == TType.STOP:
22200 
        break
22201 
      if fid == 1:
22202 
        if ftype == TType.STRUCT:
22203 
          self.ex = TransactionServiceException()
22204 
          self.ex.read(iprot)
22205 
        else:
22206 
          iprot.skip(ftype)
22207 
      else:
22208 
        iprot.skip(ftype)
22209 
      iprot.readFieldEnd()
22210 
    iprot.readStructEnd()
22211 
 
22212 
  def write(self, oprot):
22213 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22214 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22215 
      return
22216 
    oprot.writeStructBegin('markOrderCancellationRequestDenied_result')
22217 
    if self.ex is not None:
22218 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
22219 
      self.ex.write(oprot)
22220 
      oprot.writeFieldEnd()
22221 
    oprot.writeFieldStop()
22222 
    oprot.writeStructEnd()
22223 
 
22224 
  def validate(self):
22225 
    return
22226 
 
22227 
 
22228 
  def __repr__(self):
22229 
    L = ['%s=%r' % (key, value)
22230 
      for key, value in self.__dict__.iteritems()]
22231 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22232 
 
22233 
  def __eq__(self, other):
22234 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22235 
 
22236 
  def __ne__(self, other):
22237 
    return not (self == other)
22238 
 
4258 rajveer 22239 
class markTransactionAsPaymentFlagRemoved_args:
4247 rajveer 22240 
  """
22241 
  Attributes:
4258 rajveer 22242 
   - transactionId
4247 rajveer 22243 
  """
22244 
 
22245 
  thrift_spec = (
22246 
    None, # 0
4258 rajveer 22247 
    (1, TType.I64, 'transactionId', None, None, ), # 1
4247 rajveer 22248 
  )
22249 
 
4258 rajveer 22250 
  def __init__(self, transactionId=None,):
22251 
    self.transactionId = transactionId
4247 rajveer 22252 
 
22253 
  def read(self, iprot):
22254 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22255 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22256 
      return
22257 
    iprot.readStructBegin()
22258 
    while True:
22259 
      (fname, ftype, fid) = iprot.readFieldBegin()
22260 
      if ftype == TType.STOP:
22261 
        break
22262 
      if fid == 1:
22263 
        if ftype == TType.I64:
4258 rajveer 22264 
          self.transactionId = iprot.readI64();
4247 rajveer 22265 
        else:
22266 
          iprot.skip(ftype)
22267 
      else:
22268 
        iprot.skip(ftype)
22269 
      iprot.readFieldEnd()
22270 
    iprot.readStructEnd()
22271 
 
22272 
  def write(self, oprot):
22273 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22274 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22275 
      return
4258 rajveer 22276 
    oprot.writeStructBegin('markTransactionAsPaymentFlagRemoved_args')
22277 
    if self.transactionId is not None:
22278 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
22279 
      oprot.writeI64(self.transactionId)
4247 rajveer 22280 
      oprot.writeFieldEnd()
22281 
    oprot.writeFieldStop()
22282 
    oprot.writeStructEnd()
22283 
 
22284 
  def validate(self):
22285 
    return
22286 
 
22287 
 
22288 
  def __repr__(self):
22289 
    L = ['%s=%r' % (key, value)
22290 
      for key, value in self.__dict__.iteritems()]
22291 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22292 
 
22293 
  def __eq__(self, other):
22294 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22295 
 
22296 
  def __ne__(self, other):
22297 
    return not (self == other)
22298 
 
4258 rajveer 22299 
class markTransactionAsPaymentFlagRemoved_result:
4247 rajveer 22300 
  """
22301 
  Attributes:
22302 
   - ex
22303 
  """
22304 
 
22305 
  thrift_spec = (
22306 
    None, # 0
22307 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
22308 
  )
22309 
 
22310 
  def __init__(self, ex=None,):
22311 
    self.ex = ex
22312 
 
22313 
  def read(self, iprot):
22314 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22315 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22316 
      return
22317 
    iprot.readStructBegin()
22318 
    while True:
22319 
      (fname, ftype, fid) = iprot.readFieldBegin()
22320 
      if ftype == TType.STOP:
22321 
        break
22322 
      if fid == 1:
22323 
        if ftype == TType.STRUCT:
22324 
          self.ex = TransactionServiceException()
22325 
          self.ex.read(iprot)
22326 
        else:
22327 
          iprot.skip(ftype)
22328 
      else:
22329 
        iprot.skip(ftype)
22330 
      iprot.readFieldEnd()
22331 
    iprot.readStructEnd()
22332 
 
22333 
  def write(self, oprot):
22334 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22335 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22336 
      return
4258 rajveer 22337 
    oprot.writeStructBegin('markTransactionAsPaymentFlagRemoved_result')
4247 rajveer 22338 
    if self.ex is not None:
22339 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
22340 
      self.ex.write(oprot)
22341 
      oprot.writeFieldEnd()
22342 
    oprot.writeFieldStop()
22343 
    oprot.writeStructEnd()
22344 
 
22345 
  def validate(self):
22346 
    return
22347 
 
22348 
 
22349 
  def __repr__(self):
22350 
    L = ['%s=%r' % (key, value)
22351 
      for key, value in self.__dict__.iteritems()]
22352 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22353 
 
22354 
  def __eq__(self, other):
22355 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22356 
 
22357 
  def __ne__(self, other):
22358 
    return not (self == other)
4259 anupam.sin 22359 
 
22360 
class refundTransaction_args:
22361 
  """
22362 
  Attributes:
22363 
   - transactionId
22364 
   - refundedBy
22365 
   - reason
22366 
  """
22367 
 
22368 
  thrift_spec = (
22369 
    None, # 0
22370 
    (1, TType.I64, 'transactionId', None, None, ), # 1
22371 
    (2, TType.STRING, 'refundedBy', None, None, ), # 2
22372 
    (3, TType.STRING, 'reason', None, None, ), # 3
22373 
  )
22374 
 
22375 
  def __init__(self, transactionId=None, refundedBy=None, reason=None,):
22376 
    self.transactionId = transactionId
22377 
    self.refundedBy = refundedBy
22378 
    self.reason = reason
22379 
 
22380 
  def read(self, iprot):
22381 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22382 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22383 
      return
22384 
    iprot.readStructBegin()
22385 
    while True:
22386 
      (fname, ftype, fid) = iprot.readFieldBegin()
22387 
      if ftype == TType.STOP:
22388 
        break
22389 
      if fid == 1:
22390 
        if ftype == TType.I64:
22391 
          self.transactionId = iprot.readI64();
22392 
        else:
22393 
          iprot.skip(ftype)
22394 
      elif fid == 2:
22395 
        if ftype == TType.STRING:
22396 
          self.refundedBy = iprot.readString();
22397 
        else:
22398 
          iprot.skip(ftype)
22399 
      elif fid == 3:
22400 
        if ftype == TType.STRING:
22401 
          self.reason = iprot.readString();
22402 
        else:
22403 
          iprot.skip(ftype)
22404 
      else:
22405 
        iprot.skip(ftype)
22406 
      iprot.readFieldEnd()
22407 
    iprot.readStructEnd()
22408 
 
22409 
  def write(self, oprot):
22410 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22411 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22412 
      return
22413 
    oprot.writeStructBegin('refundTransaction_args')
22414 
    if self.transactionId is not None:
22415 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
22416 
      oprot.writeI64(self.transactionId)
22417 
      oprot.writeFieldEnd()
22418 
    if self.refundedBy is not None:
22419 
      oprot.writeFieldBegin('refundedBy', TType.STRING, 2)
22420 
      oprot.writeString(self.refundedBy)
22421 
      oprot.writeFieldEnd()
22422 
    if self.reason is not None:
22423 
      oprot.writeFieldBegin('reason', TType.STRING, 3)
22424 
      oprot.writeString(self.reason)
22425 
      oprot.writeFieldEnd()
22426 
    oprot.writeFieldStop()
22427 
    oprot.writeStructEnd()
22428 
 
22429 
  def validate(self):
22430 
    return
22431 
 
22432 
 
22433 
  def __repr__(self):
22434 
    L = ['%s=%r' % (key, value)
22435 
      for key, value in self.__dict__.iteritems()]
22436 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22437 
 
22438 
  def __eq__(self, other):
22439 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22440 
 
22441 
  def __ne__(self, other):
22442 
    return not (self == other)
22443 
 
22444 
class refundTransaction_result:
22445 
  """
22446 
  Attributes:
22447 
   - ex
22448 
  """
22449 
 
22450 
  thrift_spec = (
22451 
    None, # 0
22452 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
22453 
  )
22454 
 
22455 
  def __init__(self, ex=None,):
22456 
    self.ex = ex
22457 
 
22458 
  def read(self, iprot):
22459 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22460 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22461 
      return
22462 
    iprot.readStructBegin()
22463 
    while True:
22464 
      (fname, ftype, fid) = iprot.readFieldBegin()
22465 
      if ftype == TType.STOP:
22466 
        break
22467 
      if fid == 1:
22468 
        if ftype == TType.STRUCT:
22469 
          self.ex = TransactionServiceException()
22470 
          self.ex.read(iprot)
22471 
        else:
22472 
          iprot.skip(ftype)
22473 
      else:
22474 
        iprot.skip(ftype)
22475 
      iprot.readFieldEnd()
22476 
    iprot.readStructEnd()
22477 
 
22478 
  def write(self, oprot):
22479 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22480 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22481 
      return
22482 
    oprot.writeStructBegin('refundTransaction_result')
22483 
    if self.ex is not None:
22484 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
22485 
      self.ex.write(oprot)
22486 
      oprot.writeFieldEnd()
22487 
    oprot.writeFieldStop()
22488 
    oprot.writeStructEnd()
22489 
 
22490 
  def validate(self):
22491 
    return
22492 
 
22493 
 
22494 
  def __repr__(self):
22495 
    L = ['%s=%r' % (key, value)
22496 
      for key, value in self.__dict__.iteritems()]
22497 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22498 
 
22499 
  def __eq__(self, other):
22500 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22501 
 
22502 
  def __ne__(self, other):
22503 
    return not (self == other)
4285 rajveer 22504 
 
4324 mandeep.dh 22505 
class updateShipmentAddress_args:
22506 
  """
22507 
  Attributes:
22508 
   - orderId
22509 
   - addressId
22510 
  """
22511 
 
22512 
  thrift_spec = (
22513 
    None, # 0
22514 
    (1, TType.I64, 'orderId', None, None, ), # 1
22515 
    (2, TType.I64, 'addressId', None, None, ), # 2
22516 
  )
22517 
 
22518 
  def __init__(self, orderId=None, addressId=None,):
22519 
    self.orderId = orderId
22520 
    self.addressId = addressId
22521 
 
22522 
  def read(self, iprot):
22523 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22524 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22525 
      return
22526 
    iprot.readStructBegin()
22527 
    while True:
22528 
      (fname, ftype, fid) = iprot.readFieldBegin()
22529 
      if ftype == TType.STOP:
22530 
        break
22531 
      if fid == 1:
22532 
        if ftype == TType.I64:
22533 
          self.orderId = iprot.readI64();
22534 
        else:
22535 
          iprot.skip(ftype)
22536 
      elif fid == 2:
22537 
        if ftype == TType.I64:
22538 
          self.addressId = iprot.readI64();
22539 
        else:
22540 
          iprot.skip(ftype)
22541 
      else:
22542 
        iprot.skip(ftype)
22543 
      iprot.readFieldEnd()
22544 
    iprot.readStructEnd()
22545 
 
22546 
  def write(self, oprot):
22547 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22548 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22549 
      return
22550 
    oprot.writeStructBegin('updateShipmentAddress_args')
22551 
    if self.orderId is not None:
22552 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
22553 
      oprot.writeI64(self.orderId)
22554 
      oprot.writeFieldEnd()
22555 
    if self.addressId is not None:
22556 
      oprot.writeFieldBegin('addressId', TType.I64, 2)
22557 
      oprot.writeI64(self.addressId)
22558 
      oprot.writeFieldEnd()
22559 
    oprot.writeFieldStop()
22560 
    oprot.writeStructEnd()
22561 
 
22562 
  def validate(self):
22563 
    return
22564 
 
22565 
 
22566 
  def __repr__(self):
22567 
    L = ['%s=%r' % (key, value)
22568 
      for key, value in self.__dict__.iteritems()]
22569 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22570 
 
22571 
  def __eq__(self, other):
22572 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22573 
 
22574 
  def __ne__(self, other):
22575 
    return not (self == other)
22576 
 
22577 
class updateShipmentAddress_result:
22578 
  """
22579 
  Attributes:
22580 
   - ex
22581 
  """
22582 
 
22583 
  thrift_spec = (
22584 
    None, # 0
22585 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
22586 
  )
22587 
 
22588 
  def __init__(self, ex=None,):
22589 
    self.ex = ex
22590 
 
22591 
  def read(self, iprot):
22592 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22593 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22594 
      return
22595 
    iprot.readStructBegin()
22596 
    while True:
22597 
      (fname, ftype, fid) = iprot.readFieldBegin()
22598 
      if ftype == TType.STOP:
22599 
        break
22600 
      if fid == 1:
22601 
        if ftype == TType.STRUCT:
22602 
          self.ex = TransactionServiceException()
22603 
          self.ex.read(iprot)
22604 
        else:
22605 
          iprot.skip(ftype)
22606 
      else:
22607 
        iprot.skip(ftype)
22608 
      iprot.readFieldEnd()
22609 
    iprot.readStructEnd()
22610 
 
22611 
  def write(self, oprot):
22612 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22613 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22614 
      return
22615 
    oprot.writeStructBegin('updateShipmentAddress_result')
22616 
    if self.ex is not None:
22617 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
22618 
      self.ex.write(oprot)
22619 
      oprot.writeFieldEnd()
22620 
    oprot.writeFieldStop()
22621 
    oprot.writeStructEnd()
22622 
 
22623 
  def validate(self):
22624 
    return
22625 
 
22626 
 
22627 
  def __repr__(self):
22628 
    L = ['%s=%r' % (key, value)
22629 
      for key, value in self.__dict__.iteritems()]
22630 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22631 
 
22632 
  def __eq__(self, other):
22633 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22634 
 
22635 
  def __ne__(self, other):
22636 
    return not (self == other)
22637 
 
4285 rajveer 22638 
class acceptOrdersForItemId_args:
22639 
  """
22640 
  Attributes:
22641 
   - itemId
22642 
   - inventory
22643 
  """
22644 
 
22645 
  thrift_spec = (
22646 
    None, # 0
22647 
    (1, TType.I64, 'itemId', None, None, ), # 1
22648 
    (2, TType.I64, 'inventory', None, None, ), # 2
22649 
  )
22650 
 
22651 
  def __init__(self, itemId=None, inventory=None,):
22652 
    self.itemId = itemId
22653 
    self.inventory = inventory
22654 
 
22655 
  def read(self, iprot):
22656 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22657 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22658 
      return
22659 
    iprot.readStructBegin()
22660 
    while True:
22661 
      (fname, ftype, fid) = iprot.readFieldBegin()
22662 
      if ftype == TType.STOP:
22663 
        break
22664 
      if fid == 1:
22665 
        if ftype == TType.I64:
22666 
          self.itemId = iprot.readI64();
22667 
        else:
22668 
          iprot.skip(ftype)
22669 
      elif fid == 2:
22670 
        if ftype == TType.I64:
22671 
          self.inventory = iprot.readI64();
22672 
        else:
22673 
          iprot.skip(ftype)
22674 
      else:
22675 
        iprot.skip(ftype)
22676 
      iprot.readFieldEnd()
22677 
    iprot.readStructEnd()
22678 
 
22679 
  def write(self, oprot):
22680 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22681 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22682 
      return
22683 
    oprot.writeStructBegin('acceptOrdersForItemId_args')
22684 
    if self.itemId is not None:
22685 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
22686 
      oprot.writeI64(self.itemId)
22687 
      oprot.writeFieldEnd()
22688 
    if self.inventory is not None:
22689 
      oprot.writeFieldBegin('inventory', TType.I64, 2)
22690 
      oprot.writeI64(self.inventory)
22691 
      oprot.writeFieldEnd()
22692 
    oprot.writeFieldStop()
22693 
    oprot.writeStructEnd()
22694 
 
22695 
  def validate(self):
22696 
    return
22697 
 
22698 
 
22699 
  def __repr__(self):
22700 
    L = ['%s=%r' % (key, value)
22701 
      for key, value in self.__dict__.iteritems()]
22702 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22703 
 
22704 
  def __eq__(self, other):
22705 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22706 
 
22707 
  def __ne__(self, other):
22708 
    return not (self == other)
22709 
 
22710 
class acceptOrdersForItemId_result:
22711 
  """
22712 
  Attributes:
22713 
   - success
22714 
   - ex
22715 
  """
22716 
 
22717 
  thrift_spec = (
22718 
    (0, TType.BOOL, 'success', None, None, ), # 0
22719 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
22720 
  )
22721 
 
22722 
  def __init__(self, success=None, ex=None,):
22723 
    self.success = success
22724 
    self.ex = ex
22725 
 
22726 
  def read(self, iprot):
22727 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22728 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22729 
      return
22730 
    iprot.readStructBegin()
22731 
    while True:
22732 
      (fname, ftype, fid) = iprot.readFieldBegin()
22733 
      if ftype == TType.STOP:
22734 
        break
22735 
      if fid == 0:
22736 
        if ftype == TType.BOOL:
22737 
          self.success = iprot.readBool();
22738 
        else:
22739 
          iprot.skip(ftype)
22740 
      elif fid == 1:
22741 
        if ftype == TType.STRUCT:
22742 
          self.ex = TransactionServiceException()
22743 
          self.ex.read(iprot)
22744 
        else:
22745 
          iprot.skip(ftype)
22746 
      else:
22747 
        iprot.skip(ftype)
22748 
      iprot.readFieldEnd()
22749 
    iprot.readStructEnd()
22750 
 
22751 
  def write(self, oprot):
22752 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22753 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22754 
      return
22755 
    oprot.writeStructBegin('acceptOrdersForItemId_result')
22756 
    if self.success is not None:
22757 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
22758 
      oprot.writeBool(self.success)
22759 
      oprot.writeFieldEnd()
22760 
    if self.ex is not None:
22761 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
22762 
      self.ex.write(oprot)
22763 
      oprot.writeFieldEnd()
22764 
    oprot.writeFieldStop()
22765 
    oprot.writeStructEnd()
22766 
 
22767 
  def validate(self):
22768 
    return
22769 
 
22770 
 
22771 
  def __repr__(self):
22772 
    L = ['%s=%r' % (key, value)
22773 
      for key, value in self.__dict__.iteritems()]
22774 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22775 
 
22776 
  def __eq__(self, other):
22777 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22778 
 
22779 
  def __ne__(self, other):
22780 
    return not (self == other)
4303 rajveer 22781 
 
22782 
class markOrdersAsPORaised_args:
22783 
  """
22784 
  Attributes:
22785 
   - vendorId
22786 
   - itemId
22787 
   - quantity
22788 
   - estimate
4369 rajveer 22789 
   - isReminder
4303 rajveer 22790 
  """
22791 
 
22792 
  thrift_spec = (
22793 
    None, # 0
22794 
    (1, TType.I64, 'vendorId', None, None, ), # 1
22795 
    (2, TType.I64, 'itemId', None, None, ), # 2
22796 
    (3, TType.I64, 'quantity', None, None, ), # 3
22797 
    (4, TType.I64, 'estimate', None, None, ), # 4
4369 rajveer 22798 
    (5, TType.BOOL, 'isReminder', None, None, ), # 5
4303 rajveer 22799 
  )
22800 
 
4369 rajveer 22801 
  def __init__(self, vendorId=None, itemId=None, quantity=None, estimate=None, isReminder=None,):
4303 rajveer 22802 
    self.vendorId = vendorId
22803 
    self.itemId = itemId
22804 
    self.quantity = quantity
22805 
    self.estimate = estimate
4369 rajveer 22806 
    self.isReminder = isReminder
4303 rajveer 22807 
 
22808 
  def read(self, iprot):
22809 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22810 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22811 
      return
22812 
    iprot.readStructBegin()
22813 
    while True:
22814 
      (fname, ftype, fid) = iprot.readFieldBegin()
22815 
      if ftype == TType.STOP:
22816 
        break
22817 
      if fid == 1:
22818 
        if ftype == TType.I64:
22819 
          self.vendorId = iprot.readI64();
22820 
        else:
22821 
          iprot.skip(ftype)
22822 
      elif fid == 2:
22823 
        if ftype == TType.I64:
22824 
          self.itemId = iprot.readI64();
22825 
        else:
22826 
          iprot.skip(ftype)
22827 
      elif fid == 3:
22828 
        if ftype == TType.I64:
22829 
          self.quantity = iprot.readI64();
22830 
        else:
22831 
          iprot.skip(ftype)
22832 
      elif fid == 4:
22833 
        if ftype == TType.I64:
22834 
          self.estimate = iprot.readI64();
22835 
        else:
22836 
          iprot.skip(ftype)
4369 rajveer 22837 
      elif fid == 5:
22838 
        if ftype == TType.BOOL:
22839 
          self.isReminder = iprot.readBool();
22840 
        else:
22841 
          iprot.skip(ftype)
4303 rajveer 22842 
      else:
22843 
        iprot.skip(ftype)
22844 
      iprot.readFieldEnd()
22845 
    iprot.readStructEnd()
22846 
 
22847 
  def write(self, oprot):
22848 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22849 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22850 
      return
22851 
    oprot.writeStructBegin('markOrdersAsPORaised_args')
22852 
    if self.vendorId is not None:
22853 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
22854 
      oprot.writeI64(self.vendorId)
22855 
      oprot.writeFieldEnd()
22856 
    if self.itemId is not None:
22857 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
22858 
      oprot.writeI64(self.itemId)
22859 
      oprot.writeFieldEnd()
22860 
    if self.quantity is not None:
22861 
      oprot.writeFieldBegin('quantity', TType.I64, 3)
22862 
      oprot.writeI64(self.quantity)
22863 
      oprot.writeFieldEnd()
22864 
    if self.estimate is not None:
22865 
      oprot.writeFieldBegin('estimate', TType.I64, 4)
22866 
      oprot.writeI64(self.estimate)
22867 
      oprot.writeFieldEnd()
4369 rajveer 22868 
    if self.isReminder is not None:
22869 
      oprot.writeFieldBegin('isReminder', TType.BOOL, 5)
22870 
      oprot.writeBool(self.isReminder)
22871 
      oprot.writeFieldEnd()
4303 rajveer 22872 
    oprot.writeFieldStop()
22873 
    oprot.writeStructEnd()
22874 
 
22875 
  def validate(self):
22876 
    return
22877 
 
22878 
 
22879 
  def __repr__(self):
22880 
    L = ['%s=%r' % (key, value)
22881 
      for key, value in self.__dict__.iteritems()]
22882 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22883 
 
22884 
  def __eq__(self, other):
22885 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22886 
 
22887 
  def __ne__(self, other):
22888 
    return not (self == other)
22889 
 
22890 
class markOrdersAsPORaised_result:
22891 
  """
22892 
  Attributes:
22893 
   - ex
22894 
  """
22895 
 
22896 
  thrift_spec = (
22897 
    None, # 0
22898 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
22899 
  )
22900 
 
22901 
  def __init__(self, ex=None,):
22902 
    self.ex = ex
22903 
 
22904 
  def read(self, iprot):
22905 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22906 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22907 
      return
22908 
    iprot.readStructBegin()
22909 
    while True:
22910 
      (fname, ftype, fid) = iprot.readFieldBegin()
22911 
      if ftype == TType.STOP:
22912 
        break
22913 
      if fid == 1:
22914 
        if ftype == TType.STRUCT:
22915 
          self.ex = TransactionServiceException()
22916 
          self.ex.read(iprot)
22917 
        else:
22918 
          iprot.skip(ftype)
22919 
      else:
22920 
        iprot.skip(ftype)
22921 
      iprot.readFieldEnd()
22922 
    iprot.readStructEnd()
22923 
 
22924 
  def write(self, oprot):
22925 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22926 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22927 
      return
22928 
    oprot.writeStructBegin('markOrdersAsPORaised_result')
22929 
    if self.ex is not None:
22930 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
22931 
      self.ex.write(oprot)
22932 
      oprot.writeFieldEnd()
22933 
    oprot.writeFieldStop()
22934 
    oprot.writeStructEnd()
22935 
 
22936 
  def validate(self):
22937 
    return
22938 
 
22939 
 
22940 
  def __repr__(self):
22941 
    L = ['%s=%r' % (key, value)
22942 
      for key, value in self.__dict__.iteritems()]
22943 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22944 
 
22945 
  def __eq__(self, other):
22946 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22947 
 
22948 
  def __ne__(self, other):
22949 
    return not (self == other)
22950 
 
22951 
class markOrdersAsReversalInitiated_args:
22952 
  """
22953 
  Attributes:
22954 
   - vendorId
22955 
   - itemId
22956 
   - quantity
22957 
   - estimate
4369 rajveer 22958 
   - isReminder
4303 rajveer 22959 
  """
22960 
 
22961 
  thrift_spec = (
22962 
    None, # 0
22963 
    (1, TType.I64, 'vendorId', None, None, ), # 1
22964 
    (2, TType.I64, 'itemId', None, None, ), # 2
22965 
    (3, TType.I64, 'quantity', None, None, ), # 3
22966 
    (4, TType.I64, 'estimate', None, None, ), # 4
4369 rajveer 22967 
    (5, TType.BOOL, 'isReminder', None, None, ), # 5
4303 rajveer 22968 
  )
22969 
 
4369 rajveer 22970 
  def __init__(self, vendorId=None, itemId=None, quantity=None, estimate=None, isReminder=None,):
4303 rajveer 22971 
    self.vendorId = vendorId
22972 
    self.itemId = itemId
22973 
    self.quantity = quantity
22974 
    self.estimate = estimate
4369 rajveer 22975 
    self.isReminder = isReminder
4303 rajveer 22976 
 
22977 
  def read(self, iprot):
22978 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22979 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22980 
      return
22981 
    iprot.readStructBegin()
22982 
    while True:
22983 
      (fname, ftype, fid) = iprot.readFieldBegin()
22984 
      if ftype == TType.STOP:
22985 
        break
22986 
      if fid == 1:
22987 
        if ftype == TType.I64:
22988 
          self.vendorId = iprot.readI64();
22989 
        else:
22990 
          iprot.skip(ftype)
22991 
      elif fid == 2:
22992 
        if ftype == TType.I64:
22993 
          self.itemId = iprot.readI64();
22994 
        else:
22995 
          iprot.skip(ftype)
22996 
      elif fid == 3:
22997 
        if ftype == TType.I64:
22998 
          self.quantity = iprot.readI64();
22999 
        else:
23000 
          iprot.skip(ftype)
23001 
      elif fid == 4:
23002 
        if ftype == TType.I64:
23003 
          self.estimate = iprot.readI64();
23004 
        else:
23005 
          iprot.skip(ftype)
4369 rajveer 23006 
      elif fid == 5:
23007 
        if ftype == TType.BOOL:
23008 
          self.isReminder = iprot.readBool();
23009 
        else:
23010 
          iprot.skip(ftype)
4303 rajveer 23011 
      else:
23012 
        iprot.skip(ftype)
23013 
      iprot.readFieldEnd()
23014 
    iprot.readStructEnd()
23015 
 
23016 
  def write(self, oprot):
23017 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23018 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23019 
      return
23020 
    oprot.writeStructBegin('markOrdersAsReversalInitiated_args')
23021 
    if self.vendorId is not None:
23022 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
23023 
      oprot.writeI64(self.vendorId)
23024 
      oprot.writeFieldEnd()
23025 
    if self.itemId is not None:
23026 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
23027 
      oprot.writeI64(self.itemId)
23028 
      oprot.writeFieldEnd()
23029 
    if self.quantity is not None:
23030 
      oprot.writeFieldBegin('quantity', TType.I64, 3)
23031 
      oprot.writeI64(self.quantity)
23032 
      oprot.writeFieldEnd()
23033 
    if self.estimate is not None:
23034 
      oprot.writeFieldBegin('estimate', TType.I64, 4)
23035 
      oprot.writeI64(self.estimate)
23036 
      oprot.writeFieldEnd()
4369 rajveer 23037 
    if self.isReminder is not None:
23038 
      oprot.writeFieldBegin('isReminder', TType.BOOL, 5)
23039 
      oprot.writeBool(self.isReminder)
23040 
      oprot.writeFieldEnd()
4303 rajveer 23041 
    oprot.writeFieldStop()
23042 
    oprot.writeStructEnd()
23043 
 
23044 
  def validate(self):
23045 
    return
23046 
 
23047 
 
23048 
  def __repr__(self):
23049 
    L = ['%s=%r' % (key, value)
23050 
      for key, value in self.__dict__.iteritems()]
23051 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23052 
 
23053 
  def __eq__(self, other):
23054 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23055 
 
23056 
  def __ne__(self, other):
23057 
    return not (self == other)
23058 
 
23059 
class markOrdersAsReversalInitiated_result:
23060 
  """
23061 
  Attributes:
23062 
   - ex
23063 
  """
23064 
 
23065 
  thrift_spec = (
23066 
    None, # 0
23067 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
23068 
  )
23069 
 
23070 
  def __init__(self, ex=None,):
23071 
    self.ex = ex
23072 
 
23073 
  def read(self, iprot):
23074 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23075 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23076 
      return
23077 
    iprot.readStructBegin()
23078 
    while True:
23079 
      (fname, ftype, fid) = iprot.readFieldBegin()
23080 
      if ftype == TType.STOP:
23081 
        break
23082 
      if fid == 1:
23083 
        if ftype == TType.STRUCT:
23084 
          self.ex = TransactionServiceException()
23085 
          self.ex.read(iprot)
23086 
        else:
23087 
          iprot.skip(ftype)
23088 
      else:
23089 
        iprot.skip(ftype)
23090 
      iprot.readFieldEnd()
23091 
    iprot.readStructEnd()
23092 
 
23093 
  def write(self, oprot):
23094 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23095 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23096 
      return
23097 
    oprot.writeStructBegin('markOrdersAsReversalInitiated_result')
23098 
    if self.ex is not None:
23099 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
23100 
      self.ex.write(oprot)
23101 
      oprot.writeFieldEnd()
23102 
    oprot.writeFieldStop()
23103 
    oprot.writeStructEnd()
23104 
 
23105 
  def validate(self):
23106 
    return
23107 
 
23108 
 
23109 
  def __repr__(self):
23110 
    L = ['%s=%r' % (key, value)
23111 
      for key, value in self.__dict__.iteritems()]
23112 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23113 
 
23114 
  def __eq__(self, other):
23115 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23116 
 
23117 
  def __ne__(self, other):
23118 
    return not (self == other)
23119 
 
23120 
class markOrdersAsNotAvailabke_args:
23121 
  """
23122 
  Attributes:
23123 
   - vendorId
23124 
   - itemId
23125 
   - quantity
23126 
   - estimate
4369 rajveer 23127 
   - isReminder
4303 rajveer 23128 
  """
23129 
 
23130 
  thrift_spec = (
23131 
    None, # 0
23132 
    (1, TType.I64, 'vendorId', None, None, ), # 1
23133 
    (2, TType.I64, 'itemId', None, None, ), # 2
23134 
    (3, TType.I64, 'quantity', None, None, ), # 3
23135 
    (4, TType.I64, 'estimate', None, None, ), # 4
4369 rajveer 23136 
    (5, TType.BOOL, 'isReminder', None, None, ), # 5
4303 rajveer 23137 
  )
23138 
 
4369 rajveer 23139 
  def __init__(self, vendorId=None, itemId=None, quantity=None, estimate=None, isReminder=None,):
4303 rajveer 23140 
    self.vendorId = vendorId
23141 
    self.itemId = itemId
23142 
    self.quantity = quantity
23143 
    self.estimate = estimate
4369 rajveer 23144 
    self.isReminder = isReminder
4303 rajveer 23145 
 
23146 
  def read(self, iprot):
23147 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23148 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23149 
      return
23150 
    iprot.readStructBegin()
23151 
    while True:
23152 
      (fname, ftype, fid) = iprot.readFieldBegin()
23153 
      if ftype == TType.STOP:
23154 
        break
23155 
      if fid == 1:
23156 
        if ftype == TType.I64:
23157 
          self.vendorId = iprot.readI64();
23158 
        else:
23159 
          iprot.skip(ftype)
23160 
      elif fid == 2:
23161 
        if ftype == TType.I64:
23162 
          self.itemId = iprot.readI64();
23163 
        else:
23164 
          iprot.skip(ftype)
23165 
      elif fid == 3:
23166 
        if ftype == TType.I64:
23167 
          self.quantity = iprot.readI64();
23168 
        else:
23169 
          iprot.skip(ftype)
23170 
      elif fid == 4:
23171 
        if ftype == TType.I64:
23172 
          self.estimate = iprot.readI64();
23173 
        else:
23174 
          iprot.skip(ftype)
4369 rajveer 23175 
      elif fid == 5:
23176 
        if ftype == TType.BOOL:
23177 
          self.isReminder = iprot.readBool();
23178 
        else:
23179 
          iprot.skip(ftype)
4303 rajveer 23180 
      else:
23181 
        iprot.skip(ftype)
23182 
      iprot.readFieldEnd()
23183 
    iprot.readStructEnd()
23184 
 
23185 
  def write(self, oprot):
23186 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23187 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23188 
      return
23189 
    oprot.writeStructBegin('markOrdersAsNotAvailabke_args')
23190 
    if self.vendorId is not None:
23191 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
23192 
      oprot.writeI64(self.vendorId)
23193 
      oprot.writeFieldEnd()
23194 
    if self.itemId is not None:
23195 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
23196 
      oprot.writeI64(self.itemId)
23197 
      oprot.writeFieldEnd()
23198 
    if self.quantity is not None:
23199 
      oprot.writeFieldBegin('quantity', TType.I64, 3)
23200 
      oprot.writeI64(self.quantity)
23201 
      oprot.writeFieldEnd()
23202 
    if self.estimate is not None:
23203 
      oprot.writeFieldBegin('estimate', TType.I64, 4)
23204 
      oprot.writeI64(self.estimate)
23205 
      oprot.writeFieldEnd()
4369 rajveer 23206 
    if self.isReminder is not None:
23207 
      oprot.writeFieldBegin('isReminder', TType.BOOL, 5)
23208 
      oprot.writeBool(self.isReminder)
23209 
      oprot.writeFieldEnd()
4303 rajveer 23210 
    oprot.writeFieldStop()
23211 
    oprot.writeStructEnd()
23212 
 
23213 
  def validate(self):
23214 
    return
23215 
 
23216 
 
23217 
  def __repr__(self):
23218 
    L = ['%s=%r' % (key, value)
23219 
      for key, value in self.__dict__.iteritems()]
23220 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23221 
 
23222 
  def __eq__(self, other):
23223 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23224 
 
23225 
  def __ne__(self, other):
23226 
    return not (self == other)
23227 
 
23228 
class markOrdersAsNotAvailabke_result:
23229 
  """
23230 
  Attributes:
23231 
   - ex
23232 
  """
23233 
 
23234 
  thrift_spec = (
23235 
    None, # 0
23236 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
23237 
  )
23238 
 
23239 
  def __init__(self, ex=None,):
23240 
    self.ex = ex
23241 
 
23242 
  def read(self, iprot):
23243 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23244 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23245 
      return
23246 
    iprot.readStructBegin()
23247 
    while True:
23248 
      (fname, ftype, fid) = iprot.readFieldBegin()
23249 
      if ftype == TType.STOP:
23250 
        break
23251 
      if fid == 1:
23252 
        if ftype == TType.STRUCT:
23253 
          self.ex = TransactionServiceException()
23254 
          self.ex.read(iprot)
23255 
        else:
23256 
          iprot.skip(ftype)
23257 
      else:
23258 
        iprot.skip(ftype)
23259 
      iprot.readFieldEnd()
23260 
    iprot.readStructEnd()
23261 
 
23262 
  def write(self, oprot):
23263 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23264 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23265 
      return
23266 
    oprot.writeStructBegin('markOrdersAsNotAvailabke_result')
23267 
    if self.ex is not None:
23268 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
23269 
      self.ex.write(oprot)
23270 
      oprot.writeFieldEnd()
23271 
    oprot.writeFieldStop()
23272 
    oprot.writeStructEnd()
23273 
 
23274 
  def validate(self):
23275 
    return
23276 
 
23277 
 
23278 
  def __repr__(self):
23279 
    L = ['%s=%r' % (key, value)
23280 
      for key, value in self.__dict__.iteritems()]
23281 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23282 
 
23283 
  def __eq__(self, other):
23284 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23285 
 
23286 
  def __ne__(self, other):
23287 
    return not (self == other)
4369 rajveer 23288 
 
23289 
class markOrdersAsTimeout_args:
23290 
  """
23291 
  Attributes:
23292 
   - vendorId
23293 
  """
23294 
 
23295 
  thrift_spec = (
23296 
    None, # 0
23297 
    (1, TType.I64, 'vendorId', None, None, ), # 1
23298 
  )
23299 
 
23300 
  def __init__(self, vendorId=None,):
23301 
    self.vendorId = vendorId
23302 
 
23303 
  def read(self, iprot):
23304 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23305 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23306 
      return
23307 
    iprot.readStructBegin()
23308 
    while True:
23309 
      (fname, ftype, fid) = iprot.readFieldBegin()
23310 
      if ftype == TType.STOP:
23311 
        break
23312 
      if fid == 1:
23313 
        if ftype == TType.I64:
23314 
          self.vendorId = iprot.readI64();
23315 
        else:
23316 
          iprot.skip(ftype)
23317 
      else:
23318 
        iprot.skip(ftype)
23319 
      iprot.readFieldEnd()
23320 
    iprot.readStructEnd()
23321 
 
23322 
  def write(self, oprot):
23323 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23324 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23325 
      return
23326 
    oprot.writeStructBegin('markOrdersAsTimeout_args')
23327 
    if self.vendorId is not None:
23328 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
23329 
      oprot.writeI64(self.vendorId)
23330 
      oprot.writeFieldEnd()
23331 
    oprot.writeFieldStop()
23332 
    oprot.writeStructEnd()
23333 
 
23334 
  def validate(self):
23335 
    return
23336 
 
23337 
 
23338 
  def __repr__(self):
23339 
    L = ['%s=%r' % (key, value)
23340 
      for key, value in self.__dict__.iteritems()]
23341 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23342 
 
23343 
  def __eq__(self, other):
23344 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23345 
 
23346 
  def __ne__(self, other):
23347 
    return not (self == other)
23348 
 
23349 
class markOrdersAsTimeout_result:
23350 
  """
23351 
  Attributes:
23352 
   - success
23353 
   - ex
23354 
  """
23355 
 
23356 
  thrift_spec = (
23357 
    (0, TType.MAP, 'success', (TType.I32,None,TType.STRUCT,(TimeoutSummary, TimeoutSummary.thrift_spec)), None, ), # 0
23358 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
23359 
  )
23360 
 
23361 
  def __init__(self, success=None, ex=None,):
23362 
    self.success = success
23363 
    self.ex = ex
23364 
 
23365 
  def read(self, iprot):
23366 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23367 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23368 
      return
23369 
    iprot.readStructBegin()
23370 
    while True:
23371 
      (fname, ftype, fid) = iprot.readFieldBegin()
23372 
      if ftype == TType.STOP:
23373 
        break
23374 
      if fid == 0:
23375 
        if ftype == TType.MAP:
23376 
          self.success = {}
6188 rajveer 23377 
          (_ktype502, _vtype503, _size501 ) = iprot.readMapBegin()
23378 
          for _i505 in xrange(_size501):
23379 
            _key506 = iprot.readI32();
23380 
            _val507 = TimeoutSummary()
23381 
            _val507.read(iprot)
23382 
            self.success[_key506] = _val507
4369 rajveer 23383 
          iprot.readMapEnd()
23384 
        else:
23385 
          iprot.skip(ftype)
23386 
      elif fid == 1:
23387 
        if ftype == TType.STRUCT:
23388 
          self.ex = TransactionServiceException()
23389 
          self.ex.read(iprot)
23390 
        else:
23391 
          iprot.skip(ftype)
23392 
      else:
23393 
        iprot.skip(ftype)
23394 
      iprot.readFieldEnd()
23395 
    iprot.readStructEnd()
23396 
 
23397 
  def write(self, oprot):
23398 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23399 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23400 
      return
23401 
    oprot.writeStructBegin('markOrdersAsTimeout_result')
23402 
    if self.success is not None:
23403 
      oprot.writeFieldBegin('success', TType.MAP, 0)
23404 
      oprot.writeMapBegin(TType.I32, TType.STRUCT, len(self.success))
6188 rajveer 23405 
      for kiter508,viter509 in self.success.items():
23406 
        oprot.writeI32(kiter508)
23407 
        viter509.write(oprot)
4369 rajveer 23408 
      oprot.writeMapEnd()
23409 
      oprot.writeFieldEnd()
23410 
    if self.ex is not None:
23411 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
23412 
      self.ex.write(oprot)
23413 
      oprot.writeFieldEnd()
23414 
    oprot.writeFieldStop()
23415 
    oprot.writeStructEnd()
23416 
 
23417 
  def validate(self):
23418 
    return
23419 
 
23420 
 
23421 
  def __repr__(self):
23422 
    L = ['%s=%r' % (key, value)
23423 
      for key, value in self.__dict__.iteritems()]
23424 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23425 
 
23426 
  def __eq__(self, other):
23427 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23428 
 
23429 
  def __ne__(self, other):
23430 
    return not (self == other)
4386 anupam.sin 23431 
 
4662 rajveer 23432 
class markOrderAsLostInTransit_args:
23433 
  """
23434 
  Attributes:
23435 
   - orderId
23436 
  """
23437 
 
23438 
  thrift_spec = (
23439 
    None, # 0
23440 
    (1, TType.I64, 'orderId', None, None, ), # 1
23441 
  )
23442 
 
23443 
  def __init__(self, orderId=None,):
23444 
    self.orderId = orderId
23445 
 
23446 
  def read(self, iprot):
23447 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23448 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23449 
      return
23450 
    iprot.readStructBegin()
23451 
    while True:
23452 
      (fname, ftype, fid) = iprot.readFieldBegin()
23453 
      if ftype == TType.STOP:
23454 
        break
23455 
      if fid == 1:
23456 
        if ftype == TType.I64:
23457 
          self.orderId = iprot.readI64();
23458 
        else:
23459 
          iprot.skip(ftype)
23460 
      else:
23461 
        iprot.skip(ftype)
23462 
      iprot.readFieldEnd()
23463 
    iprot.readStructEnd()
23464 
 
23465 
  def write(self, oprot):
23466 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23467 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23468 
      return
23469 
    oprot.writeStructBegin('markOrderAsLostInTransit_args')
23470 
    if self.orderId is not None:
23471 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
23472 
      oprot.writeI64(self.orderId)
23473 
      oprot.writeFieldEnd()
23474 
    oprot.writeFieldStop()
23475 
    oprot.writeStructEnd()
23476 
 
23477 
  def validate(self):
23478 
    return
23479 
 
23480 
 
23481 
  def __repr__(self):
23482 
    L = ['%s=%r' % (key, value)
23483 
      for key, value in self.__dict__.iteritems()]
23484 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23485 
 
23486 
  def __eq__(self, other):
23487 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23488 
 
23489 
  def __ne__(self, other):
23490 
    return not (self == other)
23491 
 
23492 
class markOrderAsLostInTransit_result:
23493 
  """
23494 
  Attributes:
23495 
   - success
23496 
   - ex
23497 
  """
23498 
 
23499 
  thrift_spec = (
23500 
    (0, TType.BOOL, 'success', None, None, ), # 0
23501 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
23502 
  )
23503 
 
23504 
  def __init__(self, success=None, ex=None,):
23505 
    self.success = success
23506 
    self.ex = ex
23507 
 
23508 
  def read(self, iprot):
23509 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23510 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23511 
      return
23512 
    iprot.readStructBegin()
23513 
    while True:
23514 
      (fname, ftype, fid) = iprot.readFieldBegin()
23515 
      if ftype == TType.STOP:
23516 
        break
23517 
      if fid == 0:
23518 
        if ftype == TType.BOOL:
23519 
          self.success = iprot.readBool();
23520 
        else:
23521 
          iprot.skip(ftype)
23522 
      elif fid == 1:
23523 
        if ftype == TType.STRUCT:
23524 
          self.ex = TransactionServiceException()
23525 
          self.ex.read(iprot)
23526 
        else:
23527 
          iprot.skip(ftype)
23528 
      else:
23529 
        iprot.skip(ftype)
23530 
      iprot.readFieldEnd()
23531 
    iprot.readStructEnd()
23532 
 
23533 
  def write(self, oprot):
23534 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23535 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23536 
      return
23537 
    oprot.writeStructBegin('markOrderAsLostInTransit_result')
23538 
    if self.success is not None:
23539 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
23540 
      oprot.writeBool(self.success)
23541 
      oprot.writeFieldEnd()
23542 
    if self.ex is not None:
23543 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
23544 
      self.ex.write(oprot)
23545 
      oprot.writeFieldEnd()
23546 
    oprot.writeFieldStop()
23547 
    oprot.writeStructEnd()
23548 
 
23549 
  def validate(self):
23550 
    return
23551 
 
23552 
 
23553 
  def __repr__(self):
23554 
    L = ['%s=%r' % (key, value)
23555 
      for key, value in self.__dict__.iteritems()]
23556 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23557 
 
23558 
  def __eq__(self, other):
23559 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23560 
 
23561 
  def __ne__(self, other):
23562 
    return not (self == other)
23563 
 
4386 anupam.sin 23564 
class getOrderForAwb_args:
23565 
  """
23566 
  Attributes:
23567 
   - awb
23568 
  """
23569 
 
23570 
  thrift_spec = (
23571 
    None, # 0
23572 
    (1, TType.STRING, 'awb', None, None, ), # 1
23573 
  )
23574 
 
23575 
  def __init__(self, awb=None,):
23576 
    self.awb = awb
23577 
 
23578 
  def read(self, iprot):
23579 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23580 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23581 
      return
23582 
    iprot.readStructBegin()
23583 
    while True:
23584 
      (fname, ftype, fid) = iprot.readFieldBegin()
23585 
      if ftype == TType.STOP:
23586 
        break
23587 
      if fid == 1:
23588 
        if ftype == TType.STRING:
23589 
          self.awb = iprot.readString();
23590 
        else:
23591 
          iprot.skip(ftype)
23592 
      else:
23593 
        iprot.skip(ftype)
23594 
      iprot.readFieldEnd()
23595 
    iprot.readStructEnd()
23596 
 
23597 
  def write(self, oprot):
23598 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23599 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23600 
      return
23601 
    oprot.writeStructBegin('getOrderForAwb_args')
23602 
    if self.awb is not None:
23603 
      oprot.writeFieldBegin('awb', TType.STRING, 1)
23604 
      oprot.writeString(self.awb)
23605 
      oprot.writeFieldEnd()
23606 
    oprot.writeFieldStop()
23607 
    oprot.writeStructEnd()
23608 
 
23609 
  def validate(self):
23610 
    return
23611 
 
23612 
 
23613 
  def __repr__(self):
23614 
    L = ['%s=%r' % (key, value)
23615 
      for key, value in self.__dict__.iteritems()]
23616 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23617 
 
23618 
  def __eq__(self, other):
23619 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23620 
 
23621 
  def __ne__(self, other):
23622 
    return not (self == other)
23623 
 
23624 
class getOrderForAwb_result:
23625 
  """
23626 
  Attributes:
23627 
   - success
23628 
   - ex
23629 
  """
23630 
 
23631 
  thrift_spec = (
23632 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
23633 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
23634 
  )
23635 
 
23636 
  def __init__(self, success=None, ex=None,):
23637 
    self.success = success
23638 
    self.ex = ex
23639 
 
23640 
  def read(self, iprot):
23641 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23642 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23643 
      return
23644 
    iprot.readStructBegin()
23645 
    while True:
23646 
      (fname, ftype, fid) = iprot.readFieldBegin()
23647 
      if ftype == TType.STOP:
23648 
        break
23649 
      if fid == 0:
23650 
        if ftype == TType.STRUCT:
23651 
          self.success = Order()
23652 
          self.success.read(iprot)
23653 
        else:
23654 
          iprot.skip(ftype)
23655 
      elif fid == 1:
23656 
        if ftype == TType.STRUCT:
23657 
          self.ex = TransactionServiceException()
23658 
          self.ex.read(iprot)
23659 
        else:
23660 
          iprot.skip(ftype)
23661 
      else:
23662 
        iprot.skip(ftype)
23663 
      iprot.readFieldEnd()
23664 
    iprot.readStructEnd()
23665 
 
23666 
  def write(self, oprot):
23667 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23668 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23669 
      return
23670 
    oprot.writeStructBegin('getOrderForAwb_result')
23671 
    if self.success is not None:
23672 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
23673 
      self.success.write(oprot)
23674 
      oprot.writeFieldEnd()
23675 
    if self.ex is not None:
23676 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
23677 
      self.ex.write(oprot)
23678 
      oprot.writeFieldEnd()
23679 
    oprot.writeFieldStop()
23680 
    oprot.writeStructEnd()
23681 
 
23682 
  def validate(self):
23683 
    return
23684 
 
23685 
 
23686 
  def __repr__(self):
23687 
    L = ['%s=%r' % (key, value)
23688 
      for key, value in self.__dict__.iteritems()]
23689 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23690 
 
23691 
  def __eq__(self, other):
23692 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23693 
 
23694 
  def __ne__(self, other):
23695 
    return not (self == other)
4506 phani.kuma 23696 
 
23697 
class getOrdersForProviderForStatus_args:
23698 
  """
23699 
  Attributes:
23700 
   - logistics_provider_id
4910 phani.kuma 23701 
   - order_status_list
4506 phani.kuma 23702 
  """
23703 
 
23704 
  thrift_spec = (
23705 
    None, # 0
23706 
    (1, TType.I64, 'logistics_provider_id', None, None, ), # 1
4910 phani.kuma 23707 
    (2, TType.LIST, 'order_status_list', (TType.I32,None), None, ), # 2
4506 phani.kuma 23708 
  )
23709 
 
4910 phani.kuma 23710 
  def __init__(self, logistics_provider_id=None, order_status_list=None,):
4506 phani.kuma 23711 
    self.logistics_provider_id = logistics_provider_id
4910 phani.kuma 23712 
    self.order_status_list = order_status_list
4506 phani.kuma 23713 
 
23714 
  def read(self, iprot):
23715 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23716 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23717 
      return
23718 
    iprot.readStructBegin()
23719 
    while True:
23720 
      (fname, ftype, fid) = iprot.readFieldBegin()
23721 
      if ftype == TType.STOP:
23722 
        break
23723 
      if fid == 1:
23724 
        if ftype == TType.I64:
23725 
          self.logistics_provider_id = iprot.readI64();
23726 
        else:
23727 
          iprot.skip(ftype)
23728 
      elif fid == 2:
4910 phani.kuma 23729 
        if ftype == TType.LIST:
23730 
          self.order_status_list = []
6188 rajveer 23731 
          (_etype513, _size510) = iprot.readListBegin()
23732 
          for _i514 in xrange(_size510):
23733 
            _elem515 = iprot.readI32();
23734 
            self.order_status_list.append(_elem515)
4910 phani.kuma 23735 
          iprot.readListEnd()
4506 phani.kuma 23736 
        else:
23737 
          iprot.skip(ftype)
23738 
      else:
23739 
        iprot.skip(ftype)
23740 
      iprot.readFieldEnd()
23741 
    iprot.readStructEnd()
23742 
 
23743 
  def write(self, oprot):
23744 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23745 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23746 
      return
23747 
    oprot.writeStructBegin('getOrdersForProviderForStatus_args')
23748 
    if self.logistics_provider_id is not None:
23749 
      oprot.writeFieldBegin('logistics_provider_id', TType.I64, 1)
23750 
      oprot.writeI64(self.logistics_provider_id)
23751 
      oprot.writeFieldEnd()
4910 phani.kuma 23752 
    if self.order_status_list is not None:
23753 
      oprot.writeFieldBegin('order_status_list', TType.LIST, 2)
23754 
      oprot.writeListBegin(TType.I32, len(self.order_status_list))
6188 rajveer 23755 
      for iter516 in self.order_status_list:
23756 
        oprot.writeI32(iter516)
4910 phani.kuma 23757 
      oprot.writeListEnd()
4506 phani.kuma 23758 
      oprot.writeFieldEnd()
23759 
    oprot.writeFieldStop()
23760 
    oprot.writeStructEnd()
23761 
 
23762 
  def validate(self):
23763 
    return
23764 
 
23765 
 
23766 
  def __repr__(self):
23767 
    L = ['%s=%r' % (key, value)
23768 
      for key, value in self.__dict__.iteritems()]
23769 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23770 
 
23771 
  def __eq__(self, other):
23772 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23773 
 
23774 
  def __ne__(self, other):
23775 
    return not (self == other)
23776 
 
23777 
class getOrdersForProviderForStatus_result:
23778 
  """
23779 
  Attributes:
23780 
   - success
23781 
   - ex
23782 
  """
23783 
 
23784 
  thrift_spec = (
23785 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
23786 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
23787 
  )
23788 
 
23789 
  def __init__(self, success=None, ex=None,):
23790 
    self.success = success
23791 
    self.ex = ex
23792 
 
23793 
  def read(self, iprot):
23794 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23795 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23796 
      return
23797 
    iprot.readStructBegin()
23798 
    while True:
23799 
      (fname, ftype, fid) = iprot.readFieldBegin()
23800 
      if ftype == TType.STOP:
23801 
        break
23802 
      if fid == 0:
23803 
        if ftype == TType.LIST:
23804 
          self.success = []
6188 rajveer 23805 
          (_etype520, _size517) = iprot.readListBegin()
23806 
          for _i521 in xrange(_size517):
23807 
            _elem522 = Order()
23808 
            _elem522.read(iprot)
23809 
            self.success.append(_elem522)
4506 phani.kuma 23810 
          iprot.readListEnd()
23811 
        else:
23812 
          iprot.skip(ftype)
23813 
      elif fid == 1:
23814 
        if ftype == TType.STRUCT:
23815 
          self.ex = TransactionServiceException()
23816 
          self.ex.read(iprot)
23817 
        else:
23818 
          iprot.skip(ftype)
23819 
      else:
23820 
        iprot.skip(ftype)
23821 
      iprot.readFieldEnd()
23822 
    iprot.readStructEnd()
23823 
 
23824 
  def write(self, oprot):
23825 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23826 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23827 
      return
23828 
    oprot.writeStructBegin('getOrdersForProviderForStatus_result')
23829 
    if self.success is not None:
23830 
      oprot.writeFieldBegin('success', TType.LIST, 0)
23831 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 23832 
      for iter523 in self.success:
23833 
        iter523.write(oprot)
4506 phani.kuma 23834 
      oprot.writeListEnd()
23835 
      oprot.writeFieldEnd()
23836 
    if self.ex is not None:
23837 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
23838 
      self.ex.write(oprot)
23839 
      oprot.writeFieldEnd()
23840 
    oprot.writeFieldStop()
23841 
    oprot.writeStructEnd()
23842 
 
23843 
  def validate(self):
23844 
    return
23845 
 
23846 
 
23847 
  def __repr__(self):
23848 
    L = ['%s=%r' % (key, value)
23849 
      for key, value in self.__dict__.iteritems()]
23850 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23851 
 
23852 
  def __eq__(self, other):
23853 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23854 
 
23855 
  def __ne__(self, other):
23856 
    return not (self == other)
4600 varun.gupt 23857 
 
23858 
class getBilledOrdersForVendor_args:
23859 
  """
23860 
  Attributes:
23861 
   - vendorId
23862 
   - billingDateFrom
23863 
   - billingDateTo
23864 
  """
23865 
 
23866 
  thrift_spec = (
23867 
    None, # 0
23868 
    (1, TType.I64, 'vendorId', None, None, ), # 1
23869 
    (2, TType.I64, 'billingDateFrom', None, None, ), # 2
23870 
    (3, TType.I64, 'billingDateTo', None, None, ), # 3
23871 
  )
23872 
 
23873 
  def __init__(self, vendorId=None, billingDateFrom=None, billingDateTo=None,):
23874 
    self.vendorId = vendorId
23875 
    self.billingDateFrom = billingDateFrom
23876 
    self.billingDateTo = billingDateTo
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 == 1:
23888 
        if ftype == TType.I64:
23889 
          self.vendorId = iprot.readI64();
23890 
        else:
23891 
          iprot.skip(ftype)
23892 
      elif fid == 2:
23893 
        if ftype == TType.I64:
23894 
          self.billingDateFrom = iprot.readI64();
23895 
        else:
23896 
          iprot.skip(ftype)
23897 
      elif fid == 3:
23898 
        if ftype == TType.I64:
23899 
          self.billingDateTo = iprot.readI64();
23900 
        else:
23901 
          iprot.skip(ftype)
23902 
      else:
23903 
        iprot.skip(ftype)
23904 
      iprot.readFieldEnd()
23905 
    iprot.readStructEnd()
23906 
 
23907 
  def write(self, oprot):
23908 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23909 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23910 
      return
23911 
    oprot.writeStructBegin('getBilledOrdersForVendor_args')
23912 
    if self.vendorId is not None:
23913 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
23914 
      oprot.writeI64(self.vendorId)
23915 
      oprot.writeFieldEnd()
23916 
    if self.billingDateFrom is not None:
23917 
      oprot.writeFieldBegin('billingDateFrom', TType.I64, 2)
23918 
      oprot.writeI64(self.billingDateFrom)
23919 
      oprot.writeFieldEnd()
23920 
    if self.billingDateTo is not None:
23921 
      oprot.writeFieldBegin('billingDateTo', TType.I64, 3)
23922 
      oprot.writeI64(self.billingDateTo)
23923 
      oprot.writeFieldEnd()
23924 
    oprot.writeFieldStop()
23925 
    oprot.writeStructEnd()
23926 
 
23927 
  def validate(self):
23928 
    return
23929 
 
23930 
 
23931 
  def __repr__(self):
23932 
    L = ['%s=%r' % (key, value)
23933 
      for key, value in self.__dict__.iteritems()]
23934 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23935 
 
23936 
  def __eq__(self, other):
23937 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23938 
 
23939 
  def __ne__(self, other):
23940 
    return not (self == other)
23941 
 
23942 
class getBilledOrdersForVendor_result:
23943 
  """
23944 
  Attributes:
23945 
   - success
23946 
   - ex
23947 
  """
23948 
 
23949 
  thrift_spec = (
23950 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
23951 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
23952 
  )
23953 
 
23954 
  def __init__(self, success=None, ex=None,):
23955 
    self.success = success
23956 
    self.ex = ex
23957 
 
23958 
  def read(self, iprot):
23959 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23960 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23961 
      return
23962 
    iprot.readStructBegin()
23963 
    while True:
23964 
      (fname, ftype, fid) = iprot.readFieldBegin()
23965 
      if ftype == TType.STOP:
23966 
        break
23967 
      if fid == 0:
23968 
        if ftype == TType.LIST:
23969 
          self.success = []
6188 rajveer 23970 
          (_etype527, _size524) = iprot.readListBegin()
23971 
          for _i528 in xrange(_size524):
23972 
            _elem529 = Order()
23973 
            _elem529.read(iprot)
23974 
            self.success.append(_elem529)
4600 varun.gupt 23975 
          iprot.readListEnd()
23976 
        else:
23977 
          iprot.skip(ftype)
23978 
      elif fid == 1:
23979 
        if ftype == TType.STRUCT:
23980 
          self.ex = TransactionServiceException()
23981 
          self.ex.read(iprot)
23982 
        else:
23983 
          iprot.skip(ftype)
23984 
      else:
23985 
        iprot.skip(ftype)
23986 
      iprot.readFieldEnd()
23987 
    iprot.readStructEnd()
23988 
 
23989 
  def write(self, oprot):
23990 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23991 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23992 
      return
23993 
    oprot.writeStructBegin('getBilledOrdersForVendor_result')
23994 
    if self.success is not None:
23995 
      oprot.writeFieldBegin('success', TType.LIST, 0)
23996 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 23997 
      for iter530 in self.success:
23998 
        iter530.write(oprot)
4600 varun.gupt 23999 
      oprot.writeListEnd()
24000 
      oprot.writeFieldEnd()
24001 
    if self.ex is not None:
24002 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
24003 
      self.ex.write(oprot)
24004 
      oprot.writeFieldEnd()
24005 
    oprot.writeFieldStop()
24006 
    oprot.writeStructEnd()
24007 
 
24008 
  def validate(self):
24009 
    return
24010 
 
24011 
 
24012 
  def __repr__(self):
24013 
    L = ['%s=%r' % (key, value)
24014 
      for key, value in self.__dict__.iteritems()]
24015 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24016 
 
24017 
  def __eq__(self, other):
24018 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24019 
 
24020 
  def __ne__(self, other):
24021 
    return not (self == other)
24022 
 
4607 rajveer 24023 
class getSlippedSippingDateOrders_args:
24024 
 
24025 
  thrift_spec = (
24026 
  )
24027 
 
24028 
  def read(self, iprot):
24029 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24030 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24031 
      return
24032 
    iprot.readStructBegin()
24033 
    while True:
24034 
      (fname, ftype, fid) = iprot.readFieldBegin()
24035 
      if ftype == TType.STOP:
24036 
        break
24037 
      else:
24038 
        iprot.skip(ftype)
24039 
      iprot.readFieldEnd()
24040 
    iprot.readStructEnd()
24041 
 
24042 
  def write(self, oprot):
24043 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24044 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24045 
      return
24046 
    oprot.writeStructBegin('getSlippedSippingDateOrders_args')
24047 
    oprot.writeFieldStop()
24048 
    oprot.writeStructEnd()
24049 
 
24050 
  def validate(self):
24051 
    return
24052 
 
24053 
 
24054 
  def __repr__(self):
24055 
    L = ['%s=%r' % (key, value)
24056 
      for key, value in self.__dict__.iteritems()]
24057 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24058 
 
24059 
  def __eq__(self, other):
24060 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24061 
 
24062 
  def __ne__(self, other):
24063 
    return not (self == other)
24064 
 
24065 
class getSlippedSippingDateOrders_result:
24066 
  """
24067 
  Attributes:
24068 
   - success
24069 
   - ex
24070 
  """
24071 
 
24072 
  thrift_spec = (
24073 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
24074 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
24075 
  )
24076 
 
24077 
  def __init__(self, success=None, ex=None,):
24078 
    self.success = success
24079 
    self.ex = ex
24080 
 
24081 
  def read(self, iprot):
24082 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24083 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24084 
      return
24085 
    iprot.readStructBegin()
24086 
    while True:
24087 
      (fname, ftype, fid) = iprot.readFieldBegin()
24088 
      if ftype == TType.STOP:
24089 
        break
24090 
      if fid == 0:
24091 
        if ftype == TType.LIST:
24092 
          self.success = []
6188 rajveer 24093 
          (_etype534, _size531) = iprot.readListBegin()
24094 
          for _i535 in xrange(_size531):
24095 
            _elem536 = Order()
24096 
            _elem536.read(iprot)
24097 
            self.success.append(_elem536)
4607 rajveer 24098 
          iprot.readListEnd()
24099 
        else:
24100 
          iprot.skip(ftype)
24101 
      elif fid == 1:
24102 
        if ftype == TType.STRUCT:
24103 
          self.ex = TransactionServiceException()
24104 
          self.ex.read(iprot)
24105 
        else:
24106 
          iprot.skip(ftype)
24107 
      else:
24108 
        iprot.skip(ftype)
24109 
      iprot.readFieldEnd()
24110 
    iprot.readStructEnd()
24111 
 
24112 
  def write(self, oprot):
24113 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24114 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24115 
      return
24116 
    oprot.writeStructBegin('getSlippedSippingDateOrders_result')
24117 
    if self.success is not None:
24118 
      oprot.writeFieldBegin('success', TType.LIST, 0)
24119 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 24120 
      for iter537 in self.success:
24121 
        iter537.write(oprot)
4607 rajveer 24122 
      oprot.writeListEnd()
24123 
      oprot.writeFieldEnd()
24124 
    if self.ex is not None:
24125 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
24126 
      self.ex.write(oprot)
24127 
      oprot.writeFieldEnd()
24128 
    oprot.writeFieldStop()
24129 
    oprot.writeStructEnd()
24130 
 
24131 
  def validate(self):
24132 
    return
24133 
 
24134 
 
24135 
  def __repr__(self):
24136 
    L = ['%s=%r' % (key, value)
24137 
      for key, value in self.__dict__.iteritems()]
24138 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24139 
 
24140 
  def __eq__(self, other):
24141 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24142 
 
24143 
  def __ne__(self, other):
24144 
    return not (self == other)
24145 
 
4709 rajveer 24146 
class getCancelledOrders_args:
24147 
  """
24148 
  Attributes:
24149 
   - cancelDateFrom
24150 
   - cancelDateTo
24151 
  """
24152 
 
24153 
  thrift_spec = (
24154 
    None, # 0
24155 
    (1, TType.I64, 'cancelDateFrom', None, None, ), # 1
24156 
    (2, TType.I64, 'cancelDateTo', None, None, ), # 2
24157 
  )
24158 
 
24159 
  def __init__(self, cancelDateFrom=None, cancelDateTo=None,):
24160 
    self.cancelDateFrom = cancelDateFrom
24161 
    self.cancelDateTo = cancelDateTo
24162 
 
24163 
  def read(self, iprot):
24164 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24165 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24166 
      return
24167 
    iprot.readStructBegin()
24168 
    while True:
24169 
      (fname, ftype, fid) = iprot.readFieldBegin()
24170 
      if ftype == TType.STOP:
24171 
        break
24172 
      if fid == 1:
24173 
        if ftype == TType.I64:
24174 
          self.cancelDateFrom = iprot.readI64();
24175 
        else:
24176 
          iprot.skip(ftype)
24177 
      elif fid == 2:
24178 
        if ftype == TType.I64:
24179 
          self.cancelDateTo = iprot.readI64();
24180 
        else:
24181 
          iprot.skip(ftype)
24182 
      else:
24183 
        iprot.skip(ftype)
24184 
      iprot.readFieldEnd()
24185 
    iprot.readStructEnd()
24186 
 
24187 
  def write(self, oprot):
24188 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24189 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24190 
      return
24191 
    oprot.writeStructBegin('getCancelledOrders_args')
24192 
    if self.cancelDateFrom is not None:
24193 
      oprot.writeFieldBegin('cancelDateFrom', TType.I64, 1)
24194 
      oprot.writeI64(self.cancelDateFrom)
24195 
      oprot.writeFieldEnd()
24196 
    if self.cancelDateTo is not None:
24197 
      oprot.writeFieldBegin('cancelDateTo', TType.I64, 2)
24198 
      oprot.writeI64(self.cancelDateTo)
24199 
      oprot.writeFieldEnd()
24200 
    oprot.writeFieldStop()
24201 
    oprot.writeStructEnd()
24202 
 
24203 
  def validate(self):
24204 
    return
24205 
 
24206 
 
24207 
  def __repr__(self):
24208 
    L = ['%s=%r' % (key, value)
24209 
      for key, value in self.__dict__.iteritems()]
24210 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24211 
 
24212 
  def __eq__(self, other):
24213 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24214 
 
24215 
  def __ne__(self, other):
24216 
    return not (self == other)
24217 
 
24218 
class getCancelledOrders_result:
24219 
  """
24220 
  Attributes:
24221 
   - success
24222 
   - ex
24223 
  """
24224 
 
24225 
  thrift_spec = (
24226 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
24227 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
24228 
  )
24229 
 
24230 
  def __init__(self, success=None, ex=None,):
24231 
    self.success = success
24232 
    self.ex = ex
24233 
 
24234 
  def read(self, iprot):
24235 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24236 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24237 
      return
24238 
    iprot.readStructBegin()
24239 
    while True:
24240 
      (fname, ftype, fid) = iprot.readFieldBegin()
24241 
      if ftype == TType.STOP:
24242 
        break
24243 
      if fid == 0:
24244 
        if ftype == TType.LIST:
24245 
          self.success = []
6188 rajveer 24246 
          (_etype541, _size538) = iprot.readListBegin()
24247 
          for _i542 in xrange(_size538):
24248 
            _elem543 = Order()
24249 
            _elem543.read(iprot)
24250 
            self.success.append(_elem543)
4709 rajveer 24251 
          iprot.readListEnd()
24252 
        else:
24253 
          iprot.skip(ftype)
24254 
      elif fid == 1:
24255 
        if ftype == TType.STRUCT:
24256 
          self.ex = TransactionServiceException()
24257 
          self.ex.read(iprot)
24258 
        else:
24259 
          iprot.skip(ftype)
24260 
      else:
24261 
        iprot.skip(ftype)
24262 
      iprot.readFieldEnd()
24263 
    iprot.readStructEnd()
24264 
 
24265 
  def write(self, oprot):
24266 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24267 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24268 
      return
24269 
    oprot.writeStructBegin('getCancelledOrders_result')
24270 
    if self.success is not None:
24271 
      oprot.writeFieldBegin('success', TType.LIST, 0)
24272 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 24273 
      for iter544 in self.success:
24274 
        iter544.write(oprot)
4709 rajveer 24275 
      oprot.writeListEnd()
24276 
      oprot.writeFieldEnd()
24277 
    if self.ex is not None:
24278 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
24279 
      self.ex.write(oprot)
24280 
      oprot.writeFieldEnd()
24281 
    oprot.writeFieldStop()
24282 
    oprot.writeStructEnd()
24283 
 
24284 
  def validate(self):
24285 
    return
24286 
 
24287 
 
24288 
  def __repr__(self):
24289 
    L = ['%s=%r' % (key, value)
24290 
      for key, value in self.__dict__.iteritems()]
24291 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24292 
 
24293 
  def __eq__(self, other):
24294 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24295 
 
24296 
  def __ne__(self, other):
24297 
    return not (self == other)
24298 
 
4600 varun.gupt 24299 
class saveBluedartSettlements_args:
24300 
  """
24301 
  Attributes:
24302 
   - mapAWBAndAmount
24303 
  """
24304 
 
24305 
  thrift_spec = (
24306 
    None, # 0
24307 
    (1, TType.MAP, 'mapAWBAndAmount', (TType.I64,None,TType.DOUBLE,None), None, ), # 1
24308 
  )
24309 
 
24310 
  def __init__(self, mapAWBAndAmount=None,):
24311 
    self.mapAWBAndAmount = mapAWBAndAmount
24312 
 
24313 
  def read(self, iprot):
24314 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24315 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24316 
      return
24317 
    iprot.readStructBegin()
24318 
    while True:
24319 
      (fname, ftype, fid) = iprot.readFieldBegin()
24320 
      if ftype == TType.STOP:
24321 
        break
24322 
      if fid == 1:
24323 
        if ftype == TType.MAP:
24324 
          self.mapAWBAndAmount = {}
6188 rajveer 24325 
          (_ktype546, _vtype547, _size545 ) = iprot.readMapBegin()
24326 
          for _i549 in xrange(_size545):
24327 
            _key550 = iprot.readI64();
24328 
            _val551 = iprot.readDouble();
24329 
            self.mapAWBAndAmount[_key550] = _val551
4600 varun.gupt 24330 
          iprot.readMapEnd()
24331 
        else:
24332 
          iprot.skip(ftype)
24333 
      else:
24334 
        iprot.skip(ftype)
24335 
      iprot.readFieldEnd()
24336 
    iprot.readStructEnd()
24337 
 
24338 
  def write(self, oprot):
24339 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24340 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24341 
      return
24342 
    oprot.writeStructBegin('saveBluedartSettlements_args')
24343 
    if self.mapAWBAndAmount is not None:
24344 
      oprot.writeFieldBegin('mapAWBAndAmount', TType.MAP, 1)
24345 
      oprot.writeMapBegin(TType.I64, TType.DOUBLE, len(self.mapAWBAndAmount))
6188 rajveer 24346 
      for kiter552,viter553 in self.mapAWBAndAmount.items():
24347 
        oprot.writeI64(kiter552)
24348 
        oprot.writeDouble(viter553)
4600 varun.gupt 24349 
      oprot.writeMapEnd()
24350 
      oprot.writeFieldEnd()
24351 
    oprot.writeFieldStop()
24352 
    oprot.writeStructEnd()
24353 
 
24354 
  def validate(self):
24355 
    return
24356 
 
24357 
 
24358 
  def __repr__(self):
24359 
    L = ['%s=%r' % (key, value)
24360 
      for key, value in self.__dict__.iteritems()]
24361 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24362 
 
24363 
  def __eq__(self, other):
24364 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24365 
 
24366 
  def __ne__(self, other):
24367 
    return not (self == other)
24368 
 
24369 
class saveBluedartSettlements_result:
24370 
  """
24371 
  Attributes:
24372 
   - ex
24373 
  """
24374 
 
24375 
  thrift_spec = (
24376 
    None, # 0
24377 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
24378 
  )
24379 
 
24380 
  def __init__(self, ex=None,):
24381 
    self.ex = ex
24382 
 
24383 
  def read(self, iprot):
24384 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24385 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24386 
      return
24387 
    iprot.readStructBegin()
24388 
    while True:
24389 
      (fname, ftype, fid) = iprot.readFieldBegin()
24390 
      if ftype == TType.STOP:
24391 
        break
24392 
      if fid == 1:
24393 
        if ftype == TType.STRUCT:
24394 
          self.ex = TransactionServiceException()
24395 
          self.ex.read(iprot)
24396 
        else:
24397 
          iprot.skip(ftype)
24398 
      else:
24399 
        iprot.skip(ftype)
24400 
      iprot.readFieldEnd()
24401 
    iprot.readStructEnd()
24402 
 
24403 
  def write(self, oprot):
24404 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24405 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24406 
      return
24407 
    oprot.writeStructBegin('saveBluedartSettlements_result')
24408 
    if self.ex is not None:
24409 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
24410 
      self.ex.write(oprot)
24411 
      oprot.writeFieldEnd()
24412 
    oprot.writeFieldStop()
24413 
    oprot.writeStructEnd()
24414 
 
24415 
  def validate(self):
24416 
    return
24417 
 
24418 
 
24419 
  def __repr__(self):
24420 
    L = ['%s=%r' % (key, value)
24421 
      for key, value in self.__dict__.iteritems()]
24422 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24423 
 
24424 
  def __eq__(self, other):
24425 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24426 
 
24427 
  def __ne__(self, other):
24428 
    return not (self == other)
24429 
 
24430 
class savePaymentSettlements_args:
24431 
  """
24432 
  Attributes:
24433 
   - settlementDate
24434 
   - paymentGatewayId
4905 varun.gupt 24435 
   - referenceId
4600 varun.gupt 24436 
   - serviceTax
24437 
   - otherCharges
24438 
   - netCollection
24439 
  """
24440 
 
24441 
  thrift_spec = (
24442 
    None, # 0
24443 
    (1, TType.I64, 'settlementDate', None, None, ), # 1
24444 
    (2, TType.I64, 'paymentGatewayId', None, None, ), # 2
4905 varun.gupt 24445 
    (3, TType.I64, 'referenceId', None, None, ), # 3
4600 varun.gupt 24446 
    (4, TType.DOUBLE, 'serviceTax', None, None, ), # 4
24447 
    (5, TType.DOUBLE, 'otherCharges', None, None, ), # 5
24448 
    (6, TType.DOUBLE, 'netCollection', None, None, ), # 6
24449 
  )
24450 
 
4905 varun.gupt 24451 
  def __init__(self, settlementDate=None, paymentGatewayId=None, referenceId=None, serviceTax=None, otherCharges=None, netCollection=None,):
4600 varun.gupt 24452 
    self.settlementDate = settlementDate
24453 
    self.paymentGatewayId = paymentGatewayId
4905 varun.gupt 24454 
    self.referenceId = referenceId
4600 varun.gupt 24455 
    self.serviceTax = serviceTax
24456 
    self.otherCharges = otherCharges
24457 
    self.netCollection = netCollection
24458 
 
24459 
  def read(self, iprot):
24460 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24461 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24462 
      return
24463 
    iprot.readStructBegin()
24464 
    while True:
24465 
      (fname, ftype, fid) = iprot.readFieldBegin()
24466 
      if ftype == TType.STOP:
24467 
        break
24468 
      if fid == 1:
24469 
        if ftype == TType.I64:
24470 
          self.settlementDate = iprot.readI64();
24471 
        else:
24472 
          iprot.skip(ftype)
24473 
      elif fid == 2:
24474 
        if ftype == TType.I64:
24475 
          self.paymentGatewayId = iprot.readI64();
24476 
        else:
24477 
          iprot.skip(ftype)
24478 
      elif fid == 3:
24479 
        if ftype == TType.I64:
4905 varun.gupt 24480 
          self.referenceId = iprot.readI64();
4600 varun.gupt 24481 
        else:
24482 
          iprot.skip(ftype)
24483 
      elif fid == 4:
24484 
        if ftype == TType.DOUBLE:
24485 
          self.serviceTax = iprot.readDouble();
24486 
        else:
24487 
          iprot.skip(ftype)
24488 
      elif fid == 5:
24489 
        if ftype == TType.DOUBLE:
24490 
          self.otherCharges = iprot.readDouble();
24491 
        else:
24492 
          iprot.skip(ftype)
24493 
      elif fid == 6:
24494 
        if ftype == TType.DOUBLE:
24495 
          self.netCollection = iprot.readDouble();
24496 
        else:
24497 
          iprot.skip(ftype)
24498 
      else:
24499 
        iprot.skip(ftype)
24500 
      iprot.readFieldEnd()
24501 
    iprot.readStructEnd()
24502 
 
24503 
  def write(self, oprot):
24504 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24505 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24506 
      return
24507 
    oprot.writeStructBegin('savePaymentSettlements_args')
24508 
    if self.settlementDate is not None:
24509 
      oprot.writeFieldBegin('settlementDate', TType.I64, 1)
24510 
      oprot.writeI64(self.settlementDate)
24511 
      oprot.writeFieldEnd()
24512 
    if self.paymentGatewayId is not None:
24513 
      oprot.writeFieldBegin('paymentGatewayId', TType.I64, 2)
24514 
      oprot.writeI64(self.paymentGatewayId)
24515 
      oprot.writeFieldEnd()
4905 varun.gupt 24516 
    if self.referenceId is not None:
24517 
      oprot.writeFieldBegin('referenceId', TType.I64, 3)
24518 
      oprot.writeI64(self.referenceId)
4600 varun.gupt 24519 
      oprot.writeFieldEnd()
24520 
    if self.serviceTax is not None:
24521 
      oprot.writeFieldBegin('serviceTax', TType.DOUBLE, 4)
24522 
      oprot.writeDouble(self.serviceTax)
24523 
      oprot.writeFieldEnd()
24524 
    if self.otherCharges is not None:
24525 
      oprot.writeFieldBegin('otherCharges', TType.DOUBLE, 5)
24526 
      oprot.writeDouble(self.otherCharges)
24527 
      oprot.writeFieldEnd()
24528 
    if self.netCollection is not None:
24529 
      oprot.writeFieldBegin('netCollection', TType.DOUBLE, 6)
24530 
      oprot.writeDouble(self.netCollection)
24531 
      oprot.writeFieldEnd()
24532 
    oprot.writeFieldStop()
24533 
    oprot.writeStructEnd()
24534 
 
24535 
  def validate(self):
24536 
    return
24537 
 
24538 
 
24539 
  def __repr__(self):
24540 
    L = ['%s=%r' % (key, value)
24541 
      for key, value in self.__dict__.iteritems()]
24542 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24543 
 
24544 
  def __eq__(self, other):
24545 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24546 
 
24547 
  def __ne__(self, other):
24548 
    return not (self == other)
24549 
 
24550 
class savePaymentSettlements_result:
24551 
  """
24552 
  Attributes:
24553 
   - ex
24554 
  """
24555 
 
24556 
  thrift_spec = (
24557 
    None, # 0
24558 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
24559 
  )
24560 
 
24561 
  def __init__(self, ex=None,):
24562 
    self.ex = ex
24563 
 
24564 
  def read(self, iprot):
24565 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24566 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24567 
      return
24568 
    iprot.readStructBegin()
24569 
    while True:
24570 
      (fname, ftype, fid) = iprot.readFieldBegin()
24571 
      if ftype == TType.STOP:
24572 
        break
24573 
      if fid == 1:
24574 
        if ftype == TType.STRUCT:
24575 
          self.ex = TransactionServiceException()
24576 
          self.ex.read(iprot)
24577 
        else:
24578 
          iprot.skip(ftype)
24579 
      else:
24580 
        iprot.skip(ftype)
24581 
      iprot.readFieldEnd()
24582 
    iprot.readStructEnd()
24583 
 
24584 
  def write(self, oprot):
24585 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24586 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24587 
      return
24588 
    oprot.writeStructBegin('savePaymentSettlements_result')
24589 
    if self.ex is not None:
24590 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
24591 
      self.ex.write(oprot)
24592 
      oprot.writeFieldEnd()
24593 
    oprot.writeFieldStop()
24594 
    oprot.writeStructEnd()
24595 
 
24596 
  def validate(self):
24597 
    return
24598 
 
24599 
 
24600 
  def __repr__(self):
24601 
    L = ['%s=%r' % (key, value)
24602 
      for key, value in self.__dict__.iteritems()]
24603 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24604 
 
24605 
  def __eq__(self, other):
24606 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24607 
 
24608 
  def __ne__(self, other):
24609 
    return not (self == other)
24610 
 
24611 
class saveEBSSettlementSummary_args:
24612 
  """
24613 
  Attributes:
24614 
   - settlementId
24615 
   - settlementDate
24616 
   - transactionDateFrom
24617 
   - transactionDateTo
24618 
   - amount
24619 
  """
24620 
 
24621 
  thrift_spec = (
24622 
    None, # 0
24623 
    (1, TType.I64, 'settlementId', None, None, ), # 1
24624 
    (2, TType.I64, 'settlementDate', None, None, ), # 2
24625 
    (3, TType.I64, 'transactionDateFrom', None, None, ), # 3
24626 
    (4, TType.I64, 'transactionDateTo', None, None, ), # 4
24627 
    (5, TType.DOUBLE, 'amount', None, None, ), # 5
24628 
  )
24629 
 
24630 
  def __init__(self, settlementId=None, settlementDate=None, transactionDateFrom=None, transactionDateTo=None, amount=None,):
24631 
    self.settlementId = settlementId
24632 
    self.settlementDate = settlementDate
24633 
    self.transactionDateFrom = transactionDateFrom
24634 
    self.transactionDateTo = transactionDateTo
24635 
    self.amount = amount
24636 
 
24637 
  def read(self, iprot):
24638 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24639 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24640 
      return
24641 
    iprot.readStructBegin()
24642 
    while True:
24643 
      (fname, ftype, fid) = iprot.readFieldBegin()
24644 
      if ftype == TType.STOP:
24645 
        break
24646 
      if fid == 1:
24647 
        if ftype == TType.I64:
24648 
          self.settlementId = iprot.readI64();
24649 
        else:
24650 
          iprot.skip(ftype)
24651 
      elif fid == 2:
24652 
        if ftype == TType.I64:
24653 
          self.settlementDate = iprot.readI64();
24654 
        else:
24655 
          iprot.skip(ftype)
24656 
      elif fid == 3:
24657 
        if ftype == TType.I64:
24658 
          self.transactionDateFrom = iprot.readI64();
24659 
        else:
24660 
          iprot.skip(ftype)
24661 
      elif fid == 4:
24662 
        if ftype == TType.I64:
24663 
          self.transactionDateTo = iprot.readI64();
24664 
        else:
24665 
          iprot.skip(ftype)
24666 
      elif fid == 5:
24667 
        if ftype == TType.DOUBLE:
24668 
          self.amount = iprot.readDouble();
24669 
        else:
24670 
          iprot.skip(ftype)
24671 
      else:
24672 
        iprot.skip(ftype)
24673 
      iprot.readFieldEnd()
24674 
    iprot.readStructEnd()
24675 
 
24676 
  def write(self, oprot):
24677 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24678 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24679 
      return
24680 
    oprot.writeStructBegin('saveEBSSettlementSummary_args')
24681 
    if self.settlementId is not None:
24682 
      oprot.writeFieldBegin('settlementId', TType.I64, 1)
24683 
      oprot.writeI64(self.settlementId)
24684 
      oprot.writeFieldEnd()
24685 
    if self.settlementDate is not None:
24686 
      oprot.writeFieldBegin('settlementDate', TType.I64, 2)
24687 
      oprot.writeI64(self.settlementDate)
24688 
      oprot.writeFieldEnd()
24689 
    if self.transactionDateFrom is not None:
24690 
      oprot.writeFieldBegin('transactionDateFrom', TType.I64, 3)
24691 
      oprot.writeI64(self.transactionDateFrom)
24692 
      oprot.writeFieldEnd()
24693 
    if self.transactionDateTo is not None:
24694 
      oprot.writeFieldBegin('transactionDateTo', TType.I64, 4)
24695 
      oprot.writeI64(self.transactionDateTo)
24696 
      oprot.writeFieldEnd()
24697 
    if self.amount is not None:
24698 
      oprot.writeFieldBegin('amount', TType.DOUBLE, 5)
24699 
      oprot.writeDouble(self.amount)
24700 
      oprot.writeFieldEnd()
24701 
    oprot.writeFieldStop()
24702 
    oprot.writeStructEnd()
24703 
 
24704 
  def validate(self):
24705 
    return
24706 
 
24707 
 
24708 
  def __repr__(self):
24709 
    L = ['%s=%r' % (key, value)
24710 
      for key, value in self.__dict__.iteritems()]
24711 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24712 
 
24713 
  def __eq__(self, other):
24714 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24715 
 
24716 
  def __ne__(self, other):
24717 
    return not (self == other)
24718 
 
24719 
class saveEBSSettlementSummary_result:
24720 
  """
24721 
  Attributes:
24722 
   - ex
24723 
  """
24724 
 
24725 
  thrift_spec = (
24726 
    None, # 0
24727 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
24728 
  )
24729 
 
24730 
  def __init__(self, ex=None,):
24731 
    self.ex = ex
24732 
 
24733 
  def read(self, iprot):
24734 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24735 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24736 
      return
24737 
    iprot.readStructBegin()
24738 
    while True:
24739 
      (fname, ftype, fid) = iprot.readFieldBegin()
24740 
      if ftype == TType.STOP:
24741 
        break
24742 
      if fid == 1:
24743 
        if ftype == TType.STRUCT:
24744 
          self.ex = TransactionServiceException()
24745 
          self.ex.read(iprot)
24746 
        else:
24747 
          iprot.skip(ftype)
24748 
      else:
24749 
        iprot.skip(ftype)
24750 
      iprot.readFieldEnd()
24751 
    iprot.readStructEnd()
24752 
 
24753 
  def write(self, oprot):
24754 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24755 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24756 
      return
24757 
    oprot.writeStructBegin('saveEBSSettlementSummary_result')
24758 
    if self.ex is not None:
24759 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
24760 
      self.ex.write(oprot)
24761 
      oprot.writeFieldEnd()
24762 
    oprot.writeFieldStop()
24763 
    oprot.writeStructEnd()
24764 
 
24765 
  def validate(self):
24766 
    return
24767 
 
24768 
 
24769 
  def __repr__(self):
24770 
    L = ['%s=%r' % (key, value)
24771 
      for key, value in self.__dict__.iteritems()]
24772 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24773 
 
24774 
  def __eq__(self, other):
24775 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24776 
 
24777 
  def __ne__(self, other):
24778 
    return not (self == other)
24779 
 
5386 phani.kuma 24780 
class getSettlementForPrepaid_args:
4600 varun.gupt 24781 
  """
24782 
  Attributes:
5189 varun.gupt 24783 
   - referenceId
24784 
   - isRefund
4600 varun.gupt 24785 
  """
24786 
 
24787 
  thrift_spec = (
24788 
    None, # 0
5189 varun.gupt 24789 
    (1, TType.I64, 'referenceId', None, None, ), # 1
5386 phani.kuma 24790 
    (2, TType.BOOL, 'isRefund', None, None, ), # 2
4600 varun.gupt 24791 
  )
24792 
 
5386 phani.kuma 24793 
  def __init__(self, referenceId=None, isRefund=None,):
5189 varun.gupt 24794 
    self.referenceId = referenceId
24795 
    self.isRefund = isRefund
4600 varun.gupt 24796 
 
24797 
  def read(self, iprot):
24798 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24799 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24800 
      return
24801 
    iprot.readStructBegin()
24802 
    while True:
24803 
      (fname, ftype, fid) = iprot.readFieldBegin()
24804 
      if ftype == TType.STOP:
24805 
        break
24806 
      if fid == 1:
24807 
        if ftype == TType.I64:
5189 varun.gupt 24808 
          self.referenceId = iprot.readI64();
4600 varun.gupt 24809 
        else:
24810 
          iprot.skip(ftype)
5189 varun.gupt 24811 
      elif fid == 2:
24812 
        if ftype == TType.BOOL:
24813 
          self.isRefund = iprot.readBool();
24814 
        else:
24815 
          iprot.skip(ftype)
4600 varun.gupt 24816 
      else:
24817 
        iprot.skip(ftype)
24818 
      iprot.readFieldEnd()
24819 
    iprot.readStructEnd()
24820 
 
24821 
  def write(self, oprot):
24822 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24823 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24824 
      return
5386 phani.kuma 24825 
    oprot.writeStructBegin('getSettlementForPrepaid_args')
5189 varun.gupt 24826 
    if self.referenceId is not None:
24827 
      oprot.writeFieldBegin('referenceId', TType.I64, 1)
24828 
      oprot.writeI64(self.referenceId)
4600 varun.gupt 24829 
      oprot.writeFieldEnd()
5386 phani.kuma 24830 
    if self.isRefund is not None:
24831 
      oprot.writeFieldBegin('isRefund', TType.BOOL, 2)
24832 
      oprot.writeBool(self.isRefund)
5382 varun.gupt 24833 
      oprot.writeFieldEnd()
5386 phani.kuma 24834 
    oprot.writeFieldStop()
24835 
    oprot.writeStructEnd()
24836 
 
24837 
  def validate(self):
24838 
    return
24839 
 
24840 
 
24841 
  def __repr__(self):
24842 
    L = ['%s=%r' % (key, value)
24843 
      for key, value in self.__dict__.iteritems()]
24844 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24845 
 
24846 
  def __eq__(self, other):
24847 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24848 
 
24849 
  def __ne__(self, other):
24850 
    return not (self == other)
24851 
 
24852 
class getSettlementForPrepaid_result:
24853 
  """
24854 
  Attributes:
24855 
   - success
24856 
   - ex
24857 
  """
24858 
 
24859 
  thrift_spec = (
24860 
    (0, TType.STRUCT, 'success', (PaymentSettlement, PaymentSettlement.thrift_spec), None, ), # 0
24861 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
24862 
  )
24863 
 
24864 
  def __init__(self, success=None, ex=None,):
24865 
    self.success = success
24866 
    self.ex = ex
24867 
 
24868 
  def read(self, iprot):
24869 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24870 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24871 
      return
24872 
    iprot.readStructBegin()
24873 
    while True:
24874 
      (fname, ftype, fid) = iprot.readFieldBegin()
24875 
      if ftype == TType.STOP:
24876 
        break
24877 
      if fid == 0:
24878 
        if ftype == TType.STRUCT:
24879 
          self.success = PaymentSettlement()
24880 
          self.success.read(iprot)
24881 
        else:
24882 
          iprot.skip(ftype)
24883 
      elif fid == 1:
24884 
        if ftype == TType.STRUCT:
24885 
          self.ex = TransactionServiceException()
24886 
          self.ex.read(iprot)
24887 
        else:
24888 
          iprot.skip(ftype)
24889 
      else:
24890 
        iprot.skip(ftype)
24891 
      iprot.readFieldEnd()
24892 
    iprot.readStructEnd()
24893 
 
24894 
  def write(self, oprot):
24895 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24896 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24897 
      return
24898 
    oprot.writeStructBegin('getSettlementForPrepaid_result')
24899 
    if self.success is not None:
24900 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
24901 
      self.success.write(oprot)
24902 
      oprot.writeFieldEnd()
24903 
    if self.ex is not None:
24904 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
24905 
      self.ex.write(oprot)
24906 
      oprot.writeFieldEnd()
24907 
    oprot.writeFieldStop()
24908 
    oprot.writeStructEnd()
24909 
 
24910 
  def validate(self):
24911 
    return
24912 
 
24913 
 
24914 
  def __repr__(self):
24915 
    L = ['%s=%r' % (key, value)
24916 
      for key, value in self.__dict__.iteritems()]
24917 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24918 
 
24919 
  def __eq__(self, other):
24920 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24921 
 
24922 
  def __ne__(self, other):
24923 
    return not (self == other)
24924 
 
24925 
class getSettlementForCod_args:
24926 
  """
24927 
  Attributes:
24928 
   - orderId
24929 
   - isRefund
24930 
  """
24931 
 
24932 
  thrift_spec = (
24933 
    None, # 0
24934 
    (1, TType.I64, 'orderId', None, None, ), # 1
24935 
    (2, TType.BOOL, 'isRefund', None, None, ), # 2
24936 
  )
24937 
 
24938 
  def __init__(self, orderId=None, isRefund=None,):
24939 
    self.orderId = orderId
24940 
    self.isRefund = isRefund
24941 
 
24942 
  def read(self, iprot):
24943 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24944 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24945 
      return
24946 
    iprot.readStructBegin()
24947 
    while True:
24948 
      (fname, ftype, fid) = iprot.readFieldBegin()
24949 
      if ftype == TType.STOP:
24950 
        break
24951 
      if fid == 1:
24952 
        if ftype == TType.I64:
24953 
          self.orderId = iprot.readI64();
24954 
        else:
24955 
          iprot.skip(ftype)
24956 
      elif fid == 2:
24957 
        if ftype == TType.BOOL:
24958 
          self.isRefund = iprot.readBool();
24959 
        else:
24960 
          iprot.skip(ftype)
24961 
      else:
24962 
        iprot.skip(ftype)
24963 
      iprot.readFieldEnd()
24964 
    iprot.readStructEnd()
24965 
 
24966 
  def write(self, oprot):
24967 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24968 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24969 
      return
24970 
    oprot.writeStructBegin('getSettlementForCod_args')
24971 
    if self.orderId is not None:
24972 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
24973 
      oprot.writeI64(self.orderId)
24974 
      oprot.writeFieldEnd()
5189 varun.gupt 24975 
    if self.isRefund is not None:
5386 phani.kuma 24976 
      oprot.writeFieldBegin('isRefund', TType.BOOL, 2)
5189 varun.gupt 24977 
      oprot.writeBool(self.isRefund)
24978 
      oprot.writeFieldEnd()
4600 varun.gupt 24979 
    oprot.writeFieldStop()
24980 
    oprot.writeStructEnd()
24981 
 
24982 
  def validate(self):
24983 
    return
24984 
 
24985 
 
24986 
  def __repr__(self):
24987 
    L = ['%s=%r' % (key, value)
24988 
      for key, value in self.__dict__.iteritems()]
24989 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24990 
 
24991 
  def __eq__(self, other):
24992 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24993 
 
24994 
  def __ne__(self, other):
24995 
    return not (self == other)
24996 
 
5386 phani.kuma 24997 
class getSettlementForCod_result:
4600 varun.gupt 24998 
  """
24999 
  Attributes:
25000 
   - success
25001 
   - ex
25002 
  """
25003 
 
25004 
  thrift_spec = (
25005 
    (0, TType.STRUCT, 'success', (PaymentSettlement, PaymentSettlement.thrift_spec), None, ), # 0
25006 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
25007 
  )
25008 
 
25009 
  def __init__(self, success=None, ex=None,):
25010 
    self.success = success
25011 
    self.ex = ex
25012 
 
25013 
  def read(self, iprot):
25014 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25015 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25016 
      return
25017 
    iprot.readStructBegin()
25018 
    while True:
25019 
      (fname, ftype, fid) = iprot.readFieldBegin()
25020 
      if ftype == TType.STOP:
25021 
        break
25022 
      if fid == 0:
25023 
        if ftype == TType.STRUCT:
25024 
          self.success = PaymentSettlement()
25025 
          self.success.read(iprot)
25026 
        else:
25027 
          iprot.skip(ftype)
25028 
      elif fid == 1:
25029 
        if ftype == TType.STRUCT:
25030 
          self.ex = TransactionServiceException()
25031 
          self.ex.read(iprot)
25032 
        else:
25033 
          iprot.skip(ftype)
25034 
      else:
25035 
        iprot.skip(ftype)
25036 
      iprot.readFieldEnd()
25037 
    iprot.readStructEnd()
25038 
 
25039 
  def write(self, oprot):
25040 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25041 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25042 
      return
5386 phani.kuma 25043 
    oprot.writeStructBegin('getSettlementForCod_result')
4600 varun.gupt 25044 
    if self.success is not None:
25045 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
25046 
      self.success.write(oprot)
25047 
      oprot.writeFieldEnd()
25048 
    if self.ex is not None:
25049 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
25050 
      self.ex.write(oprot)
25051 
      oprot.writeFieldEnd()
25052 
    oprot.writeFieldStop()
25053 
    oprot.writeStructEnd()
25054 
 
25055 
  def validate(self):
25056 
    return
25057 
 
25058 
 
25059 
  def __repr__(self):
25060 
    L = ['%s=%r' % (key, value)
25061 
      for key, value in self.__dict__.iteritems()]
25062 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25063 
 
25064 
  def __eq__(self, other):
25065 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25066 
 
25067 
  def __ne__(self, other):
25068 
    return not (self == other)
25069 
 
25070 
class getEBSSettlementSummaries_args:
25071 
 
25072 
  thrift_spec = (
25073 
  )
25074 
 
25075 
  def read(self, iprot):
25076 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25077 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25078 
      return
25079 
    iprot.readStructBegin()
25080 
    while True:
25081 
      (fname, ftype, fid) = iprot.readFieldBegin()
25082 
      if ftype == TType.STOP:
25083 
        break
25084 
      else:
25085 
        iprot.skip(ftype)
25086 
      iprot.readFieldEnd()
25087 
    iprot.readStructEnd()
25088 
 
25089 
  def write(self, oprot):
25090 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25091 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25092 
      return
25093 
    oprot.writeStructBegin('getEBSSettlementSummaries_args')
25094 
    oprot.writeFieldStop()
25095 
    oprot.writeStructEnd()
25096 
 
25097 
  def validate(self):
25098 
    return
25099 
 
25100 
 
25101 
  def __repr__(self):
25102 
    L = ['%s=%r' % (key, value)
25103 
      for key, value in self.__dict__.iteritems()]
25104 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25105 
 
25106 
  def __eq__(self, other):
25107 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25108 
 
25109 
  def __ne__(self, other):
25110 
    return not (self == other)
25111 
 
25112 
class getEBSSettlementSummaries_result:
25113 
  """
25114 
  Attributes:
25115 
   - success
25116 
   - ex
25117 
  """
25118 
 
25119 
  thrift_spec = (
25120 
    (0, TType.MAP, 'success', (TType.I64,None,TType.STRING,None), None, ), # 0
25121 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
25122 
  )
25123 
 
25124 
  def __init__(self, success=None, ex=None,):
25125 
    self.success = success
25126 
    self.ex = ex
25127 
 
25128 
  def read(self, iprot):
25129 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25130 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25131 
      return
25132 
    iprot.readStructBegin()
25133 
    while True:
25134 
      (fname, ftype, fid) = iprot.readFieldBegin()
25135 
      if ftype == TType.STOP:
25136 
        break
25137 
      if fid == 0:
25138 
        if ftype == TType.MAP:
25139 
          self.success = {}
6188 rajveer 25140 
          (_ktype555, _vtype556, _size554 ) = iprot.readMapBegin()
25141 
          for _i558 in xrange(_size554):
25142 
            _key559 = iprot.readI64();
25143 
            _val560 = iprot.readString();
25144 
            self.success[_key559] = _val560
4600 varun.gupt 25145 
          iprot.readMapEnd()
25146 
        else:
25147 
          iprot.skip(ftype)
25148 
      elif fid == 1:
25149 
        if ftype == TType.STRUCT:
25150 
          self.ex = TransactionServiceException()
25151 
          self.ex.read(iprot)
25152 
        else:
25153 
          iprot.skip(ftype)
25154 
      else:
25155 
        iprot.skip(ftype)
25156 
      iprot.readFieldEnd()
25157 
    iprot.readStructEnd()
25158 
 
25159 
  def write(self, oprot):
25160 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25161 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25162 
      return
25163 
    oprot.writeStructBegin('getEBSSettlementSummaries_result')
25164 
    if self.success is not None:
25165 
      oprot.writeFieldBegin('success', TType.MAP, 0)
25166 
      oprot.writeMapBegin(TType.I64, TType.STRING, len(self.success))
6188 rajveer 25167 
      for kiter561,viter562 in self.success.items():
25168 
        oprot.writeI64(kiter561)
25169 
        oprot.writeString(viter562)
4600 varun.gupt 25170 
      oprot.writeMapEnd()
25171 
      oprot.writeFieldEnd()
25172 
    if self.ex is not None:
25173 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
25174 
      self.ex.write(oprot)
25175 
      oprot.writeFieldEnd()
25176 
    oprot.writeFieldStop()
25177 
    oprot.writeStructEnd()
25178 
 
25179 
  def validate(self):
25180 
    return
25181 
 
25182 
 
25183 
  def __repr__(self):
25184 
    L = ['%s=%r' % (key, value)
25185 
      for key, value in self.__dict__.iteritems()]
25186 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25187 
 
25188 
  def __eq__(self, other):
25189 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25190 
 
25191 
  def __ne__(self, other):
25192 
    return not (self == other)
25193 
 
25194 
class markEBSSettlementUploaded_args:
25195 
  """
25196 
  Attributes:
25197 
   - settlementId
25198 
  """
25199 
 
25200 
  thrift_spec = (
25201 
    None, # 0
25202 
    (1, TType.I64, 'settlementId', None, None, ), # 1
25203 
  )
25204 
 
25205 
  def __init__(self, settlementId=None,):
25206 
    self.settlementId = settlementId
25207 
 
25208 
  def read(self, iprot):
25209 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25210 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25211 
      return
25212 
    iprot.readStructBegin()
25213 
    while True:
25214 
      (fname, ftype, fid) = iprot.readFieldBegin()
25215 
      if ftype == TType.STOP:
25216 
        break
25217 
      if fid == 1:
25218 
        if ftype == TType.I64:
25219 
          self.settlementId = iprot.readI64();
25220 
        else:
25221 
          iprot.skip(ftype)
25222 
      else:
25223 
        iprot.skip(ftype)
25224 
      iprot.readFieldEnd()
25225 
    iprot.readStructEnd()
25226 
 
25227 
  def write(self, oprot):
25228 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25229 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25230 
      return
25231 
    oprot.writeStructBegin('markEBSSettlementUploaded_args')
25232 
    if self.settlementId is not None:
25233 
      oprot.writeFieldBegin('settlementId', TType.I64, 1)
25234 
      oprot.writeI64(self.settlementId)
25235 
      oprot.writeFieldEnd()
25236 
    oprot.writeFieldStop()
25237 
    oprot.writeStructEnd()
25238 
 
25239 
  def validate(self):
25240 
    return
25241 
 
25242 
 
25243 
  def __repr__(self):
25244 
    L = ['%s=%r' % (key, value)
25245 
      for key, value in self.__dict__.iteritems()]
25246 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25247 
 
25248 
  def __eq__(self, other):
25249 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25250 
 
25251 
  def __ne__(self, other):
25252 
    return not (self == other)
25253 
 
25254 
class markEBSSettlementUploaded_result:
25255 
  """
25256 
  Attributes:
25257 
   - ex
25258 
  """
25259 
 
25260 
  thrift_spec = (
25261 
    None, # 0
25262 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
25263 
  )
25264 
 
25265 
  def __init__(self, ex=None,):
25266 
    self.ex = ex
25267 
 
25268 
  def read(self, iprot):
25269 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25270 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25271 
      return
25272 
    iprot.readStructBegin()
25273 
    while True:
25274 
      (fname, ftype, fid) = iprot.readFieldBegin()
25275 
      if ftype == TType.STOP:
25276 
        break
25277 
      if fid == 1:
25278 
        if ftype == TType.STRUCT:
25279 
          self.ex = TransactionServiceException()
25280 
          self.ex.read(iprot)
25281 
        else:
25282 
          iprot.skip(ftype)
25283 
      else:
25284 
        iprot.skip(ftype)
25285 
      iprot.readFieldEnd()
25286 
    iprot.readStructEnd()
25287 
 
25288 
  def write(self, oprot):
25289 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25290 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25291 
      return
25292 
    oprot.writeStructBegin('markEBSSettlementUploaded_result')
25293 
    if self.ex is not None:
25294 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
25295 
      self.ex.write(oprot)
25296 
      oprot.writeFieldEnd()
25297 
    oprot.writeFieldStop()
25298 
    oprot.writeStructEnd()
25299 
 
25300 
  def validate(self):
25301 
    return
25302 
 
25303 
 
25304 
  def __repr__(self):
25305 
    L = ['%s=%r' % (key, value)
25306 
      for key, value in self.__dict__.iteritems()]
25307 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25308 
 
25309 
  def __eq__(self, other):
25310 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25311 
 
25312 
  def __ne__(self, other):
25313 
    return not (self == other)
25314 
 
25315 
class getEBSSettlementDate_args:
25316 
  """
25317 
  Attributes:
25318 
   - settlementId
25319 
  """
25320 
 
25321 
  thrift_spec = (
25322 
    None, # 0
25323 
    (1, TType.I64, 'settlementId', None, None, ), # 1
25324 
  )
25325 
 
25326 
  def __init__(self, settlementId=None,):
25327 
    self.settlementId = settlementId
25328 
 
25329 
  def read(self, iprot):
25330 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25331 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25332 
      return
25333 
    iprot.readStructBegin()
25334 
    while True:
25335 
      (fname, ftype, fid) = iprot.readFieldBegin()
25336 
      if ftype == TType.STOP:
25337 
        break
25338 
      if fid == 1:
25339 
        if ftype == TType.I64:
25340 
          self.settlementId = iprot.readI64();
25341 
        else:
25342 
          iprot.skip(ftype)
25343 
      else:
25344 
        iprot.skip(ftype)
25345 
      iprot.readFieldEnd()
25346 
    iprot.readStructEnd()
25347 
 
25348 
  def write(self, oprot):
25349 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25350 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25351 
      return
25352 
    oprot.writeStructBegin('getEBSSettlementDate_args')
25353 
    if self.settlementId is not None:
25354 
      oprot.writeFieldBegin('settlementId', TType.I64, 1)
25355 
      oprot.writeI64(self.settlementId)
25356 
      oprot.writeFieldEnd()
25357 
    oprot.writeFieldStop()
25358 
    oprot.writeStructEnd()
25359 
 
25360 
  def validate(self):
25361 
    return
25362 
 
25363 
 
25364 
  def __repr__(self):
25365 
    L = ['%s=%r' % (key, value)
25366 
      for key, value in self.__dict__.iteritems()]
25367 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25368 
 
25369 
  def __eq__(self, other):
25370 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25371 
 
25372 
  def __ne__(self, other):
25373 
    return not (self == other)
25374 
 
25375 
class getEBSSettlementDate_result:
25376 
  """
25377 
  Attributes:
25378 
   - success
25379 
   - ex
25380 
  """
25381 
 
25382 
  thrift_spec = (
25383 
    (0, TType.I64, 'success', None, None, ), # 0
25384 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
25385 
  )
25386 
 
25387 
  def __init__(self, success=None, ex=None,):
25388 
    self.success = success
25389 
    self.ex = ex
25390 
 
25391 
  def read(self, iprot):
25392 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25393 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25394 
      return
25395 
    iprot.readStructBegin()
25396 
    while True:
25397 
      (fname, ftype, fid) = iprot.readFieldBegin()
25398 
      if ftype == TType.STOP:
25399 
        break
25400 
      if fid == 0:
25401 
        if ftype == TType.I64:
25402 
          self.success = iprot.readI64();
25403 
        else:
25404 
          iprot.skip(ftype)
25405 
      elif fid == 1:
25406 
        if ftype == TType.STRUCT:
25407 
          self.ex = TransactionServiceException()
25408 
          self.ex.read(iprot)
25409 
        else:
25410 
          iprot.skip(ftype)
25411 
      else:
25412 
        iprot.skip(ftype)
25413 
      iprot.readFieldEnd()
25414 
    iprot.readStructEnd()
25415 
 
25416 
  def write(self, oprot):
25417 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25418 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25419 
      return
25420 
    oprot.writeStructBegin('getEBSSettlementDate_result')
25421 
    if self.success is not None:
25422 
      oprot.writeFieldBegin('success', TType.I64, 0)
25423 
      oprot.writeI64(self.success)
25424 
      oprot.writeFieldEnd()
25425 
    if self.ex is not None:
25426 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
25427 
      self.ex.write(oprot)
25428 
      oprot.writeFieldEnd()
25429 
    oprot.writeFieldStop()
25430 
    oprot.writeStructEnd()
25431 
 
25432 
  def validate(self):
25433 
    return
25434 
 
25435 
 
25436 
  def __repr__(self):
25437 
    L = ['%s=%r' % (key, value)
25438 
      for key, value in self.__dict__.iteritems()]
25439 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25440 
 
25441 
  def __eq__(self, other):
25442 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25443 
 
25444 
  def __ne__(self, other):
25445 
    return not (self == other)
4715 varun.gupt 25446 
 
25447 
class getSettlementsByDate_args:
25448 
  """
25449 
  Attributes:
25450 
   - settlementDateFrom
25451 
   - settlementDateTo
25452 
   - isRefund
25453 
  """
25454 
 
25455 
  thrift_spec = (
25456 
    None, # 0
25457 
    (1, TType.I64, 'settlementDateFrom', None, None, ), # 1
25458 
    (2, TType.I64, 'settlementDateTo', None, None, ), # 2
25459 
    (3, TType.BOOL, 'isRefund', None, None, ), # 3
25460 
  )
25461 
 
25462 
  def __init__(self, settlementDateFrom=None, settlementDateTo=None, isRefund=None,):
25463 
    self.settlementDateFrom = settlementDateFrom
25464 
    self.settlementDateTo = settlementDateTo
25465 
    self.isRefund = isRefund
25466 
 
25467 
  def read(self, iprot):
25468 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25469 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25470 
      return
25471 
    iprot.readStructBegin()
25472 
    while True:
25473 
      (fname, ftype, fid) = iprot.readFieldBegin()
25474 
      if ftype == TType.STOP:
25475 
        break
25476 
      if fid == 1:
25477 
        if ftype == TType.I64:
25478 
          self.settlementDateFrom = iprot.readI64();
25479 
        else:
25480 
          iprot.skip(ftype)
25481 
      elif fid == 2:
25482 
        if ftype == TType.I64:
25483 
          self.settlementDateTo = iprot.readI64();
25484 
        else:
25485 
          iprot.skip(ftype)
25486 
      elif fid == 3:
25487 
        if ftype == TType.BOOL:
25488 
          self.isRefund = iprot.readBool();
25489 
        else:
25490 
          iprot.skip(ftype)
25491 
      else:
25492 
        iprot.skip(ftype)
25493 
      iprot.readFieldEnd()
25494 
    iprot.readStructEnd()
25495 
 
25496 
  def write(self, oprot):
25497 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25498 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25499 
      return
25500 
    oprot.writeStructBegin('getSettlementsByDate_args')
25501 
    if self.settlementDateFrom is not None:
25502 
      oprot.writeFieldBegin('settlementDateFrom', TType.I64, 1)
25503 
      oprot.writeI64(self.settlementDateFrom)
25504 
      oprot.writeFieldEnd()
25505 
    if self.settlementDateTo is not None:
25506 
      oprot.writeFieldBegin('settlementDateTo', TType.I64, 2)
25507 
      oprot.writeI64(self.settlementDateTo)
25508 
      oprot.writeFieldEnd()
25509 
    if self.isRefund is not None:
25510 
      oprot.writeFieldBegin('isRefund', TType.BOOL, 3)
25511 
      oprot.writeBool(self.isRefund)
25512 
      oprot.writeFieldEnd()
25513 
    oprot.writeFieldStop()
25514 
    oprot.writeStructEnd()
25515 
 
25516 
  def validate(self):
25517 
    return
25518 
 
25519 
 
25520 
  def __repr__(self):
25521 
    L = ['%s=%r' % (key, value)
25522 
      for key, value in self.__dict__.iteritems()]
25523 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25524 
 
25525 
  def __eq__(self, other):
25526 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25527 
 
25528 
  def __ne__(self, other):
25529 
    return not (self == other)
25530 
 
25531 
class getSettlementsByDate_result:
25532 
  """
25533 
  Attributes:
25534 
   - success
25535 
   - ex
25536 
  """
25537 
 
25538 
  thrift_spec = (
25539 
    (0, TType.LIST, 'success', (TType.STRUCT,(PaymentSettlement, PaymentSettlement.thrift_spec)), None, ), # 0
25540 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
25541 
  )
25542 
 
25543 
  def __init__(self, success=None, ex=None,):
25544 
    self.success = success
25545 
    self.ex = ex
25546 
 
25547 
  def read(self, iprot):
25548 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25549 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25550 
      return
25551 
    iprot.readStructBegin()
25552 
    while True:
25553 
      (fname, ftype, fid) = iprot.readFieldBegin()
25554 
      if ftype == TType.STOP:
25555 
        break
25556 
      if fid == 0:
25557 
        if ftype == TType.LIST:
25558 
          self.success = []
6188 rajveer 25559 
          (_etype566, _size563) = iprot.readListBegin()
25560 
          for _i567 in xrange(_size563):
25561 
            _elem568 = PaymentSettlement()
25562 
            _elem568.read(iprot)
25563 
            self.success.append(_elem568)
4715 varun.gupt 25564 
          iprot.readListEnd()
25565 
        else:
25566 
          iprot.skip(ftype)
25567 
      elif fid == 1:
25568 
        if ftype == TType.STRUCT:
25569 
          self.ex = TransactionServiceException()
25570 
          self.ex.read(iprot)
25571 
        else:
25572 
          iprot.skip(ftype)
25573 
      else:
25574 
        iprot.skip(ftype)
25575 
      iprot.readFieldEnd()
25576 
    iprot.readStructEnd()
25577 
 
25578 
  def write(self, oprot):
25579 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25580 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25581 
      return
25582 
    oprot.writeStructBegin('getSettlementsByDate_result')
25583 
    if self.success is not None:
25584 
      oprot.writeFieldBegin('success', TType.LIST, 0)
25585 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 25586 
      for iter569 in self.success:
25587 
        iter569.write(oprot)
4715 varun.gupt 25588 
      oprot.writeListEnd()
25589 
      oprot.writeFieldEnd()
25590 
    if self.ex is not None:
25591 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
25592 
      self.ex.write(oprot)
25593 
      oprot.writeFieldEnd()
25594 
    oprot.writeFieldStop()
25595 
    oprot.writeStructEnd()
25596 
 
25597 
  def validate(self):
25598 
    return
25599 
 
25600 
 
25601 
  def __repr__(self):
25602 
    L = ['%s=%r' % (key, value)
25603 
      for key, value in self.__dict__.iteritems()]
25604 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25605 
 
25606 
  def __eq__(self, other):
25607 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25608 
 
25609 
  def __ne__(self, other):
25610 
    return not (self == other)
25611 
 
25612 
class getReshippedOrderIds_args:
25613 
  """
25614 
  Attributes:
25615 
   - orderIds
25616 
  """
25617 
 
25618 
  thrift_spec = (
25619 
    None, # 0
25620 
    (1, TType.LIST, 'orderIds', (TType.I64,None), None, ), # 1
25621 
  )
25622 
 
25623 
  def __init__(self, orderIds=None,):
25624 
    self.orderIds = orderIds
25625 
 
25626 
  def read(self, iprot):
25627 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25628 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25629 
      return
25630 
    iprot.readStructBegin()
25631 
    while True:
25632 
      (fname, ftype, fid) = iprot.readFieldBegin()
25633 
      if ftype == TType.STOP:
25634 
        break
25635 
      if fid == 1:
25636 
        if ftype == TType.LIST:
25637 
          self.orderIds = []
6188 rajveer 25638 
          (_etype573, _size570) = iprot.readListBegin()
25639 
          for _i574 in xrange(_size570):
25640 
            _elem575 = iprot.readI64();
25641 
            self.orderIds.append(_elem575)
4715 varun.gupt 25642 
          iprot.readListEnd()
25643 
        else:
25644 
          iprot.skip(ftype)
25645 
      else:
25646 
        iprot.skip(ftype)
25647 
      iprot.readFieldEnd()
25648 
    iprot.readStructEnd()
25649 
 
25650 
  def write(self, oprot):
25651 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25652 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25653 
      return
25654 
    oprot.writeStructBegin('getReshippedOrderIds_args')
25655 
    if self.orderIds is not None:
25656 
      oprot.writeFieldBegin('orderIds', TType.LIST, 1)
25657 
      oprot.writeListBegin(TType.I64, len(self.orderIds))
6188 rajveer 25658 
      for iter576 in self.orderIds:
25659 
        oprot.writeI64(iter576)
4715 varun.gupt 25660 
      oprot.writeListEnd()
25661 
      oprot.writeFieldEnd()
25662 
    oprot.writeFieldStop()
25663 
    oprot.writeStructEnd()
25664 
 
25665 
  def validate(self):
25666 
    return
25667 
 
25668 
 
25669 
  def __repr__(self):
25670 
    L = ['%s=%r' % (key, value)
25671 
      for key, value in self.__dict__.iteritems()]
25672 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25673 
 
25674 
  def __eq__(self, other):
25675 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25676 
 
25677 
  def __ne__(self, other):
25678 
    return not (self == other)
25679 
 
25680 
class getReshippedOrderIds_result:
25681 
  """
25682 
  Attributes:
25683 
   - success
25684 
   - ex
25685 
  """
25686 
 
25687 
  thrift_spec = (
25688 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
25689 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
25690 
  )
25691 
 
25692 
  def __init__(self, success=None, ex=None,):
25693 
    self.success = success
25694 
    self.ex = ex
25695 
 
25696 
  def read(self, iprot):
25697 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25698 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25699 
      return
25700 
    iprot.readStructBegin()
25701 
    while True:
25702 
      (fname, ftype, fid) = iprot.readFieldBegin()
25703 
      if ftype == TType.STOP:
25704 
        break
25705 
      if fid == 0:
25706 
        if ftype == TType.LIST:
25707 
          self.success = []
6188 rajveer 25708 
          (_etype580, _size577) = iprot.readListBegin()
25709 
          for _i581 in xrange(_size577):
25710 
            _elem582 = iprot.readI64();
25711 
            self.success.append(_elem582)
4715 varun.gupt 25712 
          iprot.readListEnd()
25713 
        else:
25714 
          iprot.skip(ftype)
25715 
      elif fid == 1:
25716 
        if ftype == TType.STRUCT:
25717 
          self.ex = TransactionServiceException()
25718 
          self.ex.read(iprot)
25719 
        else:
25720 
          iprot.skip(ftype)
25721 
      else:
25722 
        iprot.skip(ftype)
25723 
      iprot.readFieldEnd()
25724 
    iprot.readStructEnd()
25725 
 
25726 
  def write(self, oprot):
25727 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25728 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25729 
      return
25730 
    oprot.writeStructBegin('getReshippedOrderIds_result')
25731 
    if self.success is not None:
25732 
      oprot.writeFieldBegin('success', TType.LIST, 0)
25733 
      oprot.writeListBegin(TType.I64, len(self.success))
6188 rajveer 25734 
      for iter583 in self.success:
25735 
        oprot.writeI64(iter583)
4715 varun.gupt 25736 
      oprot.writeListEnd()
25737 
      oprot.writeFieldEnd()
25738 
    if self.ex is not None:
25739 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
25740 
      self.ex.write(oprot)
25741 
      oprot.writeFieldEnd()
25742 
    oprot.writeFieldStop()
25743 
    oprot.writeStructEnd()
25744 
 
25745 
  def validate(self):
25746 
    return
25747 
 
25748 
 
25749 
  def __repr__(self):
25750 
    L = ['%s=%r' % (key, value)
25751 
      for key, value in self.__dict__.iteritems()]
25752 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25753 
 
25754 
  def __eq__(self, other):
25755 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25756 
 
25757 
  def __ne__(self, other):
25758 
    return not (self == other)
4757 mandeep.dh 25759 
 
5481 phani.kuma 25760 
class getBilledOrders_args:
4875 varun.gupt 25761 
  """
25762 
  Attributes:
25763 
   - vendorId
5481 phani.kuma 25764 
   - onlyVendorNotPaid
25765 
   - billingDateFrom
25766 
   - billingDateTo
4875 varun.gupt 25767 
  """
25768 
 
25769 
  thrift_spec = (
25770 
    None, # 0
25771 
    (1, TType.I64, 'vendorId', None, None, ), # 1
5481 phani.kuma 25772 
    (2, TType.BOOL, 'onlyVendorNotPaid', None, None, ), # 2
25773 
    (3, TType.I64, 'billingDateFrom', None, None, ), # 3
25774 
    (4, TType.I64, 'billingDateTo', None, None, ), # 4
4875 varun.gupt 25775 
  )
25776 
 
5481 phani.kuma 25777 
  def __init__(self, vendorId=None, onlyVendorNotPaid=None, billingDateFrom=None, billingDateTo=None,):
4875 varun.gupt 25778 
    self.vendorId = vendorId
5481 phani.kuma 25779 
    self.onlyVendorNotPaid = onlyVendorNotPaid
25780 
    self.billingDateFrom = billingDateFrom
25781 
    self.billingDateTo = billingDateTo
4875 varun.gupt 25782 
 
25783 
  def read(self, iprot):
25784 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25785 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25786 
      return
25787 
    iprot.readStructBegin()
25788 
    while True:
25789 
      (fname, ftype, fid) = iprot.readFieldBegin()
25790 
      if ftype == TType.STOP:
25791 
        break
25792 
      if fid == 1:
25793 
        if ftype == TType.I64:
25794 
          self.vendorId = iprot.readI64();
25795 
        else:
25796 
          iprot.skip(ftype)
5481 phani.kuma 25797 
      elif fid == 2:
25798 
        if ftype == TType.BOOL:
25799 
          self.onlyVendorNotPaid = iprot.readBool();
25800 
        else:
25801 
          iprot.skip(ftype)
25802 
      elif fid == 3:
25803 
        if ftype == TType.I64:
25804 
          self.billingDateFrom = iprot.readI64();
25805 
        else:
25806 
          iprot.skip(ftype)
25807 
      elif fid == 4:
25808 
        if ftype == TType.I64:
25809 
          self.billingDateTo = iprot.readI64();
25810 
        else:
25811 
          iprot.skip(ftype)
4875 varun.gupt 25812 
      else:
25813 
        iprot.skip(ftype)
25814 
      iprot.readFieldEnd()
25815 
    iprot.readStructEnd()
25816 
 
25817 
  def write(self, oprot):
25818 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25819 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25820 
      return
5481 phani.kuma 25821 
    oprot.writeStructBegin('getBilledOrders_args')
4875 varun.gupt 25822 
    if self.vendorId is not None:
25823 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
25824 
      oprot.writeI64(self.vendorId)
25825 
      oprot.writeFieldEnd()
5481 phani.kuma 25826 
    if self.onlyVendorNotPaid is not None:
25827 
      oprot.writeFieldBegin('onlyVendorNotPaid', TType.BOOL, 2)
25828 
      oprot.writeBool(self.onlyVendorNotPaid)
25829 
      oprot.writeFieldEnd()
25830 
    if self.billingDateFrom is not None:
25831 
      oprot.writeFieldBegin('billingDateFrom', TType.I64, 3)
25832 
      oprot.writeI64(self.billingDateFrom)
25833 
      oprot.writeFieldEnd()
25834 
    if self.billingDateTo is not None:
25835 
      oprot.writeFieldBegin('billingDateTo', TType.I64, 4)
25836 
      oprot.writeI64(self.billingDateTo)
25837 
      oprot.writeFieldEnd()
4875 varun.gupt 25838 
    oprot.writeFieldStop()
25839 
    oprot.writeStructEnd()
25840 
 
25841 
  def validate(self):
25842 
    return
25843 
 
25844 
 
25845 
  def __repr__(self):
25846 
    L = ['%s=%r' % (key, value)
25847 
      for key, value in self.__dict__.iteritems()]
25848 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25849 
 
25850 
  def __eq__(self, other):
25851 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25852 
 
25853 
  def __ne__(self, other):
25854 
    return not (self == other)
25855 
 
5481 phani.kuma 25856 
class getBilledOrders_result:
4875 varun.gupt 25857 
  """
25858 
  Attributes:
25859 
   - success
25860 
   - ex
25861 
  """
25862 
 
25863 
  thrift_spec = (
25864 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
25865 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
25866 
  )
25867 
 
25868 
  def __init__(self, success=None, ex=None,):
25869 
    self.success = success
25870 
    self.ex = ex
25871 
 
25872 
  def read(self, iprot):
25873 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25874 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25875 
      return
25876 
    iprot.readStructBegin()
25877 
    while True:
25878 
      (fname, ftype, fid) = iprot.readFieldBegin()
25879 
      if ftype == TType.STOP:
25880 
        break
25881 
      if fid == 0:
25882 
        if ftype == TType.LIST:
25883 
          self.success = []
6188 rajveer 25884 
          (_etype587, _size584) = iprot.readListBegin()
25885 
          for _i588 in xrange(_size584):
25886 
            _elem589 = Order()
25887 
            _elem589.read(iprot)
25888 
            self.success.append(_elem589)
4875 varun.gupt 25889 
          iprot.readListEnd()
25890 
        else:
25891 
          iprot.skip(ftype)
25892 
      elif fid == 1:
25893 
        if ftype == TType.STRUCT:
25894 
          self.ex = TransactionServiceException()
25895 
          self.ex.read(iprot)
25896 
        else:
25897 
          iprot.skip(ftype)
25898 
      else:
25899 
        iprot.skip(ftype)
25900 
      iprot.readFieldEnd()
25901 
    iprot.readStructEnd()
25902 
 
25903 
  def write(self, oprot):
25904 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25905 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25906 
      return
5481 phani.kuma 25907 
    oprot.writeStructBegin('getBilledOrders_result')
4875 varun.gupt 25908 
    if self.success is not None:
25909 
      oprot.writeFieldBegin('success', TType.LIST, 0)
25910 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 25911 
      for iter590 in self.success:
25912 
        iter590.write(oprot)
4875 varun.gupt 25913 
      oprot.writeListEnd()
25914 
      oprot.writeFieldEnd()
25915 
    if self.ex is not None:
25916 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
25917 
      self.ex.write(oprot)
25918 
      oprot.writeFieldEnd()
25919 
    oprot.writeFieldStop()
25920 
    oprot.writeStructEnd()
25921 
 
25922 
  def validate(self):
25923 
    return
25924 
 
25925 
 
25926 
  def __repr__(self):
25927 
    L = ['%s=%r' % (key, value)
25928 
      for key, value in self.__dict__.iteritems()]
25929 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25930 
 
25931 
  def __eq__(self, other):
25932 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25933 
 
25934 
  def __ne__(self, other):
25935 
    return not (self == other)
5031 varun.gupt 25936 
 
25937 
class getStatusDistributionOfOrders_args:
25938 
  """
25939 
  Attributes:
25940 
   - startDate
25941 
   - endDate
25942 
  """
25943 
 
25944 
  thrift_spec = (
25945 
    None, # 0
25946 
    (1, TType.I64, 'startDate', None, None, ), # 1
25947 
    (2, TType.I64, 'endDate', None, None, ), # 2
25948 
  )
25949 
 
25950 
  def __init__(self, startDate=None, endDate=None,):
25951 
    self.startDate = startDate
25952 
    self.endDate = endDate
25953 
 
25954 
  def read(self, iprot):
25955 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25956 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25957 
      return
25958 
    iprot.readStructBegin()
25959 
    while True:
25960 
      (fname, ftype, fid) = iprot.readFieldBegin()
25961 
      if ftype == TType.STOP:
25962 
        break
25963 
      if fid == 1:
25964 
        if ftype == TType.I64:
25965 
          self.startDate = iprot.readI64();
25966 
        else:
25967 
          iprot.skip(ftype)
25968 
      elif fid == 2:
25969 
        if ftype == TType.I64:
25970 
          self.endDate = iprot.readI64();
25971 
        else:
25972 
          iprot.skip(ftype)
25973 
      else:
25974 
        iprot.skip(ftype)
25975 
      iprot.readFieldEnd()
25976 
    iprot.readStructEnd()
25977 
 
25978 
  def write(self, oprot):
25979 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25980 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25981 
      return
25982 
    oprot.writeStructBegin('getStatusDistributionOfOrders_args')
25983 
    if self.startDate is not None:
25984 
      oprot.writeFieldBegin('startDate', TType.I64, 1)
25985 
      oprot.writeI64(self.startDate)
25986 
      oprot.writeFieldEnd()
25987 
    if self.endDate is not None:
25988 
      oprot.writeFieldBegin('endDate', TType.I64, 2)
25989 
      oprot.writeI64(self.endDate)
25990 
      oprot.writeFieldEnd()
25991 
    oprot.writeFieldStop()
25992 
    oprot.writeStructEnd()
25993 
 
25994 
  def validate(self):
25995 
    return
25996 
 
25997 
 
25998 
  def __repr__(self):
25999 
    L = ['%s=%r' % (key, value)
26000 
      for key, value in self.__dict__.iteritems()]
26001 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26002 
 
26003 
  def __eq__(self, other):
26004 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26005 
 
26006 
  def __ne__(self, other):
26007 
    return not (self == other)
26008 
 
26009 
class getStatusDistributionOfOrders_result:
26010 
  """
26011 
  Attributes:
26012 
   - success
26013 
   - ex
26014 
  """
26015 
 
26016 
  thrift_spec = (
26017 
    (0, TType.MAP, 'success', (TType.I64,None,TType.I64,None), None, ), # 0
26018 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
26019 
  )
26020 
 
26021 
  def __init__(self, success=None, ex=None,):
26022 
    self.success = success
26023 
    self.ex = ex
26024 
 
26025 
  def read(self, iprot):
26026 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26027 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26028 
      return
26029 
    iprot.readStructBegin()
26030 
    while True:
26031 
      (fname, ftype, fid) = iprot.readFieldBegin()
26032 
      if ftype == TType.STOP:
26033 
        break
26034 
      if fid == 0:
26035 
        if ftype == TType.MAP:
26036 
          self.success = {}
6188 rajveer 26037 
          (_ktype592, _vtype593, _size591 ) = iprot.readMapBegin()
26038 
          for _i595 in xrange(_size591):
26039 
            _key596 = iprot.readI64();
26040 
            _val597 = iprot.readI64();
26041 
            self.success[_key596] = _val597
5031 varun.gupt 26042 
          iprot.readMapEnd()
26043 
        else:
26044 
          iprot.skip(ftype)
26045 
      elif fid == 1:
26046 
        if ftype == TType.STRUCT:
26047 
          self.ex = TransactionServiceException()
26048 
          self.ex.read(iprot)
26049 
        else:
26050 
          iprot.skip(ftype)
26051 
      else:
26052 
        iprot.skip(ftype)
26053 
      iprot.readFieldEnd()
26054 
    iprot.readStructEnd()
26055 
 
26056 
  def write(self, oprot):
26057 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26058 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26059 
      return
26060 
    oprot.writeStructBegin('getStatusDistributionOfOrders_result')
26061 
    if self.success is not None:
26062 
      oprot.writeFieldBegin('success', TType.MAP, 0)
26063 
      oprot.writeMapBegin(TType.I64, TType.I64, len(self.success))
6188 rajveer 26064 
      for kiter598,viter599 in self.success.items():
26065 
        oprot.writeI64(kiter598)
26066 
        oprot.writeI64(viter599)
5031 varun.gupt 26067 
      oprot.writeMapEnd()
26068 
      oprot.writeFieldEnd()
26069 
    if self.ex is not None:
26070 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
26071 
      self.ex.write(oprot)
26072 
      oprot.writeFieldEnd()
26073 
    oprot.writeFieldStop()
26074 
    oprot.writeStructEnd()
26075 
 
26076 
  def validate(self):
26077 
    return
26078 
 
26079 
 
26080 
  def __repr__(self):
26081 
    L = ['%s=%r' % (key, value)
26082 
      for key, value in self.__dict__.iteritems()]
26083 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26084 
 
26085 
  def __eq__(self, other):
26086 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26087 
 
26088 
  def __ne__(self, other):
26089 
    return not (self == other)
5067 varun.gupt 26090 
 
26091 
class getOrderIdsForStatus_args:
26092 
  """
26093 
  Attributes:
26094 
   - status
26095 
   - startDatetime
26096 
   - endDatetime
26097 
  """
26098 
 
26099 
  thrift_spec = (
26100 
    None, # 0
26101 
    (1, TType.I64, 'status', None, None, ), # 1
26102 
    (2, TType.I64, 'startDatetime', None, None, ), # 2
26103 
    (3, TType.I64, 'endDatetime', None, None, ), # 3
26104 
  )
26105 
 
26106 
  def __init__(self, status=None, startDatetime=None, endDatetime=None,):
26107 
    self.status = status
26108 
    self.startDatetime = startDatetime
26109 
    self.endDatetime = endDatetime
26110 
 
26111 
  def read(self, iprot):
26112 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26113 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26114 
      return
26115 
    iprot.readStructBegin()
26116 
    while True:
26117 
      (fname, ftype, fid) = iprot.readFieldBegin()
26118 
      if ftype == TType.STOP:
26119 
        break
26120 
      if fid == 1:
26121 
        if ftype == TType.I64:
26122 
          self.status = iprot.readI64();
26123 
        else:
26124 
          iprot.skip(ftype)
26125 
      elif fid == 2:
26126 
        if ftype == TType.I64:
26127 
          self.startDatetime = iprot.readI64();
26128 
        else:
26129 
          iprot.skip(ftype)
26130 
      elif fid == 3:
26131 
        if ftype == TType.I64:
26132 
          self.endDatetime = iprot.readI64();
26133 
        else:
26134 
          iprot.skip(ftype)
26135 
      else:
26136 
        iprot.skip(ftype)
26137 
      iprot.readFieldEnd()
26138 
    iprot.readStructEnd()
26139 
 
26140 
  def write(self, oprot):
26141 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26142 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26143 
      return
26144 
    oprot.writeStructBegin('getOrderIdsForStatus_args')
26145 
    if self.status is not None:
26146 
      oprot.writeFieldBegin('status', TType.I64, 1)
26147 
      oprot.writeI64(self.status)
26148 
      oprot.writeFieldEnd()
26149 
    if self.startDatetime is not None:
26150 
      oprot.writeFieldBegin('startDatetime', TType.I64, 2)
26151 
      oprot.writeI64(self.startDatetime)
26152 
      oprot.writeFieldEnd()
26153 
    if self.endDatetime is not None:
26154 
      oprot.writeFieldBegin('endDatetime', TType.I64, 3)
26155 
      oprot.writeI64(self.endDatetime)
26156 
      oprot.writeFieldEnd()
26157 
    oprot.writeFieldStop()
26158 
    oprot.writeStructEnd()
26159 
 
26160 
  def validate(self):
26161 
    return
26162 
 
26163 
 
26164 
  def __repr__(self):
26165 
    L = ['%s=%r' % (key, value)
26166 
      for key, value in self.__dict__.iteritems()]
26167 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26168 
 
26169 
  def __eq__(self, other):
26170 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26171 
 
26172 
  def __ne__(self, other):
26173 
    return not (self == other)
26174 
 
26175 
class getOrderIdsForStatus_result:
26176 
  """
26177 
  Attributes:
26178 
   - success
26179 
   - ex
26180 
  """
26181 
 
26182 
  thrift_spec = (
26183 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
26184 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
26185 
  )
26186 
 
26187 
  def __init__(self, success=None, ex=None,):
26188 
    self.success = success
26189 
    self.ex = ex
26190 
 
26191 
  def read(self, iprot):
26192 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26193 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26194 
      return
26195 
    iprot.readStructBegin()
26196 
    while True:
26197 
      (fname, ftype, fid) = iprot.readFieldBegin()
26198 
      if ftype == TType.STOP:
26199 
        break
26200 
      if fid == 0:
26201 
        if ftype == TType.LIST:
26202 
          self.success = []
6188 rajveer 26203 
          (_etype603, _size600) = iprot.readListBegin()
26204 
          for _i604 in xrange(_size600):
26205 
            _elem605 = iprot.readI64();
26206 
            self.success.append(_elem605)
5067 varun.gupt 26207 
          iprot.readListEnd()
26208 
        else:
26209 
          iprot.skip(ftype)
26210 
      elif fid == 1:
26211 
        if ftype == TType.STRUCT:
26212 
          self.ex = TransactionServiceException()
26213 
          self.ex.read(iprot)
26214 
        else:
26215 
          iprot.skip(ftype)
26216 
      else:
26217 
        iprot.skip(ftype)
26218 
      iprot.readFieldEnd()
26219 
    iprot.readStructEnd()
26220 
 
26221 
  def write(self, oprot):
26222 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26223 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26224 
      return
26225 
    oprot.writeStructBegin('getOrderIdsForStatus_result')
26226 
    if self.success is not None:
26227 
      oprot.writeFieldBegin('success', TType.LIST, 0)
26228 
      oprot.writeListBegin(TType.I64, len(self.success))
6188 rajveer 26229 
      for iter606 in self.success:
26230 
        oprot.writeI64(iter606)
5067 varun.gupt 26231 
      oprot.writeListEnd()
26232 
      oprot.writeFieldEnd()
26233 
    if self.ex is not None:
26234 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
26235 
      self.ex.write(oprot)
26236 
      oprot.writeFieldEnd()
26237 
    oprot.writeFieldStop()
26238 
    oprot.writeStructEnd()
26239 
 
26240 
  def validate(self):
26241 
    return
26242 
 
26243 
 
26244 
  def __repr__(self):
26245 
    L = ['%s=%r' % (key, value)
26246 
      for key, value in self.__dict__.iteritems()]
26247 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26248 
 
26249 
  def __eq__(self, other):
26250 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26251 
 
26252 
  def __ne__(self, other):
26253 
    return not (self == other)
5099 varun.gupt 26254 
 
5348 anupam.sin 26255 
class updateCODAgent_args:
26256 
  """
26257 
  Attributes:
26258 
   - agent
26259 
   - orderId
26260 
  """
26261 
 
26262 
  thrift_spec = (
26263 
    None, # 0
26264 
    (1, TType.STRING, 'agent', None, None, ), # 1
26265 
    (2, TType.I64, 'orderId', None, None, ), # 2
26266 
  )
26267 
 
26268 
  def __init__(self, agent=None, orderId=None,):
26269 
    self.agent = agent
26270 
    self.orderId = orderId
26271 
 
26272 
  def read(self, iprot):
26273 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26274 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26275 
      return
26276 
    iprot.readStructBegin()
26277 
    while True:
26278 
      (fname, ftype, fid) = iprot.readFieldBegin()
26279 
      if ftype == TType.STOP:
26280 
        break
26281 
      if fid == 1:
26282 
        if ftype == TType.STRING:
26283 
          self.agent = iprot.readString();
26284 
        else:
26285 
          iprot.skip(ftype)
26286 
      elif fid == 2:
26287 
        if ftype == TType.I64:
26288 
          self.orderId = iprot.readI64();
26289 
        else:
26290 
          iprot.skip(ftype)
26291 
      else:
26292 
        iprot.skip(ftype)
26293 
      iprot.readFieldEnd()
26294 
    iprot.readStructEnd()
26295 
 
26296 
  def write(self, oprot):
26297 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26298 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26299 
      return
26300 
    oprot.writeStructBegin('updateCODAgent_args')
26301 
    if self.agent is not None:
26302 
      oprot.writeFieldBegin('agent', TType.STRING, 1)
26303 
      oprot.writeString(self.agent)
26304 
      oprot.writeFieldEnd()
26305 
    if self.orderId is not None:
26306 
      oprot.writeFieldBegin('orderId', TType.I64, 2)
26307 
      oprot.writeI64(self.orderId)
26308 
      oprot.writeFieldEnd()
26309 
    oprot.writeFieldStop()
26310 
    oprot.writeStructEnd()
26311 
 
26312 
  def validate(self):
26313 
    return
26314 
 
26315 
 
26316 
  def __repr__(self):
26317 
    L = ['%s=%r' % (key, value)
26318 
      for key, value in self.__dict__.iteritems()]
26319 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26320 
 
26321 
  def __eq__(self, other):
26322 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26323 
 
26324 
  def __ne__(self, other):
26325 
    return not (self == other)
26326 
 
26327 
class updateCODAgent_result:
26328 
  """
26329 
  Attributes:
26330 
   - ex
26331 
  """
26332 
 
26333 
  thrift_spec = (
26334 
    None, # 0
26335 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
26336 
  )
26337 
 
26338 
  def __init__(self, ex=None,):
26339 
    self.ex = ex
26340 
 
26341 
  def read(self, iprot):
26342 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26343 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26344 
      return
26345 
    iprot.readStructBegin()
26346 
    while True:
26347 
      (fname, ftype, fid) = iprot.readFieldBegin()
26348 
      if ftype == TType.STOP:
26349 
        break
26350 
      if fid == 1:
26351 
        if ftype == TType.STRUCT:
26352 
          self.ex = TransactionServiceException()
26353 
          self.ex.read(iprot)
26354 
        else:
26355 
          iprot.skip(ftype)
26356 
      else:
26357 
        iprot.skip(ftype)
26358 
      iprot.readFieldEnd()
26359 
    iprot.readStructEnd()
26360 
 
26361 
  def write(self, oprot):
26362 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26363 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26364 
      return
26365 
    oprot.writeStructBegin('updateCODAgent_result')
26366 
    if self.ex is not None:
26367 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
26368 
      self.ex.write(oprot)
26369 
      oprot.writeFieldEnd()
26370 
    oprot.writeFieldStop()
26371 
    oprot.writeStructEnd()
26372 
 
26373 
  def validate(self):
26374 
    return
26375 
 
26376 
 
26377 
  def __repr__(self):
26378 
    L = ['%s=%r' % (key, value)
26379 
      for key, value in self.__dict__.iteritems()]
26380 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26381 
 
26382 
  def __eq__(self, other):
26383 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26384 
 
26385 
  def __ne__(self, other):
26386 
    return not (self == other)
26387 
 
5099 varun.gupt 26388 
class updateOrderAsPaidToVendor_args:
26389 
  """
26390 
  Attributes:
26391 
   - orderId
26392 
  """
26393 
 
26394 
  thrift_spec = (
26395 
    None, # 0
26396 
    (1, TType.I64, 'orderId', None, None, ), # 1
26397 
  )
26398 
 
26399 
  def __init__(self, orderId=None,):
26400 
    self.orderId = orderId
26401 
 
26402 
  def read(self, iprot):
26403 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26404 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26405 
      return
26406 
    iprot.readStructBegin()
26407 
    while True:
26408 
      (fname, ftype, fid) = iprot.readFieldBegin()
26409 
      if ftype == TType.STOP:
26410 
        break
26411 
      if fid == 1:
26412 
        if ftype == TType.I64:
26413 
          self.orderId = iprot.readI64();
26414 
        else:
26415 
          iprot.skip(ftype)
26416 
      else:
26417 
        iprot.skip(ftype)
26418 
      iprot.readFieldEnd()
26419 
    iprot.readStructEnd()
26420 
 
26421 
  def write(self, oprot):
26422 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26423 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26424 
      return
26425 
    oprot.writeStructBegin('updateOrderAsPaidToVendor_args')
26426 
    if self.orderId is not None:
26427 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
26428 
      oprot.writeI64(self.orderId)
26429 
      oprot.writeFieldEnd()
26430 
    oprot.writeFieldStop()
26431 
    oprot.writeStructEnd()
26432 
 
26433 
  def validate(self):
26434 
    return
26435 
 
26436 
 
26437 
  def __repr__(self):
26438 
    L = ['%s=%r' % (key, value)
26439 
      for key, value in self.__dict__.iteritems()]
26440 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26441 
 
26442 
  def __eq__(self, other):
26443 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26444 
 
26445 
  def __ne__(self, other):
26446 
    return not (self == other)
26447 
 
26448 
class updateOrderAsPaidToVendor_result:
26449 
  """
26450 
  Attributes:
26451 
   - ex
26452 
  """
26453 
 
26454 
  thrift_spec = (
26455 
    None, # 0
26456 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
26457 
  )
26458 
 
26459 
  def __init__(self, ex=None,):
26460 
    self.ex = ex
26461 
 
26462 
  def read(self, iprot):
26463 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26464 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26465 
      return
26466 
    iprot.readStructBegin()
26467 
    while True:
26468 
      (fname, ftype, fid) = iprot.readFieldBegin()
26469 
      if ftype == TType.STOP:
26470 
        break
26471 
      if fid == 1:
26472 
        if ftype == TType.STRUCT:
26473 
          self.ex = TransactionServiceException()
26474 
          self.ex.read(iprot)
26475 
        else:
26476 
          iprot.skip(ftype)
26477 
      else:
26478 
        iprot.skip(ftype)
26479 
      iprot.readFieldEnd()
26480 
    iprot.readStructEnd()
26481 
 
26482 
  def write(self, oprot):
26483 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26484 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26485 
      return
26486 
    oprot.writeStructBegin('updateOrderAsPaidToVendor_result')
26487 
    if self.ex is not None:
26488 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
26489 
      self.ex.write(oprot)
26490 
      oprot.writeFieldEnd()
26491 
    oprot.writeFieldStop()
26492 
    oprot.writeStructEnd()
26493 
 
26494 
  def validate(self):
26495 
    return
26496 
 
26497 
 
26498 
  def __repr__(self):
26499 
    L = ['%s=%r' % (key, value)
26500 
      for key, value in self.__dict__.iteritems()]
26501 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26502 
 
26503 
  def __eq__(self, other):
26504 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26505 
 
26506 
  def __ne__(self, other):
26507 
    return not (self == other)
5208 varun.gupt 26508 
 
5386 phani.kuma 26509 
class updateOrderOnlyAsPaidToVendor_args:
26510 
  """
26511 
  Attributes:
26512 
   - orderId
26513 
  """
26514 
 
26515 
  thrift_spec = (
26516 
    None, # 0
26517 
    (1, TType.I64, 'orderId', None, None, ), # 1
26518 
  )
26519 
 
26520 
  def __init__(self, orderId=None,):
26521 
    self.orderId = orderId
26522 
 
26523 
  def read(self, iprot):
26524 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26525 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26526 
      return
26527 
    iprot.readStructBegin()
26528 
    while True:
26529 
      (fname, ftype, fid) = iprot.readFieldBegin()
26530 
      if ftype == TType.STOP:
26531 
        break
26532 
      if fid == 1:
26533 
        if ftype == TType.I64:
26534 
          self.orderId = iprot.readI64();
26535 
        else:
26536 
          iprot.skip(ftype)
26537 
      else:
26538 
        iprot.skip(ftype)
26539 
      iprot.readFieldEnd()
26540 
    iprot.readStructEnd()
26541 
 
26542 
  def write(self, oprot):
26543 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26544 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26545 
      return
26546 
    oprot.writeStructBegin('updateOrderOnlyAsPaidToVendor_args')
26547 
    if self.orderId is not None:
26548 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
26549 
      oprot.writeI64(self.orderId)
26550 
      oprot.writeFieldEnd()
26551 
    oprot.writeFieldStop()
26552 
    oprot.writeStructEnd()
26553 
 
26554 
  def validate(self):
26555 
    return
26556 
 
26557 
 
26558 
  def __repr__(self):
26559 
    L = ['%s=%r' % (key, value)
26560 
      for key, value in self.__dict__.iteritems()]
26561 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26562 
 
26563 
  def __eq__(self, other):
26564 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26565 
 
26566 
  def __ne__(self, other):
26567 
    return not (self == other)
26568 
 
26569 
class updateOrderOnlyAsPaidToVendor_result:
26570 
  """
26571 
  Attributes:
26572 
   - ex
26573 
  """
26574 
 
26575 
  thrift_spec = (
26576 
    None, # 0
26577 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
26578 
  )
26579 
 
26580 
  def __init__(self, ex=None,):
26581 
    self.ex = ex
26582 
 
26583 
  def read(self, iprot):
26584 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26585 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26586 
      return
26587 
    iprot.readStructBegin()
26588 
    while True:
26589 
      (fname, ftype, fid) = iprot.readFieldBegin()
26590 
      if ftype == TType.STOP:
26591 
        break
26592 
      if fid == 1:
26593 
        if ftype == TType.STRUCT:
26594 
          self.ex = TransactionServiceException()
26595 
          self.ex.read(iprot)
26596 
        else:
26597 
          iprot.skip(ftype)
26598 
      else:
26599 
        iprot.skip(ftype)
26600 
      iprot.readFieldEnd()
26601 
    iprot.readStructEnd()
26602 
 
26603 
  def write(self, oprot):
26604 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26605 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26606 
      return
26607 
    oprot.writeStructBegin('updateOrderOnlyAsPaidToVendor_result')
26608 
    if self.ex is not None:
26609 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
26610 
      self.ex.write(oprot)
26611 
      oprot.writeFieldEnd()
26612 
    oprot.writeFieldStop()
26613 
    oprot.writeStructEnd()
26614 
 
26615 
  def validate(self):
26616 
    return
26617 
 
26618 
 
26619 
  def __repr__(self):
26620 
    L = ['%s=%r' % (key, value)
26621 
      for key, value in self.__dict__.iteritems()]
26622 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26623 
 
26624 
  def __eq__(self, other):
26625 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26626 
 
26627 
  def __ne__(self, other):
26628 
    return not (self == other)
26629 
 
5208 varun.gupt 26630 
class getRefundedOrdersMarkedPaid_args:
26631 
 
26632 
  thrift_spec = (
26633 
  )
26634 
 
26635 
  def read(self, iprot):
26636 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26637 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26638 
      return
26639 
    iprot.readStructBegin()
26640 
    while True:
26641 
      (fname, ftype, fid) = iprot.readFieldBegin()
26642 
      if ftype == TType.STOP:
26643 
        break
26644 
      else:
26645 
        iprot.skip(ftype)
26646 
      iprot.readFieldEnd()
26647 
    iprot.readStructEnd()
26648 
 
26649 
  def write(self, oprot):
26650 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26651 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26652 
      return
26653 
    oprot.writeStructBegin('getRefundedOrdersMarkedPaid_args')
26654 
    oprot.writeFieldStop()
26655 
    oprot.writeStructEnd()
26656 
 
26657 
  def validate(self):
26658 
    return
26659 
 
26660 
 
26661 
  def __repr__(self):
26662 
    L = ['%s=%r' % (key, value)
26663 
      for key, value in self.__dict__.iteritems()]
26664 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26665 
 
26666 
  def __eq__(self, other):
26667 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26668 
 
26669 
  def __ne__(self, other):
26670 
    return not (self == other)
26671 
 
26672 
class getRefundedOrdersMarkedPaid_result:
26673 
  """
26674 
  Attributes:
26675 
   - success
26676 
   - ex
26677 
  """
26678 
 
26679 
  thrift_spec = (
26680 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
26681 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
26682 
  )
26683 
 
26684 
  def __init__(self, success=None, ex=None,):
26685 
    self.success = success
26686 
    self.ex = ex
26687 
 
26688 
  def read(self, iprot):
26689 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26690 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26691 
      return
26692 
    iprot.readStructBegin()
26693 
    while True:
26694 
      (fname, ftype, fid) = iprot.readFieldBegin()
26695 
      if ftype == TType.STOP:
26696 
        break
26697 
      if fid == 0:
26698 
        if ftype == TType.LIST:
26699 
          self.success = []
6188 rajveer 26700 
          (_etype610, _size607) = iprot.readListBegin()
26701 
          for _i611 in xrange(_size607):
26702 
            _elem612 = Order()
26703 
            _elem612.read(iprot)
26704 
            self.success.append(_elem612)
5208 varun.gupt 26705 
          iprot.readListEnd()
26706 
        else:
26707 
          iprot.skip(ftype)
26708 
      elif fid == 1:
26709 
        if ftype == TType.STRUCT:
26710 
          self.ex = TransactionServiceException()
26711 
          self.ex.read(iprot)
26712 
        else:
26713 
          iprot.skip(ftype)
26714 
      else:
26715 
        iprot.skip(ftype)
26716 
      iprot.readFieldEnd()
26717 
    iprot.readStructEnd()
26718 
 
26719 
  def write(self, oprot):
26720 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26721 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26722 
      return
26723 
    oprot.writeStructBegin('getRefundedOrdersMarkedPaid_result')
26724 
    if self.success is not None:
26725 
      oprot.writeFieldBegin('success', TType.LIST, 0)
26726 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 26727 
      for iter613 in self.success:
26728 
        iter613.write(oprot)
5208 varun.gupt 26729 
      oprot.writeListEnd()
26730 
      oprot.writeFieldEnd()
26731 
    if self.ex is not None:
26732 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
26733 
      self.ex.write(oprot)
26734 
      oprot.writeFieldEnd()
26735 
    oprot.writeFieldStop()
26736 
    oprot.writeStructEnd()
26737 
 
26738 
  def validate(self):
26739 
    return
26740 
 
26741 
 
26742 
  def __repr__(self):
26743 
    L = ['%s=%r' % (key, value)
26744 
      for key, value in self.__dict__.iteritems()]
26745 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26746 
 
26747 
  def __eq__(self, other):
26748 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26749 
 
26750 
  def __ne__(self, other):
26751 
    return not (self == other)
5447 anupam.sin 26752 
 
26753 
class getAllVerificationAgents_args:
26754 
  """
26755 
  Attributes:
26756 
   - minOrderId
26757 
   - maxOrderId
26758 
  """
26759 
 
26760 
  thrift_spec = (
26761 
    None, # 0
26762 
    (1, TType.I64, 'minOrderId', None, None, ), # 1
26763 
    (2, TType.I64, 'maxOrderId', None, None, ), # 2
26764 
  )
26765 
 
26766 
  def __init__(self, minOrderId=None, maxOrderId=None,):
26767 
    self.minOrderId = minOrderId
26768 
    self.maxOrderId = maxOrderId
26769 
 
26770 
  def read(self, iprot):
26771 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26772 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26773 
      return
26774 
    iprot.readStructBegin()
26775 
    while True:
26776 
      (fname, ftype, fid) = iprot.readFieldBegin()
26777 
      if ftype == TType.STOP:
26778 
        break
26779 
      if fid == 1:
26780 
        if ftype == TType.I64:
26781 
          self.minOrderId = iprot.readI64();
26782 
        else:
26783 
          iprot.skip(ftype)
26784 
      elif fid == 2:
26785 
        if ftype == TType.I64:
26786 
          self.maxOrderId = iprot.readI64();
26787 
        else:
26788 
          iprot.skip(ftype)
26789 
      else:
26790 
        iprot.skip(ftype)
26791 
      iprot.readFieldEnd()
26792 
    iprot.readStructEnd()
26793 
 
26794 
  def write(self, oprot):
26795 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26796 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26797 
      return
26798 
    oprot.writeStructBegin('getAllVerificationAgents_args')
26799 
    if self.minOrderId is not None:
26800 
      oprot.writeFieldBegin('minOrderId', TType.I64, 1)
26801 
      oprot.writeI64(self.minOrderId)
26802 
      oprot.writeFieldEnd()
26803 
    if self.maxOrderId is not None:
26804 
      oprot.writeFieldBegin('maxOrderId', TType.I64, 2)
26805 
      oprot.writeI64(self.maxOrderId)
26806 
      oprot.writeFieldEnd()
26807 
    oprot.writeFieldStop()
26808 
    oprot.writeStructEnd()
26809 
 
26810 
  def validate(self):
26811 
    return
26812 
 
26813 
 
26814 
  def __repr__(self):
26815 
    L = ['%s=%r' % (key, value)
26816 
      for key, value in self.__dict__.iteritems()]
26817 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26818 
 
26819 
  def __eq__(self, other):
26820 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26821 
 
26822 
  def __ne__(self, other):
26823 
    return not (self == other)
26824 
 
26825 
class getAllVerificationAgents_result:
26826 
  """
26827 
  Attributes:
26828 
   - success
26829 
  """
26830 
 
26831 
  thrift_spec = (
26832 
    (0, TType.LIST, 'success', (TType.STRUCT,(CODVerificationAgent, CODVerificationAgent.thrift_spec)), None, ), # 0
26833 
  )
26834 
 
26835 
  def __init__(self, success=None,):
26836 
    self.success = success
26837 
 
26838 
  def read(self, iprot):
26839 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26840 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26841 
      return
26842 
    iprot.readStructBegin()
26843 
    while True:
26844 
      (fname, ftype, fid) = iprot.readFieldBegin()
26845 
      if ftype == TType.STOP:
26846 
        break
26847 
      if fid == 0:
26848 
        if ftype == TType.LIST:
26849 
          self.success = []
6188 rajveer 26850 
          (_etype617, _size614) = iprot.readListBegin()
26851 
          for _i618 in xrange(_size614):
26852 
            _elem619 = CODVerificationAgent()
26853 
            _elem619.read(iprot)
26854 
            self.success.append(_elem619)
5447 anupam.sin 26855 
          iprot.readListEnd()
26856 
        else:
26857 
          iprot.skip(ftype)
26858 
      else:
26859 
        iprot.skip(ftype)
26860 
      iprot.readFieldEnd()
26861 
    iprot.readStructEnd()
26862 
 
26863 
  def write(self, oprot):
26864 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26865 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26866 
      return
26867 
    oprot.writeStructBegin('getAllVerificationAgents_result')
26868 
    if self.success is not None:
26869 
      oprot.writeFieldBegin('success', TType.LIST, 0)
26870 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 26871 
      for iter620 in self.success:
26872 
        iter620.write(oprot)
5447 anupam.sin 26873 
      oprot.writeListEnd()
26874 
      oprot.writeFieldEnd()
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)
5527 anupam.sin 26892 
 
26893 
class getAllAttributesForOrderId_args:
26894 
  """
26895 
  Attributes:
26896 
   - orderId
26897 
  """
26898 
 
26899 
  thrift_spec = (
26900 
    None, # 0
26901 
    (1, TType.I64, 'orderId', None, None, ), # 1
26902 
  )
26903 
 
26904 
  def __init__(self, orderId=None,):
26905 
    self.orderId = orderId
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.orderId = 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('getAllAttributesForOrderId_args')
26931 
    if self.orderId is not None:
26932 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
26933 
      oprot.writeI64(self.orderId)
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 getAllAttributesForOrderId_result:
26954 
  """
26955 
  Attributes:
26956 
   - success
26957 
  """
26958 
 
26959 
  thrift_spec = (
26960 
    (0, TType.LIST, 'success', (TType.STRUCT,(Attribute, Attribute.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 
          (_etype624, _size621) = iprot.readListBegin()
26979 
          for _i625 in xrange(_size621):
26980 
            _elem626 = Attribute()
26981 
            _elem626.read(iprot)
26982 
            self.success.append(_elem626)
5527 anupam.sin 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('getAllAttributesForOrderId_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 iter627 in self.success:
27000 
        iter627.write(oprot)
5527 anupam.sin 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 
 
5676 rajveer 27021 
class setOrderAttributes_args:
27022 
  """
27023 
  Attributes:
27024 
   - orderId
27025 
   - attributes
27026 
  """
27027 
 
27028 
  thrift_spec = None
27029 
  def __init__(self, orderId=None, attributes=None,):
27030 
    self.orderId = orderId
27031 
    self.attributes = attributes
27032 
 
27033 
  def read(self, iprot):
27034 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27035 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27036 
      return
27037 
    iprot.readStructBegin()
27038 
    while True:
27039 
      (fname, ftype, fid) = iprot.readFieldBegin()
27040 
      if ftype == TType.STOP:
27041 
        break
27042 
      if fid == 1:
27043 
        if ftype == TType.I64:
27044 
          self.orderId = iprot.readI64();
27045 
        else:
27046 
          iprot.skip(ftype)
27047 
      elif fid == -1:
27048 
        if ftype == TType.LIST:
27049 
          self.attributes = []
6188 rajveer 27050 
          (_etype631, _size628) = iprot.readListBegin()
27051 
          for _i632 in xrange(_size628):
27052 
            _elem633 = Attribute()
27053 
            _elem633.read(iprot)
27054 
            self.attributes.append(_elem633)
5676 rajveer 27055 
          iprot.readListEnd()
27056 
        else:
27057 
          iprot.skip(ftype)
27058 
      else:
27059 
        iprot.skip(ftype)
27060 
      iprot.readFieldEnd()
27061 
    iprot.readStructEnd()
27062 
 
27063 
  def write(self, oprot):
27064 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27065 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27066 
      return
27067 
    oprot.writeStructBegin('setOrderAttributes_args')
27068 
    if self.attributes is not None:
27069 
      oprot.writeFieldBegin('attributes', TType.LIST, -1)
27070 
      oprot.writeListBegin(TType.STRUCT, len(self.attributes))
6188 rajveer 27071 
      for iter634 in self.attributes:
27072 
        iter634.write(oprot)
5676 rajveer 27073 
      oprot.writeListEnd()
27074 
      oprot.writeFieldEnd()
27075 
    if self.orderId is not None:
27076 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
27077 
      oprot.writeI64(self.orderId)
27078 
      oprot.writeFieldEnd()
27079 
    oprot.writeFieldStop()
27080 
    oprot.writeStructEnd()
27081 
 
27082 
  def validate(self):
27083 
    return
27084 
 
27085 
 
27086 
  def __repr__(self):
27087 
    L = ['%s=%r' % (key, value)
27088 
      for key, value in self.__dict__.iteritems()]
27089 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27090 
 
27091 
  def __eq__(self, other):
27092 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27093 
 
27094 
  def __ne__(self, other):
27095 
    return not (self == other)
27096 
 
27097 
class setOrderAttributes_result:
27098 
 
27099 
  thrift_spec = (
27100 
  )
27101 
 
27102 
  def read(self, iprot):
27103 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27104 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27105 
      return
27106 
    iprot.readStructBegin()
27107 
    while True:
27108 
      (fname, ftype, fid) = iprot.readFieldBegin()
27109 
      if ftype == TType.STOP:
27110 
        break
27111 
      else:
27112 
        iprot.skip(ftype)
27113 
      iprot.readFieldEnd()
27114 
    iprot.readStructEnd()
27115 
 
27116 
  def write(self, oprot):
27117 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27118 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27119 
      return
27120 
    oprot.writeStructBegin('setOrderAttributes_result')
27121 
    oprot.writeFieldStop()
27122 
    oprot.writeStructEnd()
27123 
 
27124 
  def validate(self):
27125 
    return
27126 
 
27127 
 
27128 
  def __repr__(self):
27129 
    L = ['%s=%r' % (key, value)
27130 
      for key, value in self.__dict__.iteritems()]
27131 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27132 
 
27133 
  def __eq__(self, other):
27134 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27135 
 
27136 
  def __ne__(self, other):
27137 
    return not (self == other)
27138 
 
5527 anupam.sin 27139 
class setOrderAttributeForTransaction_args:
27140 
  """
27141 
  Attributes:
27142 
   - transactionId
27143 
   - attribute
27144 
  """
27145 
 
27146 
  thrift_spec = None
27147 
  def __init__(self, transactionId=None, attribute=None,):
27148 
    self.transactionId = transactionId
27149 
    self.attribute = attribute
27150 
 
27151 
  def read(self, iprot):
27152 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27153 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27154 
      return
27155 
    iprot.readStructBegin()
27156 
    while True:
27157 
      (fname, ftype, fid) = iprot.readFieldBegin()
27158 
      if ftype == TType.STOP:
27159 
        break
27160 
      if fid == 1:
27161 
        if ftype == TType.I64:
27162 
          self.transactionId = iprot.readI64();
27163 
        else:
27164 
          iprot.skip(ftype)
27165 
      elif fid == -1:
27166 
        if ftype == TType.STRUCT:
27167 
          self.attribute = Attribute()
27168 
          self.attribute.read(iprot)
27169 
        else:
27170 
          iprot.skip(ftype)
27171 
      else:
27172 
        iprot.skip(ftype)
27173 
      iprot.readFieldEnd()
27174 
    iprot.readStructEnd()
27175 
 
27176 
  def write(self, oprot):
27177 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27178 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27179 
      return
27180 
    oprot.writeStructBegin('setOrderAttributeForTransaction_args')
27181 
    if self.attribute is not None:
27182 
      oprot.writeFieldBegin('attribute', TType.STRUCT, -1)
27183 
      self.attribute.write(oprot)
27184 
      oprot.writeFieldEnd()
27185 
    if self.transactionId is not None:
27186 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
27187 
      oprot.writeI64(self.transactionId)
27188 
      oprot.writeFieldEnd()
27189 
    oprot.writeFieldStop()
27190 
    oprot.writeStructEnd()
27191 
 
27192 
  def validate(self):
27193 
    return
27194 
 
27195 
 
27196 
  def __repr__(self):
27197 
    L = ['%s=%r' % (key, value)
27198 
      for key, value in self.__dict__.iteritems()]
27199 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27200 
 
27201 
  def __eq__(self, other):
27202 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27203 
 
27204 
  def __ne__(self, other):
27205 
    return not (self == other)
27206 
 
27207 
class setOrderAttributeForTransaction_result:
27208 
 
27209 
  thrift_spec = (
27210 
  )
27211 
 
27212 
  def read(self, iprot):
27213 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27214 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27215 
      return
27216 
    iprot.readStructBegin()
27217 
    while True:
27218 
      (fname, ftype, fid) = iprot.readFieldBegin()
27219 
      if ftype == TType.STOP:
27220 
        break
27221 
      else:
27222 
        iprot.skip(ftype)
27223 
      iprot.readFieldEnd()
27224 
    iprot.readStructEnd()
27225 
 
27226 
  def write(self, oprot):
27227 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27228 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27229 
      return
27230 
    oprot.writeStructBegin('setOrderAttributeForTransaction_result')
27231 
    oprot.writeFieldStop()
27232 
    oprot.writeStructEnd()
27233 
 
27234 
  def validate(self):
27235 
    return
27236 
 
27237 
 
27238 
  def __repr__(self):
27239 
    L = ['%s=%r' % (key, value)
27240 
      for key, value in self.__dict__.iteritems()]
27241 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27242 
 
27243 
  def __eq__(self, other):
27244 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27245 
 
27246 
  def __ne__(self, other):
27247 
    return not (self == other)
5553 rajveer 27248 
 
27249 
class getReceivePendingOrders_args:
27250 
  """
27251 
  Attributes:
27252 
   - storeId
27253 
  """
27254 
 
27255 
  thrift_spec = (
27256 
    None, # 0
27257 
    (1, TType.I64, 'storeId', None, None, ), # 1
27258 
  )
27259 
 
27260 
  def __init__(self, storeId=None,):
27261 
    self.storeId = storeId
27262 
 
27263 
  def read(self, iprot):
27264 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27265 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27266 
      return
27267 
    iprot.readStructBegin()
27268 
    while True:
27269 
      (fname, ftype, fid) = iprot.readFieldBegin()
27270 
      if ftype == TType.STOP:
27271 
        break
27272 
      if fid == 1:
27273 
        if ftype == TType.I64:
27274 
          self.storeId = iprot.readI64();
27275 
        else:
27276 
          iprot.skip(ftype)
27277 
      else:
27278 
        iprot.skip(ftype)
27279 
      iprot.readFieldEnd()
27280 
    iprot.readStructEnd()
27281 
 
27282 
  def write(self, oprot):
27283 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27284 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27285 
      return
27286 
    oprot.writeStructBegin('getReceivePendingOrders_args')
27287 
    if self.storeId is not None:
27288 
      oprot.writeFieldBegin('storeId', TType.I64, 1)
27289 
      oprot.writeI64(self.storeId)
27290 
      oprot.writeFieldEnd()
27291 
    oprot.writeFieldStop()
27292 
    oprot.writeStructEnd()
27293 
 
27294 
  def validate(self):
27295 
    return
27296 
 
27297 
 
27298 
  def __repr__(self):
27299 
    L = ['%s=%r' % (key, value)
27300 
      for key, value in self.__dict__.iteritems()]
27301 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27302 
 
27303 
  def __eq__(self, other):
27304 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27305 
 
27306 
  def __ne__(self, other):
27307 
    return not (self == other)
27308 
 
27309 
class getReceivePendingOrders_result:
27310 
  """
27311 
  Attributes:
27312 
   - success
27313 
  """
27314 
 
27315 
  thrift_spec = (
27316 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
27317 
  )
27318 
 
27319 
  def __init__(self, success=None,):
27320 
    self.success = success
27321 
 
27322 
  def read(self, iprot):
27323 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27324 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27325 
      return
27326 
    iprot.readStructBegin()
27327 
    while True:
27328 
      (fname, ftype, fid) = iprot.readFieldBegin()
27329 
      if ftype == TType.STOP:
27330 
        break
27331 
      if fid == 0:
27332 
        if ftype == TType.LIST:
27333 
          self.success = []
6188 rajveer 27334 
          (_etype638, _size635) = iprot.readListBegin()
27335 
          for _i639 in xrange(_size635):
27336 
            _elem640 = Order()
27337 
            _elem640.read(iprot)
27338 
            self.success.append(_elem640)
5553 rajveer 27339 
          iprot.readListEnd()
27340 
        else:
27341 
          iprot.skip(ftype)
27342 
      else:
27343 
        iprot.skip(ftype)
27344 
      iprot.readFieldEnd()
27345 
    iprot.readStructEnd()
27346 
 
27347 
  def write(self, oprot):
27348 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27349 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27350 
      return
27351 
    oprot.writeStructBegin('getReceivePendingOrders_result')
27352 
    if self.success is not None:
27353 
      oprot.writeFieldBegin('success', TType.LIST, 0)
27354 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 27355 
      for iter641 in self.success:
27356 
        iter641.write(oprot)
5553 rajveer 27357 
      oprot.writeListEnd()
27358 
      oprot.writeFieldEnd()
27359 
    oprot.writeFieldStop()
27360 
    oprot.writeStructEnd()
27361 
 
27362 
  def validate(self):
27363 
    return
27364 
 
27365 
 
27366 
  def __repr__(self):
27367 
    L = ['%s=%r' % (key, value)
27368 
      for key, value in self.__dict__.iteritems()]
27369 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27370 
 
27371 
  def __eq__(self, other):
27372 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27373 
 
27374 
  def __ne__(self, other):
27375 
    return not (self == other)
27376 
 
27377 
class getReceivedAtStoreOrders_args:
27378 
  """
27379 
  Attributes:
27380 
   - storeId
27381 
  """
27382 
 
27383 
  thrift_spec = (
27384 
    None, # 0
27385 
    (1, TType.I64, 'storeId', None, None, ), # 1
27386 
  )
27387 
 
27388 
  def __init__(self, storeId=None,):
27389 
    self.storeId = storeId
27390 
 
27391 
  def read(self, iprot):
27392 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27393 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27394 
      return
27395 
    iprot.readStructBegin()
27396 
    while True:
27397 
      (fname, ftype, fid) = iprot.readFieldBegin()
27398 
      if ftype == TType.STOP:
27399 
        break
27400 
      if fid == 1:
27401 
        if ftype == TType.I64:
27402 
          self.storeId = iprot.readI64();
27403 
        else:
27404 
          iprot.skip(ftype)
27405 
      else:
27406 
        iprot.skip(ftype)
27407 
      iprot.readFieldEnd()
27408 
    iprot.readStructEnd()
27409 
 
27410 
  def write(self, oprot):
27411 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27412 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27413 
      return
27414 
    oprot.writeStructBegin('getReceivedAtStoreOrders_args')
27415 
    if self.storeId is not None:
27416 
      oprot.writeFieldBegin('storeId', TType.I64, 1)
27417 
      oprot.writeI64(self.storeId)
27418 
      oprot.writeFieldEnd()
27419 
    oprot.writeFieldStop()
27420 
    oprot.writeStructEnd()
27421 
 
27422 
  def validate(self):
27423 
    return
27424 
 
27425 
 
27426 
  def __repr__(self):
27427 
    L = ['%s=%r' % (key, value)
27428 
      for key, value in self.__dict__.iteritems()]
27429 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27430 
 
27431 
  def __eq__(self, other):
27432 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27433 
 
27434 
  def __ne__(self, other):
27435 
    return not (self == other)
27436 
 
27437 
class getReceivedAtStoreOrders_result:
27438 
  """
27439 
  Attributes:
27440 
   - success
27441 
  """
27442 
 
27443 
  thrift_spec = (
27444 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
27445 
  )
27446 
 
27447 
  def __init__(self, success=None,):
27448 
    self.success = success
27449 
 
27450 
  def read(self, iprot):
27451 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27452 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27453 
      return
27454 
    iprot.readStructBegin()
27455 
    while True:
27456 
      (fname, ftype, fid) = iprot.readFieldBegin()
27457 
      if ftype == TType.STOP:
27458 
        break
27459 
      if fid == 0:
27460 
        if ftype == TType.LIST:
27461 
          self.success = []
6188 rajveer 27462 
          (_etype645, _size642) = iprot.readListBegin()
27463 
          for _i646 in xrange(_size642):
27464 
            _elem647 = Order()
27465 
            _elem647.read(iprot)
27466 
            self.success.append(_elem647)
5553 rajveer 27467 
          iprot.readListEnd()
27468 
        else:
27469 
          iprot.skip(ftype)
27470 
      else:
27471 
        iprot.skip(ftype)
27472 
      iprot.readFieldEnd()
27473 
    iprot.readStructEnd()
27474 
 
27475 
  def write(self, oprot):
27476 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27477 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27478 
      return
27479 
    oprot.writeStructBegin('getReceivedAtStoreOrders_result')
27480 
    if self.success is not None:
27481 
      oprot.writeFieldBegin('success', TType.LIST, 0)
27482 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 27483 
      for iter648 in self.success:
27484 
        iter648.write(oprot)
5553 rajveer 27485 
      oprot.writeListEnd()
27486 
      oprot.writeFieldEnd()
27487 
    oprot.writeFieldStop()
27488 
    oprot.writeStructEnd()
27489 
 
27490 
  def validate(self):
27491 
    return
27492 
 
27493 
 
27494 
  def __repr__(self):
27495 
    L = ['%s=%r' % (key, value)
27496 
      for key, value in self.__dict__.iteritems()]
27497 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27498 
 
27499 
  def __eq__(self, other):
27500 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27501 
 
27502 
  def __ne__(self, other):
27503 
    return not (self == other)
5593 mandeep.dh 27504 
 
5713 rajveer 27505 
class getOrdersCollectionAtStore_args:
27506 
  """
27507 
  Attributes:
27508 
   - storeId
27509 
   - fromDate
27510 
   - toDate
27511 
   - onlyCod
27512 
  """
27513 
 
27514 
  thrift_spec = (
27515 
    None, # 0
27516 
    (1, TType.I64, 'storeId', None, None, ), # 1
27517 
    (2, TType.I64, 'fromDate', None, None, ), # 2
27518 
    (3, TType.I64, 'toDate', None, None, ), # 3
27519 
    (4, TType.BOOL, 'onlyCod', None, None, ), # 4
27520 
  )
27521 
 
27522 
  def __init__(self, storeId=None, fromDate=None, toDate=None, onlyCod=None,):
27523 
    self.storeId = storeId
27524 
    self.fromDate = fromDate
27525 
    self.toDate = toDate
27526 
    self.onlyCod = onlyCod
27527 
 
27528 
  def read(self, iprot):
27529 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27530 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27531 
      return
27532 
    iprot.readStructBegin()
27533 
    while True:
27534 
      (fname, ftype, fid) = iprot.readFieldBegin()
27535 
      if ftype == TType.STOP:
27536 
        break
27537 
      if fid == 1:
27538 
        if ftype == TType.I64:
27539 
          self.storeId = iprot.readI64();
27540 
        else:
27541 
          iprot.skip(ftype)
27542 
      elif fid == 2:
27543 
        if ftype == TType.I64:
27544 
          self.fromDate = iprot.readI64();
27545 
        else:
27546 
          iprot.skip(ftype)
27547 
      elif fid == 3:
27548 
        if ftype == TType.I64:
27549 
          self.toDate = iprot.readI64();
27550 
        else:
27551 
          iprot.skip(ftype)
27552 
      elif fid == 4:
27553 
        if ftype == TType.BOOL:
27554 
          self.onlyCod = iprot.readBool();
27555 
        else:
27556 
          iprot.skip(ftype)
27557 
      else:
27558 
        iprot.skip(ftype)
27559 
      iprot.readFieldEnd()
27560 
    iprot.readStructEnd()
27561 
 
27562 
  def write(self, oprot):
27563 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27564 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27565 
      return
27566 
    oprot.writeStructBegin('getOrdersCollectionAtStore_args')
27567 
    if self.storeId is not None:
27568 
      oprot.writeFieldBegin('storeId', TType.I64, 1)
27569 
      oprot.writeI64(self.storeId)
27570 
      oprot.writeFieldEnd()
27571 
    if self.fromDate is not None:
27572 
      oprot.writeFieldBegin('fromDate', TType.I64, 2)
27573 
      oprot.writeI64(self.fromDate)
27574 
      oprot.writeFieldEnd()
27575 
    if self.toDate is not None:
27576 
      oprot.writeFieldBegin('toDate', TType.I64, 3)
27577 
      oprot.writeI64(self.toDate)
27578 
      oprot.writeFieldEnd()
27579 
    if self.onlyCod is not None:
27580 
      oprot.writeFieldBegin('onlyCod', TType.BOOL, 4)
27581 
      oprot.writeBool(self.onlyCod)
27582 
      oprot.writeFieldEnd()
27583 
    oprot.writeFieldStop()
27584 
    oprot.writeStructEnd()
27585 
 
27586 
  def validate(self):
27587 
    return
27588 
 
27589 
 
27590 
  def __repr__(self):
27591 
    L = ['%s=%r' % (key, value)
27592 
      for key, value in self.__dict__.iteritems()]
27593 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27594 
 
27595 
  def __eq__(self, other):
27596 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27597 
 
27598 
  def __ne__(self, other):
27599 
    return not (self == other)
27600 
 
27601 
class getOrdersCollectionAtStore_result:
27602 
  """
27603 
  Attributes:
27604 
   - success
27605 
  """
27606 
 
27607 
  thrift_spec = (
27608 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
27609 
  )
27610 
 
27611 
  def __init__(self, success=None,):
27612 
    self.success = success
27613 
 
27614 
  def read(self, iprot):
27615 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27616 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27617 
      return
27618 
    iprot.readStructBegin()
27619 
    while True:
27620 
      (fname, ftype, fid) = iprot.readFieldBegin()
27621 
      if ftype == TType.STOP:
27622 
        break
27623 
      if fid == 0:
27624 
        if ftype == TType.LIST:
27625 
          self.success = []
6188 rajveer 27626 
          (_etype652, _size649) = iprot.readListBegin()
27627 
          for _i653 in xrange(_size649):
27628 
            _elem654 = Order()
27629 
            _elem654.read(iprot)
27630 
            self.success.append(_elem654)
5713 rajveer 27631 
          iprot.readListEnd()
27632 
        else:
27633 
          iprot.skip(ftype)
27634 
      else:
27635 
        iprot.skip(ftype)
27636 
      iprot.readFieldEnd()
27637 
    iprot.readStructEnd()
27638 
 
27639 
  def write(self, oprot):
27640 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27641 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27642 
      return
27643 
    oprot.writeStructBegin('getOrdersCollectionAtStore_result')
27644 
    if self.success is not None:
27645 
      oprot.writeFieldBegin('success', TType.LIST, 0)
27646 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 27647 
      for iter655 in self.success:
27648 
        iter655.write(oprot)
5713 rajveer 27649 
      oprot.writeListEnd()
27650 
      oprot.writeFieldEnd()
27651 
    oprot.writeFieldStop()
27652 
    oprot.writeStructEnd()
27653 
 
27654 
  def validate(self):
27655 
    return
27656 
 
27657 
 
27658 
  def __repr__(self):
27659 
    L = ['%s=%r' % (key, value)
27660 
      for key, value in self.__dict__.iteritems()]
27661 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27662 
 
27663 
  def __eq__(self, other):
27664 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27665 
 
27666 
  def __ne__(self, other):
27667 
    return not (self == other)
27668 
 
5833 rajveer 27669 
class getOrderAttributeValue_args:
27670 
  """
27671 
  Attributes:
27672 
   - orderId
27673 
   - attributeName
27674 
  """
27675 
 
27676 
  thrift_spec = None
27677 
  def __init__(self, orderId=None, attributeName=None,):
27678 
    self.orderId = orderId
27679 
    self.attributeName = attributeName
27680 
 
27681 
  def read(self, iprot):
27682 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27683 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27684 
      return
27685 
    iprot.readStructBegin()
27686 
    while True:
27687 
      (fname, ftype, fid) = iprot.readFieldBegin()
27688 
      if ftype == TType.STOP:
27689 
        break
27690 
      if fid == 1:
27691 
        if ftype == TType.I64:
27692 
          self.orderId = iprot.readI64();
27693 
        else:
27694 
          iprot.skip(ftype)
27695 
      elif fid == -1:
27696 
        if ftype == TType.STRING:
27697 
          self.attributeName = iprot.readString();
27698 
        else:
27699 
          iprot.skip(ftype)
27700 
      else:
27701 
        iprot.skip(ftype)
27702 
      iprot.readFieldEnd()
27703 
    iprot.readStructEnd()
27704 
 
27705 
  def write(self, oprot):
27706 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27707 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27708 
      return
27709 
    oprot.writeStructBegin('getOrderAttributeValue_args')
27710 
    if self.attributeName is not None:
27711 
      oprot.writeFieldBegin('attributeName', TType.STRING, -1)
27712 
      oprot.writeString(self.attributeName)
27713 
      oprot.writeFieldEnd()
27714 
    if self.orderId is not None:
27715 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
27716 
      oprot.writeI64(self.orderId)
27717 
      oprot.writeFieldEnd()
27718 
    oprot.writeFieldStop()
27719 
    oprot.writeStructEnd()
27720 
 
27721 
  def validate(self):
27722 
    return
27723 
 
27724 
 
27725 
  def __repr__(self):
27726 
    L = ['%s=%r' % (key, value)
27727 
      for key, value in self.__dict__.iteritems()]
27728 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27729 
 
27730 
  def __eq__(self, other):
27731 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27732 
 
27733 
  def __ne__(self, other):
27734 
    return not (self == other)
27735 
 
27736 
class getOrderAttributeValue_result:
27737 
  """
27738 
  Attributes:
27739 
   - success
27740 
  """
27741 
 
27742 
  thrift_spec = (
27743 
    (0, TType.STRING, 'success', None, None, ), # 0
27744 
  )
27745 
 
27746 
  def __init__(self, success=None,):
27747 
    self.success = success
27748 
 
27749 
  def read(self, iprot):
27750 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27751 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27752 
      return
27753 
    iprot.readStructBegin()
27754 
    while True:
27755 
      (fname, ftype, fid) = iprot.readFieldBegin()
27756 
      if ftype == TType.STOP:
27757 
        break
27758 
      if fid == 0:
27759 
        if ftype == TType.STRING:
27760 
          self.success = iprot.readString();
27761 
        else:
27762 
          iprot.skip(ftype)
27763 
      else:
27764 
        iprot.skip(ftype)
27765 
      iprot.readFieldEnd()
27766 
    iprot.readStructEnd()
27767 
 
27768 
  def write(self, oprot):
27769 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27770 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27771 
      return
27772 
    oprot.writeStructBegin('getOrderAttributeValue_result')
27773 
    if self.success is not None:
27774 
      oprot.writeFieldBegin('success', TType.STRING, 0)
27775 
      oprot.writeString(self.success)
27776 
      oprot.writeFieldEnd()
27777 
    oprot.writeFieldStop()
27778 
    oprot.writeStructEnd()
27779 
 
27780 
  def validate(self):
27781 
    return
27782 
 
27783 
 
27784 
  def __repr__(self):
27785 
    L = ['%s=%r' % (key, value)
27786 
      for key, value in self.__dict__.iteritems()]
27787 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27788 
 
27789 
  def __eq__(self, other):
27790 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27791 
 
27792 
  def __ne__(self, other):
27793 
    return not (self == other)
27794 
 
6019 rajveer 27795 
class changeJacketNumber_args:
27796 
  """
27797 
  Attributes:
27798 
   - orderId
27799 
   - jacketNumber
27800 
  """
27801 
 
27802 
  thrift_spec = (
27803 
    None, # 0
27804 
    (1, TType.I64, 'orderId', None, None, ), # 1
27805 
    (2, TType.I64, 'jacketNumber', None, None, ), # 2
27806 
  )
27807 
 
27808 
  def __init__(self, orderId=None, jacketNumber=None,):
27809 
    self.orderId = orderId
27810 
    self.jacketNumber = jacketNumber
27811 
 
27812 
  def read(self, iprot):
27813 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27814 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27815 
      return
27816 
    iprot.readStructBegin()
27817 
    while True:
27818 
      (fname, ftype, fid) = iprot.readFieldBegin()
27819 
      if ftype == TType.STOP:
27820 
        break
27821 
      if fid == 1:
27822 
        if ftype == TType.I64:
27823 
          self.orderId = iprot.readI64();
27824 
        else:
27825 
          iprot.skip(ftype)
27826 
      elif fid == 2:
27827 
        if ftype == TType.I64:
27828 
          self.jacketNumber = iprot.readI64();
27829 
        else:
27830 
          iprot.skip(ftype)
27831 
      else:
27832 
        iprot.skip(ftype)
27833 
      iprot.readFieldEnd()
27834 
    iprot.readStructEnd()
27835 
 
27836 
  def write(self, oprot):
27837 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27838 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27839 
      return
27840 
    oprot.writeStructBegin('changeJacketNumber_args')
27841 
    if self.orderId is not None:
27842 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
27843 
      oprot.writeI64(self.orderId)
27844 
      oprot.writeFieldEnd()
27845 
    if self.jacketNumber is not None:
27846 
      oprot.writeFieldBegin('jacketNumber', TType.I64, 2)
27847 
      oprot.writeI64(self.jacketNumber)
27848 
      oprot.writeFieldEnd()
27849 
    oprot.writeFieldStop()
27850 
    oprot.writeStructEnd()
27851 
 
27852 
  def validate(self):
27853 
    return
27854 
 
27855 
 
27856 
  def __repr__(self):
27857 
    L = ['%s=%r' % (key, value)
27858 
      for key, value in self.__dict__.iteritems()]
27859 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27860 
 
27861 
  def __eq__(self, other):
27862 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27863 
 
27864 
  def __ne__(self, other):
27865 
    return not (self == other)
27866 
 
27867 
class changeJacketNumber_result:
27868 
  """
27869 
  Attributes:
27870 
   - success
27871 
  """
27872 
 
27873 
  thrift_spec = (
27874 
    (0, TType.BOOL, 'success', None, None, ), # 0
27875 
  )
27876 
 
27877 
  def __init__(self, success=None,):
27878 
    self.success = success
27879 
 
27880 
  def read(self, iprot):
27881 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27882 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27883 
      return
27884 
    iprot.readStructBegin()
27885 
    while True:
27886 
      (fname, ftype, fid) = iprot.readFieldBegin()
27887 
      if ftype == TType.STOP:
27888 
        break
27889 
      if fid == 0:
27890 
        if ftype == TType.BOOL:
27891 
          self.success = iprot.readBool();
27892 
        else:
27893 
          iprot.skip(ftype)
27894 
      else:
27895 
        iprot.skip(ftype)
27896 
      iprot.readFieldEnd()
27897 
    iprot.readStructEnd()
27898 
 
27899 
  def write(self, oprot):
27900 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27901 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27902 
      return
27903 
    oprot.writeStructBegin('changeJacketNumber_result')
27904 
    if self.success is not None:
27905 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
27906 
      oprot.writeBool(self.success)
27907 
      oprot.writeFieldEnd()
27908 
    oprot.writeFieldStop()
27909 
    oprot.writeStructEnd()
27910 
 
27911 
  def validate(self):
27912 
    return
27913 
 
27914 
 
27915 
  def __repr__(self):
27916 
    L = ['%s=%r' % (key, value)
27917 
      for key, value in self.__dict__.iteritems()]
27918 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27919 
 
27920 
  def __eq__(self, other):
27921 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27922 
 
27923 
  def __ne__(self, other):
27924 
    return not (self == other)
27925 
 
27926 
class markOrderAsRtoInTransit_args:
27927 
  """
27928 
  Attributes:
27929 
   - orderId
27930 
  """
27931 
 
27932 
  thrift_spec = (
27933 
    None, # 0
27934 
    (1, TType.I64, 'orderId', None, None, ), # 1
27935 
  )
27936 
 
27937 
  def __init__(self, orderId=None,):
27938 
    self.orderId = orderId
27939 
 
27940 
  def read(self, iprot):
27941 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27942 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27943 
      return
27944 
    iprot.readStructBegin()
27945 
    while True:
27946 
      (fname, ftype, fid) = iprot.readFieldBegin()
27947 
      if ftype == TType.STOP:
27948 
        break
27949 
      if fid == 1:
27950 
        if ftype == TType.I64:
27951 
          self.orderId = iprot.readI64();
27952 
        else:
27953 
          iprot.skip(ftype)
27954 
      else:
27955 
        iprot.skip(ftype)
27956 
      iprot.readFieldEnd()
27957 
    iprot.readStructEnd()
27958 
 
27959 
  def write(self, oprot):
27960 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27961 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27962 
      return
27963 
    oprot.writeStructBegin('markOrderAsRtoInTransit_args')
27964 
    if self.orderId is not None:
27965 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
27966 
      oprot.writeI64(self.orderId)
27967 
      oprot.writeFieldEnd()
27968 
    oprot.writeFieldStop()
27969 
    oprot.writeStructEnd()
27970 
 
27971 
  def validate(self):
27972 
    return
27973 
 
27974 
 
27975 
  def __repr__(self):
27976 
    L = ['%s=%r' % (key, value)
27977 
      for key, value in self.__dict__.iteritems()]
27978 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27979 
 
27980 
  def __eq__(self, other):
27981 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27982 
 
27983 
  def __ne__(self, other):
27984 
    return not (self == other)
27985 
 
27986 
class markOrderAsRtoInTransit_result:
27987 
  """
27988 
  Attributes:
27989 
   - success
27990 
  """
27991 
 
27992 
  thrift_spec = (
27993 
    (0, TType.BOOL, 'success', None, None, ), # 0
27994 
  )
27995 
 
27996 
  def __init__(self, success=None,):
27997 
    self.success = success
27998 
 
27999 
  def read(self, iprot):
28000 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28001 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28002 
      return
28003 
    iprot.readStructBegin()
28004 
    while True:
28005 
      (fname, ftype, fid) = iprot.readFieldBegin()
28006 
      if ftype == TType.STOP:
28007 
        break
28008 
      if fid == 0:
28009 
        if ftype == TType.BOOL:
28010 
          self.success = iprot.readBool();
28011 
        else:
28012 
          iprot.skip(ftype)
28013 
      else:
28014 
        iprot.skip(ftype)
28015 
      iprot.readFieldEnd()
28016 
    iprot.readStructEnd()
28017 
 
28018 
  def write(self, oprot):
28019 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28020 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28021 
      return
28022 
    oprot.writeStructBegin('markOrderAsRtoInTransit_result')
28023 
    if self.success is not None:
28024 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
28025 
      oprot.writeBool(self.success)
28026 
      oprot.writeFieldEnd()
28027 
    oprot.writeFieldStop()
28028 
    oprot.writeStructEnd()
28029 
 
28030 
  def validate(self):
28031 
    return
28032 
 
28033 
 
28034 
  def __repr__(self):
28035 
    L = ['%s=%r' % (key, value)
28036 
      for key, value in self.__dict__.iteritems()]
28037 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28038 
 
28039 
  def __eq__(self, other):
28040 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28041 
 
28042 
  def __ne__(self, other):
28043 
    return not (self == other)
28044 
 
5593 mandeep.dh 28045 
class acceptOrderForItem_args:
28046 
  """
28047 
  Attributes:
28048 
   - itemId
28049 
   - quantity
28050 
   - fulfilmentWarehouseId
28051 
   - billingWarehouseId
28052 
  """
28053 
 
28054 
  thrift_spec = (
28055 
    None, # 0
28056 
    (1, TType.I64, 'itemId', None, None, ), # 1
28057 
    (2, TType.I64, 'quantity', None, None, ), # 2
28058 
    (3, TType.I64, 'fulfilmentWarehouseId', None, None, ), # 3
28059 
    (4, TType.I64, 'billingWarehouseId', None, None, ), # 4
28060 
  )
28061 
 
28062 
  def __init__(self, itemId=None, quantity=None, fulfilmentWarehouseId=None, billingWarehouseId=None,):
28063 
    self.itemId = itemId
28064 
    self.quantity = quantity
28065 
    self.fulfilmentWarehouseId = fulfilmentWarehouseId
28066 
    self.billingWarehouseId = billingWarehouseId
28067 
 
28068 
  def read(self, iprot):
28069 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28070 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28071 
      return
28072 
    iprot.readStructBegin()
28073 
    while True:
28074 
      (fname, ftype, fid) = iprot.readFieldBegin()
28075 
      if ftype == TType.STOP:
28076 
        break
28077 
      if fid == 1:
28078 
        if ftype == TType.I64:
28079 
          self.itemId = iprot.readI64();
28080 
        else:
28081 
          iprot.skip(ftype)
28082 
      elif fid == 2:
28083 
        if ftype == TType.I64:
28084 
          self.quantity = iprot.readI64();
28085 
        else:
28086 
          iprot.skip(ftype)
28087 
      elif fid == 3:
28088 
        if ftype == TType.I64:
28089 
          self.fulfilmentWarehouseId = iprot.readI64();
28090 
        else:
28091 
          iprot.skip(ftype)
28092 
      elif fid == 4:
28093 
        if ftype == TType.I64:
28094 
          self.billingWarehouseId = iprot.readI64();
28095 
        else:
28096 
          iprot.skip(ftype)
28097 
      else:
28098 
        iprot.skip(ftype)
28099 
      iprot.readFieldEnd()
28100 
    iprot.readStructEnd()
28101 
 
28102 
  def write(self, oprot):
28103 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28104 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28105 
      return
28106 
    oprot.writeStructBegin('acceptOrderForItem_args')
28107 
    if self.itemId is not None:
28108 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
28109 
      oprot.writeI64(self.itemId)
28110 
      oprot.writeFieldEnd()
28111 
    if self.quantity is not None:
28112 
      oprot.writeFieldBegin('quantity', TType.I64, 2)
28113 
      oprot.writeI64(self.quantity)
28114 
      oprot.writeFieldEnd()
28115 
    if self.fulfilmentWarehouseId is not None:
28116 
      oprot.writeFieldBegin('fulfilmentWarehouseId', TType.I64, 3)
28117 
      oprot.writeI64(self.fulfilmentWarehouseId)
28118 
      oprot.writeFieldEnd()
28119 
    if self.billingWarehouseId is not None:
28120 
      oprot.writeFieldBegin('billingWarehouseId', TType.I64, 4)
28121 
      oprot.writeI64(self.billingWarehouseId)
28122 
      oprot.writeFieldEnd()
28123 
    oprot.writeFieldStop()
28124 
    oprot.writeStructEnd()
28125 
 
28126 
  def validate(self):
28127 
    return
28128 
 
28129 
 
28130 
  def __repr__(self):
28131 
    L = ['%s=%r' % (key, value)
28132 
      for key, value in self.__dict__.iteritems()]
28133 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28134 
 
28135 
  def __eq__(self, other):
28136 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28137 
 
28138 
  def __ne__(self, other):
28139 
    return not (self == other)
28140 
 
28141 
class acceptOrderForItem_result:
28142 
 
28143 
  thrift_spec = (
28144 
  )
28145 
 
28146 
  def read(self, iprot):
28147 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28148 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28149 
      return
28150 
    iprot.readStructBegin()
28151 
    while True:
28152 
      (fname, ftype, fid) = iprot.readFieldBegin()
28153 
      if ftype == TType.STOP:
28154 
        break
28155 
      else:
28156 
        iprot.skip(ftype)
28157 
      iprot.readFieldEnd()
28158 
    iprot.readStructEnd()
28159 
 
28160 
  def write(self, oprot):
28161 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28162 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28163 
      return
28164 
    oprot.writeStructBegin('acceptOrderForItem_result')
28165 
    oprot.writeFieldStop()
28166 
    oprot.writeStructEnd()
28167 
 
28168 
  def validate(self):
28169 
    return
28170 
 
28171 
 
28172 
  def __repr__(self):
28173 
    L = ['%s=%r' % (key, value)
28174 
      for key, value in self.__dict__.iteritems()]
28175 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28176 
 
28177 
  def __eq__(self, other):
28178 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28179 
 
28180 
  def __ne__(self, other):
28181 
    return not (self == other)
6000 mandeep.dh 28182 
 
28183 
class createRechargeOrder_args:
28184 
  """
28185 
  Attributes:
28186 
   - rechargeOrder
28187 
  """
28188 
 
28189 
  thrift_spec = (
28190 
    None, # 0
28191 
    (1, TType.STRUCT, 'rechargeOrder', (RechargeOrder, RechargeOrder.thrift_spec), None, ), # 1
28192 
  )
28193 
 
28194 
  def __init__(self, rechargeOrder=None,):
28195 
    self.rechargeOrder = rechargeOrder
28196 
 
28197 
  def read(self, iprot):
28198 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28199 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28200 
      return
28201 
    iprot.readStructBegin()
28202 
    while True:
28203 
      (fname, ftype, fid) = iprot.readFieldBegin()
28204 
      if ftype == TType.STOP:
28205 
        break
28206 
      if fid == 1:
28207 
        if ftype == TType.STRUCT:
28208 
          self.rechargeOrder = RechargeOrder()
28209 
          self.rechargeOrder.read(iprot)
28210 
        else:
28211 
          iprot.skip(ftype)
28212 
      else:
28213 
        iprot.skip(ftype)
28214 
      iprot.readFieldEnd()
28215 
    iprot.readStructEnd()
28216 
 
28217 
  def write(self, oprot):
28218 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28219 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28220 
      return
28221 
    oprot.writeStructBegin('createRechargeOrder_args')
28222 
    if self.rechargeOrder is not None:
28223 
      oprot.writeFieldBegin('rechargeOrder', TType.STRUCT, 1)
28224 
      self.rechargeOrder.write(oprot)
28225 
      oprot.writeFieldEnd()
28226 
    oprot.writeFieldStop()
28227 
    oprot.writeStructEnd()
28228 
 
28229 
  def validate(self):
28230 
    return
28231 
 
28232 
 
28233 
  def __repr__(self):
28234 
    L = ['%s=%r' % (key, value)
28235 
      for key, value in self.__dict__.iteritems()]
28236 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28237 
 
28238 
  def __eq__(self, other):
28239 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28240 
 
28241 
  def __ne__(self, other):
28242 
    return not (self == other)
28243 
 
28244 
class createRechargeOrder_result:
28245 
  """
28246 
  Attributes:
28247 
   - success
28248 
   - ex
28249 
  """
28250 
 
28251 
  thrift_spec = (
28252 
    (0, TType.STRUCT, 'success', (RechargeOrder, RechargeOrder.thrift_spec), None, ), # 0
28253 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
28254 
  )
28255 
 
28256 
  def __init__(self, success=None, ex=None,):
28257 
    self.success = success
28258 
    self.ex = ex
28259 
 
28260 
  def read(self, iprot):
28261 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28262 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28263 
      return
28264 
    iprot.readStructBegin()
28265 
    while True:
28266 
      (fname, ftype, fid) = iprot.readFieldBegin()
28267 
      if ftype == TType.STOP:
28268 
        break
28269 
      if fid == 0:
28270 
        if ftype == TType.STRUCT:
28271 
          self.success = RechargeOrder()
28272 
          self.success.read(iprot)
28273 
        else:
28274 
          iprot.skip(ftype)
28275 
      elif fid == 1:
28276 
        if ftype == TType.STRUCT:
28277 
          self.ex = TransactionServiceException()
28278 
          self.ex.read(iprot)
28279 
        else:
28280 
          iprot.skip(ftype)
28281 
      else:
28282 
        iprot.skip(ftype)
28283 
      iprot.readFieldEnd()
28284 
    iprot.readStructEnd()
28285 
 
28286 
  def write(self, oprot):
28287 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28288 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28289 
      return
28290 
    oprot.writeStructBegin('createRechargeOrder_result')
28291 
    if self.success is not None:
28292 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
28293 
      self.success.write(oprot)
28294 
      oprot.writeFieldEnd()
28295 
    if self.ex is not None:
28296 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
28297 
      self.ex.write(oprot)
28298 
      oprot.writeFieldEnd()
28299 
    oprot.writeFieldStop()
28300 
    oprot.writeStructEnd()
28301 
 
28302 
  def validate(self):
28303 
    return
28304 
 
28305 
 
28306 
  def __repr__(self):
28307 
    L = ['%s=%r' % (key, value)
28308 
      for key, value in self.__dict__.iteritems()]
28309 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28310 
 
28311 
  def __eq__(self, other):
28312 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28313 
 
28314 
  def __ne__(self, other):
28315 
    return not (self == other)
28316 
 
6031 rajveer 28317 
class getRechargeOrder_args:
28318 
  """
28319 
  Attributes:
28320 
   - rechargeRrderId
28321 
  """
28322 
 
28323 
  thrift_spec = (
28324 
    None, # 0
28325 
    (1, TType.I64, 'rechargeRrderId', None, None, ), # 1
28326 
  )
28327 
 
28328 
  def __init__(self, rechargeRrderId=None,):
28329 
    self.rechargeRrderId = rechargeRrderId
28330 
 
28331 
  def read(self, iprot):
28332 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28333 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28334 
      return
28335 
    iprot.readStructBegin()
28336 
    while True:
28337 
      (fname, ftype, fid) = iprot.readFieldBegin()
28338 
      if ftype == TType.STOP:
28339 
        break
28340 
      if fid == 1:
28341 
        if ftype == TType.I64:
28342 
          self.rechargeRrderId = iprot.readI64();
28343 
        else:
28344 
          iprot.skip(ftype)
28345 
      else:
28346 
        iprot.skip(ftype)
28347 
      iprot.readFieldEnd()
28348 
    iprot.readStructEnd()
28349 
 
28350 
  def write(self, oprot):
28351 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28352 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28353 
      return
28354 
    oprot.writeStructBegin('getRechargeOrder_args')
28355 
    if self.rechargeRrderId is not None:
28356 
      oprot.writeFieldBegin('rechargeRrderId', TType.I64, 1)
28357 
      oprot.writeI64(self.rechargeRrderId)
28358 
      oprot.writeFieldEnd()
28359 
    oprot.writeFieldStop()
28360 
    oprot.writeStructEnd()
28361 
 
28362 
  def validate(self):
28363 
    return
28364 
 
28365 
 
28366 
  def __repr__(self):
28367 
    L = ['%s=%r' % (key, value)
28368 
      for key, value in self.__dict__.iteritems()]
28369 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28370 
 
28371 
  def __eq__(self, other):
28372 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28373 
 
28374 
  def __ne__(self, other):
28375 
    return not (self == other)
28376 
 
28377 
class getRechargeOrder_result:
28378 
  """
28379 
  Attributes:
28380 
   - success
28381 
   - ex
28382 
  """
28383 
 
28384 
  thrift_spec = (
28385 
    (0, TType.STRUCT, 'success', (RechargeOrder, RechargeOrder.thrift_spec), None, ), # 0
28386 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
28387 
  )
28388 
 
28389 
  def __init__(self, success=None, ex=None,):
28390 
    self.success = success
28391 
    self.ex = ex
28392 
 
28393 
  def read(self, iprot):
28394 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28395 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28396 
      return
28397 
    iprot.readStructBegin()
28398 
    while True:
28399 
      (fname, ftype, fid) = iprot.readFieldBegin()
28400 
      if ftype == TType.STOP:
28401 
        break
28402 
      if fid == 0:
28403 
        if ftype == TType.STRUCT:
28404 
          self.success = RechargeOrder()
28405 
          self.success.read(iprot)
28406 
        else:
28407 
          iprot.skip(ftype)
28408 
      elif fid == 1:
28409 
        if ftype == TType.STRUCT:
28410 
          self.ex = TransactionServiceException()
28411 
          self.ex.read(iprot)
28412 
        else:
28413 
          iprot.skip(ftype)
28414 
      else:
28415 
        iprot.skip(ftype)
28416 
      iprot.readFieldEnd()
28417 
    iprot.readStructEnd()
28418 
 
28419 
  def write(self, oprot):
28420 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28421 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28422 
      return
28423 
    oprot.writeStructBegin('getRechargeOrder_result')
28424 
    if self.success is not None:
28425 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
28426 
      self.success.write(oprot)
28427 
      oprot.writeFieldEnd()
28428 
    if self.ex is not None:
28429 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
28430 
      self.ex.write(oprot)
28431 
      oprot.writeFieldEnd()
28432 
    oprot.writeFieldStop()
28433 
    oprot.writeStructEnd()
28434 
 
28435 
  def validate(self):
28436 
    return
28437 
 
28438 
 
28439 
  def __repr__(self):
28440 
    L = ['%s=%r' % (key, value)
28441 
      for key, value in self.__dict__.iteritems()]
28442 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28443 
 
28444 
  def __eq__(self, other):
28445 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28446 
 
28447 
  def __ne__(self, other):
28448 
    return not (self == other)
28449 
 
28450 
class getRechargeOrders_args:
28451 
  """
28452 
  Attributes:
28453 
   - userId
28454 
  """
28455 
 
28456 
  thrift_spec = (
28457 
    None, # 0
28458 
    (1, TType.I64, 'userId', None, None, ), # 1
28459 
  )
28460 
 
28461 
  def __init__(self, userId=None,):
28462 
    self.userId = userId
28463 
 
28464 
  def read(self, iprot):
28465 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28466 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28467 
      return
28468 
    iprot.readStructBegin()
28469 
    while True:
28470 
      (fname, ftype, fid) = iprot.readFieldBegin()
28471 
      if ftype == TType.STOP:
28472 
        break
28473 
      if fid == 1:
28474 
        if ftype == TType.I64:
28475 
          self.userId = iprot.readI64();
28476 
        else:
28477 
          iprot.skip(ftype)
28478 
      else:
28479 
        iprot.skip(ftype)
28480 
      iprot.readFieldEnd()
28481 
    iprot.readStructEnd()
28482 
 
28483 
  def write(self, oprot):
28484 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28485 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28486 
      return
28487 
    oprot.writeStructBegin('getRechargeOrders_args')
28488 
    if self.userId is not None:
28489 
      oprot.writeFieldBegin('userId', TType.I64, 1)
28490 
      oprot.writeI64(self.userId)
28491 
      oprot.writeFieldEnd()
28492 
    oprot.writeFieldStop()
28493 
    oprot.writeStructEnd()
28494 
 
28495 
  def validate(self):
28496 
    return
28497 
 
28498 
 
28499 
  def __repr__(self):
28500 
    L = ['%s=%r' % (key, value)
28501 
      for key, value in self.__dict__.iteritems()]
28502 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28503 
 
28504 
  def __eq__(self, other):
28505 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28506 
 
28507 
  def __ne__(self, other):
28508 
    return not (self == other)
28509 
 
28510 
class getRechargeOrders_result:
28511 
  """
28512 
  Attributes:
28513 
   - success
28514 
  """
28515 
 
28516 
  thrift_spec = (
28517 
    (0, TType.LIST, 'success', (TType.STRUCT,(RechargeOrder, RechargeOrder.thrift_spec)), None, ), # 0
28518 
  )
28519 
 
28520 
  def __init__(self, success=None,):
28521 
    self.success = success
28522 
 
28523 
  def read(self, iprot):
28524 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28525 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28526 
      return
28527 
    iprot.readStructBegin()
28528 
    while True:
28529 
      (fname, ftype, fid) = iprot.readFieldBegin()
28530 
      if ftype == TType.STOP:
28531 
        break
28532 
      if fid == 0:
28533 
        if ftype == TType.LIST:
28534 
          self.success = []
6188 rajveer 28535 
          (_etype659, _size656) = iprot.readListBegin()
28536 
          for _i660 in xrange(_size656):
28537 
            _elem661 = RechargeOrder()
28538 
            _elem661.read(iprot)
28539 
            self.success.append(_elem661)
6031 rajveer 28540 
          iprot.readListEnd()
28541 
        else:
28542 
          iprot.skip(ftype)
28543 
      else:
28544 
        iprot.skip(ftype)
28545 
      iprot.readFieldEnd()
28546 
    iprot.readStructEnd()
28547 
 
28548 
  def write(self, oprot):
28549 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28550 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28551 
      return
28552 
    oprot.writeStructBegin('getRechargeOrders_result')
28553 
    if self.success is not None:
28554 
      oprot.writeFieldBegin('success', TType.LIST, 0)
28555 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 28556 
      for iter662 in self.success:
28557 
        iter662.write(oprot)
6031 rajveer 28558 
      oprot.writeListEnd()
28559 
      oprot.writeFieldEnd()
28560 
    oprot.writeFieldStop()
28561 
    oprot.writeStructEnd()
28562 
 
28563 
  def validate(self):
28564 
    return
28565 
 
28566 
 
28567 
  def __repr__(self):
28568 
    L = ['%s=%r' % (key, value)
28569 
      for key, value in self.__dict__.iteritems()]
28570 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28571 
 
28572 
  def __eq__(self, other):
28573 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28574 
 
28575 
  def __ne__(self, other):
28576 
    return not (self == other)
28577 
 
6000 mandeep.dh 28578 
class updateRechargeOrderStatus_args:
28579 
  """
28580 
  Attributes:
28581 
   - rechargeOrderId
28582 
   - rechargeOrderStatus
28583 
  """
28584 
 
28585 
  thrift_spec = (
28586 
    None, # 0
28587 
    (1, TType.I64, 'rechargeOrderId', None, None, ), # 1
28588 
    (2, TType.I32, 'rechargeOrderStatus', None, None, ), # 2
28589 
  )
28590 
 
28591 
  def __init__(self, rechargeOrderId=None, rechargeOrderStatus=None,):
28592 
    self.rechargeOrderId = rechargeOrderId
28593 
    self.rechargeOrderStatus = rechargeOrderStatus
28594 
 
28595 
  def read(self, iprot):
28596 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28597 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28598 
      return
28599 
    iprot.readStructBegin()
28600 
    while True:
28601 
      (fname, ftype, fid) = iprot.readFieldBegin()
28602 
      if ftype == TType.STOP:
28603 
        break
28604 
      if fid == 1:
28605 
        if ftype == TType.I64:
28606 
          self.rechargeOrderId = iprot.readI64();
28607 
        else:
28608 
          iprot.skip(ftype)
28609 
      elif fid == 2:
28610 
        if ftype == TType.I32:
28611 
          self.rechargeOrderStatus = iprot.readI32();
28612 
        else:
28613 
          iprot.skip(ftype)
28614 
      else:
28615 
        iprot.skip(ftype)
28616 
      iprot.readFieldEnd()
28617 
    iprot.readStructEnd()
28618 
 
28619 
  def write(self, oprot):
28620 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28621 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28622 
      return
28623 
    oprot.writeStructBegin('updateRechargeOrderStatus_args')
28624 
    if self.rechargeOrderId is not None:
28625 
      oprot.writeFieldBegin('rechargeOrderId', TType.I64, 1)
28626 
      oprot.writeI64(self.rechargeOrderId)
28627 
      oprot.writeFieldEnd()
28628 
    if self.rechargeOrderStatus is not None:
28629 
      oprot.writeFieldBegin('rechargeOrderStatus', TType.I32, 2)
28630 
      oprot.writeI32(self.rechargeOrderStatus)
28631 
      oprot.writeFieldEnd()
28632 
    oprot.writeFieldStop()
28633 
    oprot.writeStructEnd()
28634 
 
28635 
  def validate(self):
28636 
    return
28637 
 
28638 
 
28639 
  def __repr__(self):
28640 
    L = ['%s=%r' % (key, value)
28641 
      for key, value in self.__dict__.iteritems()]
28642 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28643 
 
28644 
  def __eq__(self, other):
28645 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28646 
 
28647 
  def __ne__(self, other):
28648 
    return not (self == other)
28649 
 
28650 
class updateRechargeOrderStatus_result:
28651 
  """
28652 
  Attributes:
6031 rajveer 28653 
   - success
6000 mandeep.dh 28654 
   - ex
28655 
  """
28656 
 
28657 
  thrift_spec = (
6031 rajveer 28658 
    (0, TType.BOOL, 'success', None, None, ), # 0
6000 mandeep.dh 28659 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
28660 
  )
28661 
 
6031 rajveer 28662 
  def __init__(self, success=None, ex=None,):
28663 
    self.success = success
6000 mandeep.dh 28664 
    self.ex = ex
28665 
 
28666 
  def read(self, iprot):
28667 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28668 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28669 
      return
28670 
    iprot.readStructBegin()
28671 
    while True:
28672 
      (fname, ftype, fid) = iprot.readFieldBegin()
28673 
      if ftype == TType.STOP:
28674 
        break
6031 rajveer 28675 
      if fid == 0:
28676 
        if ftype == TType.BOOL:
28677 
          self.success = iprot.readBool();
28678 
        else:
28679 
          iprot.skip(ftype)
28680 
      elif fid == 1:
6000 mandeep.dh 28681 
        if ftype == TType.STRUCT:
28682 
          self.ex = TransactionServiceException()
28683 
          self.ex.read(iprot)
28684 
        else:
28685 
          iprot.skip(ftype)
28686 
      else:
28687 
        iprot.skip(ftype)
28688 
      iprot.readFieldEnd()
28689 
    iprot.readStructEnd()
28690 
 
28691 
  def write(self, oprot):
28692 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28693 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28694 
      return
28695 
    oprot.writeStructBegin('updateRechargeOrderStatus_result')
6031 rajveer 28696 
    if self.success is not None:
28697 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
28698 
      oprot.writeBool(self.success)
28699 
      oprot.writeFieldEnd()
6000 mandeep.dh 28700 
    if self.ex is not None:
28701 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
28702 
      self.ex.write(oprot)
28703 
      oprot.writeFieldEnd()
28704 
    oprot.writeFieldStop()
28705 
    oprot.writeStructEnd()
28706 
 
28707 
  def validate(self):
28708 
    return
28709 
 
28710 
 
28711 
  def __repr__(self):
28712 
    L = ['%s=%r' % (key, value)
28713 
      for key, value in self.__dict__.iteritems()]
28714 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28715 
 
28716 
  def __eq__(self, other):
28717 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28718 
 
28719 
  def __ne__(self, other):
28720 
    return not (self == other)
28721 
 
28722 
class activateRechargeTxn_args:
28723 
  """
28724 
  Attributes:
6031 rajveer 28725 
   - rechargeOrderId
6000 mandeep.dh 28726 
  """
28727 
 
28728 
  thrift_spec = (
28729 
    None, # 0
6031 rajveer 28730 
    (1, TType.I64, 'rechargeOrderId', None, None, ), # 1
6000 mandeep.dh 28731 
  )
28732 
 
6031 rajveer 28733 
  def __init__(self, rechargeOrderId=None,):
28734 
    self.rechargeOrderId = rechargeOrderId
6000 mandeep.dh 28735 
 
28736 
  def read(self, iprot):
28737 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28738 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28739 
      return
28740 
    iprot.readStructBegin()
28741 
    while True:
28742 
      (fname, ftype, fid) = iprot.readFieldBegin()
28743 
      if ftype == TType.STOP:
28744 
        break
28745 
      if fid == 1:
6031 rajveer 28746 
        if ftype == TType.I64:
28747 
          self.rechargeOrderId = iprot.readI64();
6000 mandeep.dh 28748 
        else:
28749 
          iprot.skip(ftype)
28750 
      else:
28751 
        iprot.skip(ftype)
28752 
      iprot.readFieldEnd()
28753 
    iprot.readStructEnd()
28754 
 
28755 
  def write(self, oprot):
28756 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28757 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28758 
      return
28759 
    oprot.writeStructBegin('activateRechargeTxn_args')
6031 rajveer 28760 
    if self.rechargeOrderId is not None:
28761 
      oprot.writeFieldBegin('rechargeOrderId', TType.I64, 1)
28762 
      oprot.writeI64(self.rechargeOrderId)
6000 mandeep.dh 28763 
      oprot.writeFieldEnd()
28764 
    oprot.writeFieldStop()
28765 
    oprot.writeStructEnd()
28766 
 
28767 
  def validate(self):
28768 
    return
28769 
 
28770 
 
28771 
  def __repr__(self):
28772 
    L = ['%s=%r' % (key, value)
28773 
      for key, value in self.__dict__.iteritems()]
28774 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28775 
 
28776 
  def __eq__(self, other):
28777 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28778 
 
28779 
  def __ne__(self, other):
28780 
    return not (self == other)
28781 
 
28782 
class activateRechargeTxn_result:
28783 
  """
28784 
  Attributes:
28785 
   - success
28786 
   - ex
28787 
  """
28788 
 
28789 
  thrift_spec = (
6031 rajveer 28790 
    (0, TType.BOOL, 'success', None, None, ), # 0
6000 mandeep.dh 28791 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
28792 
  )
28793 
 
28794 
  def __init__(self, success=None, ex=None,):
28795 
    self.success = success
28796 
    self.ex = ex
28797 
 
28798 
  def read(self, iprot):
28799 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28800 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28801 
      return
28802 
    iprot.readStructBegin()
28803 
    while True:
28804 
      (fname, ftype, fid) = iprot.readFieldBegin()
28805 
      if ftype == TType.STOP:
28806 
        break
28807 
      if fid == 0:
6031 rajveer 28808 
        if ftype == TType.BOOL:
28809 
          self.success = iprot.readBool();
6000 mandeep.dh 28810 
        else:
28811 
          iprot.skip(ftype)
28812 
      elif fid == 1:
28813 
        if ftype == TType.STRUCT:
28814 
          self.ex = TransactionServiceException()
28815 
          self.ex.read(iprot)
28816 
        else:
28817 
          iprot.skip(ftype)
28818 
      else:
28819 
        iprot.skip(ftype)
28820 
      iprot.readFieldEnd()
28821 
    iprot.readStructEnd()
28822 
 
28823 
  def write(self, oprot):
28824 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28825 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28826 
      return
28827 
    oprot.writeStructBegin('activateRechargeTxn_result')
28828 
    if self.success is not None:
6031 rajveer 28829 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
28830 
      oprot.writeBool(self.success)
6000 mandeep.dh 28831 
      oprot.writeFieldEnd()
28832 
    if self.ex is not None:
28833 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
28834 
      self.ex.write(oprot)
28835 
      oprot.writeFieldEnd()
28836 
    oprot.writeFieldStop()
28837 
    oprot.writeStructEnd()
28838 
 
28839 
  def validate(self):
28840 
    return
28841 
 
28842 
 
28843 
  def __repr__(self):
28844 
    L = ['%s=%r' % (key, value)
28845 
      for key, value in self.__dict__.iteritems()]
28846 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28847 
 
28848 
  def __eq__(self, other):
28849 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28850 
 
28851 
  def __ne__(self, other):
28852 
    return not (self == other)
28853 
 
6031 rajveer 28854 
class getUserWallet_args:
6000 mandeep.dh 28855 
  """
28856 
  Attributes:
6031 rajveer 28857 
   - userId
6000 mandeep.dh 28858 
  """
28859 
 
28860 
  thrift_spec = (
28861 
    None, # 0
6031 rajveer 28862 
    (1, TType.I64, 'userId', None, None, ), # 1
6000 mandeep.dh 28863 
  )
28864 
 
6031 rajveer 28865 
  def __init__(self, userId=None,):
28866 
    self.userId = userId
6000 mandeep.dh 28867 
 
28868 
  def read(self, iprot):
28869 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28870 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28871 
      return
28872 
    iprot.readStructBegin()
28873 
    while True:
28874 
      (fname, ftype, fid) = iprot.readFieldBegin()
28875 
      if ftype == TType.STOP:
28876 
        break
28877 
      if fid == 1:
28878 
        if ftype == TType.I64:
6031 rajveer 28879 
          self.userId = iprot.readI64();
6000 mandeep.dh 28880 
        else:
28881 
          iprot.skip(ftype)
28882 
      else:
28883 
        iprot.skip(ftype)
28884 
      iprot.readFieldEnd()
28885 
    iprot.readStructEnd()
28886 
 
28887 
  def write(self, oprot):
28888 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28889 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28890 
      return
6031 rajveer 28891 
    oprot.writeStructBegin('getUserWallet_args')
28892 
    if self.userId is not None:
28893 
      oprot.writeFieldBegin('userId', TType.I64, 1)
28894 
      oprot.writeI64(self.userId)
6000 mandeep.dh 28895 
      oprot.writeFieldEnd()
28896 
    oprot.writeFieldStop()
28897 
    oprot.writeStructEnd()
28898 
 
28899 
  def validate(self):
28900 
    return
28901 
 
28902 
 
28903 
  def __repr__(self):
28904 
    L = ['%s=%r' % (key, value)
28905 
      for key, value in self.__dict__.iteritems()]
28906 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28907 
 
28908 
  def __eq__(self, other):
28909 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28910 
 
28911 
  def __ne__(self, other):
28912 
    return not (self == other)
28913 
 
6031 rajveer 28914 
class getUserWallet_result:
6000 mandeep.dh 28915 
  """
28916 
  Attributes:
28917 
   - success
28918 
  """
28919 
 
28920 
  thrift_spec = (
6031 rajveer 28921 
    (0, TType.STRUCT, 'success', (UserWallet, UserWallet.thrift_spec), None, ), # 0
6000 mandeep.dh 28922 
  )
28923 
 
28924 
  def __init__(self, success=None,):
28925 
    self.success = success
28926 
 
28927 
  def read(self, iprot):
28928 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28929 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28930 
      return
28931 
    iprot.readStructBegin()
28932 
    while True:
28933 
      (fname, ftype, fid) = iprot.readFieldBegin()
28934 
      if ftype == TType.STOP:
28935 
        break
28936 
      if fid == 0:
6031 rajveer 28937 
        if ftype == TType.STRUCT:
28938 
          self.success = UserWallet()
28939 
          self.success.read(iprot)
6000 mandeep.dh 28940 
        else:
28941 
          iprot.skip(ftype)
28942 
      else:
28943 
        iprot.skip(ftype)
28944 
      iprot.readFieldEnd()
28945 
    iprot.readStructEnd()
28946 
 
28947 
  def write(self, oprot):
28948 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28949 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28950 
      return
6031 rajveer 28951 
    oprot.writeStructBegin('getUserWallet_result')
6000 mandeep.dh 28952 
    if self.success is not None:
6031 rajveer 28953 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
28954 
      self.success.write(oprot)
6000 mandeep.dh 28955 
      oprot.writeFieldEnd()
28956 
    oprot.writeFieldStop()
28957 
    oprot.writeStructEnd()
28958 
 
28959 
  def validate(self):
28960 
    return
28961 
 
28962 
 
28963 
  def __repr__(self):
28964 
    L = ['%s=%r' % (key, value)
28965 
      for key, value in self.__dict__.iteritems()]
28966 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28967 
 
28968 
  def __eq__(self, other):
28969 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28970 
 
28971 
  def __ne__(self, other):
28972 
    return not (self == other)
28973 
 
6031 rajveer 28974 
class getUserWalletHistory_args:
6000 mandeep.dh 28975 
  """
28976 
  Attributes:
6031 rajveer 28977 
   - userId
6000 mandeep.dh 28978 
  """
28979 
 
28980 
  thrift_spec = (
28981 
    None, # 0
6031 rajveer 28982 
    (1, TType.I64, 'userId', None, None, ), # 1
6000 mandeep.dh 28983 
  )
28984 
 
6031 rajveer 28985 
  def __init__(self, userId=None,):
28986 
    self.userId = userId
6000 mandeep.dh 28987 
 
28988 
  def read(self, iprot):
28989 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28990 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28991 
      return
28992 
    iprot.readStructBegin()
28993 
    while True:
28994 
      (fname, ftype, fid) = iprot.readFieldBegin()
28995 
      if ftype == TType.STOP:
28996 
        break
28997 
      if fid == 1:
28998 
        if ftype == TType.I64:
6031 rajveer 28999 
          self.userId = iprot.readI64();
6000 mandeep.dh 29000 
        else:
29001 
          iprot.skip(ftype)
29002 
      else:
29003 
        iprot.skip(ftype)
29004 
      iprot.readFieldEnd()
29005 
    iprot.readStructEnd()
29006 
 
29007 
  def write(self, oprot):
29008 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
29009 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
29010 
      return
6031 rajveer 29011 
    oprot.writeStructBegin('getUserWalletHistory_args')
29012 
    if self.userId is not None:
29013 
      oprot.writeFieldBegin('userId', TType.I64, 1)
29014 
      oprot.writeI64(self.userId)
6000 mandeep.dh 29015 
      oprot.writeFieldEnd()
29016 
    oprot.writeFieldStop()
29017 
    oprot.writeStructEnd()
29018 
 
29019 
  def validate(self):
29020 
    return
29021 
 
29022 
 
29023 
  def __repr__(self):
29024 
    L = ['%s=%r' % (key, value)
29025 
      for key, value in self.__dict__.iteritems()]
29026 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
29027 
 
29028 
  def __eq__(self, other):
29029 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
29030 
 
29031 
  def __ne__(self, other):
29032 
    return not (self == other)
29033 
 
6031 rajveer 29034 
class getUserWalletHistory_result:
6000 mandeep.dh 29035 
  """
29036 
  Attributes:
29037 
   - success
29038 
  """
29039 
 
29040 
  thrift_spec = (
6031 rajveer 29041 
    (0, TType.LIST, 'success', (TType.STRUCT,(UserWalletHistory, UserWalletHistory.thrift_spec)), None, ), # 0
6000 mandeep.dh 29042 
  )
29043 
 
29044 
  def __init__(self, success=None,):
29045 
    self.success = success
29046 
 
29047 
  def read(self, iprot):
29048 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
29049 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
29050 
      return
29051 
    iprot.readStructBegin()
29052 
    while True:
29053 
      (fname, ftype, fid) = iprot.readFieldBegin()
29054 
      if ftype == TType.STOP:
29055 
        break
29056 
      if fid == 0:
29057 
        if ftype == TType.LIST:
29058 
          self.success = []
6188 rajveer 29059 
          (_etype666, _size663) = iprot.readListBegin()
29060 
          for _i667 in xrange(_size663):
29061 
            _elem668 = UserWalletHistory()
29062 
            _elem668.read(iprot)
29063 
            self.success.append(_elem668)
6000 mandeep.dh 29064 
          iprot.readListEnd()
29065 
        else:
29066 
          iprot.skip(ftype)
29067 
      else:
29068 
        iprot.skip(ftype)
29069 
      iprot.readFieldEnd()
29070 
    iprot.readStructEnd()
29071 
 
29072 
  def write(self, oprot):
29073 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
29074 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
29075 
      return
6031 rajveer 29076 
    oprot.writeStructBegin('getUserWalletHistory_result')
6000 mandeep.dh 29077 
    if self.success is not None:
29078 
      oprot.writeFieldBegin('success', TType.LIST, 0)
29079 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 29080 
      for iter669 in self.success:
29081 
        iter669.write(oprot)
6000 mandeep.dh 29082 
      oprot.writeListEnd()
29083 
      oprot.writeFieldEnd()
29084 
    oprot.writeFieldStop()
29085 
    oprot.writeStructEnd()
29086 
 
29087 
  def validate(self):
29088 
    return
29089 
 
29090 
 
29091 
  def __repr__(self):
29092 
    L = ['%s=%r' % (key, value)
29093 
      for key, value in self.__dict__.iteritems()]
29094 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
29095 
 
29096 
  def __eq__(self, other):
29097 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
29098 
 
29099 
  def __ne__(self, other):
29100 
    return not (self == other)
6048 rajveer 29101 
 
6050 anupam.sin 29102 
class getRechargeOrdersForTransaction_args:
29103 
  """
29104 
  Attributes:
29105 
   - txnId
29106 
  """
29107 
 
29108 
  thrift_spec = (
29109 
    None, # 0
29110 
    (1, TType.I64, 'txnId', None, None, ), # 1
29111 
  )
29112 
 
29113 
  def __init__(self, txnId=None,):
29114 
    self.txnId = txnId
29115 
 
29116 
  def read(self, iprot):
29117 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
29118 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
29119 
      return
29120 
    iprot.readStructBegin()
29121 
    while True:
29122 
      (fname, ftype, fid) = iprot.readFieldBegin()
29123 
      if ftype == TType.STOP:
29124 
        break
29125 
      if fid == 1:
29126 
        if ftype == TType.I64:
29127 
          self.txnId = iprot.readI64();
29128 
        else:
29129 
          iprot.skip(ftype)
29130 
      else:
29131 
        iprot.skip(ftype)
29132 
      iprot.readFieldEnd()
29133 
    iprot.readStructEnd()
29134 
 
29135 
  def write(self, oprot):
29136 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
29137 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
29138 
      return
29139 
    oprot.writeStructBegin('getRechargeOrdersForTransaction_args')
29140 
    if self.txnId is not None:
29141 
      oprot.writeFieldBegin('txnId', TType.I64, 1)
29142 
      oprot.writeI64(self.txnId)
29143 
      oprot.writeFieldEnd()
29144 
    oprot.writeFieldStop()
29145 
    oprot.writeStructEnd()
29146 
 
29147 
  def validate(self):
29148 
    return
29149 
 
29150 
 
29151 
  def __repr__(self):
29152 
    L = ['%s=%r' % (key, value)
29153 
      for key, value in self.__dict__.iteritems()]
29154 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
29155 
 
29156 
  def __eq__(self, other):
29157 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
29158 
 
29159 
  def __ne__(self, other):
29160 
    return not (self == other)
29161 
 
29162 
class getRechargeOrdersForTransaction_result:
29163 
  """
29164 
  Attributes:
29165 
   - success
29166 
   - ex
29167 
  """
29168 
 
29169 
  thrift_spec = (
29170 
    (0, TType.STRUCT, 'success', (RechargeOrder, RechargeOrder.thrift_spec), None, ), # 0
29171 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
29172 
  )
29173 
 
29174 
  def __init__(self, success=None, ex=None,):
29175 
    self.success = success
29176 
    self.ex = ex
29177 
 
29178 
  def read(self, iprot):
29179 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
29180 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
29181 
      return
29182 
    iprot.readStructBegin()
29183 
    while True:
29184 
      (fname, ftype, fid) = iprot.readFieldBegin()
29185 
      if ftype == TType.STOP:
29186 
        break
29187 
      if fid == 0:
29188 
        if ftype == TType.STRUCT:
29189 
          self.success = RechargeOrder()
29190 
          self.success.read(iprot)
29191 
        else:
29192 
          iprot.skip(ftype)
29193 
      elif fid == 1:
29194 
        if ftype == TType.STRUCT:
29195 
          self.ex = TransactionServiceException()
29196 
          self.ex.read(iprot)
29197 
        else:
29198 
          iprot.skip(ftype)
29199 
      else:
29200 
        iprot.skip(ftype)
29201 
      iprot.readFieldEnd()
29202 
    iprot.readStructEnd()
29203 
 
29204 
  def write(self, oprot):
29205 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
29206 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
29207 
      return
29208 
    oprot.writeStructBegin('getRechargeOrdersForTransaction_result')
29209 
    if self.success is not None:
29210 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
29211 
      self.success.write(oprot)
29212 
      oprot.writeFieldEnd()
29213 
    if self.ex is not None:
29214 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
29215 
      self.ex.write(oprot)
29216 
      oprot.writeFieldEnd()
29217 
    oprot.writeFieldStop()
29218 
    oprot.writeStructEnd()
29219 
 
29220 
  def validate(self):
29221 
    return
29222 
 
29223 
 
29224 
  def __repr__(self):
29225 
    L = ['%s=%r' % (key, value)
29226 
      for key, value in self.__dict__.iteritems()]
29227 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
29228 
 
29229 
  def __eq__(self, other):
29230 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
29231 
 
29232 
  def __ne__(self, other):
29233 
    return not (self == other)
29234 
 
6048 rajveer 29235 
class getServiceProviders_args:
29236 
  """
29237 
  Attributes:
29238 
   - rechargeType
6206 rajveer 29239 
   - onlyActive
6048 rajveer 29240 
  """
29241 
 
29242 
  thrift_spec = (
29243 
    None, # 0
29244 
    (1, TType.I32, 'rechargeType', None, None, ), # 1
6206 rajveer 29245 
    (2, TType.BOOL, 'onlyActive', None, None, ), # 2
6048 rajveer 29246 
  )
29247 
 
6206 rajveer 29248 
  def __init__(self, rechargeType=None, onlyActive=None,):
6048 rajveer 29249 
    self.rechargeType = rechargeType
6206 rajveer 29250 
    self.onlyActive = onlyActive
6048 rajveer 29251 
 
29252 
  def read(self, iprot):
29253 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
29254 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
29255 
      return
29256 
    iprot.readStructBegin()
29257 
    while True:
29258 
      (fname, ftype, fid) = iprot.readFieldBegin()
29259 
      if ftype == TType.STOP:
29260 
        break
29261 
      if fid == 1:
29262 
        if ftype == TType.I32:
29263 
          self.rechargeType = iprot.readI32();
29264 
        else:
29265 
          iprot.skip(ftype)
6206 rajveer 29266 
      elif fid == 2:
29267 
        if ftype == TType.BOOL:
29268 
          self.onlyActive = iprot.readBool();
29269 
        else:
29270 
          iprot.skip(ftype)
6048 rajveer 29271 
      else:
29272 
        iprot.skip(ftype)
29273 
      iprot.readFieldEnd()
29274 
    iprot.readStructEnd()
29275 
 
29276 
  def write(self, oprot):
29277 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
29278 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
29279 
      return
29280 
    oprot.writeStructBegin('getServiceProviders_args')
29281 
    if self.rechargeType is not None:
29282 
      oprot.writeFieldBegin('rechargeType', TType.I32, 1)
29283 
      oprot.writeI32(self.rechargeType)
29284 
      oprot.writeFieldEnd()
6206 rajveer 29285 
    if self.onlyActive is not None:
29286 
      oprot.writeFieldBegin('onlyActive', TType.BOOL, 2)
29287 
      oprot.writeBool(self.onlyActive)
29288 
      oprot.writeFieldEnd()
6048 rajveer 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 
 
29307 
class getServiceProviders_result:
29308 
  """
29309 
  Attributes:
29310 
   - success
29311 
  """
29312 
 
29313 
  thrift_spec = (
29314 
    (0, TType.MAP, 'success', (TType.I64,None,TType.STRING,None), None, ), # 0
29315 
  )
29316 
 
29317 
  def __init__(self, success=None,):
29318 
    self.success = success
29319 
 
29320 
  def read(self, iprot):
29321 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
29322 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
29323 
      return
29324 
    iprot.readStructBegin()
29325 
    while True:
29326 
      (fname, ftype, fid) = iprot.readFieldBegin()
29327 
      if ftype == TType.STOP:
29328 
        break
29329 
      if fid == 0:
29330 
        if ftype == TType.MAP:
29331 
          self.success = {}
6188 rajveer 29332 
          (_ktype671, _vtype672, _size670 ) = iprot.readMapBegin()
29333 
          for _i674 in xrange(_size670):
29334 
            _key675 = iprot.readI64();
29335 
            _val676 = iprot.readString();
29336 
            self.success[_key675] = _val676
6048 rajveer 29337 
          iprot.readMapEnd()
29338 
        else:
29339 
          iprot.skip(ftype)
29340 
      else:
29341 
        iprot.skip(ftype)
29342 
      iprot.readFieldEnd()
29343 
    iprot.readStructEnd()
29344 
 
29345 
  def write(self, oprot):
29346 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
29347 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
29348 
      return
29349 
    oprot.writeStructBegin('getServiceProviders_result')
29350 
    if self.success is not None:
29351 
      oprot.writeFieldBegin('success', TType.MAP, 0)
29352 
      oprot.writeMapBegin(TType.I64, TType.STRING, len(self.success))
6188 rajveer 29353 
      for kiter677,viter678 in self.success.items():
29354 
        oprot.writeI64(kiter677)
29355 
        oprot.writeString(viter678)
6048 rajveer 29356 
      oprot.writeMapEnd()
29357 
      oprot.writeFieldEnd()
29358 
    oprot.writeFieldStop()
29359 
    oprot.writeStructEnd()
29360 
 
29361 
  def validate(self):
29362 
    return
29363 
 
29364 
 
29365 
  def __repr__(self):
29366 
    L = ['%s=%r' % (key, value)
29367 
      for key, value in self.__dict__.iteritems()]
29368 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
29369 
 
29370 
  def __eq__(self, other):
29371 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
29372 
 
29373 
  def __ne__(self, other):
29374 
    return not (self == other)
29375 
 
29376 
class getServiceProviderForDevice_args:
29377 
  """
29378 
  Attributes:
6049 rajveer 29379 
   - rechargeType
6048 rajveer 29380 
   - deviceNumber
29381 
  """
29382 
 
29383 
  thrift_spec = (
29384 
    None, # 0
6049 rajveer 29385 
    (1, TType.I32, 'rechargeType', None, None, ), # 1
29386 
    (2, TType.STRING, 'deviceNumber', None, None, ), # 2
6048 rajveer 29387 
  )
29388 
 
6049 rajveer 29389 
  def __init__(self, rechargeType=None, deviceNumber=None,):
29390 
    self.rechargeType = rechargeType
6048 rajveer 29391 
    self.deviceNumber = deviceNumber
29392 
 
29393 
  def read(self, iprot):
29394 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
29395 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
29396 
      return
29397 
    iprot.readStructBegin()
29398 
    while True:
29399 
      (fname, ftype, fid) = iprot.readFieldBegin()
29400 
      if ftype == TType.STOP:
29401 
        break
29402 
      if fid == 1:
6049 rajveer 29403 
        if ftype == TType.I32:
29404 
          self.rechargeType = iprot.readI32();
29405 
        else:
29406 
          iprot.skip(ftype)
29407 
      elif fid == 2:
6048 rajveer 29408 
        if ftype == TType.STRING:
29409 
          self.deviceNumber = iprot.readString();
29410 
        else:
29411 
          iprot.skip(ftype)
29412 
      else:
29413 
        iprot.skip(ftype)
29414 
      iprot.readFieldEnd()
29415 
    iprot.readStructEnd()
29416 
 
29417 
  def write(self, oprot):
29418 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
29419 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
29420 
      return
29421 
    oprot.writeStructBegin('getServiceProviderForDevice_args')
6049 rajveer 29422 
    if self.rechargeType is not None:
29423 
      oprot.writeFieldBegin('rechargeType', TType.I32, 1)
29424 
      oprot.writeI32(self.rechargeType)
29425 
      oprot.writeFieldEnd()
6048 rajveer 29426 
    if self.deviceNumber is not None:
6049 rajveer 29427 
      oprot.writeFieldBegin('deviceNumber', TType.STRING, 2)
6048 rajveer 29428 
      oprot.writeString(self.deviceNumber)
29429 
      oprot.writeFieldEnd()
29430 
    oprot.writeFieldStop()
29431 
    oprot.writeStructEnd()
29432 
 
29433 
  def validate(self):
29434 
    return
29435 
 
29436 
 
29437 
  def __repr__(self):
29438 
    L = ['%s=%r' % (key, value)
29439 
      for key, value in self.__dict__.iteritems()]
29440 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
29441 
 
29442 
  def __eq__(self, other):
29443 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
29444 
 
29445 
  def __ne__(self, other):
29446 
    return not (self == other)
29447 
 
29448 
class getServiceProviderForDevice_result:
29449 
  """
29450 
  Attributes:
29451 
   - success
29452 
  """
29453 
 
29454 
  thrift_spec = (
6289 anupam.sin 29455 
    (0, TType.STRUCT, 'success', (DeviceNumberInfo, DeviceNumberInfo.thrift_spec), None, ), # 0
6048 rajveer 29456 
  )
29457 
 
29458 
  def __init__(self, success=None,):
29459 
    self.success = success
29460 
 
29461 
  def read(self, iprot):
29462 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
29463 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
29464 
      return
29465 
    iprot.readStructBegin()
29466 
    while True:
29467 
      (fname, ftype, fid) = iprot.readFieldBegin()
29468 
      if ftype == TType.STOP:
29469 
        break
29470 
      if fid == 0:
6289 anupam.sin 29471 
        if ftype == TType.STRUCT:
29472 
          self.success = DeviceNumberInfo()
29473 
          self.success.read(iprot)
6048 rajveer 29474 
        else:
29475 
          iprot.skip(ftype)
29476 
      else:
29477 
        iprot.skip(ftype)
29478 
      iprot.readFieldEnd()
29479 
    iprot.readStructEnd()
29480 
 
29481 
  def write(self, oprot):
29482 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
29483 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
29484 
      return
29485 
    oprot.writeStructBegin('getServiceProviderForDevice_result')
29486 
    if self.success is not None:
6289 anupam.sin 29487 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
29488 
      self.success.write(oprot)
6048 rajveer 29489 
      oprot.writeFieldEnd()
29490 
    oprot.writeFieldStop()
29491 
    oprot.writeStructEnd()
29492 
 
29493 
  def validate(self):
29494 
    return
29495 
 
29496 
 
29497 
  def __repr__(self):
29498 
    L = ['%s=%r' % (key, value)
29499 
      for key, value in self.__dict__.iteritems()]
29500 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
29501 
 
29502 
  def __eq__(self, other):
29503 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
29504 
 
29505 
  def __ne__(self, other):
29506 
    return not (self == other)
6094 rajveer 29507 
 
6269 rajveer 29508 
class validateRecharge_args:
29509 
  """
29510 
  Attributes:
29511 
   - rechargeType
29512 
   - deviceNumber
6307 anupam.sin 29513 
   - userSelectedProviderId
6591 anupam.sin 29514 
   - clientAddress
6269 rajveer 29515 
  """
29516 
 
29517 
  thrift_spec = (
29518 
    None, # 0
29519 
    (1, TType.I32, 'rechargeType', None, None, ), # 1
29520 
    (2, TType.STRING, 'deviceNumber', None, None, ), # 2
6336 anupam.sin 29521 
    (3, TType.I64, 'userSelectedProviderId', None, None, ), # 3
6591 anupam.sin 29522 
    (4, TType.STRING, 'clientAddress', None, None, ), # 4
6269 rajveer 29523 
  )
29524 
 
6591 anupam.sin 29525 
  def __init__(self, rechargeType=None, deviceNumber=None, userSelectedProviderId=None, clientAddress=None,):
6269 rajveer 29526 
    self.rechargeType = rechargeType
29527 
    self.deviceNumber = deviceNumber
6307 anupam.sin 29528 
    self.userSelectedProviderId = userSelectedProviderId
6591 anupam.sin 29529 
    self.clientAddress = clientAddress
6269 rajveer 29530 
 
29531 
  def read(self, iprot):
29532 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
29533 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
29534 
      return
29535 
    iprot.readStructBegin()
29536 
    while True:
29537 
      (fname, ftype, fid) = iprot.readFieldBegin()
29538 
      if ftype == TType.STOP:
29539 
        break
29540 
      if fid == 1:
29541 
        if ftype == TType.I32:
29542 
          self.rechargeType = iprot.readI32();
29543 
        else:
29544 
          iprot.skip(ftype)
29545 
      elif fid == 2:
29546 
        if ftype == TType.STRING:
29547 
          self.deviceNumber = iprot.readString();
29548 
        else:
29549 
          iprot.skip(ftype)
6307 anupam.sin 29550 
      elif fid == 3:
29551 
        if ftype == TType.I64:
29552 
          self.userSelectedProviderId = iprot.readI64();
29553 
        else:
29554 
          iprot.skip(ftype)
6591 anupam.sin 29555 
      elif fid == 4:
29556 
        if ftype == TType.STRING:
29557 
          self.clientAddress = iprot.readString();
29558 
        else:
29559 
          iprot.skip(ftype)
6269 rajveer 29560 
      else:
29561 
        iprot.skip(ftype)
29562 
      iprot.readFieldEnd()
29563 
    iprot.readStructEnd()
29564 
 
29565 
  def write(self, oprot):
29566 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
29567 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
29568 
      return
29569 
    oprot.writeStructBegin('validateRecharge_args')
29570 
    if self.rechargeType is not None:
29571 
      oprot.writeFieldBegin('rechargeType', TType.I32, 1)
29572 
      oprot.writeI32(self.rechargeType)
29573 
      oprot.writeFieldEnd()
29574 
    if self.deviceNumber is not None:
29575 
      oprot.writeFieldBegin('deviceNumber', TType.STRING, 2)
29576 
      oprot.writeString(self.deviceNumber)
29577 
      oprot.writeFieldEnd()
6307 anupam.sin 29578 
    if self.userSelectedProviderId is not None:
6336 anupam.sin 29579 
      oprot.writeFieldBegin('userSelectedProviderId', TType.I64, 3)
6307 anupam.sin 29580 
      oprot.writeI64(self.userSelectedProviderId)
29581 
      oprot.writeFieldEnd()
6591 anupam.sin 29582 
    if self.clientAddress is not None:
29583 
      oprot.writeFieldBegin('clientAddress', TType.STRING, 4)
29584 
      oprot.writeString(self.clientAddress)
29585 
      oprot.writeFieldEnd()
6269 rajveer 29586 
    oprot.writeFieldStop()
29587 
    oprot.writeStructEnd()
29588 
 
29589 
  def validate(self):
29590 
    return
29591 
 
29592 
 
29593 
  def __repr__(self):
29594 
    L = ['%s=%r' % (key, value)
29595 
      for key, value in self.__dict__.iteritems()]
29596 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
29597 
 
29598 
  def __eq__(self, other):
29599 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
29600 
 
29601 
  def __ne__(self, other):
29602 
    return not (self == other)
29603 
 
29604 
class validateRecharge_result:
29605 
  """
29606 
  Attributes:
29607 
   - success
29608 
  """
29609 
 
29610 
  thrift_spec = (
29611 
    (0, TType.STRING, 'success', None, None, ), # 0
29612 
  )
29613 
 
29614 
  def __init__(self, success=None,):
29615 
    self.success = success
29616 
 
29617 
  def read(self, iprot):
29618 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
29619 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
29620 
      return
29621 
    iprot.readStructBegin()
29622 
    while True:
29623 
      (fname, ftype, fid) = iprot.readFieldBegin()
29624 
      if ftype == TType.STOP:
29625 
        break
29626 
      if fid == 0:
29627 
        if ftype == TType.STRING:
29628 
          self.success = iprot.readString();
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('validateRecharge_result')
29641 
    if self.success is not None:
29642 
      oprot.writeFieldBegin('success', TType.STRING, 0)
29643 
      oprot.writeString(self.success)
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 
 
6094 rajveer 29663 
class getRechargeOrdersForDevice_args:
29664 
  """
29665 
  Attributes:
29666 
   - deviceNumber
29667 
  """
29668 
 
29669 
  thrift_spec = (
29670 
    None, # 0
29671 
    (1, TType.STRING, 'deviceNumber', None, None, ), # 1
29672 
  )
29673 
 
29674 
  def __init__(self, deviceNumber=None,):
29675 
    self.deviceNumber = deviceNumber
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.STRING:
29688 
          self.deviceNumber = iprot.readString();
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('getRechargeOrdersForDevice_args')
29701 
    if self.deviceNumber is not None:
29702 
      oprot.writeFieldBegin('deviceNumber', TType.STRING, 1)
29703 
      oprot.writeString(self.deviceNumber)
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 getRechargeOrdersForDevice_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 
          (_etype682, _size679) = iprot.readListBegin()
29749 
          for _i683 in xrange(_size679):
29750 
            _elem684 = RechargeOrder()
29751 
            _elem684.read(iprot)
29752 
            self.success.append(_elem684)
6094 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('getRechargeOrdersForDevice_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 iter685 in self.success:
29770 
        iter685.write(oprot)
6094 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)
29790 
 
29791 
class addAmountToWallet_args:
29792 
  """
29793 
  Attributes:
29794 
   - userId
29795 
   - orderId
29796 
   - amount
29797 
  """
29798 
 
29799 
  thrift_spec = (
29800 
    None, # 0
29801 
    (1, TType.I64, 'userId', None, None, ), # 1
29802 
    (2, TType.I64, 'orderId', None, None, ), # 2
29803 
    (3, TType.I64, 'amount', None, None, ), # 3
29804 
  )
29805 
 
29806 
  def __init__(self, userId=None, orderId=None, amount=None,):
29807 
    self.userId = userId
29808 
    self.orderId = orderId
29809 
    self.amount = amount
29810 
 
29811 
  def read(self, iprot):
29812 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
29813 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
29814 
      return
29815 
    iprot.readStructBegin()
29816 
    while True:
29817 
      (fname, ftype, fid) = iprot.readFieldBegin()
29818 
      if ftype == TType.STOP:
29819 
        break
29820 
      if fid == 1:
29821 
        if ftype == TType.I64:
29822 
          self.userId = iprot.readI64();
29823 
        else:
29824 
          iprot.skip(ftype)
29825 
      elif fid == 2:
29826 
        if ftype == TType.I64:
29827 
          self.orderId = iprot.readI64();
29828 
        else:
29829 
          iprot.skip(ftype)
29830 
      elif fid == 3:
29831 
        if ftype == TType.I64:
29832 
          self.amount = iprot.readI64();
29833 
        else:
29834 
          iprot.skip(ftype)
29835 
      else:
29836 
        iprot.skip(ftype)
29837 
      iprot.readFieldEnd()
29838 
    iprot.readStructEnd()
29839 
 
29840 
  def write(self, oprot):
29841 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
29842 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
29843 
      return
29844 
    oprot.writeStructBegin('addAmountToWallet_args')
29845 
    if self.userId is not None:
29846 
      oprot.writeFieldBegin('userId', TType.I64, 1)
29847 
      oprot.writeI64(self.userId)
29848 
      oprot.writeFieldEnd()
29849 
    if self.orderId is not None:
29850 
      oprot.writeFieldBegin('orderId', TType.I64, 2)
29851 
      oprot.writeI64(self.orderId)
29852 
      oprot.writeFieldEnd()
29853 
    if self.amount is not None:
29854 
      oprot.writeFieldBegin('amount', TType.I64, 3)
29855 
      oprot.writeI64(self.amount)
29856 
      oprot.writeFieldEnd()
29857 
    oprot.writeFieldStop()
29858 
    oprot.writeStructEnd()
29859 
 
29860 
  def validate(self):
29861 
    return
29862 
 
29863 
 
29864 
  def __repr__(self):
29865 
    L = ['%s=%r' % (key, value)
29866 
      for key, value in self.__dict__.iteritems()]
29867 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
29868 
 
29869 
  def __eq__(self, other):
29870 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
29871 
 
29872 
  def __ne__(self, other):
29873 
    return not (self == other)
29874 
 
29875 
class addAmountToWallet_result:
29876 
 
29877 
  thrift_spec = (
29878 
  )
29879 
 
29880 
  def read(self, iprot):
29881 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
29882 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
29883 
      return
29884 
    iprot.readStructBegin()
29885 
    while True:
29886 
      (fname, ftype, fid) = iprot.readFieldBegin()
29887 
      if ftype == TType.STOP:
29888 
        break
29889 
      else:
29890 
        iprot.skip(ftype)
29891 
      iprot.readFieldEnd()
29892 
    iprot.readStructEnd()
29893 
 
29894 
  def write(self, oprot):
29895 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
29896 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
29897 
      return
29898 
    oprot.writeStructBegin('addAmountToWallet_result')
29899 
    oprot.writeFieldStop()
29900 
    oprot.writeStructEnd()
29901 
 
29902 
  def validate(self):
29903 
    return
29904 
 
29905 
 
29906 
  def __repr__(self):
29907 
    L = ['%s=%r' % (key, value)
29908 
      for key, value in self.__dict__.iteritems()]
29909 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
29910 
 
29911 
  def __eq__(self, other):
29912 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
29913 
 
29914 
  def __ne__(self, other):
29915 
    return not (self == other)
6154 rajveer 29916 
 
6188 rajveer 29917 
class getRechargeStatistics_args:
29918 
 
29919 
  thrift_spec = (
29920 
  )
29921 
 
29922 
  def read(self, iprot):
29923 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
29924 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
29925 
      return
29926 
    iprot.readStructBegin()
29927 
    while True:
29928 
      (fname, ftype, fid) = iprot.readFieldBegin()
29929 
      if ftype == TType.STOP:
29930 
        break
29931 
      else:
29932 
        iprot.skip(ftype)
29933 
      iprot.readFieldEnd()
29934 
    iprot.readStructEnd()
29935 
 
29936 
  def write(self, oprot):
29937 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
29938 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
29939 
      return
29940 
    oprot.writeStructBegin('getRechargeStatistics_args')
29941 
    oprot.writeFieldStop()
29942 
    oprot.writeStructEnd()
29943 
 
29944 
  def validate(self):
29945 
    return
29946 
 
29947 
 
29948 
  def __repr__(self):
29949 
    L = ['%s=%r' % (key, value)
29950 
      for key, value in self.__dict__.iteritems()]
29951 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
29952 
 
29953 
  def __eq__(self, other):
29954 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
29955 
 
29956 
  def __ne__(self, other):
29957 
    return not (self == other)
29958 
 
29959 
class getRechargeStatistics_result:
29960 
  """
29961 
  Attributes:
29962 
   - success
29963 
  """
29964 
 
29965 
  thrift_spec = (
29966 
    (0, TType.STRUCT, 'success', (RechargeStatistics, RechargeStatistics.thrift_spec), None, ), # 0
29967 
  )
29968 
 
29969 
  def __init__(self, success=None,):
29970 
    self.success = success
29971 
 
29972 
  def read(self, iprot):
29973 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
29974 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
29975 
      return
29976 
    iprot.readStructBegin()
29977 
    while True:
29978 
      (fname, ftype, fid) = iprot.readFieldBegin()
29979 
      if ftype == TType.STOP:
29980 
        break
29981 
      if fid == 0:
29982 
        if ftype == TType.STRUCT:
29983 
          self.success = RechargeStatistics()
29984 
          self.success.read(iprot)
29985 
        else:
29986 
          iprot.skip(ftype)
29987 
      else:
29988 
        iprot.skip(ftype)
29989 
      iprot.readFieldEnd()
29990 
    iprot.readStructEnd()
29991 
 
29992 
  def write(self, oprot):
29993 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
29994 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
29995 
      return
29996 
    oprot.writeStructBegin('getRechargeStatistics_result')
29997 
    if self.success is not None:
29998 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
29999 
      self.success.write(oprot)
30000 
      oprot.writeFieldEnd()
30001 
    oprot.writeFieldStop()
30002 
    oprot.writeStructEnd()
30003 
 
30004 
  def validate(self):
30005 
    return
30006 
 
30007 
 
30008 
  def __repr__(self):
30009 
    L = ['%s=%r' % (key, value)
30010 
      for key, value in self.__dict__.iteritems()]
30011 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
30012 
 
30013 
  def __eq__(self, other):
30014 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
30015 
 
30016 
  def __ne__(self, other):
30017 
    return not (self == other)
30018 
 
6154 rajveer 30019 
class getRechargeOrdersForStatus_args:
30020 
  """
30021 
  Attributes:
30022 
   - status
30023 
  """
30024 
 
30025 
  thrift_spec = (
30026 
    None, # 0
30027 
    (1, TType.I64, 'status', None, None, ), # 1
30028 
  )
30029 
 
30030 
  def __init__(self, status=None,):
30031 
    self.status = status
30032 
 
30033 
  def read(self, iprot):
30034 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
30035 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
30036 
      return
30037 
    iprot.readStructBegin()
30038 
    while True:
30039 
      (fname, ftype, fid) = iprot.readFieldBegin()
30040 
      if ftype == TType.STOP:
30041 
        break
30042 
      if fid == 1:
30043 
        if ftype == TType.I64:
30044 
          self.status = iprot.readI64();
30045 
        else:
30046 
          iprot.skip(ftype)
30047 
      else:
30048 
        iprot.skip(ftype)
30049 
      iprot.readFieldEnd()
30050 
    iprot.readStructEnd()
30051 
 
30052 
  def write(self, oprot):
30053 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
30054 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
30055 
      return
30056 
    oprot.writeStructBegin('getRechargeOrdersForStatus_args')
30057 
    if self.status is not None:
30058 
      oprot.writeFieldBegin('status', TType.I64, 1)
30059 
      oprot.writeI64(self.status)
30060 
      oprot.writeFieldEnd()
30061 
    oprot.writeFieldStop()
30062 
    oprot.writeStructEnd()
30063 
 
30064 
  def validate(self):
30065 
    return
30066 
 
30067 
 
30068 
  def __repr__(self):
30069 
    L = ['%s=%r' % (key, value)
30070 
      for key, value in self.__dict__.iteritems()]
30071 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
30072 
 
30073 
  def __eq__(self, other):
30074 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
30075 
 
30076 
  def __ne__(self, other):
30077 
    return not (self == other)
30078 
 
30079 
class getRechargeOrdersForStatus_result:
30080 
  """
30081 
  Attributes:
30082 
   - success
30083 
  """
30084 
 
30085 
  thrift_spec = (
30086 
    (0, TType.LIST, 'success', (TType.STRUCT,(RechargeOrder, RechargeOrder.thrift_spec)), None, ), # 0
30087 
  )
30088 
 
30089 
  def __init__(self, success=None,):
30090 
    self.success = success
30091 
 
30092 
  def read(self, iprot):
30093 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
30094 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
30095 
      return
30096 
    iprot.readStructBegin()
30097 
    while True:
30098 
      (fname, ftype, fid) = iprot.readFieldBegin()
30099 
      if ftype == TType.STOP:
30100 
        break
30101 
      if fid == 0:
30102 
        if ftype == TType.LIST:
30103 
          self.success = []
6188 rajveer 30104 
          (_etype689, _size686) = iprot.readListBegin()
30105 
          for _i690 in xrange(_size686):
30106 
            _elem691 = RechargeOrder()
30107 
            _elem691.read(iprot)
30108 
            self.success.append(_elem691)
6154 rajveer 30109 
          iprot.readListEnd()
30110 
        else:
30111 
          iprot.skip(ftype)
30112 
      else:
30113 
        iprot.skip(ftype)
30114 
      iprot.readFieldEnd()
30115 
    iprot.readStructEnd()
30116 
 
30117 
  def write(self, oprot):
30118 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
30119 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
30120 
      return
30121 
    oprot.writeStructBegin('getRechargeOrdersForStatus_result')
30122 
    if self.success is not None:
30123 
      oprot.writeFieldBegin('success', TType.LIST, 0)
30124 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 30125 
      for iter692 in self.success:
30126 
        iter692.write(oprot)
6154 rajveer 30127 
      oprot.writeListEnd()
30128 
      oprot.writeFieldEnd()
30129 
    oprot.writeFieldStop()
30130 
    oprot.writeStructEnd()
30131 
 
30132 
  def validate(self):
30133 
    return
30134 
 
30135 
 
30136 
  def __repr__(self):
30137 
    L = ['%s=%r' % (key, value)
30138 
      for key, value in self.__dict__.iteritems()]
30139 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
30140 
 
30141 
  def __eq__(self, other):
30142 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
30143 
 
30144 
  def __ne__(self, other):
30145 
    return not (self == other)
6159 rajveer 30146 
 
30147 
class getPlansForOperator_args:
30148 
  """
30149 
  Attributes:
30150 
   - operatorId
30151 
  """
30152 
 
30153 
  thrift_spec = (
30154 
    None, # 0
30155 
    (1, TType.I64, 'operatorId', None, None, ), # 1
30156 
  )
30157 
 
30158 
  def __init__(self, operatorId=None,):
30159 
    self.operatorId = operatorId
30160 
 
30161 
  def read(self, iprot):
30162 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
30163 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
30164 
      return
30165 
    iprot.readStructBegin()
30166 
    while True:
30167 
      (fname, ftype, fid) = iprot.readFieldBegin()
30168 
      if ftype == TType.STOP:
30169 
        break
30170 
      if fid == 1:
30171 
        if ftype == TType.I64:
30172 
          self.operatorId = iprot.readI64();
30173 
        else:
30174 
          iprot.skip(ftype)
30175 
      else:
30176 
        iprot.skip(ftype)
30177 
      iprot.readFieldEnd()
30178 
    iprot.readStructEnd()
30179 
 
30180 
  def write(self, oprot):
30181 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
30182 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
30183 
      return
30184 
    oprot.writeStructBegin('getPlansForOperator_args')
30185 
    if self.operatorId is not None:
30186 
      oprot.writeFieldBegin('operatorId', TType.I64, 1)
30187 
      oprot.writeI64(self.operatorId)
30188 
      oprot.writeFieldEnd()
30189 
    oprot.writeFieldStop()
30190 
    oprot.writeStructEnd()
30191 
 
30192 
  def validate(self):
30193 
    return
30194 
 
30195 
 
30196 
  def __repr__(self):
30197 
    L = ['%s=%r' % (key, value)
30198 
      for key, value in self.__dict__.iteritems()]
30199 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
30200 
 
30201 
  def __eq__(self, other):
30202 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
30203 
 
30204 
  def __ne__(self, other):
30205 
    return not (self == other)
30206 
 
30207 
class getPlansForOperator_result:
30208 
  """
30209 
  Attributes:
30210 
   - success
30211 
  """
30212 
 
30213 
  thrift_spec = (
30214 
    (0, TType.LIST, 'success', (TType.STRUCT,(RechargePlan, RechargePlan.thrift_spec)), None, ), # 0
30215 
  )
30216 
 
30217 
  def __init__(self, success=None,):
30218 
    self.success = success
30219 
 
30220 
  def read(self, iprot):
30221 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
30222 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
30223 
      return
30224 
    iprot.readStructBegin()
30225 
    while True:
30226 
      (fname, ftype, fid) = iprot.readFieldBegin()
30227 
      if ftype == TType.STOP:
30228 
        break
30229 
      if fid == 0:
30230 
        if ftype == TType.LIST:
30231 
          self.success = []
6188 rajveer 30232 
          (_etype696, _size693) = iprot.readListBegin()
30233 
          for _i697 in xrange(_size693):
30234 
            _elem698 = RechargePlan()
30235 
            _elem698.read(iprot)
30236 
            self.success.append(_elem698)
6159 rajveer 30237 
          iprot.readListEnd()
30238 
        else:
30239 
          iprot.skip(ftype)
30240 
      else:
30241 
        iprot.skip(ftype)
30242 
      iprot.readFieldEnd()
30243 
    iprot.readStructEnd()
30244 
 
30245 
  def write(self, oprot):
30246 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
30247 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
30248 
      return
30249 
    oprot.writeStructBegin('getPlansForOperator_result')
30250 
    if self.success is not None:
30251 
      oprot.writeFieldBegin('success', TType.LIST, 0)
30252 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 30253 
      for iter699 in self.success:
30254 
        iter699.write(oprot)
6159 rajveer 30255 
      oprot.writeListEnd()
30256 
      oprot.writeFieldEnd()
30257 
    oprot.writeFieldStop()
30258 
    oprot.writeStructEnd()
30259 
 
30260 
  def validate(self):
30261 
    return
30262 
 
30263 
 
30264 
  def __repr__(self):
30265 
    L = ['%s=%r' % (key, value)
30266 
      for key, value in self.__dict__.iteritems()]
30267 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
30268 
 
30269 
  def __eq__(self, other):
30270 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
30271 
 
30272 
  def __ne__(self, other):
30273 
    return not (self == other)
6289 anupam.sin 30274 
 
30275 
class getRechargeDenominations_args:
30276 
  """
30277 
  Attributes:
30278 
   - operatorId
6307 anupam.sin 30279 
   - circleCode
6289 anupam.sin 30280 
   - denominationType
30281 
  """
30282 
 
30283 
  thrift_spec = (
30284 
    None, # 0
30285 
    (1, TType.I64, 'operatorId', None, None, ), # 1
6307 anupam.sin 30286 
    (2, TType.STRING, 'circleCode', None, None, ), # 2
6289 anupam.sin 30287 
    (3, TType.I32, 'denominationType', None, None, ), # 3
30288 
  )
30289 
 
6307 anupam.sin 30290 
  def __init__(self, operatorId=None, circleCode=None, denominationType=None,):
6289 anupam.sin 30291 
    self.operatorId = operatorId
6307 anupam.sin 30292 
    self.circleCode = circleCode
6289 anupam.sin 30293 
    self.denominationType = denominationType
30294 
 
30295 
  def read(self, iprot):
30296 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
30297 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
30298 
      return
30299 
    iprot.readStructBegin()
30300 
    while True:
30301 
      (fname, ftype, fid) = iprot.readFieldBegin()
30302 
      if ftype == TType.STOP:
30303 
        break
30304 
      if fid == 1:
30305 
        if ftype == TType.I64:
30306 
          self.operatorId = iprot.readI64();
30307 
        else:
30308 
          iprot.skip(ftype)
30309 
      elif fid == 2:
30310 
        if ftype == TType.STRING:
6307 anupam.sin 30311 
          self.circleCode = iprot.readString();
6289 anupam.sin 30312 
        else:
30313 
          iprot.skip(ftype)
30314 
      elif fid == 3:
30315 
        if ftype == TType.I32:
30316 
          self.denominationType = iprot.readI32();
30317 
        else:
30318 
          iprot.skip(ftype)
30319 
      else:
30320 
        iprot.skip(ftype)
30321 
      iprot.readFieldEnd()
30322 
    iprot.readStructEnd()
30323 
 
30324 
  def write(self, oprot):
30325 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
30326 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
30327 
      return
30328 
    oprot.writeStructBegin('getRechargeDenominations_args')
30329 
    if self.operatorId is not None:
30330 
      oprot.writeFieldBegin('operatorId', TType.I64, 1)
30331 
      oprot.writeI64(self.operatorId)
30332 
      oprot.writeFieldEnd()
6307 anupam.sin 30333 
    if self.circleCode is not None:
30334 
      oprot.writeFieldBegin('circleCode', TType.STRING, 2)
30335 
      oprot.writeString(self.circleCode)
6289 anupam.sin 30336 
      oprot.writeFieldEnd()
30337 
    if self.denominationType is not None:
30338 
      oprot.writeFieldBegin('denominationType', TType.I32, 3)
30339 
      oprot.writeI32(self.denominationType)
30340 
      oprot.writeFieldEnd()
30341 
    oprot.writeFieldStop()
30342 
    oprot.writeStructEnd()
30343 
 
30344 
  def validate(self):
30345 
    return
30346 
 
30347 
 
30348 
  def __repr__(self):
30349 
    L = ['%s=%r' % (key, value)
30350 
      for key, value in self.__dict__.iteritems()]
30351 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
30352 
 
30353 
  def __eq__(self, other):
30354 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
30355 
 
30356 
  def __ne__(self, other):
30357 
    return not (self == other)
30358 
 
30359 
class getRechargeDenominations_result:
30360 
  """
30361 
  Attributes:
30362 
   - success
30363 
   - ex
30364 
  """
30365 
 
30366 
  thrift_spec = (
30367 
    (0, TType.LIST, 'success', (TType.STRUCT,(RechargeDenomination, RechargeDenomination.thrift_spec)), None, ), # 0
30368 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
30369 
  )
30370 
 
30371 
  def __init__(self, success=None, ex=None,):
30372 
    self.success = success
30373 
    self.ex = ex
30374 
 
30375 
  def read(self, iprot):
30376 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
30377 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
30378 
      return
30379 
    iprot.readStructBegin()
30380 
    while True:
30381 
      (fname, ftype, fid) = iprot.readFieldBegin()
30382 
      if ftype == TType.STOP:
30383 
        break
30384 
      if fid == 0:
30385 
        if ftype == TType.LIST:
30386 
          self.success = []
30387 
          (_etype703, _size700) = iprot.readListBegin()
30388 
          for _i704 in xrange(_size700):
30389 
            _elem705 = RechargeDenomination()
30390 
            _elem705.read(iprot)
30391 
            self.success.append(_elem705)
30392 
          iprot.readListEnd()
30393 
        else:
30394 
          iprot.skip(ftype)
30395 
      elif fid == 1:
30396 
        if ftype == TType.STRUCT:
30397 
          self.ex = TransactionServiceException()
30398 
          self.ex.read(iprot)
30399 
        else:
30400 
          iprot.skip(ftype)
30401 
      else:
30402 
        iprot.skip(ftype)
30403 
      iprot.readFieldEnd()
30404 
    iprot.readStructEnd()
30405 
 
30406 
  def write(self, oprot):
30407 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
30408 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
30409 
      return
30410 
    oprot.writeStructBegin('getRechargeDenominations_result')
30411 
    if self.success is not None:
30412 
      oprot.writeFieldBegin('success', TType.LIST, 0)
30413 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
30414 
      for iter706 in self.success:
30415 
        iter706.write(oprot)
30416 
      oprot.writeListEnd()
30417 
      oprot.writeFieldEnd()
30418 
    if self.ex is not None:
30419 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
30420 
      self.ex.write(oprot)
30421 
      oprot.writeFieldEnd()
30422 
    oprot.writeFieldStop()
30423 
    oprot.writeStructEnd()
30424 
 
30425 
  def validate(self):
30426 
    return
30427 
 
30428 
 
30429 
  def __repr__(self):
30430 
    L = ['%s=%r' % (key, value)
30431 
      for key, value in self.__dict__.iteritems()]
30432 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
30433 
 
30434 
  def __eq__(self, other):
30435 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
30436 
 
30437 
  def __ne__(self, other):
30438 
    return not (self == other)
6371 rajveer 30439 
 
30440 
class updateAvailabilityStatus_args:
30441 
  """
30442 
  Attributes:
30443 
   - operatorId
30444 
   - circleId
30445 
   - isAvailable
30446 
  """
30447 
 
30448 
  thrift_spec = (
30449 
    None, # 0
30450 
    (1, TType.I64, 'operatorId', None, None, ), # 1
30451 
    (2, TType.I64, 'circleId', None, None, ), # 2
30452 
    (3, TType.BOOL, 'isAvailable', None, None, ), # 3
30453 
  )
30454 
 
30455 
  def __init__(self, operatorId=None, circleId=None, isAvailable=None,):
30456 
    self.operatorId = operatorId
30457 
    self.circleId = circleId
30458 
    self.isAvailable = isAvailable
30459 
 
30460 
  def read(self, iprot):
30461 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
30462 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
30463 
      return
30464 
    iprot.readStructBegin()
30465 
    while True:
30466 
      (fname, ftype, fid) = iprot.readFieldBegin()
30467 
      if ftype == TType.STOP:
30468 
        break
30469 
      if fid == 1:
30470 
        if ftype == TType.I64:
30471 
          self.operatorId = iprot.readI64();
30472 
        else:
30473 
          iprot.skip(ftype)
30474 
      elif fid == 2:
30475 
        if ftype == TType.I64:
30476 
          self.circleId = iprot.readI64();
30477 
        else:
30478 
          iprot.skip(ftype)
30479 
      elif fid == 3:
30480 
        if ftype == TType.BOOL:
30481 
          self.isAvailable = iprot.readBool();
30482 
        else:
30483 
          iprot.skip(ftype)
30484 
      else:
30485 
        iprot.skip(ftype)
30486 
      iprot.readFieldEnd()
30487 
    iprot.readStructEnd()
30488 
 
30489 
  def write(self, oprot):
30490 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
30491 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
30492 
      return
30493 
    oprot.writeStructBegin('updateAvailabilityStatus_args')
30494 
    if self.operatorId is not None:
30495 
      oprot.writeFieldBegin('operatorId', TType.I64, 1)
30496 
      oprot.writeI64(self.operatorId)
30497 
      oprot.writeFieldEnd()
30498 
    if self.circleId is not None:
30499 
      oprot.writeFieldBegin('circleId', TType.I64, 2)
30500 
      oprot.writeI64(self.circleId)
30501 
      oprot.writeFieldEnd()
30502 
    if self.isAvailable is not None:
30503 
      oprot.writeFieldBegin('isAvailable', TType.BOOL, 3)
30504 
      oprot.writeBool(self.isAvailable)
30505 
      oprot.writeFieldEnd()
30506 
    oprot.writeFieldStop()
30507 
    oprot.writeStructEnd()
30508 
 
30509 
  def validate(self):
30510 
    return
30511 
 
30512 
 
30513 
  def __repr__(self):
30514 
    L = ['%s=%r' % (key, value)
30515 
      for key, value in self.__dict__.iteritems()]
30516 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
30517 
 
30518 
  def __eq__(self, other):
30519 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
30520 
 
30521 
  def __ne__(self, other):
30522 
    return not (self == other)
30523 
 
30524 
class updateAvailabilityStatus_result:
30525 
 
30526 
  thrift_spec = (
30527 
  )
30528 
 
30529 
  def read(self, iprot):
30530 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
30531 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
30532 
      return
30533 
    iprot.readStructBegin()
30534 
    while True:
30535 
      (fname, ftype, fid) = iprot.readFieldBegin()
30536 
      if ftype == TType.STOP:
30537 
        break
30538 
      else:
30539 
        iprot.skip(ftype)
30540 
      iprot.readFieldEnd()
30541 
    iprot.readStructEnd()
30542 
 
30543 
  def write(self, oprot):
30544 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
30545 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
30546 
      return
30547 
    oprot.writeStructBegin('updateAvailabilityStatus_result')
30548 
    oprot.writeFieldStop()
30549 
    oprot.writeStructEnd()
30550 
 
30551 
  def validate(self):
30552 
    return
30553 
 
30554 
 
30555 
  def __repr__(self):
30556 
    L = ['%s=%r' % (key, value)
30557 
      for key, value in self.__dict__.iteritems()]
30558 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
30559 
 
30560 
  def __eq__(self, other):
30561 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
30562 
 
30563 
  def __ne__(self, other):
30564 
    return not (self == other)
6389 rajveer 30565 
 
30566 
class getAvailableEmiSchemes_args:
30567 
 
30568 
  thrift_spec = (
30569 
  )
30570 
 
30571 
  def read(self, iprot):
30572 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
30573 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
30574 
      return
30575 
    iprot.readStructBegin()
30576 
    while True:
30577 
      (fname, ftype, fid) = iprot.readFieldBegin()
30578 
      if ftype == TType.STOP:
30579 
        break
30580 
      else:
30581 
        iprot.skip(ftype)
30582 
      iprot.readFieldEnd()
30583 
    iprot.readStructEnd()
30584 
 
30585 
  def write(self, oprot):
30586 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
30587 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
30588 
      return
30589 
    oprot.writeStructBegin('getAvailableEmiSchemes_args')
30590 
    oprot.writeFieldStop()
30591 
    oprot.writeStructEnd()
30592 
 
30593 
  def validate(self):
30594 
    return
30595 
 
30596 
 
30597 
  def __repr__(self):
30598 
    L = ['%s=%r' % (key, value)
30599 
      for key, value in self.__dict__.iteritems()]
30600 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
30601 
 
30602 
  def __eq__(self, other):
30603 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
30604 
 
30605 
  def __ne__(self, other):
30606 
    return not (self == other)
30607 
 
30608 
class getAvailableEmiSchemes_result:
30609 
  """
30610 
  Attributes:
30611 
   - success
30612 
  """
30613 
 
30614 
  thrift_spec = (
30615 
    (0, TType.LIST, 'success', (TType.STRUCT,(EmiScheme, EmiScheme.thrift_spec)), None, ), # 0
30616 
  )
30617 
 
30618 
  def __init__(self, success=None,):
30619 
    self.success = success
30620 
 
30621 
  def read(self, iprot):
30622 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
30623 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
30624 
      return
30625 
    iprot.readStructBegin()
30626 
    while True:
30627 
      (fname, ftype, fid) = iprot.readFieldBegin()
30628 
      if ftype == TType.STOP:
30629 
        break
30630 
      if fid == 0:
30631 
        if ftype == TType.LIST:
30632 
          self.success = []
30633 
          (_etype710, _size707) = iprot.readListBegin()
30634 
          for _i711 in xrange(_size707):
30635 
            _elem712 = EmiScheme()
30636 
            _elem712.read(iprot)
30637 
            self.success.append(_elem712)
30638 
          iprot.readListEnd()
30639 
        else:
30640 
          iprot.skip(ftype)
30641 
      else:
30642 
        iprot.skip(ftype)
30643 
      iprot.readFieldEnd()
30644 
    iprot.readStructEnd()
30645 
 
30646 
  def write(self, oprot):
30647 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
30648 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
30649 
      return
30650 
    oprot.writeStructBegin('getAvailableEmiSchemes_result')
30651 
    if self.success is not None:
30652 
      oprot.writeFieldBegin('success', TType.LIST, 0)
30653 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
30654 
      for iter713 in self.success:
30655 
        iter713.write(oprot)
30656 
      oprot.writeListEnd()
30657 
      oprot.writeFieldEnd()
30658 
    oprot.writeFieldStop()
30659 
    oprot.writeStructEnd()
30660 
 
30661 
  def validate(self):
30662 
    return
30663 
 
30664 
 
30665 
  def __repr__(self):
30666 
    L = ['%s=%r' % (key, value)
30667 
      for key, value in self.__dict__.iteritems()]
30668 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
30669 
 
30670 
  def __eq__(self, other):
30671 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
30672 
 
30673 
  def __ne__(self, other):
30674 
    return not (self == other)
30675 
 
30676 
class getMiscCharges_args:
30677 
  """
30678 
  Attributes:
30679 
   - transactionId
30680 
  """
30681 
 
30682 
  thrift_spec = (
30683 
    None, # 0
30684 
    (1, TType.I64, 'transactionId', None, None, ), # 1
30685 
  )
30686 
 
30687 
  def __init__(self, transactionId=None,):
30688 
    self.transactionId = transactionId
30689 
 
30690 
  def read(self, iprot):
30691 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
30692 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
30693 
      return
30694 
    iprot.readStructBegin()
30695 
    while True:
30696 
      (fname, ftype, fid) = iprot.readFieldBegin()
30697 
      if ftype == TType.STOP:
30698 
        break
30699 
      if fid == 1:
30700 
        if ftype == TType.I64:
30701 
          self.transactionId = iprot.readI64();
30702 
        else:
30703 
          iprot.skip(ftype)
30704 
      else:
30705 
        iprot.skip(ftype)
30706 
      iprot.readFieldEnd()
30707 
    iprot.readStructEnd()
30708 
 
30709 
  def write(self, oprot):
30710 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
30711 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
30712 
      return
30713 
    oprot.writeStructBegin('getMiscCharges_args')
30714 
    if self.transactionId is not None:
30715 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
30716 
      oprot.writeI64(self.transactionId)
30717 
      oprot.writeFieldEnd()
30718 
    oprot.writeFieldStop()
30719 
    oprot.writeStructEnd()
30720 
 
30721 
  def validate(self):
30722 
    return
30723 
 
30724 
 
30725 
  def __repr__(self):
30726 
    L = ['%s=%r' % (key, value)
30727 
      for key, value in self.__dict__.iteritems()]
30728 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
30729 
 
30730 
  def __eq__(self, other):
30731 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
30732 
 
30733 
  def __ne__(self, other):
30734 
    return not (self == other)
30735 
 
30736 
class getMiscCharges_result:
30737 
  """
30738 
  Attributes:
30739 
   - success
30740 
  """
30741 
 
30742 
  thrift_spec = (
6412 rajveer 30743 
    (0, TType.MAP, 'success', (TType.I64,None,TType.DOUBLE,None), None, ), # 0
6389 rajveer 30744 
  )
30745 
 
30746 
  def __init__(self, success=None,):
30747 
    self.success = success
30748 
 
30749 
  def read(self, iprot):
30750 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
30751 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
30752 
      return
30753 
    iprot.readStructBegin()
30754 
    while True:
30755 
      (fname, ftype, fid) = iprot.readFieldBegin()
30756 
      if ftype == TType.STOP:
30757 
        break
30758 
      if fid == 0:
30759 
        if ftype == TType.MAP:
30760 
          self.success = {}
30761 
          (_ktype715, _vtype716, _size714 ) = iprot.readMapBegin()
30762 
          for _i718 in xrange(_size714):
30763 
            _key719 = iprot.readI64();
6412 rajveer 30764 
            _val720 = iprot.readDouble();
6389 rajveer 30765 
            self.success[_key719] = _val720
30766 
          iprot.readMapEnd()
30767 
        else:
30768 
          iprot.skip(ftype)
30769 
      else:
30770 
        iprot.skip(ftype)
30771 
      iprot.readFieldEnd()
30772 
    iprot.readStructEnd()
30773 
 
30774 
  def write(self, oprot):
30775 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
30776 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
30777 
      return
30778 
    oprot.writeStructBegin('getMiscCharges_result')
30779 
    if self.success is not None:
30780 
      oprot.writeFieldBegin('success', TType.MAP, 0)
6412 rajveer 30781 
      oprot.writeMapBegin(TType.I64, TType.DOUBLE, len(self.success))
6389 rajveer 30782 
      for kiter721,viter722 in self.success.items():
30783 
        oprot.writeI64(kiter721)
6412 rajveer 30784 
        oprot.writeDouble(viter722)
6389 rajveer 30785 
      oprot.writeMapEnd()
30786 
      oprot.writeFieldEnd()
30787 
    oprot.writeFieldStop()
30788 
    oprot.writeStructEnd()
30789 
 
30790 
  def validate(self):
30791 
    return
30792 
 
30793 
 
30794 
  def __repr__(self):
30795 
    L = ['%s=%r' % (key, value)
30796 
      for key, value in self.__dict__.iteritems()]
30797 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
30798 
 
30799 
  def __eq__(self, other):
30800 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
30801 
 
30802 
  def __ne__(self, other):
30803 
    return not (self == other)
6507 anupam.sin 30804 
 
30805 
class refundRechargeOrder_args:
30806 
  """
30807 
  Attributes:
30808 
   - rechargeOrderId
30809 
  """
30810 
 
30811 
  thrift_spec = (
30812 
    None, # 0
30813 
    (1, TType.I64, 'rechargeOrderId', None, None, ), # 1
30814 
  )
30815 
 
30816 
  def __init__(self, rechargeOrderId=None,):
30817 
    self.rechargeOrderId = rechargeOrderId
30818 
 
30819 
  def read(self, iprot):
30820 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
30821 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
30822 
      return
30823 
    iprot.readStructBegin()
30824 
    while True:
30825 
      (fname, ftype, fid) = iprot.readFieldBegin()
30826 
      if ftype == TType.STOP:
30827 
        break
30828 
      if fid == 1:
30829 
        if ftype == TType.I64:
30830 
          self.rechargeOrderId = iprot.readI64();
30831 
        else:
30832 
          iprot.skip(ftype)
30833 
      else:
30834 
        iprot.skip(ftype)
30835 
      iprot.readFieldEnd()
30836 
    iprot.readStructEnd()
30837 
 
30838 
  def write(self, oprot):
30839 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
30840 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
30841 
      return
30842 
    oprot.writeStructBegin('refundRechargeOrder_args')
30843 
    if self.rechargeOrderId is not None:
30844 
      oprot.writeFieldBegin('rechargeOrderId', TType.I64, 1)
30845 
      oprot.writeI64(self.rechargeOrderId)
30846 
      oprot.writeFieldEnd()
30847 
    oprot.writeFieldStop()
30848 
    oprot.writeStructEnd()
30849 
 
30850 
  def validate(self):
30851 
    return
30852 
 
30853 
 
30854 
  def __repr__(self):
30855 
    L = ['%s=%r' % (key, value)
30856 
      for key, value in self.__dict__.iteritems()]
30857 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
30858 
 
30859 
  def __eq__(self, other):
30860 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
30861 
 
30862 
  def __ne__(self, other):
30863 
    return not (self == other)
30864 
 
30865 
class refundRechargeOrder_result:
30866 
  """
30867 
  Attributes:
30868 
   - success
30869 
   - ex
30870 
  """
30871 
 
30872 
  thrift_spec = (
30873 
    (0, TType.BOOL, 'success', None, None, ), # 0
30874 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
30875 
  )
30876 
 
30877 
  def __init__(self, success=None, ex=None,):
30878 
    self.success = success
30879 
    self.ex = ex
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 == 0:
30891 
        if ftype == TType.BOOL:
30892 
          self.success = iprot.readBool();
30893 
        else:
30894 
          iprot.skip(ftype)
30895 
      elif fid == 1:
30896 
        if ftype == TType.STRUCT:
30897 
          self.ex = TransactionServiceException()
30898 
          self.ex.read(iprot)
30899 
        else:
30900 
          iprot.skip(ftype)
30901 
      else:
30902 
        iprot.skip(ftype)
30903 
      iprot.readFieldEnd()
30904 
    iprot.readStructEnd()
30905 
 
30906 
  def write(self, oprot):
30907 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
30908 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
30909 
      return
30910 
    oprot.writeStructBegin('refundRechargeOrder_result')
30911 
    if self.success is not None:
30912 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
30913 
      oprot.writeBool(self.success)
30914 
      oprot.writeFieldEnd()
30915 
    if self.ex is not None:
30916 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
30917 
      self.ex.write(oprot)
30918 
      oprot.writeFieldEnd()
30919 
    oprot.writeFieldStop()
30920 
    oprot.writeStructEnd()
30921 
 
30922 
  def validate(self):
30923 
    return
30924 
 
30925 
 
30926 
  def __repr__(self):
30927 
    L = ['%s=%r' % (key, value)
30928 
      for key, value in self.__dict__.iteritems()]
30929 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
30930 
 
30931 
  def __eq__(self, other):
30932 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
30933 
 
30934 
  def __ne__(self, other):
30935 
    return not (self == other)
6821 amar.kumar 30936 
 
30937 
class getPhysicalOrders_args:
30938 
  """
30939 
  Attributes:
30940 
   - fromDate
30941 
   - toDate
30942 
  """
30943 
 
30944 
  thrift_spec = (
30945 
    None, # 0
30946 
    (1, TType.I64, 'fromDate', None, None, ), # 1
30947 
    (2, TType.I64, 'toDate', None, None, ), # 2
30948 
  )
30949 
 
30950 
  def __init__(self, fromDate=None, toDate=None,):
30951 
    self.fromDate = fromDate
30952 
    self.toDate = toDate
30953 
 
30954 
  def read(self, iprot):
30955 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
30956 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
30957 
      return
30958 
    iprot.readStructBegin()
30959 
    while True:
30960 
      (fname, ftype, fid) = iprot.readFieldBegin()
30961 
      if ftype == TType.STOP:
30962 
        break
30963 
      if fid == 1:
30964 
        if ftype == TType.I64:
30965 
          self.fromDate = iprot.readI64();
30966 
        else:
30967 
          iprot.skip(ftype)
30968 
      elif fid == 2:
30969 
        if ftype == TType.I64:
30970 
          self.toDate = iprot.readI64();
30971 
        else:
30972 
          iprot.skip(ftype)
30973 
      else:
30974 
        iprot.skip(ftype)
30975 
      iprot.readFieldEnd()
30976 
    iprot.readStructEnd()
30977 
 
30978 
  def write(self, oprot):
30979 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
30980 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
30981 
      return
30982 
    oprot.writeStructBegin('getPhysicalOrders_args')
30983 
    if self.fromDate is not None:
30984 
      oprot.writeFieldBegin('fromDate', TType.I64, 1)
30985 
      oprot.writeI64(self.fromDate)
30986 
      oprot.writeFieldEnd()
30987 
    if self.toDate is not None:
30988 
      oprot.writeFieldBegin('toDate', TType.I64, 2)
30989 
      oprot.writeI64(self.toDate)
30990 
      oprot.writeFieldEnd()
30991 
    oprot.writeFieldStop()
30992 
    oprot.writeStructEnd()
30993 
 
30994 
  def validate(self):
30995 
    return
30996 
 
30997 
 
30998 
  def __repr__(self):
30999 
    L = ['%s=%r' % (key, value)
31000 
      for key, value in self.__dict__.iteritems()]
31001 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
31002 
 
31003 
  def __eq__(self, other):
31004 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
31005 
 
31006 
  def __ne__(self, other):
31007 
    return not (self == other)
31008 
 
31009 
class getPhysicalOrders_result:
31010 
  """
31011 
  Attributes:
31012 
   - success
31013 
  """
31014 
 
31015 
  thrift_spec = (
31016 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
31017 
  )
31018 
 
31019 
  def __init__(self, success=None,):
31020 
    self.success = success
31021 
 
31022 
  def read(self, iprot):
31023 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
31024 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
31025 
      return
31026 
    iprot.readStructBegin()
31027 
    while True:
31028 
      (fname, ftype, fid) = iprot.readFieldBegin()
31029 
      if ftype == TType.STOP:
31030 
        break
31031 
      if fid == 0:
31032 
        if ftype == TType.LIST:
31033 
          self.success = []
31034 
          (_etype726, _size723) = iprot.readListBegin()
31035 
          for _i727 in xrange(_size723):
31036 
            _elem728 = Order()
31037 
            _elem728.read(iprot)
31038 
            self.success.append(_elem728)
31039 
          iprot.readListEnd()
31040 
        else:
31041 
          iprot.skip(ftype)
31042 
      else:
31043 
        iprot.skip(ftype)
31044 
      iprot.readFieldEnd()
31045 
    iprot.readStructEnd()
31046 
 
31047 
  def write(self, oprot):
31048 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
31049 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
31050 
      return
31051 
    oprot.writeStructBegin('getPhysicalOrders_result')
31052 
    if self.success is not None:
31053 
      oprot.writeFieldBegin('success', TType.LIST, 0)
31054 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
31055 
      for iter729 in self.success:
31056 
        iter729.write(oprot)
31057 
      oprot.writeListEnd()
31058 
      oprot.writeFieldEnd()
31059 
    oprot.writeFieldStop()
31060 
    oprot.writeStructEnd()
31061 
 
31062 
  def validate(self):
31063 
    return
31064 
 
31065 
 
31066 
  def __repr__(self):
31067 
    L = ['%s=%r' % (key, value)
31068 
      for key, value in self.__dict__.iteritems()]
31069 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
31070 
 
31071 
  def __eq__(self, other):
31072 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
31073 
 
31074 
  def __ne__(self, other):
31075 
    return not (self == other)
6906 rajveer 31076 
 
31077 
class getDocument_args:
31078 
  """
31079 
  Attributes:
31080 
   - docType
31081 
   - docSource
31082 
  """
31083 
 
31084 
  thrift_spec = (
31085 
    None, # 0
31086 
    (1, TType.I64, 'docType', None, None, ), # 1
31087 
    (2, TType.I64, 'docSource', None, None, ), # 2
31088 
  )
31089 
 
31090 
  def __init__(self, docType=None, docSource=None,):
31091 
    self.docType = docType
31092 
    self.docSource = docSource
31093 
 
31094 
  def read(self, iprot):
31095 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
31096 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
31097 
      return
31098 
    iprot.readStructBegin()
31099 
    while True:
31100 
      (fname, ftype, fid) = iprot.readFieldBegin()
31101 
      if ftype == TType.STOP:
31102 
        break
31103 
      if fid == 1:
31104 
        if ftype == TType.I64:
31105 
          self.docType = iprot.readI64();
31106 
        else:
31107 
          iprot.skip(ftype)
31108 
      elif fid == 2:
31109 
        if ftype == TType.I64:
31110 
          self.docSource = iprot.readI64();
31111 
        else:
31112 
          iprot.skip(ftype)
31113 
      else:
31114 
        iprot.skip(ftype)
31115 
      iprot.readFieldEnd()
31116 
    iprot.readStructEnd()
31117 
 
31118 
  def write(self, oprot):
31119 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
31120 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
31121 
      return
31122 
    oprot.writeStructBegin('getDocument_args')
31123 
    if self.docType is not None:
31124 
      oprot.writeFieldBegin('docType', TType.I64, 1)
31125 
      oprot.writeI64(self.docType)
31126 
      oprot.writeFieldEnd()
31127 
    if self.docSource is not None:
31128 
      oprot.writeFieldBegin('docSource', TType.I64, 2)
31129 
      oprot.writeI64(self.docSource)
31130 
      oprot.writeFieldEnd()
31131 
    oprot.writeFieldStop()
31132 
    oprot.writeStructEnd()
31133 
 
31134 
  def validate(self):
31135 
    return
31136 
 
31137 
 
31138 
  def __repr__(self):
31139 
    L = ['%s=%r' % (key, value)
31140 
      for key, value in self.__dict__.iteritems()]
31141 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
31142 
 
31143 
  def __eq__(self, other):
31144 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
31145 
 
31146 
  def __ne__(self, other):
31147 
    return not (self == other)
31148 
 
31149 
class getDocument_result:
31150 
  """
31151 
  Attributes:
31152 
   - success
31153 
  """
31154 
 
31155 
  thrift_spec = (
31156 
    (0, TType.STRING, 'success', None, None, ), # 0
31157 
  )
31158 
 
31159 
  def __init__(self, success=None,):
31160 
    self.success = success
31161 
 
31162 
  def read(self, iprot):
31163 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
31164 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
31165 
      return
31166 
    iprot.readStructBegin()
31167 
    while True:
31168 
      (fname, ftype, fid) = iprot.readFieldBegin()
31169 
      if ftype == TType.STOP:
31170 
        break
31171 
      if fid == 0:
31172 
        if ftype == TType.STRING:
31173 
          self.success = iprot.readString();
31174 
        else:
31175 
          iprot.skip(ftype)
31176 
      else:
31177 
        iprot.skip(ftype)
31178 
      iprot.readFieldEnd()
31179 
    iprot.readStructEnd()
31180 
 
31181 
  def write(self, oprot):
31182 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
31183 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
31184 
      return
31185 
    oprot.writeStructBegin('getDocument_result')
31186 
    if self.success is not None:
31187 
      oprot.writeFieldBegin('success', TType.STRING, 0)
31188 
      oprot.writeString(self.success)
31189 
      oprot.writeFieldEnd()
31190 
    oprot.writeFieldStop()
31191 
    oprot.writeStructEnd()
31192 
 
31193 
  def validate(self):
31194 
    return
31195 
 
31196 
 
31197 
  def __repr__(self):
31198 
    L = ['%s=%r' % (key, value)
31199 
      for key, value in self.__dict__.iteritems()]
31200 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
31201 
 
31202 
  def __eq__(self, other):
31203 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
31204 
 
31205 
  def __ne__(self, other):
31206 
    return not (self == other)
6985 anupam.sin 31207 
 
31208 
class changeShippingAddress_args:
31209 
  """
31210 
  Attributes:
31211 
   - orderId
31212 
   - line1
31213 
   - line2
31214 
   - city
31215 
   - state
31216 
   - pin
31217 
  """
31218 
 
31219 
  thrift_spec = (
31220 
    None, # 0
31221 
    (1, TType.I64, 'orderId', None, None, ), # 1
31222 
    (2, TType.STRING, 'line1', None, None, ), # 2
31223 
    (3, TType.STRING, 'line2', None, None, ), # 3
31224 
    (4, TType.STRING, 'city', None, None, ), # 4
31225 
    (5, TType.STRING, 'state', None, None, ), # 5
31226 
    (6, TType.STRING, 'pin', None, None, ), # 6
31227 
  )
31228 
 
31229 
  def __init__(self, orderId=None, line1=None, line2=None, city=None, state=None, pin=None,):
31230 
    self.orderId = orderId
31231 
    self.line1 = line1
31232 
    self.line2 = line2
31233 
    self.city = city
31234 
    self.state = state
31235 
    self.pin = pin
31236 
 
31237 
  def read(self, iprot):
31238 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
31239 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
31240 
      return
31241 
    iprot.readStructBegin()
31242 
    while True:
31243 
      (fname, ftype, fid) = iprot.readFieldBegin()
31244 
      if ftype == TType.STOP:
31245 
        break
31246 
      if fid == 1:
31247 
        if ftype == TType.I64:
31248 
          self.orderId = iprot.readI64();
31249 
        else:
31250 
          iprot.skip(ftype)
31251 
      elif fid == 2:
31252 
        if ftype == TType.STRING:
31253 
          self.line1 = iprot.readString();
31254 
        else:
31255 
          iprot.skip(ftype)
31256 
      elif fid == 3:
31257 
        if ftype == TType.STRING:
31258 
          self.line2 = iprot.readString();
31259 
        else:
31260 
          iprot.skip(ftype)
31261 
      elif fid == 4:
31262 
        if ftype == TType.STRING:
31263 
          self.city = iprot.readString();
31264 
        else:
31265 
          iprot.skip(ftype)
31266 
      elif fid == 5:
31267 
        if ftype == TType.STRING:
31268 
          self.state = iprot.readString();
31269 
        else:
31270 
          iprot.skip(ftype)
31271 
      elif fid == 6:
31272 
        if ftype == TType.STRING:
31273 
          self.pin = iprot.readString();
31274 
        else:
31275 
          iprot.skip(ftype)
31276 
      else:
31277 
        iprot.skip(ftype)
31278 
      iprot.readFieldEnd()
31279 
    iprot.readStructEnd()
31280 
 
31281 
  def write(self, oprot):
31282 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
31283 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
31284 
      return
31285 
    oprot.writeStructBegin('changeShippingAddress_args')
31286 
    if self.orderId is not None:
31287 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
31288 
      oprot.writeI64(self.orderId)
31289 
      oprot.writeFieldEnd()
31290 
    if self.line1 is not None:
31291 
      oprot.writeFieldBegin('line1', TType.STRING, 2)
31292 
      oprot.writeString(self.line1)
31293 
      oprot.writeFieldEnd()
31294 
    if self.line2 is not None:
31295 
      oprot.writeFieldBegin('line2', TType.STRING, 3)
31296 
      oprot.writeString(self.line2)
31297 
      oprot.writeFieldEnd()
31298 
    if self.city is not None:
31299 
      oprot.writeFieldBegin('city', TType.STRING, 4)
31300 
      oprot.writeString(self.city)
31301 
      oprot.writeFieldEnd()
31302 
    if self.state is not None:
31303 
      oprot.writeFieldBegin('state', TType.STRING, 5)
31304 
      oprot.writeString(self.state)
31305 
      oprot.writeFieldEnd()
31306 
    if self.pin is not None:
31307 
      oprot.writeFieldBegin('pin', TType.STRING, 6)
31308 
      oprot.writeString(self.pin)
31309 
      oprot.writeFieldEnd()
31310 
    oprot.writeFieldStop()
31311 
    oprot.writeStructEnd()
31312 
 
31313 
  def validate(self):
31314 
    return
31315 
 
31316 
 
31317 
  def __repr__(self):
31318 
    L = ['%s=%r' % (key, value)
31319 
      for key, value in self.__dict__.iteritems()]
31320 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
31321 
 
31322 
  def __eq__(self, other):
31323 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
31324 
 
31325 
  def __ne__(self, other):
31326 
    return not (self == other)
31327 
 
31328 
class changeShippingAddress_result:
31329 
  """
31330 
  Attributes:
31331 
   - success
31332 
  """
31333 
 
31334 
  thrift_spec = (
31335 
    (0, TType.BOOL, 'success', None, None, ), # 0
31336 
  )
31337 
 
31338 
  def __init__(self, success=None,):
31339 
    self.success = success
31340 
 
31341 
  def read(self, iprot):
31342 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
31343 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
31344 
      return
31345 
    iprot.readStructBegin()
31346 
    while True:
31347 
      (fname, ftype, fid) = iprot.readFieldBegin()
31348 
      if ftype == TType.STOP:
31349 
        break
31350 
      if fid == 0:
31351 
        if ftype == TType.BOOL:
31352 
          self.success = iprot.readBool();
31353 
        else:
31354 
          iprot.skip(ftype)
31355 
      else:
31356 
        iprot.skip(ftype)
31357 
      iprot.readFieldEnd()
31358 
    iprot.readStructEnd()
31359 
 
31360 
  def write(self, oprot):
31361 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
31362 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
31363 
      return
31364 
    oprot.writeStructBegin('changeShippingAddress_result')
31365 
    if self.success is not None:
31366 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
31367 
      oprot.writeBool(self.success)
31368 
      oprot.writeFieldEnd()
31369 
    oprot.writeFieldStop()
31370 
    oprot.writeStructEnd()
31371 
 
31372 
  def validate(self):
31373 
    return
31374 
 
31375 
 
31376 
  def __repr__(self):
31377 
    L = ['%s=%r' % (key, value)
31378 
      for key, value in self.__dict__.iteritems()]
31379 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
31380 
 
31381 
  def __eq__(self, other):
31382 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
31383 
 
31384 
  def __ne__(self, other):
31385 
    return not (self == other)
6988 rajveer 31386 
 
31387 
class retrieveInvoice_args:
31388 
  """
31389 
  Attributes:
31390 
   - orderId
7075 rajveer 31391 
   - userId
6988 rajveer 31392 
  """
31393 
 
31394 
  thrift_spec = (
31395 
    None, # 0
31396 
    (1, TType.I64, 'orderId', None, None, ), # 1
7075 rajveer 31397 
    (2, TType.I64, 'userId', None, None, ), # 2
6988 rajveer 31398 
  )
31399 
 
7075 rajveer 31400 
  def __init__(self, orderId=None, userId=None,):
6988 rajveer 31401 
    self.orderId = orderId
7075 rajveer 31402 
    self.userId = userId
6988 rajveer 31403 
 
31404 
  def read(self, iprot):
31405 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
31406 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
31407 
      return
31408 
    iprot.readStructBegin()
31409 
    while True:
31410 
      (fname, ftype, fid) = iprot.readFieldBegin()
31411 
      if ftype == TType.STOP:
31412 
        break
31413 
      if fid == 1:
31414 
        if ftype == TType.I64:
31415 
          self.orderId = iprot.readI64();
31416 
        else:
31417 
          iprot.skip(ftype)
7075 rajveer 31418 
      elif fid == 2:
31419 
        if ftype == TType.I64:
31420 
          self.userId = iprot.readI64();
31421 
        else:
31422 
          iprot.skip(ftype)
6988 rajveer 31423 
      else:
31424 
        iprot.skip(ftype)
31425 
      iprot.readFieldEnd()
31426 
    iprot.readStructEnd()
31427 
 
31428 
  def write(self, oprot):
31429 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
31430 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
31431 
      return
31432 
    oprot.writeStructBegin('retrieveInvoice_args')
31433 
    if self.orderId is not None:
31434 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
31435 
      oprot.writeI64(self.orderId)
31436 
      oprot.writeFieldEnd()
7075 rajveer 31437 
    if self.userId is not None:
31438 
      oprot.writeFieldBegin('userId', TType.I64, 2)
31439 
      oprot.writeI64(self.userId)
31440 
      oprot.writeFieldEnd()
6988 rajveer 31441 
    oprot.writeFieldStop()
31442 
    oprot.writeStructEnd()
31443 
 
31444 
  def validate(self):
31445 
    return
31446 
 
31447 
 
31448 
  def __repr__(self):
31449 
    L = ['%s=%r' % (key, value)
31450 
      for key, value in self.__dict__.iteritems()]
31451 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
31452 
 
31453 
  def __eq__(self, other):
31454 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
31455 
 
31456 
  def __ne__(self, other):
31457 
    return not (self == other)
31458 
 
31459 
class retrieveInvoice_result:
31460 
  """
31461 
  Attributes:
31462 
   - success
31463 
  """
31464 
 
31465 
  thrift_spec = (
31466 
    (0, TType.STRING, 'success', None, None, ), # 0
31467 
  )
31468 
 
31469 
  def __init__(self, success=None,):
31470 
    self.success = success
31471 
 
31472 
  def read(self, iprot):
31473 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
31474 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
31475 
      return
31476 
    iprot.readStructBegin()
31477 
    while True:
31478 
      (fname, ftype, fid) = iprot.readFieldBegin()
31479 
      if ftype == TType.STOP:
31480 
        break
31481 
      if fid == 0:
31482 
        if ftype == TType.STRING:
31483 
          self.success = iprot.readString();
31484 
        else:
31485 
          iprot.skip(ftype)
31486 
      else:
31487 
        iprot.skip(ftype)
31488 
      iprot.readFieldEnd()
31489 
    iprot.readStructEnd()
31490 
 
31491 
  def write(self, oprot):
31492 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
31493 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
31494 
      return
31495 
    oprot.writeStructBegin('retrieveInvoice_result')
31496 
    if self.success is not None:
31497 
      oprot.writeFieldBegin('success', TType.STRING, 0)
31498 
      oprot.writeString(self.success)
31499 
      oprot.writeFieldEnd()
31500 
    oprot.writeFieldStop()
31501 
    oprot.writeStructEnd()
31502 
 
31503 
  def validate(self):
31504 
    return
31505 
 
31506 
 
31507 
  def __repr__(self):
31508 
    L = ['%s=%r' % (key, value)
31509 
      for key, value in self.__dict__.iteritems()]
31510 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
31511 
 
31512 
  def __eq__(self, other):
31513 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
31514 
 
31515 
  def __ne__(self, other):
31516 
    return not (self == other)
7026 rajveer 31517 
 
31518 
class receiveUpdatesForRedExpress_args:
31519 
  """
31520 
  Attributes:
31521 
   - awbNumber
31522 
  """
31523 
 
31524 
  thrift_spec = (
31525 
    None, # 0
31526 
    (1, TType.STRING, 'awbNumber', None, None, ), # 1
31527 
  )
31528 
 
31529 
  def __init__(self, awbNumber=None,):
31530 
    self.awbNumber = awbNumber
31531 
 
31532 
  def read(self, iprot):
31533 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
31534 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
31535 
      return
31536 
    iprot.readStructBegin()
31537 
    while True:
31538 
      (fname, ftype, fid) = iprot.readFieldBegin()
31539 
      if ftype == TType.STOP:
31540 
        break
31541 
      if fid == 1:
31542 
        if ftype == TType.STRING:
31543 
          self.awbNumber = iprot.readString();
31544 
        else:
31545 
          iprot.skip(ftype)
31546 
      else:
31547 
        iprot.skip(ftype)
31548 
      iprot.readFieldEnd()
31549 
    iprot.readStructEnd()
31550 
 
31551 
  def write(self, oprot):
31552 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
31553 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
31554 
      return
31555 
    oprot.writeStructBegin('receiveUpdatesForRedExpress_args')
31556 
    if self.awbNumber is not None:
31557 
      oprot.writeFieldBegin('awbNumber', TType.STRING, 1)
31558 
      oprot.writeString(self.awbNumber)
31559 
      oprot.writeFieldEnd()
31560 
    oprot.writeFieldStop()
31561 
    oprot.writeStructEnd()
31562 
 
31563 
  def validate(self):
31564 
    return
31565 
 
31566 
 
31567 
  def __repr__(self):
31568 
    L = ['%s=%r' % (key, value)
31569 
      for key, value in self.__dict__.iteritems()]
31570 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
31571 
 
31572 
  def __eq__(self, other):
31573 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
31574 
 
31575 
  def __ne__(self, other):
31576 
    return not (self == other)
31577 
 
31578 
class receiveUpdatesForRedExpress_result:
31579 
  """
31580 
  Attributes:
31581 
   - success
31582 
  """
31583 
 
31584 
  thrift_spec = (
31585 
    (0, TType.LIST, 'success', (TType.STRING,None), None, ), # 0
31586 
  )
31587 
 
31588 
  def __init__(self, success=None,):
31589 
    self.success = success
31590 
 
31591 
  def read(self, iprot):
31592 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
31593 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
31594 
      return
31595 
    iprot.readStructBegin()
31596 
    while True:
31597 
      (fname, ftype, fid) = iprot.readFieldBegin()
31598 
      if ftype == TType.STOP:
31599 
        break
31600 
      if fid == 0:
31601 
        if ftype == TType.LIST:
31602 
          self.success = []
31603 
          (_etype733, _size730) = iprot.readListBegin()
31604 
          for _i734 in xrange(_size730):
31605 
            _elem735 = iprot.readString();
31606 
            self.success.append(_elem735)
31607 
          iprot.readListEnd()
31608 
        else:
31609 
          iprot.skip(ftype)
31610 
      else:
31611 
        iprot.skip(ftype)
31612 
      iprot.readFieldEnd()
31613 
    iprot.readStructEnd()
31614 
 
31615 
  def write(self, oprot):
31616 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
31617 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
31618 
      return
31619 
    oprot.writeStructBegin('receiveUpdatesForRedExpress_result')
31620 
    if self.success is not None:
31621 
      oprot.writeFieldBegin('success', TType.LIST, 0)
31622 
      oprot.writeListBegin(TType.STRING, len(self.success))
31623 
      for iter736 in self.success:
31624 
        oprot.writeString(iter736)
31625 
      oprot.writeListEnd()
31626 
      oprot.writeFieldEnd()
31627 
    oprot.writeFieldStop()
31628 
    oprot.writeStructEnd()
31629 
 
31630 
  def validate(self):
31631 
    return
31632 
 
31633 
 
31634 
  def __repr__(self):
31635 
    L = ['%s=%r' % (key, value)
31636 
      for key, value in self.__dict__.iteritems()]
31637 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
31638 
 
31639 
  def __eq__(self, other):
31640 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
31641 
 
31642 
  def __ne__(self, other):
31643 
    return not (self == other)
7073 anupam.sin 31644 
 
31645 
class createRechargeTransaction_args:
31646 
  """
31647 
  Attributes:
31648 
   - thriftRechargeTransaction
31649 
  """
31650 
 
31651 
  thrift_spec = (
31652 
    None, # 0
31653 
    (1, TType.STRUCT, 'thriftRechargeTransaction', (RechargeTransaction, RechargeTransaction.thrift_spec), None, ), # 1
31654 
  )
31655 
 
31656 
  def __init__(self, thriftRechargeTransaction=None,):
31657 
    self.thriftRechargeTransaction = thriftRechargeTransaction
31658 
 
31659 
  def read(self, iprot):
31660 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
31661 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
31662 
      return
31663 
    iprot.readStructBegin()
31664 
    while True:
31665 
      (fname, ftype, fid) = iprot.readFieldBegin()
31666 
      if ftype == TType.STOP:
31667 
        break
31668 
      if fid == 1:
31669 
        if ftype == TType.STRUCT:
31670 
          self.thriftRechargeTransaction = RechargeTransaction()
31671 
          self.thriftRechargeTransaction.read(iprot)
31672 
        else:
31673 
          iprot.skip(ftype)
31674 
      else:
31675 
        iprot.skip(ftype)
31676 
      iprot.readFieldEnd()
31677 
    iprot.readStructEnd()
31678 
 
31679 
  def write(self, oprot):
31680 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
31681 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
31682 
      return
31683 
    oprot.writeStructBegin('createRechargeTransaction_args')
31684 
    if self.thriftRechargeTransaction is not None:
31685 
      oprot.writeFieldBegin('thriftRechargeTransaction', TType.STRUCT, 1)
31686 
      self.thriftRechargeTransaction.write(oprot)
31687 
      oprot.writeFieldEnd()
31688 
    oprot.writeFieldStop()
31689 
    oprot.writeStructEnd()
31690 
 
31691 
  def validate(self):
31692 
    return
31693 
 
31694 
 
31695 
  def __repr__(self):
31696 
    L = ['%s=%r' % (key, value)
31697 
      for key, value in self.__dict__.iteritems()]
31698 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
31699 
 
31700 
  def __eq__(self, other):
31701 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
31702 
 
31703 
  def __ne__(self, other):
31704 
    return not (self == other)
31705 
 
31706 
class createRechargeTransaction_result:
31707 
  """
31708 
  Attributes:
31709 
   - success
31710 
  """
31711 
 
31712 
  thrift_spec = (
31713 
    (0, TType.STRUCT, 'success', (RechargeTransaction, RechargeTransaction.thrift_spec), None, ), # 0
31714 
  )
31715 
 
31716 
  def __init__(self, success=None,):
31717 
    self.success = success
31718 
 
31719 
  def read(self, iprot):
31720 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
31721 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
31722 
      return
31723 
    iprot.readStructBegin()
31724 
    while True:
31725 
      (fname, ftype, fid) = iprot.readFieldBegin()
31726 
      if ftype == TType.STOP:
31727 
        break
31728 
      if fid == 0:
31729 
        if ftype == TType.STRUCT:
31730 
          self.success = RechargeTransaction()
31731 
          self.success.read(iprot)
31732 
        else:
31733 
          iprot.skip(ftype)
31734 
      else:
31735 
        iprot.skip(ftype)
31736 
      iprot.readFieldEnd()
31737 
    iprot.readStructEnd()
31738 
 
31739 
  def write(self, oprot):
31740 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
31741 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
31742 
      return
31743 
    oprot.writeStructBegin('createRechargeTransaction_result')
31744 
    if self.success is not None:
31745 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
31746 
      self.success.write(oprot)
31747 
      oprot.writeFieldEnd()
31748 
    oprot.writeFieldStop()
31749 
    oprot.writeStructEnd()
31750 
 
31751 
  def validate(self):
31752 
    return
31753 
 
31754 
 
31755 
  def __repr__(self):
31756 
    L = ['%s=%r' % (key, value)
31757 
      for key, value in self.__dict__.iteritems()]
31758 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
31759 
 
31760 
  def __eq__(self, other):
31761 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
31762 
 
31763 
  def __ne__(self, other):
31764 
    return not (self == other)
7080 anupam.sin 31765 
 
7085 rajveer 31766 
class getRechargeTransactions_args:
31767 
  """
31768 
  Attributes:
31769 
   - storeId
31770 
  """
31771 
 
31772 
  thrift_spec = (
31773 
    None, # 0
31774 
    (1, TType.I64, 'storeId', None, None, ), # 1
31775 
  )
31776 
 
31777 
  def __init__(self, storeId=None,):
31778 
    self.storeId = storeId
31779 
 
31780 
  def read(self, iprot):
31781 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
31782 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
31783 
      return
31784 
    iprot.readStructBegin()
31785 
    while True:
31786 
      (fname, ftype, fid) = iprot.readFieldBegin()
31787 
      if ftype == TType.STOP:
31788 
        break
31789 
      if fid == 1:
31790 
        if ftype == TType.I64:
31791 
          self.storeId = iprot.readI64();
31792 
        else:
31793 
          iprot.skip(ftype)
31794 
      else:
31795 
        iprot.skip(ftype)
31796 
      iprot.readFieldEnd()
31797 
    iprot.readStructEnd()
31798 
 
31799 
  def write(self, oprot):
31800 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
31801 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
31802 
      return
31803 
    oprot.writeStructBegin('getRechargeTransactions_args')
31804 
    if self.storeId is not None:
31805 
      oprot.writeFieldBegin('storeId', TType.I64, 1)
31806 
      oprot.writeI64(self.storeId)
31807 
      oprot.writeFieldEnd()
31808 
    oprot.writeFieldStop()
31809 
    oprot.writeStructEnd()
31810 
 
31811 
  def validate(self):
31812 
    return
31813 
 
31814 
 
31815 
  def __repr__(self):
31816 
    L = ['%s=%r' % (key, value)
31817 
      for key, value in self.__dict__.iteritems()]
31818 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
31819 
 
31820 
  def __eq__(self, other):
31821 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
31822 
 
31823 
  def __ne__(self, other):
31824 
    return not (self == other)
31825 
 
31826 
class getRechargeTransactions_result:
31827 
  """
31828 
  Attributes:
31829 
   - success
31830 
  """
31831 
 
31832 
  thrift_spec = (
31833 
    (0, TType.LIST, 'success', (TType.STRUCT,(RechargeTransaction, RechargeTransaction.thrift_spec)), None, ), # 0
31834 
  )
31835 
 
31836 
  def __init__(self, success=None,):
31837 
    self.success = success
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 == 0:
31849 
        if ftype == TType.LIST:
31850 
          self.success = []
31851 
          (_etype740, _size737) = iprot.readListBegin()
31852 
          for _i741 in xrange(_size737):
31853 
            _elem742 = RechargeTransaction()
31854 
            _elem742.read(iprot)
31855 
            self.success.append(_elem742)
31856 
          iprot.readListEnd()
31857 
        else:
31858 
          iprot.skip(ftype)
31859 
      else:
31860 
        iprot.skip(ftype)
31861 
      iprot.readFieldEnd()
31862 
    iprot.readStructEnd()
31863 
 
31864 
  def write(self, oprot):
31865 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
31866 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
31867 
      return
31868 
    oprot.writeStructBegin('getRechargeTransactions_result')
31869 
    if self.success is not None:
31870 
      oprot.writeFieldBegin('success', TType.LIST, 0)
31871 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
31872 
      for iter743 in self.success:
31873 
        iter743.write(oprot)
31874 
      oprot.writeListEnd()
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 
 
7151 amit.gupta 31894 
class getRechargeTrans_args:
31895 
  """
31896 
  Attributes:
31897 
   - storeId
31898 
   - startDate
31899 
   - endDate
31900 
   - status
31901 
  """
31902 
 
31903 
  thrift_spec = (
31904 
    None, # 0
31905 
    (1, TType.I64, 'storeId', None, None, ), # 1
31906 
    (2, TType.I64, 'startDate', None, None, ), # 2
31907 
    (3, TType.I64, 'endDate', None, None, ), # 3
31908 
    (4, TType.I32, 'status', None, None, ), # 4
31909 
  )
31910 
 
31911 
  def __init__(self, storeId=None, startDate=None, endDate=None, status=None,):
31912 
    self.storeId = storeId
31913 
    self.startDate = startDate
31914 
    self.endDate = endDate
31915 
    self.status = status
31916 
 
31917 
  def read(self, iprot):
31918 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
31919 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
31920 
      return
31921 
    iprot.readStructBegin()
31922 
    while True:
31923 
      (fname, ftype, fid) = iprot.readFieldBegin()
31924 
      if ftype == TType.STOP:
31925 
        break
31926 
      if fid == 1:
31927 
        if ftype == TType.I64:
31928 
          self.storeId = iprot.readI64();
31929 
        else:
31930 
          iprot.skip(ftype)
31931 
      elif fid == 2:
31932 
        if ftype == TType.I64:
31933 
          self.startDate = iprot.readI64();
31934 
        else:
31935 
          iprot.skip(ftype)
31936 
      elif fid == 3:
31937 
        if ftype == TType.I64:
31938 
          self.endDate = iprot.readI64();
31939 
        else:
31940 
          iprot.skip(ftype)
31941 
      elif fid == 4:
31942 
        if ftype == TType.I32:
31943 
          self.status = iprot.readI32();
31944 
        else:
31945 
          iprot.skip(ftype)
31946 
      else:
31947 
        iprot.skip(ftype)
31948 
      iprot.readFieldEnd()
31949 
    iprot.readStructEnd()
31950 
 
31951 
  def write(self, oprot):
31952 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
31953 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
31954 
      return
31955 
    oprot.writeStructBegin('getRechargeTrans_args')
31956 
    if self.storeId is not None:
31957 
      oprot.writeFieldBegin('storeId', TType.I64, 1)
31958 
      oprot.writeI64(self.storeId)
31959 
      oprot.writeFieldEnd()
31960 
    if self.startDate is not None:
31961 
      oprot.writeFieldBegin('startDate', TType.I64, 2)
31962 
      oprot.writeI64(self.startDate)
31963 
      oprot.writeFieldEnd()
31964 
    if self.endDate is not None:
31965 
      oprot.writeFieldBegin('endDate', TType.I64, 3)
31966 
      oprot.writeI64(self.endDate)
31967 
      oprot.writeFieldEnd()
31968 
    if self.status is not None:
31969 
      oprot.writeFieldBegin('status', TType.I32, 4)
31970 
      oprot.writeI32(self.status)
31971 
      oprot.writeFieldEnd()
31972 
    oprot.writeFieldStop()
31973 
    oprot.writeStructEnd()
31974 
 
31975 
  def validate(self):
31976 
    return
31977 
 
31978 
 
31979 
  def __repr__(self):
31980 
    L = ['%s=%r' % (key, value)
31981 
      for key, value in self.__dict__.iteritems()]
31982 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
31983 
 
31984 
  def __eq__(self, other):
31985 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
31986 
 
31987 
  def __ne__(self, other):
31988 
    return not (self == other)
31989 
 
31990 
class getRechargeTrans_result:
31991 
  """
31992 
  Attributes:
31993 
   - success
31994 
  """
31995 
 
31996 
  thrift_spec = (
31997 
    (0, TType.LIST, 'success', (TType.STRUCT,(RechargeTransaction, RechargeTransaction.thrift_spec)), None, ), # 0
31998 
  )
31999 
 
32000 
  def __init__(self, success=None,):
32001 
    self.success = success
32002 
 
32003 
  def read(self, iprot):
32004 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
32005 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
32006 
      return
32007 
    iprot.readStructBegin()
32008 
    while True:
32009 
      (fname, ftype, fid) = iprot.readFieldBegin()
32010 
      if ftype == TType.STOP:
32011 
        break
32012 
      if fid == 0:
32013 
        if ftype == TType.LIST:
32014 
          self.success = []
32015 
          (_etype747, _size744) = iprot.readListBegin()
32016 
          for _i748 in xrange(_size744):
32017 
            _elem749 = RechargeTransaction()
32018 
            _elem749.read(iprot)
32019 
            self.success.append(_elem749)
32020 
          iprot.readListEnd()
32021 
        else:
32022 
          iprot.skip(ftype)
32023 
      else:
32024 
        iprot.skip(ftype)
32025 
      iprot.readFieldEnd()
32026 
    iprot.readStructEnd()
32027 
 
32028 
  def write(self, oprot):
32029 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
32030 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
32031 
      return
32032 
    oprot.writeStructBegin('getRechargeTrans_result')
32033 
    if self.success is not None:
32034 
      oprot.writeFieldBegin('success', TType.LIST, 0)
32035 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
32036 
      for iter750 in self.success:
32037 
        iter750.write(oprot)
32038 
      oprot.writeListEnd()
32039 
      oprot.writeFieldEnd()
32040 
    oprot.writeFieldStop()
32041 
    oprot.writeStructEnd()
32042 
 
32043 
  def validate(self):
32044 
    return
32045 
 
32046 
 
32047 
  def __repr__(self):
32048 
    L = ['%s=%r' % (key, value)
32049 
      for key, value in self.__dict__.iteritems()]
32050 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
32051 
 
32052 
  def __eq__(self, other):
32053 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
32054 
 
32055 
  def __ne__(self, other):
32056 
    return not (self == other)
32057 
 
7080 anupam.sin 32058 
class getRechargeTransaction_args:
32059 
  """
32060 
  Attributes:
32061 
   - rechargeId
32062 
  """
32063 
 
32064 
  thrift_spec = (
32065 
    None, # 0
32066 
    (1, TType.I64, 'rechargeId', None, None, ), # 1
32067 
  )
32068 
 
32069 
  def __init__(self, rechargeId=None,):
32070 
    self.rechargeId = rechargeId
32071 
 
32072 
  def read(self, iprot):
32073 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
32074 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
32075 
      return
32076 
    iprot.readStructBegin()
32077 
    while True:
32078 
      (fname, ftype, fid) = iprot.readFieldBegin()
32079 
      if ftype == TType.STOP:
32080 
        break
32081 
      if fid == 1:
32082 
        if ftype == TType.I64:
32083 
          self.rechargeId = iprot.readI64();
32084 
        else:
32085 
          iprot.skip(ftype)
32086 
      else:
32087 
        iprot.skip(ftype)
32088 
      iprot.readFieldEnd()
32089 
    iprot.readStructEnd()
32090 
 
32091 
  def write(self, oprot):
32092 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
32093 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
32094 
      return
32095 
    oprot.writeStructBegin('getRechargeTransaction_args')
32096 
    if self.rechargeId is not None:
32097 
      oprot.writeFieldBegin('rechargeId', TType.I64, 1)
32098 
      oprot.writeI64(self.rechargeId)
32099 
      oprot.writeFieldEnd()
32100 
    oprot.writeFieldStop()
32101 
    oprot.writeStructEnd()
32102 
 
32103 
  def validate(self):
32104 
    return
32105 
 
32106 
 
32107 
  def __repr__(self):
32108 
    L = ['%s=%r' % (key, value)
32109 
      for key, value in self.__dict__.iteritems()]
32110 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
32111 
 
32112 
  def __eq__(self, other):
32113 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
32114 
 
32115 
  def __ne__(self, other):
32116 
    return not (self == other)
32117 
 
32118 
class getRechargeTransaction_result:
32119 
  """
32120 
  Attributes:
32121 
   - success
32122 
  """
32123 
 
32124 
  thrift_spec = (
32125 
    (0, TType.STRUCT, 'success', (RechargeTransaction, RechargeTransaction.thrift_spec), None, ), # 0
32126 
  )
32127 
 
32128 
  def __init__(self, success=None,):
32129 
    self.success = success
32130 
 
32131 
  def read(self, iprot):
32132 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
32133 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
32134 
      return
32135 
    iprot.readStructBegin()
32136 
    while True:
32137 
      (fname, ftype, fid) = iprot.readFieldBegin()
32138 
      if ftype == TType.STOP:
32139 
        break
32140 
      if fid == 0:
32141 
        if ftype == TType.STRUCT:
32142 
          self.success = RechargeTransaction()
32143 
          self.success.read(iprot)
32144 
        else:
32145 
          iprot.skip(ftype)
32146 
      else:
32147 
        iprot.skip(ftype)
32148 
      iprot.readFieldEnd()
32149 
    iprot.readStructEnd()
32150 
 
32151 
  def write(self, oprot):
32152 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
32153 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
32154 
      return
32155 
    oprot.writeStructBegin('getRechargeTransaction_result')
32156 
    if self.success is not None:
32157 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
32158 
      self.success.write(oprot)
32159 
      oprot.writeFieldEnd()
32160 
    oprot.writeFieldStop()
32161 
    oprot.writeStructEnd()
32162 
 
32163 
  def validate(self):
32164 
    return
32165 
 
32166 
 
32167 
  def __repr__(self):
32168 
    L = ['%s=%r' % (key, value)
32169 
      for key, value in self.__dict__.iteritems()]
32170 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
32171 
 
32172 
  def __eq__(self, other):
32173 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
32174 
 
32175 
  def __ne__(self, other):
32176 
    return not (self == other)
32177 
 
32178 
class getFRCs_args:
32179 
  """
32180 
  Attributes:
32181 
   - circleId
32182 
   - operatorId
32183 
  """
32184 
 
32185 
  thrift_spec = (
32186 
    None, # 0
32187 
    (1, TType.I64, 'circleId', None, None, ), # 1
32188 
    (2, TType.I64, 'operatorId', None, None, ), # 2
32189 
  )
32190 
 
32191 
  def __init__(self, circleId=None, operatorId=None,):
32192 
    self.circleId = circleId
32193 
    self.operatorId = operatorId
32194 
 
32195 
  def read(self, iprot):
32196 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
32197 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
32198 
      return
32199 
    iprot.readStructBegin()
32200 
    while True:
32201 
      (fname, ftype, fid) = iprot.readFieldBegin()
32202 
      if ftype == TType.STOP:
32203 
        break
32204 
      if fid == 1:
32205 
        if ftype == TType.I64:
32206 
          self.circleId = iprot.readI64();
32207 
        else:
32208 
          iprot.skip(ftype)
32209 
      elif fid == 2:
32210 
        if ftype == TType.I64:
32211 
          self.operatorId = iprot.readI64();
32212 
        else:
32213 
          iprot.skip(ftype)
32214 
      else:
32215 
        iprot.skip(ftype)
32216 
      iprot.readFieldEnd()
32217 
    iprot.readStructEnd()
32218 
 
32219 
  def write(self, oprot):
32220 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
32221 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
32222 
      return
32223 
    oprot.writeStructBegin('getFRCs_args')
32224 
    if self.circleId is not None:
32225 
      oprot.writeFieldBegin('circleId', TType.I64, 1)
32226 
      oprot.writeI64(self.circleId)
32227 
      oprot.writeFieldEnd()
32228 
    if self.operatorId is not None:
32229 
      oprot.writeFieldBegin('operatorId', TType.I64, 2)
32230 
      oprot.writeI64(self.operatorId)
32231 
      oprot.writeFieldEnd()
32232 
    oprot.writeFieldStop()
32233 
    oprot.writeStructEnd()
32234 
 
32235 
  def validate(self):
32236 
    return
32237 
 
32238 
 
32239 
  def __repr__(self):
32240 
    L = ['%s=%r' % (key, value)
32241 
      for key, value in self.__dict__.iteritems()]
32242 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
32243 
 
32244 
  def __eq__(self, other):
32245 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
32246 
 
32247 
  def __ne__(self, other):
32248 
    return not (self == other)
32249 
 
32250 
class getFRCs_result:
32251 
  """
32252 
  Attributes:
32253 
   - success
32254 
  """
32255 
 
32256 
  thrift_spec = (
32257 
    (0, TType.LIST, 'success', (TType.STRUCT,(FRC, FRC.thrift_spec)), None, ), # 0
32258 
  )
32259 
 
32260 
  def __init__(self, success=None,):
32261 
    self.success = success
32262 
 
32263 
  def read(self, iprot):
32264 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
32265 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
32266 
      return
32267 
    iprot.readStructBegin()
32268 
    while True:
32269 
      (fname, ftype, fid) = iprot.readFieldBegin()
32270 
      if ftype == TType.STOP:
32271 
        break
32272 
      if fid == 0:
32273 
        if ftype == TType.LIST:
32274 
          self.success = []
7151 amit.gupta 32275 
          (_etype754, _size751) = iprot.readListBegin()
32276 
          for _i755 in xrange(_size751):
32277 
            _elem756 = FRC()
32278 
            _elem756.read(iprot)
32279 
            self.success.append(_elem756)
7080 anupam.sin 32280 
          iprot.readListEnd()
32281 
        else:
32282 
          iprot.skip(ftype)
32283 
      else:
32284 
        iprot.skip(ftype)
32285 
      iprot.readFieldEnd()
32286 
    iprot.readStructEnd()
32287 
 
32288 
  def write(self, oprot):
32289 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
32290 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
32291 
      return
32292 
    oprot.writeStructBegin('getFRCs_result')
32293 
    if self.success is not None:
32294 
      oprot.writeFieldBegin('success', TType.LIST, 0)
32295 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
7151 amit.gupta 32296 
      for iter757 in self.success:
32297 
        iter757.write(oprot)
7080 anupam.sin 32298 
      oprot.writeListEnd()
32299 
      oprot.writeFieldEnd()
32300 
    oprot.writeFieldStop()
32301 
    oprot.writeStructEnd()
32302 
 
32303 
  def validate(self):
32304 
    return
32305 
 
32306 
 
32307 
  def __repr__(self):
32308 
    L = ['%s=%r' % (key, value)
32309 
      for key, value in self.__dict__.iteritems()]
32310 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
32311 
 
32312 
  def __eq__(self, other):
32313 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
32314 
 
32315 
  def __ne__(self, other):
32316 
    return not (self == other)
7096 anupam.sin 32317 
 
32318 
class getHotspotStore_args:
32319 
  """
32320 
  Attributes:
32321 
   - id
32322 
   - hotspotid
32323 
  """
32324 
 
32325 
  thrift_spec = (
32326 
    None, # 0
32327 
    (1, TType.I64, 'id', None, None, ), # 1
32328 
    (2, TType.STRING, 'hotspotid', None, None, ), # 2
32329 
  )
32330 
 
32331 
  def __init__(self, id=None, hotspotid=None,):
32332 
    self.id = id
32333 
    self.hotspotid = hotspotid
32334 
 
32335 
  def read(self, iprot):
32336 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
32337 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
32338 
      return
32339 
    iprot.readStructBegin()
32340 
    while True:
32341 
      (fname, ftype, fid) = iprot.readFieldBegin()
32342 
      if ftype == TType.STOP:
32343 
        break
32344 
      if fid == 1:
32345 
        if ftype == TType.I64:
32346 
          self.id = iprot.readI64();
32347 
        else:
32348 
          iprot.skip(ftype)
32349 
      elif fid == 2:
32350 
        if ftype == TType.STRING:
32351 
          self.hotspotid = iprot.readString();
32352 
        else:
32353 
          iprot.skip(ftype)
32354 
      else:
32355 
        iprot.skip(ftype)
32356 
      iprot.readFieldEnd()
32357 
    iprot.readStructEnd()
32358 
 
32359 
  def write(self, oprot):
32360 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
32361 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
32362 
      return
32363 
    oprot.writeStructBegin('getHotspotStore_args')
32364 
    if self.id is not None:
32365 
      oprot.writeFieldBegin('id', TType.I64, 1)
32366 
      oprot.writeI64(self.id)
32367 
      oprot.writeFieldEnd()
32368 
    if self.hotspotid is not None:
32369 
      oprot.writeFieldBegin('hotspotid', TType.STRING, 2)
32370 
      oprot.writeString(self.hotspotid)
32371 
      oprot.writeFieldEnd()
32372 
    oprot.writeFieldStop()
32373 
    oprot.writeStructEnd()
32374 
 
32375 
  def validate(self):
32376 
    return
32377 
 
32378 
 
32379 
  def __repr__(self):
32380 
    L = ['%s=%r' % (key, value)
32381 
      for key, value in self.__dict__.iteritems()]
32382 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
32383 
 
32384 
  def __eq__(self, other):
32385 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
32386 
 
32387 
  def __ne__(self, other):
32388 
    return not (self == other)
32389 
 
32390 
class getHotspotStore_result:
32391 
  """
32392 
  Attributes:
32393 
   - success
32394 
  """
32395 
 
32396 
  thrift_spec = (
32397 
    (0, TType.STRUCT, 'success', (HotspotStore, HotspotStore.thrift_spec), None, ), # 0
32398 
  )
32399 
 
32400 
  def __init__(self, success=None,):
32401 
    self.success = success
32402 
 
32403 
  def read(self, iprot):
32404 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
32405 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
32406 
      return
32407 
    iprot.readStructBegin()
32408 
    while True:
32409 
      (fname, ftype, fid) = iprot.readFieldBegin()
32410 
      if ftype == TType.STOP:
32411 
        break
32412 
      if fid == 0:
32413 
        if ftype == TType.STRUCT:
32414 
          self.success = HotspotStore()
32415 
          self.success.read(iprot)
32416 
        else:
32417 
          iprot.skip(ftype)
32418 
      else:
32419 
        iprot.skip(ftype)
32420 
      iprot.readFieldEnd()
32421 
    iprot.readStructEnd()
32422 
 
32423 
  def write(self, oprot):
32424 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
32425 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
32426 
      return
32427 
    oprot.writeStructBegin('getHotspotStore_result')
32428 
    if self.success is not None:
32429 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
32430 
      self.success.write(oprot)
32431 
      oprot.writeFieldEnd()
32432 
    oprot.writeFieldStop()
32433 
    oprot.writeStructEnd()
32434 
 
32435 
  def validate(self):
32436 
    return
32437 
 
32438 
 
32439 
  def __repr__(self):
32440 
    L = ['%s=%r' % (key, value)
32441 
      for key, value in self.__dict__.iteritems()]
32442 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
32443 
 
32444 
  def __eq__(self, other):
32445 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
32446 
 
32447 
  def __ne__(self, other):
32448 
    return not (self == other)
32449 
 
32450 
class getTelecomCircle_args:
32451 
  """
32452 
  Attributes:
32453 
   - id
32454 
   - code
32455 
  """
32456 
 
32457 
  thrift_spec = (
32458 
    None, # 0
32459 
    (1, TType.I64, 'id', None, None, ), # 1
32460 
    (2, TType.STRING, 'code', None, None, ), # 2
32461 
  )
32462 
 
32463 
  def __init__(self, id=None, code=None,):
32464 
    self.id = id
32465 
    self.code = code
32466 
 
32467 
  def read(self, iprot):
32468 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
32469 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
32470 
      return
32471 
    iprot.readStructBegin()
32472 
    while True:
32473 
      (fname, ftype, fid) = iprot.readFieldBegin()
32474 
      if ftype == TType.STOP:
32475 
        break
32476 
      if fid == 1:
32477 
        if ftype == TType.I64:
32478 
          self.id = iprot.readI64();
32479 
        else:
32480 
          iprot.skip(ftype)
32481 
      elif fid == 2:
32482 
        if ftype == TType.STRING:
32483 
          self.code = iprot.readString();
32484 
        else:
32485 
          iprot.skip(ftype)
32486 
      else:
32487 
        iprot.skip(ftype)
32488 
      iprot.readFieldEnd()
32489 
    iprot.readStructEnd()
32490 
 
32491 
  def write(self, oprot):
32492 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
32493 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
32494 
      return
32495 
    oprot.writeStructBegin('getTelecomCircle_args')
32496 
    if self.id is not None:
32497 
      oprot.writeFieldBegin('id', TType.I64, 1)
32498 
      oprot.writeI64(self.id)
32499 
      oprot.writeFieldEnd()
32500 
    if self.code is not None:
32501 
      oprot.writeFieldBegin('code', TType.STRING, 2)
32502 
      oprot.writeString(self.code)
32503 
      oprot.writeFieldEnd()
32504 
    oprot.writeFieldStop()
32505 
    oprot.writeStructEnd()
32506 
 
32507 
  def validate(self):
32508 
    return
32509 
 
32510 
 
32511 
  def __repr__(self):
32512 
    L = ['%s=%r' % (key, value)
32513 
      for key, value in self.__dict__.iteritems()]
32514 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
32515 
 
32516 
  def __eq__(self, other):
32517 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
32518 
 
32519 
  def __ne__(self, other):
32520 
    return not (self == other)
32521 
 
32522 
class getTelecomCircle_result:
32523 
  """
32524 
  Attributes:
32525 
   - success
32526 
  """
32527 
 
32528 
  thrift_spec = (
32529 
    (0, TType.STRUCT, 'success', (TelecomCircle, TelecomCircle.thrift_spec), None, ), # 0
32530 
  )
32531 
 
32532 
  def __init__(self, success=None,):
32533 
    self.success = success
32534 
 
32535 
  def read(self, iprot):
32536 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
32537 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
32538 
      return
32539 
    iprot.readStructBegin()
32540 
    while True:
32541 
      (fname, ftype, fid) = iprot.readFieldBegin()
32542 
      if ftype == TType.STOP:
32543 
        break
32544 
      if fid == 0:
32545 
        if ftype == TType.STRUCT:
32546 
          self.success = TelecomCircle()
32547 
          self.success.read(iprot)
32548 
        else:
32549 
          iprot.skip(ftype)
32550 
      else:
32551 
        iprot.skip(ftype)
32552 
      iprot.readFieldEnd()
32553 
    iprot.readStructEnd()
32554 
 
32555 
  def write(self, oprot):
32556 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
32557 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
32558 
      return
32559 
    oprot.writeStructBegin('getTelecomCircle_result')
32560 
    if self.success is not None:
32561 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
32562 
      self.success.write(oprot)
32563 
      oprot.writeFieldEnd()
32564 
    oprot.writeFieldStop()
32565 
    oprot.writeStructEnd()
32566 
 
32567 
  def validate(self):
32568 
    return
32569 
 
32570 
 
32571 
  def __repr__(self):
32572 
    L = ['%s=%r' % (key, value)
32573 
      for key, value in self.__dict__.iteritems()]
32574 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
32575 
 
32576 
  def __eq__(self, other):
32577 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
32578 
 
32579 
  def __ne__(self, other):
32580 
    return not (self == other)
7109 anupam.sin 32581 
 
32582 
class retrieveHotspotRechargeInvoice_args:
32583 
  """
32584 
  Attributes:
32585 
   - rechargeId
32586 
  """
32587 
 
32588 
  thrift_spec = (
32589 
    None, # 0
32590 
    (1, TType.I64, 'rechargeId', None, None, ), # 1
32591 
  )
32592 
 
32593 
  def __init__(self, rechargeId=None,):
32594 
    self.rechargeId = rechargeId
32595 
 
32596 
  def read(self, iprot):
32597 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
32598 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
32599 
      return
32600 
    iprot.readStructBegin()
32601 
    while True:
32602 
      (fname, ftype, fid) = iprot.readFieldBegin()
32603 
      if ftype == TType.STOP:
32604 
        break
32605 
      if fid == 1:
32606 
        if ftype == TType.I64:
32607 
          self.rechargeId = iprot.readI64();
32608 
        else:
32609 
          iprot.skip(ftype)
32610 
      else:
32611 
        iprot.skip(ftype)
32612 
      iprot.readFieldEnd()
32613 
    iprot.readStructEnd()
32614 
 
32615 
  def write(self, oprot):
32616 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
32617 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
32618 
      return
32619 
    oprot.writeStructBegin('retrieveHotspotRechargeInvoice_args')
32620 
    if self.rechargeId is not None:
32621 
      oprot.writeFieldBegin('rechargeId', TType.I64, 1)
32622 
      oprot.writeI64(self.rechargeId)
32623 
      oprot.writeFieldEnd()
32624 
    oprot.writeFieldStop()
32625 
    oprot.writeStructEnd()
32626 
 
32627 
  def validate(self):
32628 
    return
32629 
 
32630 
 
32631 
  def __repr__(self):
32632 
    L = ['%s=%r' % (key, value)
32633 
      for key, value in self.__dict__.iteritems()]
32634 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
32635 
 
32636 
  def __eq__(self, other):
32637 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
32638 
 
32639 
  def __ne__(self, other):
32640 
    return not (self == other)
32641 
 
32642 
class retrieveHotspotRechargeInvoice_result:
32643 
  """
32644 
  Attributes:
32645 
   - success
32646 
  """
32647 
 
32648 
  thrift_spec = (
32649 
    (0, TType.STRING, 'success', None, None, ), # 0
32650 
  )
32651 
 
32652 
  def __init__(self, success=None,):
32653 
    self.success = success
32654 
 
32655 
  def read(self, iprot):
32656 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
32657 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
32658 
      return
32659 
    iprot.readStructBegin()
32660 
    while True:
32661 
      (fname, ftype, fid) = iprot.readFieldBegin()
32662 
      if ftype == TType.STOP:
32663 
        break
32664 
      if fid == 0:
32665 
        if ftype == TType.STRING:
32666 
          self.success = iprot.readString();
32667 
        else:
32668 
          iprot.skip(ftype)
32669 
      else:
32670 
        iprot.skip(ftype)
32671 
      iprot.readFieldEnd()
32672 
    iprot.readStructEnd()
32673 
 
32674 
  def write(self, oprot):
32675 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
32676 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
32677 
      return
32678 
    oprot.writeStructBegin('retrieveHotspotRechargeInvoice_result')
32679 
    if self.success is not None:
32680 
      oprot.writeFieldBegin('success', TType.STRING, 0)
32681 
      oprot.writeString(self.success)
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)
7169 anupam.sin 32700 
 
7190 amar.kumar 32701 
class splitFreebieOrder_args:
32702 
  """
32703 
  Attributes:
32704 
   - orderId
32705 
   - splitReason
32706 
   - shippingDate
32707 
  """
32708 
 
32709 
  thrift_spec = (
32710 
    None, # 0
32711 
    (1, TType.I64, 'orderId', None, None, ), # 1
32712 
    (2, TType.STRING, 'splitReason', None, None, ), # 2
32713 
    (3, TType.I64, 'shippingDate', None, None, ), # 3
32714 
  )
32715 
 
32716 
  def __init__(self, orderId=None, splitReason=None, shippingDate=None,):
32717 
    self.orderId = orderId
32718 
    self.splitReason = splitReason
32719 
    self.shippingDate = shippingDate
32720 
 
32721 
  def read(self, iprot):
32722 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
32723 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
32724 
      return
32725 
    iprot.readStructBegin()
32726 
    while True:
32727 
      (fname, ftype, fid) = iprot.readFieldBegin()
32728 
      if ftype == TType.STOP:
32729 
        break
32730 
      if fid == 1:
32731 
        if ftype == TType.I64:
32732 
          self.orderId = iprot.readI64();
32733 
        else:
32734 
          iprot.skip(ftype)
32735 
      elif fid == 2:
32736 
        if ftype == TType.STRING:
32737 
          self.splitReason = iprot.readString();
32738 
        else:
32739 
          iprot.skip(ftype)
32740 
      elif fid == 3:
32741 
        if ftype == TType.I64:
32742 
          self.shippingDate = iprot.readI64();
32743 
        else:
32744 
          iprot.skip(ftype)
32745 
      else:
32746 
        iprot.skip(ftype)
32747 
      iprot.readFieldEnd()
32748 
    iprot.readStructEnd()
32749 
 
32750 
  def write(self, oprot):
32751 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
32752 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
32753 
      return
32754 
    oprot.writeStructBegin('splitFreebieOrder_args')
32755 
    if self.orderId is not None:
32756 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
32757 
      oprot.writeI64(self.orderId)
32758 
      oprot.writeFieldEnd()
32759 
    if self.splitReason is not None:
32760 
      oprot.writeFieldBegin('splitReason', TType.STRING, 2)
32761 
      oprot.writeString(self.splitReason)
32762 
      oprot.writeFieldEnd()
32763 
    if self.shippingDate is not None:
32764 
      oprot.writeFieldBegin('shippingDate', TType.I64, 3)
32765 
      oprot.writeI64(self.shippingDate)
32766 
      oprot.writeFieldEnd()
32767 
    oprot.writeFieldStop()
32768 
    oprot.writeStructEnd()
32769 
 
32770 
  def validate(self):
32771 
    return
32772 
 
32773 
 
32774 
  def __repr__(self):
32775 
    L = ['%s=%r' % (key, value)
32776 
      for key, value in self.__dict__.iteritems()]
32777 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
32778 
 
32779 
  def __eq__(self, other):
32780 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
32781 
 
32782 
  def __ne__(self, other):
32783 
    return not (self == other)
32784 
 
32785 
class splitFreebieOrder_result:
32786 
  """
32787 
  Attributes:
32788 
   - success
32789 
  """
32790 
 
32791 
  thrift_spec = (
32792 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
32793 
  )
32794 
 
32795 
  def __init__(self, success=None,):
32796 
    self.success = success
32797 
 
32798 
  def read(self, iprot):
32799 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
32800 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
32801 
      return
32802 
    iprot.readStructBegin()
32803 
    while True:
32804 
      (fname, ftype, fid) = iprot.readFieldBegin()
32805 
      if ftype == TType.STOP:
32806 
        break
32807 
      if fid == 0:
32808 
        if ftype == TType.STRUCT:
32809 
          self.success = Order()
32810 
          self.success.read(iprot)
32811 
        else:
32812 
          iprot.skip(ftype)
32813 
      else:
32814 
        iprot.skip(ftype)
32815 
      iprot.readFieldEnd()
32816 
    iprot.readStructEnd()
32817 
 
32818 
  def write(self, oprot):
32819 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
32820 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
32821 
      return
32822 
    oprot.writeStructBegin('splitFreebieOrder_result')
32823 
    if self.success is not None:
32824 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
32825 
      self.success.write(oprot)
32826 
      oprot.writeFieldEnd()
32827 
    oprot.writeFieldStop()
32828 
    oprot.writeStructEnd()
32829 
 
32830 
  def validate(self):
32831 
    return
32832 
 
32833 
 
32834 
  def __repr__(self):
32835 
    L = ['%s=%r' % (key, value)
32836 
      for key, value in self.__dict__.iteritems()]
32837 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
32838 
 
32839 
  def __eq__(self, other):
32840 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
32841 
 
32842 
  def __ne__(self, other):
32843 
    return not (self == other)
32844 
 
7169 anupam.sin 32845 
class getRechargeTransactionsByNumber_args:
32846 
  """
32847 
  Attributes:
32848 
   - number
7172 anupam.sin 32849 
   - storeId
7169 anupam.sin 32850 
  """
32851 
 
32852 
  thrift_spec = (
32853 
    None, # 0
32854 
    (1, TType.STRING, 'number', None, None, ), # 1
7172 anupam.sin 32855 
    (2, TType.I64, 'storeId', None, None, ), # 2
7169 anupam.sin 32856 
  )
32857 
 
7172 anupam.sin 32858 
  def __init__(self, number=None, storeId=None,):
7169 anupam.sin 32859 
    self.number = number
7172 anupam.sin 32860 
    self.storeId = storeId
7169 anupam.sin 32861 
 
32862 
  def read(self, iprot):
32863 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
32864 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
32865 
      return
32866 
    iprot.readStructBegin()
32867 
    while True:
32868 
      (fname, ftype, fid) = iprot.readFieldBegin()
32869 
      if ftype == TType.STOP:
32870 
        break
32871 
      if fid == 1:
32872 
        if ftype == TType.STRING:
32873 
          self.number = iprot.readString();
32874 
        else:
32875 
          iprot.skip(ftype)
7172 anupam.sin 32876 
      elif fid == 2:
32877 
        if ftype == TType.I64:
32878 
          self.storeId = iprot.readI64();
32879 
        else:
32880 
          iprot.skip(ftype)
7169 anupam.sin 32881 
      else:
32882 
        iprot.skip(ftype)
32883 
      iprot.readFieldEnd()
32884 
    iprot.readStructEnd()
32885 
 
32886 
  def write(self, oprot):
32887 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
32888 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
32889 
      return
32890 
    oprot.writeStructBegin('getRechargeTransactionsByNumber_args')
32891 
    if self.number is not None:
32892 
      oprot.writeFieldBegin('number', TType.STRING, 1)
32893 
      oprot.writeString(self.number)
32894 
      oprot.writeFieldEnd()
7172 anupam.sin 32895 
    if self.storeId is not None:
32896 
      oprot.writeFieldBegin('storeId', TType.I64, 2)
32897 
      oprot.writeI64(self.storeId)
32898 
      oprot.writeFieldEnd()
7169 anupam.sin 32899 
    oprot.writeFieldStop()
32900 
    oprot.writeStructEnd()
32901 
 
32902 
  def validate(self):
32903 
    return
32904 
 
32905 
 
32906 
  def __repr__(self):
32907 
    L = ['%s=%r' % (key, value)
32908 
      for key, value in self.__dict__.iteritems()]
32909 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
32910 
 
32911 
  def __eq__(self, other):
32912 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
32913 
 
32914 
  def __ne__(self, other):
32915 
    return not (self == other)
32916 
 
32917 
class getRechargeTransactionsByNumber_result:
32918 
  """
32919 
  Attributes:
32920 
   - success
32921 
  """
32922 
 
32923 
  thrift_spec = (
32924 
    (0, TType.LIST, 'success', (TType.STRUCT,(RechargeTransaction, RechargeTransaction.thrift_spec)), None, ), # 0
32925 
  )
32926 
 
32927 
  def __init__(self, success=None,):
32928 
    self.success = success
32929 
 
32930 
  def read(self, iprot):
32931 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
32932 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
32933 
      return
32934 
    iprot.readStructBegin()
32935 
    while True:
32936 
      (fname, ftype, fid) = iprot.readFieldBegin()
32937 
      if ftype == TType.STOP:
32938 
        break
32939 
      if fid == 0:
32940 
        if ftype == TType.LIST:
32941 
          self.success = []
32942 
          (_etype761, _size758) = iprot.readListBegin()
32943 
          for _i762 in xrange(_size758):
32944 
            _elem763 = RechargeTransaction()
32945 
            _elem763.read(iprot)
32946 
            self.success.append(_elem763)
32947 
          iprot.readListEnd()
32948 
        else:
32949 
          iprot.skip(ftype)
32950 
      else:
32951 
        iprot.skip(ftype)
32952 
      iprot.readFieldEnd()
32953 
    iprot.readStructEnd()
32954 
 
32955 
  def write(self, oprot):
32956 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
32957 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
32958 
      return
32959 
    oprot.writeStructBegin('getRechargeTransactionsByNumber_result')
32960 
    if self.success is not None:
32961 
      oprot.writeFieldBegin('success', TType.LIST, 0)
32962 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
32963 
      for iter764 in self.success:
32964 
        iter764.write(oprot)
32965 
      oprot.writeListEnd()
32966 
      oprot.writeFieldEnd()
32967 
    oprot.writeFieldStop()
32968 
    oprot.writeStructEnd()
32969 
 
32970 
  def validate(self):
32971 
    return
32972 
 
32973 
 
32974 
  def __repr__(self):
32975 
    L = ['%s=%r' % (key, value)
32976 
      for key, value in self.__dict__.iteritems()]
32977 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
32978 
 
32979 
  def __eq__(self, other):
32980 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
32981 
 
32982 
  def __ne__(self, other):
32983 
    return not (self == other)
32984 
 
32985 
class updateHotspotStorePassword_args:
32986 
  """
32987 
  Attributes:
32988 
   - storeId
32989 
   - password
32990 
  """
32991 
 
32992 
  thrift_spec = (
32993 
    None, # 0
32994 
    (1, TType.I64, 'storeId', None, None, ), # 1
32995 
    (2, TType.STRING, 'password', None, None, ), # 2
32996 
  )
32997 
 
32998 
  def __init__(self, storeId=None, password=None,):
32999 
    self.storeId = storeId
33000 
    self.password = password
33001 
 
33002 
  def read(self, iprot):
33003 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
33004 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
33005 
      return
33006 
    iprot.readStructBegin()
33007 
    while True:
33008 
      (fname, ftype, fid) = iprot.readFieldBegin()
33009 
      if ftype == TType.STOP:
33010 
        break
33011 
      if fid == 1:
33012 
        if ftype == TType.I64:
33013 
          self.storeId = iprot.readI64();
33014 
        else:
33015 
          iprot.skip(ftype)
33016 
      elif fid == 2:
33017 
        if ftype == TType.STRING:
33018 
          self.password = iprot.readString();
33019 
        else:
33020 
          iprot.skip(ftype)
33021 
      else:
33022 
        iprot.skip(ftype)
33023 
      iprot.readFieldEnd()
33024 
    iprot.readStructEnd()
33025 
 
33026 
  def write(self, oprot):
33027 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
33028 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
33029 
      return
33030 
    oprot.writeStructBegin('updateHotspotStorePassword_args')
33031 
    if self.storeId is not None:
33032 
      oprot.writeFieldBegin('storeId', TType.I64, 1)
33033 
      oprot.writeI64(self.storeId)
33034 
      oprot.writeFieldEnd()
33035 
    if self.password is not None:
33036 
      oprot.writeFieldBegin('password', TType.STRING, 2)
33037 
      oprot.writeString(self.password)
33038 
      oprot.writeFieldEnd()
33039 
    oprot.writeFieldStop()
33040 
    oprot.writeStructEnd()
33041 
 
33042 
  def validate(self):
33043 
    return
33044 
 
33045 
 
33046 
  def __repr__(self):
33047 
    L = ['%s=%r' % (key, value)
33048 
      for key, value in self.__dict__.iteritems()]
33049 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
33050 
 
33051 
  def __eq__(self, other):
33052 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
33053 
 
33054 
  def __ne__(self, other):
33055 
    return not (self == other)
33056 
 
33057 
class updateHotspotStorePassword_result:
33058 
  """
33059 
  Attributes:
33060 
   - success
33061 
  """
33062 
 
33063 
  thrift_spec = (
33064 
    (0, TType.BOOL, 'success', None, None, ), # 0
33065 
  )
33066 
 
33067 
  def __init__(self, success=None,):
33068 
    self.success = success
33069 
 
33070 
  def read(self, iprot):
33071 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
33072 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
33073 
      return
33074 
    iprot.readStructBegin()
33075 
    while True:
33076 
      (fname, ftype, fid) = iprot.readFieldBegin()
33077 
      if ftype == TType.STOP:
33078 
        break
33079 
      if fid == 0:
33080 
        if ftype == TType.BOOL:
33081 
          self.success = iprot.readBool();
33082 
        else:
33083 
          iprot.skip(ftype)
33084 
      else:
33085 
        iprot.skip(ftype)
33086 
      iprot.readFieldEnd()
33087 
    iprot.readStructEnd()
33088 
 
33089 
  def write(self, oprot):
33090 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
33091 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
33092 
      return
33093 
    oprot.writeStructBegin('updateHotspotStorePassword_result')
33094 
    if self.success is not None:
33095 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
33096 
      oprot.writeBool(self.success)
33097 
      oprot.writeFieldEnd()
33098 
    oprot.writeFieldStop()
33099 
    oprot.writeStructEnd()
33100 
 
33101 
  def validate(self):
33102 
    return
33103 
 
33104 
 
33105 
  def __repr__(self):
33106 
    L = ['%s=%r' % (key, value)
33107 
      for key, value in self.__dict__.iteritems()]
33108 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
33109 
 
33110 
  def __eq__(self, other):
33111 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
33112 
 
33113 
  def __ne__(self, other):
33114 
    return not (self == other)
7263 anupam.sin 33115 
 
7285 rajveer 33116 
class topupCompanyWallet_args:
7263 anupam.sin 33117 
  """
33118 
  Attributes:
7285 rajveer 33119 
   - companyId
33120 
   - amount
7263 anupam.sin 33121 
  """
33122 
 
33123 
  thrift_spec = (
33124 
    None, # 0
7285 rajveer 33125 
    (1, TType.I64, 'companyId', None, None, ), # 1
33126 
    (2, TType.I64, 'amount', None, None, ), # 2
7263 anupam.sin 33127 
  )
33128 
 
7285 rajveer 33129 
  def __init__(self, companyId=None, amount=None,):
33130 
    self.companyId = companyId
33131 
    self.amount = amount
7263 anupam.sin 33132 
 
33133 
  def read(self, iprot):
33134 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
33135 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
33136 
      return
33137 
    iprot.readStructBegin()
33138 
    while True:
33139 
      (fname, ftype, fid) = iprot.readFieldBegin()
33140 
      if ftype == TType.STOP:
33141 
        break
33142 
      if fid == 1:
33143 
        if ftype == TType.I64:
7285 rajveer 33144 
          self.companyId = iprot.readI64();
7263 anupam.sin 33145 
        else:
33146 
          iprot.skip(ftype)
7285 rajveer 33147 
      elif fid == 2:
33148 
        if ftype == TType.I64:
33149 
          self.amount = iprot.readI64();
33150 
        else:
33151 
          iprot.skip(ftype)
7263 anupam.sin 33152 
      else:
33153 
        iprot.skip(ftype)
33154 
      iprot.readFieldEnd()
33155 
    iprot.readStructEnd()
33156 
 
33157 
  def write(self, oprot):
33158 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
33159 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
33160 
      return
7285 rajveer 33161 
    oprot.writeStructBegin('topupCompanyWallet_args')
33162 
    if self.companyId is not None:
33163 
      oprot.writeFieldBegin('companyId', TType.I64, 1)
33164 
      oprot.writeI64(self.companyId)
7263 anupam.sin 33165 
      oprot.writeFieldEnd()
7285 rajveer 33166 
    if self.amount is not None:
33167 
      oprot.writeFieldBegin('amount', TType.I64, 2)
33168 
      oprot.writeI64(self.amount)
33169 
      oprot.writeFieldEnd()
7263 anupam.sin 33170 
    oprot.writeFieldStop()
33171 
    oprot.writeStructEnd()
33172 
 
33173 
  def validate(self):
33174 
    return
33175 
 
33176 
 
33177 
  def __repr__(self):
33178 
    L = ['%s=%r' % (key, value)
33179 
      for key, value in self.__dict__.iteritems()]
33180 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
33181 
 
33182 
  def __eq__(self, other):
33183 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
33184 
 
33185 
  def __ne__(self, other):
33186 
    return not (self == other)
33187 
 
7285 rajveer 33188 
class topupCompanyWallet_result:
7263 anupam.sin 33189 
  """
33190 
  Attributes:
33191 
   - success
33192 
  """
33193 
 
33194 
  thrift_spec = (
7285 rajveer 33195 
    (0, TType.I64, 'success', None, None, ), # 0
7263 anupam.sin 33196 
  )
33197 
 
33198 
  def __init__(self, success=None,):
33199 
    self.success = success
33200 
 
33201 
  def read(self, iprot):
33202 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
33203 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
33204 
      return
33205 
    iprot.readStructBegin()
33206 
    while True:
33207 
      (fname, ftype, fid) = iprot.readFieldBegin()
33208 
      if ftype == TType.STOP:
33209 
        break
33210 
      if fid == 0:
7285 rajveer 33211 
        if ftype == TType.I64:
33212 
          self.success = iprot.readI64();
7263 anupam.sin 33213 
        else:
33214 
          iprot.skip(ftype)
33215 
      else:
33216 
        iprot.skip(ftype)
33217 
      iprot.readFieldEnd()
33218 
    iprot.readStructEnd()
33219 
 
33220 
  def write(self, oprot):
33221 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
33222 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
33223 
      return
7285 rajveer 33224 
    oprot.writeStructBegin('topupCompanyWallet_result')
7263 anupam.sin 33225 
    if self.success is not None:
7285 rajveer 33226 
      oprot.writeFieldBegin('success', TType.I64, 0)
33227 
      oprot.writeI64(self.success)
7263 anupam.sin 33228 
      oprot.writeFieldEnd()
33229 
    oprot.writeFieldStop()
33230 
    oprot.writeStructEnd()
33231 
 
33232 
  def validate(self):
33233 
    return
33234 
 
33235 
 
33236 
  def __repr__(self):
33237 
    L = ['%s=%r' % (key, value)
33238 
      for key, value in self.__dict__.iteritems()]
33239 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
33240 
 
33241 
  def __eq__(self, other):
33242 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
33243 
 
33244 
  def __ne__(self, other):
33245 
    return not (self == other)
7267 anupam.sin 33246 
 
7285 rajveer 33247 
class getWalletBalanceForCompany_args:
33248 
  """
33249 
  Attributes:
33250 
   - companyId
33251 
  """
7267 anupam.sin 33252 
 
33253 
  thrift_spec = (
7285 rajveer 33254 
    None, # 0
33255 
    (1, TType.I64, 'companyId', None, None, ), # 1
7267 anupam.sin 33256 
  )
33257 
 
7285 rajveer 33258 
  def __init__(self, companyId=None,):
33259 
    self.companyId = companyId
33260 
 
7267 anupam.sin 33261 
  def read(self, iprot):
33262 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
33263 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
33264 
      return
33265 
    iprot.readStructBegin()
33266 
    while True:
33267 
      (fname, ftype, fid) = iprot.readFieldBegin()
33268 
      if ftype == TType.STOP:
33269 
        break
7285 rajveer 33270 
      if fid == 1:
33271 
        if ftype == TType.I64:
33272 
          self.companyId = iprot.readI64();
33273 
        else:
33274 
          iprot.skip(ftype)
7267 anupam.sin 33275 
      else:
33276 
        iprot.skip(ftype)
33277 
      iprot.readFieldEnd()
33278 
    iprot.readStructEnd()
33279 
 
33280 
  def write(self, oprot):
33281 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
33282 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
33283 
      return
7285 rajveer 33284 
    oprot.writeStructBegin('getWalletBalanceForCompany_args')
33285 
    if self.companyId is not None:
33286 
      oprot.writeFieldBegin('companyId', TType.I64, 1)
33287 
      oprot.writeI64(self.companyId)
33288 
      oprot.writeFieldEnd()
7267 anupam.sin 33289 
    oprot.writeFieldStop()
33290 
    oprot.writeStructEnd()
33291 
 
33292 
  def validate(self):
33293 
    return
33294 
 
33295 
 
33296 
  def __repr__(self):
33297 
    L = ['%s=%r' % (key, value)
33298 
      for key, value in self.__dict__.iteritems()]
33299 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
33300 
 
33301 
  def __eq__(self, other):
33302 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
33303 
 
33304 
  def __ne__(self, other):
33305 
    return not (self == other)
33306 
 
7285 rajveer 33307 
class getWalletBalanceForCompany_result:
7267 anupam.sin 33308 
  """
33309 
  Attributes:
33310 
   - success
33311 
  """
33312 
 
33313 
  thrift_spec = (
7285 rajveer 33314 
    (0, TType.I64, 'success', None, None, ), # 0
7267 anupam.sin 33315 
  )
33316 
 
33317 
  def __init__(self, success=None,):
33318 
    self.success = success
33319 
 
33320 
  def read(self, iprot):
33321 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
33322 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
33323 
      return
33324 
    iprot.readStructBegin()
33325 
    while True:
33326 
      (fname, ftype, fid) = iprot.readFieldBegin()
33327 
      if ftype == TType.STOP:
33328 
        break
33329 
      if fid == 0:
7285 rajveer 33330 
        if ftype == TType.I64:
33331 
          self.success = iprot.readI64();
7267 anupam.sin 33332 
        else:
33333 
          iprot.skip(ftype)
33334 
      else:
33335 
        iprot.skip(ftype)
33336 
      iprot.readFieldEnd()
33337 
    iprot.readStructEnd()
33338 
 
33339 
  def write(self, oprot):
33340 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
33341 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
33342 
      return
7285 rajveer 33343 
    oprot.writeStructBegin('getWalletBalanceForCompany_result')
7267 anupam.sin 33344 
    if self.success is not None:
7285 rajveer 33345 
      oprot.writeFieldBegin('success', TType.I64, 0)
33346 
      oprot.writeI64(self.success)
7267 anupam.sin 33347 
      oprot.writeFieldEnd()
33348 
    oprot.writeFieldStop()
33349 
    oprot.writeStructEnd()
33350 
 
33351 
  def validate(self):
33352 
    return
33353 
 
33354 
 
33355 
  def __repr__(self):
33356 
    L = ['%s=%r' % (key, value)
33357 
      for key, value in self.__dict__.iteritems()]
33358 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
33359 
 
33360 
  def __eq__(self, other):
33361 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
33362 
 
33363 
  def __ne__(self, other):
33364 
    return not (self == other)
33365 
 
7285 rajveer 33366 
class getSourceDetail_args:
7267 anupam.sin 33367 
  """
33368 
  Attributes:
7285 rajveer 33369 
   - source
7267 anupam.sin 33370 
  """
33371 
 
33372 
  thrift_spec = (
33373 
    None, # 0
7285 rajveer 33374 
    (1, TType.I64, 'source', None, None, ), # 1
7267 anupam.sin 33375 
  )
33376 
 
7285 rajveer 33377 
  def __init__(self, source=None,):
33378 
    self.source = source
7267 anupam.sin 33379 
 
33380 
  def read(self, iprot):
33381 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
33382 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
33383 
      return
33384 
    iprot.readStructBegin()
33385 
    while True:
33386 
      (fname, ftype, fid) = iprot.readFieldBegin()
33387 
      if ftype == TType.STOP:
33388 
        break
33389 
      if fid == 1:
7285 rajveer 33390 
        if ftype == TType.I64:
33391 
          self.source = iprot.readI64();
7267 anupam.sin 33392 
        else:
33393 
          iprot.skip(ftype)
33394 
      else:
33395 
        iprot.skip(ftype)
33396 
      iprot.readFieldEnd()
33397 
    iprot.readStructEnd()
33398 
 
33399 
  def write(self, oprot):
33400 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
33401 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
33402 
      return
7285 rajveer 33403 
    oprot.writeStructBegin('getSourceDetail_args')
33404 
    if self.source is not None:
33405 
      oprot.writeFieldBegin('source', TType.I64, 1)
33406 
      oprot.writeI64(self.source)
7267 anupam.sin 33407 
      oprot.writeFieldEnd()
33408 
    oprot.writeFieldStop()
33409 
    oprot.writeStructEnd()
33410 
 
33411 
  def validate(self):
33412 
    return
33413 
 
33414 
 
33415 
  def __repr__(self):
33416 
    L = ['%s=%r' % (key, value)
33417 
      for key, value in self.__dict__.iteritems()]
33418 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
33419 
 
33420 
  def __eq__(self, other):
33421 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
33422 
 
33423 
  def __ne__(self, other):
33424 
    return not (self == other)
33425 
 
7285 rajveer 33426 
class getSourceDetail_result:
7267 anupam.sin 33427 
  """
33428 
  Attributes:
33429 
   - success
33430 
  """
33431 
 
33432 
  thrift_spec = (
7285 rajveer 33433 
    (0, TType.STRUCT, 'success', (SourceDetail, SourceDetail.thrift_spec), None, ), # 0
7267 anupam.sin 33434 
  )
33435 
 
33436 
  def __init__(self, success=None,):
33437 
    self.success = success
33438 
 
33439 
  def read(self, iprot):
33440 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
33441 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
33442 
      return
33443 
    iprot.readStructBegin()
33444 
    while True:
33445 
      (fname, ftype, fid) = iprot.readFieldBegin()
33446 
      if ftype == TType.STOP:
33447 
        break
33448 
      if fid == 0:
7285 rajveer 33449 
        if ftype == TType.STRUCT:
33450 
          self.success = SourceDetail()
33451 
          self.success.read(iprot)
7267 anupam.sin 33452 
        else:
33453 
          iprot.skip(ftype)
33454 
      else:
33455 
        iprot.skip(ftype)
33456 
      iprot.readFieldEnd()
33457 
    iprot.readStructEnd()
33458 
 
33459 
  def write(self, oprot):
33460 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
33461 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
33462 
      return
7285 rajveer 33463 
    oprot.writeStructBegin('getSourceDetail_result')
7267 anupam.sin 33464 
    if self.success is not None:
7285 rajveer 33465 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
33466 
      self.success.write(oprot)
7267 anupam.sin 33467 
      oprot.writeFieldEnd()
33468 
    oprot.writeFieldStop()
33469 
    oprot.writeStructEnd()
33470 
 
33471 
  def validate(self):
33472 
    return
33473 
 
33474 
 
33475 
  def __repr__(self):
33476 
    L = ['%s=%r' % (key, value)
33477 
      for key, value in self.__dict__.iteritems()]
33478 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
33479 
 
33480 
  def __eq__(self, other):
33481 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
33482 
 
33483 
  def __ne__(self, other):
33484 
    return not (self == other)
7308 rajveer 33485 
 
33486 
class getAllCircles_args:
33487 
 
33488 
  thrift_spec = (
33489 
  )
33490 
 
33491 
  def read(self, iprot):
33492 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
33493 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
33494 
      return
33495 
    iprot.readStructBegin()
33496 
    while True:
33497 
      (fname, ftype, fid) = iprot.readFieldBegin()
33498 
      if ftype == TType.STOP:
33499 
        break
33500 
      else:
33501 
        iprot.skip(ftype)
33502 
      iprot.readFieldEnd()
33503 
    iprot.readStructEnd()
33504 
 
33505 
  def write(self, oprot):
33506 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
33507 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
33508 
      return
33509 
    oprot.writeStructBegin('getAllCircles_args')
33510 
    oprot.writeFieldStop()
33511 
    oprot.writeStructEnd()
33512 
 
33513 
  def validate(self):
33514 
    return
33515 
 
33516 
 
33517 
  def __repr__(self):
33518 
    L = ['%s=%r' % (key, value)
33519 
      for key, value in self.__dict__.iteritems()]
33520 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
33521 
 
33522 
  def __eq__(self, other):
33523 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
33524 
 
33525 
  def __ne__(self, other):
33526 
    return not (self == other)
33527 
 
33528 
class getAllCircles_result:
33529 
  """
33530 
  Attributes:
33531 
   - success
33532 
  """
33533 
 
33534 
  thrift_spec = (
33535 
    (0, TType.LIST, 'success', (TType.STRUCT,(TelecomCircle, TelecomCircle.thrift_spec)), None, ), # 0
33536 
  )
33537 
 
33538 
  def __init__(self, success=None,):
33539 
    self.success = success
33540 
 
33541 
  def read(self, iprot):
33542 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
33543 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
33544 
      return
33545 
    iprot.readStructBegin()
33546 
    while True:
33547 
      (fname, ftype, fid) = iprot.readFieldBegin()
33548 
      if ftype == TType.STOP:
33549 
        break
33550 
      if fid == 0:
33551 
        if ftype == TType.LIST:
33552 
          self.success = []
33553 
          (_etype768, _size765) = iprot.readListBegin()
33554 
          for _i769 in xrange(_size765):
33555 
            _elem770 = TelecomCircle()
33556 
            _elem770.read(iprot)
33557 
            self.success.append(_elem770)
33558 
          iprot.readListEnd()
33559 
        else:
33560 
          iprot.skip(ftype)
33561 
      else:
33562 
        iprot.skip(ftype)
33563 
      iprot.readFieldEnd()
33564 
    iprot.readStructEnd()
33565 
 
33566 
  def write(self, oprot):
33567 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
33568 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
33569 
      return
33570 
    oprot.writeStructBegin('getAllCircles_result')
33571 
    if self.success is not None:
33572 
      oprot.writeFieldBegin('success', TType.LIST, 0)
33573 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
33574 
      for iter771 in self.success:
33575 
        iter771.write(oprot)
33576 
      oprot.writeListEnd()
33577 
      oprot.writeFieldEnd()
33578 
    oprot.writeFieldStop()
33579 
    oprot.writeStructEnd()
33580 
 
33581 
  def validate(self):
33582 
    return
33583 
 
33584 
 
33585 
  def __repr__(self):
33586 
    L = ['%s=%r' % (key, value)
33587 
      for key, value in self.__dict__.iteritems()]
33588 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
33589 
 
33590 
  def __eq__(self, other):
33591 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
33592 
 
33593 
  def __ne__(self, other):
33594 
    return not (self == other)
33595 
 
33596 
class deleteFrcs_args:
33597 
  """
33598 
  Attributes:
33599 
   - frcIdsToDelete
33600 
  """
33601 
 
33602 
  thrift_spec = (
33603 
    None, # 0
33604 
    (1, TType.LIST, 'frcIdsToDelete', (TType.I64,None), None, ), # 1
33605 
  )
33606 
 
33607 
  def __init__(self, frcIdsToDelete=None,):
33608 
    self.frcIdsToDelete = frcIdsToDelete
33609 
 
33610 
  def read(self, iprot):
33611 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
33612 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
33613 
      return
33614 
    iprot.readStructBegin()
33615 
    while True:
33616 
      (fname, ftype, fid) = iprot.readFieldBegin()
33617 
      if ftype == TType.STOP:
33618 
        break
33619 
      if fid == 1:
33620 
        if ftype == TType.LIST:
33621 
          self.frcIdsToDelete = []
33622 
          (_etype775, _size772) = iprot.readListBegin()
33623 
          for _i776 in xrange(_size772):
33624 
            _elem777 = iprot.readI64();
33625 
            self.frcIdsToDelete.append(_elem777)
33626 
          iprot.readListEnd()
33627 
        else:
33628 
          iprot.skip(ftype)
33629 
      else:
33630 
        iprot.skip(ftype)
33631 
      iprot.readFieldEnd()
33632 
    iprot.readStructEnd()
33633 
 
33634 
  def write(self, oprot):
33635 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
33636 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
33637 
      return
33638 
    oprot.writeStructBegin('deleteFrcs_args')
33639 
    if self.frcIdsToDelete is not None:
33640 
      oprot.writeFieldBegin('frcIdsToDelete', TType.LIST, 1)
33641 
      oprot.writeListBegin(TType.I64, len(self.frcIdsToDelete))
33642 
      for iter778 in self.frcIdsToDelete:
33643 
        oprot.writeI64(iter778)
33644 
      oprot.writeListEnd()
33645 
      oprot.writeFieldEnd()
33646 
    oprot.writeFieldStop()
33647 
    oprot.writeStructEnd()
33648 
 
33649 
  def validate(self):
33650 
    return
33651 
 
33652 
 
33653 
  def __repr__(self):
33654 
    L = ['%s=%r' % (key, value)
33655 
      for key, value in self.__dict__.iteritems()]
33656 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
33657 
 
33658 
  def __eq__(self, other):
33659 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
33660 
 
33661 
  def __ne__(self, other):
33662 
    return not (self == other)
33663 
 
33664 
class deleteFrcs_result:
33665 
  """
33666 
  Attributes:
33667 
   - success
33668 
  """
33669 
 
33670 
  thrift_spec = (
33671 
    (0, TType.BOOL, 'success', None, None, ), # 0
33672 
  )
33673 
 
33674 
  def __init__(self, success=None,):
33675 
    self.success = success
33676 
 
33677 
  def read(self, iprot):
33678 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
33679 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
33680 
      return
33681 
    iprot.readStructBegin()
33682 
    while True:
33683 
      (fname, ftype, fid) = iprot.readFieldBegin()
33684 
      if ftype == TType.STOP:
33685 
        break
33686 
      if fid == 0:
33687 
        if ftype == TType.BOOL:
33688 
          self.success = iprot.readBool();
33689 
        else:
33690 
          iprot.skip(ftype)
33691 
      else:
33692 
        iprot.skip(ftype)
33693 
      iprot.readFieldEnd()
33694 
    iprot.readStructEnd()
33695 
 
33696 
  def write(self, oprot):
33697 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
33698 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
33699 
      return
33700 
    oprot.writeStructBegin('deleteFrcs_result')
33701 
    if self.success is not None:
33702 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
33703 
      oprot.writeBool(self.success)
33704 
      oprot.writeFieldEnd()
33705 
    oprot.writeFieldStop()
33706 
    oprot.writeStructEnd()
33707 
 
33708 
  def validate(self):
33709 
    return
33710 
 
33711 
 
33712 
  def __repr__(self):
33713 
    L = ['%s=%r' % (key, value)
33714 
      for key, value in self.__dict__.iteritems()]
33715 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
33716 
 
33717 
  def __eq__(self, other):
33718 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
33719 
 
33720 
  def __ne__(self, other):
33721 
    return not (self == other)
7311 kshitij.so 33722 
 
33723 
class addAmazonOrder_args:
33724 
  """
33725 
  Attributes:
33726 
   - amazonOrder
33727 
  """
33728 
 
33729 
  thrift_spec = (
33730 
    None, # 0
33731 
    (1, TType.STRUCT, 'amazonOrder', (AmazonOrder, AmazonOrder.thrift_spec), None, ), # 1
33732 
  )
33733 
 
33734 
  def __init__(self, amazonOrder=None,):
33735 
    self.amazonOrder = amazonOrder
33736 
 
33737 
  def read(self, iprot):
33738 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
33739 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
33740 
      return
33741 
    iprot.readStructBegin()
33742 
    while True:
33743 
      (fname, ftype, fid) = iprot.readFieldBegin()
33744 
      if ftype == TType.STOP:
33745 
        break
33746 
      if fid == 1:
33747 
        if ftype == TType.STRUCT:
33748 
          self.amazonOrder = AmazonOrder()
33749 
          self.amazonOrder.read(iprot)
33750 
        else:
33751 
          iprot.skip(ftype)
33752 
      else:
33753 
        iprot.skip(ftype)
33754 
      iprot.readFieldEnd()
33755 
    iprot.readStructEnd()
33756 
 
33757 
  def write(self, oprot):
33758 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
33759 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
33760 
      return
33761 
    oprot.writeStructBegin('addAmazonOrder_args')
33762 
    if self.amazonOrder is not None:
33763 
      oprot.writeFieldBegin('amazonOrder', TType.STRUCT, 1)
33764 
      self.amazonOrder.write(oprot)
33765 
      oprot.writeFieldEnd()
33766 
    oprot.writeFieldStop()
33767 
    oprot.writeStructEnd()
33768 
 
33769 
  def validate(self):
33770 
    return
33771 
 
33772 
 
33773 
  def __repr__(self):
33774 
    L = ['%s=%r' % (key, value)
33775 
      for key, value in self.__dict__.iteritems()]
33776 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
33777 
 
33778 
  def __eq__(self, other):
33779 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
33780 
 
33781 
  def __ne__(self, other):
33782 
    return not (self == other)
33783 
 
33784 
class addAmazonOrder_result:
33785 
 
33786 
  thrift_spec = (
33787 
  )
33788 
 
33789 
  def read(self, iprot):
33790 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
33791 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
33792 
      return
33793 
    iprot.readStructBegin()
33794 
    while True:
33795 
      (fname, ftype, fid) = iprot.readFieldBegin()
33796 
      if ftype == TType.STOP:
33797 
        break
33798 
      else:
33799 
        iprot.skip(ftype)
33800 
      iprot.readFieldEnd()
33801 
    iprot.readStructEnd()
33802 
 
33803 
  def write(self, oprot):
33804 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
33805 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
33806 
      return
33807 
    oprot.writeStructBegin('addAmazonOrder_result')
33808 
    oprot.writeFieldStop()
33809 
    oprot.writeStructEnd()
33810 
 
33811 
  def validate(self):
33812 
    return
33813 
 
33814 
 
33815 
  def __repr__(self):
33816 
    L = ['%s=%r' % (key, value)
33817 
      for key, value in self.__dict__.iteritems()]
33818 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
33819 
 
33820 
  def __eq__(self, other):
33821 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
33822 
 
33823 
  def __ne__(self, other):
33824 
    return not (self == other)
33825 
 
7322 vikram.rag 33826 
class updateAmazonOrderStatus_args:
7311 kshitij.so 33827 
  """
33828 
  Attributes:
33829 
   - orderId
33830 
   - status
33831 
  """
33832 
 
33833 
  thrift_spec = (
33834 
    None, # 0
33835 
    (1, TType.I64, 'orderId', None, None, ), # 1
33836 
    (2, TType.STRING, 'status', None, None, ), # 2
33837 
  )
33838 
 
33839 
  def __init__(self, orderId=None, status=None,):
33840 
    self.orderId = orderId
33841 
    self.status = status
33842 
 
33843 
  def read(self, iprot):
33844 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
33845 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
33846 
      return
33847 
    iprot.readStructBegin()
33848 
    while True:
33849 
      (fname, ftype, fid) = iprot.readFieldBegin()
33850 
      if ftype == TType.STOP:
33851 
        break
33852 
      if fid == 1:
33853 
        if ftype == TType.I64:
33854 
          self.orderId = iprot.readI64();
33855 
        else:
33856 
          iprot.skip(ftype)
33857 
      elif fid == 2:
33858 
        if ftype == TType.STRING:
33859 
          self.status = iprot.readString();
33860 
        else:
33861 
          iprot.skip(ftype)
33862 
      else:
33863 
        iprot.skip(ftype)
33864 
      iprot.readFieldEnd()
33865 
    iprot.readStructEnd()
33866 
 
33867 
  def write(self, oprot):
33868 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
33869 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
33870 
      return
7322 vikram.rag 33871 
    oprot.writeStructBegin('updateAmazonOrderStatus_args')
7311 kshitij.so 33872 
    if self.orderId is not None:
33873 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
33874 
      oprot.writeI64(self.orderId)
33875 
      oprot.writeFieldEnd()
33876 
    if self.status is not None:
33877 
      oprot.writeFieldBegin('status', TType.STRING, 2)
33878 
      oprot.writeString(self.status)
33879 
      oprot.writeFieldEnd()
33880 
    oprot.writeFieldStop()
33881 
    oprot.writeStructEnd()
33882 
 
33883 
  def validate(self):
33884 
    return
33885 
 
33886 
 
33887 
  def __repr__(self):
33888 
    L = ['%s=%r' % (key, value)
33889 
      for key, value in self.__dict__.iteritems()]
33890 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
33891 
 
33892 
  def __eq__(self, other):
33893 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
33894 
 
33895 
  def __ne__(self, other):
33896 
    return not (self == other)
33897 
 
7322 vikram.rag 33898 
class updateAmazonOrderStatus_result:
7311 kshitij.so 33899 
  """
33900 
  Attributes:
33901 
   - success
33902 
  """
33903 
 
33904 
  thrift_spec = (
33905 
    (0, TType.BOOL, 'success', None, None, ), # 0
33906 
  )
33907 
 
33908 
  def __init__(self, success=None,):
33909 
    self.success = success
33910 
 
33911 
  def read(self, iprot):
33912 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
33913 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
33914 
      return
33915 
    iprot.readStructBegin()
33916 
    while True:
33917 
      (fname, ftype, fid) = iprot.readFieldBegin()
33918 
      if ftype == TType.STOP:
33919 
        break
33920 
      if fid == 0:
33921 
        if ftype == TType.BOOL:
33922 
          self.success = iprot.readBool();
33923 
        else:
33924 
          iprot.skip(ftype)
33925 
      else:
33926 
        iprot.skip(ftype)
33927 
      iprot.readFieldEnd()
33928 
    iprot.readStructEnd()
33929 
 
33930 
  def write(self, oprot):
33931 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
33932 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
33933 
      return
7322 vikram.rag 33934 
    oprot.writeStructBegin('updateAmazonOrderStatus_result')
7311 kshitij.so 33935 
    if self.success is not None:
33936 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
33937 
      oprot.writeBool(self.success)
33938 
      oprot.writeFieldEnd()
33939 
    oprot.writeFieldStop()
33940 
    oprot.writeStructEnd()
33941 
 
33942 
  def validate(self):
33943 
    return
33944 
 
33945 
 
33946 
  def __repr__(self):
33947 
    L = ['%s=%r' % (key, value)
33948 
      for key, value in self.__dict__.iteritems()]
33949 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
33950 
 
33951 
  def __eq__(self, other):
33952 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
33953 
 
33954 
  def __ne__(self, other):
33955 
    return not (self == other)
33956 
 
33957 
class getAmazonOrdersShipped_args:
33958 
  """
33959 
  Attributes:
33960 
   - interval
33961 
  """
33962 
 
33963 
  thrift_spec = (
33964 
    None, # 0
33965 
    (1, TType.I64, 'interval', None, None, ), # 1
33966 
  )
33967 
 
33968 
  def __init__(self, interval=None,):
33969 
    self.interval = interval
33970 
 
33971 
  def read(self, iprot):
33972 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
33973 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
33974 
      return
33975 
    iprot.readStructBegin()
33976 
    while True:
33977 
      (fname, ftype, fid) = iprot.readFieldBegin()
33978 
      if ftype == TType.STOP:
33979 
        break
33980 
      if fid == 1:
33981 
        if ftype == TType.I64:
33982 
          self.interval = iprot.readI64();
33983 
        else:
33984 
          iprot.skip(ftype)
33985 
      else:
33986 
        iprot.skip(ftype)
33987 
      iprot.readFieldEnd()
33988 
    iprot.readStructEnd()
33989 
 
33990 
  def write(self, oprot):
33991 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
33992 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
33993 
      return
33994 
    oprot.writeStructBegin('getAmazonOrdersShipped_args')
33995 
    if self.interval is not None:
33996 
      oprot.writeFieldBegin('interval', TType.I64, 1)
33997 
      oprot.writeI64(self.interval)
33998 
      oprot.writeFieldEnd()
33999 
    oprot.writeFieldStop()
34000 
    oprot.writeStructEnd()
34001 
 
34002 
  def validate(self):
34003 
    return
34004 
 
34005 
 
34006 
  def __repr__(self):
34007 
    L = ['%s=%r' % (key, value)
34008 
      for key, value in self.__dict__.iteritems()]
34009 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
34010 
 
34011 
  def __eq__(self, other):
34012 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
34013 
 
34014 
  def __ne__(self, other):
34015 
    return not (self == other)
34016 
 
34017 
class getAmazonOrdersShipped_result:
34018 
  """
34019 
  Attributes:
34020 
   - success
34021 
  """
34022 
 
34023 
  thrift_spec = (
34024 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
34025 
  )
34026 
 
34027 
  def __init__(self, success=None,):
34028 
    self.success = success
34029 
 
34030 
  def read(self, iprot):
34031 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
34032 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
34033 
      return
34034 
    iprot.readStructBegin()
34035 
    while True:
34036 
      (fname, ftype, fid) = iprot.readFieldBegin()
34037 
      if ftype == TType.STOP:
34038 
        break
34039 
      if fid == 0:
34040 
        if ftype == TType.LIST:
34041 
          self.success = []
34042 
          (_etype782, _size779) = iprot.readListBegin()
34043 
          for _i783 in xrange(_size779):
34044 
            _elem784 = Order()
34045 
            _elem784.read(iprot)
34046 
            self.success.append(_elem784)
34047 
          iprot.readListEnd()
34048 
        else:
34049 
          iprot.skip(ftype)
34050 
      else:
34051 
        iprot.skip(ftype)
34052 
      iprot.readFieldEnd()
34053 
    iprot.readStructEnd()
34054 
 
34055 
  def write(self, oprot):
34056 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
34057 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
34058 
      return
34059 
    oprot.writeStructBegin('getAmazonOrdersShipped_result')
34060 
    if self.success is not None:
34061 
      oprot.writeFieldBegin('success', TType.LIST, 0)
34062 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
34063 
      for iter785 in self.success:
34064 
        iter785.write(oprot)
34065 
      oprot.writeListEnd()
34066 
      oprot.writeFieldEnd()
34067 
    oprot.writeFieldStop()
34068 
    oprot.writeStructEnd()
34069 
 
34070 
  def validate(self):
34071 
    return
34072 
 
34073 
 
34074 
  def __repr__(self):
34075 
    L = ['%s=%r' % (key, value)
34076 
      for key, value in self.__dict__.iteritems()]
34077 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
34078 
 
34079 
  def __eq__(self, other):
34080 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
34081 
 
34082 
  def __ne__(self, other):
34083 
    return not (self == other)
34084 
 
34085 
class getAmazonOrdersCancelled_args:
34086 
  """
34087 
  Attributes:
34088 
   - interval
34089 
  """
34090 
 
34091 
  thrift_spec = (
34092 
    None, # 0
34093 
    (1, TType.I64, 'interval', None, None, ), # 1
34094 
  )
34095 
 
34096 
  def __init__(self, interval=None,):
34097 
    self.interval = interval
34098 
 
34099 
  def read(self, iprot):
34100 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
34101 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
34102 
      return
34103 
    iprot.readStructBegin()
34104 
    while True:
34105 
      (fname, ftype, fid) = iprot.readFieldBegin()
34106 
      if ftype == TType.STOP:
34107 
        break
34108 
      if fid == 1:
34109 
        if ftype == TType.I64:
34110 
          self.interval = iprot.readI64();
34111 
        else:
34112 
          iprot.skip(ftype)
34113 
      else:
34114 
        iprot.skip(ftype)
34115 
      iprot.readFieldEnd()
34116 
    iprot.readStructEnd()
34117 
 
34118 
  def write(self, oprot):
34119 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
34120 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
34121 
      return
34122 
    oprot.writeStructBegin('getAmazonOrdersCancelled_args')
34123 
    if self.interval is not None:
34124 
      oprot.writeFieldBegin('interval', TType.I64, 1)
34125 
      oprot.writeI64(self.interval)
34126 
      oprot.writeFieldEnd()
34127 
    oprot.writeFieldStop()
34128 
    oprot.writeStructEnd()
34129 
 
34130 
  def validate(self):
34131 
    return
34132 
 
34133 
 
34134 
  def __repr__(self):
34135 
    L = ['%s=%r' % (key, value)
34136 
      for key, value in self.__dict__.iteritems()]
34137 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
34138 
 
34139 
  def __eq__(self, other):
34140 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
34141 
 
34142 
  def __ne__(self, other):
34143 
    return not (self == other)
34144 
 
34145 
class getAmazonOrdersCancelled_result:
34146 
  """
34147 
  Attributes:
34148 
   - success
34149 
  """
34150 
 
34151 
  thrift_spec = (
34152 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
34153 
  )
34154 
 
34155 
  def __init__(self, success=None,):
34156 
    self.success = success
34157 
 
34158 
  def read(self, iprot):
34159 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
34160 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
34161 
      return
34162 
    iprot.readStructBegin()
34163 
    while True:
34164 
      (fname, ftype, fid) = iprot.readFieldBegin()
34165 
      if ftype == TType.STOP:
34166 
        break
34167 
      if fid == 0:
34168 
        if ftype == TType.LIST:
34169 
          self.success = []
34170 
          (_etype789, _size786) = iprot.readListBegin()
34171 
          for _i790 in xrange(_size786):
34172 
            _elem791 = Order()
34173 
            _elem791.read(iprot)
34174 
            self.success.append(_elem791)
34175 
          iprot.readListEnd()
34176 
        else:
34177 
          iprot.skip(ftype)
34178 
      else:
34179 
        iprot.skip(ftype)
34180 
      iprot.readFieldEnd()
34181 
    iprot.readStructEnd()
34182 
 
34183 
  def write(self, oprot):
34184 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
34185 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
34186 
      return
34187 
    oprot.writeStructBegin('getAmazonOrdersCancelled_result')
34188 
    if self.success is not None:
34189 
      oprot.writeFieldBegin('success', TType.LIST, 0)
34190 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
34191 
      for iter792 in self.success:
34192 
        iter792.write(oprot)
34193 
      oprot.writeListEnd()
34194 
      oprot.writeFieldEnd()
34195 
    oprot.writeFieldStop()
34196 
    oprot.writeStructEnd()
34197 
 
34198 
  def validate(self):
34199 
    return
34200 
 
34201 
 
34202 
  def __repr__(self):
34203 
    L = ['%s=%r' % (key, value)
34204 
      for key, value in self.__dict__.iteritems()]
34205 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
34206 
 
34207 
  def __eq__(self, other):
34208 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
34209 
 
34210 
  def __ne__(self, other):
34211 
    return not (self == other)
7322 vikram.rag 34212 
 
34213 
class getAmazonOrder_args:
34214 
  """
34215 
  Attributes:
34216 
   - orderId
34217 
  """
34218 
 
34219 
  thrift_spec = (
34220 
    None, # 0
34221 
    (1, TType.I64, 'orderId', None, None, ), # 1
34222 
  )
34223 
 
34224 
  def __init__(self, orderId=None,):
34225 
    self.orderId = orderId
34226 
 
34227 
  def read(self, iprot):
34228 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
34229 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
34230 
      return
34231 
    iprot.readStructBegin()
34232 
    while True:
34233 
      (fname, ftype, fid) = iprot.readFieldBegin()
34234 
      if ftype == TType.STOP:
34235 
        break
34236 
      if fid == 1:
34237 
        if ftype == TType.I64:
34238 
          self.orderId = iprot.readI64();
34239 
        else:
34240 
          iprot.skip(ftype)
34241 
      else:
34242 
        iprot.skip(ftype)
34243 
      iprot.readFieldEnd()
34244 
    iprot.readStructEnd()
34245 
 
34246 
  def write(self, oprot):
34247 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
34248 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
34249 
      return
34250 
    oprot.writeStructBegin('getAmazonOrder_args')
34251 
    if self.orderId is not None:
34252 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
34253 
      oprot.writeI64(self.orderId)
34254 
      oprot.writeFieldEnd()
34255 
    oprot.writeFieldStop()
34256 
    oprot.writeStructEnd()
34257 
 
34258 
  def validate(self):
34259 
    return
34260 
 
34261 
 
34262 
  def __repr__(self):
34263 
    L = ['%s=%r' % (key, value)
34264 
      for key, value in self.__dict__.iteritems()]
34265 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
34266 
 
34267 
  def __eq__(self, other):
34268 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
34269 
 
34270 
  def __ne__(self, other):
34271 
    return not (self == other)
34272 
 
34273 
class getAmazonOrder_result:
34274 
  """
34275 
  Attributes:
34276 
   - success
34277 
  """
34278 
 
34279 
  thrift_spec = (
34280 
    (0, TType.STRUCT, 'success', (AmazonOrder, AmazonOrder.thrift_spec), None, ), # 0
34281 
  )
34282 
 
34283 
  def __init__(self, success=None,):
34284 
    self.success = success
34285 
 
34286 
  def read(self, iprot):
34287 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
34288 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
34289 
      return
34290 
    iprot.readStructBegin()
34291 
    while True:
34292 
      (fname, ftype, fid) = iprot.readFieldBegin()
34293 
      if ftype == TType.STOP:
34294 
        break
34295 
      if fid == 0:
34296 
        if ftype == TType.STRUCT:
34297 
          self.success = AmazonOrder()
34298 
          self.success.read(iprot)
34299 
        else:
34300 
          iprot.skip(ftype)
34301 
      else:
34302 
        iprot.skip(ftype)
34303 
      iprot.readFieldEnd()
34304 
    iprot.readStructEnd()
34305 
 
34306 
  def write(self, oprot):
34307 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
34308 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
34309 
      return
34310 
    oprot.writeStructBegin('getAmazonOrder_result')
34311 
    if self.success is not None:
34312 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
34313 
      self.success.write(oprot)
34314 
      oprot.writeFieldEnd()
34315 
    oprot.writeFieldStop()
34316 
    oprot.writeStructEnd()
34317 
 
34318 
  def validate(self):
34319 
    return
34320 
 
34321 
 
34322 
  def __repr__(self):
34323 
    L = ['%s=%r' % (key, value)
34324 
      for key, value in self.__dict__.iteritems()]
34325 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
34326 
 
34327 
  def __eq__(self, other):
34328 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
34329 
 
34330 
  def __ne__(self, other):
34331 
    return not (self == other)
7343 anupam.sin 34332 
 
34333 
class getOrdersForStore_args:
34334 
  """
34335 
  Attributes:
34336 
   - id
34337 
   - storeId
34338 
   - startDate
34339 
   - endDate
34340 
   - statuses
34341 
  """
34342 
 
34343 
  thrift_spec = (
34344 
    None, # 0
34345 
    (1, TType.I64, 'id', None, None, ), # 1
34346 
    (2, TType.I64, 'storeId', None, None, ), # 2
34347 
    (3, TType.I64, 'startDate', None, None, ), # 3
34348 
    (4, TType.I64, 'endDate', None, None, ), # 4
34349 
    (5, TType.LIST, 'statuses', (TType.I32,None), None, ), # 5
34350 
  )
34351 
 
34352 
  def __init__(self, id=None, storeId=None, startDate=None, endDate=None, statuses=None,):
34353 
    self.id = id
34354 
    self.storeId = storeId
34355 
    self.startDate = startDate
34356 
    self.endDate = endDate
34357 
    self.statuses = statuses
34358 
 
34359 
  def read(self, iprot):
34360 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
34361 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
34362 
      return
34363 
    iprot.readStructBegin()
34364 
    while True:
34365 
      (fname, ftype, fid) = iprot.readFieldBegin()
34366 
      if ftype == TType.STOP:
34367 
        break
34368 
      if fid == 1:
34369 
        if ftype == TType.I64:
34370 
          self.id = iprot.readI64();
34371 
        else:
34372 
          iprot.skip(ftype)
34373 
      elif fid == 2:
34374 
        if ftype == TType.I64:
34375 
          self.storeId = iprot.readI64();
34376 
        else:
34377 
          iprot.skip(ftype)
34378 
      elif fid == 3:
34379 
        if ftype == TType.I64:
34380 
          self.startDate = iprot.readI64();
34381 
        else:
34382 
          iprot.skip(ftype)
34383 
      elif fid == 4:
34384 
        if ftype == TType.I64:
34385 
          self.endDate = iprot.readI64();
34386 
        else:
34387 
          iprot.skip(ftype)
34388 
      elif fid == 5:
34389 
        if ftype == TType.LIST:
34390 
          self.statuses = []
34391 
          (_etype796, _size793) = iprot.readListBegin()
34392 
          for _i797 in xrange(_size793):
34393 
            _elem798 = iprot.readI32();
34394 
            self.statuses.append(_elem798)
34395 
          iprot.readListEnd()
34396 
        else:
34397 
          iprot.skip(ftype)
34398 
      else:
34399 
        iprot.skip(ftype)
34400 
      iprot.readFieldEnd()
34401 
    iprot.readStructEnd()
34402 
 
34403 
  def write(self, oprot):
34404 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
34405 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
34406 
      return
34407 
    oprot.writeStructBegin('getOrdersForStore_args')
34408 
    if self.id is not None:
34409 
      oprot.writeFieldBegin('id', TType.I64, 1)
34410 
      oprot.writeI64(self.id)
34411 
      oprot.writeFieldEnd()
34412 
    if self.storeId is not None:
34413 
      oprot.writeFieldBegin('storeId', TType.I64, 2)
34414 
      oprot.writeI64(self.storeId)
34415 
      oprot.writeFieldEnd()
34416 
    if self.startDate is not None:
34417 
      oprot.writeFieldBegin('startDate', TType.I64, 3)
34418 
      oprot.writeI64(self.startDate)
34419 
      oprot.writeFieldEnd()
34420 
    if self.endDate is not None:
34421 
      oprot.writeFieldBegin('endDate', TType.I64, 4)
34422 
      oprot.writeI64(self.endDate)
34423 
      oprot.writeFieldEnd()
34424 
    if self.statuses is not None:
34425 
      oprot.writeFieldBegin('statuses', TType.LIST, 5)
34426 
      oprot.writeListBegin(TType.I32, len(self.statuses))
34427 
      for iter799 in self.statuses:
34428 
        oprot.writeI32(iter799)
34429 
      oprot.writeListEnd()
34430 
      oprot.writeFieldEnd()
34431 
    oprot.writeFieldStop()
34432 
    oprot.writeStructEnd()
34433 
 
34434 
  def validate(self):
34435 
    return
34436 
 
34437 
 
34438 
  def __repr__(self):
34439 
    L = ['%s=%r' % (key, value)
34440 
      for key, value in self.__dict__.iteritems()]
34441 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
34442 
 
34443 
  def __eq__(self, other):
34444 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
34445 
 
34446 
  def __ne__(self, other):
34447 
    return not (self == other)
34448 
 
34449 
class getOrdersForStore_result:
34450 
  """
34451 
  Attributes:
34452 
   - success
34453 
  """
34454 
 
34455 
  thrift_spec = (
34456 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
34457 
  )
34458 
 
34459 
  def __init__(self, success=None,):
34460 
    self.success = success
34461 
 
34462 
  def read(self, iprot):
34463 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
34464 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
34465 
      return
34466 
    iprot.readStructBegin()
34467 
    while True:
34468 
      (fname, ftype, fid) = iprot.readFieldBegin()
34469 
      if ftype == TType.STOP:
34470 
        break
34471 
      if fid == 0:
34472 
        if ftype == TType.LIST:
34473 
          self.success = []
34474 
          (_etype803, _size800) = iprot.readListBegin()
34475 
          for _i804 in xrange(_size800):
34476 
            _elem805 = Order()
34477 
            _elem805.read(iprot)
34478 
            self.success.append(_elem805)
34479 
          iprot.readListEnd()
34480 
        else:
34481 
          iprot.skip(ftype)
34482 
      else:
34483 
        iprot.skip(ftype)
34484 
      iprot.readFieldEnd()
34485 
    iprot.readStructEnd()
34486 
 
34487 
  def write(self, oprot):
34488 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
34489 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
34490 
      return
34491 
    oprot.writeStructBegin('getOrdersForStore_result')
34492 
    if self.success is not None:
34493 
      oprot.writeFieldBegin('success', TType.LIST, 0)
34494 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
34495 
      for iter806 in self.success:
34496 
        iter806.write(oprot)
34497 
      oprot.writeListEnd()
34498 
      oprot.writeFieldEnd()
34499 
    oprot.writeFieldStop()
34500 
    oprot.writeStructEnd()
34501 
 
34502 
  def validate(self):
34503 
    return
34504 
 
34505 
 
34506 
  def __repr__(self):
34507 
    L = ['%s=%r' % (key, value)
34508 
      for key, value in self.__dict__.iteritems()]
34509 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
34510 
 
34511 
  def __eq__(self, other):
34512 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
34513 
 
34514 
  def __ne__(self, other):
34515 
    return not (self == other)
34516 
 
34517 
class getStoreOrderAdvanceInvoice_args:
34518 
  """
34519 
  Attributes:
34520 
   - orderId
34521 
  """
34522 
 
34523 
  thrift_spec = (
34524 
    None, # 0
34525 
    (1, TType.I64, 'orderId', None, None, ), # 1
34526 
  )
34527 
 
34528 
  def __init__(self, orderId=None,):
34529 
    self.orderId = orderId
34530 
 
34531 
  def read(self, iprot):
34532 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
34533 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
34534 
      return
34535 
    iprot.readStructBegin()
34536 
    while True:
34537 
      (fname, ftype, fid) = iprot.readFieldBegin()
34538 
      if ftype == TType.STOP:
34539 
        break
34540 
      if fid == 1:
34541 
        if ftype == TType.I64:
34542 
          self.orderId = iprot.readI64();
34543 
        else:
34544 
          iprot.skip(ftype)
34545 
      else:
34546 
        iprot.skip(ftype)
34547 
      iprot.readFieldEnd()
34548 
    iprot.readStructEnd()
34549 
 
34550 
  def write(self, oprot):
34551 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
34552 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
34553 
      return
34554 
    oprot.writeStructBegin('getStoreOrderAdvanceInvoice_args')
34555 
    if self.orderId is not None:
34556 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
34557 
      oprot.writeI64(self.orderId)
34558 
      oprot.writeFieldEnd()
34559 
    oprot.writeFieldStop()
34560 
    oprot.writeStructEnd()
34561 
 
34562 
  def validate(self):
34563 
    return
34564 
 
34565 
 
34566 
  def __repr__(self):
34567 
    L = ['%s=%r' % (key, value)
34568 
      for key, value in self.__dict__.iteritems()]
34569 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
34570 
 
34571 
  def __eq__(self, other):
34572 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
34573 
 
34574 
  def __ne__(self, other):
34575 
    return not (self == other)
34576 
 
34577 
class getStoreOrderAdvanceInvoice_result:
34578 
  """
34579 
  Attributes:
34580 
   - success
34581 
  """
34582 
 
34583 
  thrift_spec = (
34584 
    (0, TType.STRING, 'success', None, None, ), # 0
34585 
  )
34586 
 
34587 
  def __init__(self, success=None,):
34588 
    self.success = success
34589 
 
34590 
  def read(self, iprot):
34591 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
34592 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
34593 
      return
34594 
    iprot.readStructBegin()
34595 
    while True:
34596 
      (fname, ftype, fid) = iprot.readFieldBegin()
34597 
      if ftype == TType.STOP:
34598 
        break
34599 
      if fid == 0:
34600 
        if ftype == TType.STRING:
34601 
          self.success = iprot.readString();
34602 
        else:
34603 
          iprot.skip(ftype)
34604 
      else:
34605 
        iprot.skip(ftype)
34606 
      iprot.readFieldEnd()
34607 
    iprot.readStructEnd()
34608 
 
34609 
  def write(self, oprot):
34610 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
34611 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
34612 
      return
34613 
    oprot.writeStructBegin('getStoreOrderAdvanceInvoice_result')
34614 
    if self.success is not None:
34615 
      oprot.writeFieldBegin('success', TType.STRING, 0)
34616 
      oprot.writeString(self.success)
34617 
      oprot.writeFieldEnd()
34618 
    oprot.writeFieldStop()
34619 
    oprot.writeStructEnd()
34620 
 
34621 
  def validate(self):
34622 
    return
34623 
 
34624 
 
34625 
  def __repr__(self):
34626 
    L = ['%s=%r' % (key, value)
34627 
      for key, value in self.__dict__.iteritems()]
34628 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
34629 
 
34630 
  def __eq__(self, other):
34631 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
34632 
 
34633 
  def __ne__(self, other):
34634 
    return not (self == other)