Subversion Repositories SmartDukaan

Rev

Rev 7285 | Rev 7308 | 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 
 
1601 
 
3376 rajveer 1602 
class Client(shop2020.thriftpy.generic.GenericService.Client, Iface):
94 ashish 1603 
  def __init__(self, iprot, oprot=None):
3376 rajveer 1604 
    shop2020.thriftpy.generic.GenericService.Client.__init__(self, iprot, oprot)
94 ashish 1605 
 
1606 
  def createTransaction(self, transaction):
1607 
    """
1608 
    Parameters:
1609 
     - transaction
1610 
    """
1611 
    self.send_createTransaction(transaction)
132 ashish 1612 
    return self.recv_createTransaction()
94 ashish 1613 
 
1614 
  def send_createTransaction(self, transaction):
1615 
    self._oprot.writeMessageBegin('createTransaction', TMessageType.CALL, self._seqid)
1616 
    args = createTransaction_args()
1617 
    args.transaction = transaction
1618 
    args.write(self._oprot)
1619 
    self._oprot.writeMessageEnd()
1620 
    self._oprot.trans.flush()
1621 
 
1622 
  def recv_createTransaction(self, ):
1623 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1624 
    if mtype == TMessageType.EXCEPTION:
1625 
      x = TApplicationException()
1626 
      x.read(self._iprot)
1627 
      self._iprot.readMessageEnd()
1628 
      raise x
1629 
    result = createTransaction_result()
1630 
    result.read(self._iprot)
1631 
    self._iprot.readMessageEnd()
3431 rajveer 1632 
    if result.success is not None:
132 ashish 1633 
      return result.success
3431 rajveer 1634 
    if result.ex is not None:
94 ashish 1635 
      raise result.ex
132 ashish 1636 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createTransaction failed: unknown result");
94 ashish 1637 
 
1638 
  def getTransaction(self, id):
1639 
    """
1640 
    Parameters:
1641 
     - id
1642 
    """
1643 
    self.send_getTransaction(id)
1644 
    return self.recv_getTransaction()
1645 
 
1646 
  def send_getTransaction(self, id):
1647 
    self._oprot.writeMessageBegin('getTransaction', TMessageType.CALL, self._seqid)
1648 
    args = getTransaction_args()
1649 
    args.id = id
1650 
    args.write(self._oprot)
1651 
    self._oprot.writeMessageEnd()
1652 
    self._oprot.trans.flush()
1653 
 
1654 
  def recv_getTransaction(self, ):
1655 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1656 
    if mtype == TMessageType.EXCEPTION:
1657 
      x = TApplicationException()
1658 
      x.read(self._iprot)
1659 
      self._iprot.readMessageEnd()
1660 
      raise x
1661 
    result = getTransaction_result()
1662 
    result.read(self._iprot)
1663 
    self._iprot.readMessageEnd()
3431 rajveer 1664 
    if result.success is not None:
94 ashish 1665 
      return result.success
3431 rajveer 1666 
    if result.ex is not None:
94 ashish 1667 
      raise result.ex
1668 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransaction failed: unknown result");
1669 
 
1670 
  def getTransactionsForCustomer(self, customerId, from_date, to_date, status):
1671 
    """
1672 
    Parameters:
1673 
     - customerId
1674 
     - from_date
1675 
     - to_date
1676 
     - status
1677 
    """
1678 
    self.send_getTransactionsForCustomer(customerId, from_date, to_date, status)
1679 
    return self.recv_getTransactionsForCustomer()
1680 
 
1681 
  def send_getTransactionsForCustomer(self, customerId, from_date, to_date, status):
1682 
    self._oprot.writeMessageBegin('getTransactionsForCustomer', TMessageType.CALL, self._seqid)
1683 
    args = getTransactionsForCustomer_args()
1684 
    args.customerId = customerId
1685 
    args.from_date = from_date
1686 
    args.to_date = to_date
1687 
    args.status = status
1688 
    args.write(self._oprot)
1689 
    self._oprot.writeMessageEnd()
1690 
    self._oprot.trans.flush()
1691 
 
1692 
  def recv_getTransactionsForCustomer(self, ):
1693 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1694 
    if mtype == TMessageType.EXCEPTION:
1695 
      x = TApplicationException()
1696 
      x.read(self._iprot)
1697 
      self._iprot.readMessageEnd()
1698 
      raise x
1699 
    result = getTransactionsForCustomer_result()
1700 
    result.read(self._iprot)
1701 
    self._iprot.readMessageEnd()
3431 rajveer 1702 
    if result.success is not None:
94 ashish 1703 
      return result.success
3431 rajveer 1704 
    if result.ex is not None:
94 ashish 1705 
      raise result.ex
1706 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransactionsForCustomer failed: unknown result");
1707 
 
132 ashish 1708 
  def getTransactionsForShoppingCartId(self, shoppingCartId):
1709 
    """
1710 
    Parameters:
1711 
     - shoppingCartId
1712 
    """
1713 
    self.send_getTransactionsForShoppingCartId(shoppingCartId)
1714 
    return self.recv_getTransactionsForShoppingCartId()
1715 
 
1716 
  def send_getTransactionsForShoppingCartId(self, shoppingCartId):
1717 
    self._oprot.writeMessageBegin('getTransactionsForShoppingCartId', TMessageType.CALL, self._seqid)
1718 
    args = getTransactionsForShoppingCartId_args()
1719 
    args.shoppingCartId = shoppingCartId
1720 
    args.write(self._oprot)
1721 
    self._oprot.writeMessageEnd()
1722 
    self._oprot.trans.flush()
1723 
 
1724 
  def recv_getTransactionsForShoppingCartId(self, ):
1725 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1726 
    if mtype == TMessageType.EXCEPTION:
1727 
      x = TApplicationException()
1728 
      x.read(self._iprot)
1729 
      self._iprot.readMessageEnd()
1730 
      raise x
1731 
    result = getTransactionsForShoppingCartId_result()
1732 
    result.read(self._iprot)
1733 
    self._iprot.readMessageEnd()
3431 rajveer 1734 
    if result.success is not None:
132 ashish 1735 
      return result.success
3431 rajveer 1736 
    if result.ex is not None:
132 ashish 1737 
      raise result.ex
1738 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransactionsForShoppingCartId failed: unknown result");
1739 
 
94 ashish 1740 
  def getTransactionStatus(self, transactionId):
1741 
    """
1742 
    Parameters:
1743 
     - transactionId
1744 
    """
1745 
    self.send_getTransactionStatus(transactionId)
1746 
    return self.recv_getTransactionStatus()
1747 
 
1748 
  def send_getTransactionStatus(self, transactionId):
1749 
    self._oprot.writeMessageBegin('getTransactionStatus', TMessageType.CALL, self._seqid)
1750 
    args = getTransactionStatus_args()
1751 
    args.transactionId = transactionId
1752 
    args.write(self._oprot)
1753 
    self._oprot.writeMessageEnd()
1754 
    self._oprot.trans.flush()
1755 
 
1756 
  def recv_getTransactionStatus(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 = getTransactionStatus_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, "getTransactionStatus failed: unknown result");
1771 
 
7293 anupam.sin 1772 
  def changeTransactionStatus(self, transactionId, status, description, pickUp, orderType, source):
94 ashish 1773 
    """
1774 
    Parameters:
1775 
     - transactionId
1776 
     - status
1777 
     - description
5527 anupam.sin 1778 
     - pickUp
1779 
     - orderType
7293 anupam.sin 1780 
     - source
94 ashish 1781 
    """
7293 anupam.sin 1782 
    self.send_changeTransactionStatus(transactionId, status, description, pickUp, orderType, source)
94 ashish 1783 
    return self.recv_changeTransactionStatus()
1784 
 
7293 anupam.sin 1785 
  def send_changeTransactionStatus(self, transactionId, status, description, pickUp, orderType, source):
94 ashish 1786 
    self._oprot.writeMessageBegin('changeTransactionStatus', TMessageType.CALL, self._seqid)
1787 
    args = changeTransactionStatus_args()
1788 
    args.transactionId = transactionId
1789 
    args.status = status
1790 
    args.description = description
5527 anupam.sin 1791 
    args.pickUp = pickUp
1792 
    args.orderType = orderType
7293 anupam.sin 1793 
    args.source = source
94 ashish 1794 
    args.write(self._oprot)
1795 
    self._oprot.writeMessageEnd()
1796 
    self._oprot.trans.flush()
1797 
 
1798 
  def recv_changeTransactionStatus(self, ):
1799 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1800 
    if mtype == TMessageType.EXCEPTION:
1801 
      x = TApplicationException()
1802 
      x.read(self._iprot)
1803 
      self._iprot.readMessageEnd()
1804 
      raise x
1805 
    result = changeTransactionStatus_result()
1806 
    result.read(self._iprot)
1807 
    self._iprot.readMessageEnd()
3431 rajveer 1808 
    if result.success is not None:
94 ashish 1809 
      return result.success
3431 rajveer 1810 
    if result.ex is not None:
94 ashish 1811 
      raise result.ex
1812 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "changeTransactionStatus failed: unknown result");
1813 
 
1398 varun.gupt 1814 
  def enqueueTransactionInfoEmail(self, transactionId):
1382 varun.gupt 1815 
    """
1816 
    Parameters:
1817 
     - transactionId
1818 
    """
1398 varun.gupt 1819 
    self.send_enqueueTransactionInfoEmail(transactionId)
1820 
    return self.recv_enqueueTransactionInfoEmail()
1382 varun.gupt 1821 
 
1398 varun.gupt 1822 
  def send_enqueueTransactionInfoEmail(self, transactionId):
1823 
    self._oprot.writeMessageBegin('enqueueTransactionInfoEmail', TMessageType.CALL, self._seqid)
1824 
    args = enqueueTransactionInfoEmail_args()
1382 varun.gupt 1825 
    args.transactionId = transactionId
1826 
    args.write(self._oprot)
1827 
    self._oprot.writeMessageEnd()
1828 
    self._oprot.trans.flush()
1829 
 
1398 varun.gupt 1830 
  def recv_enqueueTransactionInfoEmail(self, ):
1382 varun.gupt 1831 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1832 
    if mtype == TMessageType.EXCEPTION:
1833 
      x = TApplicationException()
1834 
      x.read(self._iprot)
1835 
      self._iprot.readMessageEnd()
1836 
      raise x
1398 varun.gupt 1837 
    result = enqueueTransactionInfoEmail_result()
1382 varun.gupt 1838 
    result.read(self._iprot)
1839 
    self._iprot.readMessageEnd()
3431 rajveer 1840 
    if result.success is not None:
1382 varun.gupt 1841 
      return result.success
3431 rajveer 1842 
    if result.ex is not None:
1382 varun.gupt 1843 
      raise result.ex
1398 varun.gupt 1844 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "enqueueTransactionInfoEmail failed: unknown result");
1382 varun.gupt 1845 
 
4801 anupam.sin 1846 
  def getAllOrders(self, statuses, from_date, to_date, warehouse_id):
94 ashish 1847 
    """
1848 
    Parameters:
4801 anupam.sin 1849 
     - statuses
483 rajveer 1850 
     - from_date
1851 
     - to_date
1852 
     - warehouse_id
94 ashish 1853 
    """
4801 anupam.sin 1854 
    self.send_getAllOrders(statuses, from_date, to_date, warehouse_id)
483 rajveer 1855 
    return self.recv_getAllOrders()
94 ashish 1856 
 
4801 anupam.sin 1857 
  def send_getAllOrders(self, statuses, from_date, to_date, warehouse_id):
483 rajveer 1858 
    self._oprot.writeMessageBegin('getAllOrders', TMessageType.CALL, self._seqid)
1859 
    args = getAllOrders_args()
4801 anupam.sin 1860 
    args.statuses = statuses
483 rajveer 1861 
    args.from_date = from_date
1862 
    args.to_date = to_date
1863 
    args.warehouse_id = warehouse_id
94 ashish 1864 
    args.write(self._oprot)
1865 
    self._oprot.writeMessageEnd()
1866 
    self._oprot.trans.flush()
1867 
 
483 rajveer 1868 
  def recv_getAllOrders(self, ):
94 ashish 1869 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1870 
    if mtype == TMessageType.EXCEPTION:
1871 
      x = TApplicationException()
1872 
      x.read(self._iprot)
1873 
      self._iprot.readMessageEnd()
1874 
      raise x
483 rajveer 1875 
    result = getAllOrders_result()
94 ashish 1876 
    result.read(self._iprot)
1877 
    self._iprot.readMessageEnd()
3431 rajveer 1878 
    if result.success is not None:
94 ashish 1879 
      return result.success
3431 rajveer 1880 
    if result.ex is not None:
94 ashish 1881 
      raise result.ex
483 rajveer 1882 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllOrders failed: unknown result");
94 ashish 1883 
 
4133 chandransh 1884 
  def getOrdersInBatch(self, statuses, offset, limit, warehouse_id):
1885 
    """
1886 
    Returns at most 'limit' orders with the given statuses for the given warehouse starting from the given offset.
1887 
    Pass the status as null and the limit as 0 to ignore them.
1888 
 
1889 
    Parameters:
1890 
     - statuses
1891 
     - offset
1892 
     - limit
1893 
     - warehouse_id
1894 
    """
1895 
    self.send_getOrdersInBatch(statuses, offset, limit, warehouse_id)
1896 
    return self.recv_getOrdersInBatch()
1897 
 
1898 
  def send_getOrdersInBatch(self, statuses, offset, limit, warehouse_id):
1899 
    self._oprot.writeMessageBegin('getOrdersInBatch', TMessageType.CALL, self._seqid)
1900 
    args = getOrdersInBatch_args()
1901 
    args.statuses = statuses
1902 
    args.offset = offset
1903 
    args.limit = limit
1904 
    args.warehouse_id = warehouse_id
1905 
    args.write(self._oprot)
1906 
    self._oprot.writeMessageEnd()
1907 
    self._oprot.trans.flush()
1908 
 
1909 
  def recv_getOrdersInBatch(self, ):
1910 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1911 
    if mtype == TMessageType.EXCEPTION:
1912 
      x = TApplicationException()
1913 
      x.read(self._iprot)
1914 
      self._iprot.readMessageEnd()
1915 
      raise x
1916 
    result = getOrdersInBatch_result()
1917 
    result.read(self._iprot)
1918 
    self._iprot.readMessageEnd()
1919 
    if result.success is not None:
1920 
      return result.success
1921 
    if result.ex is not None:
1922 
      raise result.ex
1923 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersInBatch failed: unknown result");
1924 
 
1925 
  def getOrderCount(self, statuses, warehouseId):
1926 
    """
1927 
    Returns the count of orders with the given statuses assigned to the given warehouse.
1928 
 
1929 
    Parameters:
1930 
     - statuses
1931 
     - warehouseId
1932 
    """
1933 
    self.send_getOrderCount(statuses, warehouseId)
1934 
    return self.recv_getOrderCount()
1935 
 
1936 
  def send_getOrderCount(self, statuses, warehouseId):
1937 
    self._oprot.writeMessageBegin('getOrderCount', TMessageType.CALL, self._seqid)
1938 
    args = getOrderCount_args()
1939 
    args.statuses = statuses
1940 
    args.warehouseId = warehouseId
1941 
    args.write(self._oprot)
1942 
    self._oprot.writeMessageEnd()
1943 
    self._oprot.trans.flush()
1944 
 
1945 
  def recv_getOrderCount(self, ):
1946 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1947 
    if mtype == TMessageType.EXCEPTION:
1948 
      x = TApplicationException()
1949 
      x.read(self._iprot)
1950 
      self._iprot.readMessageEnd()
1951 
      raise x
1952 
    result = getOrderCount_result()
1953 
    result.read(self._iprot)
1954 
    self._iprot.readMessageEnd()
1955 
    if result.success is not None:
1956 
      return result.success
1957 
    if result.ex is not None:
1958 
      raise result.ex
1959 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderCount failed: unknown result");
1960 
 
999 varun.gupt 1961 
  def getOrdersByBillingDate(self, status, start_billing_date, end_billing_date, warehouse_id):
1962 
    """
1132 chandransh 1963 
    Returns orders within a range of their billing dates
3431 rajveer 1964 
 
999 varun.gupt 1965 
    Parameters:
1966 
     - status
1967 
     - start_billing_date
1968 
     - end_billing_date
1969 
     - warehouse_id
1970 
    """
1971 
    self.send_getOrdersByBillingDate(status, start_billing_date, end_billing_date, warehouse_id)
1972 
    return self.recv_getOrdersByBillingDate()
1973 
 
1974 
  def send_getOrdersByBillingDate(self, status, start_billing_date, end_billing_date, warehouse_id):
1975 
    self._oprot.writeMessageBegin('getOrdersByBillingDate', TMessageType.CALL, self._seqid)
1976 
    args = getOrdersByBillingDate_args()
1977 
    args.status = status
1978 
    args.start_billing_date = start_billing_date
1979 
    args.end_billing_date = end_billing_date
1980 
    args.warehouse_id = warehouse_id
1981 
    args.write(self._oprot)
1982 
    self._oprot.writeMessageEnd()
1983 
    self._oprot.trans.flush()
1984 
 
1985 
  def recv_getOrdersByBillingDate(self, ):
1986 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1987 
    if mtype == TMessageType.EXCEPTION:
1988 
      x = TApplicationException()
1989 
      x.read(self._iprot)
1990 
      self._iprot.readMessageEnd()
1991 
      raise x
1992 
    result = getOrdersByBillingDate_result()
1993 
    result.read(self._iprot)
1994 
    self._iprot.readMessageEnd()
3431 rajveer 1995 
    if result.success is not None:
999 varun.gupt 1996 
      return result.success
3431 rajveer 1997 
    if result.ex is not None:
999 varun.gupt 1998 
      raise result.ex
1999 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersByBillingDate failed: unknown result");
2000 
 
3451 chandransh 2001 
  def getOrdersByShippingDate(self, fromShippingDate, toShippingDate, providerId, warehouseId, cod):
3427 chandransh 2002 
    """
2003 
    Returns orders for a particular provider and warehouse which were shipped between the given dates.
3451 chandransh 2004 
    Returned orders comprise of COD orders if cod parameter is true. It comprises of prepaid orders otherwise.
2005 
    Pass providerId and warehouseId as -1 to ignore both these parameters.
3431 rajveer 2006 
 
3427 chandransh 2007 
    Parameters:
2008 
     - fromShippingDate
2009 
     - toShippingDate
2010 
     - providerId
2011 
     - warehouseId
3451 chandransh 2012 
     - cod
3427 chandransh 2013 
    """
3451 chandransh 2014 
    self.send_getOrdersByShippingDate(fromShippingDate, toShippingDate, providerId, warehouseId, cod)
3427 chandransh 2015 
    return self.recv_getOrdersByShippingDate()
2016 
 
3451 chandransh 2017 
  def send_getOrdersByShippingDate(self, fromShippingDate, toShippingDate, providerId, warehouseId, cod):
3427 chandransh 2018 
    self._oprot.writeMessageBegin('getOrdersByShippingDate', TMessageType.CALL, self._seqid)
2019 
    args = getOrdersByShippingDate_args()
2020 
    args.fromShippingDate = fromShippingDate
2021 
    args.toShippingDate = toShippingDate
2022 
    args.providerId = providerId
2023 
    args.warehouseId = warehouseId
3451 chandransh 2024 
    args.cod = cod
3427 chandransh 2025 
    args.write(self._oprot)
2026 
    self._oprot.writeMessageEnd()
2027 
    self._oprot.trans.flush()
2028 
 
2029 
  def recv_getOrdersByShippingDate(self, ):
2030 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2031 
    if mtype == TMessageType.EXCEPTION:
2032 
      x = TApplicationException()
2033 
      x.read(self._iprot)
2034 
      self._iprot.readMessageEnd()
2035 
      raise x
2036 
    result = getOrdersByShippingDate_result()
2037 
    result.read(self._iprot)
2038 
    self._iprot.readMessageEnd()
3431 rajveer 2039 
    if result.success is not None:
3427 chandransh 2040 
      return result.success
3431 rajveer 2041 
    if result.ex is not None:
3427 chandransh 2042 
      raise result.ex
2043 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersByShippingDate failed: unknown result");
2044 
 
1382 varun.gupt 2045 
  def getReturnableOrdersForCustomer(self, customer_id, limit):
2046 
    """
2047 
    Returns order ids for orders which can be returned
3431 rajveer 2048 
 
1382 varun.gupt 2049 
    Parameters:
2050 
     - customer_id
2051 
     - limit
2052 
    """
2053 
    self.send_getReturnableOrdersForCustomer(customer_id, limit)
2054 
    return self.recv_getReturnableOrdersForCustomer()
2055 
 
2056 
  def send_getReturnableOrdersForCustomer(self, customer_id, limit):
2057 
    self._oprot.writeMessageBegin('getReturnableOrdersForCustomer', TMessageType.CALL, self._seqid)
2058 
    args = getReturnableOrdersForCustomer_args()
2059 
    args.customer_id = customer_id
2060 
    args.limit = limit
2061 
    args.write(self._oprot)
2062 
    self._oprot.writeMessageEnd()
2063 
    self._oprot.trans.flush()
2064 
 
2065 
  def recv_getReturnableOrdersForCustomer(self, ):
2066 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2067 
    if mtype == TMessageType.EXCEPTION:
2068 
      x = TApplicationException()
2069 
      x.read(self._iprot)
2070 
      self._iprot.readMessageEnd()
2071 
      raise x
2072 
    result = getReturnableOrdersForCustomer_result()
2073 
    result.read(self._iprot)
2074 
    self._iprot.readMessageEnd()
3431 rajveer 2075 
    if result.success is not None:
1382 varun.gupt 2076 
      return result.success
3431 rajveer 2077 
    if result.ex is not None:
1382 varun.gupt 2078 
      raise result.ex
2079 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReturnableOrdersForCustomer failed: unknown result");
2080 
 
2081 
  def getCancellableOrdersForCustomer(self, customer_id, limit):
2082 
    """
2083 
    Returns order ids for orders which can be cancelled
3431 rajveer 2084 
 
1382 varun.gupt 2085 
    Parameters:
2086 
     - customer_id
2087 
     - limit
2088 
    """
2089 
    self.send_getCancellableOrdersForCustomer(customer_id, limit)
2090 
    return self.recv_getCancellableOrdersForCustomer()
2091 
 
2092 
  def send_getCancellableOrdersForCustomer(self, customer_id, limit):
2093 
    self._oprot.writeMessageBegin('getCancellableOrdersForCustomer', TMessageType.CALL, self._seqid)
2094 
    args = getCancellableOrdersForCustomer_args()
2095 
    args.customer_id = customer_id
2096 
    args.limit = limit
2097 
    args.write(self._oprot)
2098 
    self._oprot.writeMessageEnd()
2099 
    self._oprot.trans.flush()
2100 
 
2101 
  def recv_getCancellableOrdersForCustomer(self, ):
2102 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2103 
    if mtype == TMessageType.EXCEPTION:
2104 
      x = TApplicationException()
2105 
      x.read(self._iprot)
2106 
      self._iprot.readMessageEnd()
2107 
      raise x
2108 
    result = getCancellableOrdersForCustomer_result()
2109 
    result.read(self._iprot)
2110 
    self._iprot.readMessageEnd()
3431 rajveer 2111 
    if result.success is not None:
1382 varun.gupt 2112 
      return result.success
3431 rajveer 2113 
    if result.ex is not None:
1382 varun.gupt 2114 
      raise result.ex
2115 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCancellableOrdersForCustomer failed: unknown result");
2116 
 
483 rajveer 2117 
  def changeOrderStatus(self, orderId, status, description):
94 ashish 2118 
    """
2119 
    Parameters:
483 rajveer 2120 
     - orderId
2121 
     - status
2122 
     - description
94 ashish 2123 
    """
483 rajveer 2124 
    self.send_changeOrderStatus(orderId, status, description)
2125 
    return self.recv_changeOrderStatus()
94 ashish 2126 
 
483 rajveer 2127 
  def send_changeOrderStatus(self, orderId, status, description):
2128 
    self._oprot.writeMessageBegin('changeOrderStatus', TMessageType.CALL, self._seqid)
2129 
    args = changeOrderStatus_args()
2130 
    args.orderId = orderId
2131 
    args.status = status
2132 
    args.description = description
94 ashish 2133 
    args.write(self._oprot)
2134 
    self._oprot.writeMessageEnd()
2135 
    self._oprot.trans.flush()
2136 
 
483 rajveer 2137 
  def recv_changeOrderStatus(self, ):
94 ashish 2138 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2139 
    if mtype == TMessageType.EXCEPTION:
2140 
      x = TApplicationException()
2141 
      x.read(self._iprot)
2142 
      self._iprot.readMessageEnd()
2143 
      raise x
483 rajveer 2144 
    result = changeOrderStatus_result()
94 ashish 2145 
    result.read(self._iprot)
2146 
    self._iprot.readMessageEnd()
3431 rajveer 2147 
    if result.success is not None:
94 ashish 2148 
      return result.success
3431 rajveer 2149 
    if result.ex is not None:
94 ashish 2150 
      raise result.ex
483 rajveer 2151 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "changeOrderStatus failed: unknown result");
94 ashish 2152 
 
1528 ankur.sing 2153 
  def getOrdersForTransaction(self, transactionId, customerId):
94 ashish 2154 
    """
1528 ankur.sing 2155 
    Returns list of orders for given transaction Id. Also filters based on customer Id so that
2156 
    only user who owns the transaction can view its order details.
3431 rajveer 2157 
 
94 ashish 2158 
    Parameters:
2159 
     - transactionId
1528 ankur.sing 2160 
     - customerId
94 ashish 2161 
    """
1528 ankur.sing 2162 
    self.send_getOrdersForTransaction(transactionId, customerId)
483 rajveer 2163 
    return self.recv_getOrdersForTransaction()
94 ashish 2164 
 
1528 ankur.sing 2165 
  def send_getOrdersForTransaction(self, transactionId, customerId):
483 rajveer 2166 
    self._oprot.writeMessageBegin('getOrdersForTransaction', TMessageType.CALL, self._seqid)
2167 
    args = getOrdersForTransaction_args()
94 ashish 2168 
    args.transactionId = transactionId
1528 ankur.sing 2169 
    args.customerId = customerId
94 ashish 2170 
    args.write(self._oprot)
2171 
    self._oprot.writeMessageEnd()
2172 
    self._oprot.trans.flush()
2173 
 
483 rajveer 2174 
  def recv_getOrdersForTransaction(self, ):
94 ashish 2175 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2176 
    if mtype == TMessageType.EXCEPTION:
2177 
      x = TApplicationException()
2178 
      x.read(self._iprot)
2179 
      self._iprot.readMessageEnd()
2180 
      raise x
483 rajveer 2181 
    result = getOrdersForTransaction_result()
94 ashish 2182 
    result.read(self._iprot)
2183 
    self._iprot.readMessageEnd()
3431 rajveer 2184 
    if result.success is not None:
94 ashish 2185 
      return result.success
3431 rajveer 2186 
    if result.ex is not None:
94 ashish 2187 
      raise result.ex
483 rajveer 2188 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersForTransaction failed: unknown result");
94 ashish 2189 
 
3014 chandransh 2190 
  def getOrdersForCustomer(self, customerId, from_date, to_date, statuses):
94 ashish 2191 
    """
3014 chandransh 2192 
    Returns list of orders for the given customer created between the given dates and having the given statuses.
2193 
    Pass and empty list to ignore filtering on statuses.
3431 rajveer 2194 
 
94 ashish 2195 
    Parameters:
483 rajveer 2196 
     - customerId
2197 
     - from_date
2198 
     - to_date
3014 chandransh 2199 
     - statuses
94 ashish 2200 
    """
3014 chandransh 2201 
    self.send_getOrdersForCustomer(customerId, from_date, to_date, statuses)
483 rajveer 2202 
    return self.recv_getOrdersForCustomer()
94 ashish 2203 
 
3014 chandransh 2204 
  def send_getOrdersForCustomer(self, customerId, from_date, to_date, statuses):
483 rajveer 2205 
    self._oprot.writeMessageBegin('getOrdersForCustomer', TMessageType.CALL, self._seqid)
2206 
    args = getOrdersForCustomer_args()
2207 
    args.customerId = customerId
2208 
    args.from_date = from_date
2209 
    args.to_date = to_date
3014 chandransh 2210 
    args.statuses = statuses
94 ashish 2211 
    args.write(self._oprot)
2212 
    self._oprot.writeMessageEnd()
2213 
    self._oprot.trans.flush()
2214 
 
483 rajveer 2215 
  def recv_getOrdersForCustomer(self, ):
94 ashish 2216 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2217 
    if mtype == TMessageType.EXCEPTION:
2218 
      x = TApplicationException()
2219 
      x.read(self._iprot)
2220 
      self._iprot.readMessageEnd()
2221 
      raise x
483 rajveer 2222 
    result = getOrdersForCustomer_result()
94 ashish 2223 
    result.read(self._iprot)
2224 
    self._iprot.readMessageEnd()
3431 rajveer 2225 
    if result.success is not None:
94 ashish 2226 
      return result.success
3431 rajveer 2227 
    if result.ex is not None:
94 ashish 2228 
      raise result.ex
483 rajveer 2229 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersForCustomer failed: unknown result");
94 ashish 2230 
 
483 rajveer 2231 
  def createOrder(self, order):
94 ashish 2232 
    """
2233 
    Parameters:
483 rajveer 2234 
     - order
94 ashish 2235 
    """
483 rajveer 2236 
    self.send_createOrder(order)
2237 
    return self.recv_createOrder()
94 ashish 2238 
 
483 rajveer 2239 
  def send_createOrder(self, order):
2240 
    self._oprot.writeMessageBegin('createOrder', TMessageType.CALL, self._seqid)
2241 
    args = createOrder_args()
2242 
    args.order = order
94 ashish 2243 
    args.write(self._oprot)
2244 
    self._oprot.writeMessageEnd()
2245 
    self._oprot.trans.flush()
2246 
 
483 rajveer 2247 
  def recv_createOrder(self, ):
94 ashish 2248 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2249 
    if mtype == TMessageType.EXCEPTION:
2250 
      x = TApplicationException()
2251 
      x.read(self._iprot)
2252 
      self._iprot.readMessageEnd()
2253 
      raise x
483 rajveer 2254 
    result = createOrder_result()
94 ashish 2255 
    result.read(self._iprot)
2256 
    self._iprot.readMessageEnd()
3431 rajveer 2257 
    if result.success is not None:
94 ashish 2258 
      return result.success
3431 rajveer 2259 
    if result.ex is not None:
94 ashish 2260 
      raise result.ex
483 rajveer 2261 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createOrder failed: unknown result");
94 ashish 2262 
 
483 rajveer 2263 
  def getOrder(self, id):
94 ashish 2264 
    """
2265 
    Parameters:
483 rajveer 2266 
     - id
94 ashish 2267 
    """
483 rajveer 2268 
    self.send_getOrder(id)
2269 
    return self.recv_getOrder()
94 ashish 2270 
 
483 rajveer 2271 
  def send_getOrder(self, id):
2272 
    self._oprot.writeMessageBegin('getOrder', TMessageType.CALL, self._seqid)
2273 
    args = getOrder_args()
2274 
    args.id = id
94 ashish 2275 
    args.write(self._oprot)
2276 
    self._oprot.writeMessageEnd()
2277 
    self._oprot.trans.flush()
2278 
 
483 rajveer 2279 
  def recv_getOrder(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 = getOrder_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, "getOrder failed: unknown result");
94 ashish 2294 
 
483 rajveer 2295 
  def getLineItemsForOrder(self, orderId):
94 ashish 2296 
    """
2297 
    Parameters:
483 rajveer 2298 
     - orderId
94 ashish 2299 
    """
483 rajveer 2300 
    self.send_getLineItemsForOrder(orderId)
2301 
    return self.recv_getLineItemsForOrder()
94 ashish 2302 
 
483 rajveer 2303 
  def send_getLineItemsForOrder(self, orderId):
2304 
    self._oprot.writeMessageBegin('getLineItemsForOrder', TMessageType.CALL, self._seqid)
2305 
    args = getLineItemsForOrder_args()
2306 
    args.orderId = orderId
94 ashish 2307 
    args.write(self._oprot)
2308 
    self._oprot.writeMessageEnd()
2309 
    self._oprot.trans.flush()
2310 
 
483 rajveer 2311 
  def recv_getLineItemsForOrder(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 = getLineItemsForOrder_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, "getLineItemsForOrder failed: unknown result");
94 ashish 2326 
 
4999 phani.kuma 2327 
  def getOrderList(self, order_ids):
2328 
    """
2329 
    Parameters:
2330 
     - order_ids
2331 
    """
2332 
    self.send_getOrderList(order_ids)
2333 
    return self.recv_getOrderList()
2334 
 
2335 
  def send_getOrderList(self, order_ids):
2336 
    self._oprot.writeMessageBegin('getOrderList', TMessageType.CALL, self._seqid)
2337 
    args = getOrderList_args()
2338 
    args.order_ids = order_ids
2339 
    args.write(self._oprot)
2340 
    self._oprot.writeMessageEnd()
2341 
    self._oprot.trans.flush()
2342 
 
2343 
  def recv_getOrderList(self, ):
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
2350 
    result = getOrderList_result()
2351 
    result.read(self._iprot)
2352 
    self._iprot.readMessageEnd()
2353 
    if result.success is not None:
2354 
      return result.success
2355 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderList failed: unknown result");
2356 
 
5386 phani.kuma 2357 
  def getOrderListForVendor(self, order_ids, vendorId):
2358 
    """
2359 
    Parameters:
2360 
     - order_ids
2361 
     - vendorId
2362 
    """
2363 
    self.send_getOrderListForVendor(order_ids, vendorId)
2364 
    return self.recv_getOrderListForVendor()
2365 
 
2366 
  def send_getOrderListForVendor(self, order_ids, vendorId):
2367 
    self._oprot.writeMessageBegin('getOrderListForVendor', TMessageType.CALL, self._seqid)
2368 
    args = getOrderListForVendor_args()
2369 
    args.order_ids = order_ids
2370 
    args.vendorId = vendorId
2371 
    args.write(self._oprot)
2372 
    self._oprot.writeMessageEnd()
2373 
    self._oprot.trans.flush()
2374 
 
2375 
  def recv_getOrderListForVendor(self, ):
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
2382 
    result = getOrderListForVendor_result()
2383 
    result.read(self._iprot)
2384 
    self._iprot.readMessageEnd()
2385 
    if result.success is not None:
2386 
      return result.success
2387 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderListForVendor failed: unknown result");
2388 
 
1528 ankur.sing 2389 
  def getOrderForCustomer(self, orderId, customerId):
2390 
    """
2391 
    Returns an order for the order Id. Also checks if the order belongs to the customer whose Id is passed.
2392 
    Throws exception if either order Id is invalid or order does not below to the customer whose Id is passed.
3431 rajveer 2393 
 
1528 ankur.sing 2394 
    Parameters:
2395 
     - orderId
2396 
     - customerId
2397 
    """
2398 
    self.send_getOrderForCustomer(orderId, customerId)
2399 
    return self.recv_getOrderForCustomer()
2400 
 
2401 
  def send_getOrderForCustomer(self, orderId, customerId):
2402 
    self._oprot.writeMessageBegin('getOrderForCustomer', TMessageType.CALL, self._seqid)
2403 
    args = getOrderForCustomer_args()
2404 
    args.orderId = orderId
2405 
    args.customerId = customerId
2406 
    args.write(self._oprot)
2407 
    self._oprot.writeMessageEnd()
2408 
    self._oprot.trans.flush()
2409 
 
2410 
  def recv_getOrderForCustomer(self, ):
2411 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2412 
    if mtype == TMessageType.EXCEPTION:
2413 
      x = TApplicationException()
2414 
      x.read(self._iprot)
2415 
      self._iprot.readMessageEnd()
2416 
      raise x
2417 
    result = getOrderForCustomer_result()
2418 
    result.read(self._iprot)
2419 
    self._iprot.readMessageEnd()
3431 rajveer 2420 
    if result.success is not None:
1528 ankur.sing 2421 
      return result.success
3431 rajveer 2422 
    if result.ex is not None:
1528 ankur.sing 2423 
      raise result.ex
2424 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderForCustomer failed: unknown result");
2425 
 
4444 rajveer 2426 
  def getAlerts(self, type, warehouseId, status, timestamp):
3064 chandransh 2427 
    """
2428 
    Parameters:
4394 rajveer 2429 
     - type
4444 rajveer 2430 
     - warehouseId
4394 rajveer 2431 
     - status
2432 
     - timestamp
3064 chandransh 2433 
    """
4444 rajveer 2434 
    self.send_getAlerts(type, warehouseId, status, timestamp)
3064 chandransh 2435 
    return self.recv_getAlerts()
2436 
 
4444 rajveer 2437 
  def send_getAlerts(self, type, warehouseId, status, timestamp):
3064 chandransh 2438 
    self._oprot.writeMessageBegin('getAlerts', TMessageType.CALL, self._seqid)
2439 
    args = getAlerts_args()
4394 rajveer 2440 
    args.type = type
4444 rajveer 2441 
    args.warehouseId = warehouseId
4394 rajveer 2442 
    args.status = status
2443 
    args.timestamp = timestamp
3064 chandransh 2444 
    args.write(self._oprot)
2445 
    self._oprot.writeMessageEnd()
2446 
    self._oprot.trans.flush()
2447 
 
2448 
  def recv_getAlerts(self, ):
2449 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2450 
    if mtype == TMessageType.EXCEPTION:
2451 
      x = TApplicationException()
2452 
      x.read(self._iprot)
2453 
      self._iprot.readMessageEnd()
2454 
      raise x
2455 
    result = getAlerts_result()
2456 
    result.read(self._iprot)
2457 
    self._iprot.readMessageEnd()
3431 rajveer 2458 
    if result.success is not None:
3064 chandransh 2459 
      return result.success
2460 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAlerts failed: unknown result");
2461 
 
4444 rajveer 2462 
  def addAlert(self, type, warehouseId, description):
3064 chandransh 2463 
    """
2464 
    Parameters:
2465 
     - type
4444 rajveer 2466 
     - warehouseId
4394 rajveer 2467 
     - description
3064 chandransh 2468 
    """
4444 rajveer 2469 
    self.send_addAlert(type, warehouseId, description)
4394 rajveer 2470 
    self.recv_addAlert()
3064 chandransh 2471 
 
4444 rajveer 2472 
  def send_addAlert(self, type, warehouseId, description):
4394 rajveer 2473 
    self._oprot.writeMessageBegin('addAlert', TMessageType.CALL, self._seqid)
2474 
    args = addAlert_args()
3064 chandransh 2475 
    args.type = type
4444 rajveer 2476 
    args.warehouseId = warehouseId
4394 rajveer 2477 
    args.description = description
3064 chandransh 2478 
    args.write(self._oprot)
2479 
    self._oprot.writeMessageEnd()
2480 
    self._oprot.trans.flush()
2481 
 
4394 rajveer 2482 
  def recv_addAlert(self, ):
3064 chandransh 2483 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2484 
    if mtype == TMessageType.EXCEPTION:
2485 
      x = TApplicationException()
2486 
      x.read(self._iprot)
2487 
      self._iprot.readMessageEnd()
2488 
      raise x
4394 rajveer 2489 
    result = addAlert_result()
3064 chandransh 2490 
    result.read(self._iprot)
2491 
    self._iprot.readMessageEnd()
2492 
    return
2493 
 
4444 rajveer 2494 
  def markAlertsAsSeen(self, warehouseId):
2495 
    """
2496 
    Parameters:
2497 
     - warehouseId
2498 
    """
2499 
    self.send_markAlertsAsSeen(warehouseId)
2500 
    self.recv_markAlertsAsSeen()
2501 
 
2502 
  def send_markAlertsAsSeen(self, warehouseId):
2503 
    self._oprot.writeMessageBegin('markAlertsAsSeen', TMessageType.CALL, self._seqid)
2504 
    args = markAlertsAsSeen_args()
2505 
    args.warehouseId = warehouseId
2506 
    args.write(self._oprot)
2507 
    self._oprot.writeMessageEnd()
2508 
    self._oprot.trans.flush()
2509 
 
2510 
  def recv_markAlertsAsSeen(self, ):
2511 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2512 
    if mtype == TMessageType.EXCEPTION:
2513 
      x = TApplicationException()
2514 
      x.read(self._iprot)
2515 
      self._iprot.readMessageEnd()
2516 
      raise x
2517 
    result = markAlertsAsSeen_result()
2518 
    result.read(self._iprot)
2519 
    self._iprot.readMessageEnd()
2520 
    return
2521 
 
3064 chandransh 2522 
  def getValidOrderCount(self, ):
2523 
    """
2524 
    Return the number of valid orders. (OrderStatus >= OrderStatus.SUBMITTED_FOR_PROCESSING)
2525 
    """
2526 
    self.send_getValidOrderCount()
2527 
    return self.recv_getValidOrderCount()
2528 
 
2529 
  def send_getValidOrderCount(self, ):
2530 
    self._oprot.writeMessageBegin('getValidOrderCount', TMessageType.CALL, self._seqid)
2531 
    args = getValidOrderCount_args()
2532 
    args.write(self._oprot)
2533 
    self._oprot.writeMessageEnd()
2534 
    self._oprot.trans.flush()
2535 
 
2536 
  def recv_getValidOrderCount(self, ):
2537 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2538 
    if mtype == TMessageType.EXCEPTION:
2539 
      x = TApplicationException()
2540 
      x.read(self._iprot)
2541 
      self._iprot.readMessageEnd()
2542 
      raise x
2543 
    result = getValidOrderCount_result()
2544 
    result.read(self._iprot)
2545 
    self._iprot.readMessageEnd()
3431 rajveer 2546 
    if result.success is not None:
3064 chandransh 2547 
      return result.success
2548 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getValidOrderCount failed: unknown result");
2549 
 
2550 
  def getNoOfCustomersWithSuccessfulTransaction(self, ):
2551 
    """
2552 
    Returns the number of distinct customers who have done successful transactions
2553 
    """
2554 
    self.send_getNoOfCustomersWithSuccessfulTransaction()
2555 
    return self.recv_getNoOfCustomersWithSuccessfulTransaction()
2556 
 
2557 
  def send_getNoOfCustomersWithSuccessfulTransaction(self, ):
2558 
    self._oprot.writeMessageBegin('getNoOfCustomersWithSuccessfulTransaction', TMessageType.CALL, self._seqid)
2559 
    args = getNoOfCustomersWithSuccessfulTransaction_args()
2560 
    args.write(self._oprot)
2561 
    self._oprot.writeMessageEnd()
2562 
    self._oprot.trans.flush()
2563 
 
2564 
  def recv_getNoOfCustomersWithSuccessfulTransaction(self, ):
2565 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2566 
    if mtype == TMessageType.EXCEPTION:
2567 
      x = TApplicationException()
2568 
      x.read(self._iprot)
2569 
      self._iprot.readMessageEnd()
2570 
      raise x
2571 
    result = getNoOfCustomersWithSuccessfulTransaction_result()
2572 
    result.read(self._iprot)
2573 
    self._iprot.readMessageEnd()
3431 rajveer 2574 
    if result.success is not None:
3064 chandransh 2575 
      return result.success
2576 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getNoOfCustomersWithSuccessfulTransaction failed: unknown result");
2577 
 
2578 
  def getValidOrdersAmountRange(self, ):
2579 
    """
2580 
    Returns the minimum and maximum amounts of a valid order. (OrderStatus >= OrderStatus.SUBMITTED_FOR_PROCESSING)
2581 
    List contains two values, first minimum amount and second maximum amount.
2582 
    """
2583 
    self.send_getValidOrdersAmountRange()
2584 
    return self.recv_getValidOrdersAmountRange()
2585 
 
2586 
  def send_getValidOrdersAmountRange(self, ):
2587 
    self._oprot.writeMessageBegin('getValidOrdersAmountRange', TMessageType.CALL, self._seqid)
2588 
    args = getValidOrdersAmountRange_args()
2589 
    args.write(self._oprot)
2590 
    self._oprot.writeMessageEnd()
2591 
    self._oprot.trans.flush()
2592 
 
2593 
  def recv_getValidOrdersAmountRange(self, ):
2594 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2595 
    if mtype == TMessageType.EXCEPTION:
2596 
      x = TApplicationException()
2597 
      x.read(self._iprot)
2598 
      self._iprot.readMessageEnd()
2599 
      raise x
2600 
    result = getValidOrdersAmountRange_result()
2601 
    result.read(self._iprot)
2602 
    self._iprot.readMessageEnd()
3431 rajveer 2603 
    if result.success is not None:
3064 chandransh 2604 
      return result.success
2605 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getValidOrdersAmountRange failed: unknown result");
2606 
 
5874 rajveer 2607 
  def getValidOrders(self, limit, onlyStore):
3064 chandransh 2608 
    """
2609 
    Returns list of Orders in descending order by Order creation date. List is restricted to limit Orders.
2610 
    If limit is passed as 0, then all valid Orders are returned.
3431 rajveer 2611 
 
3064 chandransh 2612 
    Parameters:
2613 
     - limit
5874 rajveer 2614 
     - onlyStore
3064 chandransh 2615 
    """
5874 rajveer 2616 
    self.send_getValidOrders(limit, onlyStore)
3064 chandransh 2617 
    return self.recv_getValidOrders()
2618 
 
5874 rajveer 2619 
  def send_getValidOrders(self, limit, onlyStore):
3064 chandransh 2620 
    self._oprot.writeMessageBegin('getValidOrders', TMessageType.CALL, self._seqid)
2621 
    args = getValidOrders_args()
2622 
    args.limit = limit
5874 rajveer 2623 
    args.onlyStore = onlyStore
3064 chandransh 2624 
    args.write(self._oprot)
2625 
    self._oprot.writeMessageEnd()
2626 
    self._oprot.trans.flush()
2627 
 
2628 
  def recv_getValidOrders(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 = getValidOrders_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, "getValidOrders failed: unknown result");
2641 
 
1220 chandransh 2642 
  def batchOrders(self, warehouseId):
2643 
    """
2644 
    Create a batch of all the pending orders for the given warehouse.
2645 
    The returned list is orderd by created_timestamp.
2646 
    If there are no pending orders, an empty list is returned.
3431 rajveer 2647 
 
1220 chandransh 2648 
    Parameters:
2649 
     - warehouseId
2650 
    """
2651 
    self.send_batchOrders(warehouseId)
2652 
    return self.recv_batchOrders()
2653 
 
2654 
  def send_batchOrders(self, warehouseId):
2655 
    self._oprot.writeMessageBegin('batchOrders', TMessageType.CALL, self._seqid)
2656 
    args = batchOrders_args()
2657 
    args.warehouseId = warehouseId
2658 
    args.write(self._oprot)
2659 
    self._oprot.writeMessageEnd()
2660 
    self._oprot.trans.flush()
2661 
 
2662 
  def recv_batchOrders(self, ):
2663 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2664 
    if mtype == TMessageType.EXCEPTION:
2665 
      x = TApplicationException()
2666 
      x.read(self._iprot)
2667 
      self._iprot.readMessageEnd()
2668 
      raise x
2669 
    result = batchOrders_result()
2670 
    result.read(self._iprot)
2671 
    self._iprot.readMessageEnd()
3431 rajveer 2672 
    if result.success is not None:
1220 chandransh 2673 
      return result.success
3431 rajveer 2674 
    if result.ex is not None:
1220 chandransh 2675 
      raise result.ex
2676 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "batchOrders failed: unknown result");
2677 
 
1208 chandransh 2678 
  def markOrderAsOutOfStock(self, orderId):
2679 
    """
2680 
    Mark the given order as out of stock. Throws an exception if the order with the given Id couldn't be found.
3431 rajveer 2681 
 
1208 chandransh 2682 
    Parameters:
2683 
     - orderId
2684 
    """
2685 
    self.send_markOrderAsOutOfStock(orderId)
2686 
    return self.recv_markOrderAsOutOfStock()
2687 
 
2688 
  def send_markOrderAsOutOfStock(self, orderId):
2689 
    self._oprot.writeMessageBegin('markOrderAsOutOfStock', TMessageType.CALL, self._seqid)
2690 
    args = markOrderAsOutOfStock_args()
2691 
    args.orderId = orderId
2692 
    args.write(self._oprot)
2693 
    self._oprot.writeMessageEnd()
2694 
    self._oprot.trans.flush()
2695 
 
2696 
  def recv_markOrderAsOutOfStock(self, ):
2697 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2698 
    if mtype == TMessageType.EXCEPTION:
2699 
      x = TApplicationException()
2700 
      x.read(self._iprot)
2701 
      self._iprot.readMessageEnd()
2702 
      raise x
2703 
    result = markOrderAsOutOfStock_result()
2704 
    result.read(self._iprot)
2705 
    self._iprot.readMessageEnd()
3431 rajveer 2706 
    if result.success is not None:
1208 chandransh 2707 
      return result.success
3431 rajveer 2708 
    if result.ex is not None:
1208 chandransh 2709 
      raise result.ex
2710 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderAsOutOfStock failed: unknown result");
2711 
 
3064 chandransh 2712 
  def verifyOrder(self, orderId):
759 chandransh 2713 
    """
3064 chandransh 2714 
    Marks the given order as SUBMITTED_FOR_PROCESSING and updates the verified
2715 
    timestamp. It is intended to be used for COD orders but can be harmlessly
2716 
    used for all other orders as well.
2717 
    Throws an exception if no such order exists.
3431 rajveer 2718 
 
759 chandransh 2719 
    Parameters:
3064 chandransh 2720 
     - orderId
759 chandransh 2721 
    """
3064 chandransh 2722 
    self.send_verifyOrder(orderId)
2723 
    return self.recv_verifyOrder()
759 chandransh 2724 
 
3064 chandransh 2725 
  def send_verifyOrder(self, orderId):
2726 
    self._oprot.writeMessageBegin('verifyOrder', TMessageType.CALL, self._seqid)
2727 
    args = verifyOrder_args()
2728 
    args.orderId = orderId
759 chandransh 2729 
    args.write(self._oprot)
2730 
    self._oprot.writeMessageEnd()
2731 
    self._oprot.trans.flush()
2732 
 
3064 chandransh 2733 
  def recv_verifyOrder(self, ):
759 chandransh 2734 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2735 
    if mtype == TMessageType.EXCEPTION:
2736 
      x = TApplicationException()
2737 
      x.read(self._iprot)
2738 
      self._iprot.readMessageEnd()
2739 
      raise x
3064 chandransh 2740 
    result = verifyOrder_result()
759 chandransh 2741 
    result.read(self._iprot)
2742 
    self._iprot.readMessageEnd()
3431 rajveer 2743 
    if result.success is not None:
759 chandransh 2744 
      return result.success
3431 rajveer 2745 
    if result.ex is not None:
759 chandransh 2746 
      raise result.ex
3064 chandransh 2747 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "verifyOrder failed: unknown result");
759 chandransh 2748 
 
3064 chandransh 2749 
  def acceptOrder(self, orderId):
1113 chandransh 2750 
    """
3064 chandransh 2751 
    Marks the given order as ACCEPTED and updates the accepted timestamp. If the
2752 
    given order is not a COD order, it also captures the payment if the same has
2753 
    not been captured.
2754 
    Throws an exception if no such order exists.
3431 rajveer 2755 
 
1113 chandransh 2756 
    Parameters:
3064 chandransh 2757 
     - orderId
1113 chandransh 2758 
    """
3064 chandransh 2759 
    self.send_acceptOrder(orderId)
2760 
    return self.recv_acceptOrder()
1113 chandransh 2761 
 
3064 chandransh 2762 
  def send_acceptOrder(self, orderId):
2763 
    self._oprot.writeMessageBegin('acceptOrder', TMessageType.CALL, self._seqid)
2764 
    args = acceptOrder_args()
2765 
    args.orderId = orderId
1113 chandransh 2766 
    args.write(self._oprot)
2767 
    self._oprot.writeMessageEnd()
2768 
    self._oprot.trans.flush()
2769 
 
3064 chandransh 2770 
  def recv_acceptOrder(self, ):
1113 chandransh 2771 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2772 
    if mtype == TMessageType.EXCEPTION:
2773 
      x = TApplicationException()
2774 
      x.read(self._iprot)
2775 
      self._iprot.readMessageEnd()
2776 
      raise x
3064 chandransh 2777 
    result = acceptOrder_result()
1113 chandransh 2778 
    result.read(self._iprot)
2779 
    self._iprot.readMessageEnd()
3431 rajveer 2780 
    if result.success is not None:
1113 chandransh 2781 
      return result.success
3431 rajveer 2782 
    if result.ex is not None:
1113 chandransh 2783 
      raise result.ex
3064 chandransh 2784 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "acceptOrder failed: unknown result");
1113 chandransh 2785 
 
7190 amar.kumar 2786 
  def addBillingDetails(self, orderId, invoice_number, serialNumber, itemNumber, freebieWarehouseId, billed_by, jacketNumber, billingType, fulfilmentWarehouseId, authorize):
1132 chandransh 2787 
    """
3064 chandransh 2788 
    Add billing details such as the bill number and the biller to the Order.
4658 mandeep.dh 2789 
    Adds jacket number, item number and Serial no. to the order. Doesn't update
4283 anupam.sin 2790 
    the IMEI no. if a -1 is supplied.
2791 
    Also, it generates an invoice number for the order, marks the order as
2792 
    BILLED and sets the billing timestamp.
2793 
    Returns false if it doesn't find the order with the given ID.
3431 rajveer 2794 
 
1135 chandransh 2795 
    Parameters:
3064 chandransh 2796 
     - orderId
2797 
     - invoice_number
4658 mandeep.dh 2798 
     - serialNumber
4283 anupam.sin 2799 
     - itemNumber
7190 amar.kumar 2800 
     - freebieWarehouseId
3064 chandransh 2801 
     - billed_by
4264 rajveer 2802 
     - jacketNumber
4283 anupam.sin 2803 
     - billingType
5110 mandeep.dh 2804 
     - fulfilmentWarehouseId
4763 rajveer 2805 
     - authorize
1135 chandransh 2806 
    """
7190 amar.kumar 2807 
    self.send_addBillingDetails(orderId, invoice_number, serialNumber, itemNumber, freebieWarehouseId, billed_by, jacketNumber, billingType, fulfilmentWarehouseId, authorize)
3064 chandransh 2808 
    return self.recv_addBillingDetails()
1135 chandransh 2809 
 
7190 amar.kumar 2810 
  def send_addBillingDetails(self, orderId, invoice_number, serialNumber, itemNumber, freebieWarehouseId, billed_by, jacketNumber, billingType, fulfilmentWarehouseId, authorize):
3064 chandransh 2811 
    self._oprot.writeMessageBegin('addBillingDetails', TMessageType.CALL, self._seqid)
2812 
    args = addBillingDetails_args()
2813 
    args.orderId = orderId
2814 
    args.invoice_number = invoice_number
4658 mandeep.dh 2815 
    args.serialNumber = serialNumber
4283 anupam.sin 2816 
    args.itemNumber = itemNumber
7190 amar.kumar 2817 
    args.freebieWarehouseId = freebieWarehouseId
3064 chandransh 2818 
    args.billed_by = billed_by
4264 rajveer 2819 
    args.jacketNumber = jacketNumber
4283 anupam.sin 2820 
    args.billingType = billingType
5110 mandeep.dh 2821 
    args.fulfilmentWarehouseId = fulfilmentWarehouseId
4763 rajveer 2822 
    args.authorize = authorize
1135 chandransh 2823 
    args.write(self._oprot)
2824 
    self._oprot.writeMessageEnd()
2825 
    self._oprot.trans.flush()
2826 
 
3064 chandransh 2827 
  def recv_addBillingDetails(self, ):
1135 chandransh 2828 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2829 
    if mtype == TMessageType.EXCEPTION:
2830 
      x = TApplicationException()
2831 
      x.read(self._iprot)
2832 
      self._iprot.readMessageEnd()
2833 
      raise x
3064 chandransh 2834 
    result = addBillingDetails_result()
1135 chandransh 2835 
    result.read(self._iprot)
2836 
    self._iprot.readMessageEnd()
3431 rajveer 2837 
    if result.success is not None:
3064 chandransh 2838 
      return result.success
3431 rajveer 2839 
    if result.ex is not None:
1135 chandransh 2840 
      raise result.ex
3064 chandransh 2841 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addBillingDetails failed: unknown result");
1135 chandransh 2842 
 
6756 amar.kumar 2843 
  def addInvoiceNumber(self, orderId, invoiceNumber, color, serialNumber, itemNumber):
4579 rajveer 2844 
    """
2845 
    Add the invoice number to the order.
2846 
 
2847 
    Parameters:
2848 
     - orderId
2849 
     - invoiceNumber
4763 rajveer 2850 
     - color
6756 amar.kumar 2851 
     - serialNumber
2852 
     - itemNumber
4579 rajveer 2853 
    """
6756 amar.kumar 2854 
    self.send_addInvoiceNumber(orderId, invoiceNumber, color, serialNumber, itemNumber)
4579 rajveer 2855 
    self.recv_addInvoiceNumber()
2856 
 
6756 amar.kumar 2857 
  def send_addInvoiceNumber(self, orderId, invoiceNumber, color, serialNumber, itemNumber):
4579 rajveer 2858 
    self._oprot.writeMessageBegin('addInvoiceNumber', TMessageType.CALL, self._seqid)
2859 
    args = addInvoiceNumber_args()
2860 
    args.orderId = orderId
2861 
    args.invoiceNumber = invoiceNumber
4763 rajveer 2862 
    args.color = color
6756 amar.kumar 2863 
    args.serialNumber = serialNumber
2864 
    args.itemNumber = itemNumber
4579 rajveer 2865 
    args.write(self._oprot)
2866 
    self._oprot.writeMessageEnd()
2867 
    self._oprot.trans.flush()
2868 
 
2869 
  def recv_addInvoiceNumber(self, ):
2870 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2871 
    if mtype == TMessageType.EXCEPTION:
2872 
      x = TApplicationException()
2873 
      x.read(self._iprot)
2874 
      self._iprot.readMessageEnd()
2875 
      raise x
2876 
    result = addInvoiceNumber_result()
2877 
    result.read(self._iprot)
2878 
    self._iprot.readMessageEnd()
2879 
    if result.ex is not None:
2880 
      raise result.ex
2881 
    return
2882 
 
4910 phani.kuma 2883 
  def markOrdersAsShippedFromWarehouse(self, warehouseId, providerId, cod, orderIds):
1408 ankur.sing 2884 
    """
3064 chandransh 2885 
    Depending on the third parameter, marks either all prepaid or all cod orders BILLED by the
4910 phani.kuma 2886 
    given warehouse and were picked up by the given provider as SHIPPED_FROM_WH.
3431 rajveer 2887 
 
1408 ankur.sing 2888 
    Parameters:
3064 chandransh 2889 
     - warehouseId
1408 ankur.sing 2890 
     - providerId
3064 chandransh 2891 
     - cod
4910 phani.kuma 2892 
     - orderIds
1408 ankur.sing 2893 
    """
4910 phani.kuma 2894 
    self.send_markOrdersAsShippedFromWarehouse(warehouseId, providerId, cod, orderIds)
2895 
    return self.recv_markOrdersAsShippedFromWarehouse()
1408 ankur.sing 2896 
 
4910 phani.kuma 2897 
  def send_markOrdersAsShippedFromWarehouse(self, warehouseId, providerId, cod, orderIds):
2898 
    self._oprot.writeMessageBegin('markOrdersAsShippedFromWarehouse', TMessageType.CALL, self._seqid)
2899 
    args = markOrdersAsShippedFromWarehouse_args()
3064 chandransh 2900 
    args.warehouseId = warehouseId
1408 ankur.sing 2901 
    args.providerId = providerId
3064 chandransh 2902 
    args.cod = cod
4910 phani.kuma 2903 
    args.orderIds = orderIds
1408 ankur.sing 2904 
    args.write(self._oprot)
2905 
    self._oprot.writeMessageEnd()
2906 
    self._oprot.trans.flush()
2907 
 
4910 phani.kuma 2908 
  def recv_markOrdersAsShippedFromWarehouse(self, ):
1408 ankur.sing 2909 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2910 
    if mtype == TMessageType.EXCEPTION:
2911 
      x = TApplicationException()
2912 
      x.read(self._iprot)
2913 
      self._iprot.readMessageEnd()
2914 
      raise x
4910 phani.kuma 2915 
    result = markOrdersAsShippedFromWarehouse_result()
1408 ankur.sing 2916 
    result.read(self._iprot)
2917 
    self._iprot.readMessageEnd()
3431 rajveer 2918 
    if result.success is not None:
1408 ankur.sing 2919 
      return result.success
3431 rajveer 2920 
    if result.ex is not None:
3064 chandransh 2921 
      raise result.ex
4910 phani.kuma 2922 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrdersAsShippedFromWarehouse failed: unknown result");
1408 ankur.sing 2923 
 
5713 rajveer 2924 
  def markOrdersAsReturnedFromStore(self, providerId, orderIds, awbs):
5676 rajveer 2925 
    """
2926 
    Parameters:
2927 
     - providerId
2928 
     - orderIds
5713 rajveer 2929 
     - awbs
5676 rajveer 2930 
    """
5713 rajveer 2931 
    self.send_markOrdersAsReturnedFromStore(providerId, orderIds, awbs)
5676 rajveer 2932 
    return self.recv_markOrdersAsReturnedFromStore()
2933 
 
5713 rajveer 2934 
  def send_markOrdersAsReturnedFromStore(self, providerId, orderIds, awbs):
5676 rajveer 2935 
    self._oprot.writeMessageBegin('markOrdersAsReturnedFromStore', TMessageType.CALL, self._seqid)
2936 
    args = markOrdersAsReturnedFromStore_args()
2937 
    args.providerId = providerId
2938 
    args.orderIds = orderIds
5713 rajveer 2939 
    args.awbs = awbs
5676 rajveer 2940 
    args.write(self._oprot)
2941 
    self._oprot.writeMessageEnd()
2942 
    self._oprot.trans.flush()
2943 
 
2944 
  def recv_markOrdersAsReturnedFromStore(self, ):
2945 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2946 
    if mtype == TMessageType.EXCEPTION:
2947 
      x = TApplicationException()
2948 
      x.read(self._iprot)
2949 
      self._iprot.readMessageEnd()
2950 
      raise x
2951 
    result = markOrdersAsReturnedFromStore_result()
2952 
    result.read(self._iprot)
2953 
    self._iprot.readMessageEnd()
2954 
    if result.success is not None:
2955 
      return result.success
2956 
    if result.ex is not None:
2957 
      raise result.ex
2958 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrdersAsReturnedFromStore failed: unknown result");
2959 
 
4910 phani.kuma 2960 
  def markOrdersAsPickedUp(self, providerId, pickupDetails):
4410 rajveer 2961 
    """
4910 phani.kuma 2962 
    Marks all SHIPPED_FROM_WH orders of the previous day for a provider as SHIPPED_TO_LOGISTICS.
2963 
    Raises an exception if we encounter report for an AWB number that we did not ship.
4410 rajveer 2964 
 
2965 
    Parameters:
2966 
     - providerId
4910 phani.kuma 2967 
     - pickupDetails
4410 rajveer 2968 
    """
4910 phani.kuma 2969 
    self.send_markOrdersAsPickedUp(providerId, pickupDetails)
2970 
    self.recv_markOrdersAsPickedUp()
4410 rajveer 2971 
 
4910 phani.kuma 2972 
  def send_markOrdersAsPickedUp(self, providerId, pickupDetails):
2973 
    self._oprot.writeMessageBegin('markOrdersAsPickedUp', TMessageType.CALL, self._seqid)
2974 
    args = markOrdersAsPickedUp_args()
4410 rajveer 2975 
    args.providerId = providerId
4910 phani.kuma 2976 
    args.pickupDetails = pickupDetails
4410 rajveer 2977 
    args.write(self._oprot)
2978 
    self._oprot.writeMessageEnd()
2979 
    self._oprot.trans.flush()
2980 
 
4910 phani.kuma 2981 
  def recv_markOrdersAsPickedUp(self, ):
4410 rajveer 2982 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2983 
    if mtype == TMessageType.EXCEPTION:
2984 
      x = TApplicationException()
2985 
      x.read(self._iprot)
2986 
      self._iprot.readMessageEnd()
2987 
      raise x
4910 phani.kuma 2988 
    result = markOrdersAsPickedUp_result()
4410 rajveer 2989 
    result.read(self._iprot)
2990 
    self._iprot.readMessageEnd()
2991 
    if result.ex is not None:
2992 
      raise result.ex
4910 phani.kuma 2993 
    return
4410 rajveer 2994 
 
4910 phani.kuma 2995 
  def getOrdersNotPickedUp(self, providerId):
94 ashish 2996 
    """
3064 chandransh 2997 
    Returns a list of orders that were shipped from warehouse but did not appear in the pick-up report.
3431 rajveer 2998 
 
94 ashish 2999 
    Parameters:
3064 chandransh 3000 
     - providerId
304 ashish 3001 
    """
4910 phani.kuma 3002 
    self.send_getOrdersNotPickedUp(providerId)
3003 
    return self.recv_getOrdersNotPickedUp()
94 ashish 3004 
 
4910 phani.kuma 3005 
  def send_getOrdersNotPickedUp(self, providerId):
3006 
    self._oprot.writeMessageBegin('getOrdersNotPickedUp', TMessageType.CALL, self._seqid)
3007 
    args = getOrdersNotPickedUp_args()
3064 chandransh 3008 
    args.providerId = providerId
304 ashish 3009 
    args.write(self._oprot)
3010 
    self._oprot.writeMessageEnd()
3011 
    self._oprot.trans.flush()
3012 
 
4910 phani.kuma 3013 
  def recv_getOrdersNotPickedUp(self, ):
304 ashish 3014 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3015 
    if mtype == TMessageType.EXCEPTION:
3016 
      x = TApplicationException()
3017 
      x.read(self._iprot)
3018 
      self._iprot.readMessageEnd()
3019 
      raise x
4910 phani.kuma 3020 
    result = getOrdersNotPickedUp_result()
304 ashish 3021 
    result.read(self._iprot)
3022 
    self._iprot.readMessageEnd()
3431 rajveer 3023 
    if result.success is not None:
304 ashish 3024 
      return result.success
4910 phani.kuma 3025 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersNotPickedUp failed: unknown result");
304 ashish 3026 
 
3064 chandransh 3027 
  def markOrdersAsDelivered(self, providerId, deliveredOrders):
304 ashish 3028 
    """
3064 chandransh 3029 
    Marks all orders with AWBs in the given map as delivered. Also sets the delivery timestamp and
3030 
    the name of the receiver.
3031 
    Raises an exception if we encounter report for an AWB number that we did not ship.
3431 rajveer 3032 
 
304 ashish 3033 
    Parameters:
3064 chandransh 3034 
     - providerId
3035 
     - deliveredOrders
304 ashish 3036 
    """
3064 chandransh 3037 
    self.send_markOrdersAsDelivered(providerId, deliveredOrders)
3038 
    self.recv_markOrdersAsDelivered()
304 ashish 3039 
 
3064 chandransh 3040 
  def send_markOrdersAsDelivered(self, providerId, deliveredOrders):
3041 
    self._oprot.writeMessageBegin('markOrdersAsDelivered', TMessageType.CALL, self._seqid)
3042 
    args = markOrdersAsDelivered_args()
3043 
    args.providerId = providerId
3044 
    args.deliveredOrders = deliveredOrders
304 ashish 3045 
    args.write(self._oprot)
3046 
    self._oprot.writeMessageEnd()
3047 
    self._oprot.trans.flush()
3048 
 
3064 chandransh 3049 
  def recv_markOrdersAsDelivered(self, ):
304 ashish 3050 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3051 
    if mtype == TMessageType.EXCEPTION:
3052 
      x = TApplicationException()
3053 
      x.read(self._iprot)
3054 
      self._iprot.readMessageEnd()
3055 
      raise x
3064 chandransh 3056 
    result = markOrdersAsDelivered_result()
304 ashish 3057 
    result.read(self._iprot)
3058 
    self._iprot.readMessageEnd()
3431 rajveer 3059 
    if result.ex is not None:
3064 chandransh 3060 
      raise result.ex
304 ashish 3061 
    return
3062 
 
4910 phani.kuma 3063 
  def markAsRTOrders(self, providerId, returnedOrders):
1596 ankur.sing 3064 
    """
4910 phani.kuma 3065 
    Mark all orders with AWBs in the given map as RTO. Also sets the delivery timestamp.
3064 chandransh 3066 
    Raises an exception if we encounter report for an AWB number that we did not ship.
3431 rajveer 3067 
 
3064 chandransh 3068 
    Parameters:
3069 
     - providerId
3070 
     - returnedOrders
1596 ankur.sing 3071 
    """
4910 phani.kuma 3072 
    self.send_markAsRTOrders(providerId, returnedOrders)
3073 
    self.recv_markAsRTOrders()
304 ashish 3074 
 
4910 phani.kuma 3075 
  def send_markAsRTOrders(self, providerId, returnedOrders):
3076 
    self._oprot.writeMessageBegin('markAsRTOrders', TMessageType.CALL, self._seqid)
3077 
    args = markAsRTOrders_args()
3064 chandransh 3078 
    args.providerId = providerId
3079 
    args.returnedOrders = returnedOrders
1596 ankur.sing 3080 
    args.write(self._oprot)
3081 
    self._oprot.writeMessageEnd()
3082 
    self._oprot.trans.flush()
3083 
 
4910 phani.kuma 3084 
  def recv_markAsRTOrders(self, ):
1596 ankur.sing 3085 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3086 
    if mtype == TMessageType.EXCEPTION:
3087 
      x = TApplicationException()
3088 
      x.read(self._iprot)
3089 
      self._iprot.readMessageEnd()
3090 
      raise x
4910 phani.kuma 3091 
    result = markAsRTOrders_result()
1596 ankur.sing 3092 
    result.read(self._iprot)
3093 
    self._iprot.readMessageEnd()
3431 rajveer 3094 
    if result.ex is not None:
3064 chandransh 3095 
      raise result.ex
3096 
    return
1596 ankur.sing 3097 
 
4910 phani.kuma 3098 
  def getRTOrders(self, providerId):
3099 
    """
3100 
    Returns a list of orders that were returned by courier.
3101 
 
3102 
    Parameters:
3103 
     - providerId
3104 
    """
3105 
    self.send_getRTOrders(providerId)
3106 
    return self.recv_getRTOrders()
3107 
 
3108 
  def send_getRTOrders(self, providerId):
3109 
    self._oprot.writeMessageBegin('getRTOrders', TMessageType.CALL, self._seqid)
3110 
    args = getRTOrders_args()
3111 
    args.providerId = providerId
3112 
    args.write(self._oprot)
3113 
    self._oprot.writeMessageEnd()
3114 
    self._oprot.trans.flush()
3115 
 
3116 
  def recv_getRTOrders(self, ):
3117 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3118 
    if mtype == TMessageType.EXCEPTION:
3119 
      x = TApplicationException()
3120 
      x.read(self._iprot)
3121 
      self._iprot.readMessageEnd()
3122 
      raise x
3123 
    result = getRTOrders_result()
3124 
    result.read(self._iprot)
3125 
    self._iprot.readMessageEnd()
3126 
    if result.success is not None:
3127 
      return result.success
3128 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getRTOrders failed: unknown result");
3129 
 
3064 chandransh 3130 
  def updateNonDeliveryReason(self, providerId, undeliveredOrders):
1627 ankur.sing 3131 
    """
3064 chandransh 3132 
    Update the status description of orders whose AWB numbers are keys of the Map.
3431 rajveer 3133 
 
3064 chandransh 3134 
    Parameters:
3135 
     - providerId
3136 
     - undeliveredOrders
1627 ankur.sing 3137 
    """
3064 chandransh 3138 
    self.send_updateNonDeliveryReason(providerId, undeliveredOrders)
4910 phani.kuma 3139 
    self.recv_updateNonDeliveryReason()
1596 ankur.sing 3140 
 
3064 chandransh 3141 
  def send_updateNonDeliveryReason(self, providerId, undeliveredOrders):
3142 
    self._oprot.writeMessageBegin('updateNonDeliveryReason', TMessageType.CALL, self._seqid)
3143 
    args = updateNonDeliveryReason_args()
3144 
    args.providerId = providerId
3145 
    args.undeliveredOrders = undeliveredOrders
1627 ankur.sing 3146 
    args.write(self._oprot)
3147 
    self._oprot.writeMessageEnd()
3148 
    self._oprot.trans.flush()
3149 
 
3064 chandransh 3150 
  def recv_updateNonDeliveryReason(self, ):
1627 ankur.sing 3151 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3152 
    if mtype == TMessageType.EXCEPTION:
3153 
      x = TApplicationException()
3154 
      x.read(self._iprot)
3155 
      self._iprot.readMessageEnd()
3156 
      raise x
3064 chandransh 3157 
    result = updateNonDeliveryReason_result()
1627 ankur.sing 3158 
    result.read(self._iprot)
3159 
    self._iprot.readMessageEnd()
4910 phani.kuma 3160 
    if result.ex is not None:
3161 
      raise result.ex
3162 
    return
3163 
 
3164 
  def getNonDeliveredOrdersbyCourier(self, providerId):
3165 
    """
3166 
    Returns a list of orders that were picked up or shipped four days ago but did not get delivered.
3167 
 
3168 
    Parameters:
3169 
     - providerId
3170 
    """
3171 
    self.send_getNonDeliveredOrdersbyCourier(providerId)
3172 
    return self.recv_getNonDeliveredOrdersbyCourier()
3173 
 
3174 
  def send_getNonDeliveredOrdersbyCourier(self, providerId):
3175 
    self._oprot.writeMessageBegin('getNonDeliveredOrdersbyCourier', TMessageType.CALL, self._seqid)
3176 
    args = getNonDeliveredOrdersbyCourier_args()
3177 
    args.providerId = providerId
3178 
    args.write(self._oprot)
3179 
    self._oprot.writeMessageEnd()
3180 
    self._oprot.trans.flush()
3181 
 
3182 
  def recv_getNonDeliveredOrdersbyCourier(self, ):
3183 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3184 
    if mtype == TMessageType.EXCEPTION:
3185 
      x = TApplicationException()
3186 
      x.read(self._iprot)
3187 
      self._iprot.readMessageEnd()
3188 
      raise x
3189 
    result = getNonDeliveredOrdersbyCourier_result()
3190 
    result.read(self._iprot)
3191 
    self._iprot.readMessageEnd()
4581 phani.kuma 3192 
    if result.success is not None:
3193 
      return result.success
4910 phani.kuma 3194 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getNonDeliveredOrdersbyCourier failed: unknown result");
3195 
 
3196 
  def markOrdersAsLocalConnected(self, providerId, local_connected_orders):
3197 
    """
3198 
    Mark all orders with AWBs in the given map as local connected. Also sets the local connected timestamp.
3199 
 
3200 
    Parameters:
3201 
     - providerId
3202 
     - local_connected_orders
3203 
    """
3204 
    self.send_markOrdersAsLocalConnected(providerId, local_connected_orders)
3205 
    self.recv_markOrdersAsLocalConnected()
3206 
 
3207 
  def send_markOrdersAsLocalConnected(self, providerId, local_connected_orders):
3208 
    self._oprot.writeMessageBegin('markOrdersAsLocalConnected', TMessageType.CALL, self._seqid)
3209 
    args = markOrdersAsLocalConnected_args()
3210 
    args.providerId = providerId
3211 
    args.local_connected_orders = local_connected_orders
3212 
    args.write(self._oprot)
3213 
    self._oprot.writeMessageEnd()
3214 
    self._oprot.trans.flush()
3215 
 
3216 
  def recv_markOrdersAsLocalConnected(self, ):
3217 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3218 
    if mtype == TMessageType.EXCEPTION:
3219 
      x = TApplicationException()
3220 
      x.read(self._iprot)
3221 
      self._iprot.readMessageEnd()
3222 
      raise x
3223 
    result = markOrdersAsLocalConnected_result()
3224 
    result.read(self._iprot)
3225 
    self._iprot.readMessageEnd()
3431 rajveer 3226 
    if result.ex is not None:
3064 chandransh 3227 
      raise result.ex
4910 phani.kuma 3228 
    return
1627 ankur.sing 3229 
 
4910 phani.kuma 3230 
  def getOrdersNotLocalConnected(self, providerId):
3231 
    """
3232 
    Returns a list of orders that were picked up or shipped but pending local connection.
3233 
 
3234 
    Parameters:
3235 
     - providerId
3236 
    """
3237 
    self.send_getOrdersNotLocalConnected(providerId)
3238 
    return self.recv_getOrdersNotLocalConnected()
3239 
 
3240 
  def send_getOrdersNotLocalConnected(self, providerId):
3241 
    self._oprot.writeMessageBegin('getOrdersNotLocalConnected', TMessageType.CALL, self._seqid)
3242 
    args = getOrdersNotLocalConnected_args()
3243 
    args.providerId = providerId
3244 
    args.write(self._oprot)
3245 
    self._oprot.writeMessageEnd()
3246 
    self._oprot.trans.flush()
3247 
 
3248 
  def recv_getOrdersNotLocalConnected(self, ):
3249 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3250 
    if mtype == TMessageType.EXCEPTION:
3251 
      x = TApplicationException()
3252 
      x.read(self._iprot)
3253 
      self._iprot.readMessageEnd()
3254 
      raise x
3255 
    result = getOrdersNotLocalConnected_result()
3256 
    result.read(self._iprot)
3257 
    self._iprot.readMessageEnd()
3258 
    if result.success is not None:
3259 
      return result.success
3260 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersNotLocalConnected failed: unknown result");
3261 
 
3262 
  def markOrdersAsDestinationCityReached(self, providerId, destination_city_reached_orders):
3263 
    """
3264 
    Mark all orders with AWBs in the given map as reached destination city. Also sets the reached destination timestamp.
3265 
 
3266 
    Parameters:
3267 
     - providerId
3268 
     - destination_city_reached_orders
3269 
    """
3270 
    self.send_markOrdersAsDestinationCityReached(providerId, destination_city_reached_orders)
3271 
    self.recv_markOrdersAsDestinationCityReached()
3272 
 
3273 
  def send_markOrdersAsDestinationCityReached(self, providerId, destination_city_reached_orders):
3274 
    self._oprot.writeMessageBegin('markOrdersAsDestinationCityReached', TMessageType.CALL, self._seqid)
3275 
    args = markOrdersAsDestinationCityReached_args()
3276 
    args.providerId = providerId
3277 
    args.destination_city_reached_orders = destination_city_reached_orders
3278 
    args.write(self._oprot)
3279 
    self._oprot.writeMessageEnd()
3280 
    self._oprot.trans.flush()
3281 
 
3282 
  def recv_markOrdersAsDestinationCityReached(self, ):
3283 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3284 
    if mtype == TMessageType.EXCEPTION:
3285 
      x = TApplicationException()
3286 
      x.read(self._iprot)
3287 
      self._iprot.readMessageEnd()
3288 
      raise x
3289 
    result = markOrdersAsDestinationCityReached_result()
3290 
    result.read(self._iprot)
3291 
    self._iprot.readMessageEnd()
3292 
    if result.ex is not None:
3293 
      raise result.ex
3294 
    return
3295 
 
3296 
  def markOrdersAsFirstDeliveryAttempted(self, providerId, first_atdl_orders):
3297 
    """
3298 
    Mark all orders with AWBs in the given map as first delivery attempt made. Also sets the first delivery attempted timestamp.
3299 
 
3300 
    Parameters:
3301 
     - providerId
3302 
     - first_atdl_orders
3303 
    """
3304 
    self.send_markOrdersAsFirstDeliveryAttempted(providerId, first_atdl_orders)
3305 
    self.recv_markOrdersAsFirstDeliveryAttempted()
3306 
 
3307 
  def send_markOrdersAsFirstDeliveryAttempted(self, providerId, first_atdl_orders):
3308 
    self._oprot.writeMessageBegin('markOrdersAsFirstDeliveryAttempted', TMessageType.CALL, self._seqid)
3309 
    args = markOrdersAsFirstDeliveryAttempted_args()
3310 
    args.providerId = providerId
3311 
    args.first_atdl_orders = first_atdl_orders
3312 
    args.write(self._oprot)
3313 
    self._oprot.writeMessageEnd()
3314 
    self._oprot.trans.flush()
3315 
 
3316 
  def recv_markOrdersAsFirstDeliveryAttempted(self, ):
3317 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3318 
    if mtype == TMessageType.EXCEPTION:
3319 
      x = TApplicationException()
3320 
      x.read(self._iprot)
3321 
      self._iprot.readMessageEnd()
3322 
      raise x
3323 
    result = markOrdersAsFirstDeliveryAttempted_result()
3324 
    result.read(self._iprot)
3325 
    self._iprot.readMessageEnd()
3326 
    if result.ex is not None:
3327 
      raise result.ex
3328 
    return
3329 
 
3064 chandransh 3330 
  def getUndeliveredOrders(self, providerId, warehouseId):
1627 ankur.sing 3331 
    """
3064 chandransh 3332 
    Returns the list of orders whose delivery time has passed but have not been
3333 
    delivered yet for the given provider and warehouse. To get a complete list of
3334 
    undelivered orders, pass them as -1.
3335 
    Returns an empty list if no such orders exist.
3431 rajveer 3336 
 
1886 ankur.sing 3337 
    Parameters:
3064 chandransh 3338 
     - providerId
3339 
     - warehouseId
1886 ankur.sing 3340 
    """
3064 chandransh 3341 
    self.send_getUndeliveredOrders(providerId, warehouseId)
3342 
    return self.recv_getUndeliveredOrders()
1627 ankur.sing 3343 
 
3064 chandransh 3344 
  def send_getUndeliveredOrders(self, providerId, warehouseId):
3345 
    self._oprot.writeMessageBegin('getUndeliveredOrders', TMessageType.CALL, self._seqid)
3346 
    args = getUndeliveredOrders_args()
3347 
    args.providerId = providerId
3348 
    args.warehouseId = warehouseId
1886 ankur.sing 3349 
    args.write(self._oprot)
3350 
    self._oprot.writeMessageEnd()
3351 
    self._oprot.trans.flush()
3352 
 
3064 chandransh 3353 
  def recv_getUndeliveredOrders(self, ):
1886 ankur.sing 3354 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3355 
    if mtype == TMessageType.EXCEPTION:
3356 
      x = TApplicationException()
3357 
      x.read(self._iprot)
3358 
      self._iprot.readMessageEnd()
3359 
      raise x
3064 chandransh 3360 
    result = getUndeliveredOrders_result()
1886 ankur.sing 3361 
    result.read(self._iprot)
3362 
    self._iprot.readMessageEnd()
3431 rajveer 3363 
    if result.success is not None:
1886 ankur.sing 3364 
      return result.success
3064 chandransh 3365 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUndeliveredOrders failed: unknown result");
1886 ankur.sing 3366 
 
4783 phani.kuma 3367 
  def getUndeliveredOrdersExpectedDeliveryDateNotMet(self, ):
3368 
    """
3369 
    Returns the list of orders whose expected delivery date has passed but have not been
3370 
    delivered yet.
3371 
    Returns an empty list if no such orders exist.
3372 
    """
3373 
    self.send_getUndeliveredOrdersExpectedDeliveryDateNotMet()
3374 
    return self.recv_getUndeliveredOrdersExpectedDeliveryDateNotMet()
3375 
 
3376 
  def send_getUndeliveredOrdersExpectedDeliveryDateNotMet(self, ):
3377 
    self._oprot.writeMessageBegin('getUndeliveredOrdersExpectedDeliveryDateNotMet', TMessageType.CALL, self._seqid)
3378 
    args = getUndeliveredOrdersExpectedDeliveryDateNotMet_args()
3379 
    args.write(self._oprot)
3380 
    self._oprot.writeMessageEnd()
3381 
    self._oprot.trans.flush()
3382 
 
3383 
  def recv_getUndeliveredOrdersExpectedDeliveryDateNotMet(self, ):
3384 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3385 
    if mtype == TMessageType.EXCEPTION:
3386 
      x = TApplicationException()
3387 
      x.read(self._iprot)
3388 
      self._iprot.readMessageEnd()
3389 
      raise x
3390 
    result = getUndeliveredOrdersExpectedDeliveryDateNotMet_result()
3391 
    result.read(self._iprot)
3392 
    self._iprot.readMessageEnd()
3393 
    if result.success is not None:
3394 
      return result.success
3395 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUndeliveredOrdersExpectedDeliveryDateNotMet failed: unknown result");
3396 
 
2536 chandransh 3397 
  def toggleDOAFlag(self, orderId):
3398 
    """
3399 
    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.
3400 
    Returns the final flag status.
3401 
    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 3402 
 
2536 chandransh 3403 
    Parameters:
3404 
     - orderId
3405 
    """
3406 
    self.send_toggleDOAFlag(orderId)
3407 
    return self.recv_toggleDOAFlag()
1886 ankur.sing 3408 
 
2536 chandransh 3409 
  def send_toggleDOAFlag(self, orderId):
3410 
    self._oprot.writeMessageBegin('toggleDOAFlag', TMessageType.CALL, self._seqid)
3411 
    args = toggleDOAFlag_args()
3412 
    args.orderId = orderId
3413 
    args.write(self._oprot)
3414 
    self._oprot.writeMessageEnd()
3415 
    self._oprot.trans.flush()
3416 
 
3417 
  def recv_toggleDOAFlag(self, ):
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
3424 
    result = toggleDOAFlag_result()
3425 
    result.read(self._iprot)
3426 
    self._iprot.readMessageEnd()
3431 rajveer 3427 
    if result.success is not None:
2536 chandransh 3428 
      return result.success
3431 rajveer 3429 
    if result.ex is not None:
2536 chandransh 3430 
      raise result.ex
3431 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "toggleDOAFlag failed: unknown result");
3432 
 
4712 rajveer 3433 
  def markOrderAsDelivered(self, orderId, deliveryTimestamp, receiver):
3434 
    """
3435 
    Parameters:
3436 
     - orderId
3437 
     - deliveryTimestamp
3438 
     - receiver
3439 
    """
3440 
    self.send_markOrderAsDelivered(orderId, deliveryTimestamp, receiver)
3441 
    self.recv_markOrderAsDelivered()
3442 
 
3443 
  def send_markOrderAsDelivered(self, orderId, deliveryTimestamp, receiver):
3444 
    self._oprot.writeMessageBegin('markOrderAsDelivered', TMessageType.CALL, self._seqid)
3445 
    args = markOrderAsDelivered_args()
3446 
    args.orderId = orderId
3447 
    args.deliveryTimestamp = deliveryTimestamp
3448 
    args.receiver = receiver
3449 
    args.write(self._oprot)
3450 
    self._oprot.writeMessageEnd()
3451 
    self._oprot.trans.flush()
3452 
 
3453 
  def recv_markOrderAsDelivered(self, ):
3454 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3455 
    if mtype == TMessageType.EXCEPTION:
3456 
      x = TApplicationException()
3457 
      x.read(self._iprot)
3458 
      self._iprot.readMessageEnd()
3459 
      raise x
3460 
    result = markOrderAsDelivered_result()
3461 
    result.read(self._iprot)
3462 
    self._iprot.readMessageEnd()
3463 
    if result.ex is not None:
3464 
      raise result.ex
3465 
    return
3466 
 
5553 rajveer 3467 
  def markOrderAsReceivedAtStore(self, orderId, deliveryTimestamp):
3468 
    """
3469 
    Parameters:
3470 
     - orderId
3471 
     - deliveryTimestamp
3472 
    """
3473 
    self.send_markOrderAsReceivedAtStore(orderId, deliveryTimestamp)
3474 
    self.recv_markOrderAsReceivedAtStore()
3475 
 
3476 
  def send_markOrderAsReceivedAtStore(self, orderId, deliveryTimestamp):
3477 
    self._oprot.writeMessageBegin('markOrderAsReceivedAtStore', TMessageType.CALL, self._seqid)
3478 
    args = markOrderAsReceivedAtStore_args()
3479 
    args.orderId = orderId
3480 
    args.deliveryTimestamp = deliveryTimestamp
3481 
    args.write(self._oprot)
3482 
    self._oprot.writeMessageEnd()
3483 
    self._oprot.trans.flush()
3484 
 
3485 
  def recv_markOrderAsReceivedAtStore(self, ):
3486 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3487 
    if mtype == TMessageType.EXCEPTION:
3488 
      x = TApplicationException()
3489 
      x.read(self._iprot)
3490 
      self._iprot.readMessageEnd()
3491 
      raise x
3492 
    result = markOrderAsReceivedAtStore_result()
3493 
    result.read(self._iprot)
3494 
    self._iprot.readMessageEnd()
3495 
    if result.ex is not None:
3496 
      raise result.ex
3497 
    return
3498 
 
4454 rajveer 3499 
  def markOrderDoaRequestReceived(self, orderId):
3500 
    """
3501 
    Once user raise the request for a DOA, order status will be changed from DELVIERY_SUCCESS to DOA_REQUEST_RECEIVED
3502 
 
3503 
    Parameters:
3504 
     - orderId
3505 
    """
3506 
    self.send_markOrderDoaRequestReceived(orderId)
3507 
    return self.recv_markOrderDoaRequestReceived()
3508 
 
3509 
  def send_markOrderDoaRequestReceived(self, orderId):
3510 
    self._oprot.writeMessageBegin('markOrderDoaRequestReceived', TMessageType.CALL, self._seqid)
3511 
    args = markOrderDoaRequestReceived_args()
3512 
    args.orderId = orderId
3513 
    args.write(self._oprot)
3514 
    self._oprot.writeMessageEnd()
3515 
    self._oprot.trans.flush()
3516 
 
3517 
  def recv_markOrderDoaRequestReceived(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 = markOrderDoaRequestReceived_result()
3525 
    result.read(self._iprot)
3526 
    self._iprot.readMessageEnd()
3527 
    if result.success is not None:
3528 
      return result.success
3529 
    if result.ex is not None:
3530 
      raise result.ex
3531 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderDoaRequestReceived failed: unknown result");
3532 
 
3533 
  def markOrderDoaRequestAuthorized(self, orderId, isAuthorized):
3534 
    """
3535 
    CRM person can authorize or deny the request reised by customer. If he authorizes order will change from DOA_REQUEST_RECEIVED
3536 
    to DOA_REQUEST_AUTHORIZED. If he denies, status will be changed back to DELVIERY_SUCCESS.
3537 
 
3538 
    Parameters:
3539 
     - orderId
3540 
     - isAuthorized
3541 
    """
3542 
    self.send_markOrderDoaRequestAuthorized(orderId, isAuthorized)
3543 
    return self.recv_markOrderDoaRequestAuthorized()
3544 
 
3545 
  def send_markOrderDoaRequestAuthorized(self, orderId, isAuthorized):
3546 
    self._oprot.writeMessageBegin('markOrderDoaRequestAuthorized', TMessageType.CALL, self._seqid)
3547 
    args = markOrderDoaRequestAuthorized_args()
3548 
    args.orderId = orderId
3549 
    args.isAuthorized = isAuthorized
3550 
    args.write(self._oprot)
3551 
    self._oprot.writeMessageEnd()
3552 
    self._oprot.trans.flush()
3553 
 
3554 
  def recv_markOrderDoaRequestAuthorized(self, ):
3555 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3556 
    if mtype == TMessageType.EXCEPTION:
3557 
      x = TApplicationException()
3558 
      x.read(self._iprot)
3559 
      self._iprot.readMessageEnd()
3560 
      raise x
3561 
    result = markOrderDoaRequestAuthorized_result()
3562 
    result.read(self._iprot)
3563 
    self._iprot.readMessageEnd()
3564 
    if result.success is not None:
3565 
      return result.success
3566 
    if result.ex is not None:
3567 
      raise result.ex
3568 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderDoaRequestAuthorized failed: unknown result");
3569 
 
4488 rajveer 3570 
  def markOrderReturnRequestReceived(self, orderId):
3571 
    """
3572 
    Once user raise the request for a RET, order status will be changed from DELVIERY_SUCCESS to RET_REQUEST_RECEIVED
3573 
 
3574 
    Parameters:
3575 
     - orderId
3576 
    """
3577 
    self.send_markOrderReturnRequestReceived(orderId)
3578 
    return self.recv_markOrderReturnRequestReceived()
3579 
 
3580 
  def send_markOrderReturnRequestReceived(self, orderId):
3581 
    self._oprot.writeMessageBegin('markOrderReturnRequestReceived', TMessageType.CALL, self._seqid)
3582 
    args = markOrderReturnRequestReceived_args()
3583 
    args.orderId = orderId
3584 
    args.write(self._oprot)
3585 
    self._oprot.writeMessageEnd()
3586 
    self._oprot.trans.flush()
3587 
 
3588 
  def recv_markOrderReturnRequestReceived(self, ):
3589 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3590 
    if mtype == TMessageType.EXCEPTION:
3591 
      x = TApplicationException()
3592 
      x.read(self._iprot)
3593 
      self._iprot.readMessageEnd()
3594 
      raise x
3595 
    result = markOrderReturnRequestReceived_result()
3596 
    result.read(self._iprot)
3597 
    self._iprot.readMessageEnd()
3598 
    if result.success is not None:
3599 
      return result.success
3600 
    if result.ex is not None:
3601 
      raise result.ex
3602 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderReturnRequestReceived failed: unknown result");
3603 
 
3604 
  def markOrderReturnRequestAuthorized(self, orderId, isAuthorized):
3605 
    """
3606 
    CRM person can authorize or deny the request reised by customer. If he authorizes order will change from RET_REQUEST_RECEIVED
3607 
    to RET_REQUEST_AUTHORIZED. If he denies, status will be changed back to DELVIERY_SUCCESS.
3608 
 
3609 
    Parameters:
3610 
     - orderId
3611 
     - isAuthorized
3612 
    """
3613 
    self.send_markOrderReturnRequestAuthorized(orderId, isAuthorized)
3614 
    return self.recv_markOrderReturnRequestAuthorized()
3615 
 
3616 
  def send_markOrderReturnRequestAuthorized(self, orderId, isAuthorized):
3617 
    self._oprot.writeMessageBegin('markOrderReturnRequestAuthorized', TMessageType.CALL, self._seqid)
3618 
    args = markOrderReturnRequestAuthorized_args()
3619 
    args.orderId = orderId
3620 
    args.isAuthorized = isAuthorized
3621 
    args.write(self._oprot)
3622 
    self._oprot.writeMessageEnd()
3623 
    self._oprot.trans.flush()
3624 
 
3625 
  def recv_markOrderReturnRequestAuthorized(self, ):
3626 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3627 
    if mtype == TMessageType.EXCEPTION:
3628 
      x = TApplicationException()
3629 
      x.read(self._iprot)
3630 
      self._iprot.readMessageEnd()
3631 
      raise x
3632 
    result = markOrderReturnRequestAuthorized_result()
3633 
    result.read(self._iprot)
3634 
    self._iprot.readMessageEnd()
3635 
    if result.success is not None:
3636 
      return result.success
3637 
    if result.ex is not None:
3638 
      raise result.ex
3639 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderReturnRequestAuthorized failed: unknown result");
3640 
 
4579 rajveer 3641 
  def requestPickupNumber(self, orderId, providerId):
2536 chandransh 3642 
    """
3643 
    Sends out an email to the account manager of the original courier provider used to ship the order.
4452 rajveer 3644 
    If the order status was DELIVERY_SUCCESS, it is changed to be DOA_PICKUP_REQUEST_RAISED.
3645 
    If the order status was DOA_PICKUP_REQUEST_RAISED, it is left unchanged.
2536 chandransh 3646 
    For any other status, it returns false.
3647 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 3648 
 
2536 chandransh 3649 
    Parameters:
3650 
     - orderId
4579 rajveer 3651 
     - providerId
2536 chandransh 3652 
    """
4579 rajveer 3653 
    self.send_requestPickupNumber(orderId, providerId)
2536 chandransh 3654 
    return self.recv_requestPickupNumber()
3655 
 
4579 rajveer 3656 
  def send_requestPickupNumber(self, orderId, providerId):
2536 chandransh 3657 
    self._oprot.writeMessageBegin('requestPickupNumber', TMessageType.CALL, self._seqid)
3658 
    args = requestPickupNumber_args()
3659 
    args.orderId = orderId
4579 rajveer 3660 
    args.providerId = providerId
2536 chandransh 3661 
    args.write(self._oprot)
3662 
    self._oprot.writeMessageEnd()
3663 
    self._oprot.trans.flush()
3664 
 
3665 
  def recv_requestPickupNumber(self, ):
3666 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3667 
    if mtype == TMessageType.EXCEPTION:
3668 
      x = TApplicationException()
3669 
      x.read(self._iprot)
3670 
      self._iprot.readMessageEnd()
3671 
      raise x
3672 
    result = requestPickupNumber_result()
3673 
    result.read(self._iprot)
3674 
    self._iprot.readMessageEnd()
3431 rajveer 3675 
    if result.success is not None:
2536 chandransh 3676 
      return result.success
3431 rajveer 3677 
    if result.ex is not None:
2536 chandransh 3678 
      raise result.ex
3679 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "requestPickupNumber failed: unknown result");
3680 
 
4602 rajveer 3681 
  def authorizePickup(self, orderId, pickupNumber, providerId):
2536 chandransh 3682 
    """
4452 rajveer 3683 
    If the order status is DOA_PICKUP_REQUEST_RAISED, it does the following
2536 chandransh 3684 
    	1. Sends out an email to the customer with the dispatch advice that he has to print as an attachment.
3685 
    	2. Changes order status to be DOA_PICKUP_AUTHORIZED.
3686 
    	3. Returns true
2591 chandransh 3687 
    If the order is in any other status, it returns false.
2536 chandransh 3688 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 3689 
 
2536 chandransh 3690 
    Parameters:
3691 
     - orderId
3692 
     - pickupNumber
4602 rajveer 3693 
     - providerId
2536 chandransh 3694 
    """
4602 rajveer 3695 
    self.send_authorizePickup(orderId, pickupNumber, providerId)
2536 chandransh 3696 
    return self.recv_authorizePickup()
3697 
 
4602 rajveer 3698 
  def send_authorizePickup(self, orderId, pickupNumber, providerId):
2536 chandransh 3699 
    self._oprot.writeMessageBegin('authorizePickup', TMessageType.CALL, self._seqid)
3700 
    args = authorizePickup_args()
3701 
    args.orderId = orderId
3702 
    args.pickupNumber = pickupNumber
4602 rajveer 3703 
    args.providerId = providerId
2536 chandransh 3704 
    args.write(self._oprot)
3705 
    self._oprot.writeMessageEnd()
3706 
    self._oprot.trans.flush()
3707 
 
3708 
  def recv_authorizePickup(self, ):
3709 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3710 
    if mtype == TMessageType.EXCEPTION:
3711 
      x = TApplicationException()
3712 
      x.read(self._iprot)
3713 
      self._iprot.readMessageEnd()
3714 
      raise x
3715 
    result = authorizePickup_result()
3716 
    result.read(self._iprot)
3717 
    self._iprot.readMessageEnd()
3431 rajveer 3718 
    if result.success is not None:
2536 chandransh 3719 
      return result.success
3431 rajveer 3720 
    if result.ex is not None:
2536 chandransh 3721 
      raise result.ex
3722 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "authorizePickup failed: unknown result");
3723 
 
2764 chandransh 3724 
  def markDoasAsPickedUp(self, providerId, pickupDetails):
3725 
    """
3726 
    Marks all DOA_PICKUP_AUTHORIZED orders of the previous day for a provider as DOA_RETURN_IN_TRANSIT.
3431 rajveer 3727 
 
2764 chandransh 3728 
    Parameters:
3729 
     - providerId
3730 
     - pickupDetails
3731 
    """
3732 
    self.send_markDoasAsPickedUp(providerId, pickupDetails)
4910 phani.kuma 3733 
    self.recv_markDoasAsPickedUp()
2764 chandransh 3734 
 
3735 
  def send_markDoasAsPickedUp(self, providerId, pickupDetails):
3736 
    self._oprot.writeMessageBegin('markDoasAsPickedUp', TMessageType.CALL, self._seqid)
3737 
    args = markDoasAsPickedUp_args()
3738 
    args.providerId = providerId
3739 
    args.pickupDetails = pickupDetails
3740 
    args.write(self._oprot)
3741 
    self._oprot.writeMessageEnd()
3742 
    self._oprot.trans.flush()
3743 
 
3744 
  def recv_markDoasAsPickedUp(self, ):
3745 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3746 
    if mtype == TMessageType.EXCEPTION:
3747 
      x = TApplicationException()
3748 
      x.read(self._iprot)
3749 
      self._iprot.readMessageEnd()
3750 
      raise x
3751 
    result = markDoasAsPickedUp_result()
3752 
    result.read(self._iprot)
3753 
    self._iprot.readMessageEnd()
4910 phani.kuma 3754 
    return
3755 
 
3756 
  def getDoasNotPickedUp(self, providerId):
3757 
    """
3758 
    Returns a list of orders that were authorized for pickup but did not appear in the pick-up report.
3759 
 
3760 
    Parameters:
3761 
     - providerId
3762 
    """
3763 
    self.send_getDoasNotPickedUp(providerId)
3764 
    return self.recv_getDoasNotPickedUp()
3765 
 
3766 
  def send_getDoasNotPickedUp(self, providerId):
3767 
    self._oprot.writeMessageBegin('getDoasNotPickedUp', TMessageType.CALL, self._seqid)
3768 
    args = getDoasNotPickedUp_args()
3769 
    args.providerId = providerId
3770 
    args.write(self._oprot)
3771 
    self._oprot.writeMessageEnd()
3772 
    self._oprot.trans.flush()
3773 
 
3774 
  def recv_getDoasNotPickedUp(self, ):
3775 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3776 
    if mtype == TMessageType.EXCEPTION:
3777 
      x = TApplicationException()
3778 
      x.read(self._iprot)
3779 
      self._iprot.readMessageEnd()
3780 
      raise x
3781 
    result = getDoasNotPickedUp_result()
3782 
    result.read(self._iprot)
3783 
    self._iprot.readMessageEnd()
3431 rajveer 3784 
    if result.success is not None:
2764 chandransh 3785 
      return result.success
4910 phani.kuma 3786 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getDoasNotPickedUp failed: unknown result");
2764 chandransh 3787 
 
4741 phani.kuma 3788 
  def markReturnOrdersAsPickedUp(self, providerId, pickupDetails):
3789 
    """
3790 
    Marks all RET_PICKUP_CONFIRMED orders of the previous day for a provider as RET_RETURN_IN_TRANSIT.
3791 
 
3792 
    Parameters:
3793 
     - providerId
3794 
     - pickupDetails
3795 
    """
3796 
    self.send_markReturnOrdersAsPickedUp(providerId, pickupDetails)
4910 phani.kuma 3797 
    self.recv_markReturnOrdersAsPickedUp()
4741 phani.kuma 3798 
 
3799 
  def send_markReturnOrdersAsPickedUp(self, providerId, pickupDetails):
3800 
    self._oprot.writeMessageBegin('markReturnOrdersAsPickedUp', TMessageType.CALL, self._seqid)
3801 
    args = markReturnOrdersAsPickedUp_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_markReturnOrdersAsPickedUp(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 = markReturnOrdersAsPickedUp_result()
3816 
    result.read(self._iprot)
3817 
    self._iprot.readMessageEnd()
4910 phani.kuma 3818 
    return
3819 
 
3820 
  def getReturnOrdersNotPickedUp(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_getReturnOrdersNotPickedUp(providerId)
3828 
    return self.recv_getReturnOrdersNotPickedUp()
3829 
 
3830 
  def send_getReturnOrdersNotPickedUp(self, providerId):
3831 
    self._oprot.writeMessageBegin('getReturnOrdersNotPickedUp', TMessageType.CALL, self._seqid)
3832 
    args = getReturnOrdersNotPickedUp_args()
3833 
    args.providerId = providerId
3834 
    args.write(self._oprot)
3835 
    self._oprot.writeMessageEnd()
3836 
    self._oprot.trans.flush()
3837 
 
3838 
  def recv_getReturnOrdersNotPickedUp(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 = getReturnOrdersNotPickedUp_result()
3846 
    result.read(self._iprot)
3847 
    self._iprot.readMessageEnd()
4741 phani.kuma 3848 
    if result.success is not None:
3849 
      return result.success
4910 phani.kuma 3850 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReturnOrdersNotPickedUp failed: unknown result");
4741 phani.kuma 3851 
 
4479 rajveer 3852 
  def receiveReturn(self, orderId, receiveCondition):
2591 chandransh 3853 
    """
4452 rajveer 3854 
    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 3855 
    If the order status is RTO_IN_TRANSIT, marks the order status as RTO_RECEIVED_PRESTINE and returns true.
2591 chandransh 3856 
    If the order is in any other state, it returns false.
3857 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 3858 
 
2591 chandransh 3859 
    Parameters:
3860 
     - orderId
4479 rajveer 3861 
     - receiveCondition
2591 chandransh 3862 
    """
4479 rajveer 3863 
    self.send_receiveReturn(orderId, receiveCondition)
2616 chandransh 3864 
    return self.recv_receiveReturn()
2536 chandransh 3865 
 
4479 rajveer 3866 
  def send_receiveReturn(self, orderId, receiveCondition):
2616 chandransh 3867 
    self._oprot.writeMessageBegin('receiveReturn', TMessageType.CALL, self._seqid)
3868 
    args = receiveReturn_args()
2591 chandransh 3869 
    args.orderId = orderId
4479 rajveer 3870 
    args.receiveCondition = receiveCondition
2591 chandransh 3871 
    args.write(self._oprot)
3872 
    self._oprot.writeMessageEnd()
3873 
    self._oprot.trans.flush()
3874 
 
2616 chandransh 3875 
  def recv_receiveReturn(self, ):
2591 chandransh 3876 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3877 
    if mtype == TMessageType.EXCEPTION:
3878 
      x = TApplicationException()
3879 
      x.read(self._iprot)
3880 
      self._iprot.readMessageEnd()
3881 
      raise x
2616 chandransh 3882 
    result = receiveReturn_result()
2591 chandransh 3883 
    result.read(self._iprot)
3884 
    self._iprot.readMessageEnd()
3431 rajveer 3885 
    if result.success is not None:
2591 chandransh 3886 
      return result.success
3431 rajveer 3887 
    if result.ex is not None:
2591 chandransh 3888 
      raise result.ex
2616 chandransh 3889 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "receiveReturn failed: unknown result");
2591 chandransh 3890 
 
3891 
  def validateDoa(self, orderId, isValid):
3892 
    """
4452 rajveer 3893 
    Used to validate the DOA certificate for an order in the DOA_RECEIVED_PRESTINE state. If the certificate is valid,
2616 chandransh 3894 
    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 3895 
    If the order is in any other state, it returns false.
3896 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 3897 
 
2591 chandransh 3898 
    Parameters:
3899 
     - orderId
3900 
     - isValid
3901 
    """
3902 
    self.send_validateDoa(orderId, isValid)
3903 
    return self.recv_validateDoa()
3904 
 
3905 
  def send_validateDoa(self, orderId, isValid):
3906 
    self._oprot.writeMessageBegin('validateDoa', TMessageType.CALL, self._seqid)
3907 
    args = validateDoa_args()
3908 
    args.orderId = orderId
3909 
    args.isValid = isValid
3910 
    args.write(self._oprot)
3911 
    self._oprot.writeMessageEnd()
3912 
    self._oprot.trans.flush()
3913 
 
3914 
  def recv_validateDoa(self, ):
3915 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3916 
    if mtype == TMessageType.EXCEPTION:
3917 
      x = TApplicationException()
3918 
      x.read(self._iprot)
3919 
      self._iprot.readMessageEnd()
3920 
      raise x
3921 
    result = validateDoa_result()
3922 
    result.read(self._iprot)
3923 
    self._iprot.readMessageEnd()
3431 rajveer 3924 
    if result.success is not None:
2591 chandransh 3925 
      return result.success
3431 rajveer 3926 
    if result.ex is not None:
2591 chandransh 3927 
      raise result.ex
3928 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "validateDoa failed: unknown result");
3929 
 
4495 rajveer 3930 
  def validateReturnProduct(self, orderId, isUsable):
3931 
    """
3932 
    Parameters:
3933 
     - orderId
3934 
     - isUsable
3935 
    """
3936 
    self.send_validateReturnProduct(orderId, isUsable)
3937 
    return self.recv_validateReturnProduct()
3938 
 
3939 
  def send_validateReturnProduct(self, orderId, isUsable):
3940 
    self._oprot.writeMessageBegin('validateReturnProduct', TMessageType.CALL, self._seqid)
3941 
    args = validateReturnProduct_args()
3942 
    args.orderId = orderId
3943 
    args.isUsable = isUsable
3944 
    args.write(self._oprot)
3945 
    self._oprot.writeMessageEnd()
3946 
    self._oprot.trans.flush()
3947 
 
3948 
  def recv_validateReturnProduct(self, ):
3949 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3950 
    if mtype == TMessageType.EXCEPTION:
3951 
      x = TApplicationException()
3952 
      x.read(self._iprot)
3953 
      self._iprot.readMessageEnd()
3954 
      raise x
3955 
    result = validateReturnProduct_result()
3956 
    result.read(self._iprot)
3957 
    self._iprot.readMessageEnd()
3958 
    if result.success is not None:
3959 
      return result.success
3960 
    if result.ex is not None:
3961 
      raise result.ex
3962 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "validateReturnProduct failed: unknown result");
3963 
 
2616 chandransh 3964 
  def reshipOrder(self, orderId):
3965 
    """
4484 rajveer 3966 
    If the order is in RTO_RECEIVED_PRESTINE or DOA_CERT_INVALID state, it does the following:
2616 chandransh 3967 
    	1. Creates a new order for processing in the BILLED state. All billing information is saved.
4484 rajveer 3968 
    	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 3969 
 
3970 
    If the order is in DOA_CERT_VALID state, it does the following:
3971 
    	1. Creates a new order for processing in the SUBMITTED_FOR_PROCESSING state.
3972 
    	2. Creates a return order for the warehouse executive to return the DOA material.
4452 rajveer 3973 
    	3. Marks the current order as the final DOA_VALID_RESHIPPED state.
3431 rajveer 3974 
 
2616 chandransh 3975 
    Returns the id of the newly created order.
3431 rajveer 3976 
 
2616 chandransh 3977 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 3978 
 
2616 chandransh 3979 
    Parameters:
3980 
     - orderId
3981 
    """
3982 
    self.send_reshipOrder(orderId)
3983 
    return self.recv_reshipOrder()
2591 chandransh 3984 
 
2616 chandransh 3985 
  def send_reshipOrder(self, orderId):
3986 
    self._oprot.writeMessageBegin('reshipOrder', TMessageType.CALL, self._seqid)
3987 
    args = reshipOrder_args()
3988 
    args.orderId = orderId
3989 
    args.write(self._oprot)
3990 
    self._oprot.writeMessageEnd()
3991 
    self._oprot.trans.flush()
3992 
 
3993 
  def recv_reshipOrder(self, ):
3994 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3995 
    if mtype == TMessageType.EXCEPTION:
3996 
      x = TApplicationException()
3997 
      x.read(self._iprot)
3998 
      self._iprot.readMessageEnd()
3999 
      raise x
4000 
    result = reshipOrder_result()
4001 
    result.read(self._iprot)
4002 
    self._iprot.readMessageEnd()
3431 rajveer 4003 
    if result.success is not None:
2616 chandransh 4004 
      return result.success
3431 rajveer 4005 
    if result.ex is not None:
2616 chandransh 4006 
      raise result.ex
4007 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "reshipOrder failed: unknown result");
4008 
 
3226 chandransh 4009 
  def refundOrder(self, orderId, refundedBy, reason):
2616 chandransh 4010 
    """
4484 rajveer 4011 
    If the order is in RTO_RECEIVED_PRESTINE, DOA_CERT_VALID or DOA_CERT_INVALID state, it does the following:
2616 chandransh 4012 
    	1. Creates a refund request for batch processing.
4013 
    	2. Creates a return order for the warehouse executive to return the shipped material.
4484 rajveer 4014 
    	3. Marks the current order as RTO_REFUNDED, DOA_VALID_REFUNDED or DOA_INVALID_REFUNDED final states.
3431 rajveer 4015 
 
2616 chandransh 4016 
    If the order is in SUBMITTED_FOR_PROCESSING or INVENTORY_LOW state, it does the following:
4017 
    	1. Creates a refund request for batch processing.
3226 chandransh 4018 
    	2. Cancels the reservation of the item in the warehouse.
4019 
    	3. Marks the current order as the REFUNDED final state.
3431 rajveer 4020 
 
3226 chandransh 4021 
    For all COD orders, if the order is in INIT, SUBMITTED_FOR_PROCESSING or INVENTORY_LOW state, it does the following:
4022 
    	1. Cancels the reservation of the item in the warehouse.
4023 
    	2. Marks the current order as CANCELED.
4024 
 
4025 
    In all cases, it updates the reason for cancellation or refund and the person who performed the action.
4026 
 
2616 chandransh 4027 
    Returns True if it is successful, False otherwise.
3431 rajveer 4028 
 
2616 chandransh 4029 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 4030 
 
2616 chandransh 4031 
    Parameters:
4032 
     - orderId
3226 chandransh 4033 
     - refundedBy
4034 
     - reason
2616 chandransh 4035 
    """
3226 chandransh 4036 
    self.send_refundOrder(orderId, refundedBy, reason)
2616 chandransh 4037 
    return self.recv_refundOrder()
4038 
 
3226 chandransh 4039 
  def send_refundOrder(self, orderId, refundedBy, reason):
2616 chandransh 4040 
    self._oprot.writeMessageBegin('refundOrder', TMessageType.CALL, self._seqid)
4041 
    args = refundOrder_args()
4042 
    args.orderId = orderId
3226 chandransh 4043 
    args.refundedBy = refundedBy
4044 
    args.reason = reason
2616 chandransh 4045 
    args.write(self._oprot)
4046 
    self._oprot.writeMessageEnd()
4047 
    self._oprot.trans.flush()
4048 
 
4049 
  def recv_refundOrder(self, ):
4050 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4051 
    if mtype == TMessageType.EXCEPTION:
4052 
      x = TApplicationException()
4053 
      x.read(self._iprot)
4054 
      self._iprot.readMessageEnd()
4055 
      raise x
4056 
    result = refundOrder_result()
4057 
    result.read(self._iprot)
4058 
    self._iprot.readMessageEnd()
3431 rajveer 4059 
    if result.success is not None:
2616 chandransh 4060 
      return result.success
3431 rajveer 4061 
    if result.ex is not None:
2616 chandransh 4062 
      raise result.ex
4063 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "refundOrder failed: unknown result");
4064 
 
2690 chandransh 4065 
  def getReturnOrders(self, warehouseId, fromDate, toDate):
4066 
    """
4067 
    Get all return orders created between the from and to dates for the given warehouse.
4068 
    Ignores the warehouse if it is passed as -1.
3431 rajveer 4069 
 
2690 chandransh 4070 
    Parameters:
4071 
     - warehouseId
4072 
     - fromDate
4073 
     - toDate
4074 
    """
4075 
    self.send_getReturnOrders(warehouseId, fromDate, toDate)
4076 
    return self.recv_getReturnOrders()
2616 chandransh 4077 
 
2690 chandransh 4078 
  def send_getReturnOrders(self, warehouseId, fromDate, toDate):
4079 
    self._oprot.writeMessageBegin('getReturnOrders', TMessageType.CALL, self._seqid)
4080 
    args = getReturnOrders_args()
4081 
    args.warehouseId = warehouseId
4082 
    args.fromDate = fromDate
4083 
    args.toDate = toDate
4084 
    args.write(self._oprot)
4085 
    self._oprot.writeMessageEnd()
4086 
    self._oprot.trans.flush()
4087 
 
4088 
  def recv_getReturnOrders(self, ):
4089 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4090 
    if mtype == TMessageType.EXCEPTION:
4091 
      x = TApplicationException()
4092 
      x.read(self._iprot)
4093 
      self._iprot.readMessageEnd()
4094 
      raise x
4095 
    result = getReturnOrders_result()
4096 
    result.read(self._iprot)
4097 
    self._iprot.readMessageEnd()
3431 rajveer 4098 
    if result.success is not None:
2690 chandransh 4099 
      return result.success
4100 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReturnOrders failed: unknown result");
4101 
 
5481 phani.kuma 4102 
  def getAllReturnOrders(self, onlyNotProcessed, fromDate, toDate):
4103 
    """
4104 
    Get all return orders created between the from and to dates.
4105 
 
4106 
    Parameters:
4107 
     - onlyNotProcessed
4108 
     - fromDate
4109 
     - toDate
4110 
    """
4111 
    self.send_getAllReturnOrders(onlyNotProcessed, fromDate, toDate)
4112 
    return self.recv_getAllReturnOrders()
4113 
 
4114 
  def send_getAllReturnOrders(self, onlyNotProcessed, fromDate, toDate):
4115 
    self._oprot.writeMessageBegin('getAllReturnOrders', TMessageType.CALL, self._seqid)
4116 
    args = getAllReturnOrders_args()
4117 
    args.onlyNotProcessed = onlyNotProcessed
4118 
    args.fromDate = fromDate
4119 
    args.toDate = toDate
4120 
    args.write(self._oprot)
4121 
    self._oprot.writeMessageEnd()
4122 
    self._oprot.trans.flush()
4123 
 
4124 
  def recv_getAllReturnOrders(self, ):
4125 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4126 
    if mtype == TMessageType.EXCEPTION:
4127 
      x = TApplicationException()
4128 
      x.read(self._iprot)
4129 
      self._iprot.readMessageEnd()
4130 
      raise x
4131 
    result = getAllReturnOrders_result()
4132 
    result.read(self._iprot)
4133 
    self._iprot.readMessageEnd()
4134 
    if result.success is not None:
4135 
      return result.success
4136 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllReturnOrders failed: unknown result");
4137 
 
2700 chandransh 4138 
  def getReturnOrder(self, id):
4139 
    """
4140 
    Returns the ReturnOrder corresponding to the given id.
4141 
    Throws an exception if the return order with the given id couldn't be found.
3431 rajveer 4142 
 
2700 chandransh 4143 
    Parameters:
4144 
     - id
4145 
    """
4146 
    self.send_getReturnOrder(id)
4147 
    return self.recv_getReturnOrder()
4148 
 
4149 
  def send_getReturnOrder(self, id):
4150 
    self._oprot.writeMessageBegin('getReturnOrder', TMessageType.CALL, self._seqid)
4151 
    args = getReturnOrder_args()
4152 
    args.id = id
4153 
    args.write(self._oprot)
4154 
    self._oprot.writeMessageEnd()
4155 
    self._oprot.trans.flush()
4156 
 
4157 
  def recv_getReturnOrder(self, ):
4158 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4159 
    if mtype == TMessageType.EXCEPTION:
4160 
      x = TApplicationException()
4161 
      x.read(self._iprot)
4162 
      self._iprot.readMessageEnd()
4163 
      raise x
4164 
    result = getReturnOrder_result()
4165 
    result.read(self._iprot)
4166 
    self._iprot.readMessageEnd()
3431 rajveer 4167 
    if result.success is not None:
2700 chandransh 4168 
      return result.success
3431 rajveer 4169 
    if result.ex is not None:
2700 chandransh 4170 
      raise result.ex
4171 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReturnOrder failed: unknown result");
4172 
 
2690 chandransh 4173 
  def processReturn(self, returnOrderId):
4174 
    """
4175 
    Marks the return order with the given id as processed. Raises an exception if no such return order exists.
3431 rajveer 4176 
 
2690 chandransh 4177 
    Parameters:
4178 
     - returnOrderId
4179 
    """
4180 
    self.send_processReturn(returnOrderId)
4181 
    self.recv_processReturn()
4182 
 
4183 
  def send_processReturn(self, returnOrderId):
4184 
    self._oprot.writeMessageBegin('processReturn', TMessageType.CALL, self._seqid)
4185 
    args = processReturn_args()
4186 
    args.returnOrderId = returnOrderId
4187 
    args.write(self._oprot)
4188 
    self._oprot.writeMessageEnd()
4189 
    self._oprot.trans.flush()
4190 
 
4191 
  def recv_processReturn(self, ):
4192 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4193 
    if mtype == TMessageType.EXCEPTION:
4194 
      x = TApplicationException()
4195 
      x.read(self._iprot)
4196 
      self._iprot.readMessageEnd()
4197 
      raise x
4198 
    result = processReturn_result()
4199 
    result.read(self._iprot)
4200 
    self._iprot.readMessageEnd()
3431 rajveer 4201 
    if result.ex is not None:
2690 chandransh 4202 
      raise result.ex
4203 
    return
4204 
 
3451 chandransh 4205 
  def updateWeight(self, orderId, weight):
4206 
    """
4207 
    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 4208 
 
3451 chandransh 4209 
    Parameters:
4210 
     - orderId
4211 
     - weight
4212 
    """
4213 
    self.send_updateWeight(orderId, weight)
4214 
    return self.recv_updateWeight()
4215 
 
4216 
  def send_updateWeight(self, orderId, weight):
4217 
    self._oprot.writeMessageBegin('updateWeight', TMessageType.CALL, self._seqid)
4218 
    args = updateWeight_args()
4219 
    args.orderId = orderId
4220 
    args.weight = weight
4221 
    args.write(self._oprot)
4222 
    self._oprot.writeMessageEnd()
4223 
    self._oprot.trans.flush()
4224 
 
4225 
  def recv_updateWeight(self, ):
4226 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4227 
    if mtype == TMessageType.EXCEPTION:
4228 
      x = TApplicationException()
4229 
      x.read(self._iprot)
4230 
      self._iprot.readMessageEnd()
4231 
      raise x
4232 
    result = updateWeight_result()
4233 
    result.read(self._iprot)
4234 
    self._iprot.readMessageEnd()
4235 
    if result.success is not None:
4236 
      return result.success
4237 
    if result.ex is not None:
4238 
      raise result.ex
4239 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updateWeight failed: unknown result");
4240 
 
3469 chandransh 4241 
  def changeItem(self, orderId, itemId):
4242 
    """
4243 
    Change the item to be shipped for this order. Also adjusts the reservation in the inventory accordingly.
4244 
    Currently, it also ensures that only a different color of the given item is shipped.
3451 chandransh 4245 
 
3469 chandransh 4246 
    Parameters:
4247 
     - orderId
4248 
     - itemId
4249 
    """
4250 
    self.send_changeItem(orderId, itemId)
4251 
    return self.recv_changeItem()
4252 
 
4253 
  def send_changeItem(self, orderId, itemId):
4254 
    self._oprot.writeMessageBegin('changeItem', TMessageType.CALL, self._seqid)
4255 
    args = changeItem_args()
4256 
    args.orderId = orderId
4257 
    args.itemId = itemId
4258 
    args.write(self._oprot)
4259 
    self._oprot.writeMessageEnd()
4260 
    self._oprot.trans.flush()
4261 
 
4262 
  def recv_changeItem(self, ):
4263 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4264 
    if mtype == TMessageType.EXCEPTION:
4265 
      x = TApplicationException()
4266 
      x.read(self._iprot)
4267 
      self._iprot.readMessageEnd()
4268 
      raise x
4269 
    result = changeItem_result()
4270 
    result.read(self._iprot)
4271 
    self._iprot.readMessageEnd()
4272 
    if result.success is not None:
4273 
      return result.success
4274 
    if result.ex is not None:
4275 
      raise result.ex
4276 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "changeItem failed: unknown result");
4277 
 
4278 
  def shiftToWarehouse(self, orderId, warehouseId):
4279 
    """
4280 
    Moves the given order to the given warehouse. Also adjusts the inventory reservations accordingly.
4281 
 
4282 
    Parameters:
4283 
     - orderId
4284 
     - warehouseId
4285 
    """
4286 
    self.send_shiftToWarehouse(orderId, warehouseId)
4287 
    return self.recv_shiftToWarehouse()
4288 
 
4289 
  def send_shiftToWarehouse(self, orderId, warehouseId):
4290 
    self._oprot.writeMessageBegin('shiftToWarehouse', TMessageType.CALL, self._seqid)
4291 
    args = shiftToWarehouse_args()
4292 
    args.orderId = orderId
4293 
    args.warehouseId = warehouseId
4294 
    args.write(self._oprot)
4295 
    self._oprot.writeMessageEnd()
4296 
    self._oprot.trans.flush()
4297 
 
4298 
  def recv_shiftToWarehouse(self, ):
4299 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4300 
    if mtype == TMessageType.EXCEPTION:
4301 
      x = TApplicationException()
4302 
      x.read(self._iprot)
4303 
      self._iprot.readMessageEnd()
4304 
      raise x
4305 
    result = shiftToWarehouse_result()
4306 
    result.read(self._iprot)
4307 
    self._iprot.readMessageEnd()
4308 
    if result.success is not None:
4309 
      return result.success
4310 
    if result.ex is not None:
4311 
      raise result.ex
4312 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "shiftToWarehouse failed: unknown result");
4313 
 
4647 rajveer 4314 
  def addDelayReason(self, orderId, delayReason, furtherDelay, delayReasonText):
3553 chandransh 4315 
    """
4316 
    Adds the given delay reason to the given order.
3986 chandransh 4317 
    Increases the expected delivery time of the given order by the given no. of days.
3553 chandransh 4318 
    Raises an exception if no order with the given id can be found.
3469 chandransh 4319 
 
3553 chandransh 4320 
    Parameters:
4321 
     - orderId
4322 
     - delayReason
3986 chandransh 4323 
     - furtherDelay
4647 rajveer 4324 
     - delayReasonText
3553 chandransh 4325 
    """
4647 rajveer 4326 
    self.send_addDelayReason(orderId, delayReason, furtherDelay, delayReasonText)
3553 chandransh 4327 
    return self.recv_addDelayReason()
4328 
 
4647 rajveer 4329 
  def send_addDelayReason(self, orderId, delayReason, furtherDelay, delayReasonText):
3553 chandransh 4330 
    self._oprot.writeMessageBegin('addDelayReason', TMessageType.CALL, self._seqid)
4331 
    args = addDelayReason_args()
4332 
    args.orderId = orderId
4333 
    args.delayReason = delayReason
3986 chandransh 4334 
    args.furtherDelay = furtherDelay
4647 rajveer 4335 
    args.delayReasonText = delayReasonText
3553 chandransh 4336 
    args.write(self._oprot)
4337 
    self._oprot.writeMessageEnd()
4338 
    self._oprot.trans.flush()
4339 
 
4340 
  def recv_addDelayReason(self, ):
4341 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4342 
    if mtype == TMessageType.EXCEPTION:
4343 
      x = TApplicationException()
4344 
      x.read(self._iprot)
4345 
      self._iprot.readMessageEnd()
4346 
      raise x
4347 
    result = addDelayReason_result()
4348 
    result.read(self._iprot)
4349 
    self._iprot.readMessageEnd()
4350 
    if result.success is not None:
4351 
      return result.success
4352 
    if result.ex is not None:
4353 
      raise result.ex
4354 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addDelayReason failed: unknown result");
4355 
 
3956 chandransh 4356 
  def reconcileCodCollection(self, collectedAmountMap, xferBy, xferTxnId, xferDate):
4357 
    """
4358 
    Marks the COD orders with given AWB nos. as having been processed.
4359 
    Updates the captured amount for the corresponding payment.
3553 chandransh 4360 
 
3956 chandransh 4361 
    Returns a map of AWBs which were not processed and the associated reason. An AWB is not processed if:
4362 
    1. There is no order corresponding to an AWB number.
4363 
    2. The captured amount for a payment exceeds the total payment.
4364 
    3. The order corresponding to an AWB no. is in a state prior to DELIVERY_SUCCESS.
4365 
 
4366 
    Parameters:
4367 
     - collectedAmountMap
4368 
     - xferBy
4369 
     - xferTxnId
4370 
     - xferDate
4371 
    """
4372 
    self.send_reconcileCodCollection(collectedAmountMap, xferBy, xferTxnId, xferDate)
4373 
    return self.recv_reconcileCodCollection()
4374 
 
4375 
  def send_reconcileCodCollection(self, collectedAmountMap, xferBy, xferTxnId, xferDate):
4376 
    self._oprot.writeMessageBegin('reconcileCodCollection', TMessageType.CALL, self._seqid)
4377 
    args = reconcileCodCollection_args()
4378 
    args.collectedAmountMap = collectedAmountMap
4379 
    args.xferBy = xferBy
4380 
    args.xferTxnId = xferTxnId
4381 
    args.xferDate = xferDate
4382 
    args.write(self._oprot)
4383 
    self._oprot.writeMessageEnd()
4384 
    self._oprot.trans.flush()
4385 
 
4386 
  def recv_reconcileCodCollection(self, ):
4387 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4388 
    if mtype == TMessageType.EXCEPTION:
4389 
      x = TApplicationException()
4390 
      x.read(self._iprot)
4391 
      self._iprot.readMessageEnd()
4392 
      raise x
4393 
    result = reconcileCodCollection_result()
4394 
    result.read(self._iprot)
4395 
    self._iprot.readMessageEnd()
4396 
    if result.success is not None:
4397 
      return result.success
4398 
    if result.ex is not None:
4399 
      raise result.ex
4400 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "reconcileCodCollection failed: unknown result");
4401 
 
4008 mandeep.dh 4402 
  def getTransactionsRequiringExtraProcessing(self, category):
4403 
    """
4065 mandeep.dh 4404 
    Returns the list of transaction ids that require some extra processing and
4008 mandeep.dh 4405 
    which belong to a particular category. This is currently used by CRM
4065 mandeep.dh 4406 
    application. If no such transaction ids are present, it returns an empty list.
3956 chandransh 4407 
 
4008 mandeep.dh 4408 
    Parameters:
4409 
     - category
4410 
    """
4411 
    self.send_getTransactionsRequiringExtraProcessing(category)
4412 
    return self.recv_getTransactionsRequiringExtraProcessing()
4413 
 
4414 
  def send_getTransactionsRequiringExtraProcessing(self, category):
4415 
    self._oprot.writeMessageBegin('getTransactionsRequiringExtraProcessing', TMessageType.CALL, self._seqid)
4416 
    args = getTransactionsRequiringExtraProcessing_args()
4417 
    args.category = category
4418 
    args.write(self._oprot)
4419 
    self._oprot.writeMessageEnd()
4420 
    self._oprot.trans.flush()
4421 
 
4422 
  def recv_getTransactionsRequiringExtraProcessing(self, ):
4423 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4424 
    if mtype == TMessageType.EXCEPTION:
4425 
      x = TApplicationException()
4426 
      x.read(self._iprot)
4427 
      self._iprot.readMessageEnd()
4428 
      raise x
4429 
    result = getTransactionsRequiringExtraProcessing_result()
4430 
    result.read(self._iprot)
4431 
    self._iprot.readMessageEnd()
4432 
    if result.success is not None:
4433 
      return result.success
4434 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransactionsRequiringExtraProcessing failed: unknown result");
4435 
 
4436 
  def markTransactionAsProcessed(self, transactionId, category):
4437 
    """
4438 
    Marks a particular transaction as processed for a particular cateogory.
4065 mandeep.dh 4439 
    It essentially deletes the transaction id record for a particular
4440 
    processing type category (if present) from DB.
4441 
    This is currently used by CRM application.
4008 mandeep.dh 4442 
 
4443 
    Parameters:
4444 
     - transactionId
4445 
     - category
4446 
    """
4447 
    self.send_markTransactionAsProcessed(transactionId, category)
4448 
    self.recv_markTransactionAsProcessed()
4449 
 
4450 
  def send_markTransactionAsProcessed(self, transactionId, category):
4451 
    self._oprot.writeMessageBegin('markTransactionAsProcessed', TMessageType.CALL, self._seqid)
4452 
    args = markTransactionAsProcessed_args()
4453 
    args.transactionId = transactionId
4454 
    args.category = category
4455 
    args.write(self._oprot)
4456 
    self._oprot.writeMessageEnd()
4457 
    self._oprot.trans.flush()
4458 
 
4459 
  def recv_markTransactionAsProcessed(self, ):
4460 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4461 
    if mtype == TMessageType.EXCEPTION:
4462 
      x = TApplicationException()
4463 
      x.read(self._iprot)
4464 
      self._iprot.readMessageEnd()
4465 
      raise x
4466 
    result = markTransactionAsProcessed_result()
4467 
    result.read(self._iprot)
4468 
    self._iprot.readMessageEnd()
4469 
    return
4470 
 
4018 chandransh 4471 
  def getItemWiseRiskyOrdersCount(self, ):
4472 
    """
4473 
    Returns a map containing the number of risky orders keyed by item id. A risky order
4474 
    is defined as one whose shipping date is about to expire.
4475 
    """
4476 
    self.send_getItemWiseRiskyOrdersCount()
4477 
    return self.recv_getItemWiseRiskyOrdersCount()
4008 mandeep.dh 4478 
 
4018 chandransh 4479 
  def send_getItemWiseRiskyOrdersCount(self, ):
4480 
    self._oprot.writeMessageBegin('getItemWiseRiskyOrdersCount', TMessageType.CALL, self._seqid)
4481 
    args = getItemWiseRiskyOrdersCount_args()
4482 
    args.write(self._oprot)
4483 
    self._oprot.writeMessageEnd()
4484 
    self._oprot.trans.flush()
4485 
 
4486 
  def recv_getItemWiseRiskyOrdersCount(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 = getItemWiseRiskyOrdersCount_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, "getItemWiseRiskyOrdersCount failed: unknown result");
4499 
 
4295 varun.gupt 4500 
  def getOrdersForItemIds(self, itemIds):
4501 
    """
4502 
    Returns a list of all orders which have items with given id
4503 
 
4504 
    Parameters:
4505 
     - itemIds
4506 
    """
4507 
    self.send_getOrdersForItemIds(itemIds)
4508 
    return self.recv_getOrdersForItemIds()
4509 
 
4510 
  def send_getOrdersForItemIds(self, itemIds):
4511 
    self._oprot.writeMessageBegin('getOrdersForItemIds', TMessageType.CALL, self._seqid)
4512 
    args = getOrdersForItemIds_args()
4513 
    args.itemIds = itemIds
4514 
    args.write(self._oprot)
4515 
    self._oprot.writeMessageEnd()
4516 
    self._oprot.trans.flush()
4517 
 
4518 
  def recv_getOrdersForItemIds(self, ):
4519 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4520 
    if mtype == TMessageType.EXCEPTION:
4521 
      x = TApplicationException()
4522 
      x.read(self._iprot)
4523 
      self._iprot.readMessageEnd()
4524 
      raise x
4525 
    result = getOrdersForItemIds_result()
4526 
    result.read(self._iprot)
4527 
    self._iprot.readMessageEnd()
4528 
    if result.success is not None:
4529 
      return result.success
4530 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersForItemIds failed: unknown result");
4531 
 
4247 rajveer 4532 
  def markOrderCancellationRequestReceived(self, orderId):
4533 
    """
4534 
    Mark order as cancellation request received. If customer sends request of cancellation of
4535 
    a particular order, this method will be called. It will just change status of the order
4536 
    depending on its current status. It also records the previous status, so that we can move
4537 
    back to that status if cancellation request is denied.
4018 chandransh 4538 
 
4247 rajveer 4539 
    Parameters:
4540 
     - orderId
4541 
    """
4542 
    self.send_markOrderCancellationRequestReceived(orderId)
4543 
    self.recv_markOrderCancellationRequestReceived()
4544 
 
4545 
  def send_markOrderCancellationRequestReceived(self, orderId):
4546 
    self._oprot.writeMessageBegin('markOrderCancellationRequestReceived', TMessageType.CALL, self._seqid)
4547 
    args = markOrderCancellationRequestReceived_args()
4548 
    args.orderId = orderId
4549 
    args.write(self._oprot)
4550 
    self._oprot.writeMessageEnd()
4551 
    self._oprot.trans.flush()
4552 
 
4553 
  def recv_markOrderCancellationRequestReceived(self, ):
4554 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4555 
    if mtype == TMessageType.EXCEPTION:
4556 
      x = TApplicationException()
4557 
      x.read(self._iprot)
4558 
      self._iprot.readMessageEnd()
4559 
      raise x
4560 
    result = markOrderCancellationRequestReceived_result()
4561 
    result.read(self._iprot)
4562 
    self._iprot.readMessageEnd()
4563 
    if result.ex is not None:
4564 
      raise result.ex
4565 
    return
4566 
 
4567 
  def markOrderCancellationRequestConfirmed(self, orderId):
4568 
    """
4569 
    If we decide to to cancel order, CRM will call this method to move the status of order to
4570 
    cancellation request confirmed. After this OM will be able to cancel the order.
4571 
 
4572 
    Parameters:
4573 
     - orderId
4574 
    """
4575 
    self.send_markOrderCancellationRequestConfirmed(orderId)
4576 
    self.recv_markOrderCancellationRequestConfirmed()
4577 
 
4578 
  def send_markOrderCancellationRequestConfirmed(self, orderId):
4579 
    self._oprot.writeMessageBegin('markOrderCancellationRequestConfirmed', TMessageType.CALL, self._seqid)
4580 
    args = markOrderCancellationRequestConfirmed_args()
4581 
    args.orderId = orderId
4582 
    args.write(self._oprot)
4583 
    self._oprot.writeMessageEnd()
4584 
    self._oprot.trans.flush()
4585 
 
4586 
  def recv_markOrderCancellationRequestConfirmed(self, ):
4587 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4588 
    if mtype == TMessageType.EXCEPTION:
4589 
      x = TApplicationException()
4590 
      x.read(self._iprot)
4591 
      self._iprot.readMessageEnd()
4592 
      raise x
4593 
    result = markOrderCancellationRequestConfirmed_result()
4594 
    result.read(self._iprot)
4595 
    self._iprot.readMessageEnd()
4596 
    if result.ex is not None:
4597 
      raise result.ex
4598 
    return
4599 
 
4600 
  def markOrderCancellationRequestDenied(self, orderId):
4601 
    """
4602 
    If we decide to not to cancel order, we will move the order ro previous status.
4603 
 
4604 
    Parameters:
4605 
     - orderId
4606 
    """
4607 
    self.send_markOrderCancellationRequestDenied(orderId)
4608 
    self.recv_markOrderCancellationRequestDenied()
4609 
 
4610 
  def send_markOrderCancellationRequestDenied(self, orderId):
4611 
    self._oprot.writeMessageBegin('markOrderCancellationRequestDenied', TMessageType.CALL, self._seqid)
4612 
    args = markOrderCancellationRequestDenied_args()
4613 
    args.orderId = orderId
4614 
    args.write(self._oprot)
4615 
    self._oprot.writeMessageEnd()
4616 
    self._oprot.trans.flush()
4617 
 
4618 
  def recv_markOrderCancellationRequestDenied(self, ):
4619 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4620 
    if mtype == TMessageType.EXCEPTION:
4621 
      x = TApplicationException()
4622 
      x.read(self._iprot)
4623 
      self._iprot.readMessageEnd()
4624 
      raise x
4625 
    result = markOrderCancellationRequestDenied_result()
4626 
    result.read(self._iprot)
4627 
    self._iprot.readMessageEnd()
4628 
    if result.ex is not None:
4629 
      raise result.ex
4630 
    return
4631 
 
4258 rajveer 4632 
  def markTransactionAsPaymentFlagRemoved(self, transactionId):
4247 rajveer 4633 
    """
4258 rajveer 4634 
    If we and/or payment gateway has decided to accept the payment, this method needs to be called.
4635 
    Changed transaction and all orders status to payment accepted.
4247 rajveer 4636 
 
4637 
    Parameters:
4258 rajveer 4638 
     - transactionId
4247 rajveer 4639 
    """
4258 rajveer 4640 
    self.send_markTransactionAsPaymentFlagRemoved(transactionId)
4641 
    self.recv_markTransactionAsPaymentFlagRemoved()
4247 rajveer 4642 
 
4258 rajveer 4643 
  def send_markTransactionAsPaymentFlagRemoved(self, transactionId):
4644 
    self._oprot.writeMessageBegin('markTransactionAsPaymentFlagRemoved', TMessageType.CALL, self._seqid)
4645 
    args = markTransactionAsPaymentFlagRemoved_args()
4646 
    args.transactionId = transactionId
4247 rajveer 4647 
    args.write(self._oprot)
4648 
    self._oprot.writeMessageEnd()
4649 
    self._oprot.trans.flush()
4650 
 
4258 rajveer 4651 
  def recv_markTransactionAsPaymentFlagRemoved(self, ):
4247 rajveer 4652 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4653 
    if mtype == TMessageType.EXCEPTION:
4654 
      x = TApplicationException()
4655 
      x.read(self._iprot)
4656 
      self._iprot.readMessageEnd()
4657 
      raise x
4258 rajveer 4658 
    result = markTransactionAsPaymentFlagRemoved_result()
4247 rajveer 4659 
    result.read(self._iprot)
4660 
    self._iprot.readMessageEnd()
4661 
    if result.ex is not None:
4662 
      raise result.ex
4663 
    return
4664 
 
4259 anupam.sin 4665 
  def refundTransaction(self, transactionId, refundedBy, reason):
4666 
    """
4667 
    This method is called when a flagged payment is deemed unserviceable and the corresponding orders
4668 
    need to be cancelled
4247 rajveer 4669 
 
4259 anupam.sin 4670 
    Parameters:
4671 
     - transactionId
4672 
     - refundedBy
4673 
     - reason
4674 
    """
4675 
    self.send_refundTransaction(transactionId, refundedBy, reason)
4676 
    self.recv_refundTransaction()
4677 
 
4678 
  def send_refundTransaction(self, transactionId, refundedBy, reason):
4679 
    self._oprot.writeMessageBegin('refundTransaction', TMessageType.CALL, self._seqid)
4680 
    args = refundTransaction_args()
4681 
    args.transactionId = transactionId
4682 
    args.refundedBy = refundedBy
4683 
    args.reason = reason
4684 
    args.write(self._oprot)
4685 
    self._oprot.writeMessageEnd()
4686 
    self._oprot.trans.flush()
4687 
 
4688 
  def recv_refundTransaction(self, ):
4689 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4690 
    if mtype == TMessageType.EXCEPTION:
4691 
      x = TApplicationException()
4692 
      x.read(self._iprot)
4693 
      self._iprot.readMessageEnd()
4694 
      raise x
4695 
    result = refundTransaction_result()
4696 
    result.read(self._iprot)
4697 
    self._iprot.readMessageEnd()
4698 
    if result.ex is not None:
4699 
      raise result.ex
4700 
    return
4701 
 
4324 mandeep.dh 4702 
  def updateShipmentAddress(self, orderId, addressId):
4703 
    """
4704 
    Updates shipment address of an order. Delivery and shipping date estimates
4705 
    etc. are also updated here.
4706 
 
4707 
    Throws TransactionServiceException in case address change is not
4708 
    possible due to certain reasons such as new pincode in address is
4709 
    not serviceable etc.
4710 
 
4711 
    Parameters:
4712 
     - orderId
4713 
     - addressId
4714 
    """
4715 
    self.send_updateShipmentAddress(orderId, addressId)
4716 
    self.recv_updateShipmentAddress()
4717 
 
4718 
  def send_updateShipmentAddress(self, orderId, addressId):
4719 
    self._oprot.writeMessageBegin('updateShipmentAddress', TMessageType.CALL, self._seqid)
4720 
    args = updateShipmentAddress_args()
4721 
    args.orderId = orderId
4722 
    args.addressId = addressId
4723 
    args.write(self._oprot)
4724 
    self._oprot.writeMessageEnd()
4725 
    self._oprot.trans.flush()
4726 
 
4727 
  def recv_updateShipmentAddress(self, ):
4728 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4729 
    if mtype == TMessageType.EXCEPTION:
4730 
      x = TApplicationException()
4731 
      x.read(self._iprot)
4732 
      self._iprot.readMessageEnd()
4733 
      raise x
4734 
    result = updateShipmentAddress_result()
4735 
    result.read(self._iprot)
4736 
    self._iprot.readMessageEnd()
4737 
    if result.ex is not None:
4738 
      raise result.ex
4739 
    return
4740 
 
4285 rajveer 4741 
  def acceptOrdersForItemId(self, itemId, inventory):
4742 
    """
4743 
    Marks the orders as ACCEPTED for the given itemId and inventory. It also updates the accepted timestamp. If the
4744 
    given order is not a COD order, it also captures the payment if the same has not been captured.
4259 anupam.sin 4745 
 
4285 rajveer 4746 
    Parameters:
4747 
     - itemId
4748 
     - inventory
4749 
    """
4750 
    self.send_acceptOrdersForItemId(itemId, inventory)
4751 
    return self.recv_acceptOrdersForItemId()
4752 
 
4753 
  def send_acceptOrdersForItemId(self, itemId, inventory):
4754 
    self._oprot.writeMessageBegin('acceptOrdersForItemId', TMessageType.CALL, self._seqid)
4755 
    args = acceptOrdersForItemId_args()
4756 
    args.itemId = itemId
4757 
    args.inventory = inventory
4758 
    args.write(self._oprot)
4759 
    self._oprot.writeMessageEnd()
4760 
    self._oprot.trans.flush()
4761 
 
4762 
  def recv_acceptOrdersForItemId(self, ):
4763 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4764 
    if mtype == TMessageType.EXCEPTION:
4765 
      x = TApplicationException()
4766 
      x.read(self._iprot)
4767 
      self._iprot.readMessageEnd()
4768 
      raise x
4769 
    result = acceptOrdersForItemId_result()
4770 
    result.read(self._iprot)
4771 
    self._iprot.readMessageEnd()
4772 
    if result.success is not None:
4773 
      return result.success
4774 
    if result.ex is not None:
4775 
      raise result.ex
4776 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "acceptOrdersForItemId failed: unknown result");
4777 
 
4369 rajveer 4778 
  def markOrdersAsPORaised(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 4779 
    """
4780 
    Parameters:
4781 
     - vendorId
4782 
     - itemId
4783 
     - quantity
4784 
     - estimate
4369 rajveer 4785 
     - isReminder
4303 rajveer 4786 
    """
4369 rajveer 4787 
    self.send_markOrdersAsPORaised(vendorId, itemId, quantity, estimate, isReminder)
4303 rajveer 4788 
    self.recv_markOrdersAsPORaised()
4285 rajveer 4789 
 
4369 rajveer 4790 
  def send_markOrdersAsPORaised(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 4791 
    self._oprot.writeMessageBegin('markOrdersAsPORaised', TMessageType.CALL, self._seqid)
4792 
    args = markOrdersAsPORaised_args()
4793 
    args.vendorId = vendorId
4794 
    args.itemId = itemId
4795 
    args.quantity = quantity
4796 
    args.estimate = estimate
4369 rajveer 4797 
    args.isReminder = isReminder
4303 rajveer 4798 
    args.write(self._oprot)
4799 
    self._oprot.writeMessageEnd()
4800 
    self._oprot.trans.flush()
4801 
 
4802 
  def recv_markOrdersAsPORaised(self, ):
4803 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4804 
    if mtype == TMessageType.EXCEPTION:
4805 
      x = TApplicationException()
4806 
      x.read(self._iprot)
4807 
      self._iprot.readMessageEnd()
4808 
      raise x
4809 
    result = markOrdersAsPORaised_result()
4810 
    result.read(self._iprot)
4811 
    self._iprot.readMessageEnd()
4812 
    if result.ex is not None:
4813 
      raise result.ex
4814 
    return
4815 
 
4369 rajveer 4816 
  def markOrdersAsReversalInitiated(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 4817 
    """
4818 
    Parameters:
4819 
     - vendorId
4820 
     - itemId
4821 
     - quantity
4822 
     - estimate
4369 rajveer 4823 
     - isReminder
4303 rajveer 4824 
    """
4369 rajveer 4825 
    self.send_markOrdersAsReversalInitiated(vendorId, itemId, quantity, estimate, isReminder)
4303 rajveer 4826 
    self.recv_markOrdersAsReversalInitiated()
4827 
 
4369 rajveer 4828 
  def send_markOrdersAsReversalInitiated(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 4829 
    self._oprot.writeMessageBegin('markOrdersAsReversalInitiated', TMessageType.CALL, self._seqid)
4830 
    args = markOrdersAsReversalInitiated_args()
4831 
    args.vendorId = vendorId
4832 
    args.itemId = itemId
4833 
    args.quantity = quantity
4834 
    args.estimate = estimate
4369 rajveer 4835 
    args.isReminder = isReminder
4303 rajveer 4836 
    args.write(self._oprot)
4837 
    self._oprot.writeMessageEnd()
4838 
    self._oprot.trans.flush()
4839 
 
4840 
  def recv_markOrdersAsReversalInitiated(self, ):
4841 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4842 
    if mtype == TMessageType.EXCEPTION:
4843 
      x = TApplicationException()
4844 
      x.read(self._iprot)
4845 
      self._iprot.readMessageEnd()
4846 
      raise x
4847 
    result = markOrdersAsReversalInitiated_result()
4848 
    result.read(self._iprot)
4849 
    self._iprot.readMessageEnd()
4850 
    if result.ex is not None:
4851 
      raise result.ex
4852 
    return
4853 
 
4369 rajveer 4854 
  def markOrdersAsNotAvailabke(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 4855 
    """
4856 
    Parameters:
4857 
     - vendorId
4858 
     - itemId
4859 
     - quantity
4860 
     - estimate
4369 rajveer 4861 
     - isReminder
4303 rajveer 4862 
    """
4369 rajveer 4863 
    self.send_markOrdersAsNotAvailabke(vendorId, itemId, quantity, estimate, isReminder)
4303 rajveer 4864 
    self.recv_markOrdersAsNotAvailabke()
4865 
 
4369 rajveer 4866 
  def send_markOrdersAsNotAvailabke(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 4867 
    self._oprot.writeMessageBegin('markOrdersAsNotAvailabke', TMessageType.CALL, self._seqid)
4868 
    args = markOrdersAsNotAvailabke_args()
4869 
    args.vendorId = vendorId
4870 
    args.itemId = itemId
4871 
    args.quantity = quantity
4872 
    args.estimate = estimate
4369 rajveer 4873 
    args.isReminder = isReminder
4303 rajveer 4874 
    args.write(self._oprot)
4875 
    self._oprot.writeMessageEnd()
4876 
    self._oprot.trans.flush()
4877 
 
4878 
  def recv_markOrdersAsNotAvailabke(self, ):
4879 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4880 
    if mtype == TMessageType.EXCEPTION:
4881 
      x = TApplicationException()
4882 
      x.read(self._iprot)
4883 
      self._iprot.readMessageEnd()
4884 
      raise x
4885 
    result = markOrdersAsNotAvailabke_result()
4886 
    result.read(self._iprot)
4887 
    self._iprot.readMessageEnd()
4888 
    if result.ex is not None:
4889 
      raise result.ex
4890 
    return
4891 
 
4369 rajveer 4892 
  def markOrdersAsTimeout(self, vendorId):
4893 
    """
4894 
    Parameters:
4895 
     - vendorId
4896 
    """
4897 
    self.send_markOrdersAsTimeout(vendorId)
4898 
    return self.recv_markOrdersAsTimeout()
4303 rajveer 4899 
 
4369 rajveer 4900 
  def send_markOrdersAsTimeout(self, vendorId):
4901 
    self._oprot.writeMessageBegin('markOrdersAsTimeout', TMessageType.CALL, self._seqid)
4902 
    args = markOrdersAsTimeout_args()
4903 
    args.vendorId = vendorId
4904 
    args.write(self._oprot)
4905 
    self._oprot.writeMessageEnd()
4906 
    self._oprot.trans.flush()
4907 
 
4908 
  def recv_markOrdersAsTimeout(self, ):
4909 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4910 
    if mtype == TMessageType.EXCEPTION:
4911 
      x = TApplicationException()
4912 
      x.read(self._iprot)
4913 
      self._iprot.readMessageEnd()
4914 
      raise x
4915 
    result = markOrdersAsTimeout_result()
4916 
    result.read(self._iprot)
4917 
    self._iprot.readMessageEnd()
4918 
    if result.success is not None:
4919 
      return result.success
4920 
    if result.ex is not None:
4921 
      raise result.ex
4922 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrdersAsTimeout failed: unknown result");
4923 
 
4662 rajveer 4924 
  def markOrderAsLostInTransit(self, orderId):
4925 
    """
4926 
    Mark order as LOST_IN_TRANSIT
4927 
 
4928 
    Parameters:
4929 
     - orderId
4930 
    """
4931 
    self.send_markOrderAsLostInTransit(orderId)
4932 
    return self.recv_markOrderAsLostInTransit()
4933 
 
4934 
  def send_markOrderAsLostInTransit(self, orderId):
4935 
    self._oprot.writeMessageBegin('markOrderAsLostInTransit', TMessageType.CALL, self._seqid)
4936 
    args = markOrderAsLostInTransit_args()
4937 
    args.orderId = orderId
4938 
    args.write(self._oprot)
4939 
    self._oprot.writeMessageEnd()
4940 
    self._oprot.trans.flush()
4941 
 
4942 
  def recv_markOrderAsLostInTransit(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 = markOrderAsLostInTransit_result()
4950 
    result.read(self._iprot)
4951 
    self._iprot.readMessageEnd()
4952 
    if result.success is not None:
4953 
      return result.success
4954 
    if result.ex is not None:
4955 
      raise result.ex
4956 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderAsLostInTransit failed: unknown result");
4957 
 
4386 anupam.sin 4958 
  def getOrderForAwb(self, awb):
4959 
    """
4960 
    Returns the order corresponding to an AWB number
4369 rajveer 4961 
 
4386 anupam.sin 4962 
    Parameters:
4963 
     - awb
4964 
    """
4965 
    self.send_getOrderForAwb(awb)
4966 
    return self.recv_getOrderForAwb()
4967 
 
4968 
  def send_getOrderForAwb(self, awb):
4969 
    self._oprot.writeMessageBegin('getOrderForAwb', TMessageType.CALL, self._seqid)
4970 
    args = getOrderForAwb_args()
4971 
    args.awb = awb
4972 
    args.write(self._oprot)
4973 
    self._oprot.writeMessageEnd()
4974 
    self._oprot.trans.flush()
4975 
 
4976 
  def recv_getOrderForAwb(self, ):
4977 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4978 
    if mtype == TMessageType.EXCEPTION:
4979 
      x = TApplicationException()
4980 
      x.read(self._iprot)
4981 
      self._iprot.readMessageEnd()
4982 
      raise x
4983 
    result = getOrderForAwb_result()
4984 
    result.read(self._iprot)
4985 
    self._iprot.readMessageEnd()
4986 
    if result.success is not None:
4987 
      return result.success
4988 
    if result.ex is not None:
4989 
      raise result.ex
4990 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderForAwb failed: unknown result");
4991 
 
4910 phani.kuma 4992 
  def getOrdersForProviderForStatus(self, logistics_provider_id, order_status_list):
4506 phani.kuma 4993 
    """
4910 phani.kuma 4994 
    Returns the order corresponding to a logistics provider id for a given list of order status
4386 anupam.sin 4995 
 
4506 phani.kuma 4996 
    Parameters:
4997 
     - logistics_provider_id
4910 phani.kuma 4998 
     - order_status_list
4506 phani.kuma 4999 
    """
4910 phani.kuma 5000 
    self.send_getOrdersForProviderForStatus(logistics_provider_id, order_status_list)
4506 phani.kuma 5001 
    return self.recv_getOrdersForProviderForStatus()
5002 
 
4910 phani.kuma 5003 
  def send_getOrdersForProviderForStatus(self, logistics_provider_id, order_status_list):
4506 phani.kuma 5004 
    self._oprot.writeMessageBegin('getOrdersForProviderForStatus', TMessageType.CALL, self._seqid)
5005 
    args = getOrdersForProviderForStatus_args()
5006 
    args.logistics_provider_id = logistics_provider_id
4910 phani.kuma 5007 
    args.order_status_list = order_status_list
4506 phani.kuma 5008 
    args.write(self._oprot)
5009 
    self._oprot.writeMessageEnd()
5010 
    self._oprot.trans.flush()
5011 
 
5012 
  def recv_getOrdersForProviderForStatus(self, ):
5013 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5014 
    if mtype == TMessageType.EXCEPTION:
5015 
      x = TApplicationException()
5016 
      x.read(self._iprot)
5017 
      self._iprot.readMessageEnd()
5018 
      raise x
5019 
    result = getOrdersForProviderForStatus_result()
5020 
    result.read(self._iprot)
5021 
    self._iprot.readMessageEnd()
5022 
    if result.success is not None:
5023 
      return result.success
5024 
    if result.ex is not None:
5025 
      raise result.ex
5026 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersForProviderForStatus failed: unknown result");
5027 
 
4600 varun.gupt 5028 
  def getBilledOrdersForVendor(self, vendorId, billingDateFrom, billingDateTo):
5029 
    """
5030 
    Returns list of orders fullfiled from a certain vendor and billed in a given date range
4506 phani.kuma 5031 
 
4600 varun.gupt 5032 
    Parameters:
5033 
     - vendorId
5034 
     - billingDateFrom
5035 
     - billingDateTo
5036 
    """
5037 
    self.send_getBilledOrdersForVendor(vendorId, billingDateFrom, billingDateTo)
5038 
    return self.recv_getBilledOrdersForVendor()
5039 
 
5040 
  def send_getBilledOrdersForVendor(self, vendorId, billingDateFrom, billingDateTo):
5041 
    self._oprot.writeMessageBegin('getBilledOrdersForVendor', TMessageType.CALL, self._seqid)
5042 
    args = getBilledOrdersForVendor_args()
5043 
    args.vendorId = vendorId
5044 
    args.billingDateFrom = billingDateFrom
5045 
    args.billingDateTo = billingDateTo
5046 
    args.write(self._oprot)
5047 
    self._oprot.writeMessageEnd()
5048 
    self._oprot.trans.flush()
5049 
 
5050 
  def recv_getBilledOrdersForVendor(self, ):
5051 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5052 
    if mtype == TMessageType.EXCEPTION:
5053 
      x = TApplicationException()
5054 
      x.read(self._iprot)
5055 
      self._iprot.readMessageEnd()
5056 
      raise x
5057 
    result = getBilledOrdersForVendor_result()
5058 
    result.read(self._iprot)
5059 
    self._iprot.readMessageEnd()
5060 
    if result.success is not None:
5061 
      return result.success
5062 
    if result.ex is not None:
5063 
      raise result.ex
5064 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBilledOrdersForVendor failed: unknown result");
5065 
 
4607 rajveer 5066 
  def getSlippedSippingDateOrders(self, ):
5067 
    self.send_getSlippedSippingDateOrders()
5068 
    return self.recv_getSlippedSippingDateOrders()
5069 
 
5070 
  def send_getSlippedSippingDateOrders(self, ):
5071 
    self._oprot.writeMessageBegin('getSlippedSippingDateOrders', TMessageType.CALL, self._seqid)
5072 
    args = getSlippedSippingDateOrders_args()
5073 
    args.write(self._oprot)
5074 
    self._oprot.writeMessageEnd()
5075 
    self._oprot.trans.flush()
5076 
 
5077 
  def recv_getSlippedSippingDateOrders(self, ):
5078 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5079 
    if mtype == TMessageType.EXCEPTION:
5080 
      x = TApplicationException()
5081 
      x.read(self._iprot)
5082 
      self._iprot.readMessageEnd()
5083 
      raise x
5084 
    result = getSlippedSippingDateOrders_result()
5085 
    result.read(self._iprot)
5086 
    self._iprot.readMessageEnd()
5087 
    if result.success is not None:
5088 
      return result.success
5089 
    if result.ex is not None:
5090 
      raise result.ex
5091 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getSlippedSippingDateOrders failed: unknown result");
5092 
 
4709 rajveer 5093 
  def getCancelledOrders(self, cancelDateFrom, cancelDateTo):
5094 
    """
5095 
    Parameters:
5096 
     - cancelDateFrom
5097 
     - cancelDateTo
5098 
    """
5099 
    self.send_getCancelledOrders(cancelDateFrom, cancelDateTo)
5100 
    return self.recv_getCancelledOrders()
5101 
 
5102 
  def send_getCancelledOrders(self, cancelDateFrom, cancelDateTo):
5103 
    self._oprot.writeMessageBegin('getCancelledOrders', TMessageType.CALL, self._seqid)
5104 
    args = getCancelledOrders_args()
5105 
    args.cancelDateFrom = cancelDateFrom
5106 
    args.cancelDateTo = cancelDateTo
5107 
    args.write(self._oprot)
5108 
    self._oprot.writeMessageEnd()
5109 
    self._oprot.trans.flush()
5110 
 
5111 
  def recv_getCancelledOrders(self, ):
5112 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5113 
    if mtype == TMessageType.EXCEPTION:
5114 
      x = TApplicationException()
5115 
      x.read(self._iprot)
5116 
      self._iprot.readMessageEnd()
5117 
      raise x
5118 
    result = getCancelledOrders_result()
5119 
    result.read(self._iprot)
5120 
    self._iprot.readMessageEnd()
5121 
    if result.success is not None:
5122 
      return result.success
5123 
    if result.ex is not None:
5124 
      raise result.ex
5125 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCancelledOrders failed: unknown result");
5126 
 
4600 varun.gupt 5127 
  def saveBluedartSettlements(self, mapAWBAndAmount):
5128 
    """
5129 
    Parameters:
5130 
     - mapAWBAndAmount
5131 
    """
5132 
    self.send_saveBluedartSettlements(mapAWBAndAmount)
5133 
    self.recv_saveBluedartSettlements()
5134 
 
5135 
  def send_saveBluedartSettlements(self, mapAWBAndAmount):
5136 
    self._oprot.writeMessageBegin('saveBluedartSettlements', TMessageType.CALL, self._seqid)
5137 
    args = saveBluedartSettlements_args()
5138 
    args.mapAWBAndAmount = mapAWBAndAmount
5139 
    args.write(self._oprot)
5140 
    self._oprot.writeMessageEnd()
5141 
    self._oprot.trans.flush()
5142 
 
5143 
  def recv_saveBluedartSettlements(self, ):
5144 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5145 
    if mtype == TMessageType.EXCEPTION:
5146 
      x = TApplicationException()
5147 
      x.read(self._iprot)
5148 
      self._iprot.readMessageEnd()
5149 
      raise x
5150 
    result = saveBluedartSettlements_result()
5151 
    result.read(self._iprot)
5152 
    self._iprot.readMessageEnd()
5153 
    if result.ex is not None:
5154 
      raise result.ex
5155 
    return
5156 
 
4905 varun.gupt 5157 
  def savePaymentSettlements(self, settlementDate, paymentGatewayId, referenceId, serviceTax, otherCharges, netCollection):
4600 varun.gupt 5158 
    """
5159 
    Parameters:
5160 
     - settlementDate
5161 
     - paymentGatewayId
4905 varun.gupt 5162 
     - referenceId
4600 varun.gupt 5163 
     - serviceTax
5164 
     - otherCharges
5165 
     - netCollection
5166 
    """
4905 varun.gupt 5167 
    self.send_savePaymentSettlements(settlementDate, paymentGatewayId, referenceId, serviceTax, otherCharges, netCollection)
4600 varun.gupt 5168 
    self.recv_savePaymentSettlements()
5169 
 
4905 varun.gupt 5170 
  def send_savePaymentSettlements(self, settlementDate, paymentGatewayId, referenceId, serviceTax, otherCharges, netCollection):
4600 varun.gupt 5171 
    self._oprot.writeMessageBegin('savePaymentSettlements', TMessageType.CALL, self._seqid)
5172 
    args = savePaymentSettlements_args()
5173 
    args.settlementDate = settlementDate
5174 
    args.paymentGatewayId = paymentGatewayId
4905 varun.gupt 5175 
    args.referenceId = referenceId
4600 varun.gupt 5176 
    args.serviceTax = serviceTax
5177 
    args.otherCharges = otherCharges
5178 
    args.netCollection = netCollection
5179 
    args.write(self._oprot)
5180 
    self._oprot.writeMessageEnd()
5181 
    self._oprot.trans.flush()
5182 
 
5183 
  def recv_savePaymentSettlements(self, ):
5184 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5185 
    if mtype == TMessageType.EXCEPTION:
5186 
      x = TApplicationException()
5187 
      x.read(self._iprot)
5188 
      self._iprot.readMessageEnd()
5189 
      raise x
5190 
    result = savePaymentSettlements_result()
5191 
    result.read(self._iprot)
5192 
    self._iprot.readMessageEnd()
5193 
    if result.ex is not None:
5194 
      raise result.ex
5195 
    return
5196 
 
5197 
  def saveEBSSettlementSummary(self, settlementId, settlementDate, transactionDateFrom, transactionDateTo, amount):
5198 
    """
5199 
    Parameters:
5200 
     - settlementId
5201 
     - settlementDate
5202 
     - transactionDateFrom
5203 
     - transactionDateTo
5204 
     - amount
5205 
    """
5206 
    self.send_saveEBSSettlementSummary(settlementId, settlementDate, transactionDateFrom, transactionDateTo, amount)
5207 
    self.recv_saveEBSSettlementSummary()
5208 
 
5209 
  def send_saveEBSSettlementSummary(self, settlementId, settlementDate, transactionDateFrom, transactionDateTo, amount):
5210 
    self._oprot.writeMessageBegin('saveEBSSettlementSummary', TMessageType.CALL, self._seqid)
5211 
    args = saveEBSSettlementSummary_args()
5212 
    args.settlementId = settlementId
5213 
    args.settlementDate = settlementDate
5214 
    args.transactionDateFrom = transactionDateFrom
5215 
    args.transactionDateTo = transactionDateTo
5216 
    args.amount = amount
5217 
    args.write(self._oprot)
5218 
    self._oprot.writeMessageEnd()
5219 
    self._oprot.trans.flush()
5220 
 
5221 
  def recv_saveEBSSettlementSummary(self, ):
5222 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5223 
    if mtype == TMessageType.EXCEPTION:
5224 
      x = TApplicationException()
5225 
      x.read(self._iprot)
5226 
      self._iprot.readMessageEnd()
5227 
      raise x
5228 
    result = saveEBSSettlementSummary_result()
5229 
    result.read(self._iprot)
5230 
    self._iprot.readMessageEnd()
5231 
    if result.ex is not None:
5232 
      raise result.ex
5233 
    return
5234 
 
5386 phani.kuma 5235 
  def getSettlementForPrepaid(self, referenceId, isRefund):
4600 varun.gupt 5236 
    """
5237 
    Parameters:
5189 varun.gupt 5238 
     - referenceId
5239 
     - isRefund
4600 varun.gupt 5240 
    """
5386 phani.kuma 5241 
    self.send_getSettlementForPrepaid(referenceId, isRefund)
5242 
    return self.recv_getSettlementForPrepaid()
4600 varun.gupt 5243 
 
5386 phani.kuma 5244 
  def send_getSettlementForPrepaid(self, referenceId, isRefund):
5245 
    self._oprot.writeMessageBegin('getSettlementForPrepaid', TMessageType.CALL, self._seqid)
5246 
    args = getSettlementForPrepaid_args()
5189 varun.gupt 5247 
    args.referenceId = referenceId
5248 
    args.isRefund = isRefund
4600 varun.gupt 5249 
    args.write(self._oprot)
5250 
    self._oprot.writeMessageEnd()
5251 
    self._oprot.trans.flush()
5252 
 
5386 phani.kuma 5253 
  def recv_getSettlementForPrepaid(self, ):
4600 varun.gupt 5254 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5255 
    if mtype == TMessageType.EXCEPTION:
5256 
      x = TApplicationException()
5257 
      x.read(self._iprot)
5258 
      self._iprot.readMessageEnd()
5259 
      raise x
5386 phani.kuma 5260 
    result = getSettlementForPrepaid_result()
4600 varun.gupt 5261 
    result.read(self._iprot)
5262 
    self._iprot.readMessageEnd()
5263 
    if result.success is not None:
5264 
      return result.success
5265 
    if result.ex is not None:
5266 
      raise result.ex
5386 phani.kuma 5267 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getSettlementForPrepaid failed: unknown result");
4600 varun.gupt 5268 
 
5386 phani.kuma 5269 
  def getSettlementForCod(self, orderId, isRefund):
5270 
    """
5271 
    Parameters:
5272 
     - orderId
5273 
     - isRefund
5274 
    """
5275 
    self.send_getSettlementForCod(orderId, isRefund)
5276 
    return self.recv_getSettlementForCod()
5277 
 
5278 
  def send_getSettlementForCod(self, orderId, isRefund):
5279 
    self._oprot.writeMessageBegin('getSettlementForCod', TMessageType.CALL, self._seqid)
5280 
    args = getSettlementForCod_args()
5281 
    args.orderId = orderId
5282 
    args.isRefund = isRefund
5283 
    args.write(self._oprot)
5284 
    self._oprot.writeMessageEnd()
5285 
    self._oprot.trans.flush()
5286 
 
5287 
  def recv_getSettlementForCod(self, ):
5288 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5289 
    if mtype == TMessageType.EXCEPTION:
5290 
      x = TApplicationException()
5291 
      x.read(self._iprot)
5292 
      self._iprot.readMessageEnd()
5293 
      raise x
5294 
    result = getSettlementForCod_result()
5295 
    result.read(self._iprot)
5296 
    self._iprot.readMessageEnd()
5297 
    if result.success is not None:
5298 
      return result.success
5299 
    if result.ex is not None:
5300 
      raise result.ex
5301 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getSettlementForCod failed: unknown result");
5302 
 
4600 varun.gupt 5303 
  def getEBSSettlementSummaries(self, ):
5304 
    self.send_getEBSSettlementSummaries()
5305 
    return self.recv_getEBSSettlementSummaries()
5306 
 
5307 
  def send_getEBSSettlementSummaries(self, ):
5308 
    self._oprot.writeMessageBegin('getEBSSettlementSummaries', TMessageType.CALL, self._seqid)
5309 
    args = getEBSSettlementSummaries_args()
5310 
    args.write(self._oprot)
5311 
    self._oprot.writeMessageEnd()
5312 
    self._oprot.trans.flush()
5313 
 
5314 
  def recv_getEBSSettlementSummaries(self, ):
5315 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5316 
    if mtype == TMessageType.EXCEPTION:
5317 
      x = TApplicationException()
5318 
      x.read(self._iprot)
5319 
      self._iprot.readMessageEnd()
5320 
      raise x
5321 
    result = getEBSSettlementSummaries_result()
5322 
    result.read(self._iprot)
5323 
    self._iprot.readMessageEnd()
5324 
    if result.success is not None:
5325 
      return result.success
5326 
    if result.ex is not None:
5327 
      raise result.ex
5328 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getEBSSettlementSummaries failed: unknown result");
5329 
 
5330 
  def markEBSSettlementUploaded(self, settlementId):
5331 
    """
5332 
    Parameters:
5333 
     - settlementId
5334 
    """
5335 
    self.send_markEBSSettlementUploaded(settlementId)
5336 
    self.recv_markEBSSettlementUploaded()
5337 
 
5338 
  def send_markEBSSettlementUploaded(self, settlementId):
5339 
    self._oprot.writeMessageBegin('markEBSSettlementUploaded', TMessageType.CALL, self._seqid)
5340 
    args = markEBSSettlementUploaded_args()
5341 
    args.settlementId = settlementId
5342 
    args.write(self._oprot)
5343 
    self._oprot.writeMessageEnd()
5344 
    self._oprot.trans.flush()
5345 
 
5346 
  def recv_markEBSSettlementUploaded(self, ):
5347 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5348 
    if mtype == TMessageType.EXCEPTION:
5349 
      x = TApplicationException()
5350 
      x.read(self._iprot)
5351 
      self._iprot.readMessageEnd()
5352 
      raise x
5353 
    result = markEBSSettlementUploaded_result()
5354 
    result.read(self._iprot)
5355 
    self._iprot.readMessageEnd()
5356 
    if result.ex is not None:
5357 
      raise result.ex
5358 
    return
5359 
 
5360 
  def getEBSSettlementDate(self, settlementId):
5361 
    """
5362 
    Parameters:
5363 
     - settlementId
5364 
    """
5365 
    self.send_getEBSSettlementDate(settlementId)
5366 
    return self.recv_getEBSSettlementDate()
5367 
 
5368 
  def send_getEBSSettlementDate(self, settlementId):
5369 
    self._oprot.writeMessageBegin('getEBSSettlementDate', TMessageType.CALL, self._seqid)
5370 
    args = getEBSSettlementDate_args()
5371 
    args.settlementId = settlementId
5372 
    args.write(self._oprot)
5373 
    self._oprot.writeMessageEnd()
5374 
    self._oprot.trans.flush()
5375 
 
5376 
  def recv_getEBSSettlementDate(self, ):
5377 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5378 
    if mtype == TMessageType.EXCEPTION:
5379 
      x = TApplicationException()
5380 
      x.read(self._iprot)
5381 
      self._iprot.readMessageEnd()
5382 
      raise x
5383 
    result = getEBSSettlementDate_result()
5384 
    result.read(self._iprot)
5385 
    self._iprot.readMessageEnd()
5386 
    if result.success is not None:
5387 
      return result.success
5388 
    if result.ex is not None:
5389 
      raise result.ex
5390 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getEBSSettlementDate failed: unknown result");
5391 
 
4715 varun.gupt 5392 
  def getSettlementsByDate(self, settlementDateFrom, settlementDateTo, isRefund):
5393 
    """
5394 
    Parameters:
5395 
     - settlementDateFrom
5396 
     - settlementDateTo
5397 
     - isRefund
5398 
    """
5399 
    self.send_getSettlementsByDate(settlementDateFrom, settlementDateTo, isRefund)
5400 
    return self.recv_getSettlementsByDate()
4600 varun.gupt 5401 
 
4715 varun.gupt 5402 
  def send_getSettlementsByDate(self, settlementDateFrom, settlementDateTo, isRefund):
5403 
    self._oprot.writeMessageBegin('getSettlementsByDate', TMessageType.CALL, self._seqid)
5404 
    args = getSettlementsByDate_args()
5405 
    args.settlementDateFrom = settlementDateFrom
5406 
    args.settlementDateTo = settlementDateTo
5407 
    args.isRefund = isRefund
5408 
    args.write(self._oprot)
5409 
    self._oprot.writeMessageEnd()
5410 
    self._oprot.trans.flush()
5411 
 
5412 
  def recv_getSettlementsByDate(self, ):
5413 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5414 
    if mtype == TMessageType.EXCEPTION:
5415 
      x = TApplicationException()
5416 
      x.read(self._iprot)
5417 
      self._iprot.readMessageEnd()
5418 
      raise x
5419 
    result = getSettlementsByDate_result()
5420 
    result.read(self._iprot)
5421 
    self._iprot.readMessageEnd()
5422 
    if result.success is not None:
5423 
      return result.success
5424 
    if result.ex is not None:
5425 
      raise result.ex
5426 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getSettlementsByDate failed: unknown result");
5427 
 
5428 
  def getReshippedOrderIds(self, orderIds):
5429 
    """
5430 
    Returns list of Order Ids, which belong to reshiped orders, shortlisted from a given list of Order Ids
5431 
 
5432 
    Parameters:
5433 
     - orderIds
5434 
    """
5435 
    self.send_getReshippedOrderIds(orderIds)
5436 
    return self.recv_getReshippedOrderIds()
5437 
 
5438 
  def send_getReshippedOrderIds(self, orderIds):
5439 
    self._oprot.writeMessageBegin('getReshippedOrderIds', TMessageType.CALL, self._seqid)
5440 
    args = getReshippedOrderIds_args()
5441 
    args.orderIds = orderIds
5442 
    args.write(self._oprot)
5443 
    self._oprot.writeMessageEnd()
5444 
    self._oprot.trans.flush()
5445 
 
5446 
  def recv_getReshippedOrderIds(self, ):
5447 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5448 
    if mtype == TMessageType.EXCEPTION:
5449 
      x = TApplicationException()
5450 
      x.read(self._iprot)
5451 
      self._iprot.readMessageEnd()
5452 
      raise x
5453 
    result = getReshippedOrderIds_result()
5454 
    result.read(self._iprot)
5455 
    self._iprot.readMessageEnd()
5456 
    if result.success is not None:
5457 
      return result.success
5458 
    if result.ex is not None:
5459 
      raise result.ex
5460 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReshippedOrderIds failed: unknown result");
5461 
 
5481 phani.kuma 5462 
  def getBilledOrders(self, vendorId, onlyVendorNotPaid, billingDateFrom, billingDateTo):
4875 varun.gupt 5463 
    """
5464 
    Parameters:
5465 
     - vendorId
5481 phani.kuma 5466 
     - onlyVendorNotPaid
5467 
     - billingDateFrom
5468 
     - billingDateTo
4875 varun.gupt 5469 
    """
5481 phani.kuma 5470 
    self.send_getBilledOrders(vendorId, onlyVendorNotPaid, billingDateFrom, billingDateTo)
5471 
    return self.recv_getBilledOrders()
4757 mandeep.dh 5472 
 
5481 phani.kuma 5473 
  def send_getBilledOrders(self, vendorId, onlyVendorNotPaid, billingDateFrom, billingDateTo):
5474 
    self._oprot.writeMessageBegin('getBilledOrders', TMessageType.CALL, self._seqid)
5475 
    args = getBilledOrders_args()
4875 varun.gupt 5476 
    args.vendorId = vendorId
5481 phani.kuma 5477 
    args.onlyVendorNotPaid = onlyVendorNotPaid
5478 
    args.billingDateFrom = billingDateFrom
5479 
    args.billingDateTo = billingDateTo
4875 varun.gupt 5480 
    args.write(self._oprot)
5481 
    self._oprot.writeMessageEnd()
5482 
    self._oprot.trans.flush()
5483 
 
5481 phani.kuma 5484 
  def recv_getBilledOrders(self, ):
4875 varun.gupt 5485 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5486 
    if mtype == TMessageType.EXCEPTION:
5487 
      x = TApplicationException()
5488 
      x.read(self._iprot)
5489 
      self._iprot.readMessageEnd()
5490 
      raise x
5481 phani.kuma 5491 
    result = getBilledOrders_result()
4875 varun.gupt 5492 
    result.read(self._iprot)
5493 
    self._iprot.readMessageEnd()
5494 
    if result.success is not None:
5495 
      return result.success
5496 
    if result.ex is not None:
5497 
      raise result.ex
5481 phani.kuma 5498 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBilledOrders failed: unknown result");
4875 varun.gupt 5499 
 
5031 varun.gupt 5500 
  def getStatusDistributionOfOrders(self, startDate, endDate):
5501 
    """
5502 
    Parameters:
5503 
     - startDate
5504 
     - endDate
5505 
    """
5506 
    self.send_getStatusDistributionOfOrders(startDate, endDate)
5507 
    return self.recv_getStatusDistributionOfOrders()
4875 varun.gupt 5508 
 
5031 varun.gupt 5509 
  def send_getStatusDistributionOfOrders(self, startDate, endDate):
5510 
    self._oprot.writeMessageBegin('getStatusDistributionOfOrders', TMessageType.CALL, self._seqid)
5511 
    args = getStatusDistributionOfOrders_args()
5512 
    args.startDate = startDate
5513 
    args.endDate = endDate
5514 
    args.write(self._oprot)
5515 
    self._oprot.writeMessageEnd()
5516 
    self._oprot.trans.flush()
5517 
 
5518 
  def recv_getStatusDistributionOfOrders(self, ):
5519 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5520 
    if mtype == TMessageType.EXCEPTION:
5521 
      x = TApplicationException()
5522 
      x.read(self._iprot)
5523 
      self._iprot.readMessageEnd()
5524 
      raise x
5525 
    result = getStatusDistributionOfOrders_result()
5526 
    result.read(self._iprot)
5527 
    self._iprot.readMessageEnd()
5528 
    if result.success is not None:
5529 
      return result.success
5530 
    if result.ex is not None:
5531 
      raise result.ex
5532 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getStatusDistributionOfOrders failed: unknown result");
5533 
 
5067 varun.gupt 5534 
  def getOrderIdsForStatus(self, status, startDatetime, endDatetime):
5535 
    """
5536 
    Parameters:
5537 
     - status
5538 
     - startDatetime
5539 
     - endDatetime
5540 
    """
5541 
    self.send_getOrderIdsForStatus(status, startDatetime, endDatetime)
5542 
    return self.recv_getOrderIdsForStatus()
5031 varun.gupt 5543 
 
5067 varun.gupt 5544 
  def send_getOrderIdsForStatus(self, status, startDatetime, endDatetime):
5545 
    self._oprot.writeMessageBegin('getOrderIdsForStatus', TMessageType.CALL, self._seqid)
5546 
    args = getOrderIdsForStatus_args()
5547 
    args.status = status
5548 
    args.startDatetime = startDatetime
5549 
    args.endDatetime = endDatetime
5550 
    args.write(self._oprot)
5551 
    self._oprot.writeMessageEnd()
5552 
    self._oprot.trans.flush()
5553 
 
5554 
  def recv_getOrderIdsForStatus(self, ):
5555 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5556 
    if mtype == TMessageType.EXCEPTION:
5557 
      x = TApplicationException()
5558 
      x.read(self._iprot)
5559 
      self._iprot.readMessageEnd()
5560 
      raise x
5561 
    result = getOrderIdsForStatus_result()
5562 
    result.read(self._iprot)
5563 
    self._iprot.readMessageEnd()
5564 
    if result.success is not None:
5565 
      return result.success
5566 
    if result.ex is not None:
5567 
      raise result.ex
5568 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderIdsForStatus failed: unknown result");
5569 
 
5348 anupam.sin 5570 
  def updateCODAgent(self, agent, orderId):
5571 
    """
5572 
    Updates the agent who handled the COD verification call
5573 
 
5574 
    Parameters:
5575 
     - agent
5576 
     - orderId
5577 
    """
5578 
    self.send_updateCODAgent(agent, orderId)
5579 
    self.recv_updateCODAgent()
5580 
 
5581 
  def send_updateCODAgent(self, agent, orderId):
5582 
    self._oprot.writeMessageBegin('updateCODAgent', TMessageType.CALL, self._seqid)
5583 
    args = updateCODAgent_args()
5584 
    args.agent = agent
5585 
    args.orderId = orderId
5586 
    args.write(self._oprot)
5587 
    self._oprot.writeMessageEnd()
5588 
    self._oprot.trans.flush()
5589 
 
5590 
  def recv_updateCODAgent(self, ):
5591 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5592 
    if mtype == TMessageType.EXCEPTION:
5593 
      x = TApplicationException()
5594 
      x.read(self._iprot)
5595 
      self._iprot.readMessageEnd()
5596 
      raise x
5597 
    result = updateCODAgent_result()
5598 
    result.read(self._iprot)
5599 
    self._iprot.readMessageEnd()
5600 
    if result.ex is not None:
5601 
      raise result.ex
5602 
    return
5603 
 
5099 varun.gupt 5604 
  def updateOrderAsPaidToVendor(self, orderId):
5605 
    """
5606 
    Parameters:
5607 
     - orderId
5608 
    """
5609 
    self.send_updateOrderAsPaidToVendor(orderId)
5610 
    self.recv_updateOrderAsPaidToVendor()
5067 varun.gupt 5611 
 
5099 varun.gupt 5612 
  def send_updateOrderAsPaidToVendor(self, orderId):
5613 
    self._oprot.writeMessageBegin('updateOrderAsPaidToVendor', TMessageType.CALL, self._seqid)
5614 
    args = updateOrderAsPaidToVendor_args()
5615 
    args.orderId = orderId
5616 
    args.write(self._oprot)
5617 
    self._oprot.writeMessageEnd()
5618 
    self._oprot.trans.flush()
5619 
 
5620 
  def recv_updateOrderAsPaidToVendor(self, ):
5621 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5622 
    if mtype == TMessageType.EXCEPTION:
5623 
      x = TApplicationException()
5624 
      x.read(self._iprot)
5625 
      self._iprot.readMessageEnd()
5626 
      raise x
5627 
    result = updateOrderAsPaidToVendor_result()
5628 
    result.read(self._iprot)
5629 
    self._iprot.readMessageEnd()
5630 
    if result.ex is not None:
5631 
      raise result.ex
5632 
    return
5633 
 
5386 phani.kuma 5634 
  def updateOrderOnlyAsPaidToVendor(self, orderId):
5635 
    """
5636 
    Parameters:
5637 
     - orderId
5638 
    """
5639 
    self.send_updateOrderOnlyAsPaidToVendor(orderId)
5640 
    self.recv_updateOrderOnlyAsPaidToVendor()
5641 
 
5642 
  def send_updateOrderOnlyAsPaidToVendor(self, orderId):
5643 
    self._oprot.writeMessageBegin('updateOrderOnlyAsPaidToVendor', TMessageType.CALL, self._seqid)
5644 
    args = updateOrderOnlyAsPaidToVendor_args()
5645 
    args.orderId = orderId
5646 
    args.write(self._oprot)
5647 
    self._oprot.writeMessageEnd()
5648 
    self._oprot.trans.flush()
5649 
 
5650 
  def recv_updateOrderOnlyAsPaidToVendor(self, ):
5651 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5652 
    if mtype == TMessageType.EXCEPTION:
5653 
      x = TApplicationException()
5654 
      x.read(self._iprot)
5655 
      self._iprot.readMessageEnd()
5656 
      raise x
5657 
    result = updateOrderOnlyAsPaidToVendor_result()
5658 
    result.read(self._iprot)
5659 
    self._iprot.readMessageEnd()
5660 
    if result.ex is not None:
5661 
      raise result.ex
5662 
    return
5663 
 
5208 varun.gupt 5664 
  def getRefundedOrdersMarkedPaid(self, ):
5665 
    self.send_getRefundedOrdersMarkedPaid()
5666 
    return self.recv_getRefundedOrdersMarkedPaid()
5099 varun.gupt 5667 
 
5208 varun.gupt 5668 
  def send_getRefundedOrdersMarkedPaid(self, ):
5669 
    self._oprot.writeMessageBegin('getRefundedOrdersMarkedPaid', TMessageType.CALL, self._seqid)
5670 
    args = getRefundedOrdersMarkedPaid_args()
5671 
    args.write(self._oprot)
5672 
    self._oprot.writeMessageEnd()
5673 
    self._oprot.trans.flush()
5674 
 
5675 
  def recv_getRefundedOrdersMarkedPaid(self, ):
5676 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5677 
    if mtype == TMessageType.EXCEPTION:
5678 
      x = TApplicationException()
5679 
      x.read(self._iprot)
5680 
      self._iprot.readMessageEnd()
5681 
      raise x
5682 
    result = getRefundedOrdersMarkedPaid_result()
5683 
    result.read(self._iprot)
5684 
    self._iprot.readMessageEnd()
5685 
    if result.success is not None:
5686 
      return result.success
5687 
    if result.ex is not None:
5688 
      raise result.ex
5689 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getRefundedOrdersMarkedPaid failed: unknown result");
5690 
 
5447 anupam.sin 5691 
  def getAllVerificationAgents(self, minOrderId, maxOrderId):
5692 
    """
5693 
    gets all COD Verification Agents for all orderIds from a minId to maxId
5208 varun.gupt 5694 
 
5447 anupam.sin 5695 
 
5696 
    Parameters:
5697 
     - minOrderId
5698 
     - maxOrderId
5699 
    """
5700 
    self.send_getAllVerificationAgents(minOrderId, maxOrderId)
5701 
    return self.recv_getAllVerificationAgents()
5702 
 
5703 
  def send_getAllVerificationAgents(self, minOrderId, maxOrderId):
5704 
    self._oprot.writeMessageBegin('getAllVerificationAgents', TMessageType.CALL, self._seqid)
5705 
    args = getAllVerificationAgents_args()
5706 
    args.minOrderId = minOrderId
5707 
    args.maxOrderId = maxOrderId
5708 
    args.write(self._oprot)
5709 
    self._oprot.writeMessageEnd()
5710 
    self._oprot.trans.flush()
5711 
 
5712 
  def recv_getAllVerificationAgents(self, ):
5713 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5714 
    if mtype == TMessageType.EXCEPTION:
5715 
      x = TApplicationException()
5716 
      x.read(self._iprot)
5717 
      self._iprot.readMessageEnd()
5718 
      raise x
5719 
    result = getAllVerificationAgents_result()
5720 
    result.read(self._iprot)
5721 
    self._iprot.readMessageEnd()
5722 
    if result.success is not None:
5723 
      return result.success
5724 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllVerificationAgents failed: unknown result");
5725 
 
5527 anupam.sin 5726 
  def getAllAttributesForOrderId(self, orderId):
5727 
    """
5728 
    gets all attributes for a given orderId
5447 anupam.sin 5729 
 
5527 anupam.sin 5730 
    Parameters:
5731 
     - orderId
5732 
    """
5733 
    self.send_getAllAttributesForOrderId(orderId)
5734 
    return self.recv_getAllAttributesForOrderId()
5735 
 
5736 
  def send_getAllAttributesForOrderId(self, orderId):
5737 
    self._oprot.writeMessageBegin('getAllAttributesForOrderId', TMessageType.CALL, self._seqid)
5738 
    args = getAllAttributesForOrderId_args()
5739 
    args.orderId = orderId
5740 
    args.write(self._oprot)
5741 
    self._oprot.writeMessageEnd()
5742 
    self._oprot.trans.flush()
5743 
 
5744 
  def recv_getAllAttributesForOrderId(self, ):
5745 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5746 
    if mtype == TMessageType.EXCEPTION:
5747 
      x = TApplicationException()
5748 
      x.read(self._iprot)
5749 
      self._iprot.readMessageEnd()
5750 
      raise x
5751 
    result = getAllAttributesForOrderId_result()
5752 
    result.read(self._iprot)
5753 
    self._iprot.readMessageEnd()
5754 
    if result.success is not None:
5755 
      return result.success
5756 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllAttributesForOrderId failed: unknown result");
5757 
 
5676 rajveer 5758 
  def setOrderAttributes(self, orderId, attributes):
5759 
    """
5760 
    sets attributes for an order
5761 
 
5762 
    Parameters:
5763 
     - orderId
5764 
     - attributes
5765 
    """
5766 
    self.send_setOrderAttributes(orderId, attributes)
5767 
    self.recv_setOrderAttributes()
5768 
 
5769 
  def send_setOrderAttributes(self, orderId, attributes):
5770 
    self._oprot.writeMessageBegin('setOrderAttributes', TMessageType.CALL, self._seqid)
5771 
    args = setOrderAttributes_args()
5772 
    args.orderId = orderId
5773 
    args.attributes = attributes
5774 
    args.write(self._oprot)
5775 
    self._oprot.writeMessageEnd()
5776 
    self._oprot.trans.flush()
5777 
 
5778 
  def recv_setOrderAttributes(self, ):
5779 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5780 
    if mtype == TMessageType.EXCEPTION:
5781 
      x = TApplicationException()
5782 
      x.read(self._iprot)
5783 
      self._iprot.readMessageEnd()
5784 
      raise x
5785 
    result = setOrderAttributes_result()
5786 
    result.read(self._iprot)
5787 
    self._iprot.readMessageEnd()
5788 
    return
5789 
 
5527 anupam.sin 5790 
  def setOrderAttributeForTransaction(self, transactionId, attribute):
5791 
    """
5792 
    sets attributes for all orders in a transaction
5793 
 
5794 
    Parameters:
5795 
     - transactionId
5796 
     - attribute
5797 
    """
5798 
    self.send_setOrderAttributeForTransaction(transactionId, attribute)
5799 
    self.recv_setOrderAttributeForTransaction()
5800 
 
5801 
  def send_setOrderAttributeForTransaction(self, transactionId, attribute):
5802 
    self._oprot.writeMessageBegin('setOrderAttributeForTransaction', TMessageType.CALL, self._seqid)
5803 
    args = setOrderAttributeForTransaction_args()
5804 
    args.transactionId = transactionId
5805 
    args.attribute = attribute
5806 
    args.write(self._oprot)
5807 
    self._oprot.writeMessageEnd()
5808 
    self._oprot.trans.flush()
5809 
 
5810 
  def recv_setOrderAttributeForTransaction(self, ):
5811 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5812 
    if mtype == TMessageType.EXCEPTION:
5813 
      x = TApplicationException()
5814 
      x.read(self._iprot)
5815 
      self._iprot.readMessageEnd()
5816 
      raise x
5817 
    result = setOrderAttributeForTransaction_result()
5818 
    result.read(self._iprot)
5819 
    self._iprot.readMessageEnd()
5820 
    return
5821 
 
5553 rajveer 5822 
  def getReceivePendingOrders(self, storeId):
5823 
    """
5824 
    Parameters:
5825 
     - storeId
5826 
    """
5827 
    self.send_getReceivePendingOrders(storeId)
5828 
    return self.recv_getReceivePendingOrders()
5527 anupam.sin 5829 
 
5553 rajveer 5830 
  def send_getReceivePendingOrders(self, storeId):
5831 
    self._oprot.writeMessageBegin('getReceivePendingOrders', TMessageType.CALL, self._seqid)
5832 
    args = getReceivePendingOrders_args()
5833 
    args.storeId = storeId
5834 
    args.write(self._oprot)
5835 
    self._oprot.writeMessageEnd()
5836 
    self._oprot.trans.flush()
5837 
 
5838 
  def recv_getReceivePendingOrders(self, ):
5839 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5840 
    if mtype == TMessageType.EXCEPTION:
5841 
      x = TApplicationException()
5842 
      x.read(self._iprot)
5843 
      self._iprot.readMessageEnd()
5844 
      raise x
5845 
    result = getReceivePendingOrders_result()
5846 
    result.read(self._iprot)
5847 
    self._iprot.readMessageEnd()
5848 
    if result.success is not None:
5849 
      return result.success
5850 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReceivePendingOrders failed: unknown result");
5851 
 
5852 
  def getReceivedAtStoreOrders(self, storeId):
5853 
    """
5854 
    Parameters:
5855 
     - storeId
5856 
    """
5857 
    self.send_getReceivedAtStoreOrders(storeId)
5858 
    return self.recv_getReceivedAtStoreOrders()
5859 
 
5860 
  def send_getReceivedAtStoreOrders(self, storeId):
5861 
    self._oprot.writeMessageBegin('getReceivedAtStoreOrders', TMessageType.CALL, self._seqid)
5862 
    args = getReceivedAtStoreOrders_args()
5863 
    args.storeId = storeId
5864 
    args.write(self._oprot)
5865 
    self._oprot.writeMessageEnd()
5866 
    self._oprot.trans.flush()
5867 
 
5868 
  def recv_getReceivedAtStoreOrders(self, ):
5869 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5870 
    if mtype == TMessageType.EXCEPTION:
5871 
      x = TApplicationException()
5872 
      x.read(self._iprot)
5873 
      self._iprot.readMessageEnd()
5874 
      raise x
5875 
    result = getReceivedAtStoreOrders_result()
5876 
    result.read(self._iprot)
5877 
    self._iprot.readMessageEnd()
5878 
    if result.success is not None:
5879 
      return result.success
5880 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReceivedAtStoreOrders failed: unknown result");
5881 
 
5713 rajveer 5882 
  def getOrdersCollectionAtStore(self, storeId, fromDate, toDate, onlyCod):
5883 
    """
5884 
    Parameters:
5885 
     - storeId
5886 
     - fromDate
5887 
     - toDate
5888 
     - onlyCod
5889 
    """
5890 
    self.send_getOrdersCollectionAtStore(storeId, fromDate, toDate, onlyCod)
5891 
    return self.recv_getOrdersCollectionAtStore()
5892 
 
5893 
  def send_getOrdersCollectionAtStore(self, storeId, fromDate, toDate, onlyCod):
5894 
    self._oprot.writeMessageBegin('getOrdersCollectionAtStore', TMessageType.CALL, self._seqid)
5895 
    args = getOrdersCollectionAtStore_args()
5896 
    args.storeId = storeId
5897 
    args.fromDate = fromDate
5898 
    args.toDate = toDate
5899 
    args.onlyCod = onlyCod
5900 
    args.write(self._oprot)
5901 
    self._oprot.writeMessageEnd()
5902 
    self._oprot.trans.flush()
5903 
 
5904 
  def recv_getOrdersCollectionAtStore(self, ):
5905 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5906 
    if mtype == TMessageType.EXCEPTION:
5907 
      x = TApplicationException()
5908 
      x.read(self._iprot)
5909 
      self._iprot.readMessageEnd()
5910 
      raise x
5911 
    result = getOrdersCollectionAtStore_result()
5912 
    result.read(self._iprot)
5913 
    self._iprot.readMessageEnd()
5914 
    if result.success is not None:
5915 
      return result.success
5916 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersCollectionAtStore failed: unknown result");
5917 
 
5833 rajveer 5918 
  def getOrderAttributeValue(self, orderId, attributeName):
5919 
    """
5920 
    Parameters:
5921 
     - orderId
5922 
     - attributeName
5923 
    """
5924 
    self.send_getOrderAttributeValue(orderId, attributeName)
5925 
    return self.recv_getOrderAttributeValue()
5926 
 
5927 
  def send_getOrderAttributeValue(self, orderId, attributeName):
5928 
    self._oprot.writeMessageBegin('getOrderAttributeValue', TMessageType.CALL, self._seqid)
5929 
    args = getOrderAttributeValue_args()
5930 
    args.orderId = orderId
5931 
    args.attributeName = attributeName
5932 
    args.write(self._oprot)
5933 
    self._oprot.writeMessageEnd()
5934 
    self._oprot.trans.flush()
5935 
 
5936 
  def recv_getOrderAttributeValue(self, ):
5937 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5938 
    if mtype == TMessageType.EXCEPTION:
5939 
      x = TApplicationException()
5940 
      x.read(self._iprot)
5941 
      self._iprot.readMessageEnd()
5942 
      raise x
5943 
    result = getOrderAttributeValue_result()
5944 
    result.read(self._iprot)
5945 
    self._iprot.readMessageEnd()
5946 
    if result.success is not None:
5947 
      return result.success
5948 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderAttributeValue failed: unknown result");
5949 
 
6019 rajveer 5950 
  def changeJacketNumber(self, orderId, jacketNumber):
5951 
    """
5952 
    Parameters:
5953 
     - orderId
5954 
     - jacketNumber
5955 
    """
5956 
    self.send_changeJacketNumber(orderId, jacketNumber)
5957 
    return self.recv_changeJacketNumber()
5958 
 
5959 
  def send_changeJacketNumber(self, orderId, jacketNumber):
5960 
    self._oprot.writeMessageBegin('changeJacketNumber', TMessageType.CALL, self._seqid)
5961 
    args = changeJacketNumber_args()
5962 
    args.orderId = orderId
5963 
    args.jacketNumber = jacketNumber
5964 
    args.write(self._oprot)
5965 
    self._oprot.writeMessageEnd()
5966 
    self._oprot.trans.flush()
5967 
 
5968 
  def recv_changeJacketNumber(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 = changeJacketNumber_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, "changeJacketNumber failed: unknown result");
5981 
 
5982 
  def markOrderAsRtoInTransit(self, orderId):
5983 
    """
5984 
    Parameters:
5985 
     - orderId
5986 
    """
5987 
    self.send_markOrderAsRtoInTransit(orderId)
5988 
    return self.recv_markOrderAsRtoInTransit()
5989 
 
5990 
  def send_markOrderAsRtoInTransit(self, orderId):
5991 
    self._oprot.writeMessageBegin('markOrderAsRtoInTransit', TMessageType.CALL, self._seqid)
5992 
    args = markOrderAsRtoInTransit_args()
5993 
    args.orderId = orderId
5994 
    args.write(self._oprot)
5995 
    self._oprot.writeMessageEnd()
5996 
    self._oprot.trans.flush()
5997 
 
5998 
  def recv_markOrderAsRtoInTransit(self, ):
5999 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6000 
    if mtype == TMessageType.EXCEPTION:
6001 
      x = TApplicationException()
6002 
      x.read(self._iprot)
6003 
      self._iprot.readMessageEnd()
6004 
      raise x
6005 
    result = markOrderAsRtoInTransit_result()
6006 
    result.read(self._iprot)
6007 
    self._iprot.readMessageEnd()
6008 
    if result.success is not None:
6009 
      return result.success
6010 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderAsRtoInTransit failed: unknown result");
6011 
 
5593 mandeep.dh 6012 
  def acceptOrderForItem(self, itemId, quantity, fulfilmentWarehouseId, billingWarehouseId):
6013 
    """
6014 
    Accepts appropriate order for an item in a given billingWarehouse. Usually
6015 
    invoked while scanning IN of items.
5553 rajveer 6016 
 
5593 mandeep.dh 6017 
    Parameters:
6018 
     - itemId
6019 
     - quantity
6020 
     - fulfilmentWarehouseId
6021 
     - billingWarehouseId
6022 
    """
6023 
    self.send_acceptOrderForItem(itemId, quantity, fulfilmentWarehouseId, billingWarehouseId)
6024 
    self.recv_acceptOrderForItem()
6025 
 
6026 
  def send_acceptOrderForItem(self, itemId, quantity, fulfilmentWarehouseId, billingWarehouseId):
6027 
    self._oprot.writeMessageBegin('acceptOrderForItem', TMessageType.CALL, self._seqid)
6028 
    args = acceptOrderForItem_args()
6029 
    args.itemId = itemId
6030 
    args.quantity = quantity
6031 
    args.fulfilmentWarehouseId = fulfilmentWarehouseId
6032 
    args.billingWarehouseId = billingWarehouseId
6033 
    args.write(self._oprot)
6034 
    self._oprot.writeMessageEnd()
6035 
    self._oprot.trans.flush()
6036 
 
6037 
  def recv_acceptOrderForItem(self, ):
6038 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6039 
    if mtype == TMessageType.EXCEPTION:
6040 
      x = TApplicationException()
6041 
      x.read(self._iprot)
6042 
      self._iprot.readMessageEnd()
6043 
      raise x
6044 
    result = acceptOrderForItem_result()
6045 
    result.read(self._iprot)
6046 
    self._iprot.readMessageEnd()
6047 
    return
6048 
 
6000 mandeep.dh 6049 
  def createRechargeOrder(self, rechargeOrder):
6050 
    """
6051 
    Parameters:
6052 
     - rechargeOrder
6053 
    """
6054 
    self.send_createRechargeOrder(rechargeOrder)
6055 
    return self.recv_createRechargeOrder()
5593 mandeep.dh 6056 
 
6000 mandeep.dh 6057 
  def send_createRechargeOrder(self, rechargeOrder):
6058 
    self._oprot.writeMessageBegin('createRechargeOrder', TMessageType.CALL, self._seqid)
6059 
    args = createRechargeOrder_args()
6060 
    args.rechargeOrder = rechargeOrder
6061 
    args.write(self._oprot)
6062 
    self._oprot.writeMessageEnd()
6063 
    self._oprot.trans.flush()
6064 
 
6065 
  def recv_createRechargeOrder(self, ):
6066 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6067 
    if mtype == TMessageType.EXCEPTION:
6068 
      x = TApplicationException()
6069 
      x.read(self._iprot)
6070 
      self._iprot.readMessageEnd()
6071 
      raise x
6072 
    result = createRechargeOrder_result()
6073 
    result.read(self._iprot)
6074 
    self._iprot.readMessageEnd()
6075 
    if result.success is not None:
6076 
      return result.success
6077 
    if result.ex is not None:
6078 
      raise result.ex
6079 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createRechargeOrder failed: unknown result");
6080 
 
6031 rajveer 6081 
  def getRechargeOrder(self, rechargeRrderId):
6082 
    """
6083 
    Parameters:
6084 
     - rechargeRrderId
6085 
    """
6086 
    self.send_getRechargeOrder(rechargeRrderId)
6087 
    return self.recv_getRechargeOrder()
6088 
 
6089 
  def send_getRechargeOrder(self, rechargeRrderId):
6090 
    self._oprot.writeMessageBegin('getRechargeOrder', TMessageType.CALL, self._seqid)
6091 
    args = getRechargeOrder_args()
6092 
    args.rechargeRrderId = rechargeRrderId
6093 
    args.write(self._oprot)
6094 
    self._oprot.writeMessageEnd()
6095 
    self._oprot.trans.flush()
6096 
 
6097 
  def recv_getRechargeOrder(self, ):
6098 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6099 
    if mtype == TMessageType.EXCEPTION:
6100 
      x = TApplicationException()
6101 
      x.read(self._iprot)
6102 
      self._iprot.readMessageEnd()
6103 
      raise x
6104 
    result = getRechargeOrder_result()
6105 
    result.read(self._iprot)
6106 
    self._iprot.readMessageEnd()
6107 
    if result.success is not None:
6108 
      return result.success
6109 
    if result.ex is not None:
6110 
      raise result.ex
6111 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getRechargeOrder failed: unknown result");
6112 
 
6113 
  def getRechargeOrders(self, userId):
6114 
    """
6115 
    Parameters:
6116 
     - userId
6117 
    """
6118 
    self.send_getRechargeOrders(userId)
6119 
    return self.recv_getRechargeOrders()
6120 
 
6121 
  def send_getRechargeOrders(self, userId):
6122 
    self._oprot.writeMessageBegin('getRechargeOrders', TMessageType.CALL, self._seqid)
6123 
    args = getRechargeOrders_args()
6124 
    args.userId = userId
6125 
    args.write(self._oprot)
6126 
    self._oprot.writeMessageEnd()
6127 
    self._oprot.trans.flush()
6128 
 
6129 
  def recv_getRechargeOrders(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 = getRechargeOrders_result()
6137 
    result.read(self._iprot)
6138 
    self._iprot.readMessageEnd()
6139 
    if result.success is not None:
6140 
      return result.success
6141 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getRechargeOrders failed: unknown result");
6142 
 
6000 mandeep.dh 6143 
  def updateRechargeOrderStatus(self, rechargeOrderId, rechargeOrderStatus):
6144 
    """
6145 
    Parameters:
6146 
     - rechargeOrderId
6147 
     - rechargeOrderStatus
6148 
    """
6149 
    self.send_updateRechargeOrderStatus(rechargeOrderId, rechargeOrderStatus)
6031 rajveer 6150 
    return self.recv_updateRechargeOrderStatus()
6000 mandeep.dh 6151 
 
6152 
  def send_updateRechargeOrderStatus(self, rechargeOrderId, rechargeOrderStatus):
6153 
    self._oprot.writeMessageBegin('updateRechargeOrderStatus', TMessageType.CALL, self._seqid)
6154 
    args = updateRechargeOrderStatus_args()
6155 
    args.rechargeOrderId = rechargeOrderId
6156 
    args.rechargeOrderStatus = rechargeOrderStatus
6157 
    args.write(self._oprot)
6158 
    self._oprot.writeMessageEnd()
6159 
    self._oprot.trans.flush()
6160 
 
6161 
  def recv_updateRechargeOrderStatus(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 = updateRechargeOrderStatus_result()
6169 
    result.read(self._iprot)
6170 
    self._iprot.readMessageEnd()
6031 rajveer 6171 
    if result.success is not None:
6172 
      return result.success
6000 mandeep.dh 6173 
    if result.ex is not None:
6174 
      raise result.ex
6031 rajveer 6175 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updateRechargeOrderStatus failed: unknown result");
6000 mandeep.dh 6176 
 
6031 rajveer 6177 
  def activateRechargeTxn(self, rechargeOrderId):
6000 mandeep.dh 6178 
    """
6179 
    Parameters:
6031 rajveer 6180 
     - rechargeOrderId
6000 mandeep.dh 6181 
    """
6031 rajveer 6182 
    self.send_activateRechargeTxn(rechargeOrderId)
6000 mandeep.dh 6183 
    return self.recv_activateRechargeTxn()
6184 
 
6031 rajveer 6185 
  def send_activateRechargeTxn(self, rechargeOrderId):
6000 mandeep.dh 6186 
    self._oprot.writeMessageBegin('activateRechargeTxn', TMessageType.CALL, self._seqid)
6187 
    args = activateRechargeTxn_args()
6031 rajveer 6188 
    args.rechargeOrderId = rechargeOrderId
6000 mandeep.dh 6189 
    args.write(self._oprot)
6190 
    self._oprot.writeMessageEnd()
6191 
    self._oprot.trans.flush()
6192 
 
6193 
  def recv_activateRechargeTxn(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 = activateRechargeTxn_result()
6201 
    result.read(self._iprot)
6202 
    self._iprot.readMessageEnd()
6203 
    if result.success is not None:
6204 
      return result.success
6205 
    if result.ex is not None:
6206 
      raise result.ex
6207 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "activateRechargeTxn failed: unknown result");
6208 
 
6031 rajveer 6209 
  def getUserWallet(self, userId):
6000 mandeep.dh 6210 
    """
6211 
    Parameters:
6031 rajveer 6212 
     - userId
6000 mandeep.dh 6213 
    """
6031 rajveer 6214 
    self.send_getUserWallet(userId)
6215 
    return self.recv_getUserWallet()
6000 mandeep.dh 6216 
 
6031 rajveer 6217 
  def send_getUserWallet(self, userId):
6218 
    self._oprot.writeMessageBegin('getUserWallet', TMessageType.CALL, self._seqid)
6219 
    args = getUserWallet_args()
6220 
    args.userId = userId
6000 mandeep.dh 6221 
    args.write(self._oprot)
6222 
    self._oprot.writeMessageEnd()
6223 
    self._oprot.trans.flush()
6224 
 
6031 rajveer 6225 
  def recv_getUserWallet(self, ):
6000 mandeep.dh 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
6031 rajveer 6232 
    result = getUserWallet_result()
6000 mandeep.dh 6233 
    result.read(self._iprot)
6234 
    self._iprot.readMessageEnd()
6235 
    if result.success is not None:
6236 
      return result.success
6031 rajveer 6237 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUserWallet failed: unknown result");
6000 mandeep.dh 6238 
 
6031 rajveer 6239 
  def getUserWalletHistory(self, userId):
6000 mandeep.dh 6240 
    """
6241 
    Parameters:
6031 rajveer 6242 
     - userId
6000 mandeep.dh 6243 
    """
6031 rajveer 6244 
    self.send_getUserWalletHistory(userId)
6245 
    return self.recv_getUserWalletHistory()
6000 mandeep.dh 6246 
 
6031 rajveer 6247 
  def send_getUserWalletHistory(self, userId):
6248 
    self._oprot.writeMessageBegin('getUserWalletHistory', TMessageType.CALL, self._seqid)
6249 
    args = getUserWalletHistory_args()
6250 
    args.userId = userId
6000 mandeep.dh 6251 
    args.write(self._oprot)
6252 
    self._oprot.writeMessageEnd()
6253 
    self._oprot.trans.flush()
6254 
 
6031 rajveer 6255 
  def recv_getUserWalletHistory(self, ):
6000 mandeep.dh 6256 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6257 
    if mtype == TMessageType.EXCEPTION:
6258 
      x = TApplicationException()
6259 
      x.read(self._iprot)
6260 
      self._iprot.readMessageEnd()
6261 
      raise x
6031 rajveer 6262 
    result = getUserWalletHistory_result()
6000 mandeep.dh 6263 
    result.read(self._iprot)
6264 
    self._iprot.readMessageEnd()
6265 
    if result.success is not None:
6266 
      return result.success
6031 rajveer 6267 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUserWalletHistory failed: unknown result");
6000 mandeep.dh 6268 
 
6050 anupam.sin 6269 
  def getRechargeOrdersForTransaction(self, txnId):
6270 
    """
6271 
    Returns a recharge order for a given transactionId
6272 
 
6273 
    Parameters:
6274 
     - txnId
6275 
    """
6276 
    self.send_getRechargeOrdersForTransaction(txnId)
6277 
    return self.recv_getRechargeOrdersForTransaction()
6278 
 
6279 
  def send_getRechargeOrdersForTransaction(self, txnId):
6280 
    self._oprot.writeMessageBegin('getRechargeOrdersForTransaction', TMessageType.CALL, self._seqid)
6281 
    args = getRechargeOrdersForTransaction_args()
6282 
    args.txnId = txnId
6283 
    args.write(self._oprot)
6284 
    self._oprot.writeMessageEnd()
6285 
    self._oprot.trans.flush()
6286 
 
6287 
  def recv_getRechargeOrdersForTransaction(self, ):
6288 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6289 
    if mtype == TMessageType.EXCEPTION:
6290 
      x = TApplicationException()
6291 
      x.read(self._iprot)
6292 
      self._iprot.readMessageEnd()
6293 
      raise x
6294 
    result = getRechargeOrdersForTransaction_result()
6295 
    result.read(self._iprot)
6296 
    self._iprot.readMessageEnd()
6297 
    if result.success is not None:
6298 
      return result.success
6299 
    if result.ex is not None:
6300 
      raise result.ex
6301 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getRechargeOrdersForTransaction failed: unknown result");
6302 
 
6206 rajveer 6303 
  def getServiceProviders(self, rechargeType, onlyActive):
6048 rajveer 6304 
    """
6305 
    Parameters:
6306 
     - rechargeType
6206 rajveer 6307 
     - onlyActive
6048 rajveer 6308 
    """
6206 rajveer 6309 
    self.send_getServiceProviders(rechargeType, onlyActive)
6048 rajveer 6310 
    return self.recv_getServiceProviders()
6000 mandeep.dh 6311 
 
6206 rajveer 6312 
  def send_getServiceProviders(self, rechargeType, onlyActive):
6048 rajveer 6313 
    self._oprot.writeMessageBegin('getServiceProviders', TMessageType.CALL, self._seqid)
6314 
    args = getServiceProviders_args()
6315 
    args.rechargeType = rechargeType
6206 rajveer 6316 
    args.onlyActive = onlyActive
6048 rajveer 6317 
    args.write(self._oprot)
6318 
    self._oprot.writeMessageEnd()
6319 
    self._oprot.trans.flush()
6320 
 
6321 
  def recv_getServiceProviders(self, ):
6322 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6323 
    if mtype == TMessageType.EXCEPTION:
6324 
      x = TApplicationException()
6325 
      x.read(self._iprot)
6326 
      self._iprot.readMessageEnd()
6327 
      raise x
6328 
    result = getServiceProviders_result()
6329 
    result.read(self._iprot)
6330 
    self._iprot.readMessageEnd()
6331 
    if result.success is not None:
6332 
      return result.success
6333 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getServiceProviders failed: unknown result");
6334 
 
6049 rajveer 6335 
  def getServiceProviderForDevice(self, rechargeType, deviceNumber):
6048 rajveer 6336 
    """
6337 
    Parameters:
6049 rajveer 6338 
     - rechargeType
6048 rajveer 6339 
     - deviceNumber
6340 
    """
6049 rajveer 6341 
    self.send_getServiceProviderForDevice(rechargeType, deviceNumber)
6048 rajveer 6342 
    return self.recv_getServiceProviderForDevice()
6343 
 
6049 rajveer 6344 
  def send_getServiceProviderForDevice(self, rechargeType, deviceNumber):
6048 rajveer 6345 
    self._oprot.writeMessageBegin('getServiceProviderForDevice', TMessageType.CALL, self._seqid)
6346 
    args = getServiceProviderForDevice_args()
6049 rajveer 6347 
    args.rechargeType = rechargeType
6048 rajveer 6348 
    args.deviceNumber = deviceNumber
6349 
    args.write(self._oprot)
6350 
    self._oprot.writeMessageEnd()
6351 
    self._oprot.trans.flush()
6352 
 
6353 
  def recv_getServiceProviderForDevice(self, ):
6354 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6355 
    if mtype == TMessageType.EXCEPTION:
6356 
      x = TApplicationException()
6357 
      x.read(self._iprot)
6358 
      self._iprot.readMessageEnd()
6359 
      raise x
6360 
    result = getServiceProviderForDevice_result()
6361 
    result.read(self._iprot)
6362 
    self._iprot.readMessageEnd()
6363 
    if result.success is not None:
6364 
      return result.success
6365 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getServiceProviderForDevice failed: unknown result");
6366 
 
6591 anupam.sin 6367 
  def validateRecharge(self, rechargeType, deviceNumber, userSelectedProviderId, clientAddress):
6269 rajveer 6368 
    """
6369 
    Parameters:
6370 
     - rechargeType
6371 
     - deviceNumber
6307 anupam.sin 6372 
     - userSelectedProviderId
6591 anupam.sin 6373 
     - clientAddress
6269 rajveer 6374 
    """
6591 anupam.sin 6375 
    self.send_validateRecharge(rechargeType, deviceNumber, userSelectedProviderId, clientAddress)
6269 rajveer 6376 
    return self.recv_validateRecharge()
6377 
 
6591 anupam.sin 6378 
  def send_validateRecharge(self, rechargeType, deviceNumber, userSelectedProviderId, clientAddress):
6269 rajveer 6379 
    self._oprot.writeMessageBegin('validateRecharge', TMessageType.CALL, self._seqid)
6380 
    args = validateRecharge_args()
6381 
    args.rechargeType = rechargeType
6382 
    args.deviceNumber = deviceNumber
6307 anupam.sin 6383 
    args.userSelectedProviderId = userSelectedProviderId
6591 anupam.sin 6384 
    args.clientAddress = clientAddress
6269 rajveer 6385 
    args.write(self._oprot)
6386 
    self._oprot.writeMessageEnd()
6387 
    self._oprot.trans.flush()
6388 
 
6389 
  def recv_validateRecharge(self, ):
6390 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6391 
    if mtype == TMessageType.EXCEPTION:
6392 
      x = TApplicationException()
6393 
      x.read(self._iprot)
6394 
      self._iprot.readMessageEnd()
6395 
      raise x
6396 
    result = validateRecharge_result()
6397 
    result.read(self._iprot)
6398 
    self._iprot.readMessageEnd()
6399 
    if result.success is not None:
6400 
      return result.success
6401 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "validateRecharge failed: unknown result");
6402 
 
6094 rajveer 6403 
  def getRechargeOrdersForDevice(self, deviceNumber):
6404 
    """
6405 
    Parameters:
6406 
     - deviceNumber
6407 
    """
6408 
    self.send_getRechargeOrdersForDevice(deviceNumber)
6409 
    return self.recv_getRechargeOrdersForDevice()
6048 rajveer 6410 
 
6094 rajveer 6411 
  def send_getRechargeOrdersForDevice(self, deviceNumber):
6412 
    self._oprot.writeMessageBegin('getRechargeOrdersForDevice', TMessageType.CALL, self._seqid)
6413 
    args = getRechargeOrdersForDevice_args()
6414 
    args.deviceNumber = deviceNumber
6415 
    args.write(self._oprot)
6416 
    self._oprot.writeMessageEnd()
6417 
    self._oprot.trans.flush()
6418 
 
6419 
  def recv_getRechargeOrdersForDevice(self, ):
6420 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6421 
    if mtype == TMessageType.EXCEPTION:
6422 
      x = TApplicationException()
6423 
      x.read(self._iprot)
6424 
      self._iprot.readMessageEnd()
6425 
      raise x
6426 
    result = getRechargeOrdersForDevice_result()
6427 
    result.read(self._iprot)
6428 
    self._iprot.readMessageEnd()
6429 
    if result.success is not None:
6430 
      return result.success
6431 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getRechargeOrdersForDevice failed: unknown result");
6432 
 
6433 
  def addAmountToWallet(self, userId, orderId, amount):
6434 
    """
6435 
    Parameters:
6436 
     - userId
6437 
     - orderId
6438 
     - amount
6439 
    """
6440 
    self.send_addAmountToWallet(userId, orderId, amount)
6441 
    self.recv_addAmountToWallet()
6442 
 
6443 
  def send_addAmountToWallet(self, userId, orderId, amount):
6444 
    self._oprot.writeMessageBegin('addAmountToWallet', TMessageType.CALL, self._seqid)
6445 
    args = addAmountToWallet_args()
6446 
    args.userId = userId
6447 
    args.orderId = orderId
6448 
    args.amount = amount
6449 
    args.write(self._oprot)
6450 
    self._oprot.writeMessageEnd()
6451 
    self._oprot.trans.flush()
6452 
 
6453 
  def recv_addAmountToWallet(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 = addAmountToWallet_result()
6461 
    result.read(self._iprot)
6462 
    self._iprot.readMessageEnd()
6463 
    return
6464 
 
6188 rajveer 6465 
  def getRechargeStatistics(self, ):
6466 
    self.send_getRechargeStatistics()
6467 
    return self.recv_getRechargeStatistics()
6468 
 
6469 
  def send_getRechargeStatistics(self, ):
6470 
    self._oprot.writeMessageBegin('getRechargeStatistics', TMessageType.CALL, self._seqid)
6471 
    args = getRechargeStatistics_args()
6472 
    args.write(self._oprot)
6473 
    self._oprot.writeMessageEnd()
6474 
    self._oprot.trans.flush()
6475 
 
6476 
  def recv_getRechargeStatistics(self, ):
6477 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6478 
    if mtype == TMessageType.EXCEPTION:
6479 
      x = TApplicationException()
6480 
      x.read(self._iprot)
6481 
      self._iprot.readMessageEnd()
6482 
      raise x
6483 
    result = getRechargeStatistics_result()
6484 
    result.read(self._iprot)
6485 
    self._iprot.readMessageEnd()
6486 
    if result.success is not None:
6487 
      return result.success
6488 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getRechargeStatistics failed: unknown result");
6489 
 
6154 rajveer 6490 
  def getRechargeOrdersForStatus(self, status):
6491 
    """
6492 
    Parameters:
6493 
     - status
6494 
    """
6495 
    self.send_getRechargeOrdersForStatus(status)
6496 
    return self.recv_getRechargeOrdersForStatus()
6094 rajveer 6497 
 
6154 rajveer 6498 
  def send_getRechargeOrdersForStatus(self, status):
6499 
    self._oprot.writeMessageBegin('getRechargeOrdersForStatus', TMessageType.CALL, self._seqid)
6500 
    args = getRechargeOrdersForStatus_args()
6501 
    args.status = status
6502 
    args.write(self._oprot)
6503 
    self._oprot.writeMessageEnd()
6504 
    self._oprot.trans.flush()
6505 
 
6506 
  def recv_getRechargeOrdersForStatus(self, ):
6507 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6508 
    if mtype == TMessageType.EXCEPTION:
6509 
      x = TApplicationException()
6510 
      x.read(self._iprot)
6511 
      self._iprot.readMessageEnd()
6512 
      raise x
6513 
    result = getRechargeOrdersForStatus_result()
6514 
    result.read(self._iprot)
6515 
    self._iprot.readMessageEnd()
6516 
    if result.success is not None:
6517 
      return result.success
6518 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getRechargeOrdersForStatus failed: unknown result");
6519 
 
6159 rajveer 6520 
  def getPlansForOperator(self, operatorId):
6521 
    """
6522 
    Parameters:
6523 
     - operatorId
6524 
    """
6525 
    self.send_getPlansForOperator(operatorId)
6526 
    return self.recv_getPlansForOperator()
6154 rajveer 6527 
 
6159 rajveer 6528 
  def send_getPlansForOperator(self, operatorId):
6529 
    self._oprot.writeMessageBegin('getPlansForOperator', TMessageType.CALL, self._seqid)
6530 
    args = getPlansForOperator_args()
6531 
    args.operatorId = operatorId
6532 
    args.write(self._oprot)
6533 
    self._oprot.writeMessageEnd()
6534 
    self._oprot.trans.flush()
6535 
 
6536 
  def recv_getPlansForOperator(self, ):
6537 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6538 
    if mtype == TMessageType.EXCEPTION:
6539 
      x = TApplicationException()
6540 
      x.read(self._iprot)
6541 
      self._iprot.readMessageEnd()
6542 
      raise x
6543 
    result = getPlansForOperator_result()
6544 
    result.read(self._iprot)
6545 
    self._iprot.readMessageEnd()
6546 
    if result.success is not None:
6547 
      return result.success
6548 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getPlansForOperator failed: unknown result");
6549 
 
6307 anupam.sin 6550 
  def getRechargeDenominations(self, operatorId, circleCode, denominationType):
6289 anupam.sin 6551 
    """
6552 
    Returns denominations for a given operator and circle
6159 rajveer 6553 
 
6289 anupam.sin 6554 
    Parameters:
6555 
     - operatorId
6307 anupam.sin 6556 
     - circleCode
6289 anupam.sin 6557 
     - denominationType
6558 
    """
6307 anupam.sin 6559 
    self.send_getRechargeDenominations(operatorId, circleCode, denominationType)
6289 anupam.sin 6560 
    return self.recv_getRechargeDenominations()
6561 
 
6307 anupam.sin 6562 
  def send_getRechargeDenominations(self, operatorId, circleCode, denominationType):
6289 anupam.sin 6563 
    self._oprot.writeMessageBegin('getRechargeDenominations', TMessageType.CALL, self._seqid)
6564 
    args = getRechargeDenominations_args()
6565 
    args.operatorId = operatorId
6307 anupam.sin 6566 
    args.circleCode = circleCode
6289 anupam.sin 6567 
    args.denominationType = denominationType
6568 
    args.write(self._oprot)
6569 
    self._oprot.writeMessageEnd()
6570 
    self._oprot.trans.flush()
6571 
 
6572 
  def recv_getRechargeDenominations(self, ):
6573 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6574 
    if mtype == TMessageType.EXCEPTION:
6575 
      x = TApplicationException()
6576 
      x.read(self._iprot)
6577 
      self._iprot.readMessageEnd()
6578 
      raise x
6579 
    result = getRechargeDenominations_result()
6580 
    result.read(self._iprot)
6581 
    self._iprot.readMessageEnd()
6582 
    if result.success is not None:
6583 
      return result.success
6584 
    if result.ex is not None:
6585 
      raise result.ex
6586 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getRechargeDenominations failed: unknown result");
6587 
 
6371 rajveer 6588 
  def updateAvailabilityStatus(self, operatorId, circleId, isAvailable):
6589 
    """
6590 
    Parameters:
6591 
     - operatorId
6592 
     - circleId
6593 
     - isAvailable
6594 
    """
6595 
    self.send_updateAvailabilityStatus(operatorId, circleId, isAvailable)
6596 
    self.recv_updateAvailabilityStatus()
6289 anupam.sin 6597 
 
6371 rajveer 6598 
  def send_updateAvailabilityStatus(self, operatorId, circleId, isAvailable):
6599 
    self._oprot.writeMessageBegin('updateAvailabilityStatus', TMessageType.CALL, self._seqid)
6600 
    args = updateAvailabilityStatus_args()
6601 
    args.operatorId = operatorId
6602 
    args.circleId = circleId
6603 
    args.isAvailable = isAvailable
6604 
    args.write(self._oprot)
6605 
    self._oprot.writeMessageEnd()
6606 
    self._oprot.trans.flush()
6607 
 
6608 
  def recv_updateAvailabilityStatus(self, ):
6609 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6610 
    if mtype == TMessageType.EXCEPTION:
6611 
      x = TApplicationException()
6612 
      x.read(self._iprot)
6613 
      self._iprot.readMessageEnd()
6614 
      raise x
6615 
    result = updateAvailabilityStatus_result()
6616 
    result.read(self._iprot)
6617 
    self._iprot.readMessageEnd()
6618 
    return
6619 
 
6389 rajveer 6620 
  def getAvailableEmiSchemes(self, ):
6621 
    self.send_getAvailableEmiSchemes()
6622 
    return self.recv_getAvailableEmiSchemes()
6371 rajveer 6623 
 
6389 rajveer 6624 
  def send_getAvailableEmiSchemes(self, ):
6625 
    self._oprot.writeMessageBegin('getAvailableEmiSchemes', TMessageType.CALL, self._seqid)
6626 
    args = getAvailableEmiSchemes_args()
6627 
    args.write(self._oprot)
6628 
    self._oprot.writeMessageEnd()
6629 
    self._oprot.trans.flush()
6630 
 
6631 
  def recv_getAvailableEmiSchemes(self, ):
6632 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6633 
    if mtype == TMessageType.EXCEPTION:
6634 
      x = TApplicationException()
6635 
      x.read(self._iprot)
6636 
      self._iprot.readMessageEnd()
6637 
      raise x
6638 
    result = getAvailableEmiSchemes_result()
6639 
    result.read(self._iprot)
6640 
    self._iprot.readMessageEnd()
6641 
    if result.success is not None:
6642 
      return result.success
6643 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAvailableEmiSchemes failed: unknown result");
6644 
 
6645 
  def getMiscCharges(self, transactionId):
6646 
    """
6647 
    Parameters:
6648 
     - transactionId
6649 
    """
6650 
    self.send_getMiscCharges(transactionId)
6651 
    return self.recv_getMiscCharges()
6652 
 
6653 
  def send_getMiscCharges(self, transactionId):
6654 
    self._oprot.writeMessageBegin('getMiscCharges', TMessageType.CALL, self._seqid)
6655 
    args = getMiscCharges_args()
6656 
    args.transactionId = transactionId
6657 
    args.write(self._oprot)
6658 
    self._oprot.writeMessageEnd()
6659 
    self._oprot.trans.flush()
6660 
 
6661 
  def recv_getMiscCharges(self, ):
6662 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6663 
    if mtype == TMessageType.EXCEPTION:
6664 
      x = TApplicationException()
6665 
      x.read(self._iprot)
6666 
      self._iprot.readMessageEnd()
6667 
      raise x
6668 
    result = getMiscCharges_result()
6669 
    result.read(self._iprot)
6670 
    self._iprot.readMessageEnd()
6671 
    if result.success is not None:
6672 
      return result.success
6673 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getMiscCharges failed: unknown result");
6674 
 
6507 anupam.sin 6675 
  def refundRechargeOrder(self, rechargeOrderId):
6676 
    """
6677 
    Parameters:
6678 
     - rechargeOrderId
6679 
    """
6680 
    self.send_refundRechargeOrder(rechargeOrderId)
6681 
    return self.recv_refundRechargeOrder()
6389 rajveer 6682 
 
6507 anupam.sin 6683 
  def send_refundRechargeOrder(self, rechargeOrderId):
6684 
    self._oprot.writeMessageBegin('refundRechargeOrder', TMessageType.CALL, self._seqid)
6685 
    args = refundRechargeOrder_args()
6686 
    args.rechargeOrderId = rechargeOrderId
6687 
    args.write(self._oprot)
6688 
    self._oprot.writeMessageEnd()
6689 
    self._oprot.trans.flush()
6690 
 
6691 
  def recv_refundRechargeOrder(self, ):
6692 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6693 
    if mtype == TMessageType.EXCEPTION:
6694 
      x = TApplicationException()
6695 
      x.read(self._iprot)
6696 
      self._iprot.readMessageEnd()
6697 
      raise x
6698 
    result = refundRechargeOrder_result()
6699 
    result.read(self._iprot)
6700 
    self._iprot.readMessageEnd()
6701 
    if result.success is not None:
6702 
      return result.success
6703 
    if result.ex is not None:
6704 
      raise result.ex
6705 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "refundRechargeOrder failed: unknown result");
6706 
 
6821 amar.kumar 6707 
  def getPhysicalOrders(self, fromDate, toDate):
6708 
    """
6709 
    Parameters:
6710 
     - fromDate
6711 
     - toDate
6712 
    """
6713 
    self.send_getPhysicalOrders(fromDate, toDate)
6714 
    return self.recv_getPhysicalOrders()
6507 anupam.sin 6715 
 
6821 amar.kumar 6716 
  def send_getPhysicalOrders(self, fromDate, toDate):
6717 
    self._oprot.writeMessageBegin('getPhysicalOrders', TMessageType.CALL, self._seqid)
6718 
    args = getPhysicalOrders_args()
6719 
    args.fromDate = fromDate
6720 
    args.toDate = toDate
6721 
    args.write(self._oprot)
6722 
    self._oprot.writeMessageEnd()
6723 
    self._oprot.trans.flush()
6724 
 
6725 
  def recv_getPhysicalOrders(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 = getPhysicalOrders_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, "getPhysicalOrders failed: unknown result");
6738 
 
6906 rajveer 6739 
  def getDocument(self, docType, docSource):
6740 
    """
6741 
    Parameters:
6742 
     - docType
6743 
     - docSource
6744 
    """
6745 
    self.send_getDocument(docType, docSource)
6746 
    return self.recv_getDocument()
6821 amar.kumar 6747 
 
6906 rajveer 6748 
  def send_getDocument(self, docType, docSource):
6749 
    self._oprot.writeMessageBegin('getDocument', TMessageType.CALL, self._seqid)
6750 
    args = getDocument_args()
6751 
    args.docType = docType
6752 
    args.docSource = docSource
6753 
    args.write(self._oprot)
6754 
    self._oprot.writeMessageEnd()
6755 
    self._oprot.trans.flush()
6756 
 
6757 
  def recv_getDocument(self, ):
6758 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6759 
    if mtype == TMessageType.EXCEPTION:
6760 
      x = TApplicationException()
6761 
      x.read(self._iprot)
6762 
      self._iprot.readMessageEnd()
6763 
      raise x
6764 
    result = getDocument_result()
6765 
    result.read(self._iprot)
6766 
    self._iprot.readMessageEnd()
6767 
    if result.success is not None:
6768 
      return result.success
6769 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getDocument failed: unknown result");
6770 
 
6985 anupam.sin 6771 
  def changeShippingAddress(self, orderId, line1, line2, city, state, pin):
6772 
    """
6773 
    Parameters:
6774 
     - orderId
6775 
     - line1
6776 
     - line2
6777 
     - city
6778 
     - state
6779 
     - pin
6780 
    """
6781 
    self.send_changeShippingAddress(orderId, line1, line2, city, state, pin)
6782 
    return self.recv_changeShippingAddress()
6906 rajveer 6783 
 
6985 anupam.sin 6784 
  def send_changeShippingAddress(self, orderId, line1, line2, city, state, pin):
6785 
    self._oprot.writeMessageBegin('changeShippingAddress', TMessageType.CALL, self._seqid)
6786 
    args = changeShippingAddress_args()
6787 
    args.orderId = orderId
6788 
    args.line1 = line1
6789 
    args.line2 = line2
6790 
    args.city = city
6791 
    args.state = state
6792 
    args.pin = pin
6793 
    args.write(self._oprot)
6794 
    self._oprot.writeMessageEnd()
6795 
    self._oprot.trans.flush()
6796 
 
6797 
  def recv_changeShippingAddress(self, ):
6798 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6799 
    if mtype == TMessageType.EXCEPTION:
6800 
      x = TApplicationException()
6801 
      x.read(self._iprot)
6802 
      self._iprot.readMessageEnd()
6803 
      raise x
6804 
    result = changeShippingAddress_result()
6805 
    result.read(self._iprot)
6806 
    self._iprot.readMessageEnd()
6807 
    if result.success is not None:
6808 
      return result.success
6809 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "changeShippingAddress failed: unknown result");
6810 
 
7075 rajveer 6811 
  def retrieveInvoice(self, orderId, userId):
6988 rajveer 6812 
    """
6813 
    Parameters:
6814 
     - orderId
7075 rajveer 6815 
     - userId
6988 rajveer 6816 
    """
7075 rajveer 6817 
    self.send_retrieveInvoice(orderId, userId)
6988 rajveer 6818 
    return self.recv_retrieveInvoice()
6985 anupam.sin 6819 
 
7075 rajveer 6820 
  def send_retrieveInvoice(self, orderId, userId):
6988 rajveer 6821 
    self._oprot.writeMessageBegin('retrieveInvoice', TMessageType.CALL, self._seqid)
6822 
    args = retrieveInvoice_args()
6823 
    args.orderId = orderId
7075 rajveer 6824 
    args.userId = userId
6988 rajveer 6825 
    args.write(self._oprot)
6826 
    self._oprot.writeMessageEnd()
6827 
    self._oprot.trans.flush()
6828 
 
6829 
  def recv_retrieveInvoice(self, ):
6830 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6831 
    if mtype == TMessageType.EXCEPTION:
6832 
      x = TApplicationException()
6833 
      x.read(self._iprot)
6834 
      self._iprot.readMessageEnd()
6835 
      raise x
6836 
    result = retrieveInvoice_result()
6837 
    result.read(self._iprot)
6838 
    self._iprot.readMessageEnd()
6839 
    if result.success is not None:
6840 
      return result.success
6841 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "retrieveInvoice failed: unknown result");
6842 
 
7026 rajveer 6843 
  def receiveUpdatesForRedExpress(self, awbNumber):
6844 
    """
6845 
    Parameters:
6846 
     - awbNumber
6847 
    """
6848 
    self.send_receiveUpdatesForRedExpress(awbNumber)
6849 
    return self.recv_receiveUpdatesForRedExpress()
6988 rajveer 6850 
 
7026 rajveer 6851 
  def send_receiveUpdatesForRedExpress(self, awbNumber):
6852 
    self._oprot.writeMessageBegin('receiveUpdatesForRedExpress', TMessageType.CALL, self._seqid)
6853 
    args = receiveUpdatesForRedExpress_args()
6854 
    args.awbNumber = awbNumber
6855 
    args.write(self._oprot)
6856 
    self._oprot.writeMessageEnd()
6857 
    self._oprot.trans.flush()
6858 
 
6859 
  def recv_receiveUpdatesForRedExpress(self, ):
6860 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6861 
    if mtype == TMessageType.EXCEPTION:
6862 
      x = TApplicationException()
6863 
      x.read(self._iprot)
6864 
      self._iprot.readMessageEnd()
6865 
      raise x
6866 
    result = receiveUpdatesForRedExpress_result()
6867 
    result.read(self._iprot)
6868 
    self._iprot.readMessageEnd()
6869 
    if result.success is not None:
6870 
      return result.success
6871 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "receiveUpdatesForRedExpress failed: unknown result");
6872 
 
7073 anupam.sin 6873 
  def createRechargeTransaction(self, thriftRechargeTransaction):
6874 
    """
6875 
    Parameters:
6876 
     - thriftRechargeTransaction
6877 
    """
6878 
    self.send_createRechargeTransaction(thriftRechargeTransaction)
6879 
    return self.recv_createRechargeTransaction()
7026 rajveer 6880 
 
7073 anupam.sin 6881 
  def send_createRechargeTransaction(self, thriftRechargeTransaction):
6882 
    self._oprot.writeMessageBegin('createRechargeTransaction', TMessageType.CALL, self._seqid)
6883 
    args = createRechargeTransaction_args()
6884 
    args.thriftRechargeTransaction = thriftRechargeTransaction
6885 
    args.write(self._oprot)
6886 
    self._oprot.writeMessageEnd()
6887 
    self._oprot.trans.flush()
6888 
 
6889 
  def recv_createRechargeTransaction(self, ):
6890 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6891 
    if mtype == TMessageType.EXCEPTION:
6892 
      x = TApplicationException()
6893 
      x.read(self._iprot)
6894 
      self._iprot.readMessageEnd()
6895 
      raise x
6896 
    result = createRechargeTransaction_result()
6897 
    result.read(self._iprot)
6898 
    self._iprot.readMessageEnd()
6899 
    if result.success is not None:
6900 
      return result.success
6901 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createRechargeTransaction failed: unknown result");
6902 
 
7085 rajveer 6903 
  def getRechargeTransactions(self, storeId):
6904 
    """
6905 
    Parameters:
6906 
     - storeId
6907 
    """
6908 
    self.send_getRechargeTransactions(storeId)
6909 
    return self.recv_getRechargeTransactions()
6910 
 
6911 
  def send_getRechargeTransactions(self, storeId):
6912 
    self._oprot.writeMessageBegin('getRechargeTransactions', TMessageType.CALL, self._seqid)
6913 
    args = getRechargeTransactions_args()
6914 
    args.storeId = storeId
6915 
    args.write(self._oprot)
6916 
    self._oprot.writeMessageEnd()
6917 
    self._oprot.trans.flush()
6918 
 
6919 
  def recv_getRechargeTransactions(self, ):
6920 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6921 
    if mtype == TMessageType.EXCEPTION:
6922 
      x = TApplicationException()
6923 
      x.read(self._iprot)
6924 
      self._iprot.readMessageEnd()
6925 
      raise x
6926 
    result = getRechargeTransactions_result()
6927 
    result.read(self._iprot)
6928 
    self._iprot.readMessageEnd()
6929 
    if result.success is not None:
6930 
      return result.success
6931 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getRechargeTransactions failed: unknown result");
6932 
 
7151 amit.gupta 6933 
  def getRechargeTrans(self, storeId, startDate, endDate, status):
6934 
    """
6935 
    Parameters:
6936 
     - storeId
6937 
     - startDate
6938 
     - endDate
6939 
     - status
6940 
    """
6941 
    self.send_getRechargeTrans(storeId, startDate, endDate, status)
6942 
    return self.recv_getRechargeTrans()
6943 
 
6944 
  def send_getRechargeTrans(self, storeId, startDate, endDate, status):
6945 
    self._oprot.writeMessageBegin('getRechargeTrans', TMessageType.CALL, self._seqid)
6946 
    args = getRechargeTrans_args()
6947 
    args.storeId = storeId
6948 
    args.startDate = startDate
6949 
    args.endDate = endDate
6950 
    args.status = status
6951 
    args.write(self._oprot)
6952 
    self._oprot.writeMessageEnd()
6953 
    self._oprot.trans.flush()
6954 
 
6955 
  def recv_getRechargeTrans(self, ):
6956 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6957 
    if mtype == TMessageType.EXCEPTION:
6958 
      x = TApplicationException()
6959 
      x.read(self._iprot)
6960 
      self._iprot.readMessageEnd()
6961 
      raise x
6962 
    result = getRechargeTrans_result()
6963 
    result.read(self._iprot)
6964 
    self._iprot.readMessageEnd()
6965 
    if result.success is not None:
6966 
      return result.success
6967 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getRechargeTrans failed: unknown result");
6968 
 
7080 anupam.sin 6969 
  def getRechargeTransaction(self, rechargeId):
6970 
    """
6971 
    Parameters:
6972 
     - rechargeId
6973 
    """
6974 
    self.send_getRechargeTransaction(rechargeId)
6975 
    return self.recv_getRechargeTransaction()
7073 anupam.sin 6976 
 
7080 anupam.sin 6977 
  def send_getRechargeTransaction(self, rechargeId):
6978 
    self._oprot.writeMessageBegin('getRechargeTransaction', TMessageType.CALL, self._seqid)
6979 
    args = getRechargeTransaction_args()
6980 
    args.rechargeId = rechargeId
6981 
    args.write(self._oprot)
6982 
    self._oprot.writeMessageEnd()
6983 
    self._oprot.trans.flush()
6984 
 
6985 
  def recv_getRechargeTransaction(self, ):
6986 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6987 
    if mtype == TMessageType.EXCEPTION:
6988 
      x = TApplicationException()
6989 
      x.read(self._iprot)
6990 
      self._iprot.readMessageEnd()
6991 
      raise x
6992 
    result = getRechargeTransaction_result()
6993 
    result.read(self._iprot)
6994 
    self._iprot.readMessageEnd()
6995 
    if result.success is not None:
6996 
      return result.success
6997 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getRechargeTransaction failed: unknown result");
6998 
 
6999 
  def getFRCs(self, circleId, operatorId):
7000 
    """
7001 
    Parameters:
7002 
     - circleId
7003 
     - operatorId
7004 
    """
7005 
    self.send_getFRCs(circleId, operatorId)
7006 
    return self.recv_getFRCs()
7007 
 
7008 
  def send_getFRCs(self, circleId, operatorId):
7009 
    self._oprot.writeMessageBegin('getFRCs', TMessageType.CALL, self._seqid)
7010 
    args = getFRCs_args()
7011 
    args.circleId = circleId
7012 
    args.operatorId = operatorId
7013 
    args.write(self._oprot)
7014 
    self._oprot.writeMessageEnd()
7015 
    self._oprot.trans.flush()
7016 
 
7017 
  def recv_getFRCs(self, ):
7018 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
7019 
    if mtype == TMessageType.EXCEPTION:
7020 
      x = TApplicationException()
7021 
      x.read(self._iprot)
7022 
      self._iprot.readMessageEnd()
7023 
      raise x
7024 
    result = getFRCs_result()
7025 
    result.read(self._iprot)
7026 
    self._iprot.readMessageEnd()
7027 
    if result.success is not None:
7028 
      return result.success
7029 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getFRCs failed: unknown result");
7030 
 
7096 anupam.sin 7031 
  def getHotspotStore(self, id, hotspotid):
7032 
    """
7033 
    Parameters:
7034 
     - id
7035 
     - hotspotid
7036 
    """
7037 
    self.send_getHotspotStore(id, hotspotid)
7038 
    return self.recv_getHotspotStore()
7080 anupam.sin 7039 
 
7096 anupam.sin 7040 
  def send_getHotspotStore(self, id, hotspotid):
7041 
    self._oprot.writeMessageBegin('getHotspotStore', TMessageType.CALL, self._seqid)
7042 
    args = getHotspotStore_args()
7043 
    args.id = id
7044 
    args.hotspotid = hotspotid
7045 
    args.write(self._oprot)
7046 
    self._oprot.writeMessageEnd()
7047 
    self._oprot.trans.flush()
7048 
 
7049 
  def recv_getHotspotStore(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 = getHotspotStore_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, "getHotspotStore failed: unknown result");
7062 
 
7063 
  def getTelecomCircle(self, id, code):
7064 
    """
7065 
    Parameters:
7066 
     - id
7067 
     - code
7068 
    """
7069 
    self.send_getTelecomCircle(id, code)
7070 
    return self.recv_getTelecomCircle()
7071 
 
7072 
  def send_getTelecomCircle(self, id, code):
7073 
    self._oprot.writeMessageBegin('getTelecomCircle', TMessageType.CALL, self._seqid)
7074 
    args = getTelecomCircle_args()
7075 
    args.id = id
7076 
    args.code = code
7077 
    args.write(self._oprot)
7078 
    self._oprot.writeMessageEnd()
7079 
    self._oprot.trans.flush()
7080 
 
7081 
  def recv_getTelecomCircle(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 = getTelecomCircle_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, "getTelecomCircle failed: unknown result");
7094 
 
7109 anupam.sin 7095 
  def retrieveHotspotRechargeInvoice(self, rechargeId):
7096 
    """
7097 
    Parameters:
7098 
     - rechargeId
7099 
    """
7100 
    self.send_retrieveHotspotRechargeInvoice(rechargeId)
7101 
    return self.recv_retrieveHotspotRechargeInvoice()
7096 anupam.sin 7102 
 
7109 anupam.sin 7103 
  def send_retrieveHotspotRechargeInvoice(self, rechargeId):
7104 
    self._oprot.writeMessageBegin('retrieveHotspotRechargeInvoice', TMessageType.CALL, self._seqid)
7105 
    args = retrieveHotspotRechargeInvoice_args()
7106 
    args.rechargeId = rechargeId
7107 
    args.write(self._oprot)
7108 
    self._oprot.writeMessageEnd()
7109 
    self._oprot.trans.flush()
7110 
 
7111 
  def recv_retrieveHotspotRechargeInvoice(self, ):
7112 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
7113 
    if mtype == TMessageType.EXCEPTION:
7114 
      x = TApplicationException()
7115 
      x.read(self._iprot)
7116 
      self._iprot.readMessageEnd()
7117 
      raise x
7118 
    result = retrieveHotspotRechargeInvoice_result()
7119 
    result.read(self._iprot)
7120 
    self._iprot.readMessageEnd()
7121 
    if result.success is not None:
7122 
      return result.success
7123 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "retrieveHotspotRechargeInvoice failed: unknown result");
7124 
 
7190 amar.kumar 7125 
  def splitFreebieOrder(self, orderId, splitReason, shippingDate):
7126 
    """
7127 
    Parameters:
7128 
     - orderId
7129 
     - splitReason
7130 
     - shippingDate
7131 
    """
7132 
    self.send_splitFreebieOrder(orderId, splitReason, shippingDate)
7133 
    return self.recv_splitFreebieOrder()
7134 
 
7135 
  def send_splitFreebieOrder(self, orderId, splitReason, shippingDate):
7136 
    self._oprot.writeMessageBegin('splitFreebieOrder', TMessageType.CALL, self._seqid)
7137 
    args = splitFreebieOrder_args()
7138 
    args.orderId = orderId
7139 
    args.splitReason = splitReason
7140 
    args.shippingDate = shippingDate
7141 
    args.write(self._oprot)
7142 
    self._oprot.writeMessageEnd()
7143 
    self._oprot.trans.flush()
7144 
 
7145 
  def recv_splitFreebieOrder(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 = splitFreebieOrder_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, "splitFreebieOrder failed: unknown result");
7158 
 
7172 anupam.sin 7159 
  def getRechargeTransactionsByNumber(self, number, storeId):
7169 anupam.sin 7160 
    """
7161 
    Parameters:
7162 
     - number
7172 anupam.sin 7163 
     - storeId
7169 anupam.sin 7164 
    """
7172 anupam.sin 7165 
    self.send_getRechargeTransactionsByNumber(number, storeId)
7169 anupam.sin 7166 
    return self.recv_getRechargeTransactionsByNumber()
7109 anupam.sin 7167 
 
7172 anupam.sin 7168 
  def send_getRechargeTransactionsByNumber(self, number, storeId):
7169 anupam.sin 7169 
    self._oprot.writeMessageBegin('getRechargeTransactionsByNumber', TMessageType.CALL, self._seqid)
7170 
    args = getRechargeTransactionsByNumber_args()
7171 
    args.number = number
7172 anupam.sin 7172 
    args.storeId = storeId
7169 anupam.sin 7173 
    args.write(self._oprot)
7174 
    self._oprot.writeMessageEnd()
7175 
    self._oprot.trans.flush()
7176 
 
7177 
  def recv_getRechargeTransactionsByNumber(self, ):
7178 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
7179 
    if mtype == TMessageType.EXCEPTION:
7180 
      x = TApplicationException()
7181 
      x.read(self._iprot)
7182 
      self._iprot.readMessageEnd()
7183 
      raise x
7184 
    result = getRechargeTransactionsByNumber_result()
7185 
    result.read(self._iprot)
7186 
    self._iprot.readMessageEnd()
7187 
    if result.success is not None:
7188 
      return result.success
7189 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getRechargeTransactionsByNumber failed: unknown result");
7190 
 
7191 
  def updateHotspotStorePassword(self, storeId, password):
7192 
    """
7193 
    Parameters:
7194 
     - storeId
7195 
     - password
7196 
    """
7197 
    self.send_updateHotspotStorePassword(storeId, password)
7198 
    return self.recv_updateHotspotStorePassword()
7199 
 
7200 
  def send_updateHotspotStorePassword(self, storeId, password):
7201 
    self._oprot.writeMessageBegin('updateHotspotStorePassword', TMessageType.CALL, self._seqid)
7202 
    args = updateHotspotStorePassword_args()
7203 
    args.storeId = storeId
7204 
    args.password = password
7205 
    args.write(self._oprot)
7206 
    self._oprot.writeMessageEnd()
7207 
    self._oprot.trans.flush()
7208 
 
7209 
  def recv_updateHotspotStorePassword(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 = updateHotspotStorePassword_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, "updateHotspotStorePassword failed: unknown result");
7222 
 
7285 rajveer 7223 
  def topupCompanyWallet(self, companyId, amount):
7263 anupam.sin 7224 
    """
7225 
    Parameters:
7285 rajveer 7226 
     - companyId
7227 
     - amount
7263 anupam.sin 7228 
    """
7285 rajveer 7229 
    self.send_topupCompanyWallet(companyId, amount)
7230 
    return self.recv_topupCompanyWallet()
7169 anupam.sin 7231 
 
7285 rajveer 7232 
  def send_topupCompanyWallet(self, companyId, amount):
7233 
    self._oprot.writeMessageBegin('topupCompanyWallet', TMessageType.CALL, self._seqid)
7234 
    args = topupCompanyWallet_args()
7235 
    args.companyId = companyId
7236 
    args.amount = amount
7263 anupam.sin 7237 
    args.write(self._oprot)
7238 
    self._oprot.writeMessageEnd()
7239 
    self._oprot.trans.flush()
7240 
 
7285 rajveer 7241 
  def recv_topupCompanyWallet(self, ):
7263 anupam.sin 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
7285 rajveer 7248 
    result = topupCompanyWallet_result()
7263 anupam.sin 7249 
    result.read(self._iprot)
7250 
    self._iprot.readMessageEnd()
7251 
    if result.success is not None:
7252 
      return result.success
7285 rajveer 7253 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "topupCompanyWallet failed: unknown result");
7263 anupam.sin 7254 
 
7285 rajveer 7255 
  def getWalletBalanceForCompany(self, companyId):
7256 
    """
7257 
    Parameters:
7258 
     - companyId
7259 
    """
7260 
    self.send_getWalletBalanceForCompany(companyId)
7261 
    return self.recv_getWalletBalanceForCompany()
7263 anupam.sin 7262 
 
7285 rajveer 7263 
  def send_getWalletBalanceForCompany(self, companyId):
7264 
    self._oprot.writeMessageBegin('getWalletBalanceForCompany', TMessageType.CALL, self._seqid)
7265 
    args = getWalletBalanceForCompany_args()
7266 
    args.companyId = companyId
7267 anupam.sin 7267 
    args.write(self._oprot)
7268 
    self._oprot.writeMessageEnd()
7269 
    self._oprot.trans.flush()
7270 
 
7285 rajveer 7271 
  def recv_getWalletBalanceForCompany(self, ):
7267 anupam.sin 7272 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
7273 
    if mtype == TMessageType.EXCEPTION:
7274 
      x = TApplicationException()
7275 
      x.read(self._iprot)
7276 
      self._iprot.readMessageEnd()
7277 
      raise x
7285 rajveer 7278 
    result = getWalletBalanceForCompany_result()
7267 anupam.sin 7279 
    result.read(self._iprot)
7280 
    self._iprot.readMessageEnd()
7281 
    if result.success is not None:
7282 
      return result.success
7285 rajveer 7283 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getWalletBalanceForCompany failed: unknown result");
7267 anupam.sin 7284 
 
7285 rajveer 7285 
  def getSourceDetail(self, source):
7267 anupam.sin 7286 
    """
7287 
    Parameters:
7285 rajveer 7288 
     - source
7267 anupam.sin 7289 
    """
7285 rajveer 7290 
    self.send_getSourceDetail(source)
7291 
    return self.recv_getSourceDetail()
7267 anupam.sin 7292 
 
7285 rajveer 7293 
  def send_getSourceDetail(self, source):
7294 
    self._oprot.writeMessageBegin('getSourceDetail', TMessageType.CALL, self._seqid)
7295 
    args = getSourceDetail_args()
7296 
    args.source = source
7267 anupam.sin 7297 
    args.write(self._oprot)
7298 
    self._oprot.writeMessageEnd()
7299 
    self._oprot.trans.flush()
7300 
 
7285 rajveer 7301 
  def recv_getSourceDetail(self, ):
7267 anupam.sin 7302 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
7303 
    if mtype == TMessageType.EXCEPTION:
7304 
      x = TApplicationException()
7305 
      x.read(self._iprot)
7306 
      self._iprot.readMessageEnd()
7307 
      raise x
7285 rajveer 7308 
    result = getSourceDetail_result()
7267 anupam.sin 7309 
    result.read(self._iprot)
7310 
    self._iprot.readMessageEnd()
7311 
    if result.success is not None:
7312 
      return result.success
7285 rajveer 7313 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getSourceDetail failed: unknown result");
7267 anupam.sin 7314 
 
7315 
 
3376 rajveer 7316 
class Processor(shop2020.thriftpy.generic.GenericService.Processor, Iface, TProcessor):
94 ashish 7317 
  def __init__(self, handler):
3376 rajveer 7318 
    shop2020.thriftpy.generic.GenericService.Processor.__init__(self, handler)
94 ashish 7319 
    self._processMap["createTransaction"] = Processor.process_createTransaction
7320 
    self._processMap["getTransaction"] = Processor.process_getTransaction
7321 
    self._processMap["getTransactionsForCustomer"] = Processor.process_getTransactionsForCustomer
132 ashish 7322 
    self._processMap["getTransactionsForShoppingCartId"] = Processor.process_getTransactionsForShoppingCartId
94 ashish 7323 
    self._processMap["getTransactionStatus"] = Processor.process_getTransactionStatus
7324 
    self._processMap["changeTransactionStatus"] = Processor.process_changeTransactionStatus
1398 varun.gupt 7325 
    self._processMap["enqueueTransactionInfoEmail"] = Processor.process_enqueueTransactionInfoEmail
483 rajveer 7326 
    self._processMap["getAllOrders"] = Processor.process_getAllOrders
4133 chandransh 7327 
    self._processMap["getOrdersInBatch"] = Processor.process_getOrdersInBatch
7328 
    self._processMap["getOrderCount"] = Processor.process_getOrderCount
999 varun.gupt 7329 
    self._processMap["getOrdersByBillingDate"] = Processor.process_getOrdersByBillingDate
3427 chandransh 7330 
    self._processMap["getOrdersByShippingDate"] = Processor.process_getOrdersByShippingDate
1382 varun.gupt 7331 
    self._processMap["getReturnableOrdersForCustomer"] = Processor.process_getReturnableOrdersForCustomer
7332 
    self._processMap["getCancellableOrdersForCustomer"] = Processor.process_getCancellableOrdersForCustomer
483 rajveer 7333 
    self._processMap["changeOrderStatus"] = Processor.process_changeOrderStatus
7334 
    self._processMap["getOrdersForTransaction"] = Processor.process_getOrdersForTransaction
7335 
    self._processMap["getOrdersForCustomer"] = Processor.process_getOrdersForCustomer
7336 
    self._processMap["createOrder"] = Processor.process_createOrder
7337 
    self._processMap["getOrder"] = Processor.process_getOrder
7338 
    self._processMap["getLineItemsForOrder"] = Processor.process_getLineItemsForOrder
4999 phani.kuma 7339 
    self._processMap["getOrderList"] = Processor.process_getOrderList
5386 phani.kuma 7340 
    self._processMap["getOrderListForVendor"] = Processor.process_getOrderListForVendor
1528 ankur.sing 7341 
    self._processMap["getOrderForCustomer"] = Processor.process_getOrderForCustomer
3064 chandransh 7342 
    self._processMap["getAlerts"] = Processor.process_getAlerts
4394 rajveer 7343 
    self._processMap["addAlert"] = Processor.process_addAlert
4444 rajveer 7344 
    self._processMap["markAlertsAsSeen"] = Processor.process_markAlertsAsSeen
3064 chandransh 7345 
    self._processMap["getValidOrderCount"] = Processor.process_getValidOrderCount
7346 
    self._processMap["getNoOfCustomersWithSuccessfulTransaction"] = Processor.process_getNoOfCustomersWithSuccessfulTransaction
7347 
    self._processMap["getValidOrdersAmountRange"] = Processor.process_getValidOrdersAmountRange
7348 
    self._processMap["getValidOrders"] = Processor.process_getValidOrders
1220 chandransh 7349 
    self._processMap["batchOrders"] = Processor.process_batchOrders
1208 chandransh 7350 
    self._processMap["markOrderAsOutOfStock"] = Processor.process_markOrderAsOutOfStock
3064 chandransh 7351 
    self._processMap["verifyOrder"] = Processor.process_verifyOrder
7352 
    self._processMap["acceptOrder"] = Processor.process_acceptOrder
7353 
    self._processMap["addBillingDetails"] = Processor.process_addBillingDetails
4579 rajveer 7354 
    self._processMap["addInvoiceNumber"] = Processor.process_addInvoiceNumber
4410 rajveer 7355 
    self._processMap["markOrdersAsShippedFromWarehouse"] = Processor.process_markOrdersAsShippedFromWarehouse
5676 rajveer 7356 
    self._processMap["markOrdersAsReturnedFromStore"] = Processor.process_markOrdersAsReturnedFromStore
1113 chandransh 7357 
    self._processMap["markOrdersAsPickedUp"] = Processor.process_markOrdersAsPickedUp
4910 phani.kuma 7358 
    self._processMap["getOrdersNotPickedUp"] = Processor.process_getOrdersNotPickedUp
1132 chandransh 7359 
    self._processMap["markOrdersAsDelivered"] = Processor.process_markOrdersAsDelivered
4910 phani.kuma 7360 
    self._processMap["markAsRTOrders"] = Processor.process_markAsRTOrders
7361 
    self._processMap["getRTOrders"] = Processor.process_getRTOrders
1246 chandransh 7362 
    self._processMap["updateNonDeliveryReason"] = Processor.process_updateNonDeliveryReason
4910 phani.kuma 7363 
    self._processMap["getNonDeliveredOrdersbyCourier"] = Processor.process_getNonDeliveredOrdersbyCourier
7364 
    self._processMap["markOrdersAsLocalConnected"] = Processor.process_markOrdersAsLocalConnected
7365 
    self._processMap["getOrdersNotLocalConnected"] = Processor.process_getOrdersNotLocalConnected
7366 
    self._processMap["markOrdersAsDestinationCityReached"] = Processor.process_markOrdersAsDestinationCityReached
7367 
    self._processMap["markOrdersAsFirstDeliveryAttempted"] = Processor.process_markOrdersAsFirstDeliveryAttempted
1408 ankur.sing 7368 
    self._processMap["getUndeliveredOrders"] = Processor.process_getUndeliveredOrders
4783 phani.kuma 7369 
    self._processMap["getUndeliveredOrdersExpectedDeliveryDateNotMet"] = Processor.process_getUndeliveredOrdersExpectedDeliveryDateNotMet
2536 chandransh 7370 
    self._processMap["toggleDOAFlag"] = Processor.process_toggleDOAFlag
4712 rajveer 7371 
    self._processMap["markOrderAsDelivered"] = Processor.process_markOrderAsDelivered
5553 rajveer 7372 
    self._processMap["markOrderAsReceivedAtStore"] = Processor.process_markOrderAsReceivedAtStore
4454 rajveer 7373 
    self._processMap["markOrderDoaRequestReceived"] = Processor.process_markOrderDoaRequestReceived
7374 
    self._processMap["markOrderDoaRequestAuthorized"] = Processor.process_markOrderDoaRequestAuthorized
4488 rajveer 7375 
    self._processMap["markOrderReturnRequestReceived"] = Processor.process_markOrderReturnRequestReceived
7376 
    self._processMap["markOrderReturnRequestAuthorized"] = Processor.process_markOrderReturnRequestAuthorized
2536 chandransh 7377 
    self._processMap["requestPickupNumber"] = Processor.process_requestPickupNumber
7378 
    self._processMap["authorizePickup"] = Processor.process_authorizePickup
2764 chandransh 7379 
    self._processMap["markDoasAsPickedUp"] = Processor.process_markDoasAsPickedUp
4910 phani.kuma 7380 
    self._processMap["getDoasNotPickedUp"] = Processor.process_getDoasNotPickedUp
4741 phani.kuma 7381 
    self._processMap["markReturnOrdersAsPickedUp"] = Processor.process_markReturnOrdersAsPickedUp
4910 phani.kuma 7382 
    self._processMap["getReturnOrdersNotPickedUp"] = Processor.process_getReturnOrdersNotPickedUp
2616 chandransh 7383 
    self._processMap["receiveReturn"] = Processor.process_receiveReturn
2591 chandransh 7384 
    self._processMap["validateDoa"] = Processor.process_validateDoa
4495 rajveer 7385 
    self._processMap["validateReturnProduct"] = Processor.process_validateReturnProduct
2616 chandransh 7386 
    self._processMap["reshipOrder"] = Processor.process_reshipOrder
7387 
    self._processMap["refundOrder"] = Processor.process_refundOrder
2690 chandransh 7388 
    self._processMap["getReturnOrders"] = Processor.process_getReturnOrders
5481 phani.kuma 7389 
    self._processMap["getAllReturnOrders"] = Processor.process_getAllReturnOrders
2700 chandransh 7390 
    self._processMap["getReturnOrder"] = Processor.process_getReturnOrder
2690 chandransh 7391 
    self._processMap["processReturn"] = Processor.process_processReturn
3451 chandransh 7392 
    self._processMap["updateWeight"] = Processor.process_updateWeight
3469 chandransh 7393 
    self._processMap["changeItem"] = Processor.process_changeItem
7394 
    self._processMap["shiftToWarehouse"] = Processor.process_shiftToWarehouse
3553 chandransh 7395 
    self._processMap["addDelayReason"] = Processor.process_addDelayReason
3956 chandransh 7396 
    self._processMap["reconcileCodCollection"] = Processor.process_reconcileCodCollection
4008 mandeep.dh 7397 
    self._processMap["getTransactionsRequiringExtraProcessing"] = Processor.process_getTransactionsRequiringExtraProcessing
7398 
    self._processMap["markTransactionAsProcessed"] = Processor.process_markTransactionAsProcessed
4018 chandransh 7399 
    self._processMap["getItemWiseRiskyOrdersCount"] = Processor.process_getItemWiseRiskyOrdersCount
4295 varun.gupt 7400 
    self._processMap["getOrdersForItemIds"] = Processor.process_getOrdersForItemIds
4247 rajveer 7401 
    self._processMap["markOrderCancellationRequestReceived"] = Processor.process_markOrderCancellationRequestReceived
7402 
    self._processMap["markOrderCancellationRequestConfirmed"] = Processor.process_markOrderCancellationRequestConfirmed
7403 
    self._processMap["markOrderCancellationRequestDenied"] = Processor.process_markOrderCancellationRequestDenied
4258 rajveer 7404 
    self._processMap["markTransactionAsPaymentFlagRemoved"] = Processor.process_markTransactionAsPaymentFlagRemoved
4259 anupam.sin 7405 
    self._processMap["refundTransaction"] = Processor.process_refundTransaction
4324 mandeep.dh 7406 
    self._processMap["updateShipmentAddress"] = Processor.process_updateShipmentAddress
4285 rajveer 7407 
    self._processMap["acceptOrdersForItemId"] = Processor.process_acceptOrdersForItemId
4303 rajveer 7408 
    self._processMap["markOrdersAsPORaised"] = Processor.process_markOrdersAsPORaised
7409 
    self._processMap["markOrdersAsReversalInitiated"] = Processor.process_markOrdersAsReversalInitiated
7410 
    self._processMap["markOrdersAsNotAvailabke"] = Processor.process_markOrdersAsNotAvailabke
4369 rajveer 7411 
    self._processMap["markOrdersAsTimeout"] = Processor.process_markOrdersAsTimeout
4662 rajveer 7412 
    self._processMap["markOrderAsLostInTransit"] = Processor.process_markOrderAsLostInTransit
4386 anupam.sin 7413 
    self._processMap["getOrderForAwb"] = Processor.process_getOrderForAwb
4506 phani.kuma 7414 
    self._processMap["getOrdersForProviderForStatus"] = Processor.process_getOrdersForProviderForStatus
4600 varun.gupt 7415 
    self._processMap["getBilledOrdersForVendor"] = Processor.process_getBilledOrdersForVendor
4607 rajveer 7416 
    self._processMap["getSlippedSippingDateOrders"] = Processor.process_getSlippedSippingDateOrders
4709 rajveer 7417 
    self._processMap["getCancelledOrders"] = Processor.process_getCancelledOrders
4600 varun.gupt 7418 
    self._processMap["saveBluedartSettlements"] = Processor.process_saveBluedartSettlements
7419 
    self._processMap["savePaymentSettlements"] = Processor.process_savePaymentSettlements
7420 
    self._processMap["saveEBSSettlementSummary"] = Processor.process_saveEBSSettlementSummary
5386 phani.kuma 7421 
    self._processMap["getSettlementForPrepaid"] = Processor.process_getSettlementForPrepaid
7422 
    self._processMap["getSettlementForCod"] = Processor.process_getSettlementForCod
4600 varun.gupt 7423 
    self._processMap["getEBSSettlementSummaries"] = Processor.process_getEBSSettlementSummaries
7424 
    self._processMap["markEBSSettlementUploaded"] = Processor.process_markEBSSettlementUploaded
7425 
    self._processMap["getEBSSettlementDate"] = Processor.process_getEBSSettlementDate
4715 varun.gupt 7426 
    self._processMap["getSettlementsByDate"] = Processor.process_getSettlementsByDate
7427 
    self._processMap["getReshippedOrderIds"] = Processor.process_getReshippedOrderIds
5481 phani.kuma 7428 
    self._processMap["getBilledOrders"] = Processor.process_getBilledOrders
5031 varun.gupt 7429 
    self._processMap["getStatusDistributionOfOrders"] = Processor.process_getStatusDistributionOfOrders
5067 varun.gupt 7430 
    self._processMap["getOrderIdsForStatus"] = Processor.process_getOrderIdsForStatus
5348 anupam.sin 7431 
    self._processMap["updateCODAgent"] = Processor.process_updateCODAgent
5099 varun.gupt 7432 
    self._processMap["updateOrderAsPaidToVendor"] = Processor.process_updateOrderAsPaidToVendor
5386 phani.kuma 7433 
    self._processMap["updateOrderOnlyAsPaidToVendor"] = Processor.process_updateOrderOnlyAsPaidToVendor
5208 varun.gupt 7434 
    self._processMap["getRefundedOrdersMarkedPaid"] = Processor.process_getRefundedOrdersMarkedPaid
5447 anupam.sin 7435 
    self._processMap["getAllVerificationAgents"] = Processor.process_getAllVerificationAgents
5527 anupam.sin 7436 
    self._processMap["getAllAttributesForOrderId"] = Processor.process_getAllAttributesForOrderId
5676 rajveer 7437 
    self._processMap["setOrderAttributes"] = Processor.process_setOrderAttributes
5527 anupam.sin 7438 
    self._processMap["setOrderAttributeForTransaction"] = Processor.process_setOrderAttributeForTransaction
5553 rajveer 7439 
    self._processMap["getReceivePendingOrders"] = Processor.process_getReceivePendingOrders
7440 
    self._processMap["getReceivedAtStoreOrders"] = Processor.process_getReceivedAtStoreOrders
5713 rajveer 7441 
    self._processMap["getOrdersCollectionAtStore"] = Processor.process_getOrdersCollectionAtStore
5833 rajveer 7442 
    self._processMap["getOrderAttributeValue"] = Processor.process_getOrderAttributeValue
6019 rajveer 7443 
    self._processMap["changeJacketNumber"] = Processor.process_changeJacketNumber
7444 
    self._processMap["markOrderAsRtoInTransit"] = Processor.process_markOrderAsRtoInTransit
5593 mandeep.dh 7445 
    self._processMap["acceptOrderForItem"] = Processor.process_acceptOrderForItem
6000 mandeep.dh 7446 
    self._processMap["createRechargeOrder"] = Processor.process_createRechargeOrder
6031 rajveer 7447 
    self._processMap["getRechargeOrder"] = Processor.process_getRechargeOrder
7448 
    self._processMap["getRechargeOrders"] = Processor.process_getRechargeOrders
6000 mandeep.dh 7449 
    self._processMap["updateRechargeOrderStatus"] = Processor.process_updateRechargeOrderStatus
7450 
    self._processMap["activateRechargeTxn"] = Processor.process_activateRechargeTxn
6031 rajveer 7451 
    self._processMap["getUserWallet"] = Processor.process_getUserWallet
7452 
    self._processMap["getUserWalletHistory"] = Processor.process_getUserWalletHistory
6050 anupam.sin 7453 
    self._processMap["getRechargeOrdersForTransaction"] = Processor.process_getRechargeOrdersForTransaction
6048 rajveer 7454 
    self._processMap["getServiceProviders"] = Processor.process_getServiceProviders
7455 
    self._processMap["getServiceProviderForDevice"] = Processor.process_getServiceProviderForDevice
6269 rajveer 7456 
    self._processMap["validateRecharge"] = Processor.process_validateRecharge
6094 rajveer 7457 
    self._processMap["getRechargeOrdersForDevice"] = Processor.process_getRechargeOrdersForDevice
7458 
    self._processMap["addAmountToWallet"] = Processor.process_addAmountToWallet
6188 rajveer 7459 
    self._processMap["getRechargeStatistics"] = Processor.process_getRechargeStatistics
6154 rajveer 7460 
    self._processMap["getRechargeOrdersForStatus"] = Processor.process_getRechargeOrdersForStatus
6159 rajveer 7461 
    self._processMap["getPlansForOperator"] = Processor.process_getPlansForOperator
6289 anupam.sin 7462 
    self._processMap["getRechargeDenominations"] = Processor.process_getRechargeDenominations
6371 rajveer 7463 
    self._processMap["updateAvailabilityStatus"] = Processor.process_updateAvailabilityStatus
6389 rajveer 7464 
    self._processMap["getAvailableEmiSchemes"] = Processor.process_getAvailableEmiSchemes
7465 
    self._processMap["getMiscCharges"] = Processor.process_getMiscCharges
6507 anupam.sin 7466 
    self._processMap["refundRechargeOrder"] = Processor.process_refundRechargeOrder
6821 amar.kumar 7467 
    self._processMap["getPhysicalOrders"] = Processor.process_getPhysicalOrders
6906 rajveer 7468 
    self._processMap["getDocument"] = Processor.process_getDocument
6985 anupam.sin 7469 
    self._processMap["changeShippingAddress"] = Processor.process_changeShippingAddress
6988 rajveer 7470 
    self._processMap["retrieveInvoice"] = Processor.process_retrieveInvoice
7026 rajveer 7471 
    self._processMap["receiveUpdatesForRedExpress"] = Processor.process_receiveUpdatesForRedExpress
7073 anupam.sin 7472 
    self._processMap["createRechargeTransaction"] = Processor.process_createRechargeTransaction
7085 rajveer 7473 
    self._processMap["getRechargeTransactions"] = Processor.process_getRechargeTransactions
7151 amit.gupta 7474 
    self._processMap["getRechargeTrans"] = Processor.process_getRechargeTrans
7080 anupam.sin 7475 
    self._processMap["getRechargeTransaction"] = Processor.process_getRechargeTransaction
7476 
    self._processMap["getFRCs"] = Processor.process_getFRCs
7096 anupam.sin 7477 
    self._processMap["getHotspotStore"] = Processor.process_getHotspotStore
7478 
    self._processMap["getTelecomCircle"] = Processor.process_getTelecomCircle
7109 anupam.sin 7479 
    self._processMap["retrieveHotspotRechargeInvoice"] = Processor.process_retrieveHotspotRechargeInvoice
7190 amar.kumar 7480 
    self._processMap["splitFreebieOrder"] = Processor.process_splitFreebieOrder
7169 anupam.sin 7481 
    self._processMap["getRechargeTransactionsByNumber"] = Processor.process_getRechargeTransactionsByNumber
7482 
    self._processMap["updateHotspotStorePassword"] = Processor.process_updateHotspotStorePassword
7285 rajveer 7483 
    self._processMap["topupCompanyWallet"] = Processor.process_topupCompanyWallet
7484 
    self._processMap["getWalletBalanceForCompany"] = Processor.process_getWalletBalanceForCompany
7263 anupam.sin 7485 
    self._processMap["getSourceDetail"] = Processor.process_getSourceDetail
94 ashish 7486 
 
7487 
  def process(self, iprot, oprot):
7488 
    (name, type, seqid) = iprot.readMessageBegin()
7489 
    if name not in self._processMap:
7490 
      iprot.skip(TType.STRUCT)
7491 
      iprot.readMessageEnd()
7492 
      x = TApplicationException(TApplicationException.UNKNOWN_METHOD, 'Unknown function %s' % (name))
7493 
      oprot.writeMessageBegin(name, TMessageType.EXCEPTION, seqid)
7494 
      x.write(oprot)
7495 
      oprot.writeMessageEnd()
7496 
      oprot.trans.flush()
7497 
      return
7498 
    else:
7499 
      self._processMap[name](self, seqid, iprot, oprot)
7500 
    return True
7501 
 
7502 
  def process_createTransaction(self, seqid, iprot, oprot):
7503 
    args = createTransaction_args()
7504 
    args.read(iprot)
7505 
    iprot.readMessageEnd()
7506 
    result = createTransaction_result()
7507 
    try:
132 ashish 7508 
      result.success = self._handler.createTransaction(args.transaction)
94 ashish 7509 
    except TransactionServiceException, ex:
7510 
      result.ex = ex
7511 
    oprot.writeMessageBegin("createTransaction", TMessageType.REPLY, seqid)
7512 
    result.write(oprot)
7513 
    oprot.writeMessageEnd()
7514 
    oprot.trans.flush()
7515 
 
7516 
  def process_getTransaction(self, seqid, iprot, oprot):
7517 
    args = getTransaction_args()
7518 
    args.read(iprot)
7519 
    iprot.readMessageEnd()
7520 
    result = getTransaction_result()
7521 
    try:
7522 
      result.success = self._handler.getTransaction(args.id)
7523 
    except TransactionServiceException, ex:
7524 
      result.ex = ex
7525 
    oprot.writeMessageBegin("getTransaction", TMessageType.REPLY, seqid)
7526 
    result.write(oprot)
7527 
    oprot.writeMessageEnd()
7528 
    oprot.trans.flush()
7529 
 
7530 
  def process_getTransactionsForCustomer(self, seqid, iprot, oprot):
7531 
    args = getTransactionsForCustomer_args()
7532 
    args.read(iprot)
7533 
    iprot.readMessageEnd()
7534 
    result = getTransactionsForCustomer_result()
7535 
    try:
7536 
      result.success = self._handler.getTransactionsForCustomer(args.customerId, args.from_date, args.to_date, args.status)
7537 
    except TransactionServiceException, ex:
7538 
      result.ex = ex
7539 
    oprot.writeMessageBegin("getTransactionsForCustomer", TMessageType.REPLY, seqid)
7540 
    result.write(oprot)
7541 
    oprot.writeMessageEnd()
7542 
    oprot.trans.flush()
7543 
 
132 ashish 7544 
  def process_getTransactionsForShoppingCartId(self, seqid, iprot, oprot):
7545 
    args = getTransactionsForShoppingCartId_args()
7546 
    args.read(iprot)
7547 
    iprot.readMessageEnd()
7548 
    result = getTransactionsForShoppingCartId_result()
7549 
    try:
7550 
      result.success = self._handler.getTransactionsForShoppingCartId(args.shoppingCartId)
7551 
    except TransactionServiceException, ex:
7552 
      result.ex = ex
7553 
    oprot.writeMessageBegin("getTransactionsForShoppingCartId", TMessageType.REPLY, seqid)
7554 
    result.write(oprot)
7555 
    oprot.writeMessageEnd()
7556 
    oprot.trans.flush()
7557 
 
94 ashish 7558 
  def process_getTransactionStatus(self, seqid, iprot, oprot):
7559 
    args = getTransactionStatus_args()
7560 
    args.read(iprot)
7561 
    iprot.readMessageEnd()
7562 
    result = getTransactionStatus_result()
7563 
    try:
7564 
      result.success = self._handler.getTransactionStatus(args.transactionId)
7565 
    except TransactionServiceException, ex:
7566 
      result.ex = ex
7567 
    oprot.writeMessageBegin("getTransactionStatus", TMessageType.REPLY, seqid)
7568 
    result.write(oprot)
7569 
    oprot.writeMessageEnd()
7570 
    oprot.trans.flush()
7571 
 
7572 
  def process_changeTransactionStatus(self, seqid, iprot, oprot):
7573 
    args = changeTransactionStatus_args()
7574 
    args.read(iprot)
7575 
    iprot.readMessageEnd()
7576 
    result = changeTransactionStatus_result()
7577 
    try:
7293 anupam.sin 7578 
      result.success = self._handler.changeTransactionStatus(args.transactionId, args.status, args.description, args.pickUp, args.orderType, args.source)
94 ashish 7579 
    except TransactionServiceException, ex:
7580 
      result.ex = ex
7581 
    oprot.writeMessageBegin("changeTransactionStatus", TMessageType.REPLY, seqid)
7582 
    result.write(oprot)
7583 
    oprot.writeMessageEnd()
7584 
    oprot.trans.flush()
7585 
 
1398 varun.gupt 7586 
  def process_enqueueTransactionInfoEmail(self, seqid, iprot, oprot):
7587 
    args = enqueueTransactionInfoEmail_args()
1382 varun.gupt 7588 
    args.read(iprot)
7589 
    iprot.readMessageEnd()
1398 varun.gupt 7590 
    result = enqueueTransactionInfoEmail_result()
1382 varun.gupt 7591 
    try:
1398 varun.gupt 7592 
      result.success = self._handler.enqueueTransactionInfoEmail(args.transactionId)
1382 varun.gupt 7593 
    except TransactionServiceException, ex:
7594 
      result.ex = ex
1398 varun.gupt 7595 
    oprot.writeMessageBegin("enqueueTransactionInfoEmail", TMessageType.REPLY, seqid)
1382 varun.gupt 7596 
    result.write(oprot)
7597 
    oprot.writeMessageEnd()
7598 
    oprot.trans.flush()
7599 
 
483 rajveer 7600 
  def process_getAllOrders(self, seqid, iprot, oprot):
7601 
    args = getAllOrders_args()
94 ashish 7602 
    args.read(iprot)
7603 
    iprot.readMessageEnd()
483 rajveer 7604 
    result = getAllOrders_result()
94 ashish 7605 
    try:
4801 anupam.sin 7606 
      result.success = self._handler.getAllOrders(args.statuses, args.from_date, args.to_date, args.warehouse_id)
94 ashish 7607 
    except TransactionServiceException, ex:
7608 
      result.ex = ex
483 rajveer 7609 
    oprot.writeMessageBegin("getAllOrders", TMessageType.REPLY, seqid)
94 ashish 7610 
    result.write(oprot)
7611 
    oprot.writeMessageEnd()
7612 
    oprot.trans.flush()
7613 
 
4133 chandransh 7614 
  def process_getOrdersInBatch(self, seqid, iprot, oprot):
7615 
    args = getOrdersInBatch_args()
7616 
    args.read(iprot)
7617 
    iprot.readMessageEnd()
7618 
    result = getOrdersInBatch_result()
7619 
    try:
7620 
      result.success = self._handler.getOrdersInBatch(args.statuses, args.offset, args.limit, args.warehouse_id)
7621 
    except TransactionServiceException, ex:
7622 
      result.ex = ex
7623 
    oprot.writeMessageBegin("getOrdersInBatch", TMessageType.REPLY, seqid)
7624 
    result.write(oprot)
7625 
    oprot.writeMessageEnd()
7626 
    oprot.trans.flush()
7627 
 
7628 
  def process_getOrderCount(self, seqid, iprot, oprot):
7629 
    args = getOrderCount_args()
7630 
    args.read(iprot)
7631 
    iprot.readMessageEnd()
7632 
    result = getOrderCount_result()
7633 
    try:
7634 
      result.success = self._handler.getOrderCount(args.statuses, args.warehouseId)
7635 
    except TransactionServiceException, ex:
7636 
      result.ex = ex
7637 
    oprot.writeMessageBegin("getOrderCount", TMessageType.REPLY, seqid)
7638 
    result.write(oprot)
7639 
    oprot.writeMessageEnd()
7640 
    oprot.trans.flush()
7641 
 
999 varun.gupt 7642 
  def process_getOrdersByBillingDate(self, seqid, iprot, oprot):
7643 
    args = getOrdersByBillingDate_args()
7644 
    args.read(iprot)
7645 
    iprot.readMessageEnd()
7646 
    result = getOrdersByBillingDate_result()
7647 
    try:
7648 
      result.success = self._handler.getOrdersByBillingDate(args.status, args.start_billing_date, args.end_billing_date, args.warehouse_id)
7649 
    except TransactionServiceException, ex:
7650 
      result.ex = ex
7651 
    oprot.writeMessageBegin("getOrdersByBillingDate", TMessageType.REPLY, seqid)
7652 
    result.write(oprot)
7653 
    oprot.writeMessageEnd()
7654 
    oprot.trans.flush()
7655 
 
3427 chandransh 7656 
  def process_getOrdersByShippingDate(self, seqid, iprot, oprot):
7657 
    args = getOrdersByShippingDate_args()
7658 
    args.read(iprot)
7659 
    iprot.readMessageEnd()
7660 
    result = getOrdersByShippingDate_result()
7661 
    try:
3451 chandransh 7662 
      result.success = self._handler.getOrdersByShippingDate(args.fromShippingDate, args.toShippingDate, args.providerId, args.warehouseId, args.cod)
3427 chandransh 7663 
    except TransactionServiceException, ex:
7664 
      result.ex = ex
7665 
    oprot.writeMessageBegin("getOrdersByShippingDate", TMessageType.REPLY, seqid)
7666 
    result.write(oprot)
7667 
    oprot.writeMessageEnd()
7668 
    oprot.trans.flush()
7669 
 
1382 varun.gupt 7670 
  def process_getReturnableOrdersForCustomer(self, seqid, iprot, oprot):
7671 
    args = getReturnableOrdersForCustomer_args()
7672 
    args.read(iprot)
7673 
    iprot.readMessageEnd()
7674 
    result = getReturnableOrdersForCustomer_result()
7675 
    try:
7676 
      result.success = self._handler.getReturnableOrdersForCustomer(args.customer_id, args.limit)
7677 
    except TransactionServiceException, ex:
7678 
      result.ex = ex
7679 
    oprot.writeMessageBegin("getReturnableOrdersForCustomer", TMessageType.REPLY, seqid)
7680 
    result.write(oprot)
7681 
    oprot.writeMessageEnd()
7682 
    oprot.trans.flush()
7683 
 
7684 
  def process_getCancellableOrdersForCustomer(self, seqid, iprot, oprot):
7685 
    args = getCancellableOrdersForCustomer_args()
7686 
    args.read(iprot)
7687 
    iprot.readMessageEnd()
7688 
    result = getCancellableOrdersForCustomer_result()
7689 
    try:
7690 
      result.success = self._handler.getCancellableOrdersForCustomer(args.customer_id, args.limit)
7691 
    except TransactionServiceException, ex:
7692 
      result.ex = ex
7693 
    oprot.writeMessageBegin("getCancellableOrdersForCustomer", TMessageType.REPLY, seqid)
7694 
    result.write(oprot)
7695 
    oprot.writeMessageEnd()
7696 
    oprot.trans.flush()
7697 
 
483 rajveer 7698 
  def process_changeOrderStatus(self, seqid, iprot, oprot):
7699 
    args = changeOrderStatus_args()
94 ashish 7700 
    args.read(iprot)
7701 
    iprot.readMessageEnd()
483 rajveer 7702 
    result = changeOrderStatus_result()
94 ashish 7703 
    try:
483 rajveer 7704 
      result.success = self._handler.changeOrderStatus(args.orderId, args.status, args.description)
94 ashish 7705 
    except TransactionServiceException, ex:
7706 
      result.ex = ex
483 rajveer 7707 
    oprot.writeMessageBegin("changeOrderStatus", TMessageType.REPLY, seqid)
94 ashish 7708 
    result.write(oprot)
7709 
    oprot.writeMessageEnd()
7710 
    oprot.trans.flush()
7711 
 
483 rajveer 7712 
  def process_getOrdersForTransaction(self, seqid, iprot, oprot):
7713 
    args = getOrdersForTransaction_args()
94 ashish 7714 
    args.read(iprot)
7715 
    iprot.readMessageEnd()
483 rajveer 7716 
    result = getOrdersForTransaction_result()
94 ashish 7717 
    try:
1528 ankur.sing 7718 
      result.success = self._handler.getOrdersForTransaction(args.transactionId, args.customerId)
94 ashish 7719 
    except TransactionServiceException, ex:
7720 
      result.ex = ex
483 rajveer 7721 
    oprot.writeMessageBegin("getOrdersForTransaction", TMessageType.REPLY, seqid)
94 ashish 7722 
    result.write(oprot)
7723 
    oprot.writeMessageEnd()
7724 
    oprot.trans.flush()
7725 
 
483 rajveer 7726 
  def process_getOrdersForCustomer(self, seqid, iprot, oprot):
7727 
    args = getOrdersForCustomer_args()
94 ashish 7728 
    args.read(iprot)
7729 
    iprot.readMessageEnd()
483 rajveer 7730 
    result = getOrdersForCustomer_result()
94 ashish 7731 
    try:
3014 chandransh 7732 
      result.success = self._handler.getOrdersForCustomer(args.customerId, args.from_date, args.to_date, args.statuses)
94 ashish 7733 
    except TransactionServiceException, ex:
7734 
      result.ex = ex
483 rajveer 7735 
    oprot.writeMessageBegin("getOrdersForCustomer", TMessageType.REPLY, seqid)
94 ashish 7736 
    result.write(oprot)
7737 
    oprot.writeMessageEnd()
7738 
    oprot.trans.flush()
7739 
 
483 rajveer 7740 
  def process_createOrder(self, seqid, iprot, oprot):
7741 
    args = createOrder_args()
94 ashish 7742 
    args.read(iprot)
7743 
    iprot.readMessageEnd()
483 rajveer 7744 
    result = createOrder_result()
94 ashish 7745 
    try:
483 rajveer 7746 
      result.success = self._handler.createOrder(args.order)
94 ashish 7747 
    except TransactionServiceException, ex:
7748 
      result.ex = ex
483 rajveer 7749 
    oprot.writeMessageBegin("createOrder", TMessageType.REPLY, seqid)
94 ashish 7750 
    result.write(oprot)
7751 
    oprot.writeMessageEnd()
7752 
    oprot.trans.flush()
7753 
 
483 rajveer 7754 
  def process_getOrder(self, seqid, iprot, oprot):
7755 
    args = getOrder_args()
94 ashish 7756 
    args.read(iprot)
7757 
    iprot.readMessageEnd()
483 rajveer 7758 
    result = getOrder_result()
94 ashish 7759 
    try:
483 rajveer 7760 
      result.success = self._handler.getOrder(args.id)
94 ashish 7761 
    except TransactionServiceException, ex:
7762 
      result.ex = ex
483 rajveer 7763 
    oprot.writeMessageBegin("getOrder", TMessageType.REPLY, seqid)
94 ashish 7764 
    result.write(oprot)
7765 
    oprot.writeMessageEnd()
7766 
    oprot.trans.flush()
7767 
 
483 rajveer 7768 
  def process_getLineItemsForOrder(self, seqid, iprot, oprot):
7769 
    args = getLineItemsForOrder_args()
94 ashish 7770 
    args.read(iprot)
7771 
    iprot.readMessageEnd()
483 rajveer 7772 
    result = getLineItemsForOrder_result()
94 ashish 7773 
    try:
483 rajveer 7774 
      result.success = self._handler.getLineItemsForOrder(args.orderId)
94 ashish 7775 
    except TransactionServiceException, ex:
7776 
      result.ex = ex
483 rajveer 7777 
    oprot.writeMessageBegin("getLineItemsForOrder", TMessageType.REPLY, seqid)
94 ashish 7778 
    result.write(oprot)
7779 
    oprot.writeMessageEnd()
7780 
    oprot.trans.flush()
7781 
 
4999 phani.kuma 7782 
  def process_getOrderList(self, seqid, iprot, oprot):
7783 
    args = getOrderList_args()
7784 
    args.read(iprot)
7785 
    iprot.readMessageEnd()
7786 
    result = getOrderList_result()
7787 
    result.success = self._handler.getOrderList(args.order_ids)
7788 
    oprot.writeMessageBegin("getOrderList", TMessageType.REPLY, seqid)
7789 
    result.write(oprot)
7790 
    oprot.writeMessageEnd()
7791 
    oprot.trans.flush()
7792 
 
5386 phani.kuma 7793 
  def process_getOrderListForVendor(self, seqid, iprot, oprot):
7794 
    args = getOrderListForVendor_args()
7795 
    args.read(iprot)
7796 
    iprot.readMessageEnd()
7797 
    result = getOrderListForVendor_result()
7798 
    result.success = self._handler.getOrderListForVendor(args.order_ids, args.vendorId)
7799 
    oprot.writeMessageBegin("getOrderListForVendor", TMessageType.REPLY, seqid)
7800 
    result.write(oprot)
7801 
    oprot.writeMessageEnd()
7802 
    oprot.trans.flush()
7803 
 
1528 ankur.sing 7804 
  def process_getOrderForCustomer(self, seqid, iprot, oprot):
7805 
    args = getOrderForCustomer_args()
7806 
    args.read(iprot)
7807 
    iprot.readMessageEnd()
7808 
    result = getOrderForCustomer_result()
7809 
    try:
7810 
      result.success = self._handler.getOrderForCustomer(args.orderId, args.customerId)
7811 
    except TransactionServiceException, ex:
7812 
      result.ex = ex
7813 
    oprot.writeMessageBegin("getOrderForCustomer", TMessageType.REPLY, seqid)
7814 
    result.write(oprot)
7815 
    oprot.writeMessageEnd()
7816 
    oprot.trans.flush()
7817 
 
3064 chandransh 7818 
  def process_getAlerts(self, seqid, iprot, oprot):
7819 
    args = getAlerts_args()
7820 
    args.read(iprot)
7821 
    iprot.readMessageEnd()
7822 
    result = getAlerts_result()
4444 rajveer 7823 
    result.success = self._handler.getAlerts(args.type, args.warehouseId, args.status, args.timestamp)
3064 chandransh 7824 
    oprot.writeMessageBegin("getAlerts", TMessageType.REPLY, seqid)
7825 
    result.write(oprot)
7826 
    oprot.writeMessageEnd()
7827 
    oprot.trans.flush()
7828 
 
4394 rajveer 7829 
  def process_addAlert(self, seqid, iprot, oprot):
7830 
    args = addAlert_args()
3064 chandransh 7831 
    args.read(iprot)
7832 
    iprot.readMessageEnd()
4394 rajveer 7833 
    result = addAlert_result()
4444 rajveer 7834 
    self._handler.addAlert(args.type, args.warehouseId, args.description)
4394 rajveer 7835 
    oprot.writeMessageBegin("addAlert", TMessageType.REPLY, seqid)
3064 chandransh 7836 
    result.write(oprot)
7837 
    oprot.writeMessageEnd()
7838 
    oprot.trans.flush()
7839 
 
4444 rajveer 7840 
  def process_markAlertsAsSeen(self, seqid, iprot, oprot):
7841 
    args = markAlertsAsSeen_args()
7842 
    args.read(iprot)
7843 
    iprot.readMessageEnd()
7844 
    result = markAlertsAsSeen_result()
7845 
    self._handler.markAlertsAsSeen(args.warehouseId)
7846 
    oprot.writeMessageBegin("markAlertsAsSeen", TMessageType.REPLY, seqid)
7847 
    result.write(oprot)
7848 
    oprot.writeMessageEnd()
7849 
    oprot.trans.flush()
7850 
 
3064 chandransh 7851 
  def process_getValidOrderCount(self, seqid, iprot, oprot):
7852 
    args = getValidOrderCount_args()
7853 
    args.read(iprot)
7854 
    iprot.readMessageEnd()
7855 
    result = getValidOrderCount_result()
7856 
    result.success = self._handler.getValidOrderCount()
7857 
    oprot.writeMessageBegin("getValidOrderCount", TMessageType.REPLY, seqid)
7858 
    result.write(oprot)
7859 
    oprot.writeMessageEnd()
7860 
    oprot.trans.flush()
7861 
 
7862 
  def process_getNoOfCustomersWithSuccessfulTransaction(self, seqid, iprot, oprot):
7863 
    args = getNoOfCustomersWithSuccessfulTransaction_args()
7864 
    args.read(iprot)
7865 
    iprot.readMessageEnd()
7866 
    result = getNoOfCustomersWithSuccessfulTransaction_result()
7867 
    result.success = self._handler.getNoOfCustomersWithSuccessfulTransaction()
7868 
    oprot.writeMessageBegin("getNoOfCustomersWithSuccessfulTransaction", TMessageType.REPLY, seqid)
7869 
    result.write(oprot)
7870 
    oprot.writeMessageEnd()
7871 
    oprot.trans.flush()
7872 
 
7873 
  def process_getValidOrdersAmountRange(self, seqid, iprot, oprot):
7874 
    args = getValidOrdersAmountRange_args()
7875 
    args.read(iprot)
7876 
    iprot.readMessageEnd()
7877 
    result = getValidOrdersAmountRange_result()
7878 
    result.success = self._handler.getValidOrdersAmountRange()
7879 
    oprot.writeMessageBegin("getValidOrdersAmountRange", TMessageType.REPLY, seqid)
7880 
    result.write(oprot)
7881 
    oprot.writeMessageEnd()
7882 
    oprot.trans.flush()
7883 
 
7884 
  def process_getValidOrders(self, seqid, iprot, oprot):
7885 
    args = getValidOrders_args()
7886 
    args.read(iprot)
7887 
    iprot.readMessageEnd()
7888 
    result = getValidOrders_result()
5874 rajveer 7889 
    result.success = self._handler.getValidOrders(args.limit, args.onlyStore)
3064 chandransh 7890 
    oprot.writeMessageBegin("getValidOrders", TMessageType.REPLY, seqid)
7891 
    result.write(oprot)
7892 
    oprot.writeMessageEnd()
7893 
    oprot.trans.flush()
7894 
 
1220 chandransh 7895 
  def process_batchOrders(self, seqid, iprot, oprot):
7896 
    args = batchOrders_args()
7897 
    args.read(iprot)
7898 
    iprot.readMessageEnd()
7899 
    result = batchOrders_result()
7900 
    try:
7901 
      result.success = self._handler.batchOrders(args.warehouseId)
7902 
    except TransactionServiceException, ex:
7903 
      result.ex = ex
7904 
    oprot.writeMessageBegin("batchOrders", TMessageType.REPLY, seqid)
7905 
    result.write(oprot)
7906 
    oprot.writeMessageEnd()
7907 
    oprot.trans.flush()
7908 
 
1208 chandransh 7909 
  def process_markOrderAsOutOfStock(self, seqid, iprot, oprot):
7910 
    args = markOrderAsOutOfStock_args()
7911 
    args.read(iprot)
7912 
    iprot.readMessageEnd()
7913 
    result = markOrderAsOutOfStock_result()
7914 
    try:
7915 
      result.success = self._handler.markOrderAsOutOfStock(args.orderId)
7916 
    except TransactionServiceException, ex:
7917 
      result.ex = ex
7918 
    oprot.writeMessageBegin("markOrderAsOutOfStock", TMessageType.REPLY, seqid)
7919 
    result.write(oprot)
7920 
    oprot.writeMessageEnd()
7921 
    oprot.trans.flush()
7922 
 
3064 chandransh 7923 
  def process_verifyOrder(self, seqid, iprot, oprot):
7924 
    args = verifyOrder_args()
759 chandransh 7925 
    args.read(iprot)
7926 
    iprot.readMessageEnd()
3064 chandransh 7927 
    result = verifyOrder_result()
759 chandransh 7928 
    try:
3064 chandransh 7929 
      result.success = self._handler.verifyOrder(args.orderId)
759 chandransh 7930 
    except TransactionServiceException, ex:
7931 
      result.ex = ex
3064 chandransh 7932 
    oprot.writeMessageBegin("verifyOrder", TMessageType.REPLY, seqid)
759 chandransh 7933 
    result.write(oprot)
7934 
    oprot.writeMessageEnd()
7935 
    oprot.trans.flush()
7936 
 
3064 chandransh 7937 
  def process_acceptOrder(self, seqid, iprot, oprot):
7938 
    args = acceptOrder_args()
1113 chandransh 7939 
    args.read(iprot)
7940 
    iprot.readMessageEnd()
3064 chandransh 7941 
    result = acceptOrder_result()
1113 chandransh 7942 
    try:
3064 chandransh 7943 
      result.success = self._handler.acceptOrder(args.orderId)
1113 chandransh 7944 
    except TransactionServiceException, ex:
7945 
      result.ex = ex
3064 chandransh 7946 
    oprot.writeMessageBegin("acceptOrder", TMessageType.REPLY, seqid)
1113 chandransh 7947 
    result.write(oprot)
7948 
    oprot.writeMessageEnd()
7949 
    oprot.trans.flush()
7950 
 
3064 chandransh 7951 
  def process_addBillingDetails(self, seqid, iprot, oprot):
7952 
    args = addBillingDetails_args()
1135 chandransh 7953 
    args.read(iprot)
7954 
    iprot.readMessageEnd()
3064 chandransh 7955 
    result = addBillingDetails_result()
1135 chandransh 7956 
    try:
7190 amar.kumar 7957 
      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 7958 
    except TransactionServiceException, ex:
7959 
      result.ex = ex
3064 chandransh 7960 
    oprot.writeMessageBegin("addBillingDetails", TMessageType.REPLY, seqid)
1135 chandransh 7961 
    result.write(oprot)
7962 
    oprot.writeMessageEnd()
7963 
    oprot.trans.flush()
7964 
 
4579 rajveer 7965 
  def process_addInvoiceNumber(self, seqid, iprot, oprot):
7966 
    args = addInvoiceNumber_args()
7967 
    args.read(iprot)
7968 
    iprot.readMessageEnd()
7969 
    result = addInvoiceNumber_result()
7970 
    try:
6756 amar.kumar 7971 
      self._handler.addInvoiceNumber(args.orderId, args.invoiceNumber, args.color, args.serialNumber, args.itemNumber)
4579 rajveer 7972 
    except TransactionServiceException, ex:
7973 
      result.ex = ex
7974 
    oprot.writeMessageBegin("addInvoiceNumber", TMessageType.REPLY, seqid)
7975 
    result.write(oprot)
7976 
    oprot.writeMessageEnd()
7977 
    oprot.trans.flush()
7978 
 
4410 rajveer 7979 
  def process_markOrdersAsShippedFromWarehouse(self, seqid, iprot, oprot):
7980 
    args = markOrdersAsShippedFromWarehouse_args()
7981 
    args.read(iprot)
7982 
    iprot.readMessageEnd()
7983 
    result = markOrdersAsShippedFromWarehouse_result()
7984 
    try:
4789 rajveer 7985 
      result.success = self._handler.markOrdersAsShippedFromWarehouse(args.warehouseId, args.providerId, args.cod, args.orderIds)
4410 rajveer 7986 
    except TransactionServiceException, ex:
7987 
      result.ex = ex
7988 
    oprot.writeMessageBegin("markOrdersAsShippedFromWarehouse", TMessageType.REPLY, seqid)
7989 
    result.write(oprot)
7990 
    oprot.writeMessageEnd()
7991 
    oprot.trans.flush()
7992 
 
5676 rajveer 7993 
  def process_markOrdersAsReturnedFromStore(self, seqid, iprot, oprot):
7994 
    args = markOrdersAsReturnedFromStore_args()
7995 
    args.read(iprot)
7996 
    iprot.readMessageEnd()
7997 
    result = markOrdersAsReturnedFromStore_result()
7998 
    try:
5713 rajveer 7999 
      result.success = self._handler.markOrdersAsReturnedFromStore(args.providerId, args.orderIds, args.awbs)
5676 rajveer 8000 
    except TransactionServiceException, ex:
8001 
      result.ex = ex
8002 
    oprot.writeMessageBegin("markOrdersAsReturnedFromStore", TMessageType.REPLY, seqid)
8003 
    result.write(oprot)
8004 
    oprot.writeMessageEnd()
8005 
    oprot.trans.flush()
8006 
 
3064 chandransh 8007 
  def process_markOrdersAsPickedUp(self, seqid, iprot, oprot):
8008 
    args = markOrdersAsPickedUp_args()
304 ashish 8009 
    args.read(iprot)
8010 
    iprot.readMessageEnd()
3064 chandransh 8011 
    result = markOrdersAsPickedUp_result()
8012 
    try:
4910 phani.kuma 8013 
      self._handler.markOrdersAsPickedUp(args.providerId, args.pickupDetails)
3064 chandransh 8014 
    except TransactionServiceException, ex:
8015 
      result.ex = ex
8016 
    oprot.writeMessageBegin("markOrdersAsPickedUp", TMessageType.REPLY, seqid)
304 ashish 8017 
    result.write(oprot)
8018 
    oprot.writeMessageEnd()
8019 
    oprot.trans.flush()
94 ashish 8020 
 
4910 phani.kuma 8021 
  def process_getOrdersNotPickedUp(self, seqid, iprot, oprot):
8022 
    args = getOrdersNotPickedUp_args()
8023 
    args.read(iprot)
8024 
    iprot.readMessageEnd()
8025 
    result = getOrdersNotPickedUp_result()
8026 
    result.success = self._handler.getOrdersNotPickedUp(args.providerId)
8027 
    oprot.writeMessageBegin("getOrdersNotPickedUp", TMessageType.REPLY, seqid)
8028 
    result.write(oprot)
8029 
    oprot.writeMessageEnd()
8030 
    oprot.trans.flush()
8031 
 
3064 chandransh 8032 
  def process_markOrdersAsDelivered(self, seqid, iprot, oprot):
8033 
    args = markOrdersAsDelivered_args()
304 ashish 8034 
    args.read(iprot)
8035 
    iprot.readMessageEnd()
3064 chandransh 8036 
    result = markOrdersAsDelivered_result()
8037 
    try:
8038 
      self._handler.markOrdersAsDelivered(args.providerId, args.deliveredOrders)
8039 
    except TransactionServiceException, ex:
8040 
      result.ex = ex
8041 
    oprot.writeMessageBegin("markOrdersAsDelivered", TMessageType.REPLY, seqid)
304 ashish 8042 
    result.write(oprot)
8043 
    oprot.writeMessageEnd()
8044 
    oprot.trans.flush()
8045 
 
4910 phani.kuma 8046 
  def process_markAsRTOrders(self, seqid, iprot, oprot):
8047 
    args = markAsRTOrders_args()
1596 ankur.sing 8048 
    args.read(iprot)
8049 
    iprot.readMessageEnd()
4910 phani.kuma 8050 
    result = markAsRTOrders_result()
3064 chandransh 8051 
    try:
4910 phani.kuma 8052 
      self._handler.markAsRTOrders(args.providerId, args.returnedOrders)
3064 chandransh 8053 
    except TransactionServiceException, ex:
8054 
      result.ex = ex
4910 phani.kuma 8055 
    oprot.writeMessageBegin("markAsRTOrders", TMessageType.REPLY, seqid)
1596 ankur.sing 8056 
    result.write(oprot)
8057 
    oprot.writeMessageEnd()
8058 
    oprot.trans.flush()
304 ashish 8059 
 
4910 phani.kuma 8060 
  def process_getRTOrders(self, seqid, iprot, oprot):
8061 
    args = getRTOrders_args()
8062 
    args.read(iprot)
8063 
    iprot.readMessageEnd()
8064 
    result = getRTOrders_result()
8065 
    result.success = self._handler.getRTOrders(args.providerId)
8066 
    oprot.writeMessageBegin("getRTOrders", TMessageType.REPLY, seqid)
8067 
    result.write(oprot)
8068 
    oprot.writeMessageEnd()
8069 
    oprot.trans.flush()
8070 
 
3064 chandransh 8071 
  def process_updateNonDeliveryReason(self, seqid, iprot, oprot):
8072 
    args = updateNonDeliveryReason_args()
1627 ankur.sing 8073 
    args.read(iprot)
8074 
    iprot.readMessageEnd()
3064 chandransh 8075 
    result = updateNonDeliveryReason_result()
8076 
    try:
4910 phani.kuma 8077 
      self._handler.updateNonDeliveryReason(args.providerId, args.undeliveredOrders)
3064 chandransh 8078 
    except TransactionServiceException, ex:
8079 
      result.ex = ex
8080 
    oprot.writeMessageBegin("updateNonDeliveryReason", TMessageType.REPLY, seqid)
1627 ankur.sing 8081 
    result.write(oprot)
8082 
    oprot.writeMessageEnd()
8083 
    oprot.trans.flush()
1596 ankur.sing 8084 
 
4910 phani.kuma 8085 
  def process_getNonDeliveredOrdersbyCourier(self, seqid, iprot, oprot):
8086 
    args = getNonDeliveredOrdersbyCourier_args()
8087 
    args.read(iprot)
8088 
    iprot.readMessageEnd()
8089 
    result = getNonDeliveredOrdersbyCourier_result()
8090 
    result.success = self._handler.getNonDeliveredOrdersbyCourier(args.providerId)
8091 
    oprot.writeMessageBegin("getNonDeliveredOrdersbyCourier", TMessageType.REPLY, seqid)
8092 
    result.write(oprot)
8093 
    oprot.writeMessageEnd()
8094 
    oprot.trans.flush()
8095 
 
8096 
  def process_markOrdersAsLocalConnected(self, seqid, iprot, oprot):
8097 
    args = markOrdersAsLocalConnected_args()
8098 
    args.read(iprot)
8099 
    iprot.readMessageEnd()
8100 
    result = markOrdersAsLocalConnected_result()
8101 
    try:
8102 
      self._handler.markOrdersAsLocalConnected(args.providerId, args.local_connected_orders)
8103 
    except TransactionServiceException, ex:
8104 
      result.ex = ex
8105 
    oprot.writeMessageBegin("markOrdersAsLocalConnected", TMessageType.REPLY, seqid)
8106 
    result.write(oprot)
8107 
    oprot.writeMessageEnd()
8108 
    oprot.trans.flush()
8109 
 
8110 
  def process_getOrdersNotLocalConnected(self, seqid, iprot, oprot):
8111 
    args = getOrdersNotLocalConnected_args()
8112 
    args.read(iprot)
8113 
    iprot.readMessageEnd()
8114 
    result = getOrdersNotLocalConnected_result()
8115 
    result.success = self._handler.getOrdersNotLocalConnected(args.providerId)
8116 
    oprot.writeMessageBegin("getOrdersNotLocalConnected", TMessageType.REPLY, seqid)
8117 
    result.write(oprot)
8118 
    oprot.writeMessageEnd()
8119 
    oprot.trans.flush()
8120 
 
8121 
  def process_markOrdersAsDestinationCityReached(self, seqid, iprot, oprot):
8122 
    args = markOrdersAsDestinationCityReached_args()
8123 
    args.read(iprot)
8124 
    iprot.readMessageEnd()
8125 
    result = markOrdersAsDestinationCityReached_result()
8126 
    try:
8127 
      self._handler.markOrdersAsDestinationCityReached(args.providerId, args.destination_city_reached_orders)
8128 
    except TransactionServiceException, ex:
8129 
      result.ex = ex
8130 
    oprot.writeMessageBegin("markOrdersAsDestinationCityReached", TMessageType.REPLY, seqid)
8131 
    result.write(oprot)
8132 
    oprot.writeMessageEnd()
8133 
    oprot.trans.flush()
8134 
 
8135 
  def process_markOrdersAsFirstDeliveryAttempted(self, seqid, iprot, oprot):
8136 
    args = markOrdersAsFirstDeliveryAttempted_args()
8137 
    args.read(iprot)
8138 
    iprot.readMessageEnd()
8139 
    result = markOrdersAsFirstDeliveryAttempted_result()
8140 
    try:
8141 
      self._handler.markOrdersAsFirstDeliveryAttempted(args.providerId, args.first_atdl_orders)
8142 
    except TransactionServiceException, ex:
8143 
      result.ex = ex
8144 
    oprot.writeMessageBegin("markOrdersAsFirstDeliveryAttempted", TMessageType.REPLY, seqid)
8145 
    result.write(oprot)
8146 
    oprot.writeMessageEnd()
8147 
    oprot.trans.flush()
8148 
 
3064 chandransh 8149 
  def process_getUndeliveredOrders(self, seqid, iprot, oprot):
8150 
    args = getUndeliveredOrders_args()
1627 ankur.sing 8151 
    args.read(iprot)
8152 
    iprot.readMessageEnd()
3064 chandransh 8153 
    result = getUndeliveredOrders_result()
8154 
    result.success = self._handler.getUndeliveredOrders(args.providerId, args.warehouseId)
8155 
    oprot.writeMessageBegin("getUndeliveredOrders", TMessageType.REPLY, seqid)
1627 ankur.sing 8156 
    result.write(oprot)
8157 
    oprot.writeMessageEnd()
8158 
    oprot.trans.flush()
8159 
 
4783 phani.kuma 8160 
  def process_getUndeliveredOrdersExpectedDeliveryDateNotMet(self, seqid, iprot, oprot):
8161 
    args = getUndeliveredOrdersExpectedDeliveryDateNotMet_args()
8162 
    args.read(iprot)
8163 
    iprot.readMessageEnd()
8164 
    result = getUndeliveredOrdersExpectedDeliveryDateNotMet_result()
8165 
    result.success = self._handler.getUndeliveredOrdersExpectedDeliveryDateNotMet()
8166 
    oprot.writeMessageBegin("getUndeliveredOrdersExpectedDeliveryDateNotMet", TMessageType.REPLY, seqid)
8167 
    result.write(oprot)
8168 
    oprot.writeMessageEnd()
8169 
    oprot.trans.flush()
8170 
 
2536 chandransh 8171 
  def process_toggleDOAFlag(self, seqid, iprot, oprot):
8172 
    args = toggleDOAFlag_args()
8173 
    args.read(iprot)
8174 
    iprot.readMessageEnd()
8175 
    result = toggleDOAFlag_result()
8176 
    try:
8177 
      result.success = self._handler.toggleDOAFlag(args.orderId)
8178 
    except TransactionServiceException, ex:
8179 
      result.ex = ex
8180 
    oprot.writeMessageBegin("toggleDOAFlag", TMessageType.REPLY, seqid)
8181 
    result.write(oprot)
8182 
    oprot.writeMessageEnd()
8183 
    oprot.trans.flush()
1886 ankur.sing 8184 
 
4712 rajveer 8185 
  def process_markOrderAsDelivered(self, seqid, iprot, oprot):
8186 
    args = markOrderAsDelivered_args()
8187 
    args.read(iprot)
8188 
    iprot.readMessageEnd()
8189 
    result = markOrderAsDelivered_result()
8190 
    try:
8191 
      self._handler.markOrderAsDelivered(args.orderId, args.deliveryTimestamp, args.receiver)
8192 
    except TransactionServiceException, ex:
8193 
      result.ex = ex
8194 
    oprot.writeMessageBegin("markOrderAsDelivered", TMessageType.REPLY, seqid)
8195 
    result.write(oprot)
8196 
    oprot.writeMessageEnd()
8197 
    oprot.trans.flush()
8198 
 
5553 rajveer 8199 
  def process_markOrderAsReceivedAtStore(self, seqid, iprot, oprot):
8200 
    args = markOrderAsReceivedAtStore_args()
8201 
    args.read(iprot)
8202 
    iprot.readMessageEnd()
8203 
    result = markOrderAsReceivedAtStore_result()
8204 
    try:
8205 
      self._handler.markOrderAsReceivedAtStore(args.orderId, args.deliveryTimestamp)
8206 
    except TransactionServiceException, ex:
8207 
      result.ex = ex
8208 
    oprot.writeMessageBegin("markOrderAsReceivedAtStore", TMessageType.REPLY, seqid)
8209 
    result.write(oprot)
8210 
    oprot.writeMessageEnd()
8211 
    oprot.trans.flush()
8212 
 
4454 rajveer 8213 
  def process_markOrderDoaRequestReceived(self, seqid, iprot, oprot):
8214 
    args = markOrderDoaRequestReceived_args()
8215 
    args.read(iprot)
8216 
    iprot.readMessageEnd()
8217 
    result = markOrderDoaRequestReceived_result()
8218 
    try:
8219 
      result.success = self._handler.markOrderDoaRequestReceived(args.orderId)
8220 
    except TransactionServiceException, ex:
8221 
      result.ex = ex
8222 
    oprot.writeMessageBegin("markOrderDoaRequestReceived", TMessageType.REPLY, seqid)
8223 
    result.write(oprot)
8224 
    oprot.writeMessageEnd()
8225 
    oprot.trans.flush()
8226 
 
8227 
  def process_markOrderDoaRequestAuthorized(self, seqid, iprot, oprot):
8228 
    args = markOrderDoaRequestAuthorized_args()
8229 
    args.read(iprot)
8230 
    iprot.readMessageEnd()
8231 
    result = markOrderDoaRequestAuthorized_result()
8232 
    try:
8233 
      result.success = self._handler.markOrderDoaRequestAuthorized(args.orderId, args.isAuthorized)
8234 
    except TransactionServiceException, ex:
8235 
      result.ex = ex
8236 
    oprot.writeMessageBegin("markOrderDoaRequestAuthorized", TMessageType.REPLY, seqid)
8237 
    result.write(oprot)
8238 
    oprot.writeMessageEnd()
8239 
    oprot.trans.flush()
8240 
 
4488 rajveer 8241 
  def process_markOrderReturnRequestReceived(self, seqid, iprot, oprot):
8242 
    args = markOrderReturnRequestReceived_args()
8243 
    args.read(iprot)
8244 
    iprot.readMessageEnd()
8245 
    result = markOrderReturnRequestReceived_result()
8246 
    try:
8247 
      result.success = self._handler.markOrderReturnRequestReceived(args.orderId)
8248 
    except TransactionServiceException, ex:
8249 
      result.ex = ex
8250 
    oprot.writeMessageBegin("markOrderReturnRequestReceived", TMessageType.REPLY, seqid)
8251 
    result.write(oprot)
8252 
    oprot.writeMessageEnd()
8253 
    oprot.trans.flush()
8254 
 
8255 
  def process_markOrderReturnRequestAuthorized(self, seqid, iprot, oprot):
8256 
    args = markOrderReturnRequestAuthorized_args()
8257 
    args.read(iprot)
8258 
    iprot.readMessageEnd()
8259 
    result = markOrderReturnRequestAuthorized_result()
8260 
    try:
8261 
      result.success = self._handler.markOrderReturnRequestAuthorized(args.orderId, args.isAuthorized)
8262 
    except TransactionServiceException, ex:
8263 
      result.ex = ex
8264 
    oprot.writeMessageBegin("markOrderReturnRequestAuthorized", TMessageType.REPLY, seqid)
8265 
    result.write(oprot)
8266 
    oprot.writeMessageEnd()
8267 
    oprot.trans.flush()
8268 
 
2536 chandransh 8269 
  def process_requestPickupNumber(self, seqid, iprot, oprot):
8270 
    args = requestPickupNumber_args()
8271 
    args.read(iprot)
8272 
    iprot.readMessageEnd()
8273 
    result = requestPickupNumber_result()
8274 
    try:
4579 rajveer 8275 
      result.success = self._handler.requestPickupNumber(args.orderId, args.providerId)
2536 chandransh 8276 
    except TransactionServiceException, ex:
8277 
      result.ex = ex
8278 
    oprot.writeMessageBegin("requestPickupNumber", TMessageType.REPLY, seqid)
8279 
    result.write(oprot)
8280 
    oprot.writeMessageEnd()
8281 
    oprot.trans.flush()
8282 
 
8283 
  def process_authorizePickup(self, seqid, iprot, oprot):
8284 
    args = authorizePickup_args()
8285 
    args.read(iprot)
8286 
    iprot.readMessageEnd()
8287 
    result = authorizePickup_result()
8288 
    try:
4602 rajveer 8289 
      result.success = self._handler.authorizePickup(args.orderId, args.pickupNumber, args.providerId)
2536 chandransh 8290 
    except TransactionServiceException, ex:
8291 
      result.ex = ex
8292 
    oprot.writeMessageBegin("authorizePickup", TMessageType.REPLY, seqid)
8293 
    result.write(oprot)
8294 
    oprot.writeMessageEnd()
8295 
    oprot.trans.flush()
8296 
 
2764 chandransh 8297 
  def process_markDoasAsPickedUp(self, seqid, iprot, oprot):
8298 
    args = markDoasAsPickedUp_args()
8299 
    args.read(iprot)
8300 
    iprot.readMessageEnd()
8301 
    result = markDoasAsPickedUp_result()
4910 phani.kuma 8302 
    self._handler.markDoasAsPickedUp(args.providerId, args.pickupDetails)
2764 chandransh 8303 
    oprot.writeMessageBegin("markDoasAsPickedUp", TMessageType.REPLY, seqid)
8304 
    result.write(oprot)
8305 
    oprot.writeMessageEnd()
8306 
    oprot.trans.flush()
8307 
 
4910 phani.kuma 8308 
  def process_getDoasNotPickedUp(self, seqid, iprot, oprot):
8309 
    args = getDoasNotPickedUp_args()
8310 
    args.read(iprot)
8311 
    iprot.readMessageEnd()
8312 
    result = getDoasNotPickedUp_result()
8313 
    result.success = self._handler.getDoasNotPickedUp(args.providerId)
8314 
    oprot.writeMessageBegin("getDoasNotPickedUp", TMessageType.REPLY, seqid)
8315 
    result.write(oprot)
8316 
    oprot.writeMessageEnd()
8317 
    oprot.trans.flush()
8318 
 
4741 phani.kuma 8319 
  def process_markReturnOrdersAsPickedUp(self, seqid, iprot, oprot):
8320 
    args = markReturnOrdersAsPickedUp_args()
8321 
    args.read(iprot)
8322 
    iprot.readMessageEnd()
8323 
    result = markReturnOrdersAsPickedUp_result()
4910 phani.kuma 8324 
    self._handler.markReturnOrdersAsPickedUp(args.providerId, args.pickupDetails)
4741 phani.kuma 8325 
    oprot.writeMessageBegin("markReturnOrdersAsPickedUp", TMessageType.REPLY, seqid)
8326 
    result.write(oprot)
8327 
    oprot.writeMessageEnd()
8328 
    oprot.trans.flush()
8329 
 
4910 phani.kuma 8330 
  def process_getReturnOrdersNotPickedUp(self, seqid, iprot, oprot):
8331 
    args = getReturnOrdersNotPickedUp_args()
8332 
    args.read(iprot)
8333 
    iprot.readMessageEnd()
8334 
    result = getReturnOrdersNotPickedUp_result()
8335 
    result.success = self._handler.getReturnOrdersNotPickedUp(args.providerId)
8336 
    oprot.writeMessageBegin("getReturnOrdersNotPickedUp", TMessageType.REPLY, seqid)
8337 
    result.write(oprot)
8338 
    oprot.writeMessageEnd()
8339 
    oprot.trans.flush()
8340 
 
2616 chandransh 8341 
  def process_receiveReturn(self, seqid, iprot, oprot):
8342 
    args = receiveReturn_args()
2591 chandransh 8343 
    args.read(iprot)
8344 
    iprot.readMessageEnd()
2616 chandransh 8345 
    result = receiveReturn_result()
2591 chandransh 8346 
    try:
4479 rajveer 8347 
      result.success = self._handler.receiveReturn(args.orderId, args.receiveCondition)
2591 chandransh 8348 
    except TransactionServiceException, ex:
8349 
      result.ex = ex
2616 chandransh 8350 
    oprot.writeMessageBegin("receiveReturn", TMessageType.REPLY, seqid)
2591 chandransh 8351 
    result.write(oprot)
8352 
    oprot.writeMessageEnd()
8353 
    oprot.trans.flush()
2536 chandransh 8354 
 
2591 chandransh 8355 
  def process_validateDoa(self, seqid, iprot, oprot):
8356 
    args = validateDoa_args()
8357 
    args.read(iprot)
8358 
    iprot.readMessageEnd()
8359 
    result = validateDoa_result()
8360 
    try:
8361 
      result.success = self._handler.validateDoa(args.orderId, args.isValid)
8362 
    except TransactionServiceException, ex:
8363 
      result.ex = ex
8364 
    oprot.writeMessageBegin("validateDoa", TMessageType.REPLY, seqid)
8365 
    result.write(oprot)
8366 
    oprot.writeMessageEnd()
8367 
    oprot.trans.flush()
8368 
 
4495 rajveer 8369 
  def process_validateReturnProduct(self, seqid, iprot, oprot):
8370 
    args = validateReturnProduct_args()
8371 
    args.read(iprot)
8372 
    iprot.readMessageEnd()
8373 
    result = validateReturnProduct_result()
8374 
    try:
8375 
      result.success = self._handler.validateReturnProduct(args.orderId, args.isUsable)
8376 
    except TransactionServiceException, ex:
8377 
      result.ex = ex
8378 
    oprot.writeMessageBegin("validateReturnProduct", TMessageType.REPLY, seqid)
8379 
    result.write(oprot)
8380 
    oprot.writeMessageEnd()
8381 
    oprot.trans.flush()
8382 
 
2616 chandransh 8383 
  def process_reshipOrder(self, seqid, iprot, oprot):
8384 
    args = reshipOrder_args()
8385 
    args.read(iprot)
8386 
    iprot.readMessageEnd()
8387 
    result = reshipOrder_result()
8388 
    try:
8389 
      result.success = self._handler.reshipOrder(args.orderId)
8390 
    except TransactionServiceException, ex:
8391 
      result.ex = ex
8392 
    oprot.writeMessageBegin("reshipOrder", TMessageType.REPLY, seqid)
8393 
    result.write(oprot)
8394 
    oprot.writeMessageEnd()
8395 
    oprot.trans.flush()
2591 chandransh 8396 
 
2616 chandransh 8397 
  def process_refundOrder(self, seqid, iprot, oprot):
8398 
    args = refundOrder_args()
8399 
    args.read(iprot)
8400 
    iprot.readMessageEnd()
8401 
    result = refundOrder_result()
8402 
    try:
3226 chandransh 8403 
      result.success = self._handler.refundOrder(args.orderId, args.refundedBy, args.reason)
2616 chandransh 8404 
    except TransactionServiceException, ex:
8405 
      result.ex = ex
8406 
    oprot.writeMessageBegin("refundOrder", TMessageType.REPLY, seqid)
8407 
    result.write(oprot)
8408 
    oprot.writeMessageEnd()
8409 
    oprot.trans.flush()
8410 
 
2690 chandransh 8411 
  def process_getReturnOrders(self, seqid, iprot, oprot):
8412 
    args = getReturnOrders_args()
8413 
    args.read(iprot)
8414 
    iprot.readMessageEnd()
8415 
    result = getReturnOrders_result()
8416 
    result.success = self._handler.getReturnOrders(args.warehouseId, args.fromDate, args.toDate)
8417 
    oprot.writeMessageBegin("getReturnOrders", TMessageType.REPLY, seqid)
8418 
    result.write(oprot)
8419 
    oprot.writeMessageEnd()
8420 
    oprot.trans.flush()
2616 chandransh 8421 
 
5481 phani.kuma 8422 
  def process_getAllReturnOrders(self, seqid, iprot, oprot):
8423 
    args = getAllReturnOrders_args()
8424 
    args.read(iprot)
8425 
    iprot.readMessageEnd()
8426 
    result = getAllReturnOrders_result()
8427 
    result.success = self._handler.getAllReturnOrders(args.onlyNotProcessed, args.fromDate, args.toDate)
8428 
    oprot.writeMessageBegin("getAllReturnOrders", TMessageType.REPLY, seqid)
8429 
    result.write(oprot)
8430 
    oprot.writeMessageEnd()
8431 
    oprot.trans.flush()
8432 
 
2700 chandransh 8433 
  def process_getReturnOrder(self, seqid, iprot, oprot):
8434 
    args = getReturnOrder_args()
8435 
    args.read(iprot)
8436 
    iprot.readMessageEnd()
8437 
    result = getReturnOrder_result()
8438 
    try:
8439 
      result.success = self._handler.getReturnOrder(args.id)
8440 
    except TransactionServiceException, ex:
8441 
      result.ex = ex
8442 
    oprot.writeMessageBegin("getReturnOrder", TMessageType.REPLY, seqid)
8443 
    result.write(oprot)
8444 
    oprot.writeMessageEnd()
8445 
    oprot.trans.flush()
8446 
 
2690 chandransh 8447 
  def process_processReturn(self, seqid, iprot, oprot):
8448 
    args = processReturn_args()
8449 
    args.read(iprot)
8450 
    iprot.readMessageEnd()
8451 
    result = processReturn_result()
8452 
    try:
8453 
      self._handler.processReturn(args.returnOrderId)
8454 
    except TransactionServiceException, ex:
8455 
      result.ex = ex
8456 
    oprot.writeMessageBegin("processReturn", TMessageType.REPLY, seqid)
8457 
    result.write(oprot)
8458 
    oprot.writeMessageEnd()
8459 
    oprot.trans.flush()
8460 
 
3451 chandransh 8461 
  def process_updateWeight(self, seqid, iprot, oprot):
8462 
    args = updateWeight_args()
8463 
    args.read(iprot)
8464 
    iprot.readMessageEnd()
8465 
    result = updateWeight_result()
8466 
    try:
8467 
      result.success = self._handler.updateWeight(args.orderId, args.weight)
8468 
    except TransactionServiceException, ex:
8469 
      result.ex = ex
8470 
    oprot.writeMessageBegin("updateWeight", TMessageType.REPLY, seqid)
8471 
    result.write(oprot)
8472 
    oprot.writeMessageEnd()
8473 
    oprot.trans.flush()
2819 chandransh 8474 
 
3469 chandransh 8475 
  def process_changeItem(self, seqid, iprot, oprot):
8476 
    args = changeItem_args()
8477 
    args.read(iprot)
8478 
    iprot.readMessageEnd()
8479 
    result = changeItem_result()
8480 
    try:
8481 
      result.success = self._handler.changeItem(args.orderId, args.itemId)
8482 
    except TransactionServiceException, ex:
8483 
      result.ex = ex
8484 
    oprot.writeMessageBegin("changeItem", TMessageType.REPLY, seqid)
8485 
    result.write(oprot)
8486 
    oprot.writeMessageEnd()
8487 
    oprot.trans.flush()
3451 chandransh 8488 
 
3469 chandransh 8489 
  def process_shiftToWarehouse(self, seqid, iprot, oprot):
8490 
    args = shiftToWarehouse_args()
8491 
    args.read(iprot)
8492 
    iprot.readMessageEnd()
8493 
    result = shiftToWarehouse_result()
8494 
    try:
8495 
      result.success = self._handler.shiftToWarehouse(args.orderId, args.warehouseId)
8496 
    except TransactionServiceException, ex:
8497 
      result.ex = ex
8498 
    oprot.writeMessageBegin("shiftToWarehouse", TMessageType.REPLY, seqid)
8499 
    result.write(oprot)
8500 
    oprot.writeMessageEnd()
8501 
    oprot.trans.flush()
8502 
 
3553 chandransh 8503 
  def process_addDelayReason(self, seqid, iprot, oprot):
8504 
    args = addDelayReason_args()
8505 
    args.read(iprot)
8506 
    iprot.readMessageEnd()
8507 
    result = addDelayReason_result()
8508 
    try:
4647 rajveer 8509 
      result.success = self._handler.addDelayReason(args.orderId, args.delayReason, args.furtherDelay, args.delayReasonText)
3553 chandransh 8510 
    except TransactionServiceException, ex:
8511 
      result.ex = ex
8512 
    oprot.writeMessageBegin("addDelayReason", TMessageType.REPLY, seqid)
8513 
    result.write(oprot)
8514 
    oprot.writeMessageEnd()
8515 
    oprot.trans.flush()
3469 chandransh 8516 
 
3956 chandransh 8517 
  def process_reconcileCodCollection(self, seqid, iprot, oprot):
8518 
    args = reconcileCodCollection_args()
8519 
    args.read(iprot)
8520 
    iprot.readMessageEnd()
8521 
    result = reconcileCodCollection_result()
8522 
    try:
8523 
      result.success = self._handler.reconcileCodCollection(args.collectedAmountMap, args.xferBy, args.xferTxnId, args.xferDate)
8524 
    except TransactionServiceException, ex:
8525 
      result.ex = ex
8526 
    oprot.writeMessageBegin("reconcileCodCollection", TMessageType.REPLY, seqid)
8527 
    result.write(oprot)
8528 
    oprot.writeMessageEnd()
8529 
    oprot.trans.flush()
3553 chandransh 8530 
 
4008 mandeep.dh 8531 
  def process_getTransactionsRequiringExtraProcessing(self, seqid, iprot, oprot):
8532 
    args = getTransactionsRequiringExtraProcessing_args()
8533 
    args.read(iprot)
8534 
    iprot.readMessageEnd()
8535 
    result = getTransactionsRequiringExtraProcessing_result()
8536 
    result.success = self._handler.getTransactionsRequiringExtraProcessing(args.category)
8537 
    oprot.writeMessageBegin("getTransactionsRequiringExtraProcessing", TMessageType.REPLY, seqid)
8538 
    result.write(oprot)
8539 
    oprot.writeMessageEnd()
8540 
    oprot.trans.flush()
3956 chandransh 8541 
 
4008 mandeep.dh 8542 
  def process_markTransactionAsProcessed(self, seqid, iprot, oprot):
8543 
    args = markTransactionAsProcessed_args()
8544 
    args.read(iprot)
8545 
    iprot.readMessageEnd()
8546 
    result = markTransactionAsProcessed_result()
8547 
    self._handler.markTransactionAsProcessed(args.transactionId, args.category)
8548 
    oprot.writeMessageBegin("markTransactionAsProcessed", TMessageType.REPLY, seqid)
8549 
    result.write(oprot)
8550 
    oprot.writeMessageEnd()
8551 
    oprot.trans.flush()
8552 
 
4018 chandransh 8553 
  def process_getItemWiseRiskyOrdersCount(self, seqid, iprot, oprot):
8554 
    args = getItemWiseRiskyOrdersCount_args()
8555 
    args.read(iprot)
8556 
    iprot.readMessageEnd()
8557 
    result = getItemWiseRiskyOrdersCount_result()
8558 
    result.success = self._handler.getItemWiseRiskyOrdersCount()
8559 
    oprot.writeMessageBegin("getItemWiseRiskyOrdersCount", TMessageType.REPLY, seqid)
8560 
    result.write(oprot)
8561 
    oprot.writeMessageEnd()
8562 
    oprot.trans.flush()
4008 mandeep.dh 8563 
 
4295 varun.gupt 8564 
  def process_getOrdersForItemIds(self, seqid, iprot, oprot):
8565 
    args = getOrdersForItemIds_args()
8566 
    args.read(iprot)
8567 
    iprot.readMessageEnd()
8568 
    result = getOrdersForItemIds_result()
8569 
    result.success = self._handler.getOrdersForItemIds(args.itemIds)
8570 
    oprot.writeMessageBegin("getOrdersForItemIds", TMessageType.REPLY, seqid)
8571 
    result.write(oprot)
8572 
    oprot.writeMessageEnd()
8573 
    oprot.trans.flush()
8574 
 
4247 rajveer 8575 
  def process_markOrderCancellationRequestReceived(self, seqid, iprot, oprot):
8576 
    args = markOrderCancellationRequestReceived_args()
8577 
    args.read(iprot)
8578 
    iprot.readMessageEnd()
8579 
    result = markOrderCancellationRequestReceived_result()
8580 
    try:
8581 
      self._handler.markOrderCancellationRequestReceived(args.orderId)
8582 
    except TransactionServiceException, ex:
8583 
      result.ex = ex
8584 
    oprot.writeMessageBegin("markOrderCancellationRequestReceived", TMessageType.REPLY, seqid)
8585 
    result.write(oprot)
8586 
    oprot.writeMessageEnd()
8587 
    oprot.trans.flush()
4018 chandransh 8588 
 
4247 rajveer 8589 
  def process_markOrderCancellationRequestConfirmed(self, seqid, iprot, oprot):
8590 
    args = markOrderCancellationRequestConfirmed_args()
8591 
    args.read(iprot)
8592 
    iprot.readMessageEnd()
8593 
    result = markOrderCancellationRequestConfirmed_result()
8594 
    try:
8595 
      self._handler.markOrderCancellationRequestConfirmed(args.orderId)
8596 
    except TransactionServiceException, ex:
8597 
      result.ex = ex
8598 
    oprot.writeMessageBegin("markOrderCancellationRequestConfirmed", TMessageType.REPLY, seqid)
8599 
    result.write(oprot)
8600 
    oprot.writeMessageEnd()
8601 
    oprot.trans.flush()
8602 
 
8603 
  def process_markOrderCancellationRequestDenied(self, seqid, iprot, oprot):
8604 
    args = markOrderCancellationRequestDenied_args()
8605 
    args.read(iprot)
8606 
    iprot.readMessageEnd()
8607 
    result = markOrderCancellationRequestDenied_result()
8608 
    try:
8609 
      self._handler.markOrderCancellationRequestDenied(args.orderId)
8610 
    except TransactionServiceException, ex:
8611 
      result.ex = ex
8612 
    oprot.writeMessageBegin("markOrderCancellationRequestDenied", TMessageType.REPLY, seqid)
8613 
    result.write(oprot)
8614 
    oprot.writeMessageEnd()
8615 
    oprot.trans.flush()
8616 
 
4258 rajveer 8617 
  def process_markTransactionAsPaymentFlagRemoved(self, seqid, iprot, oprot):
8618 
    args = markTransactionAsPaymentFlagRemoved_args()
4247 rajveer 8619 
    args.read(iprot)
8620 
    iprot.readMessageEnd()
4258 rajveer 8621 
    result = markTransactionAsPaymentFlagRemoved_result()
4247 rajveer 8622 
    try:
4258 rajveer 8623 
      self._handler.markTransactionAsPaymentFlagRemoved(args.transactionId)
4247 rajveer 8624 
    except TransactionServiceException, ex:
8625 
      result.ex = ex
4258 rajveer 8626 
    oprot.writeMessageBegin("markTransactionAsPaymentFlagRemoved", TMessageType.REPLY, seqid)
4247 rajveer 8627 
    result.write(oprot)
8628 
    oprot.writeMessageEnd()
8629 
    oprot.trans.flush()
8630 
 
4259 anupam.sin 8631 
  def process_refundTransaction(self, seqid, iprot, oprot):
8632 
    args = refundTransaction_args()
8633 
    args.read(iprot)
8634 
    iprot.readMessageEnd()
8635 
    result = refundTransaction_result()
8636 
    try:
8637 
      self._handler.refundTransaction(args.transactionId, args.refundedBy, args.reason)
8638 
    except TransactionServiceException, ex:
8639 
      result.ex = ex
8640 
    oprot.writeMessageBegin("refundTransaction", TMessageType.REPLY, seqid)
8641 
    result.write(oprot)
8642 
    oprot.writeMessageEnd()
8643 
    oprot.trans.flush()
4247 rajveer 8644 
 
4324 mandeep.dh 8645 
  def process_updateShipmentAddress(self, seqid, iprot, oprot):
8646 
    args = updateShipmentAddress_args()
8647 
    args.read(iprot)
8648 
    iprot.readMessageEnd()
8649 
    result = updateShipmentAddress_result()
8650 
    try:
8651 
      self._handler.updateShipmentAddress(args.orderId, args.addressId)
8652 
    except TransactionServiceException, ex:
8653 
      result.ex = ex
8654 
    oprot.writeMessageBegin("updateShipmentAddress", TMessageType.REPLY, seqid)
8655 
    result.write(oprot)
8656 
    oprot.writeMessageEnd()
8657 
    oprot.trans.flush()
8658 
 
4285 rajveer 8659 
  def process_acceptOrdersForItemId(self, seqid, iprot, oprot):
8660 
    args = acceptOrdersForItemId_args()
8661 
    args.read(iprot)
8662 
    iprot.readMessageEnd()
8663 
    result = acceptOrdersForItemId_result()
8664 
    try:
8665 
      result.success = self._handler.acceptOrdersForItemId(args.itemId, args.inventory)
8666 
    except TransactionServiceException, ex:
8667 
      result.ex = ex
8668 
    oprot.writeMessageBegin("acceptOrdersForItemId", TMessageType.REPLY, seqid)
8669 
    result.write(oprot)
8670 
    oprot.writeMessageEnd()
8671 
    oprot.trans.flush()
4259 anupam.sin 8672 
 
4303 rajveer 8673 
  def process_markOrdersAsPORaised(self, seqid, iprot, oprot):
8674 
    args = markOrdersAsPORaised_args()
8675 
    args.read(iprot)
8676 
    iprot.readMessageEnd()
8677 
    result = markOrdersAsPORaised_result()
8678 
    try:
4369 rajveer 8679 
      self._handler.markOrdersAsPORaised(args.vendorId, args.itemId, args.quantity, args.estimate, args.isReminder)
4303 rajveer 8680 
    except TransactionServiceException, ex:
8681 
      result.ex = ex
8682 
    oprot.writeMessageBegin("markOrdersAsPORaised", TMessageType.REPLY, seqid)
8683 
    result.write(oprot)
8684 
    oprot.writeMessageEnd()
8685 
    oprot.trans.flush()
4285 rajveer 8686 
 
4303 rajveer 8687 
  def process_markOrdersAsReversalInitiated(self, seqid, iprot, oprot):
8688 
    args = markOrdersAsReversalInitiated_args()
8689 
    args.read(iprot)
8690 
    iprot.readMessageEnd()
8691 
    result = markOrdersAsReversalInitiated_result()
8692 
    try:
4369 rajveer 8693 
      self._handler.markOrdersAsReversalInitiated(args.vendorId, args.itemId, args.quantity, args.estimate, args.isReminder)
4303 rajveer 8694 
    except TransactionServiceException, ex:
8695 
      result.ex = ex
8696 
    oprot.writeMessageBegin("markOrdersAsReversalInitiated", TMessageType.REPLY, seqid)
8697 
    result.write(oprot)
8698 
    oprot.writeMessageEnd()
8699 
    oprot.trans.flush()
8700 
 
8701 
  def process_markOrdersAsNotAvailabke(self, seqid, iprot, oprot):
8702 
    args = markOrdersAsNotAvailabke_args()
8703 
    args.read(iprot)
8704 
    iprot.readMessageEnd()
8705 
    result = markOrdersAsNotAvailabke_result()
8706 
    try:
4369 rajveer 8707 
      self._handler.markOrdersAsNotAvailabke(args.vendorId, args.itemId, args.quantity, args.estimate, args.isReminder)
4303 rajveer 8708 
    except TransactionServiceException, ex:
8709 
      result.ex = ex
8710 
    oprot.writeMessageBegin("markOrdersAsNotAvailabke", TMessageType.REPLY, seqid)
8711 
    result.write(oprot)
8712 
    oprot.writeMessageEnd()
8713 
    oprot.trans.flush()
8714 
 
4369 rajveer 8715 
  def process_markOrdersAsTimeout(self, seqid, iprot, oprot):
8716 
    args = markOrdersAsTimeout_args()
8717 
    args.read(iprot)
8718 
    iprot.readMessageEnd()
8719 
    result = markOrdersAsTimeout_result()
8720 
    try:
8721 
      result.success = self._handler.markOrdersAsTimeout(args.vendorId)
8722 
    except TransactionServiceException, ex:
8723 
      result.ex = ex
8724 
    oprot.writeMessageBegin("markOrdersAsTimeout", TMessageType.REPLY, seqid)
8725 
    result.write(oprot)
8726 
    oprot.writeMessageEnd()
8727 
    oprot.trans.flush()
4303 rajveer 8728 
 
4662 rajveer 8729 
  def process_markOrderAsLostInTransit(self, seqid, iprot, oprot):
8730 
    args = markOrderAsLostInTransit_args()
8731 
    args.read(iprot)
8732 
    iprot.readMessageEnd()
8733 
    result = markOrderAsLostInTransit_result()
8734 
    try:
8735 
      result.success = self._handler.markOrderAsLostInTransit(args.orderId)
8736 
    except TransactionServiceException, ex:
8737 
      result.ex = ex
8738 
    oprot.writeMessageBegin("markOrderAsLostInTransit", TMessageType.REPLY, seqid)
8739 
    result.write(oprot)
8740 
    oprot.writeMessageEnd()
8741 
    oprot.trans.flush()
8742 
 
4386 anupam.sin 8743 
  def process_getOrderForAwb(self, seqid, iprot, oprot):
8744 
    args = getOrderForAwb_args()
8745 
    args.read(iprot)
8746 
    iprot.readMessageEnd()
8747 
    result = getOrderForAwb_result()
8748 
    try:
8749 
      result.success = self._handler.getOrderForAwb(args.awb)
8750 
    except TransactionServiceException, ex:
8751 
      result.ex = ex
8752 
    oprot.writeMessageBegin("getOrderForAwb", TMessageType.REPLY, seqid)
8753 
    result.write(oprot)
8754 
    oprot.writeMessageEnd()
8755 
    oprot.trans.flush()
4369 rajveer 8756 
 
4506 phani.kuma 8757 
  def process_getOrdersForProviderForStatus(self, seqid, iprot, oprot):
8758 
    args = getOrdersForProviderForStatus_args()
8759 
    args.read(iprot)
8760 
    iprot.readMessageEnd()
8761 
    result = getOrdersForProviderForStatus_result()
8762 
    try:
4910 phani.kuma 8763 
      result.success = self._handler.getOrdersForProviderForStatus(args.logistics_provider_id, args.order_status_list)
4506 phani.kuma 8764 
    except TransactionServiceException, ex:
8765 
      result.ex = ex
8766 
    oprot.writeMessageBegin("getOrdersForProviderForStatus", TMessageType.REPLY, seqid)
8767 
    result.write(oprot)
8768 
    oprot.writeMessageEnd()
8769 
    oprot.trans.flush()
4386 anupam.sin 8770 
 
4600 varun.gupt 8771 
  def process_getBilledOrdersForVendor(self, seqid, iprot, oprot):
8772 
    args = getBilledOrdersForVendor_args()
8773 
    args.read(iprot)
8774 
    iprot.readMessageEnd()
8775 
    result = getBilledOrdersForVendor_result()
8776 
    try:
8777 
      result.success = self._handler.getBilledOrdersForVendor(args.vendorId, args.billingDateFrom, args.billingDateTo)
8778 
    except TransactionServiceException, ex:
8779 
      result.ex = ex
8780 
    oprot.writeMessageBegin("getBilledOrdersForVendor", TMessageType.REPLY, seqid)
8781 
    result.write(oprot)
8782 
    oprot.writeMessageEnd()
8783 
    oprot.trans.flush()
4506 phani.kuma 8784 
 
4607 rajveer 8785 
  def process_getSlippedSippingDateOrders(self, seqid, iprot, oprot):
8786 
    args = getSlippedSippingDateOrders_args()
8787 
    args.read(iprot)
8788 
    iprot.readMessageEnd()
8789 
    result = getSlippedSippingDateOrders_result()
8790 
    try:
8791 
      result.success = self._handler.getSlippedSippingDateOrders()
8792 
    except TransactionServiceException, ex:
8793 
      result.ex = ex
8794 
    oprot.writeMessageBegin("getSlippedSippingDateOrders", TMessageType.REPLY, seqid)
8795 
    result.write(oprot)
8796 
    oprot.writeMessageEnd()
8797 
    oprot.trans.flush()
8798 
 
4709 rajveer 8799 
  def process_getCancelledOrders(self, seqid, iprot, oprot):
8800 
    args = getCancelledOrders_args()
8801 
    args.read(iprot)
8802 
    iprot.readMessageEnd()
8803 
    result = getCancelledOrders_result()
8804 
    try:
8805 
      result.success = self._handler.getCancelledOrders(args.cancelDateFrom, args.cancelDateTo)
8806 
    except TransactionServiceException, ex:
8807 
      result.ex = ex
8808 
    oprot.writeMessageBegin("getCancelledOrders", TMessageType.REPLY, seqid)
8809 
    result.write(oprot)
8810 
    oprot.writeMessageEnd()
8811 
    oprot.trans.flush()
8812 
 
4600 varun.gupt 8813 
  def process_saveBluedartSettlements(self, seqid, iprot, oprot):
8814 
    args = saveBluedartSettlements_args()
8815 
    args.read(iprot)
8816 
    iprot.readMessageEnd()
8817 
    result = saveBluedartSettlements_result()
8818 
    try:
8819 
      self._handler.saveBluedartSettlements(args.mapAWBAndAmount)
8820 
    except TransactionServiceException, ex:
8821 
      result.ex = ex
8822 
    oprot.writeMessageBegin("saveBluedartSettlements", TMessageType.REPLY, seqid)
8823 
    result.write(oprot)
8824 
    oprot.writeMessageEnd()
8825 
    oprot.trans.flush()
8826 
 
8827 
  def process_savePaymentSettlements(self, seqid, iprot, oprot):
8828 
    args = savePaymentSettlements_args()
8829 
    args.read(iprot)
8830 
    iprot.readMessageEnd()
8831 
    result = savePaymentSettlements_result()
8832 
    try:
4905 varun.gupt 8833 
      self._handler.savePaymentSettlements(args.settlementDate, args.paymentGatewayId, args.referenceId, args.serviceTax, args.otherCharges, args.netCollection)
4600 varun.gupt 8834 
    except TransactionServiceException, ex:
8835 
      result.ex = ex
8836 
    oprot.writeMessageBegin("savePaymentSettlements", TMessageType.REPLY, seqid)
8837 
    result.write(oprot)
8838 
    oprot.writeMessageEnd()
8839 
    oprot.trans.flush()
8840 
 
8841 
  def process_saveEBSSettlementSummary(self, seqid, iprot, oprot):
8842 
    args = saveEBSSettlementSummary_args()
8843 
    args.read(iprot)
8844 
    iprot.readMessageEnd()
8845 
    result = saveEBSSettlementSummary_result()
8846 
    try:
8847 
      self._handler.saveEBSSettlementSummary(args.settlementId, args.settlementDate, args.transactionDateFrom, args.transactionDateTo, args.amount)
8848 
    except TransactionServiceException, ex:
8849 
      result.ex = ex
8850 
    oprot.writeMessageBegin("saveEBSSettlementSummary", TMessageType.REPLY, seqid)
8851 
    result.write(oprot)
8852 
    oprot.writeMessageEnd()
8853 
    oprot.trans.flush()
8854 
 
5386 phani.kuma 8855 
  def process_getSettlementForPrepaid(self, seqid, iprot, oprot):
8856 
    args = getSettlementForPrepaid_args()
4600 varun.gupt 8857 
    args.read(iprot)
8858 
    iprot.readMessageEnd()
5386 phani.kuma 8859 
    result = getSettlementForPrepaid_result()
4600 varun.gupt 8860 
    try:
5386 phani.kuma 8861 
      result.success = self._handler.getSettlementForPrepaid(args.referenceId, args.isRefund)
4600 varun.gupt 8862 
    except TransactionServiceException, ex:
8863 
      result.ex = ex
5386 phani.kuma 8864 
    oprot.writeMessageBegin("getSettlementForPrepaid", TMessageType.REPLY, seqid)
4600 varun.gupt 8865 
    result.write(oprot)
8866 
    oprot.writeMessageEnd()
8867 
    oprot.trans.flush()
8868 
 
5386 phani.kuma 8869 
  def process_getSettlementForCod(self, seqid, iprot, oprot):
8870 
    args = getSettlementForCod_args()
8871 
    args.read(iprot)
8872 
    iprot.readMessageEnd()
8873 
    result = getSettlementForCod_result()
8874 
    try:
8875 
      result.success = self._handler.getSettlementForCod(args.orderId, args.isRefund)
8876 
    except TransactionServiceException, ex:
8877 
      result.ex = ex
8878 
    oprot.writeMessageBegin("getSettlementForCod", TMessageType.REPLY, seqid)
8879 
    result.write(oprot)
8880 
    oprot.writeMessageEnd()
8881 
    oprot.trans.flush()
8882 
 
4600 varun.gupt 8883 
  def process_getEBSSettlementSummaries(self, seqid, iprot, oprot):
8884 
    args = getEBSSettlementSummaries_args()
8885 
    args.read(iprot)
8886 
    iprot.readMessageEnd()
8887 
    result = getEBSSettlementSummaries_result()
8888 
    try:
8889 
      result.success = self._handler.getEBSSettlementSummaries()
8890 
    except TransactionServiceException, ex:
8891 
      result.ex = ex
8892 
    oprot.writeMessageBegin("getEBSSettlementSummaries", TMessageType.REPLY, seqid)
8893 
    result.write(oprot)
8894 
    oprot.writeMessageEnd()
8895 
    oprot.trans.flush()
8896 
 
8897 
  def process_markEBSSettlementUploaded(self, seqid, iprot, oprot):
8898 
    args = markEBSSettlementUploaded_args()
8899 
    args.read(iprot)
8900 
    iprot.readMessageEnd()
8901 
    result = markEBSSettlementUploaded_result()
8902 
    try:
8903 
      self._handler.markEBSSettlementUploaded(args.settlementId)
8904 
    except TransactionServiceException, ex:
8905 
      result.ex = ex
8906 
    oprot.writeMessageBegin("markEBSSettlementUploaded", TMessageType.REPLY, seqid)
8907 
    result.write(oprot)
8908 
    oprot.writeMessageEnd()
8909 
    oprot.trans.flush()
8910 
 
8911 
  def process_getEBSSettlementDate(self, seqid, iprot, oprot):
8912 
    args = getEBSSettlementDate_args()
8913 
    args.read(iprot)
8914 
    iprot.readMessageEnd()
8915 
    result = getEBSSettlementDate_result()
8916 
    try:
8917 
      result.success = self._handler.getEBSSettlementDate(args.settlementId)
8918 
    except TransactionServiceException, ex:
8919 
      result.ex = ex
8920 
    oprot.writeMessageBegin("getEBSSettlementDate", TMessageType.REPLY, seqid)
8921 
    result.write(oprot)
8922 
    oprot.writeMessageEnd()
8923 
    oprot.trans.flush()
8924 
 
4715 varun.gupt 8925 
  def process_getSettlementsByDate(self, seqid, iprot, oprot):
8926 
    args = getSettlementsByDate_args()
8927 
    args.read(iprot)
8928 
    iprot.readMessageEnd()
8929 
    result = getSettlementsByDate_result()
8930 
    try:
8931 
      result.success = self._handler.getSettlementsByDate(args.settlementDateFrom, args.settlementDateTo, args.isRefund)
8932 
    except TransactionServiceException, ex:
8933 
      result.ex = ex
8934 
    oprot.writeMessageBegin("getSettlementsByDate", TMessageType.REPLY, seqid)
8935 
    result.write(oprot)
8936 
    oprot.writeMessageEnd()
8937 
    oprot.trans.flush()
4600 varun.gupt 8938 
 
4715 varun.gupt 8939 
  def process_getReshippedOrderIds(self, seqid, iprot, oprot):
8940 
    args = getReshippedOrderIds_args()
8941 
    args.read(iprot)
8942 
    iprot.readMessageEnd()
8943 
    result = getReshippedOrderIds_result()
8944 
    try:
8945 
      result.success = self._handler.getReshippedOrderIds(args.orderIds)
8946 
    except TransactionServiceException, ex:
8947 
      result.ex = ex
8948 
    oprot.writeMessageBegin("getReshippedOrderIds", TMessageType.REPLY, seqid)
8949 
    result.write(oprot)
8950 
    oprot.writeMessageEnd()
8951 
    oprot.trans.flush()
8952 
 
5481 phani.kuma 8953 
  def process_getBilledOrders(self, seqid, iprot, oprot):
8954 
    args = getBilledOrders_args()
4875 varun.gupt 8955 
    args.read(iprot)
8956 
    iprot.readMessageEnd()
5481 phani.kuma 8957 
    result = getBilledOrders_result()
4875 varun.gupt 8958 
    try:
5481 phani.kuma 8959 
      result.success = self._handler.getBilledOrders(args.vendorId, args.onlyVendorNotPaid, args.billingDateFrom, args.billingDateTo)
4875 varun.gupt 8960 
    except TransactionServiceException, ex:
8961 
      result.ex = ex
5481 phani.kuma 8962 
    oprot.writeMessageBegin("getBilledOrders", TMessageType.REPLY, seqid)
4875 varun.gupt 8963 
    result.write(oprot)
8964 
    oprot.writeMessageEnd()
8965 
    oprot.trans.flush()
4757 mandeep.dh 8966 
 
5031 varun.gupt 8967 
  def process_getStatusDistributionOfOrders(self, seqid, iprot, oprot):
8968 
    args = getStatusDistributionOfOrders_args()
8969 
    args.read(iprot)
8970 
    iprot.readMessageEnd()
8971 
    result = getStatusDistributionOfOrders_result()
8972 
    try:
8973 
      result.success = self._handler.getStatusDistributionOfOrders(args.startDate, args.endDate)
8974 
    except TransactionServiceException, ex:
8975 
      result.ex = ex
8976 
    oprot.writeMessageBegin("getStatusDistributionOfOrders", TMessageType.REPLY, seqid)
8977 
    result.write(oprot)
8978 
    oprot.writeMessageEnd()
8979 
    oprot.trans.flush()
4875 varun.gupt 8980 
 
5067 varun.gupt 8981 
  def process_getOrderIdsForStatus(self, seqid, iprot, oprot):
8982 
    args = getOrderIdsForStatus_args()
8983 
    args.read(iprot)
8984 
    iprot.readMessageEnd()
8985 
    result = getOrderIdsForStatus_result()
8986 
    try:
8987 
      result.success = self._handler.getOrderIdsForStatus(args.status, args.startDatetime, args.endDatetime)
8988 
    except TransactionServiceException, ex:
8989 
      result.ex = ex
8990 
    oprot.writeMessageBegin("getOrderIdsForStatus", TMessageType.REPLY, seqid)
8991 
    result.write(oprot)
8992 
    oprot.writeMessageEnd()
8993 
    oprot.trans.flush()
5031 varun.gupt 8994 
 
5348 anupam.sin 8995 
  def process_updateCODAgent(self, seqid, iprot, oprot):
8996 
    args = updateCODAgent_args()
8997 
    args.read(iprot)
8998 
    iprot.readMessageEnd()
8999 
    result = updateCODAgent_result()
9000 
    try:
9001 
      self._handler.updateCODAgent(args.agent, args.orderId)
9002 
    except TransactionServiceException, ex:
9003 
      result.ex = ex
9004 
    oprot.writeMessageBegin("updateCODAgent", TMessageType.REPLY, seqid)
9005 
    result.write(oprot)
9006 
    oprot.writeMessageEnd()
9007 
    oprot.trans.flush()
9008 
 
5099 varun.gupt 9009 
  def process_updateOrderAsPaidToVendor(self, seqid, iprot, oprot):
9010 
    args = updateOrderAsPaidToVendor_args()
9011 
    args.read(iprot)
9012 
    iprot.readMessageEnd()
9013 
    result = updateOrderAsPaidToVendor_result()
9014 
    try:
9015 
      self._handler.updateOrderAsPaidToVendor(args.orderId)
9016 
    except TransactionServiceException, ex:
9017 
      result.ex = ex
9018 
    oprot.writeMessageBegin("updateOrderAsPaidToVendor", TMessageType.REPLY, seqid)
9019 
    result.write(oprot)
9020 
    oprot.writeMessageEnd()
9021 
    oprot.trans.flush()
5067 varun.gupt 9022 
 
5386 phani.kuma 9023 
  def process_updateOrderOnlyAsPaidToVendor(self, seqid, iprot, oprot):
9024 
    args = updateOrderOnlyAsPaidToVendor_args()
9025 
    args.read(iprot)
9026 
    iprot.readMessageEnd()
9027 
    result = updateOrderOnlyAsPaidToVendor_result()
9028 
    try:
9029 
      self._handler.updateOrderOnlyAsPaidToVendor(args.orderId)
9030 
    except TransactionServiceException, ex:
9031 
      result.ex = ex
9032 
    oprot.writeMessageBegin("updateOrderOnlyAsPaidToVendor", TMessageType.REPLY, seqid)
9033 
    result.write(oprot)
9034 
    oprot.writeMessageEnd()
9035 
    oprot.trans.flush()
9036 
 
5208 varun.gupt 9037 
  def process_getRefundedOrdersMarkedPaid(self, seqid, iprot, oprot):
9038 
    args = getRefundedOrdersMarkedPaid_args()
9039 
    args.read(iprot)
9040 
    iprot.readMessageEnd()
9041 
    result = getRefundedOrdersMarkedPaid_result()
9042 
    try:
9043 
      result.success = self._handler.getRefundedOrdersMarkedPaid()
9044 
    except TransactionServiceException, ex:
9045 
      result.ex = ex
9046 
    oprot.writeMessageBegin("getRefundedOrdersMarkedPaid", TMessageType.REPLY, seqid)
9047 
    result.write(oprot)
9048 
    oprot.writeMessageEnd()
9049 
    oprot.trans.flush()
5099 varun.gupt 9050 
 
5447 anupam.sin 9051 
  def process_getAllVerificationAgents(self, seqid, iprot, oprot):
9052 
    args = getAllVerificationAgents_args()
9053 
    args.read(iprot)
9054 
    iprot.readMessageEnd()
9055 
    result = getAllVerificationAgents_result()
9056 
    result.success = self._handler.getAllVerificationAgents(args.minOrderId, args.maxOrderId)
9057 
    oprot.writeMessageBegin("getAllVerificationAgents", TMessageType.REPLY, seqid)
9058 
    result.write(oprot)
9059 
    oprot.writeMessageEnd()
9060 
    oprot.trans.flush()
5208 varun.gupt 9061 
 
5527 anupam.sin 9062 
  def process_getAllAttributesForOrderId(self, seqid, iprot, oprot):
9063 
    args = getAllAttributesForOrderId_args()
9064 
    args.read(iprot)
9065 
    iprot.readMessageEnd()
9066 
    result = getAllAttributesForOrderId_result()
9067 
    result.success = self._handler.getAllAttributesForOrderId(args.orderId)
9068 
    oprot.writeMessageBegin("getAllAttributesForOrderId", TMessageType.REPLY, seqid)
9069 
    result.write(oprot)
9070 
    oprot.writeMessageEnd()
9071 
    oprot.trans.flush()
5447 anupam.sin 9072 
 
5676 rajveer 9073 
  def process_setOrderAttributes(self, seqid, iprot, oprot):
9074 
    args = setOrderAttributes_args()
9075 
    args.read(iprot)
9076 
    iprot.readMessageEnd()
9077 
    result = setOrderAttributes_result()
9078 
    self._handler.setOrderAttributes(args.orderId, args.attributes)
9079 
    oprot.writeMessageBegin("setOrderAttributes", TMessageType.REPLY, seqid)
9080 
    result.write(oprot)
9081 
    oprot.writeMessageEnd()
9082 
    oprot.trans.flush()
9083 
 
5527 anupam.sin 9084 
  def process_setOrderAttributeForTransaction(self, seqid, iprot, oprot):
9085 
    args = setOrderAttributeForTransaction_args()
9086 
    args.read(iprot)
9087 
    iprot.readMessageEnd()
9088 
    result = setOrderAttributeForTransaction_result()
9089 
    self._handler.setOrderAttributeForTransaction(args.transactionId, args.attribute)
9090 
    oprot.writeMessageBegin("setOrderAttributeForTransaction", TMessageType.REPLY, seqid)
9091 
    result.write(oprot)
9092 
    oprot.writeMessageEnd()
9093 
    oprot.trans.flush()
9094 
 
5553 rajveer 9095 
  def process_getReceivePendingOrders(self, seqid, iprot, oprot):
9096 
    args = getReceivePendingOrders_args()
9097 
    args.read(iprot)
9098 
    iprot.readMessageEnd()
9099 
    result = getReceivePendingOrders_result()
9100 
    result.success = self._handler.getReceivePendingOrders(args.storeId)
9101 
    oprot.writeMessageBegin("getReceivePendingOrders", TMessageType.REPLY, seqid)
9102 
    result.write(oprot)
9103 
    oprot.writeMessageEnd()
9104 
    oprot.trans.flush()
5527 anupam.sin 9105 
 
5553 rajveer 9106 
  def process_getReceivedAtStoreOrders(self, seqid, iprot, oprot):
9107 
    args = getReceivedAtStoreOrders_args()
9108 
    args.read(iprot)
9109 
    iprot.readMessageEnd()
9110 
    result = getReceivedAtStoreOrders_result()
9111 
    result.success = self._handler.getReceivedAtStoreOrders(args.storeId)
9112 
    oprot.writeMessageBegin("getReceivedAtStoreOrders", TMessageType.REPLY, seqid)
9113 
    result.write(oprot)
9114 
    oprot.writeMessageEnd()
9115 
    oprot.trans.flush()
9116 
 
5713 rajveer 9117 
  def process_getOrdersCollectionAtStore(self, seqid, iprot, oprot):
9118 
    args = getOrdersCollectionAtStore_args()
9119 
    args.read(iprot)
9120 
    iprot.readMessageEnd()
9121 
    result = getOrdersCollectionAtStore_result()
9122 
    result.success = self._handler.getOrdersCollectionAtStore(args.storeId, args.fromDate, args.toDate, args.onlyCod)
9123 
    oprot.writeMessageBegin("getOrdersCollectionAtStore", TMessageType.REPLY, seqid)
9124 
    result.write(oprot)
9125 
    oprot.writeMessageEnd()
9126 
    oprot.trans.flush()
9127 
 
5833 rajveer 9128 
  def process_getOrderAttributeValue(self, seqid, iprot, oprot):
9129 
    args = getOrderAttributeValue_args()
9130 
    args.read(iprot)
9131 
    iprot.readMessageEnd()
9132 
    result = getOrderAttributeValue_result()
9133 
    result.success = self._handler.getOrderAttributeValue(args.orderId, args.attributeName)
9134 
    oprot.writeMessageBegin("getOrderAttributeValue", TMessageType.REPLY, seqid)
9135 
    result.write(oprot)
9136 
    oprot.writeMessageEnd()
9137 
    oprot.trans.flush()
9138 
 
6019 rajveer 9139 
  def process_changeJacketNumber(self, seqid, iprot, oprot):
9140 
    args = changeJacketNumber_args()
9141 
    args.read(iprot)
9142 
    iprot.readMessageEnd()
9143 
    result = changeJacketNumber_result()
9144 
    result.success = self._handler.changeJacketNumber(args.orderId, args.jacketNumber)
9145 
    oprot.writeMessageBegin("changeJacketNumber", TMessageType.REPLY, seqid)
9146 
    result.write(oprot)
9147 
    oprot.writeMessageEnd()
9148 
    oprot.trans.flush()
9149 
 
9150 
  def process_markOrderAsRtoInTransit(self, seqid, iprot, oprot):
9151 
    args = markOrderAsRtoInTransit_args()
9152 
    args.read(iprot)
9153 
    iprot.readMessageEnd()
9154 
    result = markOrderAsRtoInTransit_result()
9155 
    result.success = self._handler.markOrderAsRtoInTransit(args.orderId)
9156 
    oprot.writeMessageBegin("markOrderAsRtoInTransit", TMessageType.REPLY, seqid)
9157 
    result.write(oprot)
9158 
    oprot.writeMessageEnd()
9159 
    oprot.trans.flush()
9160 
 
5593 mandeep.dh 9161 
  def process_acceptOrderForItem(self, seqid, iprot, oprot):
9162 
    args = acceptOrderForItem_args()
9163 
    args.read(iprot)
9164 
    iprot.readMessageEnd()
9165 
    result = acceptOrderForItem_result()
9166 
    self._handler.acceptOrderForItem(args.itemId, args.quantity, args.fulfilmentWarehouseId, args.billingWarehouseId)
9167 
    oprot.writeMessageBegin("acceptOrderForItem", TMessageType.REPLY, seqid)
9168 
    result.write(oprot)
9169 
    oprot.writeMessageEnd()
9170 
    oprot.trans.flush()
5553 rajveer 9171 
 
6000 mandeep.dh 9172 
  def process_createRechargeOrder(self, seqid, iprot, oprot):
9173 
    args = createRechargeOrder_args()
9174 
    args.read(iprot)
9175 
    iprot.readMessageEnd()
9176 
    result = createRechargeOrder_result()
9177 
    try:
9178 
      result.success = self._handler.createRechargeOrder(args.rechargeOrder)
9179 
    except TransactionServiceException, ex:
9180 
      result.ex = ex
9181 
    oprot.writeMessageBegin("createRechargeOrder", TMessageType.REPLY, seqid)
9182 
    result.write(oprot)
9183 
    oprot.writeMessageEnd()
9184 
    oprot.trans.flush()
5593 mandeep.dh 9185 
 
6031 rajveer 9186 
  def process_getRechargeOrder(self, seqid, iprot, oprot):
9187 
    args = getRechargeOrder_args()
9188 
    args.read(iprot)
9189 
    iprot.readMessageEnd()
9190 
    result = getRechargeOrder_result()
9191 
    try:
9192 
      result.success = self._handler.getRechargeOrder(args.rechargeRrderId)
9193 
    except TransactionServiceException, ex:
9194 
      result.ex = ex
9195 
    oprot.writeMessageBegin("getRechargeOrder", TMessageType.REPLY, seqid)
9196 
    result.write(oprot)
9197 
    oprot.writeMessageEnd()
9198 
    oprot.trans.flush()
9199 
 
9200 
  def process_getRechargeOrders(self, seqid, iprot, oprot):
9201 
    args = getRechargeOrders_args()
9202 
    args.read(iprot)
9203 
    iprot.readMessageEnd()
9204 
    result = getRechargeOrders_result()
9205 
    result.success = self._handler.getRechargeOrders(args.userId)
9206 
    oprot.writeMessageBegin("getRechargeOrders", TMessageType.REPLY, seqid)
9207 
    result.write(oprot)
9208 
    oprot.writeMessageEnd()
9209 
    oprot.trans.flush()
9210 
 
6000 mandeep.dh 9211 
  def process_updateRechargeOrderStatus(self, seqid, iprot, oprot):
9212 
    args = updateRechargeOrderStatus_args()
9213 
    args.read(iprot)
9214 
    iprot.readMessageEnd()
9215 
    result = updateRechargeOrderStatus_result()
9216 
    try:
6031 rajveer 9217 
      result.success = self._handler.updateRechargeOrderStatus(args.rechargeOrderId, args.rechargeOrderStatus)
6000 mandeep.dh 9218 
    except TransactionServiceException, ex:
9219 
      result.ex = ex
9220 
    oprot.writeMessageBegin("updateRechargeOrderStatus", TMessageType.REPLY, seqid)
9221 
    result.write(oprot)
9222 
    oprot.writeMessageEnd()
9223 
    oprot.trans.flush()
9224 
 
9225 
  def process_activateRechargeTxn(self, seqid, iprot, oprot):
9226 
    args = activateRechargeTxn_args()
9227 
    args.read(iprot)
9228 
    iprot.readMessageEnd()
9229 
    result = activateRechargeTxn_result()
9230 
    try:
6031 rajveer 9231 
      result.success = self._handler.activateRechargeTxn(args.rechargeOrderId)
6000 mandeep.dh 9232 
    except TransactionServiceException, ex:
9233 
      result.ex = ex
9234 
    oprot.writeMessageBegin("activateRechargeTxn", TMessageType.REPLY, seqid)
9235 
    result.write(oprot)
9236 
    oprot.writeMessageEnd()
9237 
    oprot.trans.flush()
9238 
 
6031 rajveer 9239 
  def process_getUserWallet(self, seqid, iprot, oprot):
9240 
    args = getUserWallet_args()
6000 mandeep.dh 9241 
    args.read(iprot)
9242 
    iprot.readMessageEnd()
6031 rajveer 9243 
    result = getUserWallet_result()
9244 
    result.success = self._handler.getUserWallet(args.userId)
9245 
    oprot.writeMessageBegin("getUserWallet", TMessageType.REPLY, seqid)
6000 mandeep.dh 9246 
    result.write(oprot)
9247 
    oprot.writeMessageEnd()
9248 
    oprot.trans.flush()
9249 
 
6031 rajveer 9250 
  def process_getUserWalletHistory(self, seqid, iprot, oprot):
9251 
    args = getUserWalletHistory_args()
6000 mandeep.dh 9252 
    args.read(iprot)
9253 
    iprot.readMessageEnd()
6031 rajveer 9254 
    result = getUserWalletHistory_result()
9255 
    result.success = self._handler.getUserWalletHistory(args.userId)
9256 
    oprot.writeMessageBegin("getUserWalletHistory", TMessageType.REPLY, seqid)
6000 mandeep.dh 9257 
    result.write(oprot)
9258 
    oprot.writeMessageEnd()
9259 
    oprot.trans.flush()
9260 
 
6050 anupam.sin 9261 
  def process_getRechargeOrdersForTransaction(self, seqid, iprot, oprot):
9262 
    args = getRechargeOrdersForTransaction_args()
9263 
    args.read(iprot)
9264 
    iprot.readMessageEnd()
9265 
    result = getRechargeOrdersForTransaction_result()
9266 
    try:
9267 
      result.success = self._handler.getRechargeOrdersForTransaction(args.txnId)
9268 
    except TransactionServiceException, ex:
9269 
      result.ex = ex
9270 
    oprot.writeMessageBegin("getRechargeOrdersForTransaction", TMessageType.REPLY, seqid)
9271 
    result.write(oprot)
9272 
    oprot.writeMessageEnd()
9273 
    oprot.trans.flush()
9274 
 
6048 rajveer 9275 
  def process_getServiceProviders(self, seqid, iprot, oprot):
9276 
    args = getServiceProviders_args()
9277 
    args.read(iprot)
9278 
    iprot.readMessageEnd()
9279 
    result = getServiceProviders_result()
6206 rajveer 9280 
    result.success = self._handler.getServiceProviders(args.rechargeType, args.onlyActive)
6048 rajveer 9281 
    oprot.writeMessageBegin("getServiceProviders", TMessageType.REPLY, seqid)
9282 
    result.write(oprot)
9283 
    oprot.writeMessageEnd()
9284 
    oprot.trans.flush()
6000 mandeep.dh 9285 
 
6048 rajveer 9286 
  def process_getServiceProviderForDevice(self, seqid, iprot, oprot):
9287 
    args = getServiceProviderForDevice_args()
9288 
    args.read(iprot)
9289 
    iprot.readMessageEnd()
9290 
    result = getServiceProviderForDevice_result()
6049 rajveer 9291 
    result.success = self._handler.getServiceProviderForDevice(args.rechargeType, args.deviceNumber)
6048 rajveer 9292 
    oprot.writeMessageBegin("getServiceProviderForDevice", TMessageType.REPLY, seqid)
9293 
    result.write(oprot)
9294 
    oprot.writeMessageEnd()
9295 
    oprot.trans.flush()
9296 
 
6269 rajveer 9297 
  def process_validateRecharge(self, seqid, iprot, oprot):
9298 
    args = validateRecharge_args()
9299 
    args.read(iprot)
9300 
    iprot.readMessageEnd()
9301 
    result = validateRecharge_result()
6591 anupam.sin 9302 
    result.success = self._handler.validateRecharge(args.rechargeType, args.deviceNumber, args.userSelectedProviderId, args.clientAddress)
6269 rajveer 9303 
    oprot.writeMessageBegin("validateRecharge", TMessageType.REPLY, seqid)
9304 
    result.write(oprot)
9305 
    oprot.writeMessageEnd()
9306 
    oprot.trans.flush()
9307 
 
6094 rajveer 9308 
  def process_getRechargeOrdersForDevice(self, seqid, iprot, oprot):
9309 
    args = getRechargeOrdersForDevice_args()
9310 
    args.read(iprot)
9311 
    iprot.readMessageEnd()
9312 
    result = getRechargeOrdersForDevice_result()
9313 
    result.success = self._handler.getRechargeOrdersForDevice(args.deviceNumber)
9314 
    oprot.writeMessageBegin("getRechargeOrdersForDevice", TMessageType.REPLY, seqid)
9315 
    result.write(oprot)
9316 
    oprot.writeMessageEnd()
9317 
    oprot.trans.flush()
6048 rajveer 9318 
 
6094 rajveer 9319 
  def process_addAmountToWallet(self, seqid, iprot, oprot):
9320 
    args = addAmountToWallet_args()
9321 
    args.read(iprot)
9322 
    iprot.readMessageEnd()
9323 
    result = addAmountToWallet_result()
9324 
    self._handler.addAmountToWallet(args.userId, args.orderId, args.amount)
9325 
    oprot.writeMessageBegin("addAmountToWallet", TMessageType.REPLY, seqid)
9326 
    result.write(oprot)
9327 
    oprot.writeMessageEnd()
9328 
    oprot.trans.flush()
9329 
 
6188 rajveer 9330 
  def process_getRechargeStatistics(self, seqid, iprot, oprot):
9331 
    args = getRechargeStatistics_args()
9332 
    args.read(iprot)
9333 
    iprot.readMessageEnd()
9334 
    result = getRechargeStatistics_result()
9335 
    result.success = self._handler.getRechargeStatistics()
9336 
    oprot.writeMessageBegin("getRechargeStatistics", TMessageType.REPLY, seqid)
9337 
    result.write(oprot)
9338 
    oprot.writeMessageEnd()
9339 
    oprot.trans.flush()
9340 
 
6154 rajveer 9341 
  def process_getRechargeOrdersForStatus(self, seqid, iprot, oprot):
9342 
    args = getRechargeOrdersForStatus_args()
9343 
    args.read(iprot)
9344 
    iprot.readMessageEnd()
9345 
    result = getRechargeOrdersForStatus_result()
9346 
    result.success = self._handler.getRechargeOrdersForStatus(args.status)
9347 
    oprot.writeMessageBegin("getRechargeOrdersForStatus", TMessageType.REPLY, seqid)
9348 
    result.write(oprot)
9349 
    oprot.writeMessageEnd()
9350 
    oprot.trans.flush()
6094 rajveer 9351 
 
6159 rajveer 9352 
  def process_getPlansForOperator(self, seqid, iprot, oprot):
9353 
    args = getPlansForOperator_args()
9354 
    args.read(iprot)
9355 
    iprot.readMessageEnd()
9356 
    result = getPlansForOperator_result()
9357 
    result.success = self._handler.getPlansForOperator(args.operatorId)
9358 
    oprot.writeMessageBegin("getPlansForOperator", TMessageType.REPLY, seqid)
9359 
    result.write(oprot)
9360 
    oprot.writeMessageEnd()
9361 
    oprot.trans.flush()
6154 rajveer 9362 
 
6289 anupam.sin 9363 
  def process_getRechargeDenominations(self, seqid, iprot, oprot):
9364 
    args = getRechargeDenominations_args()
9365 
    args.read(iprot)
9366 
    iprot.readMessageEnd()
9367 
    result = getRechargeDenominations_result()
9368 
    try:
6307 anupam.sin 9369 
      result.success = self._handler.getRechargeDenominations(args.operatorId, args.circleCode, args.denominationType)
6289 anupam.sin 9370 
    except TransactionServiceException, ex:
9371 
      result.ex = ex
9372 
    oprot.writeMessageBegin("getRechargeDenominations", TMessageType.REPLY, seqid)
9373 
    result.write(oprot)
9374 
    oprot.writeMessageEnd()
9375 
    oprot.trans.flush()
6159 rajveer 9376 
 
6371 rajveer 9377 
  def process_updateAvailabilityStatus(self, seqid, iprot, oprot):
9378 
    args = updateAvailabilityStatus_args()
9379 
    args.read(iprot)
9380 
    iprot.readMessageEnd()
9381 
    result = updateAvailabilityStatus_result()
9382 
    self._handler.updateAvailabilityStatus(args.operatorId, args.circleId, args.isAvailable)
9383 
    oprot.writeMessageBegin("updateAvailabilityStatus", TMessageType.REPLY, seqid)
9384 
    result.write(oprot)
9385 
    oprot.writeMessageEnd()
9386 
    oprot.trans.flush()
6289 anupam.sin 9387 
 
6389 rajveer 9388 
  def process_getAvailableEmiSchemes(self, seqid, iprot, oprot):
9389 
    args = getAvailableEmiSchemes_args()
9390 
    args.read(iprot)
9391 
    iprot.readMessageEnd()
9392 
    result = getAvailableEmiSchemes_result()
9393 
    result.success = self._handler.getAvailableEmiSchemes()
9394 
    oprot.writeMessageBegin("getAvailableEmiSchemes", TMessageType.REPLY, seqid)
9395 
    result.write(oprot)
9396 
    oprot.writeMessageEnd()
9397 
    oprot.trans.flush()
6371 rajveer 9398 
 
6389 rajveer 9399 
  def process_getMiscCharges(self, seqid, iprot, oprot):
9400 
    args = getMiscCharges_args()
9401 
    args.read(iprot)
9402 
    iprot.readMessageEnd()
9403 
    result = getMiscCharges_result()
9404 
    result.success = self._handler.getMiscCharges(args.transactionId)
9405 
    oprot.writeMessageBegin("getMiscCharges", TMessageType.REPLY, seqid)
9406 
    result.write(oprot)
9407 
    oprot.writeMessageEnd()
9408 
    oprot.trans.flush()
9409 
 
6507 anupam.sin 9410 
  def process_refundRechargeOrder(self, seqid, iprot, oprot):
9411 
    args = refundRechargeOrder_args()
9412 
    args.read(iprot)
9413 
    iprot.readMessageEnd()
9414 
    result = refundRechargeOrder_result()
9415 
    try:
9416 
      result.success = self._handler.refundRechargeOrder(args.rechargeOrderId)
9417 
    except TransactionServiceException, ex:
9418 
      result.ex = ex
9419 
    oprot.writeMessageBegin("refundRechargeOrder", TMessageType.REPLY, seqid)
9420 
    result.write(oprot)
9421 
    oprot.writeMessageEnd()
9422 
    oprot.trans.flush()
6389 rajveer 9423 
 
6821 amar.kumar 9424 
  def process_getPhysicalOrders(self, seqid, iprot, oprot):
9425 
    args = getPhysicalOrders_args()
9426 
    args.read(iprot)
9427 
    iprot.readMessageEnd()
9428 
    result = getPhysicalOrders_result()
9429 
    result.success = self._handler.getPhysicalOrders(args.fromDate, args.toDate)
9430 
    oprot.writeMessageBegin("getPhysicalOrders", TMessageType.REPLY, seqid)
9431 
    result.write(oprot)
9432 
    oprot.writeMessageEnd()
9433 
    oprot.trans.flush()
6507 anupam.sin 9434 
 
6906 rajveer 9435 
  def process_getDocument(self, seqid, iprot, oprot):
9436 
    args = getDocument_args()
9437 
    args.read(iprot)
9438 
    iprot.readMessageEnd()
9439 
    result = getDocument_result()
9440 
    result.success = self._handler.getDocument(args.docType, args.docSource)
9441 
    oprot.writeMessageBegin("getDocument", TMessageType.REPLY, seqid)
9442 
    result.write(oprot)
9443 
    oprot.writeMessageEnd()
9444 
    oprot.trans.flush()
6821 amar.kumar 9445 
 
6985 anupam.sin 9446 
  def process_changeShippingAddress(self, seqid, iprot, oprot):
9447 
    args = changeShippingAddress_args()
9448 
    args.read(iprot)
9449 
    iprot.readMessageEnd()
9450 
    result = changeShippingAddress_result()
9451 
    result.success = self._handler.changeShippingAddress(args.orderId, args.line1, args.line2, args.city, args.state, args.pin)
9452 
    oprot.writeMessageBegin("changeShippingAddress", TMessageType.REPLY, seqid)
9453 
    result.write(oprot)
9454 
    oprot.writeMessageEnd()
9455 
    oprot.trans.flush()
6906 rajveer 9456 
 
6988 rajveer 9457 
  def process_retrieveInvoice(self, seqid, iprot, oprot):
9458 
    args = retrieveInvoice_args()
9459 
    args.read(iprot)
9460 
    iprot.readMessageEnd()
9461 
    result = retrieveInvoice_result()
7075 rajveer 9462 
    result.success = self._handler.retrieveInvoice(args.orderId, args.userId)
6988 rajveer 9463 
    oprot.writeMessageBegin("retrieveInvoice", TMessageType.REPLY, seqid)
9464 
    result.write(oprot)
9465 
    oprot.writeMessageEnd()
9466 
    oprot.trans.flush()
6985 anupam.sin 9467 
 
7026 rajveer 9468 
  def process_receiveUpdatesForRedExpress(self, seqid, iprot, oprot):
9469 
    args = receiveUpdatesForRedExpress_args()
9470 
    args.read(iprot)
9471 
    iprot.readMessageEnd()
9472 
    result = receiveUpdatesForRedExpress_result()
9473 
    result.success = self._handler.receiveUpdatesForRedExpress(args.awbNumber)
9474 
    oprot.writeMessageBegin("receiveUpdatesForRedExpress", TMessageType.REPLY, seqid)
9475 
    result.write(oprot)
9476 
    oprot.writeMessageEnd()
9477 
    oprot.trans.flush()
6988 rajveer 9478 
 
7073 anupam.sin 9479 
  def process_createRechargeTransaction(self, seqid, iprot, oprot):
9480 
    args = createRechargeTransaction_args()
9481 
    args.read(iprot)
9482 
    iprot.readMessageEnd()
9483 
    result = createRechargeTransaction_result()
9484 
    result.success = self._handler.createRechargeTransaction(args.thriftRechargeTransaction)
9485 
    oprot.writeMessageBegin("createRechargeTransaction", TMessageType.REPLY, seqid)
9486 
    result.write(oprot)
9487 
    oprot.writeMessageEnd()
9488 
    oprot.trans.flush()
7026 rajveer 9489 
 
7085 rajveer 9490 
  def process_getRechargeTransactions(self, seqid, iprot, oprot):
9491 
    args = getRechargeTransactions_args()
9492 
    args.read(iprot)
9493 
    iprot.readMessageEnd()
9494 
    result = getRechargeTransactions_result()
9495 
    result.success = self._handler.getRechargeTransactions(args.storeId)
9496 
    oprot.writeMessageBegin("getRechargeTransactions", TMessageType.REPLY, seqid)
9497 
    result.write(oprot)
9498 
    oprot.writeMessageEnd()
9499 
    oprot.trans.flush()
9500 
 
7151 amit.gupta 9501 
  def process_getRechargeTrans(self, seqid, iprot, oprot):
9502 
    args = getRechargeTrans_args()
9503 
    args.read(iprot)
9504 
    iprot.readMessageEnd()
9505 
    result = getRechargeTrans_result()
9506 
    result.success = self._handler.getRechargeTrans(args.storeId, args.startDate, args.endDate, args.status)
9507 
    oprot.writeMessageBegin("getRechargeTrans", TMessageType.REPLY, seqid)
9508 
    result.write(oprot)
9509 
    oprot.writeMessageEnd()
9510 
    oprot.trans.flush()
9511 
 
7080 anupam.sin 9512 
  def process_getRechargeTransaction(self, seqid, iprot, oprot):
9513 
    args = getRechargeTransaction_args()
9514 
    args.read(iprot)
9515 
    iprot.readMessageEnd()
9516 
    result = getRechargeTransaction_result()
9517 
    result.success = self._handler.getRechargeTransaction(args.rechargeId)
9518 
    oprot.writeMessageBegin("getRechargeTransaction", TMessageType.REPLY, seqid)
9519 
    result.write(oprot)
9520 
    oprot.writeMessageEnd()
9521 
    oprot.trans.flush()
7073 anupam.sin 9522 
 
7080 anupam.sin 9523 
  def process_getFRCs(self, seqid, iprot, oprot):
9524 
    args = getFRCs_args()
9525 
    args.read(iprot)
9526 
    iprot.readMessageEnd()
9527 
    result = getFRCs_result()
9528 
    result.success = self._handler.getFRCs(args.circleId, args.operatorId)
9529 
    oprot.writeMessageBegin("getFRCs", TMessageType.REPLY, seqid)
9530 
    result.write(oprot)
9531 
    oprot.writeMessageEnd()
9532 
    oprot.trans.flush()
9533 
 
7096 anupam.sin 9534 
  def process_getHotspotStore(self, seqid, iprot, oprot):
9535 
    args = getHotspotStore_args()
9536 
    args.read(iprot)
9537 
    iprot.readMessageEnd()
9538 
    result = getHotspotStore_result()
9539 
    result.success = self._handler.getHotspotStore(args.id, args.hotspotid)
9540 
    oprot.writeMessageBegin("getHotspotStore", TMessageType.REPLY, seqid)
9541 
    result.write(oprot)
9542 
    oprot.writeMessageEnd()
9543 
    oprot.trans.flush()
7080 anupam.sin 9544 
 
7096 anupam.sin 9545 
  def process_getTelecomCircle(self, seqid, iprot, oprot):
9546 
    args = getTelecomCircle_args()
9547 
    args.read(iprot)
9548 
    iprot.readMessageEnd()
9549 
    result = getTelecomCircle_result()
9550 
    result.success = self._handler.getTelecomCircle(args.id, args.code)
9551 
    oprot.writeMessageBegin("getTelecomCircle", TMessageType.REPLY, seqid)
9552 
    result.write(oprot)
9553 
    oprot.writeMessageEnd()
9554 
    oprot.trans.flush()
9555 
 
7109 anupam.sin 9556 
  def process_retrieveHotspotRechargeInvoice(self, seqid, iprot, oprot):
9557 
    args = retrieveHotspotRechargeInvoice_args()
9558 
    args.read(iprot)
9559 
    iprot.readMessageEnd()
9560 
    result = retrieveHotspotRechargeInvoice_result()
9561 
    result.success = self._handler.retrieveHotspotRechargeInvoice(args.rechargeId)
9562 
    oprot.writeMessageBegin("retrieveHotspotRechargeInvoice", TMessageType.REPLY, seqid)
9563 
    result.write(oprot)
9564 
    oprot.writeMessageEnd()
9565 
    oprot.trans.flush()
7096 anupam.sin 9566 
 
7190 amar.kumar 9567 
  def process_splitFreebieOrder(self, seqid, iprot, oprot):
9568 
    args = splitFreebieOrder_args()
9569 
    args.read(iprot)
9570 
    iprot.readMessageEnd()
9571 
    result = splitFreebieOrder_result()
9572 
    result.success = self._handler.splitFreebieOrder(args.orderId, args.splitReason, args.shippingDate)
9573 
    oprot.writeMessageBegin("splitFreebieOrder", TMessageType.REPLY, seqid)
9574 
    result.write(oprot)
9575 
    oprot.writeMessageEnd()
9576 
    oprot.trans.flush()
9577 
 
7169 anupam.sin 9578 
  def process_getRechargeTransactionsByNumber(self, seqid, iprot, oprot):
9579 
    args = getRechargeTransactionsByNumber_args()
9580 
    args.read(iprot)
9581 
    iprot.readMessageEnd()
9582 
    result = getRechargeTransactionsByNumber_result()
7172 anupam.sin 9583 
    result.success = self._handler.getRechargeTransactionsByNumber(args.number, args.storeId)
7169 anupam.sin 9584 
    oprot.writeMessageBegin("getRechargeTransactionsByNumber", TMessageType.REPLY, seqid)
9585 
    result.write(oprot)
9586 
    oprot.writeMessageEnd()
9587 
    oprot.trans.flush()
7109 anupam.sin 9588 
 
7169 anupam.sin 9589 
  def process_updateHotspotStorePassword(self, seqid, iprot, oprot):
9590 
    args = updateHotspotStorePassword_args()
9591 
    args.read(iprot)
9592 
    iprot.readMessageEnd()
9593 
    result = updateHotspotStorePassword_result()
9594 
    result.success = self._handler.updateHotspotStorePassword(args.storeId, args.password)
9595 
    oprot.writeMessageBegin("updateHotspotStorePassword", TMessageType.REPLY, seqid)
9596 
    result.write(oprot)
9597 
    oprot.writeMessageEnd()
9598 
    oprot.trans.flush()
9599 
 
7285 rajveer 9600 
  def process_topupCompanyWallet(self, seqid, iprot, oprot):
9601 
    args = topupCompanyWallet_args()
7263 anupam.sin 9602 
    args.read(iprot)
9603 
    iprot.readMessageEnd()
7285 rajveer 9604 
    result = topupCompanyWallet_result()
9605 
    result.success = self._handler.topupCompanyWallet(args.companyId, args.amount)
9606 
    oprot.writeMessageBegin("topupCompanyWallet", TMessageType.REPLY, seqid)
7263 anupam.sin 9607 
    result.write(oprot)
9608 
    oprot.writeMessageEnd()
9609 
    oprot.trans.flush()
7169 anupam.sin 9610 
 
7285 rajveer 9611 
  def process_getWalletBalanceForCompany(self, seqid, iprot, oprot):
9612 
    args = getWalletBalanceForCompany_args()
7267 anupam.sin 9613 
    args.read(iprot)
9614 
    iprot.readMessageEnd()
7285 rajveer 9615 
    result = getWalletBalanceForCompany_result()
9616 
    result.success = self._handler.getWalletBalanceForCompany(args.companyId)
9617 
    oprot.writeMessageBegin("getWalletBalanceForCompany", TMessageType.REPLY, seqid)
7267 anupam.sin 9618 
    result.write(oprot)
9619 
    oprot.writeMessageEnd()
9620 
    oprot.trans.flush()
7263 anupam.sin 9621 
 
7285 rajveer 9622 
  def process_getSourceDetail(self, seqid, iprot, oprot):
9623 
    args = getSourceDetail_args()
7267 anupam.sin 9624 
    args.read(iprot)
9625 
    iprot.readMessageEnd()
7285 rajveer 9626 
    result = getSourceDetail_result()
9627 
    result.success = self._handler.getSourceDetail(args.source)
9628 
    oprot.writeMessageBegin("getSourceDetail", TMessageType.REPLY, seqid)
7267 anupam.sin 9629 
    result.write(oprot)
9630 
    oprot.writeMessageEnd()
9631 
    oprot.trans.flush()
9632 
 
9633 
 
94 ashish 9634 
# HELPER FUNCTIONS AND STRUCTURES
9635 
 
9636 
class createTransaction_args:
9637 
  """
9638 
  Attributes:
9639 
   - transaction
9640 
  """
9641 
 
9642 
  thrift_spec = (
9643 
    None, # 0
9644 
    (1, TType.STRUCT, 'transaction', (Transaction, Transaction.thrift_spec), None, ), # 1
9645 
  )
9646 
 
9647 
  def __init__(self, transaction=None,):
9648 
    self.transaction = transaction
9649 
 
9650 
  def read(self, iprot):
9651 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9652 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9653 
      return
9654 
    iprot.readStructBegin()
9655 
    while True:
9656 
      (fname, ftype, fid) = iprot.readFieldBegin()
9657 
      if ftype == TType.STOP:
9658 
        break
9659 
      if fid == 1:
9660 
        if ftype == TType.STRUCT:
9661 
          self.transaction = Transaction()
9662 
          self.transaction.read(iprot)
9663 
        else:
9664 
          iprot.skip(ftype)
9665 
      else:
9666 
        iprot.skip(ftype)
9667 
      iprot.readFieldEnd()
9668 
    iprot.readStructEnd()
9669 
 
9670 
  def write(self, oprot):
9671 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9672 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9673 
      return
9674 
    oprot.writeStructBegin('createTransaction_args')
3431 rajveer 9675 
    if self.transaction is not None:
94 ashish 9676 
      oprot.writeFieldBegin('transaction', TType.STRUCT, 1)
9677 
      self.transaction.write(oprot)
9678 
      oprot.writeFieldEnd()
9679 
    oprot.writeFieldStop()
9680 
    oprot.writeStructEnd()
9681 
 
3431 rajveer 9682 
  def validate(self):
9683 
    return
9684 
 
9685 
 
94 ashish 9686 
  def __repr__(self):
9687 
    L = ['%s=%r' % (key, value)
9688 
      for key, value in self.__dict__.iteritems()]
9689 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9690 
 
9691 
  def __eq__(self, other):
9692 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9693 
 
9694 
  def __ne__(self, other):
9695 
    return not (self == other)
9696 
 
9697 
class createTransaction_result:
9698 
  """
9699 
  Attributes:
132 ashish 9700 
   - success
94 ashish 9701 
   - ex
9702 
  """
9703 
 
9704 
  thrift_spec = (
132 ashish 9705 
    (0, TType.I64, 'success', None, None, ), # 0
94 ashish 9706 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
9707 
  )
9708 
 
132 ashish 9709 
  def __init__(self, success=None, ex=None,):
9710 
    self.success = success
94 ashish 9711 
    self.ex = ex
9712 
 
9713 
  def read(self, iprot):
9714 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9715 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9716 
      return
9717 
    iprot.readStructBegin()
9718 
    while True:
9719 
      (fname, ftype, fid) = iprot.readFieldBegin()
9720 
      if ftype == TType.STOP:
9721 
        break
132 ashish 9722 
      if fid == 0:
9723 
        if ftype == TType.I64:
9724 
          self.success = iprot.readI64();
9725 
        else:
9726 
          iprot.skip(ftype)
9727 
      elif fid == 1:
94 ashish 9728 
        if ftype == TType.STRUCT:
9729 
          self.ex = TransactionServiceException()
9730 
          self.ex.read(iprot)
9731 
        else:
9732 
          iprot.skip(ftype)
9733 
      else:
9734 
        iprot.skip(ftype)
9735 
      iprot.readFieldEnd()
9736 
    iprot.readStructEnd()
9737 
 
9738 
  def write(self, oprot):
9739 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9740 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9741 
      return
9742 
    oprot.writeStructBegin('createTransaction_result')
3431 rajveer 9743 
    if self.success is not None:
132 ashish 9744 
      oprot.writeFieldBegin('success', TType.I64, 0)
9745 
      oprot.writeI64(self.success)
9746 
      oprot.writeFieldEnd()
3431 rajveer 9747 
    if self.ex is not None:
94 ashish 9748 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9749 
      self.ex.write(oprot)
9750 
      oprot.writeFieldEnd()
9751 
    oprot.writeFieldStop()
9752 
    oprot.writeStructEnd()
9753 
 
3431 rajveer 9754 
  def validate(self):
9755 
    return
9756 
 
9757 
 
94 ashish 9758 
  def __repr__(self):
9759 
    L = ['%s=%r' % (key, value)
9760 
      for key, value in self.__dict__.iteritems()]
9761 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9762 
 
9763 
  def __eq__(self, other):
9764 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9765 
 
9766 
  def __ne__(self, other):
9767 
    return not (self == other)
9768 
 
9769 
class getTransaction_args:
9770 
  """
9771 
  Attributes:
9772 
   - id
9773 
  """
9774 
 
9775 
  thrift_spec = (
9776 
    None, # 0
9777 
    (1, TType.I64, 'id', None, None, ), # 1
9778 
  )
9779 
 
9780 
  def __init__(self, id=None,):
9781 
    self.id = id
9782 
 
9783 
  def read(self, iprot):
9784 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9785 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9786 
      return
9787 
    iprot.readStructBegin()
9788 
    while True:
9789 
      (fname, ftype, fid) = iprot.readFieldBegin()
9790 
      if ftype == TType.STOP:
9791 
        break
9792 
      if fid == 1:
9793 
        if ftype == TType.I64:
9794 
          self.id = iprot.readI64();
9795 
        else:
9796 
          iprot.skip(ftype)
9797 
      else:
9798 
        iprot.skip(ftype)
9799 
      iprot.readFieldEnd()
9800 
    iprot.readStructEnd()
9801 
 
9802 
  def write(self, oprot):
9803 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9804 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9805 
      return
9806 
    oprot.writeStructBegin('getTransaction_args')
3431 rajveer 9807 
    if self.id is not None:
94 ashish 9808 
      oprot.writeFieldBegin('id', TType.I64, 1)
9809 
      oprot.writeI64(self.id)
9810 
      oprot.writeFieldEnd()
9811 
    oprot.writeFieldStop()
9812 
    oprot.writeStructEnd()
9813 
 
3431 rajveer 9814 
  def validate(self):
9815 
    return
9816 
 
9817 
 
94 ashish 9818 
  def __repr__(self):
9819 
    L = ['%s=%r' % (key, value)
9820 
      for key, value in self.__dict__.iteritems()]
9821 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9822 
 
9823 
  def __eq__(self, other):
9824 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9825 
 
9826 
  def __ne__(self, other):
9827 
    return not (self == other)
9828 
 
9829 
class getTransaction_result:
9830 
  """
9831 
  Attributes:
9832 
   - success
9833 
   - ex
9834 
  """
9835 
 
9836 
  thrift_spec = (
9837 
    (0, TType.STRUCT, 'success', (Transaction, Transaction.thrift_spec), None, ), # 0
9838 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
9839 
  )
9840 
 
9841 
  def __init__(self, success=None, ex=None,):
9842 
    self.success = success
9843 
    self.ex = ex
9844 
 
9845 
  def read(self, iprot):
9846 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9847 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9848 
      return
9849 
    iprot.readStructBegin()
9850 
    while True:
9851 
      (fname, ftype, fid) = iprot.readFieldBegin()
9852 
      if ftype == TType.STOP:
9853 
        break
9854 
      if fid == 0:
9855 
        if ftype == TType.STRUCT:
9856 
          self.success = Transaction()
9857 
          self.success.read(iprot)
9858 
        else:
9859 
          iprot.skip(ftype)
9860 
      elif fid == 1:
9861 
        if ftype == TType.STRUCT:
9862 
          self.ex = TransactionServiceException()
9863 
          self.ex.read(iprot)
9864 
        else:
9865 
          iprot.skip(ftype)
9866 
      else:
9867 
        iprot.skip(ftype)
9868 
      iprot.readFieldEnd()
9869 
    iprot.readStructEnd()
9870 
 
9871 
  def write(self, oprot):
9872 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9873 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9874 
      return
9875 
    oprot.writeStructBegin('getTransaction_result')
3431 rajveer 9876 
    if self.success is not None:
94 ashish 9877 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
9878 
      self.success.write(oprot)
9879 
      oprot.writeFieldEnd()
3431 rajveer 9880 
    if self.ex is not None:
94 ashish 9881 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9882 
      self.ex.write(oprot)
9883 
      oprot.writeFieldEnd()
9884 
    oprot.writeFieldStop()
9885 
    oprot.writeStructEnd()
9886 
 
3431 rajveer 9887 
  def validate(self):
9888 
    return
9889 
 
9890 
 
94 ashish 9891 
  def __repr__(self):
9892 
    L = ['%s=%r' % (key, value)
9893 
      for key, value in self.__dict__.iteritems()]
9894 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9895 
 
9896 
  def __eq__(self, other):
9897 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9898 
 
9899 
  def __ne__(self, other):
9900 
    return not (self == other)
9901 
 
9902 
class getTransactionsForCustomer_args:
9903 
  """
9904 
  Attributes:
9905 
   - customerId
9906 
   - from_date
9907 
   - to_date
9908 
   - status
9909 
  """
9910 
 
9911 
  thrift_spec = (
9912 
    None, # 0
9913 
    (1, TType.I64, 'customerId', None, None, ), # 1
9914 
    (2, TType.I64, 'from_date', None, None, ), # 2
9915 
    (3, TType.I64, 'to_date', None, None, ), # 3
9916 
    (4, TType.I32, 'status', None, None, ), # 4
9917 
  )
9918 
 
9919 
  def __init__(self, customerId=None, from_date=None, to_date=None, status=None,):
9920 
    self.customerId = customerId
9921 
    self.from_date = from_date
9922 
    self.to_date = to_date
9923 
    self.status = status
9924 
 
9925 
  def read(self, iprot):
9926 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9927 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9928 
      return
9929 
    iprot.readStructBegin()
9930 
    while True:
9931 
      (fname, ftype, fid) = iprot.readFieldBegin()
9932 
      if ftype == TType.STOP:
9933 
        break
9934 
      if fid == 1:
9935 
        if ftype == TType.I64:
9936 
          self.customerId = iprot.readI64();
9937 
        else:
9938 
          iprot.skip(ftype)
9939 
      elif fid == 2:
9940 
        if ftype == TType.I64:
9941 
          self.from_date = iprot.readI64();
9942 
        else:
9943 
          iprot.skip(ftype)
9944 
      elif fid == 3:
9945 
        if ftype == TType.I64:
9946 
          self.to_date = iprot.readI64();
9947 
        else:
9948 
          iprot.skip(ftype)
9949 
      elif fid == 4:
9950 
        if ftype == TType.I32:
9951 
          self.status = iprot.readI32();
9952 
        else:
9953 
          iprot.skip(ftype)
9954 
      else:
9955 
        iprot.skip(ftype)
9956 
      iprot.readFieldEnd()
9957 
    iprot.readStructEnd()
9958 
 
9959 
  def write(self, oprot):
9960 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9961 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9962 
      return
9963 
    oprot.writeStructBegin('getTransactionsForCustomer_args')
3431 rajveer 9964 
    if self.customerId is not None:
94 ashish 9965 
      oprot.writeFieldBegin('customerId', TType.I64, 1)
9966 
      oprot.writeI64(self.customerId)
9967 
      oprot.writeFieldEnd()
3431 rajveer 9968 
    if self.from_date is not None:
94 ashish 9969 
      oprot.writeFieldBegin('from_date', TType.I64, 2)
9970 
      oprot.writeI64(self.from_date)
9971 
      oprot.writeFieldEnd()
3431 rajveer 9972 
    if self.to_date is not None:
94 ashish 9973 
      oprot.writeFieldBegin('to_date', TType.I64, 3)
9974 
      oprot.writeI64(self.to_date)
9975 
      oprot.writeFieldEnd()
3431 rajveer 9976 
    if self.status is not None:
94 ashish 9977 
      oprot.writeFieldBegin('status', TType.I32, 4)
9978 
      oprot.writeI32(self.status)
9979 
      oprot.writeFieldEnd()
9980 
    oprot.writeFieldStop()
9981 
    oprot.writeStructEnd()
9982 
 
3431 rajveer 9983 
  def validate(self):
9984 
    return
9985 
 
9986 
 
94 ashish 9987 
  def __repr__(self):
9988 
    L = ['%s=%r' % (key, value)
9989 
      for key, value in self.__dict__.iteritems()]
9990 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9991 
 
9992 
  def __eq__(self, other):
9993 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9994 
 
9995 
  def __ne__(self, other):
9996 
    return not (self == other)
9997 
 
9998 
class getTransactionsForCustomer_result:
9999 
  """
10000 
  Attributes:
10001 
   - success
10002 
   - ex
10003 
  """
10004 
 
10005 
  thrift_spec = (
10006 
    (0, TType.LIST, 'success', (TType.STRUCT,(Transaction, Transaction.thrift_spec)), None, ), # 0
10007 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
10008 
  )
10009 
 
10010 
  def __init__(self, success=None, ex=None,):
10011 
    self.success = success
10012 
    self.ex = ex
10013 
 
10014 
  def read(self, iprot):
10015 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10016 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10017 
      return
10018 
    iprot.readStructBegin()
10019 
    while True:
10020 
      (fname, ftype, fid) = iprot.readFieldBegin()
10021 
      if ftype == TType.STOP:
10022 
        break
10023 
      if fid == 0:
10024 
        if ftype == TType.LIST:
10025 
          self.success = []
6188 rajveer 10026 
          (_etype109, _size106) = iprot.readListBegin()
10027 
          for _i110 in xrange(_size106):
10028 
            _elem111 = Transaction()
10029 
            _elem111.read(iprot)
10030 
            self.success.append(_elem111)
94 ashish 10031 
          iprot.readListEnd()
10032 
        else:
10033 
          iprot.skip(ftype)
10034 
      elif fid == 1:
10035 
        if ftype == TType.STRUCT:
10036 
          self.ex = TransactionServiceException()
10037 
          self.ex.read(iprot)
10038 
        else:
10039 
          iprot.skip(ftype)
10040 
      else:
10041 
        iprot.skip(ftype)
10042 
      iprot.readFieldEnd()
10043 
    iprot.readStructEnd()
10044 
 
10045 
  def write(self, oprot):
10046 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10047 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10048 
      return
10049 
    oprot.writeStructBegin('getTransactionsForCustomer_result')
3431 rajveer 10050 
    if self.success is not None:
94 ashish 10051 
      oprot.writeFieldBegin('success', TType.LIST, 0)
10052 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 10053 
      for iter112 in self.success:
10054 
        iter112.write(oprot)
94 ashish 10055 
      oprot.writeListEnd()
10056 
      oprot.writeFieldEnd()
3431 rajveer 10057 
    if self.ex is not None:
94 ashish 10058 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10059 
      self.ex.write(oprot)
10060 
      oprot.writeFieldEnd()
10061 
    oprot.writeFieldStop()
10062 
    oprot.writeStructEnd()
10063 
 
3431 rajveer 10064 
  def validate(self):
10065 
    return
10066 
 
10067 
 
94 ashish 10068 
  def __repr__(self):
10069 
    L = ['%s=%r' % (key, value)
10070 
      for key, value in self.__dict__.iteritems()]
10071 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10072 
 
10073 
  def __eq__(self, other):
10074 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10075 
 
10076 
  def __ne__(self, other):
10077 
    return not (self == other)
10078 
 
132 ashish 10079 
class getTransactionsForShoppingCartId_args:
10080 
  """
10081 
  Attributes:
10082 
   - shoppingCartId
10083 
  """
10084 
 
10085 
  thrift_spec = (
10086 
    None, # 0
10087 
    (1, TType.I64, 'shoppingCartId', None, None, ), # 1
10088 
  )
10089 
 
10090 
  def __init__(self, shoppingCartId=None,):
10091 
    self.shoppingCartId = shoppingCartId
10092 
 
10093 
  def read(self, iprot):
10094 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10095 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10096 
      return
10097 
    iprot.readStructBegin()
10098 
    while True:
10099 
      (fname, ftype, fid) = iprot.readFieldBegin()
10100 
      if ftype == TType.STOP:
10101 
        break
10102 
      if fid == 1:
10103 
        if ftype == TType.I64:
10104 
          self.shoppingCartId = iprot.readI64();
10105 
        else:
10106 
          iprot.skip(ftype)
10107 
      else:
10108 
        iprot.skip(ftype)
10109 
      iprot.readFieldEnd()
10110 
    iprot.readStructEnd()
10111 
 
10112 
  def write(self, oprot):
10113 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10114 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10115 
      return
10116 
    oprot.writeStructBegin('getTransactionsForShoppingCartId_args')
3431 rajveer 10117 
    if self.shoppingCartId is not None:
132 ashish 10118 
      oprot.writeFieldBegin('shoppingCartId', TType.I64, 1)
10119 
      oprot.writeI64(self.shoppingCartId)
10120 
      oprot.writeFieldEnd()
10121 
    oprot.writeFieldStop()
10122 
    oprot.writeStructEnd()
10123 
 
3431 rajveer 10124 
  def validate(self):
10125 
    return
10126 
 
10127 
 
132 ashish 10128 
  def __repr__(self):
10129 
    L = ['%s=%r' % (key, value)
10130 
      for key, value in self.__dict__.iteritems()]
10131 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10132 
 
10133 
  def __eq__(self, other):
10134 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10135 
 
10136 
  def __ne__(self, other):
10137 
    return not (self == other)
10138 
 
10139 
class getTransactionsForShoppingCartId_result:
10140 
  """
10141 
  Attributes:
10142 
   - success
10143 
   - ex
10144 
  """
10145 
 
10146 
  thrift_spec = (
10147 
    (0, TType.LIST, 'success', (TType.STRUCT,(Transaction, Transaction.thrift_spec)), None, ), # 0
10148 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
10149 
  )
10150 
 
10151 
  def __init__(self, success=None, ex=None,):
10152 
    self.success = success
10153 
    self.ex = ex
10154 
 
10155 
  def read(self, iprot):
10156 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10157 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10158 
      return
10159 
    iprot.readStructBegin()
10160 
    while True:
10161 
      (fname, ftype, fid) = iprot.readFieldBegin()
10162 
      if ftype == TType.STOP:
10163 
        break
10164 
      if fid == 0:
10165 
        if ftype == TType.LIST:
10166 
          self.success = []
6188 rajveer 10167 
          (_etype116, _size113) = iprot.readListBegin()
10168 
          for _i117 in xrange(_size113):
10169 
            _elem118 = Transaction()
10170 
            _elem118.read(iprot)
10171 
            self.success.append(_elem118)
132 ashish 10172 
          iprot.readListEnd()
10173 
        else:
10174 
          iprot.skip(ftype)
10175 
      elif fid == 1:
10176 
        if ftype == TType.STRUCT:
10177 
          self.ex = TransactionServiceException()
10178 
          self.ex.read(iprot)
10179 
        else:
10180 
          iprot.skip(ftype)
10181 
      else:
10182 
        iprot.skip(ftype)
10183 
      iprot.readFieldEnd()
10184 
    iprot.readStructEnd()
10185 
 
10186 
  def write(self, oprot):
10187 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10188 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10189 
      return
10190 
    oprot.writeStructBegin('getTransactionsForShoppingCartId_result')
3431 rajveer 10191 
    if self.success is not None:
132 ashish 10192 
      oprot.writeFieldBegin('success', TType.LIST, 0)
10193 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 10194 
      for iter119 in self.success:
10195 
        iter119.write(oprot)
132 ashish 10196 
      oprot.writeListEnd()
10197 
      oprot.writeFieldEnd()
3431 rajveer 10198 
    if self.ex is not None:
132 ashish 10199 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10200 
      self.ex.write(oprot)
10201 
      oprot.writeFieldEnd()
10202 
    oprot.writeFieldStop()
10203 
    oprot.writeStructEnd()
10204 
 
3431 rajveer 10205 
  def validate(self):
10206 
    return
10207 
 
10208 
 
132 ashish 10209 
  def __repr__(self):
10210 
    L = ['%s=%r' % (key, value)
10211 
      for key, value in self.__dict__.iteritems()]
10212 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10213 
 
10214 
  def __eq__(self, other):
10215 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10216 
 
10217 
  def __ne__(self, other):
10218 
    return not (self == other)
10219 
 
94 ashish 10220 
class getTransactionStatus_args:
10221 
  """
10222 
  Attributes:
10223 
   - transactionId
10224 
  """
10225 
 
10226 
  thrift_spec = (
10227 
    None, # 0
10228 
    (1, TType.I64, 'transactionId', None, None, ), # 1
10229 
  )
10230 
 
10231 
  def __init__(self, transactionId=None,):
10232 
    self.transactionId = transactionId
10233 
 
10234 
  def read(self, iprot):
10235 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10236 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10237 
      return
10238 
    iprot.readStructBegin()
10239 
    while True:
10240 
      (fname, ftype, fid) = iprot.readFieldBegin()
10241 
      if ftype == TType.STOP:
10242 
        break
10243 
      if fid == 1:
10244 
        if ftype == TType.I64:
10245 
          self.transactionId = iprot.readI64();
10246 
        else:
10247 
          iprot.skip(ftype)
10248 
      else:
10249 
        iprot.skip(ftype)
10250 
      iprot.readFieldEnd()
10251 
    iprot.readStructEnd()
10252 
 
10253 
  def write(self, oprot):
10254 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10255 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10256 
      return
10257 
    oprot.writeStructBegin('getTransactionStatus_args')
3431 rajveer 10258 
    if self.transactionId is not None:
94 ashish 10259 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
10260 
      oprot.writeI64(self.transactionId)
10261 
      oprot.writeFieldEnd()
10262 
    oprot.writeFieldStop()
10263 
    oprot.writeStructEnd()
10264 
 
3431 rajveer 10265 
  def validate(self):
10266 
    return
10267 
 
10268 
 
94 ashish 10269 
  def __repr__(self):
10270 
    L = ['%s=%r' % (key, value)
10271 
      for key, value in self.__dict__.iteritems()]
10272 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10273 
 
10274 
  def __eq__(self, other):
10275 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10276 
 
10277 
  def __ne__(self, other):
10278 
    return not (self == other)
10279 
 
10280 
class getTransactionStatus_result:
10281 
  """
10282 
  Attributes:
10283 
   - success
10284 
   - ex
10285 
  """
10286 
 
10287 
  thrift_spec = (
10288 
    (0, TType.I32, 'success', None, None, ), # 0
10289 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
10290 
  )
10291 
 
10292 
  def __init__(self, success=None, ex=None,):
10293 
    self.success = success
10294 
    self.ex = ex
10295 
 
10296 
  def read(self, iprot):
10297 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10298 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10299 
      return
10300 
    iprot.readStructBegin()
10301 
    while True:
10302 
      (fname, ftype, fid) = iprot.readFieldBegin()
10303 
      if ftype == TType.STOP:
10304 
        break
10305 
      if fid == 0:
10306 
        if ftype == TType.I32:
10307 
          self.success = iprot.readI32();
10308 
        else:
10309 
          iprot.skip(ftype)
10310 
      elif fid == 1:
10311 
        if ftype == TType.STRUCT:
10312 
          self.ex = TransactionServiceException()
10313 
          self.ex.read(iprot)
10314 
        else:
10315 
          iprot.skip(ftype)
10316 
      else:
10317 
        iprot.skip(ftype)
10318 
      iprot.readFieldEnd()
10319 
    iprot.readStructEnd()
10320 
 
10321 
  def write(self, oprot):
10322 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10323 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10324 
      return
10325 
    oprot.writeStructBegin('getTransactionStatus_result')
3431 rajveer 10326 
    if self.success is not None:
94 ashish 10327 
      oprot.writeFieldBegin('success', TType.I32, 0)
10328 
      oprot.writeI32(self.success)
10329 
      oprot.writeFieldEnd()
3431 rajveer 10330 
    if self.ex is not None:
94 ashish 10331 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10332 
      self.ex.write(oprot)
10333 
      oprot.writeFieldEnd()
10334 
    oprot.writeFieldStop()
10335 
    oprot.writeStructEnd()
10336 
 
3431 rajveer 10337 
  def validate(self):
10338 
    return
10339 
 
10340 
 
94 ashish 10341 
  def __repr__(self):
10342 
    L = ['%s=%r' % (key, value)
10343 
      for key, value in self.__dict__.iteritems()]
10344 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10345 
 
10346 
  def __eq__(self, other):
10347 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10348 
 
10349 
  def __ne__(self, other):
10350 
    return not (self == other)
10351 
 
10352 
class changeTransactionStatus_args:
10353 
  """
10354 
  Attributes:
10355 
   - transactionId
10356 
   - status
10357 
   - description
5527 anupam.sin 10358 
   - pickUp
10359 
   - orderType
7293 anupam.sin 10360 
   - source
94 ashish 10361 
  """
10362 
 
10363 
  thrift_spec = (
10364 
    None, # 0
10365 
    (1, TType.I64, 'transactionId', None, None, ), # 1
10366 
    (2, TType.I32, 'status', None, None, ), # 2
10367 
    (3, TType.STRING, 'description', None, None, ), # 3
5527 anupam.sin 10368 
    (4, TType.I64, 'pickUp', None, None, ), # 4
10369 
    (5, TType.I32, 'orderType', None, None, ), # 5
7293 anupam.sin 10370 
    (6, TType.I32, 'source', None, None, ), # 6
94 ashish 10371 
  )
10372 
 
7293 anupam.sin 10373 
  def __init__(self, transactionId=None, status=None, description=None, pickUp=None, orderType=None, source=None,):
94 ashish 10374 
    self.transactionId = transactionId
10375 
    self.status = status
10376 
    self.description = description
5527 anupam.sin 10377 
    self.pickUp = pickUp
10378 
    self.orderType = orderType
7293 anupam.sin 10379 
    self.source = source
94 ashish 10380 
 
10381 
  def read(self, iprot):
10382 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10383 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10384 
      return
10385 
    iprot.readStructBegin()
10386 
    while True:
10387 
      (fname, ftype, fid) = iprot.readFieldBegin()
10388 
      if ftype == TType.STOP:
10389 
        break
10390 
      if fid == 1:
10391 
        if ftype == TType.I64:
10392 
          self.transactionId = iprot.readI64();
10393 
        else:
10394 
          iprot.skip(ftype)
10395 
      elif fid == 2:
10396 
        if ftype == TType.I32:
10397 
          self.status = iprot.readI32();
10398 
        else:
10399 
          iprot.skip(ftype)
10400 
      elif fid == 3:
10401 
        if ftype == TType.STRING:
10402 
          self.description = iprot.readString();
10403 
        else:
10404 
          iprot.skip(ftype)
5387 rajveer 10405 
      elif fid == 4:
5527 anupam.sin 10406 
        if ftype == TType.I64:
10407 
          self.pickUp = iprot.readI64();
5387 rajveer 10408 
        else:
10409 
          iprot.skip(ftype)
5527 anupam.sin 10410 
      elif fid == 5:
10411 
        if ftype == TType.I32:
10412 
          self.orderType = iprot.readI32();
10413 
        else:
10414 
          iprot.skip(ftype)
7293 anupam.sin 10415 
      elif fid == 6:
10416 
        if ftype == TType.I32:
10417 
          self.source = iprot.readI32();
10418 
        else:
10419 
          iprot.skip(ftype)
94 ashish 10420 
      else:
10421 
        iprot.skip(ftype)
10422 
      iprot.readFieldEnd()
10423 
    iprot.readStructEnd()
10424 
 
10425 
  def write(self, oprot):
10426 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10427 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10428 
      return
10429 
    oprot.writeStructBegin('changeTransactionStatus_args')
3431 rajveer 10430 
    if self.transactionId is not None:
94 ashish 10431 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
10432 
      oprot.writeI64(self.transactionId)
10433 
      oprot.writeFieldEnd()
3431 rajveer 10434 
    if self.status is not None:
94 ashish 10435 
      oprot.writeFieldBegin('status', TType.I32, 2)
10436 
      oprot.writeI32(self.status)
10437 
      oprot.writeFieldEnd()
3431 rajveer 10438 
    if self.description is not None:
94 ashish 10439 
      oprot.writeFieldBegin('description', TType.STRING, 3)
10440 
      oprot.writeString(self.description)
10441 
      oprot.writeFieldEnd()
5527 anupam.sin 10442 
    if self.pickUp is not None:
10443 
      oprot.writeFieldBegin('pickUp', TType.I64, 4)
10444 
      oprot.writeI64(self.pickUp)
5387 rajveer 10445 
      oprot.writeFieldEnd()
5527 anupam.sin 10446 
    if self.orderType is not None:
10447 
      oprot.writeFieldBegin('orderType', TType.I32, 5)
10448 
      oprot.writeI32(self.orderType)
10449 
      oprot.writeFieldEnd()
7293 anupam.sin 10450 
    if self.source is not None:
10451 
      oprot.writeFieldBegin('source', TType.I32, 6)
10452 
      oprot.writeI32(self.source)
10453 
      oprot.writeFieldEnd()
94 ashish 10454 
    oprot.writeFieldStop()
10455 
    oprot.writeStructEnd()
10456 
 
3431 rajveer 10457 
  def validate(self):
10458 
    return
10459 
 
10460 
 
94 ashish 10461 
  def __repr__(self):
10462 
    L = ['%s=%r' % (key, value)
10463 
      for key, value in self.__dict__.iteritems()]
10464 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10465 
 
10466 
  def __eq__(self, other):
10467 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10468 
 
10469 
  def __ne__(self, other):
10470 
    return not (self == other)
10471 
 
10472 
class changeTransactionStatus_result:
10473 
  """
10474 
  Attributes:
10475 
   - success
10476 
   - ex
10477 
  """
10478 
 
10479 
  thrift_spec = (
10480 
    (0, TType.BOOL, 'success', None, None, ), # 0
10481 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
10482 
  )
10483 
 
10484 
  def __init__(self, success=None, ex=None,):
10485 
    self.success = success
10486 
    self.ex = ex
10487 
 
10488 
  def read(self, iprot):
10489 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10490 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10491 
      return
10492 
    iprot.readStructBegin()
10493 
    while True:
10494 
      (fname, ftype, fid) = iprot.readFieldBegin()
10495 
      if ftype == TType.STOP:
10496 
        break
10497 
      if fid == 0:
10498 
        if ftype == TType.BOOL:
10499 
          self.success = iprot.readBool();
10500 
        else:
10501 
          iprot.skip(ftype)
10502 
      elif fid == 1:
10503 
        if ftype == TType.STRUCT:
10504 
          self.ex = TransactionServiceException()
10505 
          self.ex.read(iprot)
10506 
        else:
10507 
          iprot.skip(ftype)
10508 
      else:
10509 
        iprot.skip(ftype)
10510 
      iprot.readFieldEnd()
10511 
    iprot.readStructEnd()
10512 
 
10513 
  def write(self, oprot):
10514 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10515 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10516 
      return
10517 
    oprot.writeStructBegin('changeTransactionStatus_result')
3431 rajveer 10518 
    if self.success is not None:
94 ashish 10519 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
10520 
      oprot.writeBool(self.success)
10521 
      oprot.writeFieldEnd()
3431 rajveer 10522 
    if self.ex is not None:
94 ashish 10523 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10524 
      self.ex.write(oprot)
10525 
      oprot.writeFieldEnd()
10526 
    oprot.writeFieldStop()
10527 
    oprot.writeStructEnd()
10528 
 
3431 rajveer 10529 
  def validate(self):
10530 
    return
10531 
 
10532 
 
94 ashish 10533 
  def __repr__(self):
10534 
    L = ['%s=%r' % (key, value)
10535 
      for key, value in self.__dict__.iteritems()]
10536 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10537 
 
10538 
  def __eq__(self, other):
10539 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10540 
 
10541 
  def __ne__(self, other):
10542 
    return not (self == other)
10543 
 
1398 varun.gupt 10544 
class enqueueTransactionInfoEmail_args:
1382 varun.gupt 10545 
  """
10546 
  Attributes:
10547 
   - transactionId
10548 
  """
10549 
 
10550 
  thrift_spec = (
10551 
    None, # 0
10552 
    (1, TType.I64, 'transactionId', None, None, ), # 1
10553 
  )
10554 
 
10555 
  def __init__(self, transactionId=None,):
10556 
    self.transactionId = transactionId
10557 
 
10558 
  def read(self, iprot):
10559 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10560 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10561 
      return
10562 
    iprot.readStructBegin()
10563 
    while True:
10564 
      (fname, ftype, fid) = iprot.readFieldBegin()
10565 
      if ftype == TType.STOP:
10566 
        break
10567 
      if fid == 1:
10568 
        if ftype == TType.I64:
10569 
          self.transactionId = iprot.readI64();
10570 
        else:
10571 
          iprot.skip(ftype)
10572 
      else:
10573 
        iprot.skip(ftype)
10574 
      iprot.readFieldEnd()
10575 
    iprot.readStructEnd()
10576 
 
10577 
  def write(self, oprot):
10578 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10579 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10580 
      return
1398 varun.gupt 10581 
    oprot.writeStructBegin('enqueueTransactionInfoEmail_args')
3431 rajveer 10582 
    if self.transactionId is not None:
1382 varun.gupt 10583 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
10584 
      oprot.writeI64(self.transactionId)
10585 
      oprot.writeFieldEnd()
10586 
    oprot.writeFieldStop()
10587 
    oprot.writeStructEnd()
10588 
 
3431 rajveer 10589 
  def validate(self):
10590 
    return
10591 
 
10592 
 
1382 varun.gupt 10593 
  def __repr__(self):
10594 
    L = ['%s=%r' % (key, value)
10595 
      for key, value in self.__dict__.iteritems()]
10596 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10597 
 
10598 
  def __eq__(self, other):
10599 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10600 
 
10601 
  def __ne__(self, other):
10602 
    return not (self == other)
10603 
 
1398 varun.gupt 10604 
class enqueueTransactionInfoEmail_result:
1382 varun.gupt 10605 
  """
10606 
  Attributes:
10607 
   - success
10608 
   - ex
10609 
  """
10610 
 
10611 
  thrift_spec = (
10612 
    (0, TType.BOOL, 'success', None, None, ), # 0
10613 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
10614 
  )
10615 
 
10616 
  def __init__(self, success=None, ex=None,):
10617 
    self.success = success
10618 
    self.ex = ex
10619 
 
10620 
  def read(self, iprot):
10621 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10622 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10623 
      return
10624 
    iprot.readStructBegin()
10625 
    while True:
10626 
      (fname, ftype, fid) = iprot.readFieldBegin()
10627 
      if ftype == TType.STOP:
10628 
        break
10629 
      if fid == 0:
10630 
        if ftype == TType.BOOL:
10631 
          self.success = iprot.readBool();
10632 
        else:
10633 
          iprot.skip(ftype)
10634 
      elif fid == 1:
10635 
        if ftype == TType.STRUCT:
10636 
          self.ex = TransactionServiceException()
10637 
          self.ex.read(iprot)
10638 
        else:
10639 
          iprot.skip(ftype)
10640 
      else:
10641 
        iprot.skip(ftype)
10642 
      iprot.readFieldEnd()
10643 
    iprot.readStructEnd()
10644 
 
10645 
  def write(self, oprot):
10646 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10647 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10648 
      return
1398 varun.gupt 10649 
    oprot.writeStructBegin('enqueueTransactionInfoEmail_result')
3431 rajveer 10650 
    if self.success is not None:
1382 varun.gupt 10651 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
10652 
      oprot.writeBool(self.success)
10653 
      oprot.writeFieldEnd()
3431 rajveer 10654 
    if self.ex is not None:
1382 varun.gupt 10655 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10656 
      self.ex.write(oprot)
10657 
      oprot.writeFieldEnd()
10658 
    oprot.writeFieldStop()
10659 
    oprot.writeStructEnd()
10660 
 
3431 rajveer 10661 
  def validate(self):
10662 
    return
10663 
 
10664 
 
1382 varun.gupt 10665 
  def __repr__(self):
10666 
    L = ['%s=%r' % (key, value)
10667 
      for key, value in self.__dict__.iteritems()]
10668 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10669 
 
10670 
  def __eq__(self, other):
10671 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10672 
 
10673 
  def __ne__(self, other):
10674 
    return not (self == other)
10675 
 
483 rajveer 10676 
class getAllOrders_args:
94 ashish 10677 
  """
10678 
  Attributes:
4801 anupam.sin 10679 
   - statuses
483 rajveer 10680 
   - from_date
10681 
   - to_date
10682 
   - warehouse_id
94 ashish 10683 
  """
10684 
 
10685 
  thrift_spec = (
10686 
    None, # 0
4801 anupam.sin 10687 
    (1, TType.LIST, 'statuses', (TType.I32,None), None, ), # 1
483 rajveer 10688 
    (2, TType.I64, 'from_date', None, None, ), # 2
10689 
    (3, TType.I64, 'to_date', None, None, ), # 3
10690 
    (4, TType.I64, 'warehouse_id', None, None, ), # 4
94 ashish 10691 
  )
10692 
 
4801 anupam.sin 10693 
  def __init__(self, statuses=None, from_date=None, to_date=None, warehouse_id=None,):
10694 
    self.statuses = statuses
483 rajveer 10695 
    self.from_date = from_date
10696 
    self.to_date = to_date
10697 
    self.warehouse_id = warehouse_id
94 ashish 10698 
 
10699 
  def read(self, iprot):
10700 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10701 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10702 
      return
10703 
    iprot.readStructBegin()
10704 
    while True:
10705 
      (fname, ftype, fid) = iprot.readFieldBegin()
10706 
      if ftype == TType.STOP:
10707 
        break
10708 
      if fid == 1:
4801 anupam.sin 10709 
        if ftype == TType.LIST:
10710 
          self.statuses = []
6188 rajveer 10711 
          (_etype123, _size120) = iprot.readListBegin()
10712 
          for _i124 in xrange(_size120):
10713 
            _elem125 = iprot.readI32();
10714 
            self.statuses.append(_elem125)
4801 anupam.sin 10715 
          iprot.readListEnd()
94 ashish 10716 
        else:
10717 
          iprot.skip(ftype)
483 rajveer 10718 
      elif fid == 2:
10719 
        if ftype == TType.I64:
10720 
          self.from_date = iprot.readI64();
94 ashish 10721 
        else:
10722 
          iprot.skip(ftype)
483 rajveer 10723 
      elif fid == 3:
10724 
        if ftype == TType.I64:
10725 
          self.to_date = iprot.readI64();
94 ashish 10726 
        else:
10727 
          iprot.skip(ftype)
483 rajveer 10728 
      elif fid == 4:
94 ashish 10729 
        if ftype == TType.I64:
483 rajveer 10730 
          self.warehouse_id = iprot.readI64();
94 ashish 10731 
        else:
10732 
          iprot.skip(ftype)
10733 
      else:
10734 
        iprot.skip(ftype)
10735 
      iprot.readFieldEnd()
10736 
    iprot.readStructEnd()
10737 
 
10738 
  def write(self, oprot):
10739 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10740 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10741 
      return
483 rajveer 10742 
    oprot.writeStructBegin('getAllOrders_args')
4801 anupam.sin 10743 
    if self.statuses is not None:
10744 
      oprot.writeFieldBegin('statuses', TType.LIST, 1)
10745 
      oprot.writeListBegin(TType.I32, len(self.statuses))
6188 rajveer 10746 
      for iter126 in self.statuses:
10747 
        oprot.writeI32(iter126)
4801 anupam.sin 10748 
      oprot.writeListEnd()
94 ashish 10749 
      oprot.writeFieldEnd()
3431 rajveer 10750 
    if self.from_date is not None:
483 rajveer 10751 
      oprot.writeFieldBegin('from_date', TType.I64, 2)
10752 
      oprot.writeI64(self.from_date)
94 ashish 10753 
      oprot.writeFieldEnd()
3431 rajveer 10754 
    if self.to_date is not None:
483 rajveer 10755 
      oprot.writeFieldBegin('to_date', TType.I64, 3)
10756 
      oprot.writeI64(self.to_date)
94 ashish 10757 
      oprot.writeFieldEnd()
3431 rajveer 10758 
    if self.warehouse_id is not None:
483 rajveer 10759 
      oprot.writeFieldBegin('warehouse_id', TType.I64, 4)
10760 
      oprot.writeI64(self.warehouse_id)
94 ashish 10761 
      oprot.writeFieldEnd()
10762 
    oprot.writeFieldStop()
10763 
    oprot.writeStructEnd()
10764 
 
3431 rajveer 10765 
  def validate(self):
10766 
    return
10767 
 
10768 
 
94 ashish 10769 
  def __repr__(self):
10770 
    L = ['%s=%r' % (key, value)
10771 
      for key, value in self.__dict__.iteritems()]
10772 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10773 
 
10774 
  def __eq__(self, other):
10775 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10776 
 
10777 
  def __ne__(self, other):
10778 
    return not (self == other)
10779 
 
483 rajveer 10780 
class getAllOrders_result:
94 ashish 10781 
  """
10782 
  Attributes:
10783 
   - success
10784 
   - ex
10785 
  """
10786 
 
10787 
  thrift_spec = (
483 rajveer 10788 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
94 ashish 10789 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
10790 
  )
10791 
 
10792 
  def __init__(self, success=None, ex=None,):
10793 
    self.success = success
10794 
    self.ex = ex
10795 
 
10796 
  def read(self, iprot):
10797 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10798 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10799 
      return
10800 
    iprot.readStructBegin()
10801 
    while True:
10802 
      (fname, ftype, fid) = iprot.readFieldBegin()
10803 
      if ftype == TType.STOP:
10804 
        break
10805 
      if fid == 0:
483 rajveer 10806 
        if ftype == TType.LIST:
10807 
          self.success = []
6188 rajveer 10808 
          (_etype130, _size127) = iprot.readListBegin()
10809 
          for _i131 in xrange(_size127):
10810 
            _elem132 = Order()
10811 
            _elem132.read(iprot)
10812 
            self.success.append(_elem132)
483 rajveer 10813 
          iprot.readListEnd()
94 ashish 10814 
        else:
10815 
          iprot.skip(ftype)
10816 
      elif fid == 1:
10817 
        if ftype == TType.STRUCT:
10818 
          self.ex = TransactionServiceException()
10819 
          self.ex.read(iprot)
10820 
        else:
10821 
          iprot.skip(ftype)
10822 
      else:
10823 
        iprot.skip(ftype)
10824 
      iprot.readFieldEnd()
10825 
    iprot.readStructEnd()
10826 
 
10827 
  def write(self, oprot):
10828 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10829 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10830 
      return
483 rajveer 10831 
    oprot.writeStructBegin('getAllOrders_result')
3431 rajveer 10832 
    if self.success is not None:
483 rajveer 10833 
      oprot.writeFieldBegin('success', TType.LIST, 0)
10834 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 10835 
      for iter133 in self.success:
10836 
        iter133.write(oprot)
483 rajveer 10837 
      oprot.writeListEnd()
94 ashish 10838 
      oprot.writeFieldEnd()
3431 rajveer 10839 
    if self.ex is not None:
94 ashish 10840 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10841 
      self.ex.write(oprot)
10842 
      oprot.writeFieldEnd()
10843 
    oprot.writeFieldStop()
10844 
    oprot.writeStructEnd()
10845 
 
3431 rajveer 10846 
  def validate(self):
10847 
    return
10848 
 
10849 
 
94 ashish 10850 
  def __repr__(self):
10851 
    L = ['%s=%r' % (key, value)
10852 
      for key, value in self.__dict__.iteritems()]
10853 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10854 
 
10855 
  def __eq__(self, other):
10856 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10857 
 
10858 
  def __ne__(self, other):
10859 
    return not (self == other)
10860 
 
4133 chandransh 10861 
class getOrdersInBatch_args:
10862 
  """
10863 
  Attributes:
10864 
   - statuses
10865 
   - offset
10866 
   - limit
10867 
   - warehouse_id
10868 
  """
10869 
 
10870 
  thrift_spec = (
10871 
    None, # 0
10872 
    (1, TType.LIST, 'statuses', (TType.I32,None), None, ), # 1
10873 
    (2, TType.I64, 'offset', None, None, ), # 2
10874 
    (3, TType.I64, 'limit', None, None, ), # 3
10875 
    (4, TType.I64, 'warehouse_id', None, None, ), # 4
10876 
  )
10877 
 
10878 
  def __init__(self, statuses=None, offset=None, limit=None, warehouse_id=None,):
10879 
    self.statuses = statuses
10880 
    self.offset = offset
10881 
    self.limit = limit
10882 
    self.warehouse_id = warehouse_id
10883 
 
10884 
  def read(self, iprot):
10885 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10886 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10887 
      return
10888 
    iprot.readStructBegin()
10889 
    while True:
10890 
      (fname, ftype, fid) = iprot.readFieldBegin()
10891 
      if ftype == TType.STOP:
10892 
        break
10893 
      if fid == 1:
10894 
        if ftype == TType.LIST:
10895 
          self.statuses = []
6188 rajveer 10896 
          (_etype137, _size134) = iprot.readListBegin()
10897 
          for _i138 in xrange(_size134):
10898 
            _elem139 = iprot.readI32();
10899 
            self.statuses.append(_elem139)
4133 chandransh 10900 
          iprot.readListEnd()
10901 
        else:
10902 
          iprot.skip(ftype)
10903 
      elif fid == 2:
10904 
        if ftype == TType.I64:
10905 
          self.offset = iprot.readI64();
10906 
        else:
10907 
          iprot.skip(ftype)
10908 
      elif fid == 3:
10909 
        if ftype == TType.I64:
10910 
          self.limit = iprot.readI64();
10911 
        else:
10912 
          iprot.skip(ftype)
10913 
      elif fid == 4:
10914 
        if ftype == TType.I64:
10915 
          self.warehouse_id = iprot.readI64();
10916 
        else:
10917 
          iprot.skip(ftype)
10918 
      else:
10919 
        iprot.skip(ftype)
10920 
      iprot.readFieldEnd()
10921 
    iprot.readStructEnd()
10922 
 
10923 
  def write(self, oprot):
10924 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10925 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10926 
      return
10927 
    oprot.writeStructBegin('getOrdersInBatch_args')
10928 
    if self.statuses is not None:
10929 
      oprot.writeFieldBegin('statuses', TType.LIST, 1)
10930 
      oprot.writeListBegin(TType.I32, len(self.statuses))
6188 rajveer 10931 
      for iter140 in self.statuses:
10932 
        oprot.writeI32(iter140)
4133 chandransh 10933 
      oprot.writeListEnd()
10934 
      oprot.writeFieldEnd()
10935 
    if self.offset is not None:
10936 
      oprot.writeFieldBegin('offset', TType.I64, 2)
10937 
      oprot.writeI64(self.offset)
10938 
      oprot.writeFieldEnd()
10939 
    if self.limit is not None:
10940 
      oprot.writeFieldBegin('limit', TType.I64, 3)
10941 
      oprot.writeI64(self.limit)
10942 
      oprot.writeFieldEnd()
10943 
    if self.warehouse_id is not None:
10944 
      oprot.writeFieldBegin('warehouse_id', TType.I64, 4)
10945 
      oprot.writeI64(self.warehouse_id)
10946 
      oprot.writeFieldEnd()
10947 
    oprot.writeFieldStop()
10948 
    oprot.writeStructEnd()
10949 
 
10950 
  def validate(self):
10951 
    return
10952 
 
10953 
 
10954 
  def __repr__(self):
10955 
    L = ['%s=%r' % (key, value)
10956 
      for key, value in self.__dict__.iteritems()]
10957 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10958 
 
10959 
  def __eq__(self, other):
10960 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10961 
 
10962 
  def __ne__(self, other):
10963 
    return not (self == other)
10964 
 
10965 
class getOrdersInBatch_result:
10966 
  """
10967 
  Attributes:
10968 
   - success
10969 
   - ex
10970 
  """
10971 
 
10972 
  thrift_spec = (
10973 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
10974 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
10975 
  )
10976 
 
10977 
  def __init__(self, success=None, ex=None,):
10978 
    self.success = success
10979 
    self.ex = ex
10980 
 
10981 
  def read(self, iprot):
10982 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10983 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10984 
      return
10985 
    iprot.readStructBegin()
10986 
    while True:
10987 
      (fname, ftype, fid) = iprot.readFieldBegin()
10988 
      if ftype == TType.STOP:
10989 
        break
10990 
      if fid == 0:
10991 
        if ftype == TType.LIST:
10992 
          self.success = []
6188 rajveer 10993 
          (_etype144, _size141) = iprot.readListBegin()
10994 
          for _i145 in xrange(_size141):
10995 
            _elem146 = Order()
10996 
            _elem146.read(iprot)
10997 
            self.success.append(_elem146)
4133 chandransh 10998 
          iprot.readListEnd()
10999 
        else:
11000 
          iprot.skip(ftype)
11001 
      elif fid == 1:
11002 
        if ftype == TType.STRUCT:
11003 
          self.ex = TransactionServiceException()
11004 
          self.ex.read(iprot)
11005 
        else:
11006 
          iprot.skip(ftype)
11007 
      else:
11008 
        iprot.skip(ftype)
11009 
      iprot.readFieldEnd()
11010 
    iprot.readStructEnd()
11011 
 
11012 
  def write(self, oprot):
11013 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11014 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11015 
      return
11016 
    oprot.writeStructBegin('getOrdersInBatch_result')
11017 
    if self.success is not None:
11018 
      oprot.writeFieldBegin('success', TType.LIST, 0)
11019 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 11020 
      for iter147 in self.success:
11021 
        iter147.write(oprot)
4133 chandransh 11022 
      oprot.writeListEnd()
11023 
      oprot.writeFieldEnd()
11024 
    if self.ex is not None:
11025 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11026 
      self.ex.write(oprot)
11027 
      oprot.writeFieldEnd()
11028 
    oprot.writeFieldStop()
11029 
    oprot.writeStructEnd()
11030 
 
11031 
  def validate(self):
11032 
    return
11033 
 
11034 
 
11035 
  def __repr__(self):
11036 
    L = ['%s=%r' % (key, value)
11037 
      for key, value in self.__dict__.iteritems()]
11038 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11039 
 
11040 
  def __eq__(self, other):
11041 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11042 
 
11043 
  def __ne__(self, other):
11044 
    return not (self == other)
11045 
 
11046 
class getOrderCount_args:
11047 
  """
11048 
  Attributes:
11049 
   - statuses
11050 
   - warehouseId
11051 
  """
11052 
 
11053 
  thrift_spec = (
11054 
    None, # 0
11055 
    (1, TType.LIST, 'statuses', (TType.I32,None), None, ), # 1
11056 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
11057 
  )
11058 
 
11059 
  def __init__(self, statuses=None, warehouseId=None,):
11060 
    self.statuses = statuses
11061 
    self.warehouseId = warehouseId
11062 
 
11063 
  def read(self, iprot):
11064 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11065 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11066 
      return
11067 
    iprot.readStructBegin()
11068 
    while True:
11069 
      (fname, ftype, fid) = iprot.readFieldBegin()
11070 
      if ftype == TType.STOP:
11071 
        break
11072 
      if fid == 1:
11073 
        if ftype == TType.LIST:
11074 
          self.statuses = []
6188 rajveer 11075 
          (_etype151, _size148) = iprot.readListBegin()
11076 
          for _i152 in xrange(_size148):
11077 
            _elem153 = iprot.readI32();
11078 
            self.statuses.append(_elem153)
4133 chandransh 11079 
          iprot.readListEnd()
11080 
        else:
11081 
          iprot.skip(ftype)
11082 
      elif fid == 2:
11083 
        if ftype == TType.I64:
11084 
          self.warehouseId = iprot.readI64();
11085 
        else:
11086 
          iprot.skip(ftype)
11087 
      else:
11088 
        iprot.skip(ftype)
11089 
      iprot.readFieldEnd()
11090 
    iprot.readStructEnd()
11091 
 
11092 
  def write(self, oprot):
11093 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11094 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11095 
      return
11096 
    oprot.writeStructBegin('getOrderCount_args')
11097 
    if self.statuses is not None:
11098 
      oprot.writeFieldBegin('statuses', TType.LIST, 1)
11099 
      oprot.writeListBegin(TType.I32, len(self.statuses))
6188 rajveer 11100 
      for iter154 in self.statuses:
11101 
        oprot.writeI32(iter154)
4133 chandransh 11102 
      oprot.writeListEnd()
11103 
      oprot.writeFieldEnd()
11104 
    if self.warehouseId is not None:
11105 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
11106 
      oprot.writeI64(self.warehouseId)
11107 
      oprot.writeFieldEnd()
11108 
    oprot.writeFieldStop()
11109 
    oprot.writeStructEnd()
11110 
 
11111 
  def validate(self):
11112 
    return
11113 
 
11114 
 
11115 
  def __repr__(self):
11116 
    L = ['%s=%r' % (key, value)
11117 
      for key, value in self.__dict__.iteritems()]
11118 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11119 
 
11120 
  def __eq__(self, other):
11121 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11122 
 
11123 
  def __ne__(self, other):
11124 
    return not (self == other)
11125 
 
11126 
class getOrderCount_result:
11127 
  """
11128 
  Attributes:
11129 
   - success
11130 
   - ex
11131 
  """
11132 
 
11133 
  thrift_spec = (
11134 
    (0, TType.I32, 'success', None, None, ), # 0
11135 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
11136 
  )
11137 
 
11138 
  def __init__(self, success=None, ex=None,):
11139 
    self.success = success
11140 
    self.ex = ex
11141 
 
11142 
  def read(self, iprot):
11143 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11144 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11145 
      return
11146 
    iprot.readStructBegin()
11147 
    while True:
11148 
      (fname, ftype, fid) = iprot.readFieldBegin()
11149 
      if ftype == TType.STOP:
11150 
        break
11151 
      if fid == 0:
11152 
        if ftype == TType.I32:
11153 
          self.success = iprot.readI32();
11154 
        else:
11155 
          iprot.skip(ftype)
11156 
      elif fid == 1:
11157 
        if ftype == TType.STRUCT:
11158 
          self.ex = TransactionServiceException()
11159 
          self.ex.read(iprot)
11160 
        else:
11161 
          iprot.skip(ftype)
11162 
      else:
11163 
        iprot.skip(ftype)
11164 
      iprot.readFieldEnd()
11165 
    iprot.readStructEnd()
11166 
 
11167 
  def write(self, oprot):
11168 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11169 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11170 
      return
11171 
    oprot.writeStructBegin('getOrderCount_result')
11172 
    if self.success is not None:
11173 
      oprot.writeFieldBegin('success', TType.I32, 0)
11174 
      oprot.writeI32(self.success)
11175 
      oprot.writeFieldEnd()
11176 
    if self.ex is not None:
11177 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11178 
      self.ex.write(oprot)
11179 
      oprot.writeFieldEnd()
11180 
    oprot.writeFieldStop()
11181 
    oprot.writeStructEnd()
11182 
 
11183 
  def validate(self):
11184 
    return
11185 
 
11186 
 
11187 
  def __repr__(self):
11188 
    L = ['%s=%r' % (key, value)
11189 
      for key, value in self.__dict__.iteritems()]
11190 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11191 
 
11192 
  def __eq__(self, other):
11193 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11194 
 
11195 
  def __ne__(self, other):
11196 
    return not (self == other)
11197 
 
999 varun.gupt 11198 
class getOrdersByBillingDate_args:
11199 
  """
11200 
  Attributes:
11201 
   - status
11202 
   - start_billing_date
11203 
   - end_billing_date
11204 
   - warehouse_id
11205 
  """
11206 
 
11207 
  thrift_spec = (
11208 
    None, # 0
11209 
    (1, TType.I32, 'status', None, None, ), # 1
11210 
    (2, TType.I64, 'start_billing_date', None, None, ), # 2
11211 
    (3, TType.I64, 'end_billing_date', None, None, ), # 3
11212 
    (4, TType.I64, 'warehouse_id', None, None, ), # 4
11213 
  )
11214 
 
11215 
  def __init__(self, status=None, start_billing_date=None, end_billing_date=None, warehouse_id=None,):
11216 
    self.status = status
11217 
    self.start_billing_date = start_billing_date
11218 
    self.end_billing_date = end_billing_date
11219 
    self.warehouse_id = warehouse_id
11220 
 
11221 
  def read(self, iprot):
11222 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11223 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11224 
      return
11225 
    iprot.readStructBegin()
11226 
    while True:
11227 
      (fname, ftype, fid) = iprot.readFieldBegin()
11228 
      if ftype == TType.STOP:
11229 
        break
11230 
      if fid == 1:
11231 
        if ftype == TType.I32:
11232 
          self.status = iprot.readI32();
11233 
        else:
11234 
          iprot.skip(ftype)
11235 
      elif fid == 2:
11236 
        if ftype == TType.I64:
11237 
          self.start_billing_date = iprot.readI64();
11238 
        else:
11239 
          iprot.skip(ftype)
11240 
      elif fid == 3:
11241 
        if ftype == TType.I64:
11242 
          self.end_billing_date = iprot.readI64();
11243 
        else:
11244 
          iprot.skip(ftype)
11245 
      elif fid == 4:
11246 
        if ftype == TType.I64:
11247 
          self.warehouse_id = iprot.readI64();
11248 
        else:
11249 
          iprot.skip(ftype)
11250 
      else:
11251 
        iprot.skip(ftype)
11252 
      iprot.readFieldEnd()
11253 
    iprot.readStructEnd()
11254 
 
11255 
  def write(self, oprot):
11256 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11257 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11258 
      return
11259 
    oprot.writeStructBegin('getOrdersByBillingDate_args')
3431 rajveer 11260 
    if self.status is not None:
999 varun.gupt 11261 
      oprot.writeFieldBegin('status', TType.I32, 1)
11262 
      oprot.writeI32(self.status)
11263 
      oprot.writeFieldEnd()
3431 rajveer 11264 
    if self.start_billing_date is not None:
999 varun.gupt 11265 
      oprot.writeFieldBegin('start_billing_date', TType.I64, 2)
11266 
      oprot.writeI64(self.start_billing_date)
11267 
      oprot.writeFieldEnd()
3431 rajveer 11268 
    if self.end_billing_date is not None:
999 varun.gupt 11269 
      oprot.writeFieldBegin('end_billing_date', TType.I64, 3)
11270 
      oprot.writeI64(self.end_billing_date)
11271 
      oprot.writeFieldEnd()
3431 rajveer 11272 
    if self.warehouse_id is not None:
999 varun.gupt 11273 
      oprot.writeFieldBegin('warehouse_id', TType.I64, 4)
11274 
      oprot.writeI64(self.warehouse_id)
11275 
      oprot.writeFieldEnd()
11276 
    oprot.writeFieldStop()
11277 
    oprot.writeStructEnd()
11278 
 
3431 rajveer 11279 
  def validate(self):
11280 
    return
11281 
 
11282 
 
999 varun.gupt 11283 
  def __repr__(self):
11284 
    L = ['%s=%r' % (key, value)
11285 
      for key, value in self.__dict__.iteritems()]
11286 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11287 
 
11288 
  def __eq__(self, other):
11289 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11290 
 
11291 
  def __ne__(self, other):
11292 
    return not (self == other)
11293 
 
11294 
class getOrdersByBillingDate_result:
11295 
  """
11296 
  Attributes:
11297 
   - success
11298 
   - ex
11299 
  """
11300 
 
11301 
  thrift_spec = (
11302 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
11303 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
11304 
  )
11305 
 
11306 
  def __init__(self, success=None, ex=None,):
11307 
    self.success = success
11308 
    self.ex = ex
11309 
 
11310 
  def read(self, iprot):
11311 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11312 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11313 
      return
11314 
    iprot.readStructBegin()
11315 
    while True:
11316 
      (fname, ftype, fid) = iprot.readFieldBegin()
11317 
      if ftype == TType.STOP:
11318 
        break
11319 
      if fid == 0:
11320 
        if ftype == TType.LIST:
11321 
          self.success = []
6188 rajveer 11322 
          (_etype158, _size155) = iprot.readListBegin()
11323 
          for _i159 in xrange(_size155):
11324 
            _elem160 = Order()
11325 
            _elem160.read(iprot)
11326 
            self.success.append(_elem160)
999 varun.gupt 11327 
          iprot.readListEnd()
11328 
        else:
11329 
          iprot.skip(ftype)
11330 
      elif fid == 1:
11331 
        if ftype == TType.STRUCT:
11332 
          self.ex = TransactionServiceException()
11333 
          self.ex.read(iprot)
11334 
        else:
11335 
          iprot.skip(ftype)
11336 
      else:
11337 
        iprot.skip(ftype)
11338 
      iprot.readFieldEnd()
11339 
    iprot.readStructEnd()
11340 
 
11341 
  def write(self, oprot):
11342 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11343 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11344 
      return
11345 
    oprot.writeStructBegin('getOrdersByBillingDate_result')
3431 rajveer 11346 
    if self.success is not None:
999 varun.gupt 11347 
      oprot.writeFieldBegin('success', TType.LIST, 0)
11348 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 11349 
      for iter161 in self.success:
11350 
        iter161.write(oprot)
999 varun.gupt 11351 
      oprot.writeListEnd()
11352 
      oprot.writeFieldEnd()
3431 rajveer 11353 
    if self.ex is not None:
999 varun.gupt 11354 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11355 
      self.ex.write(oprot)
11356 
      oprot.writeFieldEnd()
11357 
    oprot.writeFieldStop()
11358 
    oprot.writeStructEnd()
11359 
 
3431 rajveer 11360 
  def validate(self):
11361 
    return
11362 
 
11363 
 
999 varun.gupt 11364 
  def __repr__(self):
11365 
    L = ['%s=%r' % (key, value)
11366 
      for key, value in self.__dict__.iteritems()]
11367 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11368 
 
11369 
  def __eq__(self, other):
11370 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11371 
 
11372 
  def __ne__(self, other):
11373 
    return not (self == other)
11374 
 
3427 chandransh 11375 
class getOrdersByShippingDate_args:
11376 
  """
11377 
  Attributes:
11378 
   - fromShippingDate
11379 
   - toShippingDate
11380 
   - providerId
11381 
   - warehouseId
3451 chandransh 11382 
   - cod
3427 chandransh 11383 
  """
11384 
 
11385 
  thrift_spec = (
11386 
    None, # 0
11387 
    (1, TType.I64, 'fromShippingDate', None, None, ), # 1
11388 
    (2, TType.I64, 'toShippingDate', None, None, ), # 2
11389 
    (3, TType.I64, 'providerId', None, None, ), # 3
11390 
    (4, TType.I64, 'warehouseId', None, None, ), # 4
3451 chandransh 11391 
    (5, TType.BOOL, 'cod', None, None, ), # 5
3427 chandransh 11392 
  )
11393 
 
3451 chandransh 11394 
  def __init__(self, fromShippingDate=None, toShippingDate=None, providerId=None, warehouseId=None, cod=None,):
3427 chandransh 11395 
    self.fromShippingDate = fromShippingDate
11396 
    self.toShippingDate = toShippingDate
11397 
    self.providerId = providerId
11398 
    self.warehouseId = warehouseId
3451 chandransh 11399 
    self.cod = cod
3427 chandransh 11400 
 
11401 
  def read(self, iprot):
11402 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11403 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11404 
      return
11405 
    iprot.readStructBegin()
11406 
    while True:
11407 
      (fname, ftype, fid) = iprot.readFieldBegin()
11408 
      if ftype == TType.STOP:
11409 
        break
11410 
      if fid == 1:
11411 
        if ftype == TType.I64:
11412 
          self.fromShippingDate = iprot.readI64();
11413 
        else:
11414 
          iprot.skip(ftype)
11415 
      elif fid == 2:
11416 
        if ftype == TType.I64:
11417 
          self.toShippingDate = iprot.readI64();
11418 
        else:
11419 
          iprot.skip(ftype)
11420 
      elif fid == 3:
11421 
        if ftype == TType.I64:
11422 
          self.providerId = iprot.readI64();
11423 
        else:
11424 
          iprot.skip(ftype)
11425 
      elif fid == 4:
11426 
        if ftype == TType.I64:
11427 
          self.warehouseId = iprot.readI64();
11428 
        else:
11429 
          iprot.skip(ftype)
3451 chandransh 11430 
      elif fid == 5:
11431 
        if ftype == TType.BOOL:
11432 
          self.cod = iprot.readBool();
11433 
        else:
11434 
          iprot.skip(ftype)
3427 chandransh 11435 
      else:
11436 
        iprot.skip(ftype)
11437 
      iprot.readFieldEnd()
11438 
    iprot.readStructEnd()
11439 
 
11440 
  def write(self, oprot):
11441 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11442 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11443 
      return
11444 
    oprot.writeStructBegin('getOrdersByShippingDate_args')
3431 rajveer 11445 
    if self.fromShippingDate is not None:
3427 chandransh 11446 
      oprot.writeFieldBegin('fromShippingDate', TType.I64, 1)
11447 
      oprot.writeI64(self.fromShippingDate)
11448 
      oprot.writeFieldEnd()
3431 rajveer 11449 
    if self.toShippingDate is not None:
3427 chandransh 11450 
      oprot.writeFieldBegin('toShippingDate', TType.I64, 2)
11451 
      oprot.writeI64(self.toShippingDate)
11452 
      oprot.writeFieldEnd()
3431 rajveer 11453 
    if self.providerId is not None:
3427 chandransh 11454 
      oprot.writeFieldBegin('providerId', TType.I64, 3)
11455 
      oprot.writeI64(self.providerId)
11456 
      oprot.writeFieldEnd()
3431 rajveer 11457 
    if self.warehouseId is not None:
3427 chandransh 11458 
      oprot.writeFieldBegin('warehouseId', TType.I64, 4)
11459 
      oprot.writeI64(self.warehouseId)
11460 
      oprot.writeFieldEnd()
3451 chandransh 11461 
    if self.cod is not None:
11462 
      oprot.writeFieldBegin('cod', TType.BOOL, 5)
11463 
      oprot.writeBool(self.cod)
11464 
      oprot.writeFieldEnd()
3427 chandransh 11465 
    oprot.writeFieldStop()
11466 
    oprot.writeStructEnd()
11467 
 
3431 rajveer 11468 
  def validate(self):
11469 
    return
11470 
 
11471 
 
3427 chandransh 11472 
  def __repr__(self):
11473 
    L = ['%s=%r' % (key, value)
11474 
      for key, value in self.__dict__.iteritems()]
11475 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11476 
 
11477 
  def __eq__(self, other):
11478 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11479 
 
11480 
  def __ne__(self, other):
11481 
    return not (self == other)
11482 
 
11483 
class getOrdersByShippingDate_result:
11484 
  """
11485 
  Attributes:
11486 
   - success
11487 
   - ex
11488 
  """
11489 
 
11490 
  thrift_spec = (
11491 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
11492 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
11493 
  )
11494 
 
11495 
  def __init__(self, success=None, ex=None,):
11496 
    self.success = success
11497 
    self.ex = ex
11498 
 
11499 
  def read(self, iprot):
11500 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11501 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11502 
      return
11503 
    iprot.readStructBegin()
11504 
    while True:
11505 
      (fname, ftype, fid) = iprot.readFieldBegin()
11506 
      if ftype == TType.STOP:
11507 
        break
11508 
      if fid == 0:
11509 
        if ftype == TType.LIST:
11510 
          self.success = []
6188 rajveer 11511 
          (_etype165, _size162) = iprot.readListBegin()
11512 
          for _i166 in xrange(_size162):
11513 
            _elem167 = Order()
11514 
            _elem167.read(iprot)
11515 
            self.success.append(_elem167)
3427 chandransh 11516 
          iprot.readListEnd()
11517 
        else:
11518 
          iprot.skip(ftype)
11519 
      elif fid == 1:
11520 
        if ftype == TType.STRUCT:
11521 
          self.ex = TransactionServiceException()
11522 
          self.ex.read(iprot)
11523 
        else:
11524 
          iprot.skip(ftype)
11525 
      else:
11526 
        iprot.skip(ftype)
11527 
      iprot.readFieldEnd()
11528 
    iprot.readStructEnd()
11529 
 
11530 
  def write(self, oprot):
11531 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11532 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11533 
      return
11534 
    oprot.writeStructBegin('getOrdersByShippingDate_result')
3431 rajveer 11535 
    if self.success is not None:
3427 chandransh 11536 
      oprot.writeFieldBegin('success', TType.LIST, 0)
11537 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 11538 
      for iter168 in self.success:
11539 
        iter168.write(oprot)
3427 chandransh 11540 
      oprot.writeListEnd()
11541 
      oprot.writeFieldEnd()
3431 rajveer 11542 
    if self.ex is not None:
3427 chandransh 11543 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11544 
      self.ex.write(oprot)
11545 
      oprot.writeFieldEnd()
11546 
    oprot.writeFieldStop()
11547 
    oprot.writeStructEnd()
11548 
 
3431 rajveer 11549 
  def validate(self):
11550 
    return
11551 
 
11552 
 
3427 chandransh 11553 
  def __repr__(self):
11554 
    L = ['%s=%r' % (key, value)
11555 
      for key, value in self.__dict__.iteritems()]
11556 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11557 
 
11558 
  def __eq__(self, other):
11559 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11560 
 
11561 
  def __ne__(self, other):
11562 
    return not (self == other)
11563 
 
1382 varun.gupt 11564 
class getReturnableOrdersForCustomer_args:
11565 
  """
11566 
  Attributes:
11567 
   - customer_id
11568 
   - limit
11569 
  """
11570 
 
11571 
  thrift_spec = (
11572 
    None, # 0
11573 
    (1, TType.I64, 'customer_id', None, None, ), # 1
11574 
    (2, TType.I64, 'limit', None, None, ), # 2
11575 
  )
11576 
 
11577 
  def __init__(self, customer_id=None, limit=None,):
11578 
    self.customer_id = customer_id
11579 
    self.limit = limit
11580 
 
11581 
  def read(self, iprot):
11582 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11583 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11584 
      return
11585 
    iprot.readStructBegin()
11586 
    while True:
11587 
      (fname, ftype, fid) = iprot.readFieldBegin()
11588 
      if ftype == TType.STOP:
11589 
        break
11590 
      if fid == 1:
11591 
        if ftype == TType.I64:
11592 
          self.customer_id = iprot.readI64();
11593 
        else:
11594 
          iprot.skip(ftype)
11595 
      elif fid == 2:
11596 
        if ftype == TType.I64:
11597 
          self.limit = iprot.readI64();
11598 
        else:
11599 
          iprot.skip(ftype)
11600 
      else:
11601 
        iprot.skip(ftype)
11602 
      iprot.readFieldEnd()
11603 
    iprot.readStructEnd()
11604 
 
11605 
  def write(self, oprot):
11606 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11607 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11608 
      return
11609 
    oprot.writeStructBegin('getReturnableOrdersForCustomer_args')
3431 rajveer 11610 
    if self.customer_id is not None:
1382 varun.gupt 11611 
      oprot.writeFieldBegin('customer_id', TType.I64, 1)
11612 
      oprot.writeI64(self.customer_id)
11613 
      oprot.writeFieldEnd()
3431 rajveer 11614 
    if self.limit is not None:
1382 varun.gupt 11615 
      oprot.writeFieldBegin('limit', TType.I64, 2)
11616 
      oprot.writeI64(self.limit)
11617 
      oprot.writeFieldEnd()
11618 
    oprot.writeFieldStop()
11619 
    oprot.writeStructEnd()
11620 
 
3431 rajveer 11621 
  def validate(self):
11622 
    return
11623 
 
11624 
 
1382 varun.gupt 11625 
  def __repr__(self):
11626 
    L = ['%s=%r' % (key, value)
11627 
      for key, value in self.__dict__.iteritems()]
11628 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11629 
 
11630 
  def __eq__(self, other):
11631 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11632 
 
11633 
  def __ne__(self, other):
11634 
    return not (self == other)
11635 
 
11636 
class getReturnableOrdersForCustomer_result:
11637 
  """
11638 
  Attributes:
11639 
   - success
11640 
   - ex
11641 
  """
11642 
 
11643 
  thrift_spec = (
11644 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
11645 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
11646 
  )
11647 
 
11648 
  def __init__(self, success=None, ex=None,):
11649 
    self.success = success
11650 
    self.ex = ex
11651 
 
11652 
  def read(self, iprot):
11653 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11654 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11655 
      return
11656 
    iprot.readStructBegin()
11657 
    while True:
11658 
      (fname, ftype, fid) = iprot.readFieldBegin()
11659 
      if ftype == TType.STOP:
11660 
        break
11661 
      if fid == 0:
11662 
        if ftype == TType.LIST:
11663 
          self.success = []
6188 rajveer 11664 
          (_etype172, _size169) = iprot.readListBegin()
11665 
          for _i173 in xrange(_size169):
11666 
            _elem174 = iprot.readI64();
11667 
            self.success.append(_elem174)
1382 varun.gupt 11668 
          iprot.readListEnd()
11669 
        else:
11670 
          iprot.skip(ftype)
11671 
      elif fid == 1:
11672 
        if ftype == TType.STRUCT:
11673 
          self.ex = TransactionServiceException()
11674 
          self.ex.read(iprot)
11675 
        else:
11676 
          iprot.skip(ftype)
11677 
      else:
11678 
        iprot.skip(ftype)
11679 
      iprot.readFieldEnd()
11680 
    iprot.readStructEnd()
11681 
 
11682 
  def write(self, oprot):
11683 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11684 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11685 
      return
11686 
    oprot.writeStructBegin('getReturnableOrdersForCustomer_result')
3431 rajveer 11687 
    if self.success is not None:
1382 varun.gupt 11688 
      oprot.writeFieldBegin('success', TType.LIST, 0)
11689 
      oprot.writeListBegin(TType.I64, len(self.success))
6188 rajveer 11690 
      for iter175 in self.success:
11691 
        oprot.writeI64(iter175)
1382 varun.gupt 11692 
      oprot.writeListEnd()
11693 
      oprot.writeFieldEnd()
3431 rajveer 11694 
    if self.ex is not None:
1382 varun.gupt 11695 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11696 
      self.ex.write(oprot)
11697 
      oprot.writeFieldEnd()
11698 
    oprot.writeFieldStop()
11699 
    oprot.writeStructEnd()
11700 
 
3431 rajveer 11701 
  def validate(self):
11702 
    return
11703 
 
11704 
 
1382 varun.gupt 11705 
  def __repr__(self):
11706 
    L = ['%s=%r' % (key, value)
11707 
      for key, value in self.__dict__.iteritems()]
11708 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11709 
 
11710 
  def __eq__(self, other):
11711 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11712 
 
11713 
  def __ne__(self, other):
11714 
    return not (self == other)
11715 
 
11716 
class getCancellableOrdersForCustomer_args:
11717 
  """
11718 
  Attributes:
11719 
   - customer_id
11720 
   - limit
11721 
  """
11722 
 
11723 
  thrift_spec = (
11724 
    None, # 0
11725 
    (1, TType.I64, 'customer_id', None, None, ), # 1
11726 
    (2, TType.I64, 'limit', None, None, ), # 2
11727 
  )
11728 
 
11729 
  def __init__(self, customer_id=None, limit=None,):
11730 
    self.customer_id = customer_id
11731 
    self.limit = limit
11732 
 
11733 
  def read(self, iprot):
11734 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11735 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11736 
      return
11737 
    iprot.readStructBegin()
11738 
    while True:
11739 
      (fname, ftype, fid) = iprot.readFieldBegin()
11740 
      if ftype == TType.STOP:
11741 
        break
11742 
      if fid == 1:
11743 
        if ftype == TType.I64:
11744 
          self.customer_id = iprot.readI64();
11745 
        else:
11746 
          iprot.skip(ftype)
11747 
      elif fid == 2:
11748 
        if ftype == TType.I64:
11749 
          self.limit = iprot.readI64();
11750 
        else:
11751 
          iprot.skip(ftype)
11752 
      else:
11753 
        iprot.skip(ftype)
11754 
      iprot.readFieldEnd()
11755 
    iprot.readStructEnd()
11756 
 
11757 
  def write(self, oprot):
11758 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11759 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11760 
      return
11761 
    oprot.writeStructBegin('getCancellableOrdersForCustomer_args')
3431 rajveer 11762 
    if self.customer_id is not None:
1382 varun.gupt 11763 
      oprot.writeFieldBegin('customer_id', TType.I64, 1)
11764 
      oprot.writeI64(self.customer_id)
11765 
      oprot.writeFieldEnd()
3431 rajveer 11766 
    if self.limit is not None:
1382 varun.gupt 11767 
      oprot.writeFieldBegin('limit', TType.I64, 2)
11768 
      oprot.writeI64(self.limit)
11769 
      oprot.writeFieldEnd()
11770 
    oprot.writeFieldStop()
11771 
    oprot.writeStructEnd()
11772 
 
3431 rajveer 11773 
  def validate(self):
11774 
    return
11775 
 
11776 
 
1382 varun.gupt 11777 
  def __repr__(self):
11778 
    L = ['%s=%r' % (key, value)
11779 
      for key, value in self.__dict__.iteritems()]
11780 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11781 
 
11782 
  def __eq__(self, other):
11783 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11784 
 
11785 
  def __ne__(self, other):
11786 
    return not (self == other)
11787 
 
11788 
class getCancellableOrdersForCustomer_result:
11789 
  """
11790 
  Attributes:
11791 
   - success
11792 
   - ex
11793 
  """
11794 
 
11795 
  thrift_spec = (
11796 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
11797 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
11798 
  )
11799 
 
11800 
  def __init__(self, success=None, ex=None,):
11801 
    self.success = success
11802 
    self.ex = ex
11803 
 
11804 
  def read(self, iprot):
11805 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11806 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11807 
      return
11808 
    iprot.readStructBegin()
11809 
    while True:
11810 
      (fname, ftype, fid) = iprot.readFieldBegin()
11811 
      if ftype == TType.STOP:
11812 
        break
11813 
      if fid == 0:
11814 
        if ftype == TType.LIST:
11815 
          self.success = []
6188 rajveer 11816 
          (_etype179, _size176) = iprot.readListBegin()
11817 
          for _i180 in xrange(_size176):
11818 
            _elem181 = iprot.readI64();
11819 
            self.success.append(_elem181)
1382 varun.gupt 11820 
          iprot.readListEnd()
11821 
        else:
11822 
          iprot.skip(ftype)
11823 
      elif fid == 1:
11824 
        if ftype == TType.STRUCT:
11825 
          self.ex = TransactionServiceException()
11826 
          self.ex.read(iprot)
11827 
        else:
11828 
          iprot.skip(ftype)
11829 
      else:
11830 
        iprot.skip(ftype)
11831 
      iprot.readFieldEnd()
11832 
    iprot.readStructEnd()
11833 
 
11834 
  def write(self, oprot):
11835 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11836 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11837 
      return
11838 
    oprot.writeStructBegin('getCancellableOrdersForCustomer_result')
3431 rajveer 11839 
    if self.success is not None:
1382 varun.gupt 11840 
      oprot.writeFieldBegin('success', TType.LIST, 0)
11841 
      oprot.writeListBegin(TType.I64, len(self.success))
6188 rajveer 11842 
      for iter182 in self.success:
11843 
        oprot.writeI64(iter182)
1382 varun.gupt 11844 
      oprot.writeListEnd()
11845 
      oprot.writeFieldEnd()
3431 rajveer 11846 
    if self.ex is not None:
1382 varun.gupt 11847 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11848 
      self.ex.write(oprot)
11849 
      oprot.writeFieldEnd()
11850 
    oprot.writeFieldStop()
11851 
    oprot.writeStructEnd()
11852 
 
3431 rajveer 11853 
  def validate(self):
11854 
    return
11855 
 
11856 
 
1382 varun.gupt 11857 
  def __repr__(self):
11858 
    L = ['%s=%r' % (key, value)
11859 
      for key, value in self.__dict__.iteritems()]
11860 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11861 
 
11862 
  def __eq__(self, other):
11863 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11864 
 
11865 
  def __ne__(self, other):
11866 
    return not (self == other)
11867 
 
483 rajveer 11868 
class changeOrderStatus_args:
94 ashish 11869 
  """
11870 
  Attributes:
483 rajveer 11871 
   - orderId
11872 
   - status
11873 
   - description
94 ashish 11874 
  """
11875 
 
11876 
  thrift_spec = (
11877 
    None, # 0
483 rajveer 11878 
    (1, TType.I64, 'orderId', None, None, ), # 1
11879 
    (2, TType.I32, 'status', None, None, ), # 2
11880 
    (3, TType.STRING, 'description', None, None, ), # 3
94 ashish 11881 
  )
11882 
 
483 rajveer 11883 
  def __init__(self, orderId=None, status=None, description=None,):
11884 
    self.orderId = orderId
11885 
    self.status = status
11886 
    self.description = description
94 ashish 11887 
 
11888 
  def read(self, iprot):
11889 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11890 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11891 
      return
11892 
    iprot.readStructBegin()
11893 
    while True:
11894 
      (fname, ftype, fid) = iprot.readFieldBegin()
11895 
      if ftype == TType.STOP:
11896 
        break
11897 
      if fid == 1:
11898 
        if ftype == TType.I64:
483 rajveer 11899 
          self.orderId = iprot.readI64();
94 ashish 11900 
        else:
11901 
          iprot.skip(ftype)
11902 
      elif fid == 2:
483 rajveer 11903 
        if ftype == TType.I32:
11904 
          self.status = iprot.readI32();
94 ashish 11905 
        else:
11906 
          iprot.skip(ftype)
483 rajveer 11907 
      elif fid == 3:
11908 
        if ftype == TType.STRING:
11909 
          self.description = iprot.readString();
11910 
        else:
11911 
          iprot.skip(ftype)
94 ashish 11912 
      else:
11913 
        iprot.skip(ftype)
11914 
      iprot.readFieldEnd()
11915 
    iprot.readStructEnd()
11916 
 
11917 
  def write(self, oprot):
11918 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11919 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11920 
      return
483 rajveer 11921 
    oprot.writeStructBegin('changeOrderStatus_args')
3431 rajveer 11922 
    if self.orderId is not None:
483 rajveer 11923 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
11924 
      oprot.writeI64(self.orderId)
94 ashish 11925 
      oprot.writeFieldEnd()
3431 rajveer 11926 
    if self.status is not None:
483 rajveer 11927 
      oprot.writeFieldBegin('status', TType.I32, 2)
11928 
      oprot.writeI32(self.status)
94 ashish 11929 
      oprot.writeFieldEnd()
3431 rajveer 11930 
    if self.description is not None:
483 rajveer 11931 
      oprot.writeFieldBegin('description', TType.STRING, 3)
11932 
      oprot.writeString(self.description)
11933 
      oprot.writeFieldEnd()
94 ashish 11934 
    oprot.writeFieldStop()
11935 
    oprot.writeStructEnd()
11936 
 
3431 rajveer 11937 
  def validate(self):
11938 
    return
11939 
 
11940 
 
94 ashish 11941 
  def __repr__(self):
11942 
    L = ['%s=%r' % (key, value)
11943 
      for key, value in self.__dict__.iteritems()]
11944 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11945 
 
11946 
  def __eq__(self, other):
11947 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11948 
 
11949 
  def __ne__(self, other):
11950 
    return not (self == other)
11951 
 
483 rajveer 11952 
class changeOrderStatus_result:
94 ashish 11953 
  """
11954 
  Attributes:
11955 
   - success
11956 
   - ex
11957 
  """
11958 
 
11959 
  thrift_spec = (
11960 
    (0, TType.BOOL, 'success', None, None, ), # 0
11961 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
11962 
  )
11963 
 
11964 
  def __init__(self, success=None, ex=None,):
11965 
    self.success = success
11966 
    self.ex = ex
11967 
 
11968 
  def read(self, iprot):
11969 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11970 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11971 
      return
11972 
    iprot.readStructBegin()
11973 
    while True:
11974 
      (fname, ftype, fid) = iprot.readFieldBegin()
11975 
      if ftype == TType.STOP:
11976 
        break
11977 
      if fid == 0:
11978 
        if ftype == TType.BOOL:
11979 
          self.success = iprot.readBool();
11980 
        else:
11981 
          iprot.skip(ftype)
11982 
      elif fid == 1:
11983 
        if ftype == TType.STRUCT:
11984 
          self.ex = TransactionServiceException()
11985 
          self.ex.read(iprot)
11986 
        else:
11987 
          iprot.skip(ftype)
11988 
      else:
11989 
        iprot.skip(ftype)
11990 
      iprot.readFieldEnd()
11991 
    iprot.readStructEnd()
11992 
 
11993 
  def write(self, oprot):
11994 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11995 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11996 
      return
483 rajveer 11997 
    oprot.writeStructBegin('changeOrderStatus_result')
3431 rajveer 11998 
    if self.success is not None:
94 ashish 11999 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
12000 
      oprot.writeBool(self.success)
12001 
      oprot.writeFieldEnd()
3431 rajveer 12002 
    if self.ex is not None:
94 ashish 12003 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
12004 
      self.ex.write(oprot)
12005 
      oprot.writeFieldEnd()
12006 
    oprot.writeFieldStop()
12007 
    oprot.writeStructEnd()
12008 
 
3431 rajveer 12009 
  def validate(self):
12010 
    return
12011 
 
12012 
 
94 ashish 12013 
  def __repr__(self):
12014 
    L = ['%s=%r' % (key, value)
12015 
      for key, value in self.__dict__.iteritems()]
12016 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12017 
 
12018 
  def __eq__(self, other):
12019 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12020 
 
12021 
  def __ne__(self, other):
12022 
    return not (self == other)
12023 
 
3064 chandransh 12024 
class getOrdersForTransaction_args:
494 rajveer 12025 
  """
12026 
  Attributes:
3064 chandransh 12027 
   - transactionId
12028 
   - customerId
494 rajveer 12029 
  """
12030 
 
12031 
  thrift_spec = (
12032 
    None, # 0
3064 chandransh 12033 
    (1, TType.I64, 'transactionId', None, None, ), # 1
12034 
    (2, TType.I64, 'customerId', None, None, ), # 2
494 rajveer 12035 
  )
12036 
 
3064 chandransh 12037 
  def __init__(self, transactionId=None, customerId=None,):
12038 
    self.transactionId = transactionId
12039 
    self.customerId = customerId
494 rajveer 12040 
 
12041 
  def read(self, iprot):
12042 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12043 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12044 
      return
12045 
    iprot.readStructBegin()
12046 
    while True:
12047 
      (fname, ftype, fid) = iprot.readFieldBegin()
12048 
      if ftype == TType.STOP:
12049 
        break
12050 
      if fid == 1:
12051 
        if ftype == TType.I64:
3064 chandransh 12052 
          self.transactionId = iprot.readI64();
494 rajveer 12053 
        else:
12054 
          iprot.skip(ftype)
12055 
      elif fid == 2:
3064 chandransh 12056 
        if ftype == TType.I64:
12057 
          self.customerId = iprot.readI64();
494 rajveer 12058 
        else:
12059 
          iprot.skip(ftype)
12060 
      else:
12061 
        iprot.skip(ftype)
12062 
      iprot.readFieldEnd()
12063 
    iprot.readStructEnd()
12064 
 
12065 
  def write(self, oprot):
12066 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12067 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12068 
      return
3064 chandransh 12069 
    oprot.writeStructBegin('getOrdersForTransaction_args')
3431 rajveer 12070 
    if self.transactionId is not None:
3064 chandransh 12071 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
12072 
      oprot.writeI64(self.transactionId)
494 rajveer 12073 
      oprot.writeFieldEnd()
3431 rajveer 12074 
    if self.customerId is not None:
3064 chandransh 12075 
      oprot.writeFieldBegin('customerId', TType.I64, 2)
12076 
      oprot.writeI64(self.customerId)
494 rajveer 12077 
      oprot.writeFieldEnd()
12078 
    oprot.writeFieldStop()
12079 
    oprot.writeStructEnd()
12080 
 
3431 rajveer 12081 
  def validate(self):
12082 
    return
12083 
 
12084 
 
494 rajveer 12085 
  def __repr__(self):
12086 
    L = ['%s=%r' % (key, value)
12087 
      for key, value in self.__dict__.iteritems()]
12088 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12089 
 
12090 
  def __eq__(self, other):
12091 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12092 
 
12093 
  def __ne__(self, other):
12094 
    return not (self == other)
12095 
 
3064 chandransh 12096 
class getOrdersForTransaction_result:
494 rajveer 12097 
  """
12098 
  Attributes:
12099 
   - success
12100 
   - ex
12101 
  """
12102 
 
12103 
  thrift_spec = (
3064 chandransh 12104 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
494 rajveer 12105 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
12106 
  )
12107 
 
12108 
  def __init__(self, success=None, ex=None,):
12109 
    self.success = success
12110 
    self.ex = ex
12111 
 
12112 
  def read(self, iprot):
12113 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12114 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12115 
      return
12116 
    iprot.readStructBegin()
12117 
    while True:
12118 
      (fname, ftype, fid) = iprot.readFieldBegin()
12119 
      if ftype == TType.STOP:
12120 
        break
12121 
      if fid == 0:
3064 chandransh 12122 
        if ftype == TType.LIST:
12123 
          self.success = []
6188 rajveer 12124 
          (_etype186, _size183) = iprot.readListBegin()
12125 
          for _i187 in xrange(_size183):
12126 
            _elem188 = Order()
12127 
            _elem188.read(iprot)
12128 
            self.success.append(_elem188)
3064 chandransh 12129 
          iprot.readListEnd()
494 rajveer 12130 
        else:
12131 
          iprot.skip(ftype)
12132 
      elif fid == 1:
12133 
        if ftype == TType.STRUCT:
12134 
          self.ex = TransactionServiceException()
12135 
          self.ex.read(iprot)
12136 
        else:
12137 
          iprot.skip(ftype)
12138 
      else:
12139 
        iprot.skip(ftype)
12140 
      iprot.readFieldEnd()
12141 
    iprot.readStructEnd()
12142 
 
12143 
  def write(self, oprot):
12144 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12145 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12146 
      return
3064 chandransh 12147 
    oprot.writeStructBegin('getOrdersForTransaction_result')
3431 rajveer 12148 
    if self.success is not None:
3064 chandransh 12149 
      oprot.writeFieldBegin('success', TType.LIST, 0)
12150 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 12151 
      for iter189 in self.success:
12152 
        iter189.write(oprot)
3064 chandransh 12153 
      oprot.writeListEnd()
494 rajveer 12154 
      oprot.writeFieldEnd()
3431 rajveer 12155 
    if self.ex is not None:
494 rajveer 12156 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
12157 
      self.ex.write(oprot)
12158 
      oprot.writeFieldEnd()
12159 
    oprot.writeFieldStop()
12160 
    oprot.writeStructEnd()
12161 
 
3431 rajveer 12162 
  def validate(self):
12163 
    return
12164 
 
12165 
 
494 rajveer 12166 
  def __repr__(self):
12167 
    L = ['%s=%r' % (key, value)
12168 
      for key, value in self.__dict__.iteritems()]
12169 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12170 
 
12171 
  def __eq__(self, other):
12172 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12173 
 
12174 
  def __ne__(self, other):
12175 
    return not (self == other)
12176 
 
3064 chandransh 12177 
class getOrdersForCustomer_args:
1149 chandransh 12178 
  """
12179 
  Attributes:
3064 chandransh 12180 
   - customerId
12181 
   - from_date
12182 
   - to_date
12183 
   - statuses
1149 chandransh 12184 
  """
12185 
 
12186 
  thrift_spec = (
12187 
    None, # 0
3064 chandransh 12188 
    (1, TType.I64, 'customerId', None, None, ), # 1
12189 
    (2, TType.I64, 'from_date', None, None, ), # 2
12190 
    (3, TType.I64, 'to_date', None, None, ), # 3
12191 
    (4, TType.LIST, 'statuses', (TType.I32,None), None, ), # 4
1149 chandransh 12192 
  )
12193 
 
3064 chandransh 12194 
  def __init__(self, customerId=None, from_date=None, to_date=None, statuses=None,):
12195 
    self.customerId = customerId
12196 
    self.from_date = from_date
12197 
    self.to_date = to_date
12198 
    self.statuses = statuses
1149 chandransh 12199 
 
12200 
  def read(self, iprot):
12201 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12202 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12203 
      return
12204 
    iprot.readStructBegin()
12205 
    while True:
12206 
      (fname, ftype, fid) = iprot.readFieldBegin()
12207 
      if ftype == TType.STOP:
12208 
        break
12209 
      if fid == 1:
12210 
        if ftype == TType.I64:
3064 chandransh 12211 
          self.customerId = iprot.readI64();
1149 chandransh 12212 
        else:
12213 
          iprot.skip(ftype)
12214 
      elif fid == 2:
12215 
        if ftype == TType.I64:
3064 chandransh 12216 
          self.from_date = iprot.readI64();
1149 chandransh 12217 
        else:
12218 
          iprot.skip(ftype)
2783 chandransh 12219 
      elif fid == 3:
12220 
        if ftype == TType.I64:
3064 chandransh 12221 
          self.to_date = iprot.readI64();
2783 chandransh 12222 
        else:
12223 
          iprot.skip(ftype)
12224 
      elif fid == 4:
3064 chandransh 12225 
        if ftype == TType.LIST:
12226 
          self.statuses = []
6188 rajveer 12227 
          (_etype193, _size190) = iprot.readListBegin()
12228 
          for _i194 in xrange(_size190):
12229 
            _elem195 = iprot.readI32();
12230 
            self.statuses.append(_elem195)
3064 chandransh 12231 
          iprot.readListEnd()
2783 chandransh 12232 
        else:
12233 
          iprot.skip(ftype)
1149 chandransh 12234 
      else:
12235 
        iprot.skip(ftype)
12236 
      iprot.readFieldEnd()
12237 
    iprot.readStructEnd()
12238 
 
12239 
  def write(self, oprot):
12240 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12241 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12242 
      return
3064 chandransh 12243 
    oprot.writeStructBegin('getOrdersForCustomer_args')
3431 rajveer 12244 
    if self.customerId is not None:
3064 chandransh 12245 
      oprot.writeFieldBegin('customerId', TType.I64, 1)
12246 
      oprot.writeI64(self.customerId)
1149 chandransh 12247 
      oprot.writeFieldEnd()
3431 rajveer 12248 
    if self.from_date is not None:
3064 chandransh 12249 
      oprot.writeFieldBegin('from_date', TType.I64, 2)
12250 
      oprot.writeI64(self.from_date)
1149 chandransh 12251 
      oprot.writeFieldEnd()
3431 rajveer 12252 
    if self.to_date is not None:
3064 chandransh 12253 
      oprot.writeFieldBegin('to_date', TType.I64, 3)
12254 
      oprot.writeI64(self.to_date)
2783 chandransh 12255 
      oprot.writeFieldEnd()
3431 rajveer 12256 
    if self.statuses is not None:
3064 chandransh 12257 
      oprot.writeFieldBegin('statuses', TType.LIST, 4)
12258 
      oprot.writeListBegin(TType.I32, len(self.statuses))
6188 rajveer 12259 
      for iter196 in self.statuses:
12260 
        oprot.writeI32(iter196)
3064 chandransh 12261 
      oprot.writeListEnd()
2783 chandransh 12262 
      oprot.writeFieldEnd()
1149 chandransh 12263 
    oprot.writeFieldStop()
12264 
    oprot.writeStructEnd()
12265 
 
3431 rajveer 12266 
  def validate(self):
12267 
    return
12268 
 
12269 
 
1149 chandransh 12270 
  def __repr__(self):
12271 
    L = ['%s=%r' % (key, value)
12272 
      for key, value in self.__dict__.iteritems()]
12273 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12274 
 
12275 
  def __eq__(self, other):
12276 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12277 
 
12278 
  def __ne__(self, other):
12279 
    return not (self == other)
12280 
 
3064 chandransh 12281 
class getOrdersForCustomer_result:
1149 chandransh 12282 
  """
12283 
  Attributes:
12284 
   - success
12285 
   - ex
12286 
  """
12287 
 
12288 
  thrift_spec = (
3064 chandransh 12289 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
1149 chandransh 12290 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
12291 
  )
12292 
 
12293 
  def __init__(self, success=None, ex=None,):
12294 
    self.success = success
12295 
    self.ex = ex
12296 
 
12297 
  def read(self, iprot):
12298 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12299 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12300 
      return
12301 
    iprot.readStructBegin()
12302 
    while True:
12303 
      (fname, ftype, fid) = iprot.readFieldBegin()
12304 
      if ftype == TType.STOP:
12305 
        break
12306 
      if fid == 0:
3064 chandransh 12307 
        if ftype == TType.LIST:
12308 
          self.success = []
6188 rajveer 12309 
          (_etype200, _size197) = iprot.readListBegin()
12310 
          for _i201 in xrange(_size197):
12311 
            _elem202 = Order()
12312 
            _elem202.read(iprot)
12313 
            self.success.append(_elem202)
3064 chandransh 12314 
          iprot.readListEnd()
1149 chandransh 12315 
        else:
12316 
          iprot.skip(ftype)
12317 
      elif fid == 1:
12318 
        if ftype == TType.STRUCT:
12319 
          self.ex = TransactionServiceException()
12320 
          self.ex.read(iprot)
12321 
        else:
12322 
          iprot.skip(ftype)
12323 
      else:
12324 
        iprot.skip(ftype)
12325 
      iprot.readFieldEnd()
12326 
    iprot.readStructEnd()
12327 
 
12328 
  def write(self, oprot):
12329 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12330 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12331 
      return
3064 chandransh 12332 
    oprot.writeStructBegin('getOrdersForCustomer_result')
3431 rajveer 12333 
    if self.success is not None:
3064 chandransh 12334 
      oprot.writeFieldBegin('success', TType.LIST, 0)
12335 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 12336 
      for iter203 in self.success:
12337 
        iter203.write(oprot)
3064 chandransh 12338 
      oprot.writeListEnd()
1149 chandransh 12339 
      oprot.writeFieldEnd()
3431 rajveer 12340 
    if self.ex is not None:
1149 chandransh 12341 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
12342 
      self.ex.write(oprot)
12343 
      oprot.writeFieldEnd()
12344 
    oprot.writeFieldStop()
12345 
    oprot.writeStructEnd()
12346 
 
3431 rajveer 12347 
  def validate(self):
12348 
    return
12349 
 
12350 
 
1149 chandransh 12351 
  def __repr__(self):
12352 
    L = ['%s=%r' % (key, value)
12353 
      for key, value in self.__dict__.iteritems()]
12354 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12355 
 
12356 
  def __eq__(self, other):
12357 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12358 
 
12359 
  def __ne__(self, other):
12360 
    return not (self == other)
12361 
 
3064 chandransh 12362 
class createOrder_args:
921 rajveer 12363 
  """
12364 
  Attributes:
3064 chandransh 12365 
   - order
921 rajveer 12366 
  """
12367 
 
12368 
  thrift_spec = (
12369 
    None, # 0
3064 chandransh 12370 
    (1, TType.STRUCT, 'order', (Order, Order.thrift_spec), None, ), # 1
921 rajveer 12371 
  )
12372 
 
3064 chandransh 12373 
  def __init__(self, order=None,):
12374 
    self.order = order
921 rajveer 12375 
 
12376 
  def read(self, iprot):
12377 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12378 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12379 
      return
12380 
    iprot.readStructBegin()
12381 
    while True:
12382 
      (fname, ftype, fid) = iprot.readFieldBegin()
12383 
      if ftype == TType.STOP:
12384 
        break
12385 
      if fid == 1:
3064 chandransh 12386 
        if ftype == TType.STRUCT:
12387 
          self.order = Order()
12388 
          self.order.read(iprot)
921 rajveer 12389 
        else:
12390 
          iprot.skip(ftype)
12391 
      else:
12392 
        iprot.skip(ftype)
12393 
      iprot.readFieldEnd()
12394 
    iprot.readStructEnd()
12395 
 
12396 
  def write(self, oprot):
12397 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12398 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12399 
      return
3064 chandransh 12400 
    oprot.writeStructBegin('createOrder_args')
3431 rajveer 12401 
    if self.order is not None:
3064 chandransh 12402 
      oprot.writeFieldBegin('order', TType.STRUCT, 1)
12403 
      self.order.write(oprot)
921 rajveer 12404 
      oprot.writeFieldEnd()
12405 
    oprot.writeFieldStop()
12406 
    oprot.writeStructEnd()
12407 
 
3431 rajveer 12408 
  def validate(self):
12409 
    return
12410 
 
12411 
 
921 rajveer 12412 
  def __repr__(self):
12413 
    L = ['%s=%r' % (key, value)
12414 
      for key, value in self.__dict__.iteritems()]
12415 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12416 
 
12417 
  def __eq__(self, other):
12418 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12419 
 
12420 
  def __ne__(self, other):
12421 
    return not (self == other)
12422 
 
3064 chandransh 12423 
class createOrder_result:
921 rajveer 12424 
  """
12425 
  Attributes:
12426 
   - success
12427 
   - ex
12428 
  """
12429 
 
12430 
  thrift_spec = (
3064 chandransh 12431 
    (0, TType.I64, 'success', None, None, ), # 0
921 rajveer 12432 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
12433 
  )
12434 
 
12435 
  def __init__(self, success=None, ex=None,):
12436 
    self.success = success
12437 
    self.ex = ex
12438 
 
12439 
  def read(self, iprot):
12440 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12441 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12442 
      return
12443 
    iprot.readStructBegin()
12444 
    while True:
12445 
      (fname, ftype, fid) = iprot.readFieldBegin()
12446 
      if ftype == TType.STOP:
12447 
        break
12448 
      if fid == 0:
3064 chandransh 12449 
        if ftype == TType.I64:
12450 
          self.success = iprot.readI64();
921 rajveer 12451 
        else:
12452 
          iprot.skip(ftype)
12453 
      elif fid == 1:
12454 
        if ftype == TType.STRUCT:
12455 
          self.ex = TransactionServiceException()
12456 
          self.ex.read(iprot)
12457 
        else:
12458 
          iprot.skip(ftype)
12459 
      else:
12460 
        iprot.skip(ftype)
12461 
      iprot.readFieldEnd()
12462 
    iprot.readStructEnd()
12463 
 
12464 
  def write(self, oprot):
12465 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12466 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12467 
      return
3064 chandransh 12468 
    oprot.writeStructBegin('createOrder_result')
3431 rajveer 12469 
    if self.success is not None:
3064 chandransh 12470 
      oprot.writeFieldBegin('success', TType.I64, 0)
12471 
      oprot.writeI64(self.success)
921 rajveer 12472 
      oprot.writeFieldEnd()
3431 rajveer 12473 
    if self.ex is not None:
921 rajveer 12474 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
12475 
      self.ex.write(oprot)
12476 
      oprot.writeFieldEnd()
12477 
    oprot.writeFieldStop()
12478 
    oprot.writeStructEnd()
12479 
 
3431 rajveer 12480 
  def validate(self):
12481 
    return
12482 
 
12483 
 
921 rajveer 12484 
  def __repr__(self):
12485 
    L = ['%s=%r' % (key, value)
12486 
      for key, value in self.__dict__.iteritems()]
12487 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12488 
 
12489 
  def __eq__(self, other):
12490 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12491 
 
12492 
  def __ne__(self, other):
12493 
    return not (self == other)
12494 
 
3064 chandransh 12495 
class getOrder_args:
921 rajveer 12496 
  """
12497 
  Attributes:
3064 chandransh 12498 
   - id
921 rajveer 12499 
  """
12500 
 
12501 
  thrift_spec = (
12502 
    None, # 0
3064 chandransh 12503 
    (1, TType.I64, 'id', None, None, ), # 1
921 rajveer 12504 
  )
12505 
 
3064 chandransh 12506 
  def __init__(self, id=None,):
12507 
    self.id = id
921 rajveer 12508 
 
12509 
  def read(self, iprot):
12510 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12511 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12512 
      return
12513 
    iprot.readStructBegin()
12514 
    while True:
12515 
      (fname, ftype, fid) = iprot.readFieldBegin()
12516 
      if ftype == TType.STOP:
12517 
        break
12518 
      if fid == 1:
12519 
        if ftype == TType.I64:
3064 chandransh 12520 
          self.id = iprot.readI64();
921 rajveer 12521 
        else:
12522 
          iprot.skip(ftype)
12523 
      else:
12524 
        iprot.skip(ftype)
12525 
      iprot.readFieldEnd()
12526 
    iprot.readStructEnd()
12527 
 
12528 
  def write(self, oprot):
12529 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12530 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12531 
      return
3064 chandransh 12532 
    oprot.writeStructBegin('getOrder_args')
3431 rajveer 12533 
    if self.id is not None:
3064 chandransh 12534 
      oprot.writeFieldBegin('id', TType.I64, 1)
12535 
      oprot.writeI64(self.id)
921 rajveer 12536 
      oprot.writeFieldEnd()
12537 
    oprot.writeFieldStop()
12538 
    oprot.writeStructEnd()
12539 
 
3431 rajveer 12540 
  def validate(self):
12541 
    return
12542 
 
12543 
 
921 rajveer 12544 
  def __repr__(self):
12545 
    L = ['%s=%r' % (key, value)
12546 
      for key, value in self.__dict__.iteritems()]
12547 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12548 
 
12549 
  def __eq__(self, other):
12550 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12551 
 
12552 
  def __ne__(self, other):
12553 
    return not (self == other)
12554 
 
3064 chandransh 12555 
class getOrder_result:
921 rajveer 12556 
  """
12557 
  Attributes:
12558 
   - success
12559 
   - ex
12560 
  """
12561 
 
12562 
  thrift_spec = (
3064 chandransh 12563 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
921 rajveer 12564 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
12565 
  )
12566 
 
12567 
  def __init__(self, success=None, ex=None,):
12568 
    self.success = success
12569 
    self.ex = ex
12570 
 
12571 
  def read(self, iprot):
12572 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12573 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12574 
      return
12575 
    iprot.readStructBegin()
12576 
    while True:
12577 
      (fname, ftype, fid) = iprot.readFieldBegin()
12578 
      if ftype == TType.STOP:
12579 
        break
12580 
      if fid == 0:
3064 chandransh 12581 
        if ftype == TType.STRUCT:
12582 
          self.success = Order()
12583 
          self.success.read(iprot)
921 rajveer 12584 
        else:
12585 
          iprot.skip(ftype)
12586 
      elif fid == 1:
12587 
        if ftype == TType.STRUCT:
12588 
          self.ex = TransactionServiceException()
12589 
          self.ex.read(iprot)
12590 
        else:
12591 
          iprot.skip(ftype)
12592 
      else:
12593 
        iprot.skip(ftype)
12594 
      iprot.readFieldEnd()
12595 
    iprot.readStructEnd()
12596 
 
12597 
  def write(self, oprot):
12598 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12599 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12600 
      return
3064 chandransh 12601 
    oprot.writeStructBegin('getOrder_result')
3431 rajveer 12602 
    if self.success is not None:
3064 chandransh 12603 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
12604 
      self.success.write(oprot)
921 rajveer 12605 
      oprot.writeFieldEnd()
3431 rajveer 12606 
    if self.ex is not None:
921 rajveer 12607 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
12608 
      self.ex.write(oprot)
12609 
      oprot.writeFieldEnd()
12610 
    oprot.writeFieldStop()
12611 
    oprot.writeStructEnd()
12612 
 
3431 rajveer 12613 
  def validate(self):
12614 
    return
12615 
 
12616 
 
921 rajveer 12617 
  def __repr__(self):
12618 
    L = ['%s=%r' % (key, value)
12619 
      for key, value in self.__dict__.iteritems()]
12620 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12621 
 
12622 
  def __eq__(self, other):
12623 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12624 
 
12625 
  def __ne__(self, other):
12626 
    return not (self == other)
12627 
 
3064 chandransh 12628 
class getLineItemsForOrder_args:
94 ashish 12629 
  """
12630 
  Attributes:
3064 chandransh 12631 
   - orderId
94 ashish 12632 
  """
12633 
 
12634 
  thrift_spec = (
12635 
    None, # 0
3064 chandransh 12636 
    (1, TType.I64, 'orderId', None, None, ), # 1
94 ashish 12637 
  )
12638 
 
3064 chandransh 12639 
  def __init__(self, orderId=None,):
12640 
    self.orderId = orderId
94 ashish 12641 
 
12642 
  def read(self, iprot):
12643 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12644 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12645 
      return
12646 
    iprot.readStructBegin()
12647 
    while True:
12648 
      (fname, ftype, fid) = iprot.readFieldBegin()
12649 
      if ftype == TType.STOP:
12650 
        break
12651 
      if fid == 1:
12652 
        if ftype == TType.I64:
3064 chandransh 12653 
          self.orderId = iprot.readI64();
94 ashish 12654 
        else:
12655 
          iprot.skip(ftype)
12656 
      else:
12657 
        iprot.skip(ftype)
12658 
      iprot.readFieldEnd()
12659 
    iprot.readStructEnd()
12660 
 
12661 
  def write(self, oprot):
12662 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12663 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12664 
      return
3064 chandransh 12665 
    oprot.writeStructBegin('getLineItemsForOrder_args')
3431 rajveer 12666 
    if self.orderId is not None:
3064 chandransh 12667 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
12668 
      oprot.writeI64(self.orderId)
94 ashish 12669 
      oprot.writeFieldEnd()
12670 
    oprot.writeFieldStop()
12671 
    oprot.writeStructEnd()
12672 
 
3431 rajveer 12673 
  def validate(self):
12674 
    return
12675 
 
12676 
 
94 ashish 12677 
  def __repr__(self):
12678 
    L = ['%s=%r' % (key, value)
12679 
      for key, value in self.__dict__.iteritems()]
12680 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12681 
 
12682 
  def __eq__(self, other):
12683 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12684 
 
12685 
  def __ne__(self, other):
12686 
    return not (self == other)
12687 
 
3064 chandransh 12688 
class getLineItemsForOrder_result:
94 ashish 12689 
  """
12690 
  Attributes:
12691 
   - success
12692 
   - ex
12693 
  """
12694 
 
12695 
  thrift_spec = (
3064 chandransh 12696 
    (0, TType.LIST, 'success', (TType.STRUCT,(LineItem, LineItem.thrift_spec)), None, ), # 0
94 ashish 12697 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
12698 
  )
12699 
 
12700 
  def __init__(self, success=None, ex=None,):
12701 
    self.success = success
12702 
    self.ex = ex
12703 
 
12704 
  def read(self, iprot):
12705 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12706 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12707 
      return
12708 
    iprot.readStructBegin()
12709 
    while True:
12710 
      (fname, ftype, fid) = iprot.readFieldBegin()
12711 
      if ftype == TType.STOP:
12712 
        break
12713 
      if fid == 0:
483 rajveer 12714 
        if ftype == TType.LIST:
12715 
          self.success = []
6188 rajveer 12716 
          (_etype207, _size204) = iprot.readListBegin()
12717 
          for _i208 in xrange(_size204):
12718 
            _elem209 = LineItem()
12719 
            _elem209.read(iprot)
12720 
            self.success.append(_elem209)
483 rajveer 12721 
          iprot.readListEnd()
94 ashish 12722 
        else:
12723 
          iprot.skip(ftype)
12724 
      elif fid == 1:
12725 
        if ftype == TType.STRUCT:
12726 
          self.ex = TransactionServiceException()
12727 
          self.ex.read(iprot)
12728 
        else:
12729 
          iprot.skip(ftype)
12730 
      else:
12731 
        iprot.skip(ftype)
12732 
      iprot.readFieldEnd()
12733 
    iprot.readStructEnd()
12734 
 
12735 
  def write(self, oprot):
12736 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12737 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12738 
      return
3064 chandransh 12739 
    oprot.writeStructBegin('getLineItemsForOrder_result')
3431 rajveer 12740 
    if self.success is not None:
483 rajveer 12741 
      oprot.writeFieldBegin('success', TType.LIST, 0)
12742 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 12743 
      for iter210 in self.success:
12744 
        iter210.write(oprot)
483 rajveer 12745 
      oprot.writeListEnd()
94 ashish 12746 
      oprot.writeFieldEnd()
3431 rajveer 12747 
    if self.ex is not None:
94 ashish 12748 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
12749 
      self.ex.write(oprot)
12750 
      oprot.writeFieldEnd()
12751 
    oprot.writeFieldStop()
12752 
    oprot.writeStructEnd()
12753 
 
3431 rajveer 12754 
  def validate(self):
12755 
    return
12756 
 
12757 
 
94 ashish 12758 
  def __repr__(self):
12759 
    L = ['%s=%r' % (key, value)
12760 
      for key, value in self.__dict__.iteritems()]
12761 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12762 
 
12763 
  def __eq__(self, other):
12764 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12765 
 
12766 
  def __ne__(self, other):
12767 
    return not (self == other)
12768 
 
4999 phani.kuma 12769 
class getOrderList_args:
12770 
  """
12771 
  Attributes:
12772 
   - order_ids
12773 
  """
12774 
 
12775 
  thrift_spec = (
12776 
    None, # 0
12777 
    (1, TType.LIST, 'order_ids', (TType.I64,None), None, ), # 1
12778 
  )
12779 
 
12780 
  def __init__(self, order_ids=None,):
12781 
    self.order_ids = order_ids
12782 
 
12783 
  def read(self, iprot):
12784 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12785 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12786 
      return
12787 
    iprot.readStructBegin()
12788 
    while True:
12789 
      (fname, ftype, fid) = iprot.readFieldBegin()
12790 
      if ftype == TType.STOP:
12791 
        break
12792 
      if fid == 1:
12793 
        if ftype == TType.LIST:
12794 
          self.order_ids = []
6188 rajveer 12795 
          (_etype214, _size211) = iprot.readListBegin()
12796 
          for _i215 in xrange(_size211):
12797 
            _elem216 = iprot.readI64();
12798 
            self.order_ids.append(_elem216)
4999 phani.kuma 12799 
          iprot.readListEnd()
12800 
        else:
12801 
          iprot.skip(ftype)
12802 
      else:
12803 
        iprot.skip(ftype)
12804 
      iprot.readFieldEnd()
12805 
    iprot.readStructEnd()
12806 
 
12807 
  def write(self, oprot):
12808 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12809 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12810 
      return
12811 
    oprot.writeStructBegin('getOrderList_args')
12812 
    if self.order_ids is not None:
12813 
      oprot.writeFieldBegin('order_ids', TType.LIST, 1)
12814 
      oprot.writeListBegin(TType.I64, len(self.order_ids))
6188 rajveer 12815 
      for iter217 in self.order_ids:
12816 
        oprot.writeI64(iter217)
4999 phani.kuma 12817 
      oprot.writeListEnd()
12818 
      oprot.writeFieldEnd()
12819 
    oprot.writeFieldStop()
12820 
    oprot.writeStructEnd()
12821 
 
12822 
  def validate(self):
12823 
    return
12824 
 
12825 
 
12826 
  def __repr__(self):
12827 
    L = ['%s=%r' % (key, value)
12828 
      for key, value in self.__dict__.iteritems()]
12829 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12830 
 
12831 
  def __eq__(self, other):
12832 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12833 
 
12834 
  def __ne__(self, other):
12835 
    return not (self == other)
12836 
 
12837 
class getOrderList_result:
12838 
  """
12839 
  Attributes:
12840 
   - success
12841 
  """
12842 
 
12843 
  thrift_spec = (
12844 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
12845 
  )
12846 
 
12847 
  def __init__(self, success=None,):
12848 
    self.success = success
12849 
 
12850 
  def read(self, iprot):
12851 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12852 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12853 
      return
12854 
    iprot.readStructBegin()
12855 
    while True:
12856 
      (fname, ftype, fid) = iprot.readFieldBegin()
12857 
      if ftype == TType.STOP:
12858 
        break
12859 
      if fid == 0:
12860 
        if ftype == TType.LIST:
12861 
          self.success = []
6188 rajveer 12862 
          (_etype221, _size218) = iprot.readListBegin()
12863 
          for _i222 in xrange(_size218):
12864 
            _elem223 = Order()
12865 
            _elem223.read(iprot)
12866 
            self.success.append(_elem223)
4999 phani.kuma 12867 
          iprot.readListEnd()
12868 
        else:
12869 
          iprot.skip(ftype)
12870 
      else:
12871 
        iprot.skip(ftype)
12872 
      iprot.readFieldEnd()
12873 
    iprot.readStructEnd()
12874 
 
12875 
  def write(self, oprot):
12876 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12877 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12878 
      return
12879 
    oprot.writeStructBegin('getOrderList_result')
12880 
    if self.success is not None:
12881 
      oprot.writeFieldBegin('success', TType.LIST, 0)
12882 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 12883 
      for iter224 in self.success:
12884 
        iter224.write(oprot)
4999 phani.kuma 12885 
      oprot.writeListEnd()
12886 
      oprot.writeFieldEnd()
12887 
    oprot.writeFieldStop()
12888 
    oprot.writeStructEnd()
12889 
 
12890 
  def validate(self):
12891 
    return
12892 
 
12893 
 
12894 
  def __repr__(self):
12895 
    L = ['%s=%r' % (key, value)
12896 
      for key, value in self.__dict__.iteritems()]
12897 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12898 
 
12899 
  def __eq__(self, other):
12900 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12901 
 
12902 
  def __ne__(self, other):
12903 
    return not (self == other)
12904 
 
5386 phani.kuma 12905 
class getOrderListForVendor_args:
12906 
  """
12907 
  Attributes:
12908 
   - order_ids
12909 
   - vendorId
12910 
  """
12911 
 
12912 
  thrift_spec = (
12913 
    None, # 0
12914 
    (1, TType.LIST, 'order_ids', (TType.I64,None), None, ), # 1
12915 
    (2, TType.I64, 'vendorId', None, None, ), # 2
12916 
  )
12917 
 
12918 
  def __init__(self, order_ids=None, vendorId=None,):
12919 
    self.order_ids = order_ids
12920 
    self.vendorId = vendorId
12921 
 
12922 
  def read(self, iprot):
12923 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12924 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12925 
      return
12926 
    iprot.readStructBegin()
12927 
    while True:
12928 
      (fname, ftype, fid) = iprot.readFieldBegin()
12929 
      if ftype == TType.STOP:
12930 
        break
12931 
      if fid == 1:
12932 
        if ftype == TType.LIST:
12933 
          self.order_ids = []
6188 rajveer 12934 
          (_etype228, _size225) = iprot.readListBegin()
12935 
          for _i229 in xrange(_size225):
12936 
            _elem230 = iprot.readI64();
12937 
            self.order_ids.append(_elem230)
5386 phani.kuma 12938 
          iprot.readListEnd()
12939 
        else:
12940 
          iprot.skip(ftype)
12941 
      elif fid == 2:
12942 
        if ftype == TType.I64:
12943 
          self.vendorId = iprot.readI64();
12944 
        else:
12945 
          iprot.skip(ftype)
12946 
      else:
12947 
        iprot.skip(ftype)
12948 
      iprot.readFieldEnd()
12949 
    iprot.readStructEnd()
12950 
 
12951 
  def write(self, oprot):
12952 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12953 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12954 
      return
12955 
    oprot.writeStructBegin('getOrderListForVendor_args')
12956 
    if self.order_ids is not None:
12957 
      oprot.writeFieldBegin('order_ids', TType.LIST, 1)
12958 
      oprot.writeListBegin(TType.I64, len(self.order_ids))
6188 rajveer 12959 
      for iter231 in self.order_ids:
12960 
        oprot.writeI64(iter231)
5386 phani.kuma 12961 
      oprot.writeListEnd()
12962 
      oprot.writeFieldEnd()
12963 
    if self.vendorId is not None:
12964 
      oprot.writeFieldBegin('vendorId', TType.I64, 2)
12965 
      oprot.writeI64(self.vendorId)
12966 
      oprot.writeFieldEnd()
12967 
    oprot.writeFieldStop()
12968 
    oprot.writeStructEnd()
12969 
 
12970 
  def validate(self):
12971 
    return
12972 
 
12973 
 
12974 
  def __repr__(self):
12975 
    L = ['%s=%r' % (key, value)
12976 
      for key, value in self.__dict__.iteritems()]
12977 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12978 
 
12979 
  def __eq__(self, other):
12980 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12981 
 
12982 
  def __ne__(self, other):
12983 
    return not (self == other)
12984 
 
12985 
class getOrderListForVendor_result:
12986 
  """
12987 
  Attributes:
12988 
   - success
12989 
  """
12990 
 
12991 
  thrift_spec = (
12992 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
12993 
  )
12994 
 
12995 
  def __init__(self, success=None,):
12996 
    self.success = success
12997 
 
12998 
  def read(self, iprot):
12999 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13000 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13001 
      return
13002 
    iprot.readStructBegin()
13003 
    while True:
13004 
      (fname, ftype, fid) = iprot.readFieldBegin()
13005 
      if ftype == TType.STOP:
13006 
        break
13007 
      if fid == 0:
13008 
        if ftype == TType.LIST:
13009 
          self.success = []
6188 rajveer 13010 
          (_etype235, _size232) = iprot.readListBegin()
13011 
          for _i236 in xrange(_size232):
13012 
            _elem237 = Order()
13013 
            _elem237.read(iprot)
13014 
            self.success.append(_elem237)
5386 phani.kuma 13015 
          iprot.readListEnd()
13016 
        else:
13017 
          iprot.skip(ftype)
13018 
      else:
13019 
        iprot.skip(ftype)
13020 
      iprot.readFieldEnd()
13021 
    iprot.readStructEnd()
13022 
 
13023 
  def write(self, oprot):
13024 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13025 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13026 
      return
13027 
    oprot.writeStructBegin('getOrderListForVendor_result')
13028 
    if self.success is not None:
13029 
      oprot.writeFieldBegin('success', TType.LIST, 0)
13030 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 13031 
      for iter238 in self.success:
13032 
        iter238.write(oprot)
5386 phani.kuma 13033 
      oprot.writeListEnd()
13034 
      oprot.writeFieldEnd()
13035 
    oprot.writeFieldStop()
13036 
    oprot.writeStructEnd()
13037 
 
13038 
  def validate(self):
13039 
    return
13040 
 
13041 
 
13042 
  def __repr__(self):
13043 
    L = ['%s=%r' % (key, value)
13044 
      for key, value in self.__dict__.iteritems()]
13045 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13046 
 
13047 
  def __eq__(self, other):
13048 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13049 
 
13050 
  def __ne__(self, other):
13051 
    return not (self == other)
13052 
 
3064 chandransh 13053 
class getOrderForCustomer_args:
94 ashish 13054 
  """
13055 
  Attributes:
3064 chandransh 13056 
   - orderId
483 rajveer 13057 
   - customerId
94 ashish 13058 
  """
13059 
 
13060 
  thrift_spec = (
13061 
    None, # 0
3064 chandransh 13062 
    (1, TType.I64, 'orderId', None, None, ), # 1
13063 
    (2, TType.I64, 'customerId', None, None, ), # 2
94 ashish 13064 
  )
13065 
 
3064 chandransh 13066 
  def __init__(self, orderId=None, customerId=None,):
13067 
    self.orderId = orderId
483 rajveer 13068 
    self.customerId = customerId
94 ashish 13069 
 
13070 
  def read(self, iprot):
13071 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13072 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13073 
      return
13074 
    iprot.readStructBegin()
13075 
    while True:
13076 
      (fname, ftype, fid) = iprot.readFieldBegin()
13077 
      if ftype == TType.STOP:
13078 
        break
13079 
      if fid == 1:
13080 
        if ftype == TType.I64:
3064 chandransh 13081 
          self.orderId = iprot.readI64();
94 ashish 13082 
        else:
13083 
          iprot.skip(ftype)
13084 
      elif fid == 2:
13085 
        if ftype == TType.I64:
3064 chandransh 13086 
          self.customerId = iprot.readI64();
94 ashish 13087 
        else:
13088 
          iprot.skip(ftype)
13089 
      else:
13090 
        iprot.skip(ftype)
13091 
      iprot.readFieldEnd()
13092 
    iprot.readStructEnd()
13093 
 
13094 
  def write(self, oprot):
13095 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13096 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13097 
      return
3064 chandransh 13098 
    oprot.writeStructBegin('getOrderForCustomer_args')
3431 rajveer 13099 
    if self.orderId is not None:
3064 chandransh 13100 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
13101 
      oprot.writeI64(self.orderId)
13102 
      oprot.writeFieldEnd()
3431 rajveer 13103 
    if self.customerId is not None:
3064 chandransh 13104 
      oprot.writeFieldBegin('customerId', TType.I64, 2)
483 rajveer 13105 
      oprot.writeI64(self.customerId)
94 ashish 13106 
      oprot.writeFieldEnd()
13107 
    oprot.writeFieldStop()
13108 
    oprot.writeStructEnd()
13109 
 
3431 rajveer 13110 
  def validate(self):
13111 
    return
13112 
 
13113 
 
94 ashish 13114 
  def __repr__(self):
13115 
    L = ['%s=%r' % (key, value)
13116 
      for key, value in self.__dict__.iteritems()]
13117 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13118 
 
13119 
  def __eq__(self, other):
13120 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13121 
 
13122 
  def __ne__(self, other):
13123 
    return not (self == other)
13124 
 
3064 chandransh 13125 
class getOrderForCustomer_result:
94 ashish 13126 
  """
13127 
  Attributes:
13128 
   - success
13129 
   - ex
13130 
  """
13131 
 
13132 
  thrift_spec = (
3064 chandransh 13133 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
94 ashish 13134 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
13135 
  )
13136 
 
13137 
  def __init__(self, success=None, ex=None,):
13138 
    self.success = success
13139 
    self.ex = ex
13140 
 
13141 
  def read(self, iprot):
13142 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13143 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13144 
      return
13145 
    iprot.readStructBegin()
13146 
    while True:
13147 
      (fname, ftype, fid) = iprot.readFieldBegin()
13148 
      if ftype == TType.STOP:
13149 
        break
13150 
      if fid == 0:
3064 chandransh 13151 
        if ftype == TType.STRUCT:
13152 
          self.success = Order()
13153 
          self.success.read(iprot)
94 ashish 13154 
        else:
13155 
          iprot.skip(ftype)
13156 
      elif fid == 1:
13157 
        if ftype == TType.STRUCT:
13158 
          self.ex = TransactionServiceException()
13159 
          self.ex.read(iprot)
13160 
        else:
13161 
          iprot.skip(ftype)
13162 
      else:
13163 
        iprot.skip(ftype)
13164 
      iprot.readFieldEnd()
13165 
    iprot.readStructEnd()
13166 
 
13167 
  def write(self, oprot):
13168 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13169 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13170 
      return
3064 chandransh 13171 
    oprot.writeStructBegin('getOrderForCustomer_result')
3431 rajveer 13172 
    if self.success is not None:
3064 chandransh 13173 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
13174 
      self.success.write(oprot)
94 ashish 13175 
      oprot.writeFieldEnd()
3431 rajveer 13176 
    if self.ex is not None:
94 ashish 13177 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
13178 
      self.ex.write(oprot)
13179 
      oprot.writeFieldEnd()
13180 
    oprot.writeFieldStop()
13181 
    oprot.writeStructEnd()
13182 
 
3431 rajveer 13183 
  def validate(self):
13184 
    return
13185 
 
13186 
 
94 ashish 13187 
  def __repr__(self):
13188 
    L = ['%s=%r' % (key, value)
13189 
      for key, value in self.__dict__.iteritems()]
13190 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13191 
 
13192 
  def __eq__(self, other):
13193 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13194 
 
13195 
  def __ne__(self, other):
13196 
    return not (self == other)
13197 
 
3064 chandransh 13198 
class getAlerts_args:
94 ashish 13199 
  """
13200 
  Attributes:
4394 rajveer 13201 
   - type
4444 rajveer 13202 
   - warehouseId
4394 rajveer 13203 
   - status
13204 
   - timestamp
94 ashish 13205 
  """
13206 
 
13207 
  thrift_spec = (
13208 
    None, # 0
4394 rajveer 13209 
    (1, TType.I64, 'type', None, None, ), # 1
4444 rajveer 13210 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
13211 
    (3, TType.I64, 'status', None, None, ), # 3
13212 
    (4, TType.I64, 'timestamp', None, None, ), # 4
94 ashish 13213 
  )
13214 
 
4444 rajveer 13215 
  def __init__(self, type=None, warehouseId=None, status=None, timestamp=None,):
4394 rajveer 13216 
    self.type = type
4444 rajveer 13217 
    self.warehouseId = warehouseId
4394 rajveer 13218 
    self.status = status
13219 
    self.timestamp = timestamp
94 ashish 13220 
 
13221 
  def read(self, iprot):
13222 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13223 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13224 
      return
13225 
    iprot.readStructBegin()
13226 
    while True:
13227 
      (fname, ftype, fid) = iprot.readFieldBegin()
13228 
      if ftype == TType.STOP:
13229 
        break
13230 
      if fid == 1:
3064 chandransh 13231 
        if ftype == TType.I64:
4394 rajveer 13232 
          self.type = iprot.readI64();
94 ashish 13233 
        else:
13234 
          iprot.skip(ftype)
3064 chandransh 13235 
      elif fid == 2:
4394 rajveer 13236 
        if ftype == TType.I64:
4444 rajveer 13237 
          self.warehouseId = iprot.readI64();
3064 chandransh 13238 
        else:
13239 
          iprot.skip(ftype)
4394 rajveer 13240 
      elif fid == 3:
13241 
        if ftype == TType.I64:
4444 rajveer 13242 
          self.status = iprot.readI64();
13243 
        else:
13244 
          iprot.skip(ftype)
13245 
      elif fid == 4:
13246 
        if ftype == TType.I64:
4394 rajveer 13247 
          self.timestamp = iprot.readI64();
13248 
        else:
13249 
          iprot.skip(ftype)
94 ashish 13250 
      else:
13251 
        iprot.skip(ftype)
13252 
      iprot.readFieldEnd()
13253 
    iprot.readStructEnd()
13254 
 
13255 
  def write(self, oprot):
13256 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13257 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13258 
      return
3064 chandransh 13259 
    oprot.writeStructBegin('getAlerts_args')
4394 rajveer 13260 
    if self.type is not None:
13261 
      oprot.writeFieldBegin('type', TType.I64, 1)
13262 
      oprot.writeI64(self.type)
94 ashish 13263 
      oprot.writeFieldEnd()
4444 rajveer 13264 
    if self.warehouseId is not None:
13265 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
13266 
      oprot.writeI64(self.warehouseId)
13267 
      oprot.writeFieldEnd()
4394 rajveer 13268 
    if self.status is not None:
4444 rajveer 13269 
      oprot.writeFieldBegin('status', TType.I64, 3)
4394 rajveer 13270 
      oprot.writeI64(self.status)
3064 chandransh 13271 
      oprot.writeFieldEnd()
4394 rajveer 13272 
    if self.timestamp is not None:
4444 rajveer 13273 
      oprot.writeFieldBegin('timestamp', TType.I64, 4)
4394 rajveer 13274 
      oprot.writeI64(self.timestamp)
13275 
      oprot.writeFieldEnd()
94 ashish 13276 
    oprot.writeFieldStop()
13277 
    oprot.writeStructEnd()
13278 
 
3431 rajveer 13279 
  def validate(self):
13280 
    return
13281 
 
13282 
 
94 ashish 13283 
  def __repr__(self):
13284 
    L = ['%s=%r' % (key, value)
13285 
      for key, value in self.__dict__.iteritems()]
13286 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13287 
 
13288 
  def __eq__(self, other):
13289 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13290 
 
13291 
  def __ne__(self, other):
13292 
    return not (self == other)
13293 
 
3064 chandransh 13294 
class getAlerts_result:
94 ashish 13295 
  """
13296 
  Attributes:
13297 
   - success
13298 
  """
13299 
 
13300 
  thrift_spec = (
3064 chandransh 13301 
    (0, TType.LIST, 'success', (TType.STRUCT,(Alert, Alert.thrift_spec)), None, ), # 0
94 ashish 13302 
  )
13303 
 
3064 chandransh 13304 
  def __init__(self, success=None,):
94 ashish 13305 
    self.success = success
13306 
 
13307 
  def read(self, iprot):
13308 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13309 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13310 
      return
13311 
    iprot.readStructBegin()
13312 
    while True:
13313 
      (fname, ftype, fid) = iprot.readFieldBegin()
13314 
      if ftype == TType.STOP:
13315 
        break
13316 
      if fid == 0:
3064 chandransh 13317 
        if ftype == TType.LIST:
13318 
          self.success = []
6188 rajveer 13319 
          (_etype242, _size239) = iprot.readListBegin()
13320 
          for _i243 in xrange(_size239):
13321 
            _elem244 = Alert()
13322 
            _elem244.read(iprot)
13323 
            self.success.append(_elem244)
3064 chandransh 13324 
          iprot.readListEnd()
94 ashish 13325 
        else:
13326 
          iprot.skip(ftype)
13327 
      else:
13328 
        iprot.skip(ftype)
13329 
      iprot.readFieldEnd()
13330 
    iprot.readStructEnd()
13331 
 
13332 
  def write(self, oprot):
13333 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13334 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13335 
      return
3064 chandransh 13336 
    oprot.writeStructBegin('getAlerts_result')
3431 rajveer 13337 
    if self.success is not None:
3064 chandransh 13338 
      oprot.writeFieldBegin('success', TType.LIST, 0)
13339 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 13340 
      for iter245 in self.success:
13341 
        iter245.write(oprot)
3064 chandransh 13342 
      oprot.writeListEnd()
94 ashish 13343 
      oprot.writeFieldEnd()
13344 
    oprot.writeFieldStop()
13345 
    oprot.writeStructEnd()
13346 
 
3431 rajveer 13347 
  def validate(self):
13348 
    return
13349 
 
13350 
 
94 ashish 13351 
  def __repr__(self):
13352 
    L = ['%s=%r' % (key, value)
13353 
      for key, value in self.__dict__.iteritems()]
13354 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13355 
 
13356 
  def __eq__(self, other):
13357 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13358 
 
13359 
  def __ne__(self, other):
13360 
    return not (self == other)
13361 
 
4394 rajveer 13362 
class addAlert_args:
94 ashish 13363 
  """
13364 
  Attributes:
3064 chandransh 13365 
   - type
4444 rajveer 13366 
   - warehouseId
4394 rajveer 13367 
   - description
94 ashish 13368 
  """
13369 
 
13370 
  thrift_spec = (
13371 
    None, # 0
4394 rajveer 13372 
    (1, TType.I64, 'type', None, None, ), # 1
4444 rajveer 13373 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
13374 
    (3, TType.STRING, 'description', None, None, ), # 3
94 ashish 13375 
  )
13376 
 
4444 rajveer 13377 
  def __init__(self, type=None, warehouseId=None, description=None,):
3064 chandransh 13378 
    self.type = type
4444 rajveer 13379 
    self.warehouseId = warehouseId
4394 rajveer 13380 
    self.description = description
94 ashish 13381 
 
13382 
  def read(self, iprot):
13383 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13384 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13385 
      return
13386 
    iprot.readStructBegin()
13387 
    while True:
13388 
      (fname, ftype, fid) = iprot.readFieldBegin()
13389 
      if ftype == TType.STOP:
13390 
        break
13391 
      if fid == 1:
13392 
        if ftype == TType.I64:
4394 rajveer 13393 
          self.type = iprot.readI64();
94 ashish 13394 
        else:
13395 
          iprot.skip(ftype)
3064 chandransh 13396 
      elif fid == 2:
4444 rajveer 13397 
        if ftype == TType.I64:
13398 
          self.warehouseId = iprot.readI64();
13399 
        else:
13400 
          iprot.skip(ftype)
13401 
      elif fid == 3:
3064 chandransh 13402 
        if ftype == TType.STRING:
4394 rajveer 13403 
          self.description = iprot.readString();
3064 chandransh 13404 
        else:
13405 
          iprot.skip(ftype)
94 ashish 13406 
      else:
13407 
        iprot.skip(ftype)
13408 
      iprot.readFieldEnd()
13409 
    iprot.readStructEnd()
13410 
 
13411 
  def write(self, oprot):
13412 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13413 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13414 
      return
4394 rajveer 13415 
    oprot.writeStructBegin('addAlert_args')
3431 rajveer 13416 
    if self.type is not None:
4394 rajveer 13417 
      oprot.writeFieldBegin('type', TType.I64, 1)
3064 chandransh 13418 
      oprot.writeI64(self.type)
13419 
      oprot.writeFieldEnd()
4444 rajveer 13420 
    if self.warehouseId is not None:
13421 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
13422 
      oprot.writeI64(self.warehouseId)
13423 
      oprot.writeFieldEnd()
4394 rajveer 13424 
    if self.description is not None:
4444 rajveer 13425 
      oprot.writeFieldBegin('description', TType.STRING, 3)
4394 rajveer 13426 
      oprot.writeString(self.description)
3064 chandransh 13427 
      oprot.writeFieldEnd()
94 ashish 13428 
    oprot.writeFieldStop()
13429 
    oprot.writeStructEnd()
13430 
 
3431 rajveer 13431 
  def validate(self):
13432 
    return
13433 
 
13434 
 
94 ashish 13435 
  def __repr__(self):
13436 
    L = ['%s=%r' % (key, value)
13437 
      for key, value in self.__dict__.iteritems()]
13438 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13439 
 
13440 
  def __eq__(self, other):
13441 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13442 
 
13443 
  def __ne__(self, other):
13444 
    return not (self == other)
13445 
 
4394 rajveer 13446 
class addAlert_result:
3064 chandransh 13447 
 
13448 
  thrift_spec = (
13449 
  )
13450 
 
13451 
  def read(self, iprot):
13452 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13453 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13454 
      return
13455 
    iprot.readStructBegin()
13456 
    while True:
13457 
      (fname, ftype, fid) = iprot.readFieldBegin()
13458 
      if ftype == TType.STOP:
13459 
        break
13460 
      else:
13461 
        iprot.skip(ftype)
13462 
      iprot.readFieldEnd()
13463 
    iprot.readStructEnd()
13464 
 
13465 
  def write(self, oprot):
13466 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13467 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13468 
      return
4394 rajveer 13469 
    oprot.writeStructBegin('addAlert_result')
3064 chandransh 13470 
    oprot.writeFieldStop()
13471 
    oprot.writeStructEnd()
13472 
 
3431 rajveer 13473 
  def validate(self):
13474 
    return
13475 
 
13476 
 
3064 chandransh 13477 
  def __repr__(self):
13478 
    L = ['%s=%r' % (key, value)
13479 
      for key, value in self.__dict__.iteritems()]
13480 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13481 
 
13482 
  def __eq__(self, other):
13483 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13484 
 
13485 
  def __ne__(self, other):
13486 
    return not (self == other)
13487 
 
4444 rajveer 13488 
class markAlertsAsSeen_args:
13489 
  """
13490 
  Attributes:
13491 
   - warehouseId
13492 
  """
13493 
 
13494 
  thrift_spec = (
13495 
    None, # 0
13496 
    (1, TType.I64, 'warehouseId', None, None, ), # 1
13497 
  )
13498 
 
13499 
  def __init__(self, warehouseId=None,):
13500 
    self.warehouseId = warehouseId
13501 
 
13502 
  def read(self, iprot):
13503 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13504 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13505 
      return
13506 
    iprot.readStructBegin()
13507 
    while True:
13508 
      (fname, ftype, fid) = iprot.readFieldBegin()
13509 
      if ftype == TType.STOP:
13510 
        break
13511 
      if fid == 1:
13512 
        if ftype == TType.I64:
13513 
          self.warehouseId = iprot.readI64();
13514 
        else:
13515 
          iprot.skip(ftype)
13516 
      else:
13517 
        iprot.skip(ftype)
13518 
      iprot.readFieldEnd()
13519 
    iprot.readStructEnd()
13520 
 
13521 
  def write(self, oprot):
13522 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13523 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13524 
      return
13525 
    oprot.writeStructBegin('markAlertsAsSeen_args')
13526 
    if self.warehouseId is not None:
13527 
      oprot.writeFieldBegin('warehouseId', TType.I64, 1)
13528 
      oprot.writeI64(self.warehouseId)
13529 
      oprot.writeFieldEnd()
13530 
    oprot.writeFieldStop()
13531 
    oprot.writeStructEnd()
13532 
 
13533 
  def validate(self):
13534 
    return
13535 
 
13536 
 
13537 
  def __repr__(self):
13538 
    L = ['%s=%r' % (key, value)
13539 
      for key, value in self.__dict__.iteritems()]
13540 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13541 
 
13542 
  def __eq__(self, other):
13543 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13544 
 
13545 
  def __ne__(self, other):
13546 
    return not (self == other)
13547 
 
13548 
class markAlertsAsSeen_result:
13549 
 
13550 
  thrift_spec = (
13551 
  )
13552 
 
13553 
  def read(self, iprot):
13554 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13555 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13556 
      return
13557 
    iprot.readStructBegin()
13558 
    while True:
13559 
      (fname, ftype, fid) = iprot.readFieldBegin()
13560 
      if ftype == TType.STOP:
13561 
        break
13562 
      else:
13563 
        iprot.skip(ftype)
13564 
      iprot.readFieldEnd()
13565 
    iprot.readStructEnd()
13566 
 
13567 
  def write(self, oprot):
13568 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13569 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13570 
      return
13571 
    oprot.writeStructBegin('markAlertsAsSeen_result')
13572 
    oprot.writeFieldStop()
13573 
    oprot.writeStructEnd()
13574 
 
13575 
  def validate(self):
13576 
    return
13577 
 
13578 
 
13579 
  def __repr__(self):
13580 
    L = ['%s=%r' % (key, value)
13581 
      for key, value in self.__dict__.iteritems()]
13582 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13583 
 
13584 
  def __eq__(self, other):
13585 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13586 
 
13587 
  def __ne__(self, other):
13588 
    return not (self == other)
13589 
 
3064 chandransh 13590 
class getValidOrderCount_args:
13591 
 
13592 
  thrift_spec = (
13593 
  )
13594 
 
13595 
  def read(self, iprot):
13596 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13597 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13598 
      return
13599 
    iprot.readStructBegin()
13600 
    while True:
13601 
      (fname, ftype, fid) = iprot.readFieldBegin()
13602 
      if ftype == TType.STOP:
13603 
        break
13604 
      else:
13605 
        iprot.skip(ftype)
13606 
      iprot.readFieldEnd()
13607 
    iprot.readStructEnd()
13608 
 
13609 
  def write(self, oprot):
13610 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13611 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13612 
      return
13613 
    oprot.writeStructBegin('getValidOrderCount_args')
13614 
    oprot.writeFieldStop()
13615 
    oprot.writeStructEnd()
13616 
 
3431 rajveer 13617 
  def validate(self):
13618 
    return
13619 
 
13620 
 
3064 chandransh 13621 
  def __repr__(self):
13622 
    L = ['%s=%r' % (key, value)
13623 
      for key, value in self.__dict__.iteritems()]
13624 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13625 
 
13626 
  def __eq__(self, other):
13627 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13628 
 
13629 
  def __ne__(self, other):
13630 
    return not (self == other)
13631 
 
13632 
class getValidOrderCount_result:
94 ashish 13633 
  """
13634 
  Attributes:
13635 
   - success
13636 
  """
13637 
 
13638 
  thrift_spec = (
3064 chandransh 13639 
    (0, TType.I64, 'success', None, None, ), # 0
94 ashish 13640 
  )
13641 
 
3064 chandransh 13642 
  def __init__(self, success=None,):
94 ashish 13643 
    self.success = success
13644 
 
13645 
  def read(self, iprot):
13646 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13647 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13648 
      return
13649 
    iprot.readStructBegin()
13650 
    while True:
13651 
      (fname, ftype, fid) = iprot.readFieldBegin()
13652 
      if ftype == TType.STOP:
13653 
        break
13654 
      if fid == 0:
3064 chandransh 13655 
        if ftype == TType.I64:
13656 
          self.success = iprot.readI64();
94 ashish 13657 
        else:
13658 
          iprot.skip(ftype)
13659 
      else:
13660 
        iprot.skip(ftype)
13661 
      iprot.readFieldEnd()
13662 
    iprot.readStructEnd()
13663 
 
13664 
  def write(self, oprot):
13665 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13666 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13667 
      return
3064 chandransh 13668 
    oprot.writeStructBegin('getValidOrderCount_result')
3431 rajveer 13669 
    if self.success is not None:
3064 chandransh 13670 
      oprot.writeFieldBegin('success', TType.I64, 0)
13671 
      oprot.writeI64(self.success)
94 ashish 13672 
      oprot.writeFieldEnd()
13673 
    oprot.writeFieldStop()
13674 
    oprot.writeStructEnd()
13675 
 
3431 rajveer 13676 
  def validate(self):
13677 
    return
13678 
 
13679 
 
94 ashish 13680 
  def __repr__(self):
13681 
    L = ['%s=%r' % (key, value)
13682 
      for key, value in self.__dict__.iteritems()]
13683 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13684 
 
13685 
  def __eq__(self, other):
13686 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13687 
 
13688 
  def __ne__(self, other):
13689 
    return not (self == other)
13690 
 
3064 chandransh 13691 
class getNoOfCustomersWithSuccessfulTransaction_args:
13692 
 
13693 
  thrift_spec = (
13694 
  )
13695 
 
13696 
  def read(self, iprot):
13697 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13698 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13699 
      return
13700 
    iprot.readStructBegin()
13701 
    while True:
13702 
      (fname, ftype, fid) = iprot.readFieldBegin()
13703 
      if ftype == TType.STOP:
13704 
        break
13705 
      else:
13706 
        iprot.skip(ftype)
13707 
      iprot.readFieldEnd()
13708 
    iprot.readStructEnd()
13709 
 
13710 
  def write(self, oprot):
13711 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13712 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13713 
      return
13714 
    oprot.writeStructBegin('getNoOfCustomersWithSuccessfulTransaction_args')
13715 
    oprot.writeFieldStop()
13716 
    oprot.writeStructEnd()
13717 
 
3431 rajveer 13718 
  def validate(self):
13719 
    return
13720 
 
13721 
 
3064 chandransh 13722 
  def __repr__(self):
13723 
    L = ['%s=%r' % (key, value)
13724 
      for key, value in self.__dict__.iteritems()]
13725 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13726 
 
13727 
  def __eq__(self, other):
13728 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13729 
 
13730 
  def __ne__(self, other):
13731 
    return not (self == other)
13732 
 
13733 
class getNoOfCustomersWithSuccessfulTransaction_result:
94 ashish 13734 
  """
13735 
  Attributes:
3064 chandransh 13736 
   - success
94 ashish 13737 
  """
13738 
 
13739 
  thrift_spec = (
3064 chandransh 13740 
    (0, TType.I64, 'success', None, None, ), # 0
94 ashish 13741 
  )
13742 
 
3064 chandransh 13743 
  def __init__(self, success=None,):
13744 
    self.success = success
94 ashish 13745 
 
13746 
  def read(self, iprot):
13747 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13748 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13749 
      return
13750 
    iprot.readStructBegin()
13751 
    while True:
13752 
      (fname, ftype, fid) = iprot.readFieldBegin()
13753 
      if ftype == TType.STOP:
13754 
        break
3064 chandransh 13755 
      if fid == 0:
94 ashish 13756 
        if ftype == TType.I64:
3064 chandransh 13757 
          self.success = iprot.readI64();
94 ashish 13758 
        else:
13759 
          iprot.skip(ftype)
13760 
      else:
13761 
        iprot.skip(ftype)
13762 
      iprot.readFieldEnd()
13763 
    iprot.readStructEnd()
13764 
 
13765 
  def write(self, oprot):
13766 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13767 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13768 
      return
3064 chandransh 13769 
    oprot.writeStructBegin('getNoOfCustomersWithSuccessfulTransaction_result')
3431 rajveer 13770 
    if self.success is not None:
3064 chandransh 13771 
      oprot.writeFieldBegin('success', TType.I64, 0)
13772 
      oprot.writeI64(self.success)
94 ashish 13773 
      oprot.writeFieldEnd()
13774 
    oprot.writeFieldStop()
13775 
    oprot.writeStructEnd()
13776 
 
3431 rajveer 13777 
  def validate(self):
13778 
    return
13779 
 
13780 
 
94 ashish 13781 
  def __repr__(self):
13782 
    L = ['%s=%r' % (key, value)
13783 
      for key, value in self.__dict__.iteritems()]
13784 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13785 
 
13786 
  def __eq__(self, other):
13787 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13788 
 
13789 
  def __ne__(self, other):
13790 
    return not (self == other)
13791 
 
3064 chandransh 13792 
class getValidOrdersAmountRange_args:
13793 
 
13794 
  thrift_spec = (
13795 
  )
13796 
 
13797 
  def read(self, iprot):
13798 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13799 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13800 
      return
13801 
    iprot.readStructBegin()
13802 
    while True:
13803 
      (fname, ftype, fid) = iprot.readFieldBegin()
13804 
      if ftype == TType.STOP:
13805 
        break
13806 
      else:
13807 
        iprot.skip(ftype)
13808 
      iprot.readFieldEnd()
13809 
    iprot.readStructEnd()
13810 
 
13811 
  def write(self, oprot):
13812 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13813 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13814 
      return
13815 
    oprot.writeStructBegin('getValidOrdersAmountRange_args')
13816 
    oprot.writeFieldStop()
13817 
    oprot.writeStructEnd()
13818 
 
3431 rajveer 13819 
  def validate(self):
13820 
    return
13821 
 
13822 
 
3064 chandransh 13823 
  def __repr__(self):
13824 
    L = ['%s=%r' % (key, value)
13825 
      for key, value in self.__dict__.iteritems()]
13826 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13827 
 
13828 
  def __eq__(self, other):
13829 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13830 
 
13831 
  def __ne__(self, other):
13832 
    return not (self == other)
13833 
 
13834 
class getValidOrdersAmountRange_result:
94 ashish 13835 
  """
13836 
  Attributes:
13837 
   - success
13838 
  """
13839 
 
13840 
  thrift_spec = (
3064 chandransh 13841 
    (0, TType.LIST, 'success', (TType.DOUBLE,None), None, ), # 0
94 ashish 13842 
  )
13843 
 
3064 chandransh 13844 
  def __init__(self, success=None,):
94 ashish 13845 
    self.success = success
13846 
 
13847 
  def read(self, iprot):
13848 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13849 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13850 
      return
13851 
    iprot.readStructBegin()
13852 
    while True:
13853 
      (fname, ftype, fid) = iprot.readFieldBegin()
13854 
      if ftype == TType.STOP:
13855 
        break
13856 
      if fid == 0:
483 rajveer 13857 
        if ftype == TType.LIST:
13858 
          self.success = []
6188 rajveer 13859 
          (_etype249, _size246) = iprot.readListBegin()
13860 
          for _i250 in xrange(_size246):
13861 
            _elem251 = iprot.readDouble();
13862 
            self.success.append(_elem251)
483 rajveer 13863 
          iprot.readListEnd()
94 ashish 13864 
        else:
13865 
          iprot.skip(ftype)
13866 
      else:
13867 
        iprot.skip(ftype)
13868 
      iprot.readFieldEnd()
13869 
    iprot.readStructEnd()
13870 
 
13871 
  def write(self, oprot):
13872 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13873 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13874 
      return
3064 chandransh 13875 
    oprot.writeStructBegin('getValidOrdersAmountRange_result')
3431 rajveer 13876 
    if self.success is not None:
483 rajveer 13877 
      oprot.writeFieldBegin('success', TType.LIST, 0)
3064 chandransh 13878 
      oprot.writeListBegin(TType.DOUBLE, len(self.success))
6188 rajveer 13879 
      for iter252 in self.success:
13880 
        oprot.writeDouble(iter252)
483 rajveer 13881 
      oprot.writeListEnd()
94 ashish 13882 
      oprot.writeFieldEnd()
13883 
    oprot.writeFieldStop()
13884 
    oprot.writeStructEnd()
13885 
 
3431 rajveer 13886 
  def validate(self):
13887 
    return
13888 
 
13889 
 
94 ashish 13890 
  def __repr__(self):
13891 
    L = ['%s=%r' % (key, value)
13892 
      for key, value in self.__dict__.iteritems()]
13893 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13894 
 
13895 
  def __eq__(self, other):
13896 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13897 
 
13898 
  def __ne__(self, other):
13899 
    return not (self == other)
13900 
 
3064 chandransh 13901 
class getValidOrders_args:
1528 ankur.sing 13902 
  """
13903 
  Attributes:
3064 chandransh 13904 
   - limit
5874 rajveer 13905 
   - onlyStore
1528 ankur.sing 13906 
  """
13907 
 
13908 
  thrift_spec = (
13909 
    None, # 0
3064 chandransh 13910 
    (1, TType.I64, 'limit', None, None, ), # 1
5874 rajveer 13911 
    (2, TType.BOOL, 'onlyStore', None, None, ), # 2
1528 ankur.sing 13912 
  )
13913 
 
5874 rajveer 13914 
  def __init__(self, limit=None, onlyStore=None,):
3064 chandransh 13915 
    self.limit = limit
5874 rajveer 13916 
    self.onlyStore = onlyStore
1528 ankur.sing 13917 
 
13918 
  def read(self, iprot):
13919 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13920 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13921 
      return
13922 
    iprot.readStructBegin()
13923 
    while True:
13924 
      (fname, ftype, fid) = iprot.readFieldBegin()
13925 
      if ftype == TType.STOP:
13926 
        break
13927 
      if fid == 1:
13928 
        if ftype == TType.I64:
3064 chandransh 13929 
          self.limit = iprot.readI64();
1528 ankur.sing 13930 
        else:
13931 
          iprot.skip(ftype)
5874 rajveer 13932 
      elif fid == 2:
13933 
        if ftype == TType.BOOL:
13934 
          self.onlyStore = iprot.readBool();
13935 
        else:
13936 
          iprot.skip(ftype)
1528 ankur.sing 13937 
      else:
13938 
        iprot.skip(ftype)
13939 
      iprot.readFieldEnd()
13940 
    iprot.readStructEnd()
13941 
 
13942 
  def write(self, oprot):
13943 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13944 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13945 
      return
3064 chandransh 13946 
    oprot.writeStructBegin('getValidOrders_args')
3431 rajveer 13947 
    if self.limit is not None:
3064 chandransh 13948 
      oprot.writeFieldBegin('limit', TType.I64, 1)
13949 
      oprot.writeI64(self.limit)
1528 ankur.sing 13950 
      oprot.writeFieldEnd()
5874 rajveer 13951 
    if self.onlyStore is not None:
13952 
      oprot.writeFieldBegin('onlyStore', TType.BOOL, 2)
13953 
      oprot.writeBool(self.onlyStore)
13954 
      oprot.writeFieldEnd()
1528 ankur.sing 13955 
    oprot.writeFieldStop()
13956 
    oprot.writeStructEnd()
13957 
 
3431 rajveer 13958 
  def validate(self):
13959 
    return
13960 
 
13961 
 
1528 ankur.sing 13962 
  def __repr__(self):
13963 
    L = ['%s=%r' % (key, value)
13964 
      for key, value in self.__dict__.iteritems()]
13965 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13966 
 
13967 
  def __eq__(self, other):
13968 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13969 
 
13970 
  def __ne__(self, other):
13971 
    return not (self == other)
13972 
 
3064 chandransh 13973 
class getValidOrders_result:
1528 ankur.sing 13974 
  """
13975 
  Attributes:
13976 
   - success
13977 
  """
13978 
 
13979 
  thrift_spec = (
3064 chandransh 13980 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
1528 ankur.sing 13981 
  )
13982 
 
3064 chandransh 13983 
  def __init__(self, success=None,):
1528 ankur.sing 13984 
    self.success = success
13985 
 
13986 
  def read(self, iprot):
13987 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13988 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13989 
      return
13990 
    iprot.readStructBegin()
13991 
    while True:
13992 
      (fname, ftype, fid) = iprot.readFieldBegin()
13993 
      if ftype == TType.STOP:
13994 
        break
13995 
      if fid == 0:
3064 chandransh 13996 
        if ftype == TType.LIST:
13997 
          self.success = []
6188 rajveer 13998 
          (_etype256, _size253) = iprot.readListBegin()
13999 
          for _i257 in xrange(_size253):
14000 
            _elem258 = Order()
14001 
            _elem258.read(iprot)
14002 
            self.success.append(_elem258)
3064 chandransh 14003 
          iprot.readListEnd()
1528 ankur.sing 14004 
        else:
14005 
          iprot.skip(ftype)
14006 
      else:
14007 
        iprot.skip(ftype)
14008 
      iprot.readFieldEnd()
14009 
    iprot.readStructEnd()
14010 
 
14011 
  def write(self, oprot):
14012 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14013 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14014 
      return
3064 chandransh 14015 
    oprot.writeStructBegin('getValidOrders_result')
3431 rajveer 14016 
    if self.success is not None:
3064 chandransh 14017 
      oprot.writeFieldBegin('success', TType.LIST, 0)
14018 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 14019 
      for iter259 in self.success:
14020 
        iter259.write(oprot)
3064 chandransh 14021 
      oprot.writeListEnd()
1528 ankur.sing 14022 
      oprot.writeFieldEnd()
14023 
    oprot.writeFieldStop()
14024 
    oprot.writeStructEnd()
14025 
 
3431 rajveer 14026 
  def validate(self):
14027 
    return
14028 
 
14029 
 
1528 ankur.sing 14030 
  def __repr__(self):
14031 
    L = ['%s=%r' % (key, value)
14032 
      for key, value in self.__dict__.iteritems()]
14033 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14034 
 
14035 
  def __eq__(self, other):
14036 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14037 
 
14038 
  def __ne__(self, other):
14039 
    return not (self == other)
14040 
 
1220 chandransh 14041 
class batchOrders_args:
14042 
  """
14043 
  Attributes:
14044 
   - warehouseId
14045 
  """
14046 
 
14047 
  thrift_spec = (
14048 
    None, # 0
14049 
    (1, TType.I64, 'warehouseId', None, None, ), # 1
14050 
  )
14051 
 
14052 
  def __init__(self, warehouseId=None,):
14053 
    self.warehouseId = warehouseId
14054 
 
14055 
  def read(self, iprot):
14056 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14057 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14058 
      return
14059 
    iprot.readStructBegin()
14060 
    while True:
14061 
      (fname, ftype, fid) = iprot.readFieldBegin()
14062 
      if ftype == TType.STOP:
14063 
        break
14064 
      if fid == 1:
14065 
        if ftype == TType.I64:
14066 
          self.warehouseId = iprot.readI64();
14067 
        else:
14068 
          iprot.skip(ftype)
14069 
      else:
14070 
        iprot.skip(ftype)
14071 
      iprot.readFieldEnd()
14072 
    iprot.readStructEnd()
14073 
 
14074 
  def write(self, oprot):
14075 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14076 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14077 
      return
14078 
    oprot.writeStructBegin('batchOrders_args')
3431 rajveer 14079 
    if self.warehouseId is not None:
1220 chandransh 14080 
      oprot.writeFieldBegin('warehouseId', TType.I64, 1)
14081 
      oprot.writeI64(self.warehouseId)
14082 
      oprot.writeFieldEnd()
14083 
    oprot.writeFieldStop()
14084 
    oprot.writeStructEnd()
14085 
 
3431 rajveer 14086 
  def validate(self):
14087 
    return
14088 
 
14089 
 
1220 chandransh 14090 
  def __repr__(self):
14091 
    L = ['%s=%r' % (key, value)
14092 
      for key, value in self.__dict__.iteritems()]
14093 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14094 
 
14095 
  def __eq__(self, other):
14096 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14097 
 
14098 
  def __ne__(self, other):
14099 
    return not (self == other)
14100 
 
14101 
class batchOrders_result:
14102 
  """
14103 
  Attributes:
14104 
   - success
14105 
   - ex
14106 
  """
14107 
 
14108 
  thrift_spec = (
14109 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
14110 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
14111 
  )
14112 
 
14113 
  def __init__(self, success=None, ex=None,):
14114 
    self.success = success
14115 
    self.ex = ex
14116 
 
14117 
  def read(self, iprot):
14118 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14119 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14120 
      return
14121 
    iprot.readStructBegin()
14122 
    while True:
14123 
      (fname, ftype, fid) = iprot.readFieldBegin()
14124 
      if ftype == TType.STOP:
14125 
        break
14126 
      if fid == 0:
14127 
        if ftype == TType.LIST:
14128 
          self.success = []
6188 rajveer 14129 
          (_etype263, _size260) = iprot.readListBegin()
14130 
          for _i264 in xrange(_size260):
14131 
            _elem265 = Order()
14132 
            _elem265.read(iprot)
14133 
            self.success.append(_elem265)
1220 chandransh 14134 
          iprot.readListEnd()
14135 
        else:
14136 
          iprot.skip(ftype)
14137 
      elif fid == 1:
14138 
        if ftype == TType.STRUCT:
14139 
          self.ex = TransactionServiceException()
14140 
          self.ex.read(iprot)
14141 
        else:
14142 
          iprot.skip(ftype)
14143 
      else:
14144 
        iprot.skip(ftype)
14145 
      iprot.readFieldEnd()
14146 
    iprot.readStructEnd()
14147 
 
14148 
  def write(self, oprot):
14149 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14150 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14151 
      return
14152 
    oprot.writeStructBegin('batchOrders_result')
3431 rajveer 14153 
    if self.success is not None:
1220 chandransh 14154 
      oprot.writeFieldBegin('success', TType.LIST, 0)
14155 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 14156 
      for iter266 in self.success:
14157 
        iter266.write(oprot)
1220 chandransh 14158 
      oprot.writeListEnd()
14159 
      oprot.writeFieldEnd()
3431 rajveer 14160 
    if self.ex is not None:
1220 chandransh 14161 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
14162 
      self.ex.write(oprot)
14163 
      oprot.writeFieldEnd()
14164 
    oprot.writeFieldStop()
14165 
    oprot.writeStructEnd()
14166 
 
3431 rajveer 14167 
  def validate(self):
14168 
    return
14169 
 
14170 
 
1220 chandransh 14171 
  def __repr__(self):
14172 
    L = ['%s=%r' % (key, value)
14173 
      for key, value in self.__dict__.iteritems()]
14174 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14175 
 
14176 
  def __eq__(self, other):
14177 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14178 
 
14179 
  def __ne__(self, other):
14180 
    return not (self == other)
14181 
 
1208 chandransh 14182 
class markOrderAsOutOfStock_args:
14183 
  """
14184 
  Attributes:
14185 
   - orderId
14186 
  """
14187 
 
14188 
  thrift_spec = (
14189 
    None, # 0
14190 
    (1, TType.I64, 'orderId', None, None, ), # 1
14191 
  )
14192 
 
14193 
  def __init__(self, orderId=None,):
14194 
    self.orderId = orderId
14195 
 
14196 
  def read(self, iprot):
14197 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14198 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14199 
      return
14200 
    iprot.readStructBegin()
14201 
    while True:
14202 
      (fname, ftype, fid) = iprot.readFieldBegin()
14203 
      if ftype == TType.STOP:
14204 
        break
14205 
      if fid == 1:
14206 
        if ftype == TType.I64:
14207 
          self.orderId = iprot.readI64();
14208 
        else:
14209 
          iprot.skip(ftype)
14210 
      else:
14211 
        iprot.skip(ftype)
14212 
      iprot.readFieldEnd()
14213 
    iprot.readStructEnd()
14214 
 
14215 
  def write(self, oprot):
14216 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14217 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14218 
      return
14219 
    oprot.writeStructBegin('markOrderAsOutOfStock_args')
3431 rajveer 14220 
    if self.orderId is not None:
1208 chandransh 14221 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
14222 
      oprot.writeI64(self.orderId)
14223 
      oprot.writeFieldEnd()
14224 
    oprot.writeFieldStop()
14225 
    oprot.writeStructEnd()
14226 
 
3431 rajveer 14227 
  def validate(self):
14228 
    return
14229 
 
14230 
 
1208 chandransh 14231 
  def __repr__(self):
14232 
    L = ['%s=%r' % (key, value)
14233 
      for key, value in self.__dict__.iteritems()]
14234 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14235 
 
14236 
  def __eq__(self, other):
14237 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14238 
 
14239 
  def __ne__(self, other):
14240 
    return not (self == other)
14241 
 
14242 
class markOrderAsOutOfStock_result:
14243 
  """
14244 
  Attributes:
14245 
   - success
14246 
   - ex
14247 
  """
14248 
 
14249 
  thrift_spec = (
14250 
    (0, TType.BOOL, 'success', None, None, ), # 0
14251 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
14252 
  )
14253 
 
14254 
  def __init__(self, success=None, ex=None,):
14255 
    self.success = success
14256 
    self.ex = ex
14257 
 
14258 
  def read(self, iprot):
14259 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14260 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14261 
      return
14262 
    iprot.readStructBegin()
14263 
    while True:
14264 
      (fname, ftype, fid) = iprot.readFieldBegin()
14265 
      if ftype == TType.STOP:
14266 
        break
14267 
      if fid == 0:
14268 
        if ftype == TType.BOOL:
14269 
          self.success = iprot.readBool();
14270 
        else:
14271 
          iprot.skip(ftype)
14272 
      elif fid == 1:
14273 
        if ftype == TType.STRUCT:
14274 
          self.ex = TransactionServiceException()
14275 
          self.ex.read(iprot)
14276 
        else:
14277 
          iprot.skip(ftype)
14278 
      else:
14279 
        iprot.skip(ftype)
14280 
      iprot.readFieldEnd()
14281 
    iprot.readStructEnd()
14282 
 
14283 
  def write(self, oprot):
14284 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14285 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14286 
      return
14287 
    oprot.writeStructBegin('markOrderAsOutOfStock_result')
3431 rajveer 14288 
    if self.success is not None:
1208 chandransh 14289 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
14290 
      oprot.writeBool(self.success)
14291 
      oprot.writeFieldEnd()
3431 rajveer 14292 
    if self.ex is not None:
1208 chandransh 14293 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
14294 
      self.ex.write(oprot)
14295 
      oprot.writeFieldEnd()
14296 
    oprot.writeFieldStop()
14297 
    oprot.writeStructEnd()
14298 
 
3431 rajveer 14299 
  def validate(self):
14300 
    return
14301 
 
14302 
 
1208 chandransh 14303 
  def __repr__(self):
14304 
    L = ['%s=%r' % (key, value)
14305 
      for key, value in self.__dict__.iteritems()]
14306 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14307 
 
14308 
  def __eq__(self, other):
14309 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14310 
 
14311 
  def __ne__(self, other):
14312 
    return not (self == other)
14313 
 
3064 chandransh 14314 
class verifyOrder_args:
759 chandransh 14315 
  """
14316 
  Attributes:
3064 chandransh 14317 
   - orderId
759 chandransh 14318 
  """
14319 
 
14320 
  thrift_spec = (
14321 
    None, # 0
3064 chandransh 14322 
    (1, TType.I64, 'orderId', None, None, ), # 1
759 chandransh 14323 
  )
14324 
 
3064 chandransh 14325 
  def __init__(self, orderId=None,):
14326 
    self.orderId = orderId
759 chandransh 14327 
 
14328 
  def read(self, iprot):
14329 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14330 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14331 
      return
14332 
    iprot.readStructBegin()
14333 
    while True:
14334 
      (fname, ftype, fid) = iprot.readFieldBegin()
14335 
      if ftype == TType.STOP:
14336 
        break
14337 
      if fid == 1:
14338 
        if ftype == TType.I64:
3064 chandransh 14339 
          self.orderId = iprot.readI64();
759 chandransh 14340 
        else:
14341 
          iprot.skip(ftype)
14342 
      else:
14343 
        iprot.skip(ftype)
14344 
      iprot.readFieldEnd()
14345 
    iprot.readStructEnd()
14346 
 
14347 
  def write(self, oprot):
14348 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14349 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14350 
      return
3064 chandransh 14351 
    oprot.writeStructBegin('verifyOrder_args')
3431 rajveer 14352 
    if self.orderId is not None:
3064 chandransh 14353 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
14354 
      oprot.writeI64(self.orderId)
759 chandransh 14355 
      oprot.writeFieldEnd()
14356 
    oprot.writeFieldStop()
14357 
    oprot.writeStructEnd()
14358 
 
3431 rajveer 14359 
  def validate(self):
14360 
    return
14361 
 
14362 
 
759 chandransh 14363 
  def __repr__(self):
14364 
    L = ['%s=%r' % (key, value)
14365 
      for key, value in self.__dict__.iteritems()]
14366 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14367 
 
14368 
  def __eq__(self, other):
14369 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14370 
 
14371 
  def __ne__(self, other):
14372 
    return not (self == other)
14373 
 
3064 chandransh 14374 
class verifyOrder_result:
759 chandransh 14375 
  """
14376 
  Attributes:
14377 
   - success
14378 
   - ex
14379 
  """
14380 
 
14381 
  thrift_spec = (
14382 
    (0, TType.BOOL, 'success', None, None, ), # 0
14383 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
14384 
  )
14385 
 
14386 
  def __init__(self, success=None, ex=None,):
14387 
    self.success = success
14388 
    self.ex = ex
14389 
 
14390 
  def read(self, iprot):
14391 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14392 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14393 
      return
14394 
    iprot.readStructBegin()
14395 
    while True:
14396 
      (fname, ftype, fid) = iprot.readFieldBegin()
14397 
      if ftype == TType.STOP:
14398 
        break
14399 
      if fid == 0:
14400 
        if ftype == TType.BOOL:
14401 
          self.success = iprot.readBool();
14402 
        else:
14403 
          iprot.skip(ftype)
14404 
      elif fid == 1:
14405 
        if ftype == TType.STRUCT:
14406 
          self.ex = TransactionServiceException()
14407 
          self.ex.read(iprot)
14408 
        else:
14409 
          iprot.skip(ftype)
14410 
      else:
14411 
        iprot.skip(ftype)
14412 
      iprot.readFieldEnd()
14413 
    iprot.readStructEnd()
14414 
 
14415 
  def write(self, oprot):
14416 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14417 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14418 
      return
3064 chandransh 14419 
    oprot.writeStructBegin('verifyOrder_result')
3431 rajveer 14420 
    if self.success is not None:
759 chandransh 14421 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
14422 
      oprot.writeBool(self.success)
14423 
      oprot.writeFieldEnd()
3431 rajveer 14424 
    if self.ex is not None:
759 chandransh 14425 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
14426 
      self.ex.write(oprot)
14427 
      oprot.writeFieldEnd()
14428 
    oprot.writeFieldStop()
14429 
    oprot.writeStructEnd()
14430 
 
3431 rajveer 14431 
  def validate(self):
14432 
    return
14433 
 
14434 
 
759 chandransh 14435 
  def __repr__(self):
14436 
    L = ['%s=%r' % (key, value)
14437 
      for key, value in self.__dict__.iteritems()]
14438 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14439 
 
14440 
  def __eq__(self, other):
14441 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14442 
 
14443 
  def __ne__(self, other):
14444 
    return not (self == other)
14445 
 
3064 chandransh 14446 
class acceptOrder_args:
1113 chandransh 14447 
  """
14448 
  Attributes:
3064 chandransh 14449 
   - orderId
1113 chandransh 14450 
  """
14451 
 
14452 
  thrift_spec = (
14453 
    None, # 0
3064 chandransh 14454 
    (1, TType.I64, 'orderId', None, None, ), # 1
1113 chandransh 14455 
  )
14456 
 
3064 chandransh 14457 
  def __init__(self, orderId=None,):
14458 
    self.orderId = orderId
1113 chandransh 14459 
 
14460 
  def read(self, iprot):
14461 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14462 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14463 
      return
14464 
    iprot.readStructBegin()
14465 
    while True:
14466 
      (fname, ftype, fid) = iprot.readFieldBegin()
14467 
      if ftype == TType.STOP:
14468 
        break
14469 
      if fid == 1:
14470 
        if ftype == TType.I64:
3064 chandransh 14471 
          self.orderId = iprot.readI64();
1113 chandransh 14472 
        else:
14473 
          iprot.skip(ftype)
14474 
      else:
14475 
        iprot.skip(ftype)
14476 
      iprot.readFieldEnd()
14477 
    iprot.readStructEnd()
14478 
 
14479 
  def write(self, oprot):
14480 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14481 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14482 
      return
3064 chandransh 14483 
    oprot.writeStructBegin('acceptOrder_args')
3431 rajveer 14484 
    if self.orderId is not None:
3064 chandransh 14485 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
14486 
      oprot.writeI64(self.orderId)
1113 chandransh 14487 
      oprot.writeFieldEnd()
14488 
    oprot.writeFieldStop()
14489 
    oprot.writeStructEnd()
14490 
 
3431 rajveer 14491 
  def validate(self):
14492 
    return
14493 
 
14494 
 
1113 chandransh 14495 
  def __repr__(self):
14496 
    L = ['%s=%r' % (key, value)
14497 
      for key, value in self.__dict__.iteritems()]
14498 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14499 
 
14500 
  def __eq__(self, other):
14501 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14502 
 
14503 
  def __ne__(self, other):
14504 
    return not (self == other)
14505 
 
3064 chandransh 14506 
class acceptOrder_result:
1113 chandransh 14507 
  """
14508 
  Attributes:
14509 
   - success
14510 
   - ex
14511 
  """
14512 
 
14513 
  thrift_spec = (
3064 chandransh 14514 
    (0, TType.BOOL, 'success', None, None, ), # 0
1113 chandransh 14515 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
14516 
  )
14517 
 
14518 
  def __init__(self, success=None, ex=None,):
14519 
    self.success = success
14520 
    self.ex = ex
14521 
 
14522 
  def read(self, iprot):
14523 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14524 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14525 
      return
14526 
    iprot.readStructBegin()
14527 
    while True:
14528 
      (fname, ftype, fid) = iprot.readFieldBegin()
14529 
      if ftype == TType.STOP:
14530 
        break
14531 
      if fid == 0:
3064 chandransh 14532 
        if ftype == TType.BOOL:
14533 
          self.success = iprot.readBool();
1113 chandransh 14534 
        else:
14535 
          iprot.skip(ftype)
14536 
      elif fid == 1:
14537 
        if ftype == TType.STRUCT:
14538 
          self.ex = TransactionServiceException()
14539 
          self.ex.read(iprot)
14540 
        else:
14541 
          iprot.skip(ftype)
14542 
      else:
14543 
        iprot.skip(ftype)
14544 
      iprot.readFieldEnd()
14545 
    iprot.readStructEnd()
14546 
 
14547 
  def write(self, oprot):
14548 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14549 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14550 
      return
3064 chandransh 14551 
    oprot.writeStructBegin('acceptOrder_result')
3431 rajveer 14552 
    if self.success is not None:
3064 chandransh 14553 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
14554 
      oprot.writeBool(self.success)
1113 chandransh 14555 
      oprot.writeFieldEnd()
3431 rajveer 14556 
    if self.ex is not None:
1113 chandransh 14557 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
14558 
      self.ex.write(oprot)
14559 
      oprot.writeFieldEnd()
14560 
    oprot.writeFieldStop()
14561 
    oprot.writeStructEnd()
14562 
 
3431 rajveer 14563 
  def validate(self):
14564 
    return
14565 
 
14566 
 
1113 chandransh 14567 
  def __repr__(self):
14568 
    L = ['%s=%r' % (key, value)
14569 
      for key, value in self.__dict__.iteritems()]
14570 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14571 
 
14572 
  def __eq__(self, other):
14573 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14574 
 
14575 
  def __ne__(self, other):
14576 
    return not (self == other)
14577 
 
3064 chandransh 14578 
class addBillingDetails_args:
1135 chandransh 14579 
  """
14580 
  Attributes:
3064 chandransh 14581 
   - orderId
14582 
   - invoice_number
4658 mandeep.dh 14583 
   - serialNumber
4283 anupam.sin 14584 
   - itemNumber
7190 amar.kumar 14585 
   - freebieWarehouseId
3064 chandransh 14586 
   - billed_by
4264 rajveer 14587 
   - jacketNumber
4283 anupam.sin 14588 
   - billingType
5110 mandeep.dh 14589 
   - fulfilmentWarehouseId
4763 rajveer 14590 
   - authorize
1135 chandransh 14591 
  """
14592 
 
14593 
  thrift_spec = (
14594 
    None, # 0
3064 chandransh 14595 
    (1, TType.I64, 'orderId', None, None, ), # 1
14596 
    (2, TType.STRING, 'invoice_number', None, None, ), # 2
5411 rajveer 14597 
    (3, TType.LIST, 'serialNumber', (TType.STRING,None), None, ), # 3
14598 
    (4, TType.LIST, 'itemNumber', (TType.STRING,None), None, ), # 4
7190 amar.kumar 14599 
    (5, TType.I64, 'freebieWarehouseId', None, None, ), # 5
14600 
    (6, TType.STRING, 'billed_by', None, None, ), # 6
14601 
    (7, TType.I64, 'jacketNumber', None, None, ), # 7
14602 
    (8, TType.I64, 'billingType', None, None, ), # 8
14603 
    (9, TType.I64, 'fulfilmentWarehouseId', None, None, ), # 9
14604 
    (10, TType.BOOL, 'authorize', None, None, ), # 10
1135 chandransh 14605 
  )
14606 
 
7190 amar.kumar 14607 
  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 14608 
    self.orderId = orderId
14609 
    self.invoice_number = invoice_number
4658 mandeep.dh 14610 
    self.serialNumber = serialNumber
4283 anupam.sin 14611 
    self.itemNumber = itemNumber
7190 amar.kumar 14612 
    self.freebieWarehouseId = freebieWarehouseId
3064 chandransh 14613 
    self.billed_by = billed_by
4264 rajveer 14614 
    self.jacketNumber = jacketNumber
4283 anupam.sin 14615 
    self.billingType = billingType
5110 mandeep.dh 14616 
    self.fulfilmentWarehouseId = fulfilmentWarehouseId
4763 rajveer 14617 
    self.authorize = authorize
1135 chandransh 14618 
 
14619 
  def read(self, iprot):
14620 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14621 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14622 
      return
14623 
    iprot.readStructBegin()
14624 
    while True:
14625 
      (fname, ftype, fid) = iprot.readFieldBegin()
14626 
      if ftype == TType.STOP:
14627 
        break
14628 
      if fid == 1:
14629 
        if ftype == TType.I64:
3064 chandransh 14630 
          self.orderId = iprot.readI64();
1135 chandransh 14631 
        else:
14632 
          iprot.skip(ftype)
14633 
      elif fid == 2:
3064 chandransh 14634 
        if ftype == TType.STRING:
14635 
          self.invoice_number = iprot.readString();
1135 chandransh 14636 
        else:
14637 
          iprot.skip(ftype)
3064 chandransh 14638 
      elif fid == 3:
5411 rajveer 14639 
        if ftype == TType.LIST:
14640 
          self.serialNumber = []
6188 rajveer 14641 
          (_etype270, _size267) = iprot.readListBegin()
14642 
          for _i271 in xrange(_size267):
14643 
            _elem272 = iprot.readString();
14644 
            self.serialNumber.append(_elem272)
5411 rajveer 14645 
          iprot.readListEnd()
3064 chandransh 14646 
        else:
14647 
          iprot.skip(ftype)
14648 
      elif fid == 4:
5411 rajveer 14649 
        if ftype == TType.LIST:
14650 
          self.itemNumber = []
6188 rajveer 14651 
          (_etype276, _size273) = iprot.readListBegin()
14652 
          for _i277 in xrange(_size273):
14653 
            _elem278 = iprot.readString();
14654 
            self.itemNumber.append(_elem278)
5411 rajveer 14655 
          iprot.readListEnd()
3064 chandransh 14656 
        else:
14657 
          iprot.skip(ftype)
14658 
      elif fid == 5:
7190 amar.kumar 14659 
        if ftype == TType.I64:
14660 
          self.freebieWarehouseId = iprot.readI64();
14661 
        else:
14662 
          iprot.skip(ftype)
14663 
      elif fid == 6:
3064 chandransh 14664 
        if ftype == TType.STRING:
4283 anupam.sin 14665 
          self.billed_by = iprot.readString();
3064 chandransh 14666 
        else:
14667 
          iprot.skip(ftype)
7190 amar.kumar 14668 
      elif fid == 7:
3064 chandransh 14669 
        if ftype == TType.I64:
4283 anupam.sin 14670 
          self.jacketNumber = iprot.readI64();
14671 
        else:
14672 
          iprot.skip(ftype)
7190 amar.kumar 14673 
      elif fid == 8:
4283 anupam.sin 14674 
        if ftype == TType.I64:
3064 chandransh 14675 
          self.billingType = iprot.readI64();
14676 
        else:
14677 
          iprot.skip(ftype)
7190 amar.kumar 14678 
      elif fid == 9:
4283 anupam.sin 14679 
        if ftype == TType.I64:
5110 mandeep.dh 14680 
          self.fulfilmentWarehouseId = iprot.readI64();
4283 anupam.sin 14681 
        else:
14682 
          iprot.skip(ftype)
7190 amar.kumar 14683 
      elif fid == 10:
4763 rajveer 14684 
        if ftype == TType.BOOL:
14685 
          self.authorize = iprot.readBool();
14686 
        else:
14687 
          iprot.skip(ftype)
1246 chandransh 14688 
      else:
14689 
        iprot.skip(ftype)
14690 
      iprot.readFieldEnd()
14691 
    iprot.readStructEnd()
14692 
 
14693 
  def write(self, oprot):
14694 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14695 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14696 
      return
4283 anupam.sin 14697 
    oprot.writeStructBegin('addBillingDetails_args')
3431 rajveer 14698 
    if self.orderId is not None:
3064 chandransh 14699 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
14700 
      oprot.writeI64(self.orderId)
1246 chandransh 14701 
      oprot.writeFieldEnd()
4283 anupam.sin 14702 
    if self.invoice_number is not None:
14703 
      oprot.writeFieldBegin('invoice_number', TType.STRING, 2)
14704 
      oprot.writeString(self.invoice_number)
1246 chandransh 14705 
      oprot.writeFieldEnd()
4658 mandeep.dh 14706 
    if self.serialNumber is not None:
5411 rajveer 14707 
      oprot.writeFieldBegin('serialNumber', TType.LIST, 3)
14708 
      oprot.writeListBegin(TType.STRING, len(self.serialNumber))
6188 rajveer 14709 
      for iter279 in self.serialNumber:
14710 
        oprot.writeString(iter279)
5411 rajveer 14711 
      oprot.writeListEnd()
3064 chandransh 14712 
      oprot.writeFieldEnd()
3431 rajveer 14713 
    if self.itemNumber is not None:
5411 rajveer 14714 
      oprot.writeFieldBegin('itemNumber', TType.LIST, 4)
14715 
      oprot.writeListBegin(TType.STRING, len(self.itemNumber))
6188 rajveer 14716 
      for iter280 in self.itemNumber:
14717 
        oprot.writeString(iter280)
5411 rajveer 14718 
      oprot.writeListEnd()
3064 chandransh 14719 
      oprot.writeFieldEnd()
7190 amar.kumar 14720 
    if self.freebieWarehouseId is not None:
14721 
      oprot.writeFieldBegin('freebieWarehouseId', TType.I64, 5)
14722 
      oprot.writeI64(self.freebieWarehouseId)
14723 
      oprot.writeFieldEnd()
4283 anupam.sin 14724 
    if self.billed_by is not None:
7190 amar.kumar 14725 
      oprot.writeFieldBegin('billed_by', TType.STRING, 6)
4283 anupam.sin 14726 
      oprot.writeString(self.billed_by)
3064 chandransh 14727 
      oprot.writeFieldEnd()
4283 anupam.sin 14728 
    if self.jacketNumber is not None:
7190 amar.kumar 14729 
      oprot.writeFieldBegin('jacketNumber', TType.I64, 7)
4283 anupam.sin 14730 
      oprot.writeI64(self.jacketNumber)
14731 
      oprot.writeFieldEnd()
3431 rajveer 14732 
    if self.billingType is not None:
7190 amar.kumar 14733 
      oprot.writeFieldBegin('billingType', TType.I64, 8)
3064 chandransh 14734 
      oprot.writeI64(self.billingType)
14735 
      oprot.writeFieldEnd()
5110 mandeep.dh 14736 
    if self.fulfilmentWarehouseId is not None:
7190 amar.kumar 14737 
      oprot.writeFieldBegin('fulfilmentWarehouseId', TType.I64, 9)
5110 mandeep.dh 14738 
      oprot.writeI64(self.fulfilmentWarehouseId)
4283 anupam.sin 14739 
      oprot.writeFieldEnd()
4763 rajveer 14740 
    if self.authorize is not None:
7190 amar.kumar 14741 
      oprot.writeFieldBegin('authorize', TType.BOOL, 10)
4763 rajveer 14742 
      oprot.writeBool(self.authorize)
14743 
      oprot.writeFieldEnd()
1246 chandransh 14744 
    oprot.writeFieldStop()
14745 
    oprot.writeStructEnd()
14746 
 
3431 rajveer 14747 
  def validate(self):
14748 
    return
14749 
 
14750 
 
1246 chandransh 14751 
  def __repr__(self):
14752 
    L = ['%s=%r' % (key, value)
14753 
      for key, value in self.__dict__.iteritems()]
14754 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14755 
 
14756 
  def __eq__(self, other):
14757 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14758 
 
14759 
  def __ne__(self, other):
14760 
    return not (self == other)
14761 
 
4283 anupam.sin 14762 
class addBillingDetails_result:
1246 chandransh 14763 
  """
14764 
  Attributes:
3064 chandransh 14765 
   - success
1246 chandransh 14766 
   - ex
14767 
  """
14768 
 
14769 
  thrift_spec = (
3064 chandransh 14770 
    (0, TType.BOOL, 'success', None, None, ), # 0
1246 chandransh 14771 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
14772 
  )
14773 
 
3064 chandransh 14774 
  def __init__(self, success=None, ex=None,):
14775 
    self.success = success
1246 chandransh 14776 
    self.ex = ex
14777 
 
14778 
  def read(self, iprot):
14779 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14780 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14781 
      return
14782 
    iprot.readStructBegin()
14783 
    while True:
14784 
      (fname, ftype, fid) = iprot.readFieldBegin()
14785 
      if ftype == TType.STOP:
14786 
        break
3064 chandransh 14787 
      if fid == 0:
14788 
        if ftype == TType.BOOL:
14789 
          self.success = iprot.readBool();
14790 
        else:
14791 
          iprot.skip(ftype)
14792 
      elif fid == 1:
1246 chandransh 14793 
        if ftype == TType.STRUCT:
14794 
          self.ex = TransactionServiceException()
14795 
          self.ex.read(iprot)
14796 
        else:
14797 
          iprot.skip(ftype)
14798 
      else:
14799 
        iprot.skip(ftype)
14800 
      iprot.readFieldEnd()
14801 
    iprot.readStructEnd()
14802 
 
14803 
  def write(self, oprot):
14804 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14805 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14806 
      return
4283 anupam.sin 14807 
    oprot.writeStructBegin('addBillingDetails_result')
3431 rajveer 14808 
    if self.success is not None:
3064 chandransh 14809 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
14810 
      oprot.writeBool(self.success)
14811 
      oprot.writeFieldEnd()
3431 rajveer 14812 
    if self.ex is not None:
1246 chandransh 14813 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
14814 
      self.ex.write(oprot)
14815 
      oprot.writeFieldEnd()
14816 
    oprot.writeFieldStop()
14817 
    oprot.writeStructEnd()
14818 
 
3431 rajveer 14819 
  def validate(self):
14820 
    return
14821 
 
14822 
 
1246 chandransh 14823 
  def __repr__(self):
14824 
    L = ['%s=%r' % (key, value)
14825 
      for key, value in self.__dict__.iteritems()]
14826 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14827 
 
14828 
  def __eq__(self, other):
14829 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14830 
 
14831 
  def __ne__(self, other):
14832 
    return not (self == other)
14833 
 
4579 rajveer 14834 
class addInvoiceNumber_args:
14835 
  """
14836 
  Attributes:
14837 
   - orderId
14838 
   - invoiceNumber
4763 rajveer 14839 
   - color
6756 amar.kumar 14840 
   - serialNumber
14841 
   - itemNumber
4579 rajveer 14842 
  """
14843 
 
14844 
  thrift_spec = (
14845 
    None, # 0
14846 
    (1, TType.I64, 'orderId', None, None, ), # 1
14847 
    (2, TType.STRING, 'invoiceNumber', None, None, ), # 2
4763 rajveer 14848 
    (3, TType.STRING, 'color', None, None, ), # 3
6756 amar.kumar 14849 
    (4, TType.STRING, 'serialNumber', None, None, ), # 4
14850 
    (5, TType.STRING, 'itemNumber', None, None, ), # 5
4579 rajveer 14851 
  )
14852 
 
6756 amar.kumar 14853 
  def __init__(self, orderId=None, invoiceNumber=None, color=None, serialNumber=None, itemNumber=None,):
4579 rajveer 14854 
    self.orderId = orderId
14855 
    self.invoiceNumber = invoiceNumber
4763 rajveer 14856 
    self.color = color
6756 amar.kumar 14857 
    self.serialNumber = serialNumber
14858 
    self.itemNumber = itemNumber
4579 rajveer 14859 
 
14860 
  def read(self, iprot):
14861 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14862 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14863 
      return
14864 
    iprot.readStructBegin()
14865 
    while True:
14866 
      (fname, ftype, fid) = iprot.readFieldBegin()
14867 
      if ftype == TType.STOP:
14868 
        break
14869 
      if fid == 1:
14870 
        if ftype == TType.I64:
14871 
          self.orderId = iprot.readI64();
14872 
        else:
14873 
          iprot.skip(ftype)
14874 
      elif fid == 2:
14875 
        if ftype == TType.STRING:
14876 
          self.invoiceNumber = iprot.readString();
14877 
        else:
14878 
          iprot.skip(ftype)
4763 rajveer 14879 
      elif fid == 3:
14880 
        if ftype == TType.STRING:
14881 
          self.color = iprot.readString();
14882 
        else:
14883 
          iprot.skip(ftype)
6756 amar.kumar 14884 
      elif fid == 4:
14885 
        if ftype == TType.STRING:
14886 
          self.serialNumber = iprot.readString();
14887 
        else:
14888 
          iprot.skip(ftype)
14889 
      elif fid == 5:
14890 
        if ftype == TType.STRING:
14891 
          self.itemNumber = iprot.readString();
14892 
        else:
14893 
          iprot.skip(ftype)
4579 rajveer 14894 
      else:
14895 
        iprot.skip(ftype)
14896 
      iprot.readFieldEnd()
14897 
    iprot.readStructEnd()
14898 
 
14899 
  def write(self, oprot):
14900 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14901 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14902 
      return
14903 
    oprot.writeStructBegin('addInvoiceNumber_args')
14904 
    if self.orderId is not None:
14905 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
14906 
      oprot.writeI64(self.orderId)
14907 
      oprot.writeFieldEnd()
14908 
    if self.invoiceNumber is not None:
14909 
      oprot.writeFieldBegin('invoiceNumber', TType.STRING, 2)
14910 
      oprot.writeString(self.invoiceNumber)
14911 
      oprot.writeFieldEnd()
4763 rajveer 14912 
    if self.color is not None:
14913 
      oprot.writeFieldBegin('color', TType.STRING, 3)
14914 
      oprot.writeString(self.color)
14915 
      oprot.writeFieldEnd()
6756 amar.kumar 14916 
    if self.serialNumber is not None:
14917 
      oprot.writeFieldBegin('serialNumber', TType.STRING, 4)
14918 
      oprot.writeString(self.serialNumber)
14919 
      oprot.writeFieldEnd()
14920 
    if self.itemNumber is not None:
14921 
      oprot.writeFieldBegin('itemNumber', TType.STRING, 5)
14922 
      oprot.writeString(self.itemNumber)
14923 
      oprot.writeFieldEnd()
4579 rajveer 14924 
    oprot.writeFieldStop()
14925 
    oprot.writeStructEnd()
14926 
 
14927 
  def validate(self):
14928 
    return
14929 
 
14930 
 
14931 
  def __repr__(self):
14932 
    L = ['%s=%r' % (key, value)
14933 
      for key, value in self.__dict__.iteritems()]
14934 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14935 
 
14936 
  def __eq__(self, other):
14937 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14938 
 
14939 
  def __ne__(self, other):
14940 
    return not (self == other)
14941 
 
14942 
class addInvoiceNumber_result:
14943 
  """
14944 
  Attributes:
14945 
   - ex
14946 
  """
14947 
 
14948 
  thrift_spec = (
14949 
    None, # 0
14950 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
14951 
  )
14952 
 
14953 
  def __init__(self, ex=None,):
14954 
    self.ex = ex
14955 
 
14956 
  def read(self, iprot):
14957 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14958 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14959 
      return
14960 
    iprot.readStructBegin()
14961 
    while True:
14962 
      (fname, ftype, fid) = iprot.readFieldBegin()
14963 
      if ftype == TType.STOP:
14964 
        break
14965 
      if fid == 1:
14966 
        if ftype == TType.STRUCT:
14967 
          self.ex = TransactionServiceException()
14968 
          self.ex.read(iprot)
14969 
        else:
14970 
          iprot.skip(ftype)
14971 
      else:
14972 
        iprot.skip(ftype)
14973 
      iprot.readFieldEnd()
14974 
    iprot.readStructEnd()
14975 
 
14976 
  def write(self, oprot):
14977 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14978 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14979 
      return
14980 
    oprot.writeStructBegin('addInvoiceNumber_result')
14981 
    if self.ex is not None:
14982 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
14983 
      self.ex.write(oprot)
14984 
      oprot.writeFieldEnd()
14985 
    oprot.writeFieldStop()
14986 
    oprot.writeStructEnd()
14987 
 
14988 
  def validate(self):
14989 
    return
14990 
 
14991 
 
14992 
  def __repr__(self):
14993 
    L = ['%s=%r' % (key, value)
14994 
      for key, value in self.__dict__.iteritems()]
14995 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14996 
 
14997 
  def __eq__(self, other):
14998 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14999 
 
15000 
  def __ne__(self, other):
15001 
    return not (self == other)
15002 
 
4910 phani.kuma 15003 
class markOrdersAsShippedFromWarehouse_args:
1408 ankur.sing 15004 
  """
15005 
  Attributes:
3064 chandransh 15006 
   - warehouseId
1408 ankur.sing 15007 
   - providerId
3064 chandransh 15008 
   - cod
4910 phani.kuma 15009 
   - orderIds
1408 ankur.sing 15010 
  """
15011 
 
15012 
  thrift_spec = (
15013 
    None, # 0
3064 chandransh 15014 
    (1, TType.I64, 'warehouseId', None, None, ), # 1
15015 
    (2, TType.I64, 'providerId', None, None, ), # 2
15016 
    (3, TType.BOOL, 'cod', None, None, ), # 3
4910 phani.kuma 15017 
    (4, TType.LIST, 'orderIds', (TType.I64,None), None, ), # 4
1408 ankur.sing 15018 
  )
15019 
 
4910 phani.kuma 15020 
  def __init__(self, warehouseId=None, providerId=None, cod=None, orderIds=None,):
3064 chandransh 15021 
    self.warehouseId = warehouseId
1408 ankur.sing 15022 
    self.providerId = providerId
3064 chandransh 15023 
    self.cod = cod
4910 phani.kuma 15024 
    self.orderIds = orderIds
1408 ankur.sing 15025 
 
15026 
  def read(self, iprot):
15027 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15028 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15029 
      return
15030 
    iprot.readStructBegin()
15031 
    while True:
15032 
      (fname, ftype, fid) = iprot.readFieldBegin()
15033 
      if ftype == TType.STOP:
15034 
        break
15035 
      if fid == 1:
15036 
        if ftype == TType.I64:
3064 chandransh 15037 
          self.warehouseId = iprot.readI64();
1408 ankur.sing 15038 
        else:
15039 
          iprot.skip(ftype)
15040 
      elif fid == 2:
15041 
        if ftype == TType.I64:
3064 chandransh 15042 
          self.providerId = iprot.readI64();
1408 ankur.sing 15043 
        else:
15044 
          iprot.skip(ftype)
3064 chandransh 15045 
      elif fid == 3:
15046 
        if ftype == TType.BOOL:
15047 
          self.cod = iprot.readBool();
15048 
        else:
15049 
          iprot.skip(ftype)
4910 phani.kuma 15050 
      elif fid == 4:
15051 
        if ftype == TType.LIST:
15052 
          self.orderIds = []
6188 rajveer 15053 
          (_etype284, _size281) = iprot.readListBegin()
15054 
          for _i285 in xrange(_size281):
15055 
            _elem286 = iprot.readI64();
15056 
            self.orderIds.append(_elem286)
4910 phani.kuma 15057 
          iprot.readListEnd()
15058 
        else:
15059 
          iprot.skip(ftype)
1408 ankur.sing 15060 
      else:
15061 
        iprot.skip(ftype)
15062 
      iprot.readFieldEnd()
15063 
    iprot.readStructEnd()
15064 
 
15065 
  def write(self, oprot):
15066 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15067 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15068 
      return
4910 phani.kuma 15069 
    oprot.writeStructBegin('markOrdersAsShippedFromWarehouse_args')
3431 rajveer 15070 
    if self.warehouseId is not None:
3064 chandransh 15071 
      oprot.writeFieldBegin('warehouseId', TType.I64, 1)
15072 
      oprot.writeI64(self.warehouseId)
15073 
      oprot.writeFieldEnd()
3431 rajveer 15074 
    if self.providerId is not None:
3064 chandransh 15075 
      oprot.writeFieldBegin('providerId', TType.I64, 2)
1408 ankur.sing 15076 
      oprot.writeI64(self.providerId)
15077 
      oprot.writeFieldEnd()
3431 rajveer 15078 
    if self.cod is not None:
3064 chandransh 15079 
      oprot.writeFieldBegin('cod', TType.BOOL, 3)
15080 
      oprot.writeBool(self.cod)
1408 ankur.sing 15081 
      oprot.writeFieldEnd()
4910 phani.kuma 15082 
    if self.orderIds is not None:
15083 
      oprot.writeFieldBegin('orderIds', TType.LIST, 4)
15084 
      oprot.writeListBegin(TType.I64, len(self.orderIds))
6188 rajveer 15085 
      for iter287 in self.orderIds:
15086 
        oprot.writeI64(iter287)
4910 phani.kuma 15087 
      oprot.writeListEnd()
15088 
      oprot.writeFieldEnd()
1408 ankur.sing 15089 
    oprot.writeFieldStop()
15090 
    oprot.writeStructEnd()
15091 
 
3431 rajveer 15092 
  def validate(self):
15093 
    return
15094 
 
15095 
 
1408 ankur.sing 15096 
  def __repr__(self):
15097 
    L = ['%s=%r' % (key, value)
15098 
      for key, value in self.__dict__.iteritems()]
15099 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15100 
 
15101 
  def __eq__(self, other):
15102 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15103 
 
15104 
  def __ne__(self, other):
15105 
    return not (self == other)
15106 
 
4910 phani.kuma 15107 
class markOrdersAsShippedFromWarehouse_result:
1408 ankur.sing 15108 
  """
15109 
  Attributes:
15110 
   - success
3064 chandransh 15111 
   - ex
1408 ankur.sing 15112 
  """
15113 
 
15114 
  thrift_spec = (
3064 chandransh 15115 
    (0, TType.BOOL, 'success', None, None, ), # 0
15116 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
1408 ankur.sing 15117 
  )
15118 
 
3064 chandransh 15119 
  def __init__(self, success=None, ex=None,):
1408 ankur.sing 15120 
    self.success = success
3064 chandransh 15121 
    self.ex = ex
1408 ankur.sing 15122 
 
15123 
  def read(self, iprot):
15124 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15125 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15126 
      return
15127 
    iprot.readStructBegin()
15128 
    while True:
15129 
      (fname, ftype, fid) = iprot.readFieldBegin()
15130 
      if ftype == TType.STOP:
15131 
        break
15132 
      if fid == 0:
3064 chandransh 15133 
        if ftype == TType.BOOL:
15134 
          self.success = iprot.readBool();
1408 ankur.sing 15135 
        else:
15136 
          iprot.skip(ftype)
3064 chandransh 15137 
      elif fid == 1:
15138 
        if ftype == TType.STRUCT:
15139 
          self.ex = TransactionServiceException()
15140 
          self.ex.read(iprot)
15141 
        else:
15142 
          iprot.skip(ftype)
1408 ankur.sing 15143 
      else:
15144 
        iprot.skip(ftype)
15145 
      iprot.readFieldEnd()
15146 
    iprot.readStructEnd()
15147 
 
15148 
  def write(self, oprot):
15149 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15150 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15151 
      return
4910 phani.kuma 15152 
    oprot.writeStructBegin('markOrdersAsShippedFromWarehouse_result')
3431 rajveer 15153 
    if self.success is not None:
3064 chandransh 15154 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
15155 
      oprot.writeBool(self.success)
1408 ankur.sing 15156 
      oprot.writeFieldEnd()
3431 rajveer 15157 
    if self.ex is not None:
3064 chandransh 15158 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
15159 
      self.ex.write(oprot)
15160 
      oprot.writeFieldEnd()
1408 ankur.sing 15161 
    oprot.writeFieldStop()
15162 
    oprot.writeStructEnd()
15163 
 
3431 rajveer 15164 
  def validate(self):
15165 
    return
15166 
 
15167 
 
1408 ankur.sing 15168 
  def __repr__(self):
15169 
    L = ['%s=%r' % (key, value)
15170 
      for key, value in self.__dict__.iteritems()]
15171 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15172 
 
15173 
  def __eq__(self, other):
15174 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15175 
 
15176 
  def __ne__(self, other):
15177 
    return not (self == other)
15178 
 
5676 rajveer 15179 
class markOrdersAsReturnedFromStore_args:
15180 
  """
15181 
  Attributes:
15182 
   - providerId
15183 
   - orderIds
5713 rajveer 15184 
   - awbs
5676 rajveer 15185 
  """
15186 
 
15187 
  thrift_spec = (
15188 
    None, # 0
15189 
    (1, TType.I64, 'providerId', None, None, ), # 1
15190 
    (2, TType.LIST, 'orderIds', (TType.I64,None), None, ), # 2
5713 rajveer 15191 
    (3, TType.LIST, 'awbs', (TType.STRING,None), None, ), # 3
5676 rajveer 15192 
  )
15193 
 
5713 rajveer 15194 
  def __init__(self, providerId=None, orderIds=None, awbs=None,):
5676 rajveer 15195 
    self.providerId = providerId
15196 
    self.orderIds = orderIds
5713 rajveer 15197 
    self.awbs = awbs
5676 rajveer 15198 
 
15199 
  def read(self, iprot):
15200 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15201 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15202 
      return
15203 
    iprot.readStructBegin()
15204 
    while True:
15205 
      (fname, ftype, fid) = iprot.readFieldBegin()
15206 
      if ftype == TType.STOP:
15207 
        break
15208 
      if fid == 1:
15209 
        if ftype == TType.I64:
15210 
          self.providerId = iprot.readI64();
15211 
        else:
15212 
          iprot.skip(ftype)
15213 
      elif fid == 2:
15214 
        if ftype == TType.LIST:
15215 
          self.orderIds = []
6188 rajveer 15216 
          (_etype291, _size288) = iprot.readListBegin()
15217 
          for _i292 in xrange(_size288):
15218 
            _elem293 = iprot.readI64();
15219 
            self.orderIds.append(_elem293)
5676 rajveer 15220 
          iprot.readListEnd()
15221 
        else:
15222 
          iprot.skip(ftype)
5713 rajveer 15223 
      elif fid == 3:
15224 
        if ftype == TType.LIST:
15225 
          self.awbs = []
6188 rajveer 15226 
          (_etype297, _size294) = iprot.readListBegin()
15227 
          for _i298 in xrange(_size294):
15228 
            _elem299 = iprot.readString();
15229 
            self.awbs.append(_elem299)
5713 rajveer 15230 
          iprot.readListEnd()
15231 
        else:
15232 
          iprot.skip(ftype)
5676 rajveer 15233 
      else:
15234 
        iprot.skip(ftype)
15235 
      iprot.readFieldEnd()
15236 
    iprot.readStructEnd()
15237 
 
15238 
  def write(self, oprot):
15239 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15240 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15241 
      return
15242 
    oprot.writeStructBegin('markOrdersAsReturnedFromStore_args')
15243 
    if self.providerId is not None:
15244 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
15245 
      oprot.writeI64(self.providerId)
15246 
      oprot.writeFieldEnd()
15247 
    if self.orderIds is not None:
15248 
      oprot.writeFieldBegin('orderIds', TType.LIST, 2)
15249 
      oprot.writeListBegin(TType.I64, len(self.orderIds))
6188 rajveer 15250 
      for iter300 in self.orderIds:
15251 
        oprot.writeI64(iter300)
5676 rajveer 15252 
      oprot.writeListEnd()
15253 
      oprot.writeFieldEnd()
5713 rajveer 15254 
    if self.awbs is not None:
15255 
      oprot.writeFieldBegin('awbs', TType.LIST, 3)
15256 
      oprot.writeListBegin(TType.STRING, len(self.awbs))
6188 rajveer 15257 
      for iter301 in self.awbs:
15258 
        oprot.writeString(iter301)
5713 rajveer 15259 
      oprot.writeListEnd()
15260 
      oprot.writeFieldEnd()
5676 rajveer 15261 
    oprot.writeFieldStop()
15262 
    oprot.writeStructEnd()
15263 
 
15264 
  def validate(self):
15265 
    return
15266 
 
15267 
 
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 
 
15279 
class markOrdersAsReturnedFromStore_result:
15280 
  """
15281 
  Attributes:
15282 
   - success
15283 
   - ex
15284 
  """
15285 
 
15286 
  thrift_spec = (
15287 
    (0, TType.BOOL, 'success', None, None, ), # 0
15288 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
15289 
  )
15290 
 
15291 
  def __init__(self, success=None, ex=None,):
15292 
    self.success = success
15293 
    self.ex = ex
15294 
 
15295 
  def read(self, iprot):
15296 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15297 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15298 
      return
15299 
    iprot.readStructBegin()
15300 
    while True:
15301 
      (fname, ftype, fid) = iprot.readFieldBegin()
15302 
      if ftype == TType.STOP:
15303 
        break
15304 
      if fid == 0:
15305 
        if ftype == TType.BOOL:
15306 
          self.success = iprot.readBool();
15307 
        else:
15308 
          iprot.skip(ftype)
15309 
      elif fid == 1:
15310 
        if ftype == TType.STRUCT:
15311 
          self.ex = TransactionServiceException()
15312 
          self.ex.read(iprot)
15313 
        else:
15314 
          iprot.skip(ftype)
15315 
      else:
15316 
        iprot.skip(ftype)
15317 
      iprot.readFieldEnd()
15318 
    iprot.readStructEnd()
15319 
 
15320 
  def write(self, oprot):
15321 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15322 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15323 
      return
15324 
    oprot.writeStructBegin('markOrdersAsReturnedFromStore_result')
15325 
    if self.success is not None:
15326 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
15327 
      oprot.writeBool(self.success)
15328 
      oprot.writeFieldEnd()
15329 
    if self.ex is not None:
15330 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
15331 
      self.ex.write(oprot)
15332 
      oprot.writeFieldEnd()
15333 
    oprot.writeFieldStop()
15334 
    oprot.writeStructEnd()
15335 
 
15336 
  def validate(self):
15337 
    return
15338 
 
15339 
 
15340 
  def __repr__(self):
15341 
    L = ['%s=%r' % (key, value)
15342 
      for key, value in self.__dict__.iteritems()]
15343 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15344 
 
15345 
  def __eq__(self, other):
15346 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15347 
 
15348 
  def __ne__(self, other):
15349 
    return not (self == other)
15350 
 
4910 phani.kuma 15351 
class markOrdersAsPickedUp_args:
4410 rajveer 15352 
  """
15353 
  Attributes:
15354 
   - providerId
4910 phani.kuma 15355 
   - pickupDetails
4410 rajveer 15356 
  """
15357 
 
15358 
  thrift_spec = (
15359 
    None, # 0
4910 phani.kuma 15360 
    (1, TType.I64, 'providerId', None, None, ), # 1
15361 
    (2, TType.MAP, 'pickupDetails', (TType.STRING,None,TType.STRING,None), None, ), # 2
4410 rajveer 15362 
  )
15363 
 
4910 phani.kuma 15364 
  def __init__(self, providerId=None, pickupDetails=None,):
4410 rajveer 15365 
    self.providerId = providerId
4910 phani.kuma 15366 
    self.pickupDetails = pickupDetails
4410 rajveer 15367 
 
15368 
  def read(self, iprot):
15369 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15370 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15371 
      return
15372 
    iprot.readStructBegin()
15373 
    while True:
15374 
      (fname, ftype, fid) = iprot.readFieldBegin()
15375 
      if ftype == TType.STOP:
15376 
        break
15377 
      if fid == 1:
15378 
        if ftype == TType.I64:
4910 phani.kuma 15379 
          self.providerId = iprot.readI64();
4410 rajveer 15380 
        else:
15381 
          iprot.skip(ftype)
15382 
      elif fid == 2:
4910 phani.kuma 15383 
        if ftype == TType.MAP:
15384 
          self.pickupDetails = {}
6188 rajveer 15385 
          (_ktype303, _vtype304, _size302 ) = iprot.readMapBegin()
15386 
          for _i306 in xrange(_size302):
15387 
            _key307 = iprot.readString();
15388 
            _val308 = iprot.readString();
15389 
            self.pickupDetails[_key307] = _val308
4910 phani.kuma 15390 
          iprot.readMapEnd()
4410 rajveer 15391 
        else:
15392 
          iprot.skip(ftype)
15393 
      else:
15394 
        iprot.skip(ftype)
15395 
      iprot.readFieldEnd()
15396 
    iprot.readStructEnd()
15397 
 
15398 
  def write(self, oprot):
15399 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15400 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15401 
      return
4910 phani.kuma 15402 
    oprot.writeStructBegin('markOrdersAsPickedUp_args')
4410 rajveer 15403 
    if self.providerId is not None:
4910 phani.kuma 15404 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
4410 rajveer 15405 
      oprot.writeI64(self.providerId)
15406 
      oprot.writeFieldEnd()
4910 phani.kuma 15407 
    if self.pickupDetails is not None:
15408 
      oprot.writeFieldBegin('pickupDetails', TType.MAP, 2)
15409 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.pickupDetails))
6188 rajveer 15410 
      for kiter309,viter310 in self.pickupDetails.items():
15411 
        oprot.writeString(kiter309)
15412 
        oprot.writeString(viter310)
4910 phani.kuma 15413 
      oprot.writeMapEnd()
4410 rajveer 15414 
      oprot.writeFieldEnd()
15415 
    oprot.writeFieldStop()
15416 
    oprot.writeStructEnd()
15417 
 
15418 
  def validate(self):
15419 
    return
15420 
 
15421 
 
15422 
  def __repr__(self):
15423 
    L = ['%s=%r' % (key, value)
15424 
      for key, value in self.__dict__.iteritems()]
15425 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15426 
 
15427 
  def __eq__(self, other):
15428 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15429 
 
15430 
  def __ne__(self, other):
15431 
    return not (self == other)
15432 
 
4910 phani.kuma 15433 
class markOrdersAsPickedUp_result:
4410 rajveer 15434 
  """
15435 
  Attributes:
15436 
   - ex
15437 
  """
15438 
 
15439 
  thrift_spec = (
4910 phani.kuma 15440 
    None, # 0
4410 rajveer 15441 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
15442 
  )
15443 
 
4910 phani.kuma 15444 
  def __init__(self, ex=None,):
4410 rajveer 15445 
    self.ex = ex
15446 
 
15447 
  def read(self, iprot):
15448 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15449 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15450 
      return
15451 
    iprot.readStructBegin()
15452 
    while True:
15453 
      (fname, ftype, fid) = iprot.readFieldBegin()
15454 
      if ftype == TType.STOP:
15455 
        break
4910 phani.kuma 15456 
      if fid == 1:
4410 rajveer 15457 
        if ftype == TType.STRUCT:
15458 
          self.ex = TransactionServiceException()
15459 
          self.ex.read(iprot)
15460 
        else:
15461 
          iprot.skip(ftype)
15462 
      else:
15463 
        iprot.skip(ftype)
15464 
      iprot.readFieldEnd()
15465 
    iprot.readStructEnd()
15466 
 
15467 
  def write(self, oprot):
15468 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15469 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15470 
      return
4910 phani.kuma 15471 
    oprot.writeStructBegin('markOrdersAsPickedUp_result')
4410 rajveer 15472 
    if self.ex is not None:
15473 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
15474 
      self.ex.write(oprot)
15475 
      oprot.writeFieldEnd()
15476 
    oprot.writeFieldStop()
15477 
    oprot.writeStructEnd()
15478 
 
15479 
  def validate(self):
15480 
    return
15481 
 
15482 
 
15483 
  def __repr__(self):
15484 
    L = ['%s=%r' % (key, value)
15485 
      for key, value in self.__dict__.iteritems()]
15486 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15487 
 
15488 
  def __eq__(self, other):
15489 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15490 
 
15491 
  def __ne__(self, other):
15492 
    return not (self == other)
15493 
 
4910 phani.kuma 15494 
class getOrdersNotPickedUp_args:
304 ashish 15495 
  """
15496 
  Attributes:
3064 chandransh 15497 
   - providerId
304 ashish 15498 
  """
94 ashish 15499 
 
304 ashish 15500 
  thrift_spec = (
15501 
    None, # 0
3064 chandransh 15502 
    (1, TType.I64, 'providerId', None, None, ), # 1
304 ashish 15503 
  )
15504 
 
4910 phani.kuma 15505 
  def __init__(self, providerId=None,):
3064 chandransh 15506 
    self.providerId = providerId
304 ashish 15507 
 
15508 
  def read(self, iprot):
15509 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15510 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15511 
      return
15512 
    iprot.readStructBegin()
15513 
    while True:
15514 
      (fname, ftype, fid) = iprot.readFieldBegin()
15515 
      if ftype == TType.STOP:
15516 
        break
15517 
      if fid == 1:
15518 
        if ftype == TType.I64:
3064 chandransh 15519 
          self.providerId = iprot.readI64();
304 ashish 15520 
        else:
15521 
          iprot.skip(ftype)
15522 
      else:
15523 
        iprot.skip(ftype)
15524 
      iprot.readFieldEnd()
15525 
    iprot.readStructEnd()
15526 
 
15527 
  def write(self, oprot):
15528 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15529 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15530 
      return
4910 phani.kuma 15531 
    oprot.writeStructBegin('getOrdersNotPickedUp_args')
3431 rajveer 15532 
    if self.providerId is not None:
3064 chandransh 15533 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
15534 
      oprot.writeI64(self.providerId)
304 ashish 15535 
      oprot.writeFieldEnd()
15536 
    oprot.writeFieldStop()
15537 
    oprot.writeStructEnd()
15538 
 
3431 rajveer 15539 
  def validate(self):
15540 
    return
15541 
 
15542 
 
304 ashish 15543 
  def __repr__(self):
15544 
    L = ['%s=%r' % (key, value)
15545 
      for key, value in self.__dict__.iteritems()]
15546 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15547 
 
15548 
  def __eq__(self, other):
15549 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15550 
 
15551 
  def __ne__(self, other):
15552 
    return not (self == other)
15553 
 
4910 phani.kuma 15554 
class getOrdersNotPickedUp_result:
304 ashish 15555 
  """
15556 
  Attributes:
15557 
   - success
15558 
  """
15559 
 
15560 
  thrift_spec = (
3064 chandransh 15561 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
304 ashish 15562 
  )
15563 
 
4910 phani.kuma 15564 
  def __init__(self, success=None,):
304 ashish 15565 
    self.success = success
15566 
 
15567 
  def read(self, iprot):
15568 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15569 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15570 
      return
15571 
    iprot.readStructBegin()
15572 
    while True:
15573 
      (fname, ftype, fid) = iprot.readFieldBegin()
15574 
      if ftype == TType.STOP:
15575 
        break
15576 
      if fid == 0:
15577 
        if ftype == TType.LIST:
15578 
          self.success = []
6188 rajveer 15579 
          (_etype314, _size311) = iprot.readListBegin()
15580 
          for _i315 in xrange(_size311):
15581 
            _elem316 = Order()
15582 
            _elem316.read(iprot)
15583 
            self.success.append(_elem316)
304 ashish 15584 
          iprot.readListEnd()
15585 
        else:
15586 
          iprot.skip(ftype)
15587 
      else:
15588 
        iprot.skip(ftype)
15589 
      iprot.readFieldEnd()
15590 
    iprot.readStructEnd()
15591 
 
15592 
  def write(self, oprot):
15593 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15594 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15595 
      return
4910 phani.kuma 15596 
    oprot.writeStructBegin('getOrdersNotPickedUp_result')
3431 rajveer 15597 
    if self.success is not None:
304 ashish 15598 
      oprot.writeFieldBegin('success', TType.LIST, 0)
15599 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 15600 
      for iter317 in self.success:
15601 
        iter317.write(oprot)
304 ashish 15602 
      oprot.writeListEnd()
15603 
      oprot.writeFieldEnd()
15604 
    oprot.writeFieldStop()
15605 
    oprot.writeStructEnd()
15606 
 
3431 rajveer 15607 
  def validate(self):
15608 
    return
15609 
 
15610 
 
304 ashish 15611 
  def __repr__(self):
15612 
    L = ['%s=%r' % (key, value)
15613 
      for key, value in self.__dict__.iteritems()]
15614 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15615 
 
15616 
  def __eq__(self, other):
15617 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15618 
 
15619 
  def __ne__(self, other):
15620 
    return not (self == other)
15621 
 
3064 chandransh 15622 
class markOrdersAsDelivered_args:
304 ashish 15623 
  """
15624 
  Attributes:
3064 chandransh 15625 
   - providerId
15626 
   - deliveredOrders
304 ashish 15627 
  """
15628 
 
15629 
  thrift_spec = (
15630 
    None, # 0
3064 chandransh 15631 
    (1, TType.I64, 'providerId', None, None, ), # 1
15632 
    (2, TType.MAP, 'deliveredOrders', (TType.STRING,None,TType.STRING,None), None, ), # 2
304 ashish 15633 
  )
15634 
 
3064 chandransh 15635 
  def __init__(self, providerId=None, deliveredOrders=None,):
15636 
    self.providerId = providerId
15637 
    self.deliveredOrders = deliveredOrders
304 ashish 15638 
 
15639 
  def read(self, iprot):
15640 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15641 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15642 
      return
15643 
    iprot.readStructBegin()
15644 
    while True:
15645 
      (fname, ftype, fid) = iprot.readFieldBegin()
15646 
      if ftype == TType.STOP:
15647 
        break
15648 
      if fid == 1:
15649 
        if ftype == TType.I64:
3064 chandransh 15650 
          self.providerId = iprot.readI64();
304 ashish 15651 
        else:
15652 
          iprot.skip(ftype)
15653 
      elif fid == 2:
3064 chandransh 15654 
        if ftype == TType.MAP:
15655 
          self.deliveredOrders = {}
6188 rajveer 15656 
          (_ktype319, _vtype320, _size318 ) = iprot.readMapBegin()
15657 
          for _i322 in xrange(_size318):
15658 
            _key323 = iprot.readString();
15659 
            _val324 = iprot.readString();
15660 
            self.deliveredOrders[_key323] = _val324
3064 chandransh 15661 
          iprot.readMapEnd()
304 ashish 15662 
        else:
15663 
          iprot.skip(ftype)
15664 
      else:
15665 
        iprot.skip(ftype)
15666 
      iprot.readFieldEnd()
15667 
    iprot.readStructEnd()
15668 
 
15669 
  def write(self, oprot):
15670 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15671 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15672 
      return
3064 chandransh 15673 
    oprot.writeStructBegin('markOrdersAsDelivered_args')
3431 rajveer 15674 
    if self.providerId is not None:
3064 chandransh 15675 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
15676 
      oprot.writeI64(self.providerId)
304 ashish 15677 
      oprot.writeFieldEnd()
3431 rajveer 15678 
    if self.deliveredOrders is not None:
3064 chandransh 15679 
      oprot.writeFieldBegin('deliveredOrders', TType.MAP, 2)
15680 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.deliveredOrders))
6188 rajveer 15681 
      for kiter325,viter326 in self.deliveredOrders.items():
15682 
        oprot.writeString(kiter325)
15683 
        oprot.writeString(viter326)
3064 chandransh 15684 
      oprot.writeMapEnd()
304 ashish 15685 
      oprot.writeFieldEnd()
15686 
    oprot.writeFieldStop()
15687 
    oprot.writeStructEnd()
15688 
 
3431 rajveer 15689 
  def validate(self):
15690 
    return
15691 
 
15692 
 
304 ashish 15693 
  def __repr__(self):
15694 
    L = ['%s=%r' % (key, value)
15695 
      for key, value in self.__dict__.iteritems()]
15696 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15697 
 
15698 
  def __eq__(self, other):
15699 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15700 
 
15701 
  def __ne__(self, other):
15702 
    return not (self == other)
15703 
 
3064 chandransh 15704 
class markOrdersAsDelivered_result:
15705 
  """
15706 
  Attributes:
15707 
   - ex
15708 
  """
304 ashish 15709 
 
15710 
  thrift_spec = (
3064 chandransh 15711 
    None, # 0
15712 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
304 ashish 15713 
  )
15714 
 
3064 chandransh 15715 
  def __init__(self, ex=None,):
15716 
    self.ex = ex
304 ashish 15717 
 
1596 ankur.sing 15718 
  def read(self, iprot):
15719 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15720 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15721 
      return
15722 
    iprot.readStructBegin()
15723 
    while True:
15724 
      (fname, ftype, fid) = iprot.readFieldBegin()
15725 
      if ftype == TType.STOP:
15726 
        break
3064 chandransh 15727 
      if fid == 1:
15728 
        if ftype == TType.STRUCT:
15729 
          self.ex = TransactionServiceException()
15730 
          self.ex.read(iprot)
15731 
        else:
15732 
          iprot.skip(ftype)
1596 ankur.sing 15733 
      else:
15734 
        iprot.skip(ftype)
15735 
      iprot.readFieldEnd()
15736 
    iprot.readStructEnd()
15737 
 
15738 
  def write(self, oprot):
15739 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15740 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15741 
      return
3064 chandransh 15742 
    oprot.writeStructBegin('markOrdersAsDelivered_result')
3431 rajveer 15743 
    if self.ex is not None:
3064 chandransh 15744 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
15745 
      self.ex.write(oprot)
15746 
      oprot.writeFieldEnd()
1596 ankur.sing 15747 
    oprot.writeFieldStop()
15748 
    oprot.writeStructEnd()
15749 
 
3431 rajveer 15750 
  def validate(self):
15751 
    return
15752 
 
15753 
 
1596 ankur.sing 15754 
  def __repr__(self):
15755 
    L = ['%s=%r' % (key, value)
15756 
      for key, value in self.__dict__.iteritems()]
15757 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15758 
 
15759 
  def __eq__(self, other):
15760 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15761 
 
15762 
  def __ne__(self, other):
15763 
    return not (self == other)
15764 
 
4910 phani.kuma 15765 
class markAsRTOrders_args:
1596 ankur.sing 15766 
  """
15767 
  Attributes:
3064 chandransh 15768 
   - providerId
15769 
   - returnedOrders
1596 ankur.sing 15770 
  """
15771 
 
15772 
  thrift_spec = (
3064 chandransh 15773 
    None, # 0
15774 
    (1, TType.I64, 'providerId', None, None, ), # 1
15775 
    (2, TType.MAP, 'returnedOrders', (TType.STRING,None,TType.STRING,None), None, ), # 2
1596 ankur.sing 15776 
  )
15777 
 
3064 chandransh 15778 
  def __init__(self, providerId=None, returnedOrders=None,):
15779 
    self.providerId = providerId
15780 
    self.returnedOrders = returnedOrders
1596 ankur.sing 15781 
 
15782 
  def read(self, iprot):
15783 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15784 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15785 
      return
15786 
    iprot.readStructBegin()
15787 
    while True:
15788 
      (fname, ftype, fid) = iprot.readFieldBegin()
15789 
      if ftype == TType.STOP:
15790 
        break
3064 chandransh 15791 
      if fid == 1:
1596 ankur.sing 15792 
        if ftype == TType.I64:
3064 chandransh 15793 
          self.providerId = iprot.readI64();
1596 ankur.sing 15794 
        else:
15795 
          iprot.skip(ftype)
3064 chandransh 15796 
      elif fid == 2:
15797 
        if ftype == TType.MAP:
15798 
          self.returnedOrders = {}
6188 rajveer 15799 
          (_ktype328, _vtype329, _size327 ) = iprot.readMapBegin()
15800 
          for _i331 in xrange(_size327):
15801 
            _key332 = iprot.readString();
15802 
            _val333 = iprot.readString();
15803 
            self.returnedOrders[_key332] = _val333
3064 chandransh 15804 
          iprot.readMapEnd()
15805 
        else:
15806 
          iprot.skip(ftype)
1596 ankur.sing 15807 
      else:
15808 
        iprot.skip(ftype)
15809 
      iprot.readFieldEnd()
15810 
    iprot.readStructEnd()
15811 
 
15812 
  def write(self, oprot):
15813 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15814 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15815 
      return
4910 phani.kuma 15816 
    oprot.writeStructBegin('markAsRTOrders_args')
3431 rajveer 15817 
    if self.providerId is not None:
3064 chandransh 15818 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
15819 
      oprot.writeI64(self.providerId)
1596 ankur.sing 15820 
      oprot.writeFieldEnd()
3431 rajveer 15821 
    if self.returnedOrders is not None:
3064 chandransh 15822 
      oprot.writeFieldBegin('returnedOrders', TType.MAP, 2)
15823 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.returnedOrders))
6188 rajveer 15824 
      for kiter334,viter335 in self.returnedOrders.items():
15825 
        oprot.writeString(kiter334)
15826 
        oprot.writeString(viter335)
3064 chandransh 15827 
      oprot.writeMapEnd()
15828 
      oprot.writeFieldEnd()
1596 ankur.sing 15829 
    oprot.writeFieldStop()
15830 
    oprot.writeStructEnd()
15831 
 
3431 rajveer 15832 
  def validate(self):
15833 
    return
15834 
 
15835 
 
1596 ankur.sing 15836 
  def __repr__(self):
15837 
    L = ['%s=%r' % (key, value)
15838 
      for key, value in self.__dict__.iteritems()]
15839 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15840 
 
15841 
  def __eq__(self, other):
15842 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15843 
 
15844 
  def __ne__(self, other):
15845 
    return not (self == other)
15846 
 
4910 phani.kuma 15847 
class markAsRTOrders_result:
3064 chandransh 15848 
  """
15849 
  Attributes:
15850 
   - ex
15851 
  """
1596 ankur.sing 15852 
 
1627 ankur.sing 15853 
  thrift_spec = (
3064 chandransh 15854 
    None, # 0
15855 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
1627 ankur.sing 15856 
  )
15857 
 
3064 chandransh 15858 
  def __init__(self, ex=None,):
15859 
    self.ex = ex
15860 
 
1627 ankur.sing 15861 
  def read(self, iprot):
15862 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15863 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15864 
      return
15865 
    iprot.readStructBegin()
15866 
    while True:
15867 
      (fname, ftype, fid) = iprot.readFieldBegin()
15868 
      if ftype == TType.STOP:
15869 
        break
3064 chandransh 15870 
      if fid == 1:
15871 
        if ftype == TType.STRUCT:
15872 
          self.ex = TransactionServiceException()
15873 
          self.ex.read(iprot)
15874 
        else:
15875 
          iprot.skip(ftype)
1627 ankur.sing 15876 
      else:
15877 
        iprot.skip(ftype)
15878 
      iprot.readFieldEnd()
15879 
    iprot.readStructEnd()
15880 
 
15881 
  def write(self, oprot):
15882 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15883 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15884 
      return
4910 phani.kuma 15885 
    oprot.writeStructBegin('markAsRTOrders_result')
3431 rajveer 15886 
    if self.ex is not None:
3064 chandransh 15887 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
15888 
      self.ex.write(oprot)
15889 
      oprot.writeFieldEnd()
1627 ankur.sing 15890 
    oprot.writeFieldStop()
15891 
    oprot.writeStructEnd()
15892 
 
3431 rajveer 15893 
  def validate(self):
15894 
    return
15895 
 
15896 
 
1627 ankur.sing 15897 
  def __repr__(self):
15898 
    L = ['%s=%r' % (key, value)
15899 
      for key, value in self.__dict__.iteritems()]
15900 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15901 
 
15902 
  def __eq__(self, other):
15903 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15904 
 
15905 
  def __ne__(self, other):
15906 
    return not (self == other)
15907 
 
4910 phani.kuma 15908 
class getRTOrders_args:
15909 
  """
15910 
  Attributes:
15911 
   - providerId
15912 
  """
15913 
 
15914 
  thrift_spec = (
15915 
    None, # 0
15916 
    (1, TType.I64, 'providerId', None, None, ), # 1
15917 
  )
15918 
 
15919 
  def __init__(self, providerId=None,):
15920 
    self.providerId = providerId
15921 
 
15922 
  def read(self, iprot):
15923 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15924 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15925 
      return
15926 
    iprot.readStructBegin()
15927 
    while True:
15928 
      (fname, ftype, fid) = iprot.readFieldBegin()
15929 
      if ftype == TType.STOP:
15930 
        break
15931 
      if fid == 1:
15932 
        if ftype == TType.I64:
15933 
          self.providerId = iprot.readI64();
15934 
        else:
15935 
          iprot.skip(ftype)
15936 
      else:
15937 
        iprot.skip(ftype)
15938 
      iprot.readFieldEnd()
15939 
    iprot.readStructEnd()
15940 
 
15941 
  def write(self, oprot):
15942 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15943 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15944 
      return
15945 
    oprot.writeStructBegin('getRTOrders_args')
15946 
    if self.providerId is not None:
15947 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
15948 
      oprot.writeI64(self.providerId)
15949 
      oprot.writeFieldEnd()
15950 
    oprot.writeFieldStop()
15951 
    oprot.writeStructEnd()
15952 
 
15953 
  def validate(self):
15954 
    return
15955 
 
15956 
 
15957 
  def __repr__(self):
15958 
    L = ['%s=%r' % (key, value)
15959 
      for key, value in self.__dict__.iteritems()]
15960 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15961 
 
15962 
  def __eq__(self, other):
15963 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15964 
 
15965 
  def __ne__(self, other):
15966 
    return not (self == other)
15967 
 
15968 
class getRTOrders_result:
15969 
  """
15970 
  Attributes:
15971 
   - success
15972 
  """
15973 
 
15974 
  thrift_spec = (
15975 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
15976 
  )
15977 
 
15978 
  def __init__(self, success=None,):
15979 
    self.success = success
15980 
 
15981 
  def read(self, iprot):
15982 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15983 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15984 
      return
15985 
    iprot.readStructBegin()
15986 
    while True:
15987 
      (fname, ftype, fid) = iprot.readFieldBegin()
15988 
      if ftype == TType.STOP:
15989 
        break
15990 
      if fid == 0:
15991 
        if ftype == TType.LIST:
15992 
          self.success = []
6188 rajveer 15993 
          (_etype339, _size336) = iprot.readListBegin()
15994 
          for _i340 in xrange(_size336):
15995 
            _elem341 = Order()
15996 
            _elem341.read(iprot)
15997 
            self.success.append(_elem341)
4910 phani.kuma 15998 
          iprot.readListEnd()
15999 
        else:
16000 
          iprot.skip(ftype)
16001 
      else:
16002 
        iprot.skip(ftype)
16003 
      iprot.readFieldEnd()
16004 
    iprot.readStructEnd()
16005 
 
16006 
  def write(self, oprot):
16007 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16008 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16009 
      return
16010 
    oprot.writeStructBegin('getRTOrders_result')
16011 
    if self.success is not None:
16012 
      oprot.writeFieldBegin('success', TType.LIST, 0)
16013 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 16014 
      for iter342 in self.success:
16015 
        iter342.write(oprot)
4910 phani.kuma 16016 
      oprot.writeListEnd()
16017 
      oprot.writeFieldEnd()
16018 
    oprot.writeFieldStop()
16019 
    oprot.writeStructEnd()
16020 
 
16021 
  def validate(self):
16022 
    return
16023 
 
16024 
 
16025 
  def __repr__(self):
16026 
    L = ['%s=%r' % (key, value)
16027 
      for key, value in self.__dict__.iteritems()]
16028 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16029 
 
16030 
  def __eq__(self, other):
16031 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16032 
 
16033 
  def __ne__(self, other):
16034 
    return not (self == other)
16035 
 
3064 chandransh 16036 
class updateNonDeliveryReason_args:
1627 ankur.sing 16037 
  """
16038 
  Attributes:
3064 chandransh 16039 
   - providerId
16040 
   - undeliveredOrders
1627 ankur.sing 16041 
  """
16042 
 
16043 
  thrift_spec = (
3064 chandransh 16044 
    None, # 0
16045 
    (1, TType.I64, 'providerId', None, None, ), # 1
16046 
    (2, TType.MAP, 'undeliveredOrders', (TType.STRING,None,TType.STRING,None), None, ), # 2
1627 ankur.sing 16047 
  )
16048 
 
3064 chandransh 16049 
  def __init__(self, providerId=None, undeliveredOrders=None,):
16050 
    self.providerId = providerId
16051 
    self.undeliveredOrders = undeliveredOrders
1627 ankur.sing 16052 
 
16053 
  def read(self, iprot):
16054 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16055 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16056 
      return
16057 
    iprot.readStructBegin()
16058 
    while True:
16059 
      (fname, ftype, fid) = iprot.readFieldBegin()
16060 
      if ftype == TType.STOP:
16061 
        break
3064 chandransh 16062 
      if fid == 1:
1627 ankur.sing 16063 
        if ftype == TType.I64:
3064 chandransh 16064 
          self.providerId = iprot.readI64();
1627 ankur.sing 16065 
        else:
16066 
          iprot.skip(ftype)
3064 chandransh 16067 
      elif fid == 2:
16068 
        if ftype == TType.MAP:
16069 
          self.undeliveredOrders = {}
6188 rajveer 16070 
          (_ktype344, _vtype345, _size343 ) = iprot.readMapBegin()
16071 
          for _i347 in xrange(_size343):
16072 
            _key348 = iprot.readString();
16073 
            _val349 = iprot.readString();
16074 
            self.undeliveredOrders[_key348] = _val349
3064 chandransh 16075 
          iprot.readMapEnd()
16076 
        else:
16077 
          iprot.skip(ftype)
1627 ankur.sing 16078 
      else:
16079 
        iprot.skip(ftype)
16080 
      iprot.readFieldEnd()
16081 
    iprot.readStructEnd()
16082 
 
16083 
  def write(self, oprot):
16084 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16085 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16086 
      return
3064 chandransh 16087 
    oprot.writeStructBegin('updateNonDeliveryReason_args')
3431 rajveer 16088 
    if self.providerId is not None:
3064 chandransh 16089 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
16090 
      oprot.writeI64(self.providerId)
1627 ankur.sing 16091 
      oprot.writeFieldEnd()
3431 rajveer 16092 
    if self.undeliveredOrders is not None:
3064 chandransh 16093 
      oprot.writeFieldBegin('undeliveredOrders', TType.MAP, 2)
16094 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.undeliveredOrders))
6188 rajveer 16095 
      for kiter350,viter351 in self.undeliveredOrders.items():
16096 
        oprot.writeString(kiter350)
16097 
        oprot.writeString(viter351)
3064 chandransh 16098 
      oprot.writeMapEnd()
16099 
      oprot.writeFieldEnd()
1627 ankur.sing 16100 
    oprot.writeFieldStop()
16101 
    oprot.writeStructEnd()
16102 
 
3431 rajveer 16103 
  def validate(self):
16104 
    return
16105 
 
16106 
 
1627 ankur.sing 16107 
  def __repr__(self):
16108 
    L = ['%s=%r' % (key, value)
16109 
      for key, value in self.__dict__.iteritems()]
16110 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16111 
 
16112 
  def __eq__(self, other):
16113 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16114 
 
16115 
  def __ne__(self, other):
16116 
    return not (self == other)
16117 
 
3064 chandransh 16118 
class updateNonDeliveryReason_result:
1627 ankur.sing 16119 
  """
16120 
  Attributes:
3064 chandransh 16121 
   - ex
1627 ankur.sing 16122 
  """
16123 
 
16124 
  thrift_spec = (
4910 phani.kuma 16125 
    None, # 0
3064 chandransh 16126 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
1627 ankur.sing 16127 
  )
16128 
 
4910 phani.kuma 16129 
  def __init__(self, ex=None,):
3064 chandransh 16130 
    self.ex = ex
1627 ankur.sing 16131 
 
16132 
  def read(self, iprot):
16133 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16134 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16135 
      return
16136 
    iprot.readStructBegin()
16137 
    while True:
16138 
      (fname, ftype, fid) = iprot.readFieldBegin()
16139 
      if ftype == TType.STOP:
16140 
        break
4910 phani.kuma 16141 
      if fid == 1:
16142 
        if ftype == TType.STRUCT:
16143 
          self.ex = TransactionServiceException()
16144 
          self.ex.read(iprot)
16145 
        else:
16146 
          iprot.skip(ftype)
16147 
      else:
16148 
        iprot.skip(ftype)
16149 
      iprot.readFieldEnd()
16150 
    iprot.readStructEnd()
16151 
 
16152 
  def write(self, oprot):
16153 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16154 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16155 
      return
16156 
    oprot.writeStructBegin('updateNonDeliveryReason_result')
16157 
    if self.ex is not None:
16158 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
16159 
      self.ex.write(oprot)
16160 
      oprot.writeFieldEnd()
16161 
    oprot.writeFieldStop()
16162 
    oprot.writeStructEnd()
16163 
 
16164 
  def validate(self):
16165 
    return
16166 
 
16167 
 
16168 
  def __repr__(self):
16169 
    L = ['%s=%r' % (key, value)
16170 
      for key, value in self.__dict__.iteritems()]
16171 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16172 
 
16173 
  def __eq__(self, other):
16174 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16175 
 
16176 
  def __ne__(self, other):
16177 
    return not (self == other)
16178 
 
16179 
class getNonDeliveredOrdersbyCourier_args:
16180 
  """
16181 
  Attributes:
16182 
   - providerId
16183 
  """
16184 
 
16185 
  thrift_spec = (
16186 
    None, # 0
16187 
    (1, TType.I64, 'providerId', None, None, ), # 1
16188 
  )
16189 
 
16190 
  def __init__(self, providerId=None,):
16191 
    self.providerId = providerId
16192 
 
16193 
  def read(self, iprot):
16194 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16195 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16196 
      return
16197 
    iprot.readStructBegin()
16198 
    while True:
16199 
      (fname, ftype, fid) = iprot.readFieldBegin()
16200 
      if ftype == TType.STOP:
16201 
        break
16202 
      if fid == 1:
16203 
        if ftype == TType.I64:
16204 
          self.providerId = iprot.readI64();
16205 
        else:
16206 
          iprot.skip(ftype)
16207 
      else:
16208 
        iprot.skip(ftype)
16209 
      iprot.readFieldEnd()
16210 
    iprot.readStructEnd()
16211 
 
16212 
  def write(self, oprot):
16213 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16214 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16215 
      return
16216 
    oprot.writeStructBegin('getNonDeliveredOrdersbyCourier_args')
16217 
    if self.providerId is not None:
16218 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
16219 
      oprot.writeI64(self.providerId)
16220 
      oprot.writeFieldEnd()
16221 
    oprot.writeFieldStop()
16222 
    oprot.writeStructEnd()
16223 
 
16224 
  def validate(self):
16225 
    return
16226 
 
16227 
 
16228 
  def __repr__(self):
16229 
    L = ['%s=%r' % (key, value)
16230 
      for key, value in self.__dict__.iteritems()]
16231 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16232 
 
16233 
  def __eq__(self, other):
16234 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16235 
 
16236 
  def __ne__(self, other):
16237 
    return not (self == other)
16238 
 
16239 
class getNonDeliveredOrdersbyCourier_result:
16240 
  """
16241 
  Attributes:
16242 
   - success
16243 
  """
16244 
 
16245 
  thrift_spec = (
16246 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
16247 
  )
16248 
 
16249 
  def __init__(self, success=None,):
16250 
    self.success = success
16251 
 
16252 
  def read(self, iprot):
16253 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16254 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16255 
      return
16256 
    iprot.readStructBegin()
16257 
    while True:
16258 
      (fname, ftype, fid) = iprot.readFieldBegin()
16259 
      if ftype == TType.STOP:
16260 
        break
4581 phani.kuma 16261 
      if fid == 0:
16262 
        if ftype == TType.LIST:
16263 
          self.success = []
6188 rajveer 16264 
          (_etype355, _size352) = iprot.readListBegin()
16265 
          for _i356 in xrange(_size352):
16266 
            _elem357 = Order()
16267 
            _elem357.read(iprot)
16268 
            self.success.append(_elem357)
4581 phani.kuma 16269 
          iprot.readListEnd()
16270 
        else:
16271 
          iprot.skip(ftype)
4910 phani.kuma 16272 
      else:
16273 
        iprot.skip(ftype)
16274 
      iprot.readFieldEnd()
16275 
    iprot.readStructEnd()
16276 
 
16277 
  def write(self, oprot):
16278 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16279 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16280 
      return
16281 
    oprot.writeStructBegin('getNonDeliveredOrdersbyCourier_result')
16282 
    if self.success is not None:
16283 
      oprot.writeFieldBegin('success', TType.LIST, 0)
16284 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 16285 
      for iter358 in self.success:
16286 
        iter358.write(oprot)
4910 phani.kuma 16287 
      oprot.writeListEnd()
16288 
      oprot.writeFieldEnd()
16289 
    oprot.writeFieldStop()
16290 
    oprot.writeStructEnd()
16291 
 
16292 
  def validate(self):
16293 
    return
16294 
 
16295 
 
16296 
  def __repr__(self):
16297 
    L = ['%s=%r' % (key, value)
16298 
      for key, value in self.__dict__.iteritems()]
16299 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16300 
 
16301 
  def __eq__(self, other):
16302 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16303 
 
16304 
  def __ne__(self, other):
16305 
    return not (self == other)
16306 
 
16307 
class markOrdersAsLocalConnected_args:
16308 
  """
16309 
  Attributes:
16310 
   - providerId
16311 
   - local_connected_orders
16312 
  """
16313 
 
16314 
  thrift_spec = (
16315 
    None, # 0
16316 
    (1, TType.I64, 'providerId', None, None, ), # 1
16317 
    (2, TType.MAP, 'local_connected_orders', (TType.STRING,None,TType.STRING,None), None, ), # 2
16318 
  )
16319 
 
16320 
  def __init__(self, providerId=None, local_connected_orders=None,):
16321 
    self.providerId = providerId
16322 
    self.local_connected_orders = local_connected_orders
16323 
 
16324 
  def read(self, iprot):
16325 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16326 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16327 
      return
16328 
    iprot.readStructBegin()
16329 
    while True:
16330 
      (fname, ftype, fid) = iprot.readFieldBegin()
16331 
      if ftype == TType.STOP:
16332 
        break
16333 
      if fid == 1:
16334 
        if ftype == TType.I64:
16335 
          self.providerId = iprot.readI64();
16336 
        else:
16337 
          iprot.skip(ftype)
16338 
      elif fid == 2:
16339 
        if ftype == TType.MAP:
16340 
          self.local_connected_orders = {}
6188 rajveer 16341 
          (_ktype360, _vtype361, _size359 ) = iprot.readMapBegin()
16342 
          for _i363 in xrange(_size359):
16343 
            _key364 = iprot.readString();
16344 
            _val365 = iprot.readString();
16345 
            self.local_connected_orders[_key364] = _val365
4910 phani.kuma 16346 
          iprot.readMapEnd()
16347 
        else:
16348 
          iprot.skip(ftype)
16349 
      else:
16350 
        iprot.skip(ftype)
16351 
      iprot.readFieldEnd()
16352 
    iprot.readStructEnd()
16353 
 
16354 
  def write(self, oprot):
16355 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16356 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16357 
      return
16358 
    oprot.writeStructBegin('markOrdersAsLocalConnected_args')
16359 
    if self.providerId is not None:
16360 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
16361 
      oprot.writeI64(self.providerId)
16362 
      oprot.writeFieldEnd()
16363 
    if self.local_connected_orders is not None:
16364 
      oprot.writeFieldBegin('local_connected_orders', TType.MAP, 2)
16365 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.local_connected_orders))
6188 rajveer 16366 
      for kiter366,viter367 in self.local_connected_orders.items():
16367 
        oprot.writeString(kiter366)
16368 
        oprot.writeString(viter367)
4910 phani.kuma 16369 
      oprot.writeMapEnd()
16370 
      oprot.writeFieldEnd()
16371 
    oprot.writeFieldStop()
16372 
    oprot.writeStructEnd()
16373 
 
16374 
  def validate(self):
16375 
    return
16376 
 
16377 
 
16378 
  def __repr__(self):
16379 
    L = ['%s=%r' % (key, value)
16380 
      for key, value in self.__dict__.iteritems()]
16381 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16382 
 
16383 
  def __eq__(self, other):
16384 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16385 
 
16386 
  def __ne__(self, other):
16387 
    return not (self == other)
16388 
 
16389 
class markOrdersAsLocalConnected_result:
16390 
  """
16391 
  Attributes:
16392 
   - ex
16393 
  """
16394 
 
16395 
  thrift_spec = (
16396 
    None, # 0
16397 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
16398 
  )
16399 
 
16400 
  def __init__(self, ex=None,):
16401 
    self.ex = ex
16402 
 
16403 
  def read(self, iprot):
16404 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16405 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16406 
      return
16407 
    iprot.readStructBegin()
16408 
    while True:
16409 
      (fname, ftype, fid) = iprot.readFieldBegin()
16410 
      if ftype == TType.STOP:
16411 
        break
16412 
      if fid == 1:
3064 chandransh 16413 
        if ftype == TType.STRUCT:
16414 
          self.ex = TransactionServiceException()
16415 
          self.ex.read(iprot)
1627 ankur.sing 16416 
        else:
16417 
          iprot.skip(ftype)
16418 
      else:
16419 
        iprot.skip(ftype)
16420 
      iprot.readFieldEnd()
16421 
    iprot.readStructEnd()
16422 
 
16423 
  def write(self, oprot):
16424 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16425 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16426 
      return
4910 phani.kuma 16427 
    oprot.writeStructBegin('markOrdersAsLocalConnected_result')
16428 
    if self.ex is not None:
16429 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
16430 
      self.ex.write(oprot)
16431 
      oprot.writeFieldEnd()
16432 
    oprot.writeFieldStop()
16433 
    oprot.writeStructEnd()
16434 
 
16435 
  def validate(self):
16436 
    return
16437 
 
16438 
 
16439 
  def __repr__(self):
16440 
    L = ['%s=%r' % (key, value)
16441 
      for key, value in self.__dict__.iteritems()]
16442 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16443 
 
16444 
  def __eq__(self, other):
16445 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16446 
 
16447 
  def __ne__(self, other):
16448 
    return not (self == other)
16449 
 
16450 
class getOrdersNotLocalConnected_args:
16451 
  """
16452 
  Attributes:
16453 
   - providerId
16454 
  """
16455 
 
16456 
  thrift_spec = (
16457 
    None, # 0
16458 
    (1, TType.I64, 'providerId', None, None, ), # 1
16459 
  )
16460 
 
16461 
  def __init__(self, providerId=None,):
16462 
    self.providerId = providerId
16463 
 
16464 
  def read(self, iprot):
16465 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16466 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16467 
      return
16468 
    iprot.readStructBegin()
16469 
    while True:
16470 
      (fname, ftype, fid) = iprot.readFieldBegin()
16471 
      if ftype == TType.STOP:
16472 
        break
16473 
      if fid == 1:
16474 
        if ftype == TType.I64:
16475 
          self.providerId = iprot.readI64();
16476 
        else:
16477 
          iprot.skip(ftype)
16478 
      else:
16479 
        iprot.skip(ftype)
16480 
      iprot.readFieldEnd()
16481 
    iprot.readStructEnd()
16482 
 
16483 
  def write(self, oprot):
16484 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16485 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16486 
      return
16487 
    oprot.writeStructBegin('getOrdersNotLocalConnected_args')
16488 
    if self.providerId is not None:
16489 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
16490 
      oprot.writeI64(self.providerId)
16491 
      oprot.writeFieldEnd()
16492 
    oprot.writeFieldStop()
16493 
    oprot.writeStructEnd()
16494 
 
16495 
  def validate(self):
16496 
    return
16497 
 
16498 
 
16499 
  def __repr__(self):
16500 
    L = ['%s=%r' % (key, value)
16501 
      for key, value in self.__dict__.iteritems()]
16502 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16503 
 
16504 
  def __eq__(self, other):
16505 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16506 
 
16507 
  def __ne__(self, other):
16508 
    return not (self == other)
16509 
 
16510 
class getOrdersNotLocalConnected_result:
16511 
  """
16512 
  Attributes:
16513 
   - success
16514 
  """
16515 
 
16516 
  thrift_spec = (
16517 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
16518 
  )
16519 
 
16520 
  def __init__(self, success=None,):
16521 
    self.success = success
16522 
 
16523 
  def read(self, iprot):
16524 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16525 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16526 
      return
16527 
    iprot.readStructBegin()
16528 
    while True:
16529 
      (fname, ftype, fid) = iprot.readFieldBegin()
16530 
      if ftype == TType.STOP:
16531 
        break
16532 
      if fid == 0:
16533 
        if ftype == TType.LIST:
16534 
          self.success = []
6188 rajveer 16535 
          (_etype371, _size368) = iprot.readListBegin()
16536 
          for _i372 in xrange(_size368):
16537 
            _elem373 = Order()
16538 
            _elem373.read(iprot)
16539 
            self.success.append(_elem373)
4910 phani.kuma 16540 
          iprot.readListEnd()
16541 
        else:
16542 
          iprot.skip(ftype)
16543 
      else:
16544 
        iprot.skip(ftype)
16545 
      iprot.readFieldEnd()
16546 
    iprot.readStructEnd()
16547 
 
16548 
  def write(self, oprot):
16549 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16550 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16551 
      return
16552 
    oprot.writeStructBegin('getOrdersNotLocalConnected_result')
4581 phani.kuma 16553 
    if self.success is not None:
16554 
      oprot.writeFieldBegin('success', TType.LIST, 0)
16555 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 16556 
      for iter374 in self.success:
16557 
        iter374.write(oprot)
4581 phani.kuma 16558 
      oprot.writeListEnd()
16559 
      oprot.writeFieldEnd()
4910 phani.kuma 16560 
    oprot.writeFieldStop()
16561 
    oprot.writeStructEnd()
16562 
 
16563 
  def validate(self):
16564 
    return
16565 
 
16566 
 
16567 
  def __repr__(self):
16568 
    L = ['%s=%r' % (key, value)
16569 
      for key, value in self.__dict__.iteritems()]
16570 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16571 
 
16572 
  def __eq__(self, other):
16573 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16574 
 
16575 
  def __ne__(self, other):
16576 
    return not (self == other)
16577 
 
16578 
class markOrdersAsDestinationCityReached_args:
16579 
  """
16580 
  Attributes:
16581 
   - providerId
16582 
   - destination_city_reached_orders
16583 
  """
16584 
 
16585 
  thrift_spec = (
16586 
    None, # 0
16587 
    (1, TType.I64, 'providerId', None, None, ), # 1
16588 
    (2, TType.MAP, 'destination_city_reached_orders', (TType.STRING,None,TType.STRING,None), None, ), # 2
16589 
  )
16590 
 
16591 
  def __init__(self, providerId=None, destination_city_reached_orders=None,):
16592 
    self.providerId = providerId
16593 
    self.destination_city_reached_orders = destination_city_reached_orders
16594 
 
16595 
  def read(self, iprot):
16596 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16597 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16598 
      return
16599 
    iprot.readStructBegin()
16600 
    while True:
16601 
      (fname, ftype, fid) = iprot.readFieldBegin()
16602 
      if ftype == TType.STOP:
16603 
        break
16604 
      if fid == 1:
16605 
        if ftype == TType.I64:
16606 
          self.providerId = iprot.readI64();
16607 
        else:
16608 
          iprot.skip(ftype)
16609 
      elif fid == 2:
16610 
        if ftype == TType.MAP:
16611 
          self.destination_city_reached_orders = {}
6188 rajveer 16612 
          (_ktype376, _vtype377, _size375 ) = iprot.readMapBegin()
16613 
          for _i379 in xrange(_size375):
16614 
            _key380 = iprot.readString();
16615 
            _val381 = iprot.readString();
16616 
            self.destination_city_reached_orders[_key380] = _val381
4910 phani.kuma 16617 
          iprot.readMapEnd()
16618 
        else:
16619 
          iprot.skip(ftype)
16620 
      else:
16621 
        iprot.skip(ftype)
16622 
      iprot.readFieldEnd()
16623 
    iprot.readStructEnd()
16624 
 
16625 
  def write(self, oprot):
16626 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16627 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16628 
      return
16629 
    oprot.writeStructBegin('markOrdersAsDestinationCityReached_args')
16630 
    if self.providerId is not None:
16631 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
16632 
      oprot.writeI64(self.providerId)
16633 
      oprot.writeFieldEnd()
16634 
    if self.destination_city_reached_orders is not None:
16635 
      oprot.writeFieldBegin('destination_city_reached_orders', TType.MAP, 2)
16636 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.destination_city_reached_orders))
6188 rajveer 16637 
      for kiter382,viter383 in self.destination_city_reached_orders.items():
16638 
        oprot.writeString(kiter382)
16639 
        oprot.writeString(viter383)
4910 phani.kuma 16640 
      oprot.writeMapEnd()
16641 
      oprot.writeFieldEnd()
16642 
    oprot.writeFieldStop()
16643 
    oprot.writeStructEnd()
16644 
 
16645 
  def validate(self):
16646 
    return
16647 
 
16648 
 
16649 
  def __repr__(self):
16650 
    L = ['%s=%r' % (key, value)
16651 
      for key, value in self.__dict__.iteritems()]
16652 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16653 
 
16654 
  def __eq__(self, other):
16655 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16656 
 
16657 
  def __ne__(self, other):
16658 
    return not (self == other)
16659 
 
16660 
class markOrdersAsDestinationCityReached_result:
16661 
  """
16662 
  Attributes:
16663 
   - ex
16664 
  """
16665 
 
16666 
  thrift_spec = (
16667 
    None, # 0
16668 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
16669 
  )
16670 
 
16671 
  def __init__(self, ex=None,):
16672 
    self.ex = ex
16673 
 
16674 
  def read(self, iprot):
16675 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16676 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16677 
      return
16678 
    iprot.readStructBegin()
16679 
    while True:
16680 
      (fname, ftype, fid) = iprot.readFieldBegin()
16681 
      if ftype == TType.STOP:
16682 
        break
16683 
      if fid == 1:
16684 
        if ftype == TType.STRUCT:
16685 
          self.ex = TransactionServiceException()
16686 
          self.ex.read(iprot)
16687 
        else:
16688 
          iprot.skip(ftype)
16689 
      else:
16690 
        iprot.skip(ftype)
16691 
      iprot.readFieldEnd()
16692 
    iprot.readStructEnd()
16693 
 
16694 
  def write(self, oprot):
16695 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16696 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16697 
      return
16698 
    oprot.writeStructBegin('markOrdersAsDestinationCityReached_result')
3431 rajveer 16699 
    if self.ex is not None:
3064 chandransh 16700 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
16701 
      self.ex.write(oprot)
1627 ankur.sing 16702 
      oprot.writeFieldEnd()
16703 
    oprot.writeFieldStop()
16704 
    oprot.writeStructEnd()
16705 
 
3431 rajveer 16706 
  def validate(self):
16707 
    return
16708 
 
16709 
 
1627 ankur.sing 16710 
  def __repr__(self):
16711 
    L = ['%s=%r' % (key, value)
16712 
      for key, value in self.__dict__.iteritems()]
16713 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16714 
 
16715 
  def __eq__(self, other):
16716 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16717 
 
16718 
  def __ne__(self, other):
16719 
    return not (self == other)
16720 
 
4910 phani.kuma 16721 
class markOrdersAsFirstDeliveryAttempted_args:
16722 
  """
16723 
  Attributes:
16724 
   - providerId
16725 
   - first_atdl_orders
16726 
  """
16727 
 
16728 
  thrift_spec = (
16729 
    None, # 0
16730 
    (1, TType.I64, 'providerId', None, None, ), # 1
16731 
    (2, TType.MAP, 'first_atdl_orders', (TType.STRING,None,TType.STRING,None), None, ), # 2
16732 
  )
16733 
 
16734 
  def __init__(self, providerId=None, first_atdl_orders=None,):
16735 
    self.providerId = providerId
16736 
    self.first_atdl_orders = first_atdl_orders
16737 
 
16738 
  def read(self, iprot):
16739 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16740 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16741 
      return
16742 
    iprot.readStructBegin()
16743 
    while True:
16744 
      (fname, ftype, fid) = iprot.readFieldBegin()
16745 
      if ftype == TType.STOP:
16746 
        break
16747 
      if fid == 1:
16748 
        if ftype == TType.I64:
16749 
          self.providerId = iprot.readI64();
16750 
        else:
16751 
          iprot.skip(ftype)
16752 
      elif fid == 2:
16753 
        if ftype == TType.MAP:
16754 
          self.first_atdl_orders = {}
6188 rajveer 16755 
          (_ktype385, _vtype386, _size384 ) = iprot.readMapBegin()
16756 
          for _i388 in xrange(_size384):
16757 
            _key389 = iprot.readString();
16758 
            _val390 = iprot.readString();
16759 
            self.first_atdl_orders[_key389] = _val390
4910 phani.kuma 16760 
          iprot.readMapEnd()
16761 
        else:
16762 
          iprot.skip(ftype)
16763 
      else:
16764 
        iprot.skip(ftype)
16765 
      iprot.readFieldEnd()
16766 
    iprot.readStructEnd()
16767 
 
16768 
  def write(self, oprot):
16769 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16770 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16771 
      return
16772 
    oprot.writeStructBegin('markOrdersAsFirstDeliveryAttempted_args')
16773 
    if self.providerId is not None:
16774 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
16775 
      oprot.writeI64(self.providerId)
16776 
      oprot.writeFieldEnd()
16777 
    if self.first_atdl_orders is not None:
16778 
      oprot.writeFieldBegin('first_atdl_orders', TType.MAP, 2)
16779 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.first_atdl_orders))
6188 rajveer 16780 
      for kiter391,viter392 in self.first_atdl_orders.items():
16781 
        oprot.writeString(kiter391)
16782 
        oprot.writeString(viter392)
4910 phani.kuma 16783 
      oprot.writeMapEnd()
16784 
      oprot.writeFieldEnd()
16785 
    oprot.writeFieldStop()
16786 
    oprot.writeStructEnd()
16787 
 
16788 
  def validate(self):
16789 
    return
16790 
 
16791 
 
16792 
  def __repr__(self):
16793 
    L = ['%s=%r' % (key, value)
16794 
      for key, value in self.__dict__.iteritems()]
16795 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16796 
 
16797 
  def __eq__(self, other):
16798 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16799 
 
16800 
  def __ne__(self, other):
16801 
    return not (self == other)
16802 
 
16803 
class markOrdersAsFirstDeliveryAttempted_result:
16804 
  """
16805 
  Attributes:
16806 
   - ex
16807 
  """
16808 
 
16809 
  thrift_spec = (
16810 
    None, # 0
16811 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
16812 
  )
16813 
 
16814 
  def __init__(self, ex=None,):
16815 
    self.ex = ex
16816 
 
16817 
  def read(self, iprot):
16818 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16819 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16820 
      return
16821 
    iprot.readStructBegin()
16822 
    while True:
16823 
      (fname, ftype, fid) = iprot.readFieldBegin()
16824 
      if ftype == TType.STOP:
16825 
        break
16826 
      if fid == 1:
16827 
        if ftype == TType.STRUCT:
16828 
          self.ex = TransactionServiceException()
16829 
          self.ex.read(iprot)
16830 
        else:
16831 
          iprot.skip(ftype)
16832 
      else:
16833 
        iprot.skip(ftype)
16834 
      iprot.readFieldEnd()
16835 
    iprot.readStructEnd()
16836 
 
16837 
  def write(self, oprot):
16838 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16839 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16840 
      return
16841 
    oprot.writeStructBegin('markOrdersAsFirstDeliveryAttempted_result')
16842 
    if self.ex is not None:
16843 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
16844 
      self.ex.write(oprot)
16845 
      oprot.writeFieldEnd()
16846 
    oprot.writeFieldStop()
16847 
    oprot.writeStructEnd()
16848 
 
16849 
  def validate(self):
16850 
    return
16851 
 
16852 
 
16853 
  def __repr__(self):
16854 
    L = ['%s=%r' % (key, value)
16855 
      for key, value in self.__dict__.iteritems()]
16856 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16857 
 
16858 
  def __eq__(self, other):
16859 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16860 
 
16861 
  def __ne__(self, other):
16862 
    return not (self == other)
16863 
 
3064 chandransh 16864 
class getUndeliveredOrders_args:
1886 ankur.sing 16865 
  """
16866 
  Attributes:
3064 chandransh 16867 
   - providerId
16868 
   - warehouseId
1886 ankur.sing 16869 
  """
1627 ankur.sing 16870 
 
1886 ankur.sing 16871 
  thrift_spec = (
16872 
    None, # 0
3064 chandransh 16873 
    (1, TType.I64, 'providerId', None, None, ), # 1
16874 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
1886 ankur.sing 16875 
  )
16876 
 
3064 chandransh 16877 
  def __init__(self, providerId=None, warehouseId=None,):
16878 
    self.providerId = providerId
16879 
    self.warehouseId = warehouseId
1886 ankur.sing 16880 
 
16881 
  def read(self, iprot):
16882 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16883 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16884 
      return
16885 
    iprot.readStructBegin()
16886 
    while True:
16887 
      (fname, ftype, fid) = iprot.readFieldBegin()
16888 
      if ftype == TType.STOP:
16889 
        break
16890 
      if fid == 1:
16891 
        if ftype == TType.I64:
3064 chandransh 16892 
          self.providerId = iprot.readI64();
1886 ankur.sing 16893 
        else:
16894 
          iprot.skip(ftype)
3064 chandransh 16895 
      elif fid == 2:
16896 
        if ftype == TType.I64:
16897 
          self.warehouseId = iprot.readI64();
16898 
        else:
16899 
          iprot.skip(ftype)
1886 ankur.sing 16900 
      else:
16901 
        iprot.skip(ftype)
16902 
      iprot.readFieldEnd()
16903 
    iprot.readStructEnd()
16904 
 
16905 
  def write(self, oprot):
16906 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16907 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16908 
      return
3064 chandransh 16909 
    oprot.writeStructBegin('getUndeliveredOrders_args')
3431 rajveer 16910 
    if self.providerId is not None:
3064 chandransh 16911 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
16912 
      oprot.writeI64(self.providerId)
1886 ankur.sing 16913 
      oprot.writeFieldEnd()
3431 rajveer 16914 
    if self.warehouseId is not None:
3064 chandransh 16915 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
16916 
      oprot.writeI64(self.warehouseId)
16917 
      oprot.writeFieldEnd()
1886 ankur.sing 16918 
    oprot.writeFieldStop()
16919 
    oprot.writeStructEnd()
16920 
 
3431 rajveer 16921 
  def validate(self):
16922 
    return
16923 
 
16924 
 
1886 ankur.sing 16925 
  def __repr__(self):
16926 
    L = ['%s=%r' % (key, value)
16927 
      for key, value in self.__dict__.iteritems()]
16928 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16929 
 
16930 
  def __eq__(self, other):
16931 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16932 
 
16933 
  def __ne__(self, other):
16934 
    return not (self == other)
16935 
 
3064 chandransh 16936 
class getUndeliveredOrders_result:
1886 ankur.sing 16937 
  """
16938 
  Attributes:
16939 
   - success
16940 
  """
16941 
 
16942 
  thrift_spec = (
16943 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
16944 
  )
16945 
 
16946 
  def __init__(self, success=None,):
16947 
    self.success = success
16948 
 
16949 
  def read(self, iprot):
16950 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16951 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16952 
      return
16953 
    iprot.readStructBegin()
16954 
    while True:
16955 
      (fname, ftype, fid) = iprot.readFieldBegin()
16956 
      if ftype == TType.STOP:
16957 
        break
16958 
      if fid == 0:
16959 
        if ftype == TType.LIST:
16960 
          self.success = []
6188 rajveer 16961 
          (_etype396, _size393) = iprot.readListBegin()
16962 
          for _i397 in xrange(_size393):
16963 
            _elem398 = Order()
16964 
            _elem398.read(iprot)
16965 
            self.success.append(_elem398)
1886 ankur.sing 16966 
          iprot.readListEnd()
16967 
        else:
16968 
          iprot.skip(ftype)
16969 
      else:
16970 
        iprot.skip(ftype)
16971 
      iprot.readFieldEnd()
16972 
    iprot.readStructEnd()
16973 
 
16974 
  def write(self, oprot):
16975 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16976 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16977 
      return
3064 chandransh 16978 
    oprot.writeStructBegin('getUndeliveredOrders_result')
3431 rajveer 16979 
    if self.success is not None:
1886 ankur.sing 16980 
      oprot.writeFieldBegin('success', TType.LIST, 0)
16981 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 16982 
      for iter399 in self.success:
16983 
        iter399.write(oprot)
1886 ankur.sing 16984 
      oprot.writeListEnd()
16985 
      oprot.writeFieldEnd()
16986 
    oprot.writeFieldStop()
16987 
    oprot.writeStructEnd()
16988 
 
3431 rajveer 16989 
  def validate(self):
16990 
    return
16991 
 
16992 
 
1886 ankur.sing 16993 
  def __repr__(self):
16994 
    L = ['%s=%r' % (key, value)
16995 
      for key, value in self.__dict__.iteritems()]
16996 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16997 
 
16998 
  def __eq__(self, other):
16999 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17000 
 
17001 
  def __ne__(self, other):
17002 
    return not (self == other)
17003 
 
4783 phani.kuma 17004 
class getUndeliveredOrdersExpectedDeliveryDateNotMet_args:
17005 
 
17006 
  thrift_spec = (
17007 
  )
17008 
 
17009 
  def read(self, iprot):
17010 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17011 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17012 
      return
17013 
    iprot.readStructBegin()
17014 
    while True:
17015 
      (fname, ftype, fid) = iprot.readFieldBegin()
17016 
      if ftype == TType.STOP:
17017 
        break
17018 
      else:
17019 
        iprot.skip(ftype)
17020 
      iprot.readFieldEnd()
17021 
    iprot.readStructEnd()
17022 
 
17023 
  def write(self, oprot):
17024 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17025 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17026 
      return
17027 
    oprot.writeStructBegin('getUndeliveredOrdersExpectedDeliveryDateNotMet_args')
17028 
    oprot.writeFieldStop()
17029 
    oprot.writeStructEnd()
17030 
 
17031 
  def validate(self):
17032 
    return
17033 
 
17034 
 
17035 
  def __repr__(self):
17036 
    L = ['%s=%r' % (key, value)
17037 
      for key, value in self.__dict__.iteritems()]
17038 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17039 
 
17040 
  def __eq__(self, other):
17041 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17042 
 
17043 
  def __ne__(self, other):
17044 
    return not (self == other)
17045 
 
17046 
class getUndeliveredOrdersExpectedDeliveryDateNotMet_result:
17047 
  """
17048 
  Attributes:
17049 
   - success
17050 
  """
17051 
 
17052 
  thrift_spec = (
17053 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
17054 
  )
17055 
 
17056 
  def __init__(self, success=None,):
17057 
    self.success = success
17058 
 
17059 
  def read(self, iprot):
17060 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17061 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17062 
      return
17063 
    iprot.readStructBegin()
17064 
    while True:
17065 
      (fname, ftype, fid) = iprot.readFieldBegin()
17066 
      if ftype == TType.STOP:
17067 
        break
17068 
      if fid == 0:
17069 
        if ftype == TType.LIST:
17070 
          self.success = []
6188 rajveer 17071 
          (_etype403, _size400) = iprot.readListBegin()
17072 
          for _i404 in xrange(_size400):
17073 
            _elem405 = Order()
17074 
            _elem405.read(iprot)
17075 
            self.success.append(_elem405)
4783 phani.kuma 17076 
          iprot.readListEnd()
17077 
        else:
17078 
          iprot.skip(ftype)
17079 
      else:
17080 
        iprot.skip(ftype)
17081 
      iprot.readFieldEnd()
17082 
    iprot.readStructEnd()
17083 
 
17084 
  def write(self, oprot):
17085 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17086 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17087 
      return
17088 
    oprot.writeStructBegin('getUndeliveredOrdersExpectedDeliveryDateNotMet_result')
17089 
    if self.success is not None:
17090 
      oprot.writeFieldBegin('success', TType.LIST, 0)
17091 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 17092 
      for iter406 in self.success:
17093 
        iter406.write(oprot)
4783 phani.kuma 17094 
      oprot.writeListEnd()
17095 
      oprot.writeFieldEnd()
17096 
    oprot.writeFieldStop()
17097 
    oprot.writeStructEnd()
17098 
 
17099 
  def validate(self):
17100 
    return
17101 
 
17102 
 
17103 
  def __repr__(self):
17104 
    L = ['%s=%r' % (key, value)
17105 
      for key, value in self.__dict__.iteritems()]
17106 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17107 
 
17108 
  def __eq__(self, other):
17109 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17110 
 
17111 
  def __ne__(self, other):
17112 
    return not (self == other)
17113 
 
2536 chandransh 17114 
class toggleDOAFlag_args:
17115 
  """
17116 
  Attributes:
17117 
   - orderId
17118 
  """
1886 ankur.sing 17119 
 
2536 chandransh 17120 
  thrift_spec = (
17121 
    None, # 0
17122 
    (1, TType.I64, 'orderId', None, None, ), # 1
17123 
  )
17124 
 
17125 
  def __init__(self, orderId=None,):
17126 
    self.orderId = orderId
17127 
 
17128 
  def read(self, iprot):
17129 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17130 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17131 
      return
17132 
    iprot.readStructBegin()
17133 
    while True:
17134 
      (fname, ftype, fid) = iprot.readFieldBegin()
17135 
      if ftype == TType.STOP:
17136 
        break
17137 
      if fid == 1:
17138 
        if ftype == TType.I64:
17139 
          self.orderId = iprot.readI64();
17140 
        else:
17141 
          iprot.skip(ftype)
17142 
      else:
17143 
        iprot.skip(ftype)
17144 
      iprot.readFieldEnd()
17145 
    iprot.readStructEnd()
17146 
 
17147 
  def write(self, oprot):
17148 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17149 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17150 
      return
17151 
    oprot.writeStructBegin('toggleDOAFlag_args')
3431 rajveer 17152 
    if self.orderId is not None:
2536 chandransh 17153 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
17154 
      oprot.writeI64(self.orderId)
17155 
      oprot.writeFieldEnd()
17156 
    oprot.writeFieldStop()
17157 
    oprot.writeStructEnd()
17158 
 
3431 rajveer 17159 
  def validate(self):
17160 
    return
17161 
 
17162 
 
2536 chandransh 17163 
  def __repr__(self):
17164 
    L = ['%s=%r' % (key, value)
17165 
      for key, value in self.__dict__.iteritems()]
17166 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17167 
 
17168 
  def __eq__(self, other):
17169 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17170 
 
17171 
  def __ne__(self, other):
17172 
    return not (self == other)
17173 
 
17174 
class toggleDOAFlag_result:
17175 
  """
17176 
  Attributes:
17177 
   - success
17178 
   - ex
17179 
  """
17180 
 
17181 
  thrift_spec = (
17182 
    (0, TType.BOOL, 'success', None, None, ), # 0
17183 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
17184 
  )
17185 
 
17186 
  def __init__(self, success=None, ex=None,):
17187 
    self.success = success
17188 
    self.ex = ex
17189 
 
17190 
  def read(self, iprot):
17191 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17192 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17193 
      return
17194 
    iprot.readStructBegin()
17195 
    while True:
17196 
      (fname, ftype, fid) = iprot.readFieldBegin()
17197 
      if ftype == TType.STOP:
17198 
        break
17199 
      if fid == 0:
17200 
        if ftype == TType.BOOL:
17201 
          self.success = iprot.readBool();
17202 
        else:
17203 
          iprot.skip(ftype)
17204 
      elif fid == 1:
17205 
        if ftype == TType.STRUCT:
17206 
          self.ex = TransactionServiceException()
17207 
          self.ex.read(iprot)
17208 
        else:
17209 
          iprot.skip(ftype)
17210 
      else:
17211 
        iprot.skip(ftype)
17212 
      iprot.readFieldEnd()
17213 
    iprot.readStructEnd()
17214 
 
17215 
  def write(self, oprot):
17216 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17217 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17218 
      return
17219 
    oprot.writeStructBegin('toggleDOAFlag_result')
3431 rajveer 17220 
    if self.success is not None:
2536 chandransh 17221 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
17222 
      oprot.writeBool(self.success)
17223 
      oprot.writeFieldEnd()
3431 rajveer 17224 
    if self.ex is not None:
2536 chandransh 17225 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
17226 
      self.ex.write(oprot)
17227 
      oprot.writeFieldEnd()
17228 
    oprot.writeFieldStop()
17229 
    oprot.writeStructEnd()
17230 
 
3431 rajveer 17231 
  def validate(self):
17232 
    return
17233 
 
17234 
 
2536 chandransh 17235 
  def __repr__(self):
17236 
    L = ['%s=%r' % (key, value)
17237 
      for key, value in self.__dict__.iteritems()]
17238 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17239 
 
17240 
  def __eq__(self, other):
17241 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17242 
 
17243 
  def __ne__(self, other):
17244 
    return not (self == other)
17245 
 
4712 rajveer 17246 
class markOrderAsDelivered_args:
17247 
  """
17248 
  Attributes:
17249 
   - orderId
17250 
   - deliveryTimestamp
17251 
   - receiver
17252 
  """
17253 
 
17254 
  thrift_spec = None
17255 
  def __init__(self, orderId=None, deliveryTimestamp=None, receiver=None,):
17256 
    self.orderId = orderId
17257 
    self.deliveryTimestamp = deliveryTimestamp
17258 
    self.receiver = receiver
17259 
 
17260 
  def read(self, iprot):
17261 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17262 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17263 
      return
17264 
    iprot.readStructBegin()
17265 
    while True:
17266 
      (fname, ftype, fid) = iprot.readFieldBegin()
17267 
      if ftype == TType.STOP:
17268 
        break
17269 
      if fid == 1:
17270 
        if ftype == TType.I64:
17271 
          self.orderId = iprot.readI64();
17272 
        else:
17273 
          iprot.skip(ftype)
17274 
      elif fid == 2:
17275 
        if ftype == TType.I64:
17276 
          self.deliveryTimestamp = iprot.readI64();
17277 
        else:
17278 
          iprot.skip(ftype)
17279 
      elif fid == -1:
17280 
        if ftype == TType.STRING:
17281 
          self.receiver = iprot.readString();
17282 
        else:
17283 
          iprot.skip(ftype)
17284 
      else:
17285 
        iprot.skip(ftype)
17286 
      iprot.readFieldEnd()
17287 
    iprot.readStructEnd()
17288 
 
17289 
  def write(self, oprot):
17290 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17291 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17292 
      return
17293 
    oprot.writeStructBegin('markOrderAsDelivered_args')
17294 
    if self.receiver is not None:
17295 
      oprot.writeFieldBegin('receiver', TType.STRING, -1)
17296 
      oprot.writeString(self.receiver)
17297 
      oprot.writeFieldEnd()
17298 
    if self.orderId is not None:
17299 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
17300 
      oprot.writeI64(self.orderId)
17301 
      oprot.writeFieldEnd()
17302 
    if self.deliveryTimestamp is not None:
17303 
      oprot.writeFieldBegin('deliveryTimestamp', TType.I64, 2)
17304 
      oprot.writeI64(self.deliveryTimestamp)
17305 
      oprot.writeFieldEnd()
17306 
    oprot.writeFieldStop()
17307 
    oprot.writeStructEnd()
17308 
 
17309 
  def validate(self):
17310 
    return
17311 
 
17312 
 
17313 
  def __repr__(self):
17314 
    L = ['%s=%r' % (key, value)
17315 
      for key, value in self.__dict__.iteritems()]
17316 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17317 
 
17318 
  def __eq__(self, other):
17319 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17320 
 
17321 
  def __ne__(self, other):
17322 
    return not (self == other)
17323 
 
17324 
class markOrderAsDelivered_result:
17325 
  """
17326 
  Attributes:
17327 
   - ex
17328 
  """
17329 
 
17330 
  thrift_spec = (
17331 
    None, # 0
17332 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
17333 
  )
17334 
 
17335 
  def __init__(self, ex=None,):
17336 
    self.ex = ex
17337 
 
17338 
  def read(self, iprot):
17339 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17340 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17341 
      return
17342 
    iprot.readStructBegin()
17343 
    while True:
17344 
      (fname, ftype, fid) = iprot.readFieldBegin()
17345 
      if ftype == TType.STOP:
17346 
        break
17347 
      if fid == 1:
17348 
        if ftype == TType.STRUCT:
17349 
          self.ex = TransactionServiceException()
17350 
          self.ex.read(iprot)
17351 
        else:
17352 
          iprot.skip(ftype)
17353 
      else:
17354 
        iprot.skip(ftype)
17355 
      iprot.readFieldEnd()
17356 
    iprot.readStructEnd()
17357 
 
17358 
  def write(self, oprot):
17359 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17360 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17361 
      return
17362 
    oprot.writeStructBegin('markOrderAsDelivered_result')
17363 
    if self.ex is not None:
17364 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
17365 
      self.ex.write(oprot)
17366 
      oprot.writeFieldEnd()
17367 
    oprot.writeFieldStop()
17368 
    oprot.writeStructEnd()
17369 
 
17370 
  def validate(self):
17371 
    return
17372 
 
17373 
 
17374 
  def __repr__(self):
17375 
    L = ['%s=%r' % (key, value)
17376 
      for key, value in self.__dict__.iteritems()]
17377 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17378 
 
17379 
  def __eq__(self, other):
17380 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17381 
 
17382 
  def __ne__(self, other):
17383 
    return not (self == other)
17384 
 
5553 rajveer 17385 
class markOrderAsReceivedAtStore_args:
17386 
  """
17387 
  Attributes:
17388 
   - orderId
17389 
   - deliveryTimestamp
17390 
  """
17391 
 
17392 
  thrift_spec = (
17393 
    None, # 0
17394 
    (1, TType.I64, 'orderId', None, None, ), # 1
17395 
    (2, TType.I64, 'deliveryTimestamp', None, None, ), # 2
17396 
  )
17397 
 
17398 
  def __init__(self, orderId=None, deliveryTimestamp=None,):
17399 
    self.orderId = orderId
17400 
    self.deliveryTimestamp = deliveryTimestamp
17401 
 
17402 
  def read(self, iprot):
17403 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17404 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17405 
      return
17406 
    iprot.readStructBegin()
17407 
    while True:
17408 
      (fname, ftype, fid) = iprot.readFieldBegin()
17409 
      if ftype == TType.STOP:
17410 
        break
17411 
      if fid == 1:
17412 
        if ftype == TType.I64:
17413 
          self.orderId = iprot.readI64();
17414 
        else:
17415 
          iprot.skip(ftype)
17416 
      elif fid == 2:
17417 
        if ftype == TType.I64:
17418 
          self.deliveryTimestamp = iprot.readI64();
17419 
        else:
17420 
          iprot.skip(ftype)
17421 
      else:
17422 
        iprot.skip(ftype)
17423 
      iprot.readFieldEnd()
17424 
    iprot.readStructEnd()
17425 
 
17426 
  def write(self, oprot):
17427 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17428 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17429 
      return
17430 
    oprot.writeStructBegin('markOrderAsReceivedAtStore_args')
17431 
    if self.orderId is not None:
17432 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
17433 
      oprot.writeI64(self.orderId)
17434 
      oprot.writeFieldEnd()
17435 
    if self.deliveryTimestamp is not None:
17436 
      oprot.writeFieldBegin('deliveryTimestamp', TType.I64, 2)
17437 
      oprot.writeI64(self.deliveryTimestamp)
17438 
      oprot.writeFieldEnd()
17439 
    oprot.writeFieldStop()
17440 
    oprot.writeStructEnd()
17441 
 
17442 
  def validate(self):
17443 
    return
17444 
 
17445 
 
17446 
  def __repr__(self):
17447 
    L = ['%s=%r' % (key, value)
17448 
      for key, value in self.__dict__.iteritems()]
17449 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17450 
 
17451 
  def __eq__(self, other):
17452 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17453 
 
17454 
  def __ne__(self, other):
17455 
    return not (self == other)
17456 
 
17457 
class markOrderAsReceivedAtStore_result:
17458 
  """
17459 
  Attributes:
17460 
   - ex
17461 
  """
17462 
 
17463 
  thrift_spec = (
17464 
    None, # 0
17465 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
17466 
  )
17467 
 
17468 
  def __init__(self, ex=None,):
17469 
    self.ex = ex
17470 
 
17471 
  def read(self, iprot):
17472 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17473 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17474 
      return
17475 
    iprot.readStructBegin()
17476 
    while True:
17477 
      (fname, ftype, fid) = iprot.readFieldBegin()
17478 
      if ftype == TType.STOP:
17479 
        break
17480 
      if fid == 1:
17481 
        if ftype == TType.STRUCT:
17482 
          self.ex = TransactionServiceException()
17483 
          self.ex.read(iprot)
17484 
        else:
17485 
          iprot.skip(ftype)
17486 
      else:
17487 
        iprot.skip(ftype)
17488 
      iprot.readFieldEnd()
17489 
    iprot.readStructEnd()
17490 
 
17491 
  def write(self, oprot):
17492 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17493 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17494 
      return
17495 
    oprot.writeStructBegin('markOrderAsReceivedAtStore_result')
17496 
    if self.ex is not None:
17497 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
17498 
      self.ex.write(oprot)
17499 
      oprot.writeFieldEnd()
17500 
    oprot.writeFieldStop()
17501 
    oprot.writeStructEnd()
17502 
 
17503 
  def validate(self):
17504 
    return
17505 
 
17506 
 
17507 
  def __repr__(self):
17508 
    L = ['%s=%r' % (key, value)
17509 
      for key, value in self.__dict__.iteritems()]
17510 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17511 
 
17512 
  def __eq__(self, other):
17513 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17514 
 
17515 
  def __ne__(self, other):
17516 
    return not (self == other)
17517 
 
4454 rajveer 17518 
class markOrderDoaRequestReceived_args:
17519 
  """
17520 
  Attributes:
17521 
   - orderId
17522 
  """
17523 
 
17524 
  thrift_spec = (
17525 
    None, # 0
17526 
    (1, TType.I64, 'orderId', None, None, ), # 1
17527 
  )
17528 
 
17529 
  def __init__(self, orderId=None,):
17530 
    self.orderId = orderId
17531 
 
17532 
  def read(self, iprot):
17533 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17534 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17535 
      return
17536 
    iprot.readStructBegin()
17537 
    while True:
17538 
      (fname, ftype, fid) = iprot.readFieldBegin()
17539 
      if ftype == TType.STOP:
17540 
        break
17541 
      if fid == 1:
17542 
        if ftype == TType.I64:
17543 
          self.orderId = iprot.readI64();
17544 
        else:
17545 
          iprot.skip(ftype)
17546 
      else:
17547 
        iprot.skip(ftype)
17548 
      iprot.readFieldEnd()
17549 
    iprot.readStructEnd()
17550 
 
17551 
  def write(self, oprot):
17552 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17553 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17554 
      return
17555 
    oprot.writeStructBegin('markOrderDoaRequestReceived_args')
17556 
    if self.orderId is not None:
17557 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
17558 
      oprot.writeI64(self.orderId)
17559 
      oprot.writeFieldEnd()
17560 
    oprot.writeFieldStop()
17561 
    oprot.writeStructEnd()
17562 
 
17563 
  def validate(self):
17564 
    return
17565 
 
17566 
 
17567 
  def __repr__(self):
17568 
    L = ['%s=%r' % (key, value)
17569 
      for key, value in self.__dict__.iteritems()]
17570 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17571 
 
17572 
  def __eq__(self, other):
17573 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17574 
 
17575 
  def __ne__(self, other):
17576 
    return not (self == other)
17577 
 
17578 
class markOrderDoaRequestReceived_result:
17579 
  """
17580 
  Attributes:
17581 
   - success
17582 
   - ex
17583 
  """
17584 
 
17585 
  thrift_spec = (
17586 
    (0, TType.BOOL, 'success', None, None, ), # 0
17587 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
17588 
  )
17589 
 
17590 
  def __init__(self, success=None, ex=None,):
17591 
    self.success = success
17592 
    self.ex = ex
17593 
 
17594 
  def read(self, iprot):
17595 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17596 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17597 
      return
17598 
    iprot.readStructBegin()
17599 
    while True:
17600 
      (fname, ftype, fid) = iprot.readFieldBegin()
17601 
      if ftype == TType.STOP:
17602 
        break
17603 
      if fid == 0:
17604 
        if ftype == TType.BOOL:
17605 
          self.success = iprot.readBool();
17606 
        else:
17607 
          iprot.skip(ftype)
17608 
      elif fid == 1:
17609 
        if ftype == TType.STRUCT:
17610 
          self.ex = TransactionServiceException()
17611 
          self.ex.read(iprot)
17612 
        else:
17613 
          iprot.skip(ftype)
17614 
      else:
17615 
        iprot.skip(ftype)
17616 
      iprot.readFieldEnd()
17617 
    iprot.readStructEnd()
17618 
 
17619 
  def write(self, oprot):
17620 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17621 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17622 
      return
17623 
    oprot.writeStructBegin('markOrderDoaRequestReceived_result')
17624 
    if self.success is not None:
17625 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
17626 
      oprot.writeBool(self.success)
17627 
      oprot.writeFieldEnd()
17628 
    if self.ex is not None:
17629 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
17630 
      self.ex.write(oprot)
17631 
      oprot.writeFieldEnd()
17632 
    oprot.writeFieldStop()
17633 
    oprot.writeStructEnd()
17634 
 
17635 
  def validate(self):
17636 
    return
17637 
 
17638 
 
17639 
  def __repr__(self):
17640 
    L = ['%s=%r' % (key, value)
17641 
      for key, value in self.__dict__.iteritems()]
17642 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17643 
 
17644 
  def __eq__(self, other):
17645 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17646 
 
17647 
  def __ne__(self, other):
17648 
    return not (self == other)
17649 
 
17650 
class markOrderDoaRequestAuthorized_args:
17651 
  """
17652 
  Attributes:
17653 
   - orderId
17654 
   - isAuthorized
17655 
  """
17656 
 
17657 
  thrift_spec = (
17658 
    None, # 0
17659 
    (1, TType.I64, 'orderId', None, None, ), # 1
17660 
    (2, TType.BOOL, 'isAuthorized', None, None, ), # 2
17661 
  )
17662 
 
17663 
  def __init__(self, orderId=None, isAuthorized=None,):
17664 
    self.orderId = orderId
17665 
    self.isAuthorized = isAuthorized
17666 
 
17667 
  def read(self, iprot):
17668 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17669 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17670 
      return
17671 
    iprot.readStructBegin()
17672 
    while True:
17673 
      (fname, ftype, fid) = iprot.readFieldBegin()
17674 
      if ftype == TType.STOP:
17675 
        break
17676 
      if fid == 1:
17677 
        if ftype == TType.I64:
17678 
          self.orderId = iprot.readI64();
17679 
        else:
17680 
          iprot.skip(ftype)
17681 
      elif fid == 2:
17682 
        if ftype == TType.BOOL:
17683 
          self.isAuthorized = iprot.readBool();
17684 
        else:
17685 
          iprot.skip(ftype)
17686 
      else:
17687 
        iprot.skip(ftype)
17688 
      iprot.readFieldEnd()
17689 
    iprot.readStructEnd()
17690 
 
17691 
  def write(self, oprot):
17692 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17693 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17694 
      return
17695 
    oprot.writeStructBegin('markOrderDoaRequestAuthorized_args')
17696 
    if self.orderId is not None:
17697 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
17698 
      oprot.writeI64(self.orderId)
17699 
      oprot.writeFieldEnd()
17700 
    if self.isAuthorized is not None:
17701 
      oprot.writeFieldBegin('isAuthorized', TType.BOOL, 2)
17702 
      oprot.writeBool(self.isAuthorized)
17703 
      oprot.writeFieldEnd()
17704 
    oprot.writeFieldStop()
17705 
    oprot.writeStructEnd()
17706 
 
17707 
  def validate(self):
17708 
    return
17709 
 
17710 
 
17711 
  def __repr__(self):
17712 
    L = ['%s=%r' % (key, value)
17713 
      for key, value in self.__dict__.iteritems()]
17714 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17715 
 
17716 
  def __eq__(self, other):
17717 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17718 
 
17719 
  def __ne__(self, other):
17720 
    return not (self == other)
17721 
 
17722 
class markOrderDoaRequestAuthorized_result:
17723 
  """
17724 
  Attributes:
17725 
   - success
17726 
   - ex
17727 
  """
17728 
 
17729 
  thrift_spec = (
17730 
    (0, TType.BOOL, 'success', None, None, ), # 0
17731 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
17732 
  )
17733 
 
17734 
  def __init__(self, success=None, ex=None,):
17735 
    self.success = success
17736 
    self.ex = ex
17737 
 
17738 
  def read(self, iprot):
17739 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17740 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17741 
      return
17742 
    iprot.readStructBegin()
17743 
    while True:
17744 
      (fname, ftype, fid) = iprot.readFieldBegin()
17745 
      if ftype == TType.STOP:
17746 
        break
17747 
      if fid == 0:
17748 
        if ftype == TType.BOOL:
17749 
          self.success = iprot.readBool();
17750 
        else:
17751 
          iprot.skip(ftype)
17752 
      elif fid == 1:
17753 
        if ftype == TType.STRUCT:
17754 
          self.ex = TransactionServiceException()
17755 
          self.ex.read(iprot)
17756 
        else:
17757 
          iprot.skip(ftype)
17758 
      else:
17759 
        iprot.skip(ftype)
17760 
      iprot.readFieldEnd()
17761 
    iprot.readStructEnd()
17762 
 
17763 
  def write(self, oprot):
17764 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17765 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17766 
      return
17767 
    oprot.writeStructBegin('markOrderDoaRequestAuthorized_result')
17768 
    if self.success is not None:
17769 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
17770 
      oprot.writeBool(self.success)
17771 
      oprot.writeFieldEnd()
17772 
    if self.ex is not None:
17773 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
17774 
      self.ex.write(oprot)
17775 
      oprot.writeFieldEnd()
17776 
    oprot.writeFieldStop()
17777 
    oprot.writeStructEnd()
17778 
 
17779 
  def validate(self):
17780 
    return
17781 
 
17782 
 
17783 
  def __repr__(self):
17784 
    L = ['%s=%r' % (key, value)
17785 
      for key, value in self.__dict__.iteritems()]
17786 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17787 
 
17788 
  def __eq__(self, other):
17789 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17790 
 
17791 
  def __ne__(self, other):
17792 
    return not (self == other)
17793 
 
4488 rajveer 17794 
class markOrderReturnRequestReceived_args:
17795 
  """
17796 
  Attributes:
17797 
   - orderId
17798 
  """
17799 
 
17800 
  thrift_spec = (
17801 
    None, # 0
17802 
    (1, TType.I64, 'orderId', None, None, ), # 1
17803 
  )
17804 
 
17805 
  def __init__(self, orderId=None,):
17806 
    self.orderId = orderId
17807 
 
17808 
  def read(self, iprot):
17809 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17810 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17811 
      return
17812 
    iprot.readStructBegin()
17813 
    while True:
17814 
      (fname, ftype, fid) = iprot.readFieldBegin()
17815 
      if ftype == TType.STOP:
17816 
        break
17817 
      if fid == 1:
17818 
        if ftype == TType.I64:
17819 
          self.orderId = iprot.readI64();
17820 
        else:
17821 
          iprot.skip(ftype)
17822 
      else:
17823 
        iprot.skip(ftype)
17824 
      iprot.readFieldEnd()
17825 
    iprot.readStructEnd()
17826 
 
17827 
  def write(self, oprot):
17828 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17829 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17830 
      return
17831 
    oprot.writeStructBegin('markOrderReturnRequestReceived_args')
17832 
    if self.orderId is not None:
17833 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
17834 
      oprot.writeI64(self.orderId)
17835 
      oprot.writeFieldEnd()
17836 
    oprot.writeFieldStop()
17837 
    oprot.writeStructEnd()
17838 
 
17839 
  def validate(self):
17840 
    return
17841 
 
17842 
 
17843 
  def __repr__(self):
17844 
    L = ['%s=%r' % (key, value)
17845 
      for key, value in self.__dict__.iteritems()]
17846 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17847 
 
17848 
  def __eq__(self, other):
17849 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17850 
 
17851 
  def __ne__(self, other):
17852 
    return not (self == other)
17853 
 
17854 
class markOrderReturnRequestReceived_result:
17855 
  """
17856 
  Attributes:
17857 
   - success
17858 
   - ex
17859 
  """
17860 
 
17861 
  thrift_spec = (
17862 
    (0, TType.BOOL, 'success', None, None, ), # 0
17863 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
17864 
  )
17865 
 
17866 
  def __init__(self, success=None, ex=None,):
17867 
    self.success = success
17868 
    self.ex = ex
17869 
 
17870 
  def read(self, iprot):
17871 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17872 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17873 
      return
17874 
    iprot.readStructBegin()
17875 
    while True:
17876 
      (fname, ftype, fid) = iprot.readFieldBegin()
17877 
      if ftype == TType.STOP:
17878 
        break
17879 
      if fid == 0:
17880 
        if ftype == TType.BOOL:
17881 
          self.success = iprot.readBool();
17882 
        else:
17883 
          iprot.skip(ftype)
17884 
      elif fid == 1:
17885 
        if ftype == TType.STRUCT:
17886 
          self.ex = TransactionServiceException()
17887 
          self.ex.read(iprot)
17888 
        else:
17889 
          iprot.skip(ftype)
17890 
      else:
17891 
        iprot.skip(ftype)
17892 
      iprot.readFieldEnd()
17893 
    iprot.readStructEnd()
17894 
 
17895 
  def write(self, oprot):
17896 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17897 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17898 
      return
17899 
    oprot.writeStructBegin('markOrderReturnRequestReceived_result')
17900 
    if self.success is not None:
17901 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
17902 
      oprot.writeBool(self.success)
17903 
      oprot.writeFieldEnd()
17904 
    if self.ex is not None:
17905 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
17906 
      self.ex.write(oprot)
17907 
      oprot.writeFieldEnd()
17908 
    oprot.writeFieldStop()
17909 
    oprot.writeStructEnd()
17910 
 
17911 
  def validate(self):
17912 
    return
17913 
 
17914 
 
17915 
  def __repr__(self):
17916 
    L = ['%s=%r' % (key, value)
17917 
      for key, value in self.__dict__.iteritems()]
17918 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17919 
 
17920 
  def __eq__(self, other):
17921 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17922 
 
17923 
  def __ne__(self, other):
17924 
    return not (self == other)
17925 
 
17926 
class markOrderReturnRequestAuthorized_args:
17927 
  """
17928 
  Attributes:
17929 
   - orderId
17930 
   - isAuthorized
17931 
  """
17932 
 
17933 
  thrift_spec = (
17934 
    None, # 0
17935 
    (1, TType.I64, 'orderId', None, None, ), # 1
17936 
    (2, TType.BOOL, 'isAuthorized', None, None, ), # 2
17937 
  )
17938 
 
17939 
  def __init__(self, orderId=None, isAuthorized=None,):
17940 
    self.orderId = orderId
17941 
    self.isAuthorized = isAuthorized
17942 
 
17943 
  def read(self, iprot):
17944 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17945 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17946 
      return
17947 
    iprot.readStructBegin()
17948 
    while True:
17949 
      (fname, ftype, fid) = iprot.readFieldBegin()
17950 
      if ftype == TType.STOP:
17951 
        break
17952 
      if fid == 1:
17953 
        if ftype == TType.I64:
17954 
          self.orderId = iprot.readI64();
17955 
        else:
17956 
          iprot.skip(ftype)
17957 
      elif fid == 2:
17958 
        if ftype == TType.BOOL:
17959 
          self.isAuthorized = iprot.readBool();
17960 
        else:
17961 
          iprot.skip(ftype)
17962 
      else:
17963 
        iprot.skip(ftype)
17964 
      iprot.readFieldEnd()
17965 
    iprot.readStructEnd()
17966 
 
17967 
  def write(self, oprot):
17968 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17969 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17970 
      return
17971 
    oprot.writeStructBegin('markOrderReturnRequestAuthorized_args')
17972 
    if self.orderId is not None:
17973 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
17974 
      oprot.writeI64(self.orderId)
17975 
      oprot.writeFieldEnd()
17976 
    if self.isAuthorized is not None:
17977 
      oprot.writeFieldBegin('isAuthorized', TType.BOOL, 2)
17978 
      oprot.writeBool(self.isAuthorized)
17979 
      oprot.writeFieldEnd()
17980 
    oprot.writeFieldStop()
17981 
    oprot.writeStructEnd()
17982 
 
17983 
  def validate(self):
17984 
    return
17985 
 
17986 
 
17987 
  def __repr__(self):
17988 
    L = ['%s=%r' % (key, value)
17989 
      for key, value in self.__dict__.iteritems()]
17990 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17991 
 
17992 
  def __eq__(self, other):
17993 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17994 
 
17995 
  def __ne__(self, other):
17996 
    return not (self == other)
17997 
 
17998 
class markOrderReturnRequestAuthorized_result:
17999 
  """
18000 
  Attributes:
18001 
   - success
18002 
   - ex
18003 
  """
18004 
 
18005 
  thrift_spec = (
18006 
    (0, TType.BOOL, 'success', None, None, ), # 0
18007 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
18008 
  )
18009 
 
18010 
  def __init__(self, success=None, ex=None,):
18011 
    self.success = success
18012 
    self.ex = ex
18013 
 
18014 
  def read(self, iprot):
18015 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18016 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18017 
      return
18018 
    iprot.readStructBegin()
18019 
    while True:
18020 
      (fname, ftype, fid) = iprot.readFieldBegin()
18021 
      if ftype == TType.STOP:
18022 
        break
18023 
      if fid == 0:
18024 
        if ftype == TType.BOOL:
18025 
          self.success = iprot.readBool();
18026 
        else:
18027 
          iprot.skip(ftype)
18028 
      elif fid == 1:
18029 
        if ftype == TType.STRUCT:
18030 
          self.ex = TransactionServiceException()
18031 
          self.ex.read(iprot)
18032 
        else:
18033 
          iprot.skip(ftype)
18034 
      else:
18035 
        iprot.skip(ftype)
18036 
      iprot.readFieldEnd()
18037 
    iprot.readStructEnd()
18038 
 
18039 
  def write(self, oprot):
18040 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18041 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18042 
      return
18043 
    oprot.writeStructBegin('markOrderReturnRequestAuthorized_result')
18044 
    if self.success is not None:
18045 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
18046 
      oprot.writeBool(self.success)
18047 
      oprot.writeFieldEnd()
18048 
    if self.ex is not None:
18049 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
18050 
      self.ex.write(oprot)
18051 
      oprot.writeFieldEnd()
18052 
    oprot.writeFieldStop()
18053 
    oprot.writeStructEnd()
18054 
 
18055 
  def validate(self):
18056 
    return
18057 
 
18058 
 
18059 
  def __repr__(self):
18060 
    L = ['%s=%r' % (key, value)
18061 
      for key, value in self.__dict__.iteritems()]
18062 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18063 
 
18064 
  def __eq__(self, other):
18065 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18066 
 
18067 
  def __ne__(self, other):
18068 
    return not (self == other)
18069 
 
2536 chandransh 18070 
class requestPickupNumber_args:
18071 
  """
18072 
  Attributes:
18073 
   - orderId
4579 rajveer 18074 
   - providerId
2536 chandransh 18075 
  """
18076 
 
18077 
  thrift_spec = (
18078 
    None, # 0
18079 
    (1, TType.I64, 'orderId', None, None, ), # 1
4579 rajveer 18080 
    (2, TType.I64, 'providerId', None, None, ), # 2
2536 chandransh 18081 
  )
18082 
 
4579 rajveer 18083 
  def __init__(self, orderId=None, providerId=None,):
2536 chandransh 18084 
    self.orderId = orderId
4579 rajveer 18085 
    self.providerId = providerId
2536 chandransh 18086 
 
18087 
  def read(self, iprot):
18088 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18089 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18090 
      return
18091 
    iprot.readStructBegin()
18092 
    while True:
18093 
      (fname, ftype, fid) = iprot.readFieldBegin()
18094 
      if ftype == TType.STOP:
18095 
        break
18096 
      if fid == 1:
18097 
        if ftype == TType.I64:
18098 
          self.orderId = iprot.readI64();
18099 
        else:
18100 
          iprot.skip(ftype)
4579 rajveer 18101 
      elif fid == 2:
18102 
        if ftype == TType.I64:
18103 
          self.providerId = iprot.readI64();
18104 
        else:
18105 
          iprot.skip(ftype)
2536 chandransh 18106 
      else:
18107 
        iprot.skip(ftype)
18108 
      iprot.readFieldEnd()
18109 
    iprot.readStructEnd()
18110 
 
18111 
  def write(self, oprot):
18112 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18113 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18114 
      return
18115 
    oprot.writeStructBegin('requestPickupNumber_args')
3431 rajveer 18116 
    if self.orderId is not None:
2536 chandransh 18117 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
18118 
      oprot.writeI64(self.orderId)
18119 
      oprot.writeFieldEnd()
4579 rajveer 18120 
    if self.providerId is not None:
18121 
      oprot.writeFieldBegin('providerId', TType.I64, 2)
18122 
      oprot.writeI64(self.providerId)
18123 
      oprot.writeFieldEnd()
2536 chandransh 18124 
    oprot.writeFieldStop()
18125 
    oprot.writeStructEnd()
18126 
 
3431 rajveer 18127 
  def validate(self):
18128 
    return
18129 
 
18130 
 
2536 chandransh 18131 
  def __repr__(self):
18132 
    L = ['%s=%r' % (key, value)
18133 
      for key, value in self.__dict__.iteritems()]
18134 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18135 
 
18136 
  def __eq__(self, other):
18137 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18138 
 
18139 
  def __ne__(self, other):
18140 
    return not (self == other)
18141 
 
18142 
class requestPickupNumber_result:
18143 
  """
18144 
  Attributes:
18145 
   - success
18146 
   - ex
18147 
  """
18148 
 
18149 
  thrift_spec = (
18150 
    (0, TType.BOOL, 'success', None, None, ), # 0
18151 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
18152 
  )
18153 
 
18154 
  def __init__(self, success=None, ex=None,):
18155 
    self.success = success
18156 
    self.ex = ex
18157 
 
18158 
  def read(self, iprot):
18159 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18160 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18161 
      return
18162 
    iprot.readStructBegin()
18163 
    while True:
18164 
      (fname, ftype, fid) = iprot.readFieldBegin()
18165 
      if ftype == TType.STOP:
18166 
        break
18167 
      if fid == 0:
18168 
        if ftype == TType.BOOL:
18169 
          self.success = iprot.readBool();
18170 
        else:
18171 
          iprot.skip(ftype)
18172 
      elif fid == 1:
18173 
        if ftype == TType.STRUCT:
18174 
          self.ex = TransactionServiceException()
18175 
          self.ex.read(iprot)
18176 
        else:
18177 
          iprot.skip(ftype)
18178 
      else:
18179 
        iprot.skip(ftype)
18180 
      iprot.readFieldEnd()
18181 
    iprot.readStructEnd()
18182 
 
18183 
  def write(self, oprot):
18184 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18185 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18186 
      return
18187 
    oprot.writeStructBegin('requestPickupNumber_result')
3431 rajveer 18188 
    if self.success is not None:
2536 chandransh 18189 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
18190 
      oprot.writeBool(self.success)
18191 
      oprot.writeFieldEnd()
3431 rajveer 18192 
    if self.ex is not None:
2536 chandransh 18193 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
18194 
      self.ex.write(oprot)
18195 
      oprot.writeFieldEnd()
18196 
    oprot.writeFieldStop()
18197 
    oprot.writeStructEnd()
18198 
 
3431 rajveer 18199 
  def validate(self):
18200 
    return
18201 
 
18202 
 
2536 chandransh 18203 
  def __repr__(self):
18204 
    L = ['%s=%r' % (key, value)
18205 
      for key, value in self.__dict__.iteritems()]
18206 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18207 
 
18208 
  def __eq__(self, other):
18209 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18210 
 
18211 
  def __ne__(self, other):
18212 
    return not (self == other)
18213 
 
18214 
class authorizePickup_args:
18215 
  """
18216 
  Attributes:
18217 
   - orderId
18218 
   - pickupNumber
4602 rajveer 18219 
   - providerId
2536 chandransh 18220 
  """
18221 
 
18222 
  thrift_spec = (
18223 
    None, # 0
18224 
    (1, TType.I64, 'orderId', None, None, ), # 1
18225 
    (2, TType.STRING, 'pickupNumber', None, None, ), # 2
4602 rajveer 18226 
    (3, TType.I64, 'providerId', None, None, ), # 3
2536 chandransh 18227 
  )
18228 
 
4602 rajveer 18229 
  def __init__(self, orderId=None, pickupNumber=None, providerId=None,):
2536 chandransh 18230 
    self.orderId = orderId
18231 
    self.pickupNumber = pickupNumber
4602 rajveer 18232 
    self.providerId = providerId
2536 chandransh 18233 
 
18234 
  def read(self, iprot):
18235 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18236 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18237 
      return
18238 
    iprot.readStructBegin()
18239 
    while True:
18240 
      (fname, ftype, fid) = iprot.readFieldBegin()
18241 
      if ftype == TType.STOP:
18242 
        break
18243 
      if fid == 1:
18244 
        if ftype == TType.I64:
18245 
          self.orderId = iprot.readI64();
18246 
        else:
18247 
          iprot.skip(ftype)
18248 
      elif fid == 2:
18249 
        if ftype == TType.STRING:
18250 
          self.pickupNumber = iprot.readString();
18251 
        else:
18252 
          iprot.skip(ftype)
4602 rajveer 18253 
      elif fid == 3:
18254 
        if ftype == TType.I64:
18255 
          self.providerId = iprot.readI64();
18256 
        else:
18257 
          iprot.skip(ftype)
2536 chandransh 18258 
      else:
18259 
        iprot.skip(ftype)
18260 
      iprot.readFieldEnd()
18261 
    iprot.readStructEnd()
18262 
 
18263 
  def write(self, oprot):
18264 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18265 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18266 
      return
18267 
    oprot.writeStructBegin('authorizePickup_args')
3431 rajveer 18268 
    if self.orderId is not None:
2536 chandransh 18269 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
18270 
      oprot.writeI64(self.orderId)
18271 
      oprot.writeFieldEnd()
3431 rajveer 18272 
    if self.pickupNumber is not None:
2536 chandransh 18273 
      oprot.writeFieldBegin('pickupNumber', TType.STRING, 2)
18274 
      oprot.writeString(self.pickupNumber)
18275 
      oprot.writeFieldEnd()
4602 rajveer 18276 
    if self.providerId is not None:
18277 
      oprot.writeFieldBegin('providerId', TType.I64, 3)
18278 
      oprot.writeI64(self.providerId)
18279 
      oprot.writeFieldEnd()
2536 chandransh 18280 
    oprot.writeFieldStop()
18281 
    oprot.writeStructEnd()
18282 
 
3431 rajveer 18283 
  def validate(self):
18284 
    return
18285 
 
18286 
 
2536 chandransh 18287 
  def __repr__(self):
18288 
    L = ['%s=%r' % (key, value)
18289 
      for key, value in self.__dict__.iteritems()]
18290 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18291 
 
18292 
  def __eq__(self, other):
18293 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18294 
 
18295 
  def __ne__(self, other):
18296 
    return not (self == other)
18297 
 
18298 
class authorizePickup_result:
18299 
  """
18300 
  Attributes:
18301 
   - success
18302 
   - ex
18303 
  """
18304 
 
18305 
  thrift_spec = (
18306 
    (0, TType.BOOL, 'success', None, None, ), # 0
18307 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
18308 
  )
18309 
 
18310 
  def __init__(self, success=None, ex=None,):
18311 
    self.success = success
18312 
    self.ex = ex
18313 
 
18314 
  def read(self, iprot):
18315 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18316 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18317 
      return
18318 
    iprot.readStructBegin()
18319 
    while True:
18320 
      (fname, ftype, fid) = iprot.readFieldBegin()
18321 
      if ftype == TType.STOP:
18322 
        break
18323 
      if fid == 0:
18324 
        if ftype == TType.BOOL:
18325 
          self.success = iprot.readBool();
18326 
        else:
18327 
          iprot.skip(ftype)
18328 
      elif fid == 1:
18329 
        if ftype == TType.STRUCT:
18330 
          self.ex = TransactionServiceException()
18331 
          self.ex.read(iprot)
18332 
        else:
18333 
          iprot.skip(ftype)
18334 
      else:
18335 
        iprot.skip(ftype)
18336 
      iprot.readFieldEnd()
18337 
    iprot.readStructEnd()
18338 
 
18339 
  def write(self, oprot):
18340 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18341 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18342 
      return
18343 
    oprot.writeStructBegin('authorizePickup_result')
3431 rajveer 18344 
    if self.success is not None:
2536 chandransh 18345 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
18346 
      oprot.writeBool(self.success)
18347 
      oprot.writeFieldEnd()
3431 rajveer 18348 
    if self.ex is not None:
2536 chandransh 18349 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
18350 
      self.ex.write(oprot)
18351 
      oprot.writeFieldEnd()
18352 
    oprot.writeFieldStop()
18353 
    oprot.writeStructEnd()
18354 
 
3431 rajveer 18355 
  def validate(self):
18356 
    return
18357 
 
18358 
 
2536 chandransh 18359 
  def __repr__(self):
18360 
    L = ['%s=%r' % (key, value)
18361 
      for key, value in self.__dict__.iteritems()]
18362 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18363 
 
18364 
  def __eq__(self, other):
18365 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18366 
 
18367 
  def __ne__(self, other):
18368 
    return not (self == other)
18369 
 
2764 chandransh 18370 
class markDoasAsPickedUp_args:
18371 
  """
18372 
  Attributes:
18373 
   - providerId
18374 
   - pickupDetails
18375 
  """
18376 
 
18377 
  thrift_spec = (
18378 
    None, # 0
18379 
    (1, TType.I64, 'providerId', None, None, ), # 1
18380 
    (2, TType.MAP, 'pickupDetails', (TType.STRING,None,TType.STRING,None), None, ), # 2
18381 
  )
18382 
 
18383 
  def __init__(self, providerId=None, pickupDetails=None,):
18384 
    self.providerId = providerId
18385 
    self.pickupDetails = pickupDetails
18386 
 
18387 
  def read(self, iprot):
18388 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18389 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18390 
      return
18391 
    iprot.readStructBegin()
18392 
    while True:
18393 
      (fname, ftype, fid) = iprot.readFieldBegin()
18394 
      if ftype == TType.STOP:
18395 
        break
18396 
      if fid == 1:
18397 
        if ftype == TType.I64:
18398 
          self.providerId = iprot.readI64();
18399 
        else:
18400 
          iprot.skip(ftype)
18401 
      elif fid == 2:
18402 
        if ftype == TType.MAP:
18403 
          self.pickupDetails = {}
6188 rajveer 18404 
          (_ktype408, _vtype409, _size407 ) = iprot.readMapBegin()
18405 
          for _i411 in xrange(_size407):
18406 
            _key412 = iprot.readString();
18407 
            _val413 = iprot.readString();
18408 
            self.pickupDetails[_key412] = _val413
2764 chandransh 18409 
          iprot.readMapEnd()
18410 
        else:
18411 
          iprot.skip(ftype)
18412 
      else:
18413 
        iprot.skip(ftype)
18414 
      iprot.readFieldEnd()
18415 
    iprot.readStructEnd()
18416 
 
18417 
  def write(self, oprot):
18418 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18419 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18420 
      return
18421 
    oprot.writeStructBegin('markDoasAsPickedUp_args')
3431 rajveer 18422 
    if self.providerId is not None:
2764 chandransh 18423 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
18424 
      oprot.writeI64(self.providerId)
18425 
      oprot.writeFieldEnd()
3431 rajveer 18426 
    if self.pickupDetails is not None:
2764 chandransh 18427 
      oprot.writeFieldBegin('pickupDetails', TType.MAP, 2)
18428 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.pickupDetails))
6188 rajveer 18429 
      for kiter414,viter415 in self.pickupDetails.items():
18430 
        oprot.writeString(kiter414)
18431 
        oprot.writeString(viter415)
2764 chandransh 18432 
      oprot.writeMapEnd()
18433 
      oprot.writeFieldEnd()
18434 
    oprot.writeFieldStop()
18435 
    oprot.writeStructEnd()
18436 
 
3431 rajveer 18437 
  def validate(self):
18438 
    return
18439 
 
18440 
 
2764 chandransh 18441 
  def __repr__(self):
18442 
    L = ['%s=%r' % (key, value)
18443 
      for key, value in self.__dict__.iteritems()]
18444 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18445 
 
18446 
  def __eq__(self, other):
18447 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18448 
 
18449 
  def __ne__(self, other):
18450 
    return not (self == other)
18451 
 
18452 
class markDoasAsPickedUp_result:
4910 phani.kuma 18453 
 
18454 
  thrift_spec = (
18455 
  )
18456 
 
18457 
  def read(self, iprot):
18458 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18459 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18460 
      return
18461 
    iprot.readStructBegin()
18462 
    while True:
18463 
      (fname, ftype, fid) = iprot.readFieldBegin()
18464 
      if ftype == TType.STOP:
18465 
        break
18466 
      else:
18467 
        iprot.skip(ftype)
18468 
      iprot.readFieldEnd()
18469 
    iprot.readStructEnd()
18470 
 
18471 
  def write(self, oprot):
18472 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18473 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18474 
      return
18475 
    oprot.writeStructBegin('markDoasAsPickedUp_result')
18476 
    oprot.writeFieldStop()
18477 
    oprot.writeStructEnd()
18478 
 
18479 
  def validate(self):
18480 
    return
18481 
 
18482 
 
18483 
  def __repr__(self):
18484 
    L = ['%s=%r' % (key, value)
18485 
      for key, value in self.__dict__.iteritems()]
18486 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18487 
 
18488 
  def __eq__(self, other):
18489 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18490 
 
18491 
  def __ne__(self, other):
18492 
    return not (self == other)
18493 
 
18494 
class getDoasNotPickedUp_args:
2764 chandransh 18495 
  """
18496 
  Attributes:
4910 phani.kuma 18497 
   - providerId
18498 
  """
18499 
 
18500 
  thrift_spec = (
18501 
    None, # 0
18502 
    (1, TType.I64, 'providerId', None, None, ), # 1
18503 
  )
18504 
 
18505 
  def __init__(self, providerId=None,):
18506 
    self.providerId = providerId
18507 
 
18508 
  def read(self, iprot):
18509 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18510 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18511 
      return
18512 
    iprot.readStructBegin()
18513 
    while True:
18514 
      (fname, ftype, fid) = iprot.readFieldBegin()
18515 
      if ftype == TType.STOP:
18516 
        break
18517 
      if fid == 1:
18518 
        if ftype == TType.I64:
18519 
          self.providerId = iprot.readI64();
18520 
        else:
18521 
          iprot.skip(ftype)
18522 
      else:
18523 
        iprot.skip(ftype)
18524 
      iprot.readFieldEnd()
18525 
    iprot.readStructEnd()
18526 
 
18527 
  def write(self, oprot):
18528 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18529 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18530 
      return
18531 
    oprot.writeStructBegin('getDoasNotPickedUp_args')
18532 
    if self.providerId is not None:
18533 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
18534 
      oprot.writeI64(self.providerId)
18535 
      oprot.writeFieldEnd()
18536 
    oprot.writeFieldStop()
18537 
    oprot.writeStructEnd()
18538 
 
18539 
  def validate(self):
18540 
    return
18541 
 
18542 
 
18543 
  def __repr__(self):
18544 
    L = ['%s=%r' % (key, value)
18545 
      for key, value in self.__dict__.iteritems()]
18546 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18547 
 
18548 
  def __eq__(self, other):
18549 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18550 
 
18551 
  def __ne__(self, other):
18552 
    return not (self == other)
18553 
 
18554 
class getDoasNotPickedUp_result:
18555 
  """
18556 
  Attributes:
2764 chandransh 18557 
   - success
18558 
  """
18559 
 
18560 
  thrift_spec = (
18561 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
18562 
  )
18563 
 
18564 
  def __init__(self, success=None,):
18565 
    self.success = success
18566 
 
18567 
  def read(self, iprot):
18568 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18569 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18570 
      return
18571 
    iprot.readStructBegin()
18572 
    while True:
18573 
      (fname, ftype, fid) = iprot.readFieldBegin()
18574 
      if ftype == TType.STOP:
18575 
        break
18576 
      if fid == 0:
18577 
        if ftype == TType.LIST:
18578 
          self.success = []
6188 rajveer 18579 
          (_etype419, _size416) = iprot.readListBegin()
18580 
          for _i420 in xrange(_size416):
18581 
            _elem421 = Order()
18582 
            _elem421.read(iprot)
18583 
            self.success.append(_elem421)
2764 chandransh 18584 
          iprot.readListEnd()
18585 
        else:
18586 
          iprot.skip(ftype)
18587 
      else:
18588 
        iprot.skip(ftype)
18589 
      iprot.readFieldEnd()
18590 
    iprot.readStructEnd()
18591 
 
18592 
  def write(self, oprot):
18593 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18594 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18595 
      return
4910 phani.kuma 18596 
    oprot.writeStructBegin('getDoasNotPickedUp_result')
3431 rajveer 18597 
    if self.success is not None:
2764 chandransh 18598 
      oprot.writeFieldBegin('success', TType.LIST, 0)
18599 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 18600 
      for iter422 in self.success:
18601 
        iter422.write(oprot)
2764 chandransh 18602 
      oprot.writeListEnd()
18603 
      oprot.writeFieldEnd()
18604 
    oprot.writeFieldStop()
18605 
    oprot.writeStructEnd()
18606 
 
3431 rajveer 18607 
  def validate(self):
18608 
    return
18609 
 
18610 
 
2764 chandransh 18611 
  def __repr__(self):
18612 
    L = ['%s=%r' % (key, value)
18613 
      for key, value in self.__dict__.iteritems()]
18614 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18615 
 
18616 
  def __eq__(self, other):
18617 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18618 
 
18619 
  def __ne__(self, other):
18620 
    return not (self == other)
18621 
 
4741 phani.kuma 18622 
class markReturnOrdersAsPickedUp_args:
18623 
  """
18624 
  Attributes:
18625 
   - providerId
18626 
   - pickupDetails
18627 
  """
18628 
 
18629 
  thrift_spec = (
18630 
    None, # 0
18631 
    (1, TType.I64, 'providerId', None, None, ), # 1
18632 
    (2, TType.MAP, 'pickupDetails', (TType.STRING,None,TType.STRING,None), None, ), # 2
18633 
  )
18634 
 
18635 
  def __init__(self, providerId=None, pickupDetails=None,):
18636 
    self.providerId = providerId
18637 
    self.pickupDetails = pickupDetails
18638 
 
18639 
  def read(self, iprot):
18640 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18641 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18642 
      return
18643 
    iprot.readStructBegin()
18644 
    while True:
18645 
      (fname, ftype, fid) = iprot.readFieldBegin()
18646 
      if ftype == TType.STOP:
18647 
        break
18648 
      if fid == 1:
18649 
        if ftype == TType.I64:
18650 
          self.providerId = iprot.readI64();
18651 
        else:
18652 
          iprot.skip(ftype)
18653 
      elif fid == 2:
18654 
        if ftype == TType.MAP:
18655 
          self.pickupDetails = {}
6188 rajveer 18656 
          (_ktype424, _vtype425, _size423 ) = iprot.readMapBegin()
18657 
          for _i427 in xrange(_size423):
18658 
            _key428 = iprot.readString();
18659 
            _val429 = iprot.readString();
18660 
            self.pickupDetails[_key428] = _val429
4741 phani.kuma 18661 
          iprot.readMapEnd()
18662 
        else:
18663 
          iprot.skip(ftype)
18664 
      else:
18665 
        iprot.skip(ftype)
18666 
      iprot.readFieldEnd()
18667 
    iprot.readStructEnd()
18668 
 
18669 
  def write(self, oprot):
18670 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18671 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18672 
      return
18673 
    oprot.writeStructBegin('markReturnOrdersAsPickedUp_args')
18674 
    if self.providerId is not None:
18675 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
18676 
      oprot.writeI64(self.providerId)
18677 
      oprot.writeFieldEnd()
18678 
    if self.pickupDetails is not None:
18679 
      oprot.writeFieldBegin('pickupDetails', TType.MAP, 2)
18680 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.pickupDetails))
6188 rajveer 18681 
      for kiter430,viter431 in self.pickupDetails.items():
18682 
        oprot.writeString(kiter430)
18683 
        oprot.writeString(viter431)
4741 phani.kuma 18684 
      oprot.writeMapEnd()
18685 
      oprot.writeFieldEnd()
18686 
    oprot.writeFieldStop()
18687 
    oprot.writeStructEnd()
18688 
 
18689 
  def validate(self):
18690 
    return
18691 
 
18692 
 
18693 
  def __repr__(self):
18694 
    L = ['%s=%r' % (key, value)
18695 
      for key, value in self.__dict__.iteritems()]
18696 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18697 
 
18698 
  def __eq__(self, other):
18699 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18700 
 
18701 
  def __ne__(self, other):
18702 
    return not (self == other)
18703 
 
18704 
class markReturnOrdersAsPickedUp_result:
4910 phani.kuma 18705 
 
18706 
  thrift_spec = (
18707 
  )
18708 
 
18709 
  def read(self, iprot):
18710 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18711 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18712 
      return
18713 
    iprot.readStructBegin()
18714 
    while True:
18715 
      (fname, ftype, fid) = iprot.readFieldBegin()
18716 
      if ftype == TType.STOP:
18717 
        break
18718 
      else:
18719 
        iprot.skip(ftype)
18720 
      iprot.readFieldEnd()
18721 
    iprot.readStructEnd()
18722 
 
18723 
  def write(self, oprot):
18724 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18725 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18726 
      return
18727 
    oprot.writeStructBegin('markReturnOrdersAsPickedUp_result')
18728 
    oprot.writeFieldStop()
18729 
    oprot.writeStructEnd()
18730 
 
18731 
  def validate(self):
18732 
    return
18733 
 
18734 
 
18735 
  def __repr__(self):
18736 
    L = ['%s=%r' % (key, value)
18737 
      for key, value in self.__dict__.iteritems()]
18738 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18739 
 
18740 
  def __eq__(self, other):
18741 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18742 
 
18743 
  def __ne__(self, other):
18744 
    return not (self == other)
18745 
 
18746 
class getReturnOrdersNotPickedUp_args:
4741 phani.kuma 18747 
  """
18748 
  Attributes:
4910 phani.kuma 18749 
   - providerId
18750 
  """
18751 
 
18752 
  thrift_spec = (
18753 
    None, # 0
18754 
    (1, TType.I64, 'providerId', None, None, ), # 1
18755 
  )
18756 
 
18757 
  def __init__(self, providerId=None,):
18758 
    self.providerId = providerId
18759 
 
18760 
  def read(self, iprot):
18761 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18762 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18763 
      return
18764 
    iprot.readStructBegin()
18765 
    while True:
18766 
      (fname, ftype, fid) = iprot.readFieldBegin()
18767 
      if ftype == TType.STOP:
18768 
        break
18769 
      if fid == 1:
18770 
        if ftype == TType.I64:
18771 
          self.providerId = iprot.readI64();
18772 
        else:
18773 
          iprot.skip(ftype)
18774 
      else:
18775 
        iprot.skip(ftype)
18776 
      iprot.readFieldEnd()
18777 
    iprot.readStructEnd()
18778 
 
18779 
  def write(self, oprot):
18780 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18781 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18782 
      return
18783 
    oprot.writeStructBegin('getReturnOrdersNotPickedUp_args')
18784 
    if self.providerId is not None:
18785 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
18786 
      oprot.writeI64(self.providerId)
18787 
      oprot.writeFieldEnd()
18788 
    oprot.writeFieldStop()
18789 
    oprot.writeStructEnd()
18790 
 
18791 
  def validate(self):
18792 
    return
18793 
 
18794 
 
18795 
  def __repr__(self):
18796 
    L = ['%s=%r' % (key, value)
18797 
      for key, value in self.__dict__.iteritems()]
18798 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18799 
 
18800 
  def __eq__(self, other):
18801 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18802 
 
18803 
  def __ne__(self, other):
18804 
    return not (self == other)
18805 
 
18806 
class getReturnOrdersNotPickedUp_result:
18807 
  """
18808 
  Attributes:
4741 phani.kuma 18809 
   - success
18810 
  """
18811 
 
18812 
  thrift_spec = (
18813 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
18814 
  )
18815 
 
18816 
  def __init__(self, success=None,):
18817 
    self.success = success
18818 
 
18819 
  def read(self, iprot):
18820 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18821 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18822 
      return
18823 
    iprot.readStructBegin()
18824 
    while True:
18825 
      (fname, ftype, fid) = iprot.readFieldBegin()
18826 
      if ftype == TType.STOP:
18827 
        break
18828 
      if fid == 0:
18829 
        if ftype == TType.LIST:
18830 
          self.success = []
6188 rajveer 18831 
          (_etype435, _size432) = iprot.readListBegin()
18832 
          for _i436 in xrange(_size432):
18833 
            _elem437 = Order()
18834 
            _elem437.read(iprot)
18835 
            self.success.append(_elem437)
4741 phani.kuma 18836 
          iprot.readListEnd()
18837 
        else:
18838 
          iprot.skip(ftype)
18839 
      else:
18840 
        iprot.skip(ftype)
18841 
      iprot.readFieldEnd()
18842 
    iprot.readStructEnd()
18843 
 
18844 
  def write(self, oprot):
18845 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18846 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18847 
      return
4910 phani.kuma 18848 
    oprot.writeStructBegin('getReturnOrdersNotPickedUp_result')
4741 phani.kuma 18849 
    if self.success is not None:
18850 
      oprot.writeFieldBegin('success', TType.LIST, 0)
18851 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 18852 
      for iter438 in self.success:
18853 
        iter438.write(oprot)
4741 phani.kuma 18854 
      oprot.writeListEnd()
18855 
      oprot.writeFieldEnd()
18856 
    oprot.writeFieldStop()
18857 
    oprot.writeStructEnd()
18858 
 
18859 
  def validate(self):
18860 
    return
18861 
 
18862 
 
18863 
  def __repr__(self):
18864 
    L = ['%s=%r' % (key, value)
18865 
      for key, value in self.__dict__.iteritems()]
18866 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18867 
 
18868 
  def __eq__(self, other):
18869 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18870 
 
18871 
  def __ne__(self, other):
18872 
    return not (self == other)
18873 
 
2616 chandransh 18874 
class receiveReturn_args:
2591 chandransh 18875 
  """
18876 
  Attributes:
18877 
   - orderId
4479 rajveer 18878 
   - receiveCondition
2591 chandransh 18879 
  """
2536 chandransh 18880 
 
2591 chandransh 18881 
  thrift_spec = (
18882 
    None, # 0
18883 
    (1, TType.I64, 'orderId', None, None, ), # 1
4479 rajveer 18884 
    (2, TType.I64, 'receiveCondition', None, None, ), # 2
2591 chandransh 18885 
  )
18886 
 
4479 rajveer 18887 
  def __init__(self, orderId=None, receiveCondition=None,):
2591 chandransh 18888 
    self.orderId = orderId
4479 rajveer 18889 
    self.receiveCondition = receiveCondition
2591 chandransh 18890 
 
18891 
  def read(self, iprot):
18892 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18893 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18894 
      return
18895 
    iprot.readStructBegin()
18896 
    while True:
18897 
      (fname, ftype, fid) = iprot.readFieldBegin()
18898 
      if ftype == TType.STOP:
18899 
        break
18900 
      if fid == 1:
18901 
        if ftype == TType.I64:
18902 
          self.orderId = iprot.readI64();
18903 
        else:
18904 
          iprot.skip(ftype)
4479 rajveer 18905 
      elif fid == 2:
18906 
        if ftype == TType.I64:
18907 
          self.receiveCondition = iprot.readI64();
18908 
        else:
18909 
          iprot.skip(ftype)
2591 chandransh 18910 
      else:
18911 
        iprot.skip(ftype)
18912 
      iprot.readFieldEnd()
18913 
    iprot.readStructEnd()
18914 
 
18915 
  def write(self, oprot):
18916 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18917 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18918 
      return
2616 chandransh 18919 
    oprot.writeStructBegin('receiveReturn_args')
3431 rajveer 18920 
    if self.orderId is not None:
2591 chandransh 18921 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
18922 
      oprot.writeI64(self.orderId)
18923 
      oprot.writeFieldEnd()
4479 rajveer 18924 
    if self.receiveCondition is not None:
18925 
      oprot.writeFieldBegin('receiveCondition', TType.I64, 2)
18926 
      oprot.writeI64(self.receiveCondition)
18927 
      oprot.writeFieldEnd()
2591 chandransh 18928 
    oprot.writeFieldStop()
18929 
    oprot.writeStructEnd()
18930 
 
3431 rajveer 18931 
  def validate(self):
18932 
    return
18933 
 
18934 
 
2591 chandransh 18935 
  def __repr__(self):
18936 
    L = ['%s=%r' % (key, value)
18937 
      for key, value in self.__dict__.iteritems()]
18938 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18939 
 
18940 
  def __eq__(self, other):
18941 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18942 
 
18943 
  def __ne__(self, other):
18944 
    return not (self == other)
18945 
 
2616 chandransh 18946 
class receiveReturn_result:
2591 chandransh 18947 
  """
18948 
  Attributes:
18949 
   - success
18950 
   - ex
18951 
  """
18952 
 
18953 
  thrift_spec = (
18954 
    (0, TType.BOOL, 'success', None, None, ), # 0
18955 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
18956 
  )
18957 
 
18958 
  def __init__(self, success=None, ex=None,):
18959 
    self.success = success
18960 
    self.ex = ex
18961 
 
18962 
  def read(self, iprot):
18963 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18964 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18965 
      return
18966 
    iprot.readStructBegin()
18967 
    while True:
18968 
      (fname, ftype, fid) = iprot.readFieldBegin()
18969 
      if ftype == TType.STOP:
18970 
        break
18971 
      if fid == 0:
18972 
        if ftype == TType.BOOL:
18973 
          self.success = iprot.readBool();
18974 
        else:
18975 
          iprot.skip(ftype)
18976 
      elif fid == 1:
18977 
        if ftype == TType.STRUCT:
18978 
          self.ex = TransactionServiceException()
18979 
          self.ex.read(iprot)
18980 
        else:
18981 
          iprot.skip(ftype)
18982 
      else:
18983 
        iprot.skip(ftype)
18984 
      iprot.readFieldEnd()
18985 
    iprot.readStructEnd()
18986 
 
18987 
  def write(self, oprot):
18988 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18989 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18990 
      return
2616 chandransh 18991 
    oprot.writeStructBegin('receiveReturn_result')
3431 rajveer 18992 
    if self.success is not None:
2591 chandransh 18993 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
18994 
      oprot.writeBool(self.success)
18995 
      oprot.writeFieldEnd()
3431 rajveer 18996 
    if self.ex is not None:
2591 chandransh 18997 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
18998 
      self.ex.write(oprot)
18999 
      oprot.writeFieldEnd()
19000 
    oprot.writeFieldStop()
19001 
    oprot.writeStructEnd()
19002 
 
3431 rajveer 19003 
  def validate(self):
19004 
    return
19005 
 
19006 
 
2591 chandransh 19007 
  def __repr__(self):
19008 
    L = ['%s=%r' % (key, value)
19009 
      for key, value in self.__dict__.iteritems()]
19010 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19011 
 
19012 
  def __eq__(self, other):
19013 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19014 
 
19015 
  def __ne__(self, other):
19016 
    return not (self == other)
19017 
 
19018 
class validateDoa_args:
19019 
  """
19020 
  Attributes:
19021 
   - orderId
19022 
   - isValid
19023 
  """
19024 
 
19025 
  thrift_spec = (
19026 
    None, # 0
19027 
    (1, TType.I64, 'orderId', None, None, ), # 1
19028 
    (2, TType.BOOL, 'isValid', None, None, ), # 2
19029 
  )
19030 
 
19031 
  def __init__(self, orderId=None, isValid=None,):
19032 
    self.orderId = orderId
19033 
    self.isValid = isValid
19034 
 
19035 
  def read(self, iprot):
19036 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19037 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19038 
      return
19039 
    iprot.readStructBegin()
19040 
    while True:
19041 
      (fname, ftype, fid) = iprot.readFieldBegin()
19042 
      if ftype == TType.STOP:
19043 
        break
19044 
      if fid == 1:
19045 
        if ftype == TType.I64:
19046 
          self.orderId = iprot.readI64();
19047 
        else:
19048 
          iprot.skip(ftype)
19049 
      elif fid == 2:
19050 
        if ftype == TType.BOOL:
19051 
          self.isValid = iprot.readBool();
19052 
        else:
19053 
          iprot.skip(ftype)
19054 
      else:
19055 
        iprot.skip(ftype)
19056 
      iprot.readFieldEnd()
19057 
    iprot.readStructEnd()
19058 
 
19059 
  def write(self, oprot):
19060 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19061 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19062 
      return
19063 
    oprot.writeStructBegin('validateDoa_args')
3431 rajveer 19064 
    if self.orderId is not None:
2591 chandransh 19065 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
19066 
      oprot.writeI64(self.orderId)
19067 
      oprot.writeFieldEnd()
3431 rajveer 19068 
    if self.isValid is not None:
2591 chandransh 19069 
      oprot.writeFieldBegin('isValid', TType.BOOL, 2)
19070 
      oprot.writeBool(self.isValid)
19071 
      oprot.writeFieldEnd()
19072 
    oprot.writeFieldStop()
19073 
    oprot.writeStructEnd()
19074 
 
3431 rajveer 19075 
  def validate(self):
19076 
    return
19077 
 
19078 
 
2591 chandransh 19079 
  def __repr__(self):
19080 
    L = ['%s=%r' % (key, value)
19081 
      for key, value in self.__dict__.iteritems()]
19082 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19083 
 
19084 
  def __eq__(self, other):
19085 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19086 
 
19087 
  def __ne__(self, other):
19088 
    return not (self == other)
19089 
 
19090 
class validateDoa_result:
19091 
  """
19092 
  Attributes:
19093 
   - success
19094 
   - ex
19095 
  """
19096 
 
19097 
  thrift_spec = (
19098 
    (0, TType.BOOL, 'success', None, None, ), # 0
19099 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
19100 
  )
19101 
 
19102 
  def __init__(self, success=None, ex=None,):
19103 
    self.success = success
19104 
    self.ex = ex
19105 
 
19106 
  def read(self, iprot):
19107 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19108 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19109 
      return
19110 
    iprot.readStructBegin()
19111 
    while True:
19112 
      (fname, ftype, fid) = iprot.readFieldBegin()
19113 
      if ftype == TType.STOP:
19114 
        break
19115 
      if fid == 0:
19116 
        if ftype == TType.BOOL:
19117 
          self.success = iprot.readBool();
19118 
        else:
19119 
          iprot.skip(ftype)
19120 
      elif fid == 1:
19121 
        if ftype == TType.STRUCT:
19122 
          self.ex = TransactionServiceException()
19123 
          self.ex.read(iprot)
19124 
        else:
19125 
          iprot.skip(ftype)
19126 
      else:
19127 
        iprot.skip(ftype)
19128 
      iprot.readFieldEnd()
19129 
    iprot.readStructEnd()
19130 
 
19131 
  def write(self, oprot):
19132 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19133 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19134 
      return
19135 
    oprot.writeStructBegin('validateDoa_result')
3431 rajveer 19136 
    if self.success is not None:
2591 chandransh 19137 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
19138 
      oprot.writeBool(self.success)
19139 
      oprot.writeFieldEnd()
3431 rajveer 19140 
    if self.ex is not None:
2591 chandransh 19141 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
19142 
      self.ex.write(oprot)
19143 
      oprot.writeFieldEnd()
19144 
    oprot.writeFieldStop()
19145 
    oprot.writeStructEnd()
19146 
 
3431 rajveer 19147 
  def validate(self):
19148 
    return
19149 
 
19150 
 
2591 chandransh 19151 
  def __repr__(self):
19152 
    L = ['%s=%r' % (key, value)
19153 
      for key, value in self.__dict__.iteritems()]
19154 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19155 
 
19156 
  def __eq__(self, other):
19157 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19158 
 
19159 
  def __ne__(self, other):
19160 
    return not (self == other)
19161 
 
4495 rajveer 19162 
class validateReturnProduct_args:
19163 
  """
19164 
  Attributes:
19165 
   - orderId
19166 
   - isUsable
19167 
  """
19168 
 
19169 
  thrift_spec = (
19170 
    None, # 0
19171 
    (1, TType.I64, 'orderId', None, None, ), # 1
19172 
    (2, TType.BOOL, 'isUsable', None, None, ), # 2
19173 
  )
19174 
 
19175 
  def __init__(self, orderId=None, isUsable=None,):
19176 
    self.orderId = orderId
19177 
    self.isUsable = isUsable
19178 
 
19179 
  def read(self, iprot):
19180 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19181 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19182 
      return
19183 
    iprot.readStructBegin()
19184 
    while True:
19185 
      (fname, ftype, fid) = iprot.readFieldBegin()
19186 
      if ftype == TType.STOP:
19187 
        break
19188 
      if fid == 1:
19189 
        if ftype == TType.I64:
19190 
          self.orderId = iprot.readI64();
19191 
        else:
19192 
          iprot.skip(ftype)
19193 
      elif fid == 2:
19194 
        if ftype == TType.BOOL:
19195 
          self.isUsable = iprot.readBool();
19196 
        else:
19197 
          iprot.skip(ftype)
19198 
      else:
19199 
        iprot.skip(ftype)
19200 
      iprot.readFieldEnd()
19201 
    iprot.readStructEnd()
19202 
 
19203 
  def write(self, oprot):
19204 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19205 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19206 
      return
19207 
    oprot.writeStructBegin('validateReturnProduct_args')
19208 
    if self.orderId is not None:
19209 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
19210 
      oprot.writeI64(self.orderId)
19211 
      oprot.writeFieldEnd()
19212 
    if self.isUsable is not None:
19213 
      oprot.writeFieldBegin('isUsable', TType.BOOL, 2)
19214 
      oprot.writeBool(self.isUsable)
19215 
      oprot.writeFieldEnd()
19216 
    oprot.writeFieldStop()
19217 
    oprot.writeStructEnd()
19218 
 
19219 
  def validate(self):
19220 
    return
19221 
 
19222 
 
19223 
  def __repr__(self):
19224 
    L = ['%s=%r' % (key, value)
19225 
      for key, value in self.__dict__.iteritems()]
19226 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19227 
 
19228 
  def __eq__(self, other):
19229 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19230 
 
19231 
  def __ne__(self, other):
19232 
    return not (self == other)
19233 
 
19234 
class validateReturnProduct_result:
19235 
  """
19236 
  Attributes:
19237 
   - success
19238 
   - ex
19239 
  """
19240 
 
19241 
  thrift_spec = (
19242 
    (0, TType.BOOL, 'success', None, None, ), # 0
19243 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
19244 
  )
19245 
 
19246 
  def __init__(self, success=None, ex=None,):
19247 
    self.success = success
19248 
    self.ex = ex
19249 
 
19250 
  def read(self, iprot):
19251 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19252 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19253 
      return
19254 
    iprot.readStructBegin()
19255 
    while True:
19256 
      (fname, ftype, fid) = iprot.readFieldBegin()
19257 
      if ftype == TType.STOP:
19258 
        break
19259 
      if fid == 0:
19260 
        if ftype == TType.BOOL:
19261 
          self.success = iprot.readBool();
19262 
        else:
19263 
          iprot.skip(ftype)
19264 
      elif fid == 1:
19265 
        if ftype == TType.STRUCT:
19266 
          self.ex = TransactionServiceException()
19267 
          self.ex.read(iprot)
19268 
        else:
19269 
          iprot.skip(ftype)
19270 
      else:
19271 
        iprot.skip(ftype)
19272 
      iprot.readFieldEnd()
19273 
    iprot.readStructEnd()
19274 
 
19275 
  def write(self, oprot):
19276 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19277 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19278 
      return
19279 
    oprot.writeStructBegin('validateReturnProduct_result')
19280 
    if self.success is not None:
19281 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
19282 
      oprot.writeBool(self.success)
19283 
      oprot.writeFieldEnd()
19284 
    if self.ex is not None:
19285 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
19286 
      self.ex.write(oprot)
19287 
      oprot.writeFieldEnd()
19288 
    oprot.writeFieldStop()
19289 
    oprot.writeStructEnd()
19290 
 
19291 
  def validate(self):
19292 
    return
19293 
 
19294 
 
19295 
  def __repr__(self):
19296 
    L = ['%s=%r' % (key, value)
19297 
      for key, value in self.__dict__.iteritems()]
19298 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19299 
 
19300 
  def __eq__(self, other):
19301 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19302 
 
19303 
  def __ne__(self, other):
19304 
    return not (self == other)
19305 
 
2616 chandransh 19306 
class reshipOrder_args:
19307 
  """
19308 
  Attributes:
19309 
   - orderId
19310 
  """
2591 chandransh 19311 
 
2616 chandransh 19312 
  thrift_spec = (
19313 
    None, # 0
19314 
    (1, TType.I64, 'orderId', None, None, ), # 1
19315 
  )
19316 
 
19317 
  def __init__(self, orderId=None,):
19318 
    self.orderId = orderId
19319 
 
19320 
  def read(self, iprot):
19321 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19322 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19323 
      return
19324 
    iprot.readStructBegin()
19325 
    while True:
19326 
      (fname, ftype, fid) = iprot.readFieldBegin()
19327 
      if ftype == TType.STOP:
19328 
        break
19329 
      if fid == 1:
19330 
        if ftype == TType.I64:
19331 
          self.orderId = iprot.readI64();
19332 
        else:
19333 
          iprot.skip(ftype)
19334 
      else:
19335 
        iprot.skip(ftype)
19336 
      iprot.readFieldEnd()
19337 
    iprot.readStructEnd()
19338 
 
19339 
  def write(self, oprot):
19340 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19341 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19342 
      return
19343 
    oprot.writeStructBegin('reshipOrder_args')
3431 rajveer 19344 
    if self.orderId is not None:
2616 chandransh 19345 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
19346 
      oprot.writeI64(self.orderId)
19347 
      oprot.writeFieldEnd()
19348 
    oprot.writeFieldStop()
19349 
    oprot.writeStructEnd()
19350 
 
3431 rajveer 19351 
  def validate(self):
19352 
    return
19353 
 
19354 
 
2616 chandransh 19355 
  def __repr__(self):
19356 
    L = ['%s=%r' % (key, value)
19357 
      for key, value in self.__dict__.iteritems()]
19358 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19359 
 
19360 
  def __eq__(self, other):
19361 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19362 
 
19363 
  def __ne__(self, other):
19364 
    return not (self == other)
19365 
 
19366 
class reshipOrder_result:
19367 
  """
19368 
  Attributes:
19369 
   - success
19370 
   - ex
19371 
  """
19372 
 
19373 
  thrift_spec = (
19374 
    (0, TType.I64, 'success', None, None, ), # 0
19375 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
19376 
  )
19377 
 
19378 
  def __init__(self, success=None, ex=None,):
19379 
    self.success = success
19380 
    self.ex = ex
19381 
 
19382 
  def read(self, iprot):
19383 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19384 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19385 
      return
19386 
    iprot.readStructBegin()
19387 
    while True:
19388 
      (fname, ftype, fid) = iprot.readFieldBegin()
19389 
      if ftype == TType.STOP:
19390 
        break
19391 
      if fid == 0:
19392 
        if ftype == TType.I64:
19393 
          self.success = iprot.readI64();
19394 
        else:
19395 
          iprot.skip(ftype)
19396 
      elif fid == 1:
19397 
        if ftype == TType.STRUCT:
19398 
          self.ex = TransactionServiceException()
19399 
          self.ex.read(iprot)
19400 
        else:
19401 
          iprot.skip(ftype)
19402 
      else:
19403 
        iprot.skip(ftype)
19404 
      iprot.readFieldEnd()
19405 
    iprot.readStructEnd()
19406 
 
19407 
  def write(self, oprot):
19408 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19409 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19410 
      return
19411 
    oprot.writeStructBegin('reshipOrder_result')
3431 rajveer 19412 
    if self.success is not None:
2616 chandransh 19413 
      oprot.writeFieldBegin('success', TType.I64, 0)
19414 
      oprot.writeI64(self.success)
19415 
      oprot.writeFieldEnd()
3431 rajveer 19416 
    if self.ex is not None:
2616 chandransh 19417 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
19418 
      self.ex.write(oprot)
19419 
      oprot.writeFieldEnd()
19420 
    oprot.writeFieldStop()
19421 
    oprot.writeStructEnd()
19422 
 
3431 rajveer 19423 
  def validate(self):
19424 
    return
19425 
 
19426 
 
2616 chandransh 19427 
  def __repr__(self):
19428 
    L = ['%s=%r' % (key, value)
19429 
      for key, value in self.__dict__.iteritems()]
19430 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19431 
 
19432 
  def __eq__(self, other):
19433 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19434 
 
19435 
  def __ne__(self, other):
19436 
    return not (self == other)
19437 
 
19438 
class refundOrder_args:
19439 
  """
19440 
  Attributes:
19441 
   - orderId
3226 chandransh 19442 
   - refundedBy
19443 
   - reason
2616 chandransh 19444 
  """
19445 
 
19446 
  thrift_spec = (
19447 
    None, # 0
19448 
    (1, TType.I64, 'orderId', None, None, ), # 1
3226 chandransh 19449 
    (2, TType.STRING, 'refundedBy', None, None, ), # 2
19450 
    (3, TType.STRING, 'reason', None, None, ), # 3
2616 chandransh 19451 
  )
19452 
 
3226 chandransh 19453 
  def __init__(self, orderId=None, refundedBy=None, reason=None,):
2616 chandransh 19454 
    self.orderId = orderId
3226 chandransh 19455 
    self.refundedBy = refundedBy
19456 
    self.reason = reason
2616 chandransh 19457 
 
19458 
  def read(self, iprot):
19459 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19460 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19461 
      return
19462 
    iprot.readStructBegin()
19463 
    while True:
19464 
      (fname, ftype, fid) = iprot.readFieldBegin()
19465 
      if ftype == TType.STOP:
19466 
        break
19467 
      if fid == 1:
19468 
        if ftype == TType.I64:
19469 
          self.orderId = iprot.readI64();
19470 
        else:
19471 
          iprot.skip(ftype)
3226 chandransh 19472 
      elif fid == 2:
19473 
        if ftype == TType.STRING:
19474 
          self.refundedBy = iprot.readString();
19475 
        else:
19476 
          iprot.skip(ftype)
19477 
      elif fid == 3:
19478 
        if ftype == TType.STRING:
19479 
          self.reason = iprot.readString();
19480 
        else:
19481 
          iprot.skip(ftype)
2616 chandransh 19482 
      else:
19483 
        iprot.skip(ftype)
19484 
      iprot.readFieldEnd()
19485 
    iprot.readStructEnd()
19486 
 
19487 
  def write(self, oprot):
19488 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19489 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19490 
      return
19491 
    oprot.writeStructBegin('refundOrder_args')
3431 rajveer 19492 
    if self.orderId is not None:
2616 chandransh 19493 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
19494 
      oprot.writeI64(self.orderId)
19495 
      oprot.writeFieldEnd()
3431 rajveer 19496 
    if self.refundedBy is not None:
3226 chandransh 19497 
      oprot.writeFieldBegin('refundedBy', TType.STRING, 2)
19498 
      oprot.writeString(self.refundedBy)
19499 
      oprot.writeFieldEnd()
3431 rajveer 19500 
    if self.reason is not None:
3226 chandransh 19501 
      oprot.writeFieldBegin('reason', TType.STRING, 3)
19502 
      oprot.writeString(self.reason)
19503 
      oprot.writeFieldEnd()
2616 chandransh 19504 
    oprot.writeFieldStop()
19505 
    oprot.writeStructEnd()
19506 
 
3431 rajveer 19507 
  def validate(self):
19508 
    return
19509 
 
19510 
 
2616 chandransh 19511 
  def __repr__(self):
19512 
    L = ['%s=%r' % (key, value)
19513 
      for key, value in self.__dict__.iteritems()]
19514 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19515 
 
19516 
  def __eq__(self, other):
19517 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19518 
 
19519 
  def __ne__(self, other):
19520 
    return not (self == other)
19521 
 
19522 
class refundOrder_result:
19523 
  """
19524 
  Attributes:
19525 
   - success
19526 
   - ex
19527 
  """
19528 
 
19529 
  thrift_spec = (
19530 
    (0, TType.BOOL, 'success', None, None, ), # 0
19531 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
19532 
  )
19533 
 
19534 
  def __init__(self, success=None, ex=None,):
19535 
    self.success = success
19536 
    self.ex = ex
19537 
 
19538 
  def read(self, iprot):
19539 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19540 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19541 
      return
19542 
    iprot.readStructBegin()
19543 
    while True:
19544 
      (fname, ftype, fid) = iprot.readFieldBegin()
19545 
      if ftype == TType.STOP:
19546 
        break
19547 
      if fid == 0:
19548 
        if ftype == TType.BOOL:
19549 
          self.success = iprot.readBool();
19550 
        else:
19551 
          iprot.skip(ftype)
19552 
      elif fid == 1:
19553 
        if ftype == TType.STRUCT:
19554 
          self.ex = TransactionServiceException()
19555 
          self.ex.read(iprot)
19556 
        else:
19557 
          iprot.skip(ftype)
19558 
      else:
19559 
        iprot.skip(ftype)
19560 
      iprot.readFieldEnd()
19561 
    iprot.readStructEnd()
19562 
 
19563 
  def write(self, oprot):
19564 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19565 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19566 
      return
19567 
    oprot.writeStructBegin('refundOrder_result')
3431 rajveer 19568 
    if self.success is not None:
2616 chandransh 19569 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
19570 
      oprot.writeBool(self.success)
19571 
      oprot.writeFieldEnd()
3431 rajveer 19572 
    if self.ex is not None:
2616 chandransh 19573 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
19574 
      self.ex.write(oprot)
19575 
      oprot.writeFieldEnd()
19576 
    oprot.writeFieldStop()
19577 
    oprot.writeStructEnd()
19578 
 
3431 rajveer 19579 
  def validate(self):
19580 
    return
19581 
 
19582 
 
2616 chandransh 19583 
  def __repr__(self):
19584 
    L = ['%s=%r' % (key, value)
19585 
      for key, value in self.__dict__.iteritems()]
19586 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19587 
 
19588 
  def __eq__(self, other):
19589 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19590 
 
19591 
  def __ne__(self, other):
19592 
    return not (self == other)
19593 
 
2690 chandransh 19594 
class getReturnOrders_args:
19595 
  """
19596 
  Attributes:
19597 
   - warehouseId
19598 
   - fromDate
19599 
   - toDate
19600 
  """
2616 chandransh 19601 
 
2690 chandransh 19602 
  thrift_spec = (
19603 
    None, # 0
19604 
    (1, TType.I64, 'warehouseId', None, None, ), # 1
19605 
    (2, TType.I64, 'fromDate', None, None, ), # 2
19606 
    (3, TType.I64, 'toDate', None, None, ), # 3
19607 
  )
19608 
 
19609 
  def __init__(self, warehouseId=None, fromDate=None, toDate=None,):
19610 
    self.warehouseId = warehouseId
19611 
    self.fromDate = fromDate
19612 
    self.toDate = toDate
19613 
 
19614 
  def read(self, iprot):
19615 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19616 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19617 
      return
19618 
    iprot.readStructBegin()
19619 
    while True:
19620 
      (fname, ftype, fid) = iprot.readFieldBegin()
19621 
      if ftype == TType.STOP:
19622 
        break
19623 
      if fid == 1:
19624 
        if ftype == TType.I64:
19625 
          self.warehouseId = iprot.readI64();
19626 
        else:
19627 
          iprot.skip(ftype)
19628 
      elif fid == 2:
19629 
        if ftype == TType.I64:
19630 
          self.fromDate = iprot.readI64();
19631 
        else:
19632 
          iprot.skip(ftype)
19633 
      elif fid == 3:
19634 
        if ftype == TType.I64:
19635 
          self.toDate = iprot.readI64();
19636 
        else:
19637 
          iprot.skip(ftype)
19638 
      else:
19639 
        iprot.skip(ftype)
19640 
      iprot.readFieldEnd()
19641 
    iprot.readStructEnd()
19642 
 
19643 
  def write(self, oprot):
19644 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19645 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19646 
      return
19647 
    oprot.writeStructBegin('getReturnOrders_args')
3431 rajveer 19648 
    if self.warehouseId is not None:
2690 chandransh 19649 
      oprot.writeFieldBegin('warehouseId', TType.I64, 1)
19650 
      oprot.writeI64(self.warehouseId)
19651 
      oprot.writeFieldEnd()
3431 rajveer 19652 
    if self.fromDate is not None:
2690 chandransh 19653 
      oprot.writeFieldBegin('fromDate', TType.I64, 2)
19654 
      oprot.writeI64(self.fromDate)
19655 
      oprot.writeFieldEnd()
3431 rajveer 19656 
    if self.toDate is not None:
2690 chandransh 19657 
      oprot.writeFieldBegin('toDate', TType.I64, 3)
19658 
      oprot.writeI64(self.toDate)
19659 
      oprot.writeFieldEnd()
19660 
    oprot.writeFieldStop()
19661 
    oprot.writeStructEnd()
19662 
 
3431 rajveer 19663 
  def validate(self):
19664 
    return
19665 
 
19666 
 
2690 chandransh 19667 
  def __repr__(self):
19668 
    L = ['%s=%r' % (key, value)
19669 
      for key, value in self.__dict__.iteritems()]
19670 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19671 
 
19672 
  def __eq__(self, other):
19673 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19674 
 
19675 
  def __ne__(self, other):
19676 
    return not (self == other)
19677 
 
19678 
class getReturnOrders_result:
19679 
  """
19680 
  Attributes:
19681 
   - success
19682 
  """
19683 
 
19684 
  thrift_spec = (
19685 
    (0, TType.LIST, 'success', (TType.STRUCT,(ReturnOrder, ReturnOrder.thrift_spec)), None, ), # 0
19686 
  )
19687 
 
19688 
  def __init__(self, success=None,):
19689 
    self.success = success
19690 
 
19691 
  def read(self, iprot):
19692 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19693 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19694 
      return
19695 
    iprot.readStructBegin()
19696 
    while True:
19697 
      (fname, ftype, fid) = iprot.readFieldBegin()
19698 
      if ftype == TType.STOP:
19699 
        break
19700 
      if fid == 0:
19701 
        if ftype == TType.LIST:
19702 
          self.success = []
6188 rajveer 19703 
          (_etype442, _size439) = iprot.readListBegin()
19704 
          for _i443 in xrange(_size439):
19705 
            _elem444 = ReturnOrder()
19706 
            _elem444.read(iprot)
19707 
            self.success.append(_elem444)
2690 chandransh 19708 
          iprot.readListEnd()
19709 
        else:
19710 
          iprot.skip(ftype)
19711 
      else:
19712 
        iprot.skip(ftype)
19713 
      iprot.readFieldEnd()
19714 
    iprot.readStructEnd()
19715 
 
19716 
  def write(self, oprot):
19717 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19718 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19719 
      return
19720 
    oprot.writeStructBegin('getReturnOrders_result')
3431 rajveer 19721 
    if self.success is not None:
2690 chandransh 19722 
      oprot.writeFieldBegin('success', TType.LIST, 0)
19723 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 19724 
      for iter445 in self.success:
19725 
        iter445.write(oprot)
2690 chandransh 19726 
      oprot.writeListEnd()
19727 
      oprot.writeFieldEnd()
19728 
    oprot.writeFieldStop()
19729 
    oprot.writeStructEnd()
19730 
 
3431 rajveer 19731 
  def validate(self):
19732 
    return
19733 
 
19734 
 
2690 chandransh 19735 
  def __repr__(self):
19736 
    L = ['%s=%r' % (key, value)
19737 
      for key, value in self.__dict__.iteritems()]
19738 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19739 
 
19740 
  def __eq__(self, other):
19741 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19742 
 
19743 
  def __ne__(self, other):
19744 
    return not (self == other)
19745 
 
5481 phani.kuma 19746 
class getAllReturnOrders_args:
19747 
  """
19748 
  Attributes:
19749 
   - onlyNotProcessed
19750 
   - fromDate
19751 
   - toDate
19752 
  """
19753 
 
19754 
  thrift_spec = (
19755 
    None, # 0
19756 
    (1, TType.BOOL, 'onlyNotProcessed', None, None, ), # 1
19757 
    (2, TType.I64, 'fromDate', None, None, ), # 2
19758 
    (3, TType.I64, 'toDate', None, None, ), # 3
19759 
  )
19760 
 
19761 
  def __init__(self, onlyNotProcessed=None, fromDate=None, toDate=None,):
19762 
    self.onlyNotProcessed = onlyNotProcessed
19763 
    self.fromDate = fromDate
19764 
    self.toDate = toDate
19765 
 
19766 
  def read(self, iprot):
19767 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19768 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19769 
      return
19770 
    iprot.readStructBegin()
19771 
    while True:
19772 
      (fname, ftype, fid) = iprot.readFieldBegin()
19773 
      if ftype == TType.STOP:
19774 
        break
19775 
      if fid == 1:
19776 
        if ftype == TType.BOOL:
19777 
          self.onlyNotProcessed = iprot.readBool();
19778 
        else:
19779 
          iprot.skip(ftype)
19780 
      elif fid == 2:
19781 
        if ftype == TType.I64:
19782 
          self.fromDate = iprot.readI64();
19783 
        else:
19784 
          iprot.skip(ftype)
19785 
      elif fid == 3:
19786 
        if ftype == TType.I64:
19787 
          self.toDate = iprot.readI64();
19788 
        else:
19789 
          iprot.skip(ftype)
19790 
      else:
19791 
        iprot.skip(ftype)
19792 
      iprot.readFieldEnd()
19793 
    iprot.readStructEnd()
19794 
 
19795 
  def write(self, oprot):
19796 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19797 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19798 
      return
19799 
    oprot.writeStructBegin('getAllReturnOrders_args')
19800 
    if self.onlyNotProcessed is not None:
19801 
      oprot.writeFieldBegin('onlyNotProcessed', TType.BOOL, 1)
19802 
      oprot.writeBool(self.onlyNotProcessed)
19803 
      oprot.writeFieldEnd()
19804 
    if self.fromDate is not None:
19805 
      oprot.writeFieldBegin('fromDate', TType.I64, 2)
19806 
      oprot.writeI64(self.fromDate)
19807 
      oprot.writeFieldEnd()
19808 
    if self.toDate is not None:
19809 
      oprot.writeFieldBegin('toDate', TType.I64, 3)
19810 
      oprot.writeI64(self.toDate)
19811 
      oprot.writeFieldEnd()
19812 
    oprot.writeFieldStop()
19813 
    oprot.writeStructEnd()
19814 
 
19815 
  def validate(self):
19816 
    return
19817 
 
19818 
 
19819 
  def __repr__(self):
19820 
    L = ['%s=%r' % (key, value)
19821 
      for key, value in self.__dict__.iteritems()]
19822 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19823 
 
19824 
  def __eq__(self, other):
19825 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19826 
 
19827 
  def __ne__(self, other):
19828 
    return not (self == other)
19829 
 
19830 
class getAllReturnOrders_result:
19831 
  """
19832 
  Attributes:
19833 
   - success
19834 
  """
19835 
 
19836 
  thrift_spec = (
19837 
    (0, TType.LIST, 'success', (TType.STRUCT,(ReturnOrder, ReturnOrder.thrift_spec)), None, ), # 0
19838 
  )
19839 
 
19840 
  def __init__(self, success=None,):
19841 
    self.success = success
19842 
 
19843 
  def read(self, iprot):
19844 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19845 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19846 
      return
19847 
    iprot.readStructBegin()
19848 
    while True:
19849 
      (fname, ftype, fid) = iprot.readFieldBegin()
19850 
      if ftype == TType.STOP:
19851 
        break
19852 
      if fid == 0:
19853 
        if ftype == TType.LIST:
19854 
          self.success = []
6188 rajveer 19855 
          (_etype449, _size446) = iprot.readListBegin()
19856 
          for _i450 in xrange(_size446):
19857 
            _elem451 = ReturnOrder()
19858 
            _elem451.read(iprot)
19859 
            self.success.append(_elem451)
5481 phani.kuma 19860 
          iprot.readListEnd()
19861 
        else:
19862 
          iprot.skip(ftype)
19863 
      else:
19864 
        iprot.skip(ftype)
19865 
      iprot.readFieldEnd()
19866 
    iprot.readStructEnd()
19867 
 
19868 
  def write(self, oprot):
19869 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19870 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19871 
      return
19872 
    oprot.writeStructBegin('getAllReturnOrders_result')
19873 
    if self.success is not None:
19874 
      oprot.writeFieldBegin('success', TType.LIST, 0)
19875 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 19876 
      for iter452 in self.success:
19877 
        iter452.write(oprot)
5481 phani.kuma 19878 
      oprot.writeListEnd()
19879 
      oprot.writeFieldEnd()
19880 
    oprot.writeFieldStop()
19881 
    oprot.writeStructEnd()
19882 
 
19883 
  def validate(self):
19884 
    return
19885 
 
19886 
 
19887 
  def __repr__(self):
19888 
    L = ['%s=%r' % (key, value)
19889 
      for key, value in self.__dict__.iteritems()]
19890 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19891 
 
19892 
  def __eq__(self, other):
19893 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19894 
 
19895 
  def __ne__(self, other):
19896 
    return not (self == other)
19897 
 
2700 chandransh 19898 
class getReturnOrder_args:
19899 
  """
19900 
  Attributes:
19901 
   - id
19902 
  """
19903 
 
19904 
  thrift_spec = (
19905 
    None, # 0
19906 
    (1, TType.I64, 'id', None, None, ), # 1
19907 
  )
19908 
 
19909 
  def __init__(self, id=None,):
19910 
    self.id = id
19911 
 
19912 
  def read(self, iprot):
19913 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19914 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19915 
      return
19916 
    iprot.readStructBegin()
19917 
    while True:
19918 
      (fname, ftype, fid) = iprot.readFieldBegin()
19919 
      if ftype == TType.STOP:
19920 
        break
19921 
      if fid == 1:
19922 
        if ftype == TType.I64:
19923 
          self.id = iprot.readI64();
19924 
        else:
19925 
          iprot.skip(ftype)
19926 
      else:
19927 
        iprot.skip(ftype)
19928 
      iprot.readFieldEnd()
19929 
    iprot.readStructEnd()
19930 
 
19931 
  def write(self, oprot):
19932 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19933 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19934 
      return
19935 
    oprot.writeStructBegin('getReturnOrder_args')
3431 rajveer 19936 
    if self.id is not None:
2700 chandransh 19937 
      oprot.writeFieldBegin('id', TType.I64, 1)
19938 
      oprot.writeI64(self.id)
19939 
      oprot.writeFieldEnd()
19940 
    oprot.writeFieldStop()
19941 
    oprot.writeStructEnd()
19942 
 
3431 rajveer 19943 
  def validate(self):
19944 
    return
19945 
 
19946 
 
2700 chandransh 19947 
  def __repr__(self):
19948 
    L = ['%s=%r' % (key, value)
19949 
      for key, value in self.__dict__.iteritems()]
19950 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19951 
 
19952 
  def __eq__(self, other):
19953 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19954 
 
19955 
  def __ne__(self, other):
19956 
    return not (self == other)
19957 
 
19958 
class getReturnOrder_result:
19959 
  """
19960 
  Attributes:
19961 
   - success
19962 
   - ex
19963 
  """
19964 
 
19965 
  thrift_spec = (
19966 
    (0, TType.STRUCT, 'success', (ReturnOrder, ReturnOrder.thrift_spec), None, ), # 0
19967 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
19968 
  )
19969 
 
19970 
  def __init__(self, success=None, ex=None,):
19971 
    self.success = success
19972 
    self.ex = ex
19973 
 
19974 
  def read(self, iprot):
19975 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19976 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19977 
      return
19978 
    iprot.readStructBegin()
19979 
    while True:
19980 
      (fname, ftype, fid) = iprot.readFieldBegin()
19981 
      if ftype == TType.STOP:
19982 
        break
19983 
      if fid == 0:
19984 
        if ftype == TType.STRUCT:
19985 
          self.success = ReturnOrder()
19986 
          self.success.read(iprot)
19987 
        else:
19988 
          iprot.skip(ftype)
19989 
      elif fid == 1:
19990 
        if ftype == TType.STRUCT:
19991 
          self.ex = TransactionServiceException()
19992 
          self.ex.read(iprot)
19993 
        else:
19994 
          iprot.skip(ftype)
19995 
      else:
19996 
        iprot.skip(ftype)
19997 
      iprot.readFieldEnd()
19998 
    iprot.readStructEnd()
19999 
 
20000 
  def write(self, oprot):
20001 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20002 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20003 
      return
20004 
    oprot.writeStructBegin('getReturnOrder_result')
3431 rajveer 20005 
    if self.success is not None:
2700 chandransh 20006 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
20007 
      self.success.write(oprot)
20008 
      oprot.writeFieldEnd()
3431 rajveer 20009 
    if self.ex is not None:
2700 chandransh 20010 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
20011 
      self.ex.write(oprot)
20012 
      oprot.writeFieldEnd()
20013 
    oprot.writeFieldStop()
20014 
    oprot.writeStructEnd()
20015 
 
3431 rajveer 20016 
  def validate(self):
20017 
    return
20018 
 
20019 
 
2700 chandransh 20020 
  def __repr__(self):
20021 
    L = ['%s=%r' % (key, value)
20022 
      for key, value in self.__dict__.iteritems()]
20023 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20024 
 
20025 
  def __eq__(self, other):
20026 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20027 
 
20028 
  def __ne__(self, other):
20029 
    return not (self == other)
20030 
 
2690 chandransh 20031 
class processReturn_args:
20032 
  """
20033 
  Attributes:
20034 
   - returnOrderId
20035 
  """
20036 
 
20037 
  thrift_spec = (
20038 
    None, # 0
20039 
    (1, TType.I64, 'returnOrderId', None, None, ), # 1
20040 
  )
20041 
 
20042 
  def __init__(self, returnOrderId=None,):
20043 
    self.returnOrderId = returnOrderId
20044 
 
20045 
  def read(self, iprot):
20046 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20047 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20048 
      return
20049 
    iprot.readStructBegin()
20050 
    while True:
20051 
      (fname, ftype, fid) = iprot.readFieldBegin()
20052 
      if ftype == TType.STOP:
20053 
        break
20054 
      if fid == 1:
20055 
        if ftype == TType.I64:
20056 
          self.returnOrderId = iprot.readI64();
20057 
        else:
20058 
          iprot.skip(ftype)
20059 
      else:
20060 
        iprot.skip(ftype)
20061 
      iprot.readFieldEnd()
20062 
    iprot.readStructEnd()
20063 
 
20064 
  def write(self, oprot):
20065 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20066 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20067 
      return
20068 
    oprot.writeStructBegin('processReturn_args')
3431 rajveer 20069 
    if self.returnOrderId is not None:
2690 chandransh 20070 
      oprot.writeFieldBegin('returnOrderId', TType.I64, 1)
20071 
      oprot.writeI64(self.returnOrderId)
20072 
      oprot.writeFieldEnd()
20073 
    oprot.writeFieldStop()
20074 
    oprot.writeStructEnd()
20075 
 
3431 rajveer 20076 
  def validate(self):
20077 
    return
20078 
 
20079 
 
2690 chandransh 20080 
  def __repr__(self):
20081 
    L = ['%s=%r' % (key, value)
20082 
      for key, value in self.__dict__.iteritems()]
20083 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20084 
 
20085 
  def __eq__(self, other):
20086 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20087 
 
20088 
  def __ne__(self, other):
20089 
    return not (self == other)
20090 
 
20091 
class processReturn_result:
20092 
  """
20093 
  Attributes:
20094 
   - ex
20095 
  """
20096 
 
20097 
  thrift_spec = (
20098 
    None, # 0
20099 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
20100 
  )
20101 
 
20102 
  def __init__(self, ex=None,):
20103 
    self.ex = ex
20104 
 
20105 
  def read(self, iprot):
20106 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20107 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20108 
      return
20109 
    iprot.readStructBegin()
20110 
    while True:
20111 
      (fname, ftype, fid) = iprot.readFieldBegin()
20112 
      if ftype == TType.STOP:
20113 
        break
20114 
      if fid == 1:
20115 
        if ftype == TType.STRUCT:
20116 
          self.ex = TransactionServiceException()
20117 
          self.ex.read(iprot)
20118 
        else:
20119 
          iprot.skip(ftype)
20120 
      else:
20121 
        iprot.skip(ftype)
20122 
      iprot.readFieldEnd()
20123 
    iprot.readStructEnd()
20124 
 
20125 
  def write(self, oprot):
20126 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20127 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20128 
      return
20129 
    oprot.writeStructBegin('processReturn_result')
3431 rajveer 20130 
    if self.ex is not None:
2690 chandransh 20131 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
20132 
      self.ex.write(oprot)
20133 
      oprot.writeFieldEnd()
20134 
    oprot.writeFieldStop()
20135 
    oprot.writeStructEnd()
20136 
 
3431 rajveer 20137 
  def validate(self):
20138 
    return
20139 
 
20140 
 
2690 chandransh 20141 
  def __repr__(self):
20142 
    L = ['%s=%r' % (key, value)
20143 
      for key, value in self.__dict__.iteritems()]
20144 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20145 
 
20146 
  def __eq__(self, other):
20147 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20148 
 
20149 
  def __ne__(self, other):
20150 
    return not (self == other)
20151 
 
3451 chandransh 20152 
class updateWeight_args:
20153 
  """
20154 
  Attributes:
20155 
   - orderId
20156 
   - weight
20157 
  """
20158 
 
20159 
  thrift_spec = (
20160 
    None, # 0
20161 
    (1, TType.I64, 'orderId', None, None, ), # 1
20162 
    (2, TType.DOUBLE, 'weight', None, None, ), # 2
20163 
  )
20164 
 
20165 
  def __init__(self, orderId=None, weight=None,):
20166 
    self.orderId = orderId
20167 
    self.weight = weight
20168 
 
20169 
  def read(self, iprot):
20170 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20171 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20172 
      return
20173 
    iprot.readStructBegin()
20174 
    while True:
20175 
      (fname, ftype, fid) = iprot.readFieldBegin()
20176 
      if ftype == TType.STOP:
20177 
        break
20178 
      if fid == 1:
20179 
        if ftype == TType.I64:
20180 
          self.orderId = iprot.readI64();
20181 
        else:
20182 
          iprot.skip(ftype)
20183 
      elif fid == 2:
20184 
        if ftype == TType.DOUBLE:
20185 
          self.weight = iprot.readDouble();
20186 
        else:
20187 
          iprot.skip(ftype)
20188 
      else:
20189 
        iprot.skip(ftype)
20190 
      iprot.readFieldEnd()
20191 
    iprot.readStructEnd()
20192 
 
20193 
  def write(self, oprot):
20194 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20195 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20196 
      return
20197 
    oprot.writeStructBegin('updateWeight_args')
20198 
    if self.orderId is not None:
20199 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
20200 
      oprot.writeI64(self.orderId)
20201 
      oprot.writeFieldEnd()
20202 
    if self.weight is not None:
20203 
      oprot.writeFieldBegin('weight', TType.DOUBLE, 2)
20204 
      oprot.writeDouble(self.weight)
20205 
      oprot.writeFieldEnd()
20206 
    oprot.writeFieldStop()
20207 
    oprot.writeStructEnd()
20208 
 
20209 
  def validate(self):
20210 
    return
20211 
 
20212 
 
20213 
  def __repr__(self):
20214 
    L = ['%s=%r' % (key, value)
20215 
      for key, value in self.__dict__.iteritems()]
20216 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20217 
 
20218 
  def __eq__(self, other):
20219 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20220 
 
20221 
  def __ne__(self, other):
20222 
    return not (self == other)
20223 
 
20224 
class updateWeight_result:
20225 
  """
20226 
  Attributes:
20227 
   - success
20228 
   - ex
20229 
  """
20230 
 
20231 
  thrift_spec = (
20232 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
20233 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
20234 
  )
20235 
 
20236 
  def __init__(self, success=None, ex=None,):
20237 
    self.success = success
20238 
    self.ex = ex
20239 
 
20240 
  def read(self, iprot):
20241 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20242 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20243 
      return
20244 
    iprot.readStructBegin()
20245 
    while True:
20246 
      (fname, ftype, fid) = iprot.readFieldBegin()
20247 
      if ftype == TType.STOP:
20248 
        break
20249 
      if fid == 0:
20250 
        if ftype == TType.STRUCT:
20251 
          self.success = Order()
20252 
          self.success.read(iprot)
20253 
        else:
20254 
          iprot.skip(ftype)
20255 
      elif fid == 1:
20256 
        if ftype == TType.STRUCT:
20257 
          self.ex = TransactionServiceException()
20258 
          self.ex.read(iprot)
20259 
        else:
20260 
          iprot.skip(ftype)
20261 
      else:
20262 
        iprot.skip(ftype)
20263 
      iprot.readFieldEnd()
20264 
    iprot.readStructEnd()
20265 
 
20266 
  def write(self, oprot):
20267 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20268 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20269 
      return
20270 
    oprot.writeStructBegin('updateWeight_result')
20271 
    if self.success is not None:
20272 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
20273 
      self.success.write(oprot)
20274 
      oprot.writeFieldEnd()
20275 
    if self.ex is not None:
20276 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
20277 
      self.ex.write(oprot)
20278 
      oprot.writeFieldEnd()
20279 
    oprot.writeFieldStop()
20280 
    oprot.writeStructEnd()
20281 
 
20282 
  def validate(self):
20283 
    return
20284 
 
20285 
 
20286 
  def __repr__(self):
20287 
    L = ['%s=%r' % (key, value)
20288 
      for key, value in self.__dict__.iteritems()]
20289 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20290 
 
20291 
  def __eq__(self, other):
20292 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20293 
 
20294 
  def __ne__(self, other):
20295 
    return not (self == other)
3469 chandransh 20296 
 
20297 
class changeItem_args:
20298 
  """
20299 
  Attributes:
20300 
   - orderId
20301 
   - itemId
20302 
  """
20303 
 
20304 
  thrift_spec = (
20305 
    None, # 0
20306 
    (1, TType.I64, 'orderId', None, None, ), # 1
20307 
    (2, TType.I64, 'itemId', None, None, ), # 2
20308 
  )
20309 
 
20310 
  def __init__(self, orderId=None, itemId=None,):
20311 
    self.orderId = orderId
20312 
    self.itemId = itemId
20313 
 
20314 
  def read(self, iprot):
20315 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20316 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20317 
      return
20318 
    iprot.readStructBegin()
20319 
    while True:
20320 
      (fname, ftype, fid) = iprot.readFieldBegin()
20321 
      if ftype == TType.STOP:
20322 
        break
20323 
      if fid == 1:
20324 
        if ftype == TType.I64:
20325 
          self.orderId = iprot.readI64();
20326 
        else:
20327 
          iprot.skip(ftype)
20328 
      elif fid == 2:
20329 
        if ftype == TType.I64:
20330 
          self.itemId = iprot.readI64();
20331 
        else:
20332 
          iprot.skip(ftype)
20333 
      else:
20334 
        iprot.skip(ftype)
20335 
      iprot.readFieldEnd()
20336 
    iprot.readStructEnd()
20337 
 
20338 
  def write(self, oprot):
20339 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20340 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20341 
      return
20342 
    oprot.writeStructBegin('changeItem_args')
20343 
    if self.orderId is not None:
20344 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
20345 
      oprot.writeI64(self.orderId)
20346 
      oprot.writeFieldEnd()
20347 
    if self.itemId is not None:
20348 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
20349 
      oprot.writeI64(self.itemId)
20350 
      oprot.writeFieldEnd()
20351 
    oprot.writeFieldStop()
20352 
    oprot.writeStructEnd()
20353 
 
20354 
  def validate(self):
20355 
    return
20356 
 
20357 
 
20358 
  def __repr__(self):
20359 
    L = ['%s=%r' % (key, value)
20360 
      for key, value in self.__dict__.iteritems()]
20361 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20362 
 
20363 
  def __eq__(self, other):
20364 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20365 
 
20366 
  def __ne__(self, other):
20367 
    return not (self == other)
20368 
 
20369 
class changeItem_result:
20370 
  """
20371 
  Attributes:
20372 
   - success
20373 
   - ex
20374 
  """
20375 
 
20376 
  thrift_spec = (
20377 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
20378 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
20379 
  )
20380 
 
20381 
  def __init__(self, success=None, ex=None,):
20382 
    self.success = success
20383 
    self.ex = ex
20384 
 
20385 
  def read(self, iprot):
20386 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20387 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20388 
      return
20389 
    iprot.readStructBegin()
20390 
    while True:
20391 
      (fname, ftype, fid) = iprot.readFieldBegin()
20392 
      if ftype == TType.STOP:
20393 
        break
20394 
      if fid == 0:
20395 
        if ftype == TType.STRUCT:
20396 
          self.success = Order()
20397 
          self.success.read(iprot)
20398 
        else:
20399 
          iprot.skip(ftype)
20400 
      elif fid == 1:
20401 
        if ftype == TType.STRUCT:
20402 
          self.ex = TransactionServiceException()
20403 
          self.ex.read(iprot)
20404 
        else:
20405 
          iprot.skip(ftype)
20406 
      else:
20407 
        iprot.skip(ftype)
20408 
      iprot.readFieldEnd()
20409 
    iprot.readStructEnd()
20410 
 
20411 
  def write(self, oprot):
20412 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20413 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20414 
      return
20415 
    oprot.writeStructBegin('changeItem_result')
20416 
    if self.success is not None:
20417 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
20418 
      self.success.write(oprot)
20419 
      oprot.writeFieldEnd()
20420 
    if self.ex is not None:
20421 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
20422 
      self.ex.write(oprot)
20423 
      oprot.writeFieldEnd()
20424 
    oprot.writeFieldStop()
20425 
    oprot.writeStructEnd()
20426 
 
20427 
  def validate(self):
20428 
    return
20429 
 
20430 
 
20431 
  def __repr__(self):
20432 
    L = ['%s=%r' % (key, value)
20433 
      for key, value in self.__dict__.iteritems()]
20434 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20435 
 
20436 
  def __eq__(self, other):
20437 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20438 
 
20439 
  def __ne__(self, other):
20440 
    return not (self == other)
20441 
 
20442 
class shiftToWarehouse_args:
20443 
  """
20444 
  Attributes:
20445 
   - orderId
20446 
   - warehouseId
20447 
  """
20448 
 
20449 
  thrift_spec = (
20450 
    None, # 0
20451 
    (1, TType.I64, 'orderId', None, None, ), # 1
20452 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
20453 
  )
20454 
 
20455 
  def __init__(self, orderId=None, warehouseId=None,):
20456 
    self.orderId = orderId
20457 
    self.warehouseId = warehouseId
20458 
 
20459 
  def read(self, iprot):
20460 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20461 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20462 
      return
20463 
    iprot.readStructBegin()
20464 
    while True:
20465 
      (fname, ftype, fid) = iprot.readFieldBegin()
20466 
      if ftype == TType.STOP:
20467 
        break
20468 
      if fid == 1:
20469 
        if ftype == TType.I64:
20470 
          self.orderId = iprot.readI64();
20471 
        else:
20472 
          iprot.skip(ftype)
20473 
      elif fid == 2:
20474 
        if ftype == TType.I64:
20475 
          self.warehouseId = iprot.readI64();
20476 
        else:
20477 
          iprot.skip(ftype)
20478 
      else:
20479 
        iprot.skip(ftype)
20480 
      iprot.readFieldEnd()
20481 
    iprot.readStructEnd()
20482 
 
20483 
  def write(self, oprot):
20484 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20485 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20486 
      return
20487 
    oprot.writeStructBegin('shiftToWarehouse_args')
20488 
    if self.orderId is not None:
20489 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
20490 
      oprot.writeI64(self.orderId)
20491 
      oprot.writeFieldEnd()
20492 
    if self.warehouseId is not None:
20493 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
20494 
      oprot.writeI64(self.warehouseId)
20495 
      oprot.writeFieldEnd()
20496 
    oprot.writeFieldStop()
20497 
    oprot.writeStructEnd()
20498 
 
20499 
  def validate(self):
20500 
    return
20501 
 
20502 
 
20503 
  def __repr__(self):
20504 
    L = ['%s=%r' % (key, value)
20505 
      for key, value in self.__dict__.iteritems()]
20506 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20507 
 
20508 
  def __eq__(self, other):
20509 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20510 
 
20511 
  def __ne__(self, other):
20512 
    return not (self == other)
20513 
 
20514 
class shiftToWarehouse_result:
20515 
  """
20516 
  Attributes:
20517 
   - success
20518 
   - ex
20519 
  """
20520 
 
20521 
  thrift_spec = (
20522 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
20523 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
20524 
  )
20525 
 
20526 
  def __init__(self, success=None, ex=None,):
20527 
    self.success = success
20528 
    self.ex = ex
20529 
 
20530 
  def read(self, iprot):
20531 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20532 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20533 
      return
20534 
    iprot.readStructBegin()
20535 
    while True:
20536 
      (fname, ftype, fid) = iprot.readFieldBegin()
20537 
      if ftype == TType.STOP:
20538 
        break
20539 
      if fid == 0:
20540 
        if ftype == TType.STRUCT:
20541 
          self.success = Order()
20542 
          self.success.read(iprot)
20543 
        else:
20544 
          iprot.skip(ftype)
20545 
      elif fid == 1:
20546 
        if ftype == TType.STRUCT:
20547 
          self.ex = TransactionServiceException()
20548 
          self.ex.read(iprot)
20549 
        else:
20550 
          iprot.skip(ftype)
20551 
      else:
20552 
        iprot.skip(ftype)
20553 
      iprot.readFieldEnd()
20554 
    iprot.readStructEnd()
20555 
 
20556 
  def write(self, oprot):
20557 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20558 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20559 
      return
20560 
    oprot.writeStructBegin('shiftToWarehouse_result')
20561 
    if self.success is not None:
20562 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
20563 
      self.success.write(oprot)
20564 
      oprot.writeFieldEnd()
20565 
    if self.ex is not None:
20566 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
20567 
      self.ex.write(oprot)
20568 
      oprot.writeFieldEnd()
20569 
    oprot.writeFieldStop()
20570 
    oprot.writeStructEnd()
20571 
 
20572 
  def validate(self):
20573 
    return
20574 
 
20575 
 
20576 
  def __repr__(self):
20577 
    L = ['%s=%r' % (key, value)
20578 
      for key, value in self.__dict__.iteritems()]
20579 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20580 
 
20581 
  def __eq__(self, other):
20582 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20583 
 
20584 
  def __ne__(self, other):
20585 
    return not (self == other)
3553 chandransh 20586 
 
20587 
class addDelayReason_args:
20588 
  """
20589 
  Attributes:
20590 
   - orderId
20591 
   - delayReason
3986 chandransh 20592 
   - furtherDelay
4647 rajveer 20593 
   - delayReasonText
3553 chandransh 20594 
  """
20595 
 
20596 
  thrift_spec = (
20597 
    None, # 0
20598 
    (1, TType.I64, 'orderId', None, None, ), # 1
20599 
    (2, TType.I32, 'delayReason', None, None, ), # 2
3986 chandransh 20600 
    (3, TType.I64, 'furtherDelay', None, None, ), # 3
4647 rajveer 20601 
    (4, TType.STRING, 'delayReasonText', None, None, ), # 4
3553 chandransh 20602 
  )
20603 
 
4647 rajveer 20604 
  def __init__(self, orderId=None, delayReason=None, furtherDelay=None, delayReasonText=None,):
3553 chandransh 20605 
    self.orderId = orderId
20606 
    self.delayReason = delayReason
3986 chandransh 20607 
    self.furtherDelay = furtherDelay
4647 rajveer 20608 
    self.delayReasonText = delayReasonText
3553 chandransh 20609 
 
20610 
  def read(self, iprot):
20611 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20612 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20613 
      return
20614 
    iprot.readStructBegin()
20615 
    while True:
20616 
      (fname, ftype, fid) = iprot.readFieldBegin()
20617 
      if ftype == TType.STOP:
20618 
        break
20619 
      if fid == 1:
20620 
        if ftype == TType.I64:
20621 
          self.orderId = iprot.readI64();
20622 
        else:
20623 
          iprot.skip(ftype)
20624 
      elif fid == 2:
20625 
        if ftype == TType.I32:
20626 
          self.delayReason = iprot.readI32();
20627 
        else:
20628 
          iprot.skip(ftype)
3986 chandransh 20629 
      elif fid == 3:
20630 
        if ftype == TType.I64:
20631 
          self.furtherDelay = iprot.readI64();
20632 
        else:
20633 
          iprot.skip(ftype)
4647 rajveer 20634 
      elif fid == 4:
20635 
        if ftype == TType.STRING:
20636 
          self.delayReasonText = iprot.readString();
20637 
        else:
20638 
          iprot.skip(ftype)
3553 chandransh 20639 
      else:
20640 
        iprot.skip(ftype)
20641 
      iprot.readFieldEnd()
20642 
    iprot.readStructEnd()
20643 
 
20644 
  def write(self, oprot):
20645 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20646 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20647 
      return
20648 
    oprot.writeStructBegin('addDelayReason_args')
20649 
    if self.orderId is not None:
20650 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
20651 
      oprot.writeI64(self.orderId)
20652 
      oprot.writeFieldEnd()
20653 
    if self.delayReason is not None:
20654 
      oprot.writeFieldBegin('delayReason', TType.I32, 2)
20655 
      oprot.writeI32(self.delayReason)
20656 
      oprot.writeFieldEnd()
3986 chandransh 20657 
    if self.furtherDelay is not None:
20658 
      oprot.writeFieldBegin('furtherDelay', TType.I64, 3)
20659 
      oprot.writeI64(self.furtherDelay)
20660 
      oprot.writeFieldEnd()
4647 rajveer 20661 
    if self.delayReasonText is not None:
20662 
      oprot.writeFieldBegin('delayReasonText', TType.STRING, 4)
20663 
      oprot.writeString(self.delayReasonText)
20664 
      oprot.writeFieldEnd()
3553 chandransh 20665 
    oprot.writeFieldStop()
20666 
    oprot.writeStructEnd()
20667 
 
20668 
  def validate(self):
20669 
    return
20670 
 
20671 
 
20672 
  def __repr__(self):
20673 
    L = ['%s=%r' % (key, value)
20674 
      for key, value in self.__dict__.iteritems()]
20675 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20676 
 
20677 
  def __eq__(self, other):
20678 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20679 
 
20680 
  def __ne__(self, other):
20681 
    return not (self == other)
20682 
 
20683 
class addDelayReason_result:
20684 
  """
20685 
  Attributes:
20686 
   - success
20687 
   - ex
20688 
  """
20689 
 
20690 
  thrift_spec = (
20691 
    (0, TType.BOOL, 'success', None, None, ), # 0
20692 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
20693 
  )
20694 
 
20695 
  def __init__(self, success=None, ex=None,):
20696 
    self.success = success
20697 
    self.ex = ex
20698 
 
20699 
  def read(self, iprot):
20700 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20701 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20702 
      return
20703 
    iprot.readStructBegin()
20704 
    while True:
20705 
      (fname, ftype, fid) = iprot.readFieldBegin()
20706 
      if ftype == TType.STOP:
20707 
        break
20708 
      if fid == 0:
20709 
        if ftype == TType.BOOL:
20710 
          self.success = iprot.readBool();
20711 
        else:
20712 
          iprot.skip(ftype)
20713 
      elif fid == 1:
20714 
        if ftype == TType.STRUCT:
20715 
          self.ex = TransactionServiceException()
20716 
          self.ex.read(iprot)
20717 
        else:
20718 
          iprot.skip(ftype)
20719 
      else:
20720 
        iprot.skip(ftype)
20721 
      iprot.readFieldEnd()
20722 
    iprot.readStructEnd()
20723 
 
20724 
  def write(self, oprot):
20725 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20726 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20727 
      return
20728 
    oprot.writeStructBegin('addDelayReason_result')
20729 
    if self.success is not None:
20730 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
20731 
      oprot.writeBool(self.success)
20732 
      oprot.writeFieldEnd()
20733 
    if self.ex is not None:
20734 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
20735 
      self.ex.write(oprot)
20736 
      oprot.writeFieldEnd()
20737 
    oprot.writeFieldStop()
20738 
    oprot.writeStructEnd()
20739 
 
20740 
  def validate(self):
20741 
    return
20742 
 
20743 
 
20744 
  def __repr__(self):
20745 
    L = ['%s=%r' % (key, value)
20746 
      for key, value in self.__dict__.iteritems()]
20747 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20748 
 
20749 
  def __eq__(self, other):
20750 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20751 
 
20752 
  def __ne__(self, other):
20753 
    return not (self == other)
3956 chandransh 20754 
 
20755 
class reconcileCodCollection_args:
20756 
  """
20757 
  Attributes:
20758 
   - collectedAmountMap
20759 
   - xferBy
20760 
   - xferTxnId
20761 
   - xferDate
20762 
  """
20763 
 
20764 
  thrift_spec = (
20765 
    None, # 0
20766 
    (1, TType.MAP, 'collectedAmountMap', (TType.STRING,None,TType.DOUBLE,None), None, ), # 1
20767 
    (2, TType.STRING, 'xferBy', None, None, ), # 2
20768 
    (3, TType.STRING, 'xferTxnId', None, None, ), # 3
20769 
    (4, TType.I64, 'xferDate', None, None, ), # 4
20770 
  )
20771 
 
20772 
  def __init__(self, collectedAmountMap=None, xferBy=None, xferTxnId=None, xferDate=None,):
20773 
    self.collectedAmountMap = collectedAmountMap
20774 
    self.xferBy = xferBy
20775 
    self.xferTxnId = xferTxnId
20776 
    self.xferDate = xferDate
20777 
 
20778 
  def read(self, iprot):
20779 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20780 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20781 
      return
20782 
    iprot.readStructBegin()
20783 
    while True:
20784 
      (fname, ftype, fid) = iprot.readFieldBegin()
20785 
      if ftype == TType.STOP:
20786 
        break
20787 
      if fid == 1:
20788 
        if ftype == TType.MAP:
20789 
          self.collectedAmountMap = {}
6188 rajveer 20790 
          (_ktype454, _vtype455, _size453 ) = iprot.readMapBegin()
20791 
          for _i457 in xrange(_size453):
20792 
            _key458 = iprot.readString();
20793 
            _val459 = iprot.readDouble();
20794 
            self.collectedAmountMap[_key458] = _val459
3956 chandransh 20795 
          iprot.readMapEnd()
20796 
        else:
20797 
          iprot.skip(ftype)
20798 
      elif fid == 2:
20799 
        if ftype == TType.STRING:
20800 
          self.xferBy = iprot.readString();
20801 
        else:
20802 
          iprot.skip(ftype)
20803 
      elif fid == 3:
20804 
        if ftype == TType.STRING:
20805 
          self.xferTxnId = iprot.readString();
20806 
        else:
20807 
          iprot.skip(ftype)
20808 
      elif fid == 4:
20809 
        if ftype == TType.I64:
20810 
          self.xferDate = iprot.readI64();
20811 
        else:
20812 
          iprot.skip(ftype)
20813 
      else:
20814 
        iprot.skip(ftype)
20815 
      iprot.readFieldEnd()
20816 
    iprot.readStructEnd()
20817 
 
20818 
  def write(self, oprot):
20819 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20820 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20821 
      return
20822 
    oprot.writeStructBegin('reconcileCodCollection_args')
20823 
    if self.collectedAmountMap is not None:
20824 
      oprot.writeFieldBegin('collectedAmountMap', TType.MAP, 1)
20825 
      oprot.writeMapBegin(TType.STRING, TType.DOUBLE, len(self.collectedAmountMap))
6188 rajveer 20826 
      for kiter460,viter461 in self.collectedAmountMap.items():
20827 
        oprot.writeString(kiter460)
20828 
        oprot.writeDouble(viter461)
3956 chandransh 20829 
      oprot.writeMapEnd()
20830 
      oprot.writeFieldEnd()
20831 
    if self.xferBy is not None:
20832 
      oprot.writeFieldBegin('xferBy', TType.STRING, 2)
20833 
      oprot.writeString(self.xferBy)
20834 
      oprot.writeFieldEnd()
20835 
    if self.xferTxnId is not None:
20836 
      oprot.writeFieldBegin('xferTxnId', TType.STRING, 3)
20837 
      oprot.writeString(self.xferTxnId)
20838 
      oprot.writeFieldEnd()
20839 
    if self.xferDate is not None:
20840 
      oprot.writeFieldBegin('xferDate', TType.I64, 4)
20841 
      oprot.writeI64(self.xferDate)
20842 
      oprot.writeFieldEnd()
20843 
    oprot.writeFieldStop()
20844 
    oprot.writeStructEnd()
20845 
 
20846 
  def validate(self):
20847 
    return
20848 
 
20849 
 
20850 
  def __repr__(self):
20851 
    L = ['%s=%r' % (key, value)
20852 
      for key, value in self.__dict__.iteritems()]
20853 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20854 
 
20855 
  def __eq__(self, other):
20856 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20857 
 
20858 
  def __ne__(self, other):
20859 
    return not (self == other)
20860 
 
20861 
class reconcileCodCollection_result:
20862 
  """
20863 
  Attributes:
20864 
   - success
20865 
   - ex
20866 
  """
20867 
 
20868 
  thrift_spec = (
20869 
    (0, TType.MAP, 'success', (TType.STRING,None,TType.STRING,None), None, ), # 0
20870 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
20871 
  )
20872 
 
20873 
  def __init__(self, success=None, ex=None,):
20874 
    self.success = success
20875 
    self.ex = ex
20876 
 
20877 
  def read(self, iprot):
20878 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20879 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20880 
      return
20881 
    iprot.readStructBegin()
20882 
    while True:
20883 
      (fname, ftype, fid) = iprot.readFieldBegin()
20884 
      if ftype == TType.STOP:
20885 
        break
20886 
      if fid == 0:
20887 
        if ftype == TType.MAP:
20888 
          self.success = {}
6188 rajveer 20889 
          (_ktype463, _vtype464, _size462 ) = iprot.readMapBegin()
20890 
          for _i466 in xrange(_size462):
20891 
            _key467 = iprot.readString();
20892 
            _val468 = iprot.readString();
20893 
            self.success[_key467] = _val468
3956 chandransh 20894 
          iprot.readMapEnd()
20895 
        else:
20896 
          iprot.skip(ftype)
20897 
      elif fid == 1:
20898 
        if ftype == TType.STRUCT:
20899 
          self.ex = TransactionServiceException()
20900 
          self.ex.read(iprot)
20901 
        else:
20902 
          iprot.skip(ftype)
20903 
      else:
20904 
        iprot.skip(ftype)
20905 
      iprot.readFieldEnd()
20906 
    iprot.readStructEnd()
20907 
 
20908 
  def write(self, oprot):
20909 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20910 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20911 
      return
20912 
    oprot.writeStructBegin('reconcileCodCollection_result')
20913 
    if self.success is not None:
20914 
      oprot.writeFieldBegin('success', TType.MAP, 0)
20915 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.success))
6188 rajveer 20916 
      for kiter469,viter470 in self.success.items():
20917 
        oprot.writeString(kiter469)
20918 
        oprot.writeString(viter470)
3956 chandransh 20919 
      oprot.writeMapEnd()
20920 
      oprot.writeFieldEnd()
20921 
    if self.ex is not None:
20922 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
20923 
      self.ex.write(oprot)
20924 
      oprot.writeFieldEnd()
20925 
    oprot.writeFieldStop()
20926 
    oprot.writeStructEnd()
20927 
 
20928 
  def validate(self):
20929 
    return
20930 
 
20931 
 
20932 
  def __repr__(self):
20933 
    L = ['%s=%r' % (key, value)
20934 
      for key, value in self.__dict__.iteritems()]
20935 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20936 
 
20937 
  def __eq__(self, other):
20938 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20939 
 
20940 
  def __ne__(self, other):
20941 
    return not (self == other)
4008 mandeep.dh 20942 
 
20943 
class getTransactionsRequiringExtraProcessing_args:
20944 
  """
20945 
  Attributes:
20946 
   - category
20947 
  """
20948 
 
20949 
  thrift_spec = (
20950 
    None, # 0
20951 
    (1, TType.I32, 'category', None, None, ), # 1
20952 
  )
20953 
 
20954 
  def __init__(self, category=None,):
20955 
    self.category = category
20956 
 
20957 
  def read(self, iprot):
20958 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20959 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20960 
      return
20961 
    iprot.readStructBegin()
20962 
    while True:
20963 
      (fname, ftype, fid) = iprot.readFieldBegin()
20964 
      if ftype == TType.STOP:
20965 
        break
20966 
      if fid == 1:
20967 
        if ftype == TType.I32:
20968 
          self.category = iprot.readI32();
20969 
        else:
20970 
          iprot.skip(ftype)
20971 
      else:
20972 
        iprot.skip(ftype)
20973 
      iprot.readFieldEnd()
20974 
    iprot.readStructEnd()
20975 
 
20976 
  def write(self, oprot):
20977 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20978 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20979 
      return
20980 
    oprot.writeStructBegin('getTransactionsRequiringExtraProcessing_args')
20981 
    if self.category is not None:
20982 
      oprot.writeFieldBegin('category', TType.I32, 1)
20983 
      oprot.writeI32(self.category)
20984 
      oprot.writeFieldEnd()
20985 
    oprot.writeFieldStop()
20986 
    oprot.writeStructEnd()
20987 
 
20988 
  def validate(self):
20989 
    return
20990 
 
20991 
 
20992 
  def __repr__(self):
20993 
    L = ['%s=%r' % (key, value)
20994 
      for key, value in self.__dict__.iteritems()]
20995 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20996 
 
20997 
  def __eq__(self, other):
20998 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20999 
 
21000 
  def __ne__(self, other):
21001 
    return not (self == other)
21002 
 
21003 
class getTransactionsRequiringExtraProcessing_result:
21004 
  """
21005 
  Attributes:
21006 
   - success
21007 
  """
21008 
 
21009 
  thrift_spec = (
21010 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
21011 
  )
21012 
 
21013 
  def __init__(self, success=None,):
21014 
    self.success = success
21015 
 
21016 
  def read(self, iprot):
21017 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21018 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21019 
      return
21020 
    iprot.readStructBegin()
21021 
    while True:
21022 
      (fname, ftype, fid) = iprot.readFieldBegin()
21023 
      if ftype == TType.STOP:
21024 
        break
21025 
      if fid == 0:
21026 
        if ftype == TType.LIST:
21027 
          self.success = []
6188 rajveer 21028 
          (_etype474, _size471) = iprot.readListBegin()
21029 
          for _i475 in xrange(_size471):
21030 
            _elem476 = iprot.readI64();
21031 
            self.success.append(_elem476)
4008 mandeep.dh 21032 
          iprot.readListEnd()
21033 
        else:
21034 
          iprot.skip(ftype)
21035 
      else:
21036 
        iprot.skip(ftype)
21037 
      iprot.readFieldEnd()
21038 
    iprot.readStructEnd()
21039 
 
21040 
  def write(self, oprot):
21041 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21042 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21043 
      return
21044 
    oprot.writeStructBegin('getTransactionsRequiringExtraProcessing_result')
21045 
    if self.success is not None:
21046 
      oprot.writeFieldBegin('success', TType.LIST, 0)
21047 
      oprot.writeListBegin(TType.I64, len(self.success))
6188 rajveer 21048 
      for iter477 in self.success:
21049 
        oprot.writeI64(iter477)
4008 mandeep.dh 21050 
      oprot.writeListEnd()
21051 
      oprot.writeFieldEnd()
21052 
    oprot.writeFieldStop()
21053 
    oprot.writeStructEnd()
21054 
 
21055 
  def validate(self):
21056 
    return
21057 
 
21058 
 
21059 
  def __repr__(self):
21060 
    L = ['%s=%r' % (key, value)
21061 
      for key, value in self.__dict__.iteritems()]
21062 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21063 
 
21064 
  def __eq__(self, other):
21065 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21066 
 
21067 
  def __ne__(self, other):
21068 
    return not (self == other)
21069 
 
21070 
class markTransactionAsProcessed_args:
21071 
  """
21072 
  Attributes:
21073 
   - transactionId
21074 
   - category
21075 
  """
21076 
 
21077 
  thrift_spec = (
21078 
    None, # 0
21079 
    (1, TType.I64, 'transactionId', None, None, ), # 1
21080 
    (2, TType.I32, 'category', None, None, ), # 2
21081 
  )
21082 
 
21083 
  def __init__(self, transactionId=None, category=None,):
21084 
    self.transactionId = transactionId
21085 
    self.category = category
21086 
 
21087 
  def read(self, iprot):
21088 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21089 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21090 
      return
21091 
    iprot.readStructBegin()
21092 
    while True:
21093 
      (fname, ftype, fid) = iprot.readFieldBegin()
21094 
      if ftype == TType.STOP:
21095 
        break
21096 
      if fid == 1:
21097 
        if ftype == TType.I64:
21098 
          self.transactionId = iprot.readI64();
21099 
        else:
21100 
          iprot.skip(ftype)
21101 
      elif fid == 2:
21102 
        if ftype == TType.I32:
21103 
          self.category = iprot.readI32();
21104 
        else:
21105 
          iprot.skip(ftype)
21106 
      else:
21107 
        iprot.skip(ftype)
21108 
      iprot.readFieldEnd()
21109 
    iprot.readStructEnd()
21110 
 
21111 
  def write(self, oprot):
21112 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21113 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21114 
      return
21115 
    oprot.writeStructBegin('markTransactionAsProcessed_args')
21116 
    if self.transactionId is not None:
21117 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
21118 
      oprot.writeI64(self.transactionId)
21119 
      oprot.writeFieldEnd()
21120 
    if self.category is not None:
21121 
      oprot.writeFieldBegin('category', TType.I32, 2)
21122 
      oprot.writeI32(self.category)
21123 
      oprot.writeFieldEnd()
21124 
    oprot.writeFieldStop()
21125 
    oprot.writeStructEnd()
21126 
 
21127 
  def validate(self):
21128 
    return
21129 
 
21130 
 
21131 
  def __repr__(self):
21132 
    L = ['%s=%r' % (key, value)
21133 
      for key, value in self.__dict__.iteritems()]
21134 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21135 
 
21136 
  def __eq__(self, other):
21137 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21138 
 
21139 
  def __ne__(self, other):
21140 
    return not (self == other)
21141 
 
21142 
class markTransactionAsProcessed_result:
21143 
 
21144 
  thrift_spec = (
21145 
  )
21146 
 
21147 
  def read(self, iprot):
21148 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21149 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21150 
      return
21151 
    iprot.readStructBegin()
21152 
    while True:
21153 
      (fname, ftype, fid) = iprot.readFieldBegin()
21154 
      if ftype == TType.STOP:
21155 
        break
21156 
      else:
21157 
        iprot.skip(ftype)
21158 
      iprot.readFieldEnd()
21159 
    iprot.readStructEnd()
21160 
 
21161 
  def write(self, oprot):
21162 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21163 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21164 
      return
21165 
    oprot.writeStructBegin('markTransactionAsProcessed_result')
21166 
    oprot.writeFieldStop()
21167 
    oprot.writeStructEnd()
21168 
 
21169 
  def validate(self):
21170 
    return
21171 
 
21172 
 
21173 
  def __repr__(self):
21174 
    L = ['%s=%r' % (key, value)
21175 
      for key, value in self.__dict__.iteritems()]
21176 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21177 
 
21178 
  def __eq__(self, other):
21179 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21180 
 
21181 
  def __ne__(self, other):
21182 
    return not (self == other)
4018 chandransh 21183 
 
21184 
class getItemWiseRiskyOrdersCount_args:
21185 
 
21186 
  thrift_spec = (
21187 
  )
21188 
 
21189 
  def read(self, iprot):
21190 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21191 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21192 
      return
21193 
    iprot.readStructBegin()
21194 
    while True:
21195 
      (fname, ftype, fid) = iprot.readFieldBegin()
21196 
      if ftype == TType.STOP:
21197 
        break
21198 
      else:
21199 
        iprot.skip(ftype)
21200 
      iprot.readFieldEnd()
21201 
    iprot.readStructEnd()
21202 
 
21203 
  def write(self, oprot):
21204 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21205 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21206 
      return
21207 
    oprot.writeStructBegin('getItemWiseRiskyOrdersCount_args')
21208 
    oprot.writeFieldStop()
21209 
    oprot.writeStructEnd()
21210 
 
21211 
  def validate(self):
21212 
    return
21213 
 
21214 
 
21215 
  def __repr__(self):
21216 
    L = ['%s=%r' % (key, value)
21217 
      for key, value in self.__dict__.iteritems()]
21218 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21219 
 
21220 
  def __eq__(self, other):
21221 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21222 
 
21223 
  def __ne__(self, other):
21224 
    return not (self == other)
21225 
 
21226 
class getItemWiseRiskyOrdersCount_result:
21227 
  """
21228 
  Attributes:
21229 
   - success
21230 
  """
21231 
 
21232 
  thrift_spec = (
21233 
    (0, TType.MAP, 'success', (TType.I64,None,TType.I64,None), None, ), # 0
21234 
  )
21235 
 
21236 
  def __init__(self, success=None,):
21237 
    self.success = success
21238 
 
21239 
  def read(self, iprot):
21240 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21241 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21242 
      return
21243 
    iprot.readStructBegin()
21244 
    while True:
21245 
      (fname, ftype, fid) = iprot.readFieldBegin()
21246 
      if ftype == TType.STOP:
21247 
        break
21248 
      if fid == 0:
21249 
        if ftype == TType.MAP:
21250 
          self.success = {}
6188 rajveer 21251 
          (_ktype479, _vtype480, _size478 ) = iprot.readMapBegin()
21252 
          for _i482 in xrange(_size478):
21253 
            _key483 = iprot.readI64();
21254 
            _val484 = iprot.readI64();
21255 
            self.success[_key483] = _val484
4018 chandransh 21256 
          iprot.readMapEnd()
21257 
        else:
21258 
          iprot.skip(ftype)
21259 
      else:
21260 
        iprot.skip(ftype)
21261 
      iprot.readFieldEnd()
21262 
    iprot.readStructEnd()
21263 
 
21264 
  def write(self, oprot):
21265 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21266 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21267 
      return
21268 
    oprot.writeStructBegin('getItemWiseRiskyOrdersCount_result')
21269 
    if self.success is not None:
21270 
      oprot.writeFieldBegin('success', TType.MAP, 0)
21271 
      oprot.writeMapBegin(TType.I64, TType.I64, len(self.success))
6188 rajveer 21272 
      for kiter485,viter486 in self.success.items():
21273 
        oprot.writeI64(kiter485)
21274 
        oprot.writeI64(viter486)
4018 chandransh 21275 
      oprot.writeMapEnd()
21276 
      oprot.writeFieldEnd()
21277 
    oprot.writeFieldStop()
21278 
    oprot.writeStructEnd()
21279 
 
21280 
  def validate(self):
21281 
    return
21282 
 
21283 
 
21284 
  def __repr__(self):
21285 
    L = ['%s=%r' % (key, value)
21286 
      for key, value in self.__dict__.iteritems()]
21287 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21288 
 
21289 
  def __eq__(self, other):
21290 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21291 
 
21292 
  def __ne__(self, other):
21293 
    return not (self == other)
4247 rajveer 21294 
 
4295 varun.gupt 21295 
class getOrdersForItemIds_args:
21296 
  """
21297 
  Attributes:
21298 
   - itemIds
21299 
  """
21300 
 
21301 
  thrift_spec = (
21302 
    None, # 0
21303 
    (1, TType.LIST, 'itemIds', (TType.I64,None), None, ), # 1
21304 
  )
21305 
 
21306 
  def __init__(self, itemIds=None,):
21307 
    self.itemIds = itemIds
21308 
 
21309 
  def read(self, iprot):
21310 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21311 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21312 
      return
21313 
    iprot.readStructBegin()
21314 
    while True:
21315 
      (fname, ftype, fid) = iprot.readFieldBegin()
21316 
      if ftype == TType.STOP:
21317 
        break
21318 
      if fid == 1:
21319 
        if ftype == TType.LIST:
21320 
          self.itemIds = []
6188 rajveer 21321 
          (_etype490, _size487) = iprot.readListBegin()
21322 
          for _i491 in xrange(_size487):
21323 
            _elem492 = iprot.readI64();
21324 
            self.itemIds.append(_elem492)
4295 varun.gupt 21325 
          iprot.readListEnd()
21326 
        else:
21327 
          iprot.skip(ftype)
21328 
      else:
21329 
        iprot.skip(ftype)
21330 
      iprot.readFieldEnd()
21331 
    iprot.readStructEnd()
21332 
 
21333 
  def write(self, oprot):
21334 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21335 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21336 
      return
21337 
    oprot.writeStructBegin('getOrdersForItemIds_args')
21338 
    if self.itemIds is not None:
21339 
      oprot.writeFieldBegin('itemIds', TType.LIST, 1)
21340 
      oprot.writeListBegin(TType.I64, len(self.itemIds))
6188 rajveer 21341 
      for iter493 in self.itemIds:
21342 
        oprot.writeI64(iter493)
4295 varun.gupt 21343 
      oprot.writeListEnd()
21344 
      oprot.writeFieldEnd()
21345 
    oprot.writeFieldStop()
21346 
    oprot.writeStructEnd()
21347 
 
21348 
  def validate(self):
21349 
    return
21350 
 
21351 
 
21352 
  def __repr__(self):
21353 
    L = ['%s=%r' % (key, value)
21354 
      for key, value in self.__dict__.iteritems()]
21355 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21356 
 
21357 
  def __eq__(self, other):
21358 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21359 
 
21360 
  def __ne__(self, other):
21361 
    return not (self == other)
21362 
 
21363 
class getOrdersForItemIds_result:
21364 
  """
21365 
  Attributes:
21366 
   - success
21367 
  """
21368 
 
21369 
  thrift_spec = (
21370 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
21371 
  )
21372 
 
21373 
  def __init__(self, success=None,):
21374 
    self.success = success
21375 
 
21376 
  def read(self, iprot):
21377 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21378 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21379 
      return
21380 
    iprot.readStructBegin()
21381 
    while True:
21382 
      (fname, ftype, fid) = iprot.readFieldBegin()
21383 
      if ftype == TType.STOP:
21384 
        break
21385 
      if fid == 0:
21386 
        if ftype == TType.LIST:
21387 
          self.success = []
6188 rajveer 21388 
          (_etype497, _size494) = iprot.readListBegin()
21389 
          for _i498 in xrange(_size494):
21390 
            _elem499 = Order()
21391 
            _elem499.read(iprot)
21392 
            self.success.append(_elem499)
4295 varun.gupt 21393 
          iprot.readListEnd()
21394 
        else:
21395 
          iprot.skip(ftype)
21396 
      else:
21397 
        iprot.skip(ftype)
21398 
      iprot.readFieldEnd()
21399 
    iprot.readStructEnd()
21400 
 
21401 
  def write(self, oprot):
21402 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21403 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21404 
      return
21405 
    oprot.writeStructBegin('getOrdersForItemIds_result')
21406 
    if self.success is not None:
21407 
      oprot.writeFieldBegin('success', TType.LIST, 0)
21408 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 21409 
      for iter500 in self.success:
21410 
        iter500.write(oprot)
4295 varun.gupt 21411 
      oprot.writeListEnd()
21412 
      oprot.writeFieldEnd()
21413 
    oprot.writeFieldStop()
21414 
    oprot.writeStructEnd()
21415 
 
21416 
  def validate(self):
21417 
    return
21418 
 
21419 
 
21420 
  def __repr__(self):
21421 
    L = ['%s=%r' % (key, value)
21422 
      for key, value in self.__dict__.iteritems()]
21423 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21424 
 
21425 
  def __eq__(self, other):
21426 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21427 
 
21428 
  def __ne__(self, other):
21429 
    return not (self == other)
21430 
 
4247 rajveer 21431 
class markOrderCancellationRequestReceived_args:
21432 
  """
21433 
  Attributes:
21434 
   - orderId
21435 
  """
21436 
 
21437 
  thrift_spec = (
21438 
    None, # 0
21439 
    (1, TType.I64, 'orderId', None, None, ), # 1
21440 
  )
21441 
 
21442 
  def __init__(self, orderId=None,):
21443 
    self.orderId = orderId
21444 
 
21445 
  def read(self, iprot):
21446 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21447 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21448 
      return
21449 
    iprot.readStructBegin()
21450 
    while True:
21451 
      (fname, ftype, fid) = iprot.readFieldBegin()
21452 
      if ftype == TType.STOP:
21453 
        break
21454 
      if fid == 1:
21455 
        if ftype == TType.I64:
21456 
          self.orderId = iprot.readI64();
21457 
        else:
21458 
          iprot.skip(ftype)
21459 
      else:
21460 
        iprot.skip(ftype)
21461 
      iprot.readFieldEnd()
21462 
    iprot.readStructEnd()
21463 
 
21464 
  def write(self, oprot):
21465 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21466 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21467 
      return
21468 
    oprot.writeStructBegin('markOrderCancellationRequestReceived_args')
21469 
    if self.orderId is not None:
21470 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
21471 
      oprot.writeI64(self.orderId)
21472 
      oprot.writeFieldEnd()
21473 
    oprot.writeFieldStop()
21474 
    oprot.writeStructEnd()
21475 
 
21476 
  def validate(self):
21477 
    return
21478 
 
21479 
 
21480 
  def __repr__(self):
21481 
    L = ['%s=%r' % (key, value)
21482 
      for key, value in self.__dict__.iteritems()]
21483 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21484 
 
21485 
  def __eq__(self, other):
21486 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21487 
 
21488 
  def __ne__(self, other):
21489 
    return not (self == other)
21490 
 
21491 
class markOrderCancellationRequestReceived_result:
21492 
  """
21493 
  Attributes:
21494 
   - ex
21495 
  """
21496 
 
21497 
  thrift_spec = (
21498 
    None, # 0
21499 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
21500 
  )
21501 
 
21502 
  def __init__(self, ex=None,):
21503 
    self.ex = ex
21504 
 
21505 
  def read(self, iprot):
21506 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21507 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21508 
      return
21509 
    iprot.readStructBegin()
21510 
    while True:
21511 
      (fname, ftype, fid) = iprot.readFieldBegin()
21512 
      if ftype == TType.STOP:
21513 
        break
21514 
      if fid == 1:
21515 
        if ftype == TType.STRUCT:
21516 
          self.ex = TransactionServiceException()
21517 
          self.ex.read(iprot)
21518 
        else:
21519 
          iprot.skip(ftype)
21520 
      else:
21521 
        iprot.skip(ftype)
21522 
      iprot.readFieldEnd()
21523 
    iprot.readStructEnd()
21524 
 
21525 
  def write(self, oprot):
21526 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21527 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21528 
      return
21529 
    oprot.writeStructBegin('markOrderCancellationRequestReceived_result')
21530 
    if self.ex is not None:
21531 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
21532 
      self.ex.write(oprot)
21533 
      oprot.writeFieldEnd()
21534 
    oprot.writeFieldStop()
21535 
    oprot.writeStructEnd()
21536 
 
21537 
  def validate(self):
21538 
    return
21539 
 
21540 
 
21541 
  def __repr__(self):
21542 
    L = ['%s=%r' % (key, value)
21543 
      for key, value in self.__dict__.iteritems()]
21544 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21545 
 
21546 
  def __eq__(self, other):
21547 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21548 
 
21549 
  def __ne__(self, other):
21550 
    return not (self == other)
21551 
 
21552 
class markOrderCancellationRequestConfirmed_args:
21553 
  """
21554 
  Attributes:
21555 
   - orderId
21556 
  """
21557 
 
21558 
  thrift_spec = (
21559 
    None, # 0
21560 
    (1, TType.I64, 'orderId', None, None, ), # 1
21561 
  )
21562 
 
21563 
  def __init__(self, orderId=None,):
21564 
    self.orderId = orderId
21565 
 
21566 
  def read(self, iprot):
21567 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21568 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21569 
      return
21570 
    iprot.readStructBegin()
21571 
    while True:
21572 
      (fname, ftype, fid) = iprot.readFieldBegin()
21573 
      if ftype == TType.STOP:
21574 
        break
21575 
      if fid == 1:
21576 
        if ftype == TType.I64:
21577 
          self.orderId = iprot.readI64();
21578 
        else:
21579 
          iprot.skip(ftype)
21580 
      else:
21581 
        iprot.skip(ftype)
21582 
      iprot.readFieldEnd()
21583 
    iprot.readStructEnd()
21584 
 
21585 
  def write(self, oprot):
21586 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21587 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21588 
      return
21589 
    oprot.writeStructBegin('markOrderCancellationRequestConfirmed_args')
21590 
    if self.orderId is not None:
21591 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
21592 
      oprot.writeI64(self.orderId)
21593 
      oprot.writeFieldEnd()
21594 
    oprot.writeFieldStop()
21595 
    oprot.writeStructEnd()
21596 
 
21597 
  def validate(self):
21598 
    return
21599 
 
21600 
 
21601 
  def __repr__(self):
21602 
    L = ['%s=%r' % (key, value)
21603 
      for key, value in self.__dict__.iteritems()]
21604 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21605 
 
21606 
  def __eq__(self, other):
21607 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21608 
 
21609 
  def __ne__(self, other):
21610 
    return not (self == other)
21611 
 
21612 
class markOrderCancellationRequestConfirmed_result:
21613 
  """
21614 
  Attributes:
21615 
   - ex
21616 
  """
21617 
 
21618 
  thrift_spec = (
21619 
    None, # 0
21620 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
21621 
  )
21622 
 
21623 
  def __init__(self, ex=None,):
21624 
    self.ex = ex
21625 
 
21626 
  def read(self, iprot):
21627 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21628 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21629 
      return
21630 
    iprot.readStructBegin()
21631 
    while True:
21632 
      (fname, ftype, fid) = iprot.readFieldBegin()
21633 
      if ftype == TType.STOP:
21634 
        break
21635 
      if fid == 1:
21636 
        if ftype == TType.STRUCT:
21637 
          self.ex = TransactionServiceException()
21638 
          self.ex.read(iprot)
21639 
        else:
21640 
          iprot.skip(ftype)
21641 
      else:
21642 
        iprot.skip(ftype)
21643 
      iprot.readFieldEnd()
21644 
    iprot.readStructEnd()
21645 
 
21646 
  def write(self, oprot):
21647 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21648 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21649 
      return
21650 
    oprot.writeStructBegin('markOrderCancellationRequestConfirmed_result')
21651 
    if self.ex is not None:
21652 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
21653 
      self.ex.write(oprot)
21654 
      oprot.writeFieldEnd()
21655 
    oprot.writeFieldStop()
21656 
    oprot.writeStructEnd()
21657 
 
21658 
  def validate(self):
21659 
    return
21660 
 
21661 
 
21662 
  def __repr__(self):
21663 
    L = ['%s=%r' % (key, value)
21664 
      for key, value in self.__dict__.iteritems()]
21665 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21666 
 
21667 
  def __eq__(self, other):
21668 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21669 
 
21670 
  def __ne__(self, other):
21671 
    return not (self == other)
21672 
 
21673 
class markOrderCancellationRequestDenied_args:
21674 
  """
21675 
  Attributes:
21676 
   - orderId
21677 
  """
21678 
 
21679 
  thrift_spec = (
21680 
    None, # 0
21681 
    (1, TType.I64, 'orderId', None, None, ), # 1
21682 
  )
21683 
 
21684 
  def __init__(self, orderId=None,):
21685 
    self.orderId = orderId
21686 
 
21687 
  def read(self, iprot):
21688 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21689 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21690 
      return
21691 
    iprot.readStructBegin()
21692 
    while True:
21693 
      (fname, ftype, fid) = iprot.readFieldBegin()
21694 
      if ftype == TType.STOP:
21695 
        break
21696 
      if fid == 1:
21697 
        if ftype == TType.I64:
21698 
          self.orderId = iprot.readI64();
21699 
        else:
21700 
          iprot.skip(ftype)
21701 
      else:
21702 
        iprot.skip(ftype)
21703 
      iprot.readFieldEnd()
21704 
    iprot.readStructEnd()
21705 
 
21706 
  def write(self, oprot):
21707 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21708 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21709 
      return
21710 
    oprot.writeStructBegin('markOrderCancellationRequestDenied_args')
21711 
    if self.orderId is not None:
21712 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
21713 
      oprot.writeI64(self.orderId)
21714 
      oprot.writeFieldEnd()
21715 
    oprot.writeFieldStop()
21716 
    oprot.writeStructEnd()
21717 
 
21718 
  def validate(self):
21719 
    return
21720 
 
21721 
 
21722 
  def __repr__(self):
21723 
    L = ['%s=%r' % (key, value)
21724 
      for key, value in self.__dict__.iteritems()]
21725 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21726 
 
21727 
  def __eq__(self, other):
21728 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21729 
 
21730 
  def __ne__(self, other):
21731 
    return not (self == other)
21732 
 
21733 
class markOrderCancellationRequestDenied_result:
21734 
  """
21735 
  Attributes:
21736 
   - ex
21737 
  """
21738 
 
21739 
  thrift_spec = (
21740 
    None, # 0
21741 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
21742 
  )
21743 
 
21744 
  def __init__(self, ex=None,):
21745 
    self.ex = ex
21746 
 
21747 
  def read(self, iprot):
21748 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21749 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21750 
      return
21751 
    iprot.readStructBegin()
21752 
    while True:
21753 
      (fname, ftype, fid) = iprot.readFieldBegin()
21754 
      if ftype == TType.STOP:
21755 
        break
21756 
      if fid == 1:
21757 
        if ftype == TType.STRUCT:
21758 
          self.ex = TransactionServiceException()
21759 
          self.ex.read(iprot)
21760 
        else:
21761 
          iprot.skip(ftype)
21762 
      else:
21763 
        iprot.skip(ftype)
21764 
      iprot.readFieldEnd()
21765 
    iprot.readStructEnd()
21766 
 
21767 
  def write(self, oprot):
21768 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21769 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21770 
      return
21771 
    oprot.writeStructBegin('markOrderCancellationRequestDenied_result')
21772 
    if self.ex is not None:
21773 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
21774 
      self.ex.write(oprot)
21775 
      oprot.writeFieldEnd()
21776 
    oprot.writeFieldStop()
21777 
    oprot.writeStructEnd()
21778 
 
21779 
  def validate(self):
21780 
    return
21781 
 
21782 
 
21783 
  def __repr__(self):
21784 
    L = ['%s=%r' % (key, value)
21785 
      for key, value in self.__dict__.iteritems()]
21786 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21787 
 
21788 
  def __eq__(self, other):
21789 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21790 
 
21791 
  def __ne__(self, other):
21792 
    return not (self == other)
21793 
 
4258 rajveer 21794 
class markTransactionAsPaymentFlagRemoved_args:
4247 rajveer 21795 
  """
21796 
  Attributes:
4258 rajveer 21797 
   - transactionId
4247 rajveer 21798 
  """
21799 
 
21800 
  thrift_spec = (
21801 
    None, # 0
4258 rajveer 21802 
    (1, TType.I64, 'transactionId', None, None, ), # 1
4247 rajveer 21803 
  )
21804 
 
4258 rajveer 21805 
  def __init__(self, transactionId=None,):
21806 
    self.transactionId = transactionId
4247 rajveer 21807 
 
21808 
  def read(self, iprot):
21809 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21810 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21811 
      return
21812 
    iprot.readStructBegin()
21813 
    while True:
21814 
      (fname, ftype, fid) = iprot.readFieldBegin()
21815 
      if ftype == TType.STOP:
21816 
        break
21817 
      if fid == 1:
21818 
        if ftype == TType.I64:
4258 rajveer 21819 
          self.transactionId = iprot.readI64();
4247 rajveer 21820 
        else:
21821 
          iprot.skip(ftype)
21822 
      else:
21823 
        iprot.skip(ftype)
21824 
      iprot.readFieldEnd()
21825 
    iprot.readStructEnd()
21826 
 
21827 
  def write(self, oprot):
21828 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21829 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21830 
      return
4258 rajveer 21831 
    oprot.writeStructBegin('markTransactionAsPaymentFlagRemoved_args')
21832 
    if self.transactionId is not None:
21833 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
21834 
      oprot.writeI64(self.transactionId)
4247 rajveer 21835 
      oprot.writeFieldEnd()
21836 
    oprot.writeFieldStop()
21837 
    oprot.writeStructEnd()
21838 
 
21839 
  def validate(self):
21840 
    return
21841 
 
21842 
 
21843 
  def __repr__(self):
21844 
    L = ['%s=%r' % (key, value)
21845 
      for key, value in self.__dict__.iteritems()]
21846 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21847 
 
21848 
  def __eq__(self, other):
21849 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21850 
 
21851 
  def __ne__(self, other):
21852 
    return not (self == other)
21853 
 
4258 rajveer 21854 
class markTransactionAsPaymentFlagRemoved_result:
4247 rajveer 21855 
  """
21856 
  Attributes:
21857 
   - ex
21858 
  """
21859 
 
21860 
  thrift_spec = (
21861 
    None, # 0
21862 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
21863 
  )
21864 
 
21865 
  def __init__(self, ex=None,):
21866 
    self.ex = ex
21867 
 
21868 
  def read(self, iprot):
21869 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21870 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21871 
      return
21872 
    iprot.readStructBegin()
21873 
    while True:
21874 
      (fname, ftype, fid) = iprot.readFieldBegin()
21875 
      if ftype == TType.STOP:
21876 
        break
21877 
      if fid == 1:
21878 
        if ftype == TType.STRUCT:
21879 
          self.ex = TransactionServiceException()
21880 
          self.ex.read(iprot)
21881 
        else:
21882 
          iprot.skip(ftype)
21883 
      else:
21884 
        iprot.skip(ftype)
21885 
      iprot.readFieldEnd()
21886 
    iprot.readStructEnd()
21887 
 
21888 
  def write(self, oprot):
21889 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21890 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21891 
      return
4258 rajveer 21892 
    oprot.writeStructBegin('markTransactionAsPaymentFlagRemoved_result')
4247 rajveer 21893 
    if self.ex is not None:
21894 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
21895 
      self.ex.write(oprot)
21896 
      oprot.writeFieldEnd()
21897 
    oprot.writeFieldStop()
21898 
    oprot.writeStructEnd()
21899 
 
21900 
  def validate(self):
21901 
    return
21902 
 
21903 
 
21904 
  def __repr__(self):
21905 
    L = ['%s=%r' % (key, value)
21906 
      for key, value in self.__dict__.iteritems()]
21907 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21908 
 
21909 
  def __eq__(self, other):
21910 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21911 
 
21912 
  def __ne__(self, other):
21913 
    return not (self == other)
4259 anupam.sin 21914 
 
21915 
class refundTransaction_args:
21916 
  """
21917 
  Attributes:
21918 
   - transactionId
21919 
   - refundedBy
21920 
   - reason
21921 
  """
21922 
 
21923 
  thrift_spec = (
21924 
    None, # 0
21925 
    (1, TType.I64, 'transactionId', None, None, ), # 1
21926 
    (2, TType.STRING, 'refundedBy', None, None, ), # 2
21927 
    (3, TType.STRING, 'reason', None, None, ), # 3
21928 
  )
21929 
 
21930 
  def __init__(self, transactionId=None, refundedBy=None, reason=None,):
21931 
    self.transactionId = transactionId
21932 
    self.refundedBy = refundedBy
21933 
    self.reason = reason
21934 
 
21935 
  def read(self, iprot):
21936 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21937 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21938 
      return
21939 
    iprot.readStructBegin()
21940 
    while True:
21941 
      (fname, ftype, fid) = iprot.readFieldBegin()
21942 
      if ftype == TType.STOP:
21943 
        break
21944 
      if fid == 1:
21945 
        if ftype == TType.I64:
21946 
          self.transactionId = iprot.readI64();
21947 
        else:
21948 
          iprot.skip(ftype)
21949 
      elif fid == 2:
21950 
        if ftype == TType.STRING:
21951 
          self.refundedBy = iprot.readString();
21952 
        else:
21953 
          iprot.skip(ftype)
21954 
      elif fid == 3:
21955 
        if ftype == TType.STRING:
21956 
          self.reason = iprot.readString();
21957 
        else:
21958 
          iprot.skip(ftype)
21959 
      else:
21960 
        iprot.skip(ftype)
21961 
      iprot.readFieldEnd()
21962 
    iprot.readStructEnd()
21963 
 
21964 
  def write(self, oprot):
21965 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21966 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21967 
      return
21968 
    oprot.writeStructBegin('refundTransaction_args')
21969 
    if self.transactionId is not None:
21970 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
21971 
      oprot.writeI64(self.transactionId)
21972 
      oprot.writeFieldEnd()
21973 
    if self.refundedBy is not None:
21974 
      oprot.writeFieldBegin('refundedBy', TType.STRING, 2)
21975 
      oprot.writeString(self.refundedBy)
21976 
      oprot.writeFieldEnd()
21977 
    if self.reason is not None:
21978 
      oprot.writeFieldBegin('reason', TType.STRING, 3)
21979 
      oprot.writeString(self.reason)
21980 
      oprot.writeFieldEnd()
21981 
    oprot.writeFieldStop()
21982 
    oprot.writeStructEnd()
21983 
 
21984 
  def validate(self):
21985 
    return
21986 
 
21987 
 
21988 
  def __repr__(self):
21989 
    L = ['%s=%r' % (key, value)
21990 
      for key, value in self.__dict__.iteritems()]
21991 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21992 
 
21993 
  def __eq__(self, other):
21994 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21995 
 
21996 
  def __ne__(self, other):
21997 
    return not (self == other)
21998 
 
21999 
class refundTransaction_result:
22000 
  """
22001 
  Attributes:
22002 
   - ex
22003 
  """
22004 
 
22005 
  thrift_spec = (
22006 
    None, # 0
22007 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
22008 
  )
22009 
 
22010 
  def __init__(self, ex=None,):
22011 
    self.ex = ex
22012 
 
22013 
  def read(self, iprot):
22014 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22015 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22016 
      return
22017 
    iprot.readStructBegin()
22018 
    while True:
22019 
      (fname, ftype, fid) = iprot.readFieldBegin()
22020 
      if ftype == TType.STOP:
22021 
        break
22022 
      if fid == 1:
22023 
        if ftype == TType.STRUCT:
22024 
          self.ex = TransactionServiceException()
22025 
          self.ex.read(iprot)
22026 
        else:
22027 
          iprot.skip(ftype)
22028 
      else:
22029 
        iprot.skip(ftype)
22030 
      iprot.readFieldEnd()
22031 
    iprot.readStructEnd()
22032 
 
22033 
  def write(self, oprot):
22034 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22035 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22036 
      return
22037 
    oprot.writeStructBegin('refundTransaction_result')
22038 
    if self.ex is not None:
22039 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
22040 
      self.ex.write(oprot)
22041 
      oprot.writeFieldEnd()
22042 
    oprot.writeFieldStop()
22043 
    oprot.writeStructEnd()
22044 
 
22045 
  def validate(self):
22046 
    return
22047 
 
22048 
 
22049 
  def __repr__(self):
22050 
    L = ['%s=%r' % (key, value)
22051 
      for key, value in self.__dict__.iteritems()]
22052 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22053 
 
22054 
  def __eq__(self, other):
22055 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22056 
 
22057 
  def __ne__(self, other):
22058 
    return not (self == other)
4285 rajveer 22059 
 
4324 mandeep.dh 22060 
class updateShipmentAddress_args:
22061 
  """
22062 
  Attributes:
22063 
   - orderId
22064 
   - addressId
22065 
  """
22066 
 
22067 
  thrift_spec = (
22068 
    None, # 0
22069 
    (1, TType.I64, 'orderId', None, None, ), # 1
22070 
    (2, TType.I64, 'addressId', None, None, ), # 2
22071 
  )
22072 
 
22073 
  def __init__(self, orderId=None, addressId=None,):
22074 
    self.orderId = orderId
22075 
    self.addressId = addressId
22076 
 
22077 
  def read(self, iprot):
22078 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22079 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22080 
      return
22081 
    iprot.readStructBegin()
22082 
    while True:
22083 
      (fname, ftype, fid) = iprot.readFieldBegin()
22084 
      if ftype == TType.STOP:
22085 
        break
22086 
      if fid == 1:
22087 
        if ftype == TType.I64:
22088 
          self.orderId = iprot.readI64();
22089 
        else:
22090 
          iprot.skip(ftype)
22091 
      elif fid == 2:
22092 
        if ftype == TType.I64:
22093 
          self.addressId = iprot.readI64();
22094 
        else:
22095 
          iprot.skip(ftype)
22096 
      else:
22097 
        iprot.skip(ftype)
22098 
      iprot.readFieldEnd()
22099 
    iprot.readStructEnd()
22100 
 
22101 
  def write(self, oprot):
22102 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22103 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22104 
      return
22105 
    oprot.writeStructBegin('updateShipmentAddress_args')
22106 
    if self.orderId is not None:
22107 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
22108 
      oprot.writeI64(self.orderId)
22109 
      oprot.writeFieldEnd()
22110 
    if self.addressId is not None:
22111 
      oprot.writeFieldBegin('addressId', TType.I64, 2)
22112 
      oprot.writeI64(self.addressId)
22113 
      oprot.writeFieldEnd()
22114 
    oprot.writeFieldStop()
22115 
    oprot.writeStructEnd()
22116 
 
22117 
  def validate(self):
22118 
    return
22119 
 
22120 
 
22121 
  def __repr__(self):
22122 
    L = ['%s=%r' % (key, value)
22123 
      for key, value in self.__dict__.iteritems()]
22124 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22125 
 
22126 
  def __eq__(self, other):
22127 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22128 
 
22129 
  def __ne__(self, other):
22130 
    return not (self == other)
22131 
 
22132 
class updateShipmentAddress_result:
22133 
  """
22134 
  Attributes:
22135 
   - ex
22136 
  """
22137 
 
22138 
  thrift_spec = (
22139 
    None, # 0
22140 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
22141 
  )
22142 
 
22143 
  def __init__(self, ex=None,):
22144 
    self.ex = ex
22145 
 
22146 
  def read(self, iprot):
22147 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22148 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22149 
      return
22150 
    iprot.readStructBegin()
22151 
    while True:
22152 
      (fname, ftype, fid) = iprot.readFieldBegin()
22153 
      if ftype == TType.STOP:
22154 
        break
22155 
      if fid == 1:
22156 
        if ftype == TType.STRUCT:
22157 
          self.ex = TransactionServiceException()
22158 
          self.ex.read(iprot)
22159 
        else:
22160 
          iprot.skip(ftype)
22161 
      else:
22162 
        iprot.skip(ftype)
22163 
      iprot.readFieldEnd()
22164 
    iprot.readStructEnd()
22165 
 
22166 
  def write(self, oprot):
22167 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22168 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22169 
      return
22170 
    oprot.writeStructBegin('updateShipmentAddress_result')
22171 
    if self.ex is not None:
22172 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
22173 
      self.ex.write(oprot)
22174 
      oprot.writeFieldEnd()
22175 
    oprot.writeFieldStop()
22176 
    oprot.writeStructEnd()
22177 
 
22178 
  def validate(self):
22179 
    return
22180 
 
22181 
 
22182 
  def __repr__(self):
22183 
    L = ['%s=%r' % (key, value)
22184 
      for key, value in self.__dict__.iteritems()]
22185 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22186 
 
22187 
  def __eq__(self, other):
22188 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22189 
 
22190 
  def __ne__(self, other):
22191 
    return not (self == other)
22192 
 
4285 rajveer 22193 
class acceptOrdersForItemId_args:
22194 
  """
22195 
  Attributes:
22196 
   - itemId
22197 
   - inventory
22198 
  """
22199 
 
22200 
  thrift_spec = (
22201 
    None, # 0
22202 
    (1, TType.I64, 'itemId', None, None, ), # 1
22203 
    (2, TType.I64, 'inventory', None, None, ), # 2
22204 
  )
22205 
 
22206 
  def __init__(self, itemId=None, inventory=None,):
22207 
    self.itemId = itemId
22208 
    self.inventory = inventory
22209 
 
22210 
  def read(self, iprot):
22211 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22212 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22213 
      return
22214 
    iprot.readStructBegin()
22215 
    while True:
22216 
      (fname, ftype, fid) = iprot.readFieldBegin()
22217 
      if ftype == TType.STOP:
22218 
        break
22219 
      if fid == 1:
22220 
        if ftype == TType.I64:
22221 
          self.itemId = iprot.readI64();
22222 
        else:
22223 
          iprot.skip(ftype)
22224 
      elif fid == 2:
22225 
        if ftype == TType.I64:
22226 
          self.inventory = iprot.readI64();
22227 
        else:
22228 
          iprot.skip(ftype)
22229 
      else:
22230 
        iprot.skip(ftype)
22231 
      iprot.readFieldEnd()
22232 
    iprot.readStructEnd()
22233 
 
22234 
  def write(self, oprot):
22235 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22236 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22237 
      return
22238 
    oprot.writeStructBegin('acceptOrdersForItemId_args')
22239 
    if self.itemId is not None:
22240 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
22241 
      oprot.writeI64(self.itemId)
22242 
      oprot.writeFieldEnd()
22243 
    if self.inventory is not None:
22244 
      oprot.writeFieldBegin('inventory', TType.I64, 2)
22245 
      oprot.writeI64(self.inventory)
22246 
      oprot.writeFieldEnd()
22247 
    oprot.writeFieldStop()
22248 
    oprot.writeStructEnd()
22249 
 
22250 
  def validate(self):
22251 
    return
22252 
 
22253 
 
22254 
  def __repr__(self):
22255 
    L = ['%s=%r' % (key, value)
22256 
      for key, value in self.__dict__.iteritems()]
22257 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22258 
 
22259 
  def __eq__(self, other):
22260 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22261 
 
22262 
  def __ne__(self, other):
22263 
    return not (self == other)
22264 
 
22265 
class acceptOrdersForItemId_result:
22266 
  """
22267 
  Attributes:
22268 
   - success
22269 
   - ex
22270 
  """
22271 
 
22272 
  thrift_spec = (
22273 
    (0, TType.BOOL, 'success', None, None, ), # 0
22274 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
22275 
  )
22276 
 
22277 
  def __init__(self, success=None, ex=None,):
22278 
    self.success = success
22279 
    self.ex = ex
22280 
 
22281 
  def read(self, iprot):
22282 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22283 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22284 
      return
22285 
    iprot.readStructBegin()
22286 
    while True:
22287 
      (fname, ftype, fid) = iprot.readFieldBegin()
22288 
      if ftype == TType.STOP:
22289 
        break
22290 
      if fid == 0:
22291 
        if ftype == TType.BOOL:
22292 
          self.success = iprot.readBool();
22293 
        else:
22294 
          iprot.skip(ftype)
22295 
      elif fid == 1:
22296 
        if ftype == TType.STRUCT:
22297 
          self.ex = TransactionServiceException()
22298 
          self.ex.read(iprot)
22299 
        else:
22300 
          iprot.skip(ftype)
22301 
      else:
22302 
        iprot.skip(ftype)
22303 
      iprot.readFieldEnd()
22304 
    iprot.readStructEnd()
22305 
 
22306 
  def write(self, oprot):
22307 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22308 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22309 
      return
22310 
    oprot.writeStructBegin('acceptOrdersForItemId_result')
22311 
    if self.success is not None:
22312 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
22313 
      oprot.writeBool(self.success)
22314 
      oprot.writeFieldEnd()
22315 
    if self.ex is not None:
22316 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
22317 
      self.ex.write(oprot)
22318 
      oprot.writeFieldEnd()
22319 
    oprot.writeFieldStop()
22320 
    oprot.writeStructEnd()
22321 
 
22322 
  def validate(self):
22323 
    return
22324 
 
22325 
 
22326 
  def __repr__(self):
22327 
    L = ['%s=%r' % (key, value)
22328 
      for key, value in self.__dict__.iteritems()]
22329 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22330 
 
22331 
  def __eq__(self, other):
22332 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22333 
 
22334 
  def __ne__(self, other):
22335 
    return not (self == other)
4303 rajveer 22336 
 
22337 
class markOrdersAsPORaised_args:
22338 
  """
22339 
  Attributes:
22340 
   - vendorId
22341 
   - itemId
22342 
   - quantity
22343 
   - estimate
4369 rajveer 22344 
   - isReminder
4303 rajveer 22345 
  """
22346 
 
22347 
  thrift_spec = (
22348 
    None, # 0
22349 
    (1, TType.I64, 'vendorId', None, None, ), # 1
22350 
    (2, TType.I64, 'itemId', None, None, ), # 2
22351 
    (3, TType.I64, 'quantity', None, None, ), # 3
22352 
    (4, TType.I64, 'estimate', None, None, ), # 4
4369 rajveer 22353 
    (5, TType.BOOL, 'isReminder', None, None, ), # 5
4303 rajveer 22354 
  )
22355 
 
4369 rajveer 22356 
  def __init__(self, vendorId=None, itemId=None, quantity=None, estimate=None, isReminder=None,):
4303 rajveer 22357 
    self.vendorId = vendorId
22358 
    self.itemId = itemId
22359 
    self.quantity = quantity
22360 
    self.estimate = estimate
4369 rajveer 22361 
    self.isReminder = isReminder
4303 rajveer 22362 
 
22363 
  def read(self, iprot):
22364 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22365 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22366 
      return
22367 
    iprot.readStructBegin()
22368 
    while True:
22369 
      (fname, ftype, fid) = iprot.readFieldBegin()
22370 
      if ftype == TType.STOP:
22371 
        break
22372 
      if fid == 1:
22373 
        if ftype == TType.I64:
22374 
          self.vendorId = iprot.readI64();
22375 
        else:
22376 
          iprot.skip(ftype)
22377 
      elif fid == 2:
22378 
        if ftype == TType.I64:
22379 
          self.itemId = iprot.readI64();
22380 
        else:
22381 
          iprot.skip(ftype)
22382 
      elif fid == 3:
22383 
        if ftype == TType.I64:
22384 
          self.quantity = iprot.readI64();
22385 
        else:
22386 
          iprot.skip(ftype)
22387 
      elif fid == 4:
22388 
        if ftype == TType.I64:
22389 
          self.estimate = iprot.readI64();
22390 
        else:
22391 
          iprot.skip(ftype)
4369 rajveer 22392 
      elif fid == 5:
22393 
        if ftype == TType.BOOL:
22394 
          self.isReminder = iprot.readBool();
22395 
        else:
22396 
          iprot.skip(ftype)
4303 rajveer 22397 
      else:
22398 
        iprot.skip(ftype)
22399 
      iprot.readFieldEnd()
22400 
    iprot.readStructEnd()
22401 
 
22402 
  def write(self, oprot):
22403 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22404 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22405 
      return
22406 
    oprot.writeStructBegin('markOrdersAsPORaised_args')
22407 
    if self.vendorId is not None:
22408 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
22409 
      oprot.writeI64(self.vendorId)
22410 
      oprot.writeFieldEnd()
22411 
    if self.itemId is not None:
22412 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
22413 
      oprot.writeI64(self.itemId)
22414 
      oprot.writeFieldEnd()
22415 
    if self.quantity is not None:
22416 
      oprot.writeFieldBegin('quantity', TType.I64, 3)
22417 
      oprot.writeI64(self.quantity)
22418 
      oprot.writeFieldEnd()
22419 
    if self.estimate is not None:
22420 
      oprot.writeFieldBegin('estimate', TType.I64, 4)
22421 
      oprot.writeI64(self.estimate)
22422 
      oprot.writeFieldEnd()
4369 rajveer 22423 
    if self.isReminder is not None:
22424 
      oprot.writeFieldBegin('isReminder', TType.BOOL, 5)
22425 
      oprot.writeBool(self.isReminder)
22426 
      oprot.writeFieldEnd()
4303 rajveer 22427 
    oprot.writeFieldStop()
22428 
    oprot.writeStructEnd()
22429 
 
22430 
  def validate(self):
22431 
    return
22432 
 
22433 
 
22434 
  def __repr__(self):
22435 
    L = ['%s=%r' % (key, value)
22436 
      for key, value in self.__dict__.iteritems()]
22437 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22438 
 
22439 
  def __eq__(self, other):
22440 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22441 
 
22442 
  def __ne__(self, other):
22443 
    return not (self == other)
22444 
 
22445 
class markOrdersAsPORaised_result:
22446 
  """
22447 
  Attributes:
22448 
   - ex
22449 
  """
22450 
 
22451 
  thrift_spec = (
22452 
    None, # 0
22453 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
22454 
  )
22455 
 
22456 
  def __init__(self, ex=None,):
22457 
    self.ex = ex
22458 
 
22459 
  def read(self, iprot):
22460 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22461 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22462 
      return
22463 
    iprot.readStructBegin()
22464 
    while True:
22465 
      (fname, ftype, fid) = iprot.readFieldBegin()
22466 
      if ftype == TType.STOP:
22467 
        break
22468 
      if fid == 1:
22469 
        if ftype == TType.STRUCT:
22470 
          self.ex = TransactionServiceException()
22471 
          self.ex.read(iprot)
22472 
        else:
22473 
          iprot.skip(ftype)
22474 
      else:
22475 
        iprot.skip(ftype)
22476 
      iprot.readFieldEnd()
22477 
    iprot.readStructEnd()
22478 
 
22479 
  def write(self, oprot):
22480 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22481 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22482 
      return
22483 
    oprot.writeStructBegin('markOrdersAsPORaised_result')
22484 
    if self.ex is not None:
22485 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
22486 
      self.ex.write(oprot)
22487 
      oprot.writeFieldEnd()
22488 
    oprot.writeFieldStop()
22489 
    oprot.writeStructEnd()
22490 
 
22491 
  def validate(self):
22492 
    return
22493 
 
22494 
 
22495 
  def __repr__(self):
22496 
    L = ['%s=%r' % (key, value)
22497 
      for key, value in self.__dict__.iteritems()]
22498 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22499 
 
22500 
  def __eq__(self, other):
22501 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22502 
 
22503 
  def __ne__(self, other):
22504 
    return not (self == other)
22505 
 
22506 
class markOrdersAsReversalInitiated_args:
22507 
  """
22508 
  Attributes:
22509 
   - vendorId
22510 
   - itemId
22511 
   - quantity
22512 
   - estimate
4369 rajveer 22513 
   - isReminder
4303 rajveer 22514 
  """
22515 
 
22516 
  thrift_spec = (
22517 
    None, # 0
22518 
    (1, TType.I64, 'vendorId', None, None, ), # 1
22519 
    (2, TType.I64, 'itemId', None, None, ), # 2
22520 
    (3, TType.I64, 'quantity', None, None, ), # 3
22521 
    (4, TType.I64, 'estimate', None, None, ), # 4
4369 rajveer 22522 
    (5, TType.BOOL, 'isReminder', None, None, ), # 5
4303 rajveer 22523 
  )
22524 
 
4369 rajveer 22525 
  def __init__(self, vendorId=None, itemId=None, quantity=None, estimate=None, isReminder=None,):
4303 rajveer 22526 
    self.vendorId = vendorId
22527 
    self.itemId = itemId
22528 
    self.quantity = quantity
22529 
    self.estimate = estimate
4369 rajveer 22530 
    self.isReminder = isReminder
4303 rajveer 22531 
 
22532 
  def read(self, iprot):
22533 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22534 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22535 
      return
22536 
    iprot.readStructBegin()
22537 
    while True:
22538 
      (fname, ftype, fid) = iprot.readFieldBegin()
22539 
      if ftype == TType.STOP:
22540 
        break
22541 
      if fid == 1:
22542 
        if ftype == TType.I64:
22543 
          self.vendorId = iprot.readI64();
22544 
        else:
22545 
          iprot.skip(ftype)
22546 
      elif fid == 2:
22547 
        if ftype == TType.I64:
22548 
          self.itemId = iprot.readI64();
22549 
        else:
22550 
          iprot.skip(ftype)
22551 
      elif fid == 3:
22552 
        if ftype == TType.I64:
22553 
          self.quantity = iprot.readI64();
22554 
        else:
22555 
          iprot.skip(ftype)
22556 
      elif fid == 4:
22557 
        if ftype == TType.I64:
22558 
          self.estimate = iprot.readI64();
22559 
        else:
22560 
          iprot.skip(ftype)
4369 rajveer 22561 
      elif fid == 5:
22562 
        if ftype == TType.BOOL:
22563 
          self.isReminder = iprot.readBool();
22564 
        else:
22565 
          iprot.skip(ftype)
4303 rajveer 22566 
      else:
22567 
        iprot.skip(ftype)
22568 
      iprot.readFieldEnd()
22569 
    iprot.readStructEnd()
22570 
 
22571 
  def write(self, oprot):
22572 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22573 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22574 
      return
22575 
    oprot.writeStructBegin('markOrdersAsReversalInitiated_args')
22576 
    if self.vendorId is not None:
22577 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
22578 
      oprot.writeI64(self.vendorId)
22579 
      oprot.writeFieldEnd()
22580 
    if self.itemId is not None:
22581 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
22582 
      oprot.writeI64(self.itemId)
22583 
      oprot.writeFieldEnd()
22584 
    if self.quantity is not None:
22585 
      oprot.writeFieldBegin('quantity', TType.I64, 3)
22586 
      oprot.writeI64(self.quantity)
22587 
      oprot.writeFieldEnd()
22588 
    if self.estimate is not None:
22589 
      oprot.writeFieldBegin('estimate', TType.I64, 4)
22590 
      oprot.writeI64(self.estimate)
22591 
      oprot.writeFieldEnd()
4369 rajveer 22592 
    if self.isReminder is not None:
22593 
      oprot.writeFieldBegin('isReminder', TType.BOOL, 5)
22594 
      oprot.writeBool(self.isReminder)
22595 
      oprot.writeFieldEnd()
4303 rajveer 22596 
    oprot.writeFieldStop()
22597 
    oprot.writeStructEnd()
22598 
 
22599 
  def validate(self):
22600 
    return
22601 
 
22602 
 
22603 
  def __repr__(self):
22604 
    L = ['%s=%r' % (key, value)
22605 
      for key, value in self.__dict__.iteritems()]
22606 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22607 
 
22608 
  def __eq__(self, other):
22609 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22610 
 
22611 
  def __ne__(self, other):
22612 
    return not (self == other)
22613 
 
22614 
class markOrdersAsReversalInitiated_result:
22615 
  """
22616 
  Attributes:
22617 
   - ex
22618 
  """
22619 
 
22620 
  thrift_spec = (
22621 
    None, # 0
22622 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
22623 
  )
22624 
 
22625 
  def __init__(self, ex=None,):
22626 
    self.ex = ex
22627 
 
22628 
  def read(self, iprot):
22629 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22630 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22631 
      return
22632 
    iprot.readStructBegin()
22633 
    while True:
22634 
      (fname, ftype, fid) = iprot.readFieldBegin()
22635 
      if ftype == TType.STOP:
22636 
        break
22637 
      if fid == 1:
22638 
        if ftype == TType.STRUCT:
22639 
          self.ex = TransactionServiceException()
22640 
          self.ex.read(iprot)
22641 
        else:
22642 
          iprot.skip(ftype)
22643 
      else:
22644 
        iprot.skip(ftype)
22645 
      iprot.readFieldEnd()
22646 
    iprot.readStructEnd()
22647 
 
22648 
  def write(self, oprot):
22649 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22650 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22651 
      return
22652 
    oprot.writeStructBegin('markOrdersAsReversalInitiated_result')
22653 
    if self.ex is not None:
22654 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
22655 
      self.ex.write(oprot)
22656 
      oprot.writeFieldEnd()
22657 
    oprot.writeFieldStop()
22658 
    oprot.writeStructEnd()
22659 
 
22660 
  def validate(self):
22661 
    return
22662 
 
22663 
 
22664 
  def __repr__(self):
22665 
    L = ['%s=%r' % (key, value)
22666 
      for key, value in self.__dict__.iteritems()]
22667 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22668 
 
22669 
  def __eq__(self, other):
22670 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22671 
 
22672 
  def __ne__(self, other):
22673 
    return not (self == other)
22674 
 
22675 
class markOrdersAsNotAvailabke_args:
22676 
  """
22677 
  Attributes:
22678 
   - vendorId
22679 
   - itemId
22680 
   - quantity
22681 
   - estimate
4369 rajveer 22682 
   - isReminder
4303 rajveer 22683 
  """
22684 
 
22685 
  thrift_spec = (
22686 
    None, # 0
22687 
    (1, TType.I64, 'vendorId', None, None, ), # 1
22688 
    (2, TType.I64, 'itemId', None, None, ), # 2
22689 
    (3, TType.I64, 'quantity', None, None, ), # 3
22690 
    (4, TType.I64, 'estimate', None, None, ), # 4
4369 rajveer 22691 
    (5, TType.BOOL, 'isReminder', None, None, ), # 5
4303 rajveer 22692 
  )
22693 
 
4369 rajveer 22694 
  def __init__(self, vendorId=None, itemId=None, quantity=None, estimate=None, isReminder=None,):
4303 rajveer 22695 
    self.vendorId = vendorId
22696 
    self.itemId = itemId
22697 
    self.quantity = quantity
22698 
    self.estimate = estimate
4369 rajveer 22699 
    self.isReminder = isReminder
4303 rajveer 22700 
 
22701 
  def read(self, iprot):
22702 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22703 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22704 
      return
22705 
    iprot.readStructBegin()
22706 
    while True:
22707 
      (fname, ftype, fid) = iprot.readFieldBegin()
22708 
      if ftype == TType.STOP:
22709 
        break
22710 
      if fid == 1:
22711 
        if ftype == TType.I64:
22712 
          self.vendorId = iprot.readI64();
22713 
        else:
22714 
          iprot.skip(ftype)
22715 
      elif fid == 2:
22716 
        if ftype == TType.I64:
22717 
          self.itemId = iprot.readI64();
22718 
        else:
22719 
          iprot.skip(ftype)
22720 
      elif fid == 3:
22721 
        if ftype == TType.I64:
22722 
          self.quantity = iprot.readI64();
22723 
        else:
22724 
          iprot.skip(ftype)
22725 
      elif fid == 4:
22726 
        if ftype == TType.I64:
22727 
          self.estimate = iprot.readI64();
22728 
        else:
22729 
          iprot.skip(ftype)
4369 rajveer 22730 
      elif fid == 5:
22731 
        if ftype == TType.BOOL:
22732 
          self.isReminder = iprot.readBool();
22733 
        else:
22734 
          iprot.skip(ftype)
4303 rajveer 22735 
      else:
22736 
        iprot.skip(ftype)
22737 
      iprot.readFieldEnd()
22738 
    iprot.readStructEnd()
22739 
 
22740 
  def write(self, oprot):
22741 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22742 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22743 
      return
22744 
    oprot.writeStructBegin('markOrdersAsNotAvailabke_args')
22745 
    if self.vendorId is not None:
22746 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
22747 
      oprot.writeI64(self.vendorId)
22748 
      oprot.writeFieldEnd()
22749 
    if self.itemId is not None:
22750 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
22751 
      oprot.writeI64(self.itemId)
22752 
      oprot.writeFieldEnd()
22753 
    if self.quantity is not None:
22754 
      oprot.writeFieldBegin('quantity', TType.I64, 3)
22755 
      oprot.writeI64(self.quantity)
22756 
      oprot.writeFieldEnd()
22757 
    if self.estimate is not None:
22758 
      oprot.writeFieldBegin('estimate', TType.I64, 4)
22759 
      oprot.writeI64(self.estimate)
22760 
      oprot.writeFieldEnd()
4369 rajveer 22761 
    if self.isReminder is not None:
22762 
      oprot.writeFieldBegin('isReminder', TType.BOOL, 5)
22763 
      oprot.writeBool(self.isReminder)
22764 
      oprot.writeFieldEnd()
4303 rajveer 22765 
    oprot.writeFieldStop()
22766 
    oprot.writeStructEnd()
22767 
 
22768 
  def validate(self):
22769 
    return
22770 
 
22771 
 
22772 
  def __repr__(self):
22773 
    L = ['%s=%r' % (key, value)
22774 
      for key, value in self.__dict__.iteritems()]
22775 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22776 
 
22777 
  def __eq__(self, other):
22778 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22779 
 
22780 
  def __ne__(self, other):
22781 
    return not (self == other)
22782 
 
22783 
class markOrdersAsNotAvailabke_result:
22784 
  """
22785 
  Attributes:
22786 
   - ex
22787 
  """
22788 
 
22789 
  thrift_spec = (
22790 
    None, # 0
22791 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
22792 
  )
22793 
 
22794 
  def __init__(self, ex=None,):
22795 
    self.ex = ex
22796 
 
22797 
  def read(self, iprot):
22798 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22799 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22800 
      return
22801 
    iprot.readStructBegin()
22802 
    while True:
22803 
      (fname, ftype, fid) = iprot.readFieldBegin()
22804 
      if ftype == TType.STOP:
22805 
        break
22806 
      if fid == 1:
22807 
        if ftype == TType.STRUCT:
22808 
          self.ex = TransactionServiceException()
22809 
          self.ex.read(iprot)
22810 
        else:
22811 
          iprot.skip(ftype)
22812 
      else:
22813 
        iprot.skip(ftype)
22814 
      iprot.readFieldEnd()
22815 
    iprot.readStructEnd()
22816 
 
22817 
  def write(self, oprot):
22818 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22819 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22820 
      return
22821 
    oprot.writeStructBegin('markOrdersAsNotAvailabke_result')
22822 
    if self.ex is not None:
22823 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
22824 
      self.ex.write(oprot)
22825 
      oprot.writeFieldEnd()
22826 
    oprot.writeFieldStop()
22827 
    oprot.writeStructEnd()
22828 
 
22829 
  def validate(self):
22830 
    return
22831 
 
22832 
 
22833 
  def __repr__(self):
22834 
    L = ['%s=%r' % (key, value)
22835 
      for key, value in self.__dict__.iteritems()]
22836 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22837 
 
22838 
  def __eq__(self, other):
22839 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22840 
 
22841 
  def __ne__(self, other):
22842 
    return not (self == other)
4369 rajveer 22843 
 
22844 
class markOrdersAsTimeout_args:
22845 
  """
22846 
  Attributes:
22847 
   - vendorId
22848 
  """
22849 
 
22850 
  thrift_spec = (
22851 
    None, # 0
22852 
    (1, TType.I64, 'vendorId', None, None, ), # 1
22853 
  )
22854 
 
22855 
  def __init__(self, vendorId=None,):
22856 
    self.vendorId = vendorId
22857 
 
22858 
  def read(self, iprot):
22859 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22860 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22861 
      return
22862 
    iprot.readStructBegin()
22863 
    while True:
22864 
      (fname, ftype, fid) = iprot.readFieldBegin()
22865 
      if ftype == TType.STOP:
22866 
        break
22867 
      if fid == 1:
22868 
        if ftype == TType.I64:
22869 
          self.vendorId = iprot.readI64();
22870 
        else:
22871 
          iprot.skip(ftype)
22872 
      else:
22873 
        iprot.skip(ftype)
22874 
      iprot.readFieldEnd()
22875 
    iprot.readStructEnd()
22876 
 
22877 
  def write(self, oprot):
22878 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22879 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22880 
      return
22881 
    oprot.writeStructBegin('markOrdersAsTimeout_args')
22882 
    if self.vendorId is not None:
22883 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
22884 
      oprot.writeI64(self.vendorId)
22885 
      oprot.writeFieldEnd()
22886 
    oprot.writeFieldStop()
22887 
    oprot.writeStructEnd()
22888 
 
22889 
  def validate(self):
22890 
    return
22891 
 
22892 
 
22893 
  def __repr__(self):
22894 
    L = ['%s=%r' % (key, value)
22895 
      for key, value in self.__dict__.iteritems()]
22896 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22897 
 
22898 
  def __eq__(self, other):
22899 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22900 
 
22901 
  def __ne__(self, other):
22902 
    return not (self == other)
22903 
 
22904 
class markOrdersAsTimeout_result:
22905 
  """
22906 
  Attributes:
22907 
   - success
22908 
   - ex
22909 
  """
22910 
 
22911 
  thrift_spec = (
22912 
    (0, TType.MAP, 'success', (TType.I32,None,TType.STRUCT,(TimeoutSummary, TimeoutSummary.thrift_spec)), None, ), # 0
22913 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
22914 
  )
22915 
 
22916 
  def __init__(self, success=None, ex=None,):
22917 
    self.success = success
22918 
    self.ex = ex
22919 
 
22920 
  def read(self, iprot):
22921 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22922 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22923 
      return
22924 
    iprot.readStructBegin()
22925 
    while True:
22926 
      (fname, ftype, fid) = iprot.readFieldBegin()
22927 
      if ftype == TType.STOP:
22928 
        break
22929 
      if fid == 0:
22930 
        if ftype == TType.MAP:
22931 
          self.success = {}
6188 rajveer 22932 
          (_ktype502, _vtype503, _size501 ) = iprot.readMapBegin()
22933 
          for _i505 in xrange(_size501):
22934 
            _key506 = iprot.readI32();
22935 
            _val507 = TimeoutSummary()
22936 
            _val507.read(iprot)
22937 
            self.success[_key506] = _val507
4369 rajveer 22938 
          iprot.readMapEnd()
22939 
        else:
22940 
          iprot.skip(ftype)
22941 
      elif fid == 1:
22942 
        if ftype == TType.STRUCT:
22943 
          self.ex = TransactionServiceException()
22944 
          self.ex.read(iprot)
22945 
        else:
22946 
          iprot.skip(ftype)
22947 
      else:
22948 
        iprot.skip(ftype)
22949 
      iprot.readFieldEnd()
22950 
    iprot.readStructEnd()
22951 
 
22952 
  def write(self, oprot):
22953 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22954 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22955 
      return
22956 
    oprot.writeStructBegin('markOrdersAsTimeout_result')
22957 
    if self.success is not None:
22958 
      oprot.writeFieldBegin('success', TType.MAP, 0)
22959 
      oprot.writeMapBegin(TType.I32, TType.STRUCT, len(self.success))
6188 rajveer 22960 
      for kiter508,viter509 in self.success.items():
22961 
        oprot.writeI32(kiter508)
22962 
        viter509.write(oprot)
4369 rajveer 22963 
      oprot.writeMapEnd()
22964 
      oprot.writeFieldEnd()
22965 
    if self.ex is not None:
22966 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
22967 
      self.ex.write(oprot)
22968 
      oprot.writeFieldEnd()
22969 
    oprot.writeFieldStop()
22970 
    oprot.writeStructEnd()
22971 
 
22972 
  def validate(self):
22973 
    return
22974 
 
22975 
 
22976 
  def __repr__(self):
22977 
    L = ['%s=%r' % (key, value)
22978 
      for key, value in self.__dict__.iteritems()]
22979 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22980 
 
22981 
  def __eq__(self, other):
22982 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22983 
 
22984 
  def __ne__(self, other):
22985 
    return not (self == other)
4386 anupam.sin 22986 
 
4662 rajveer 22987 
class markOrderAsLostInTransit_args:
22988 
  """
22989 
  Attributes:
22990 
   - orderId
22991 
  """
22992 
 
22993 
  thrift_spec = (
22994 
    None, # 0
22995 
    (1, TType.I64, 'orderId', None, None, ), # 1
22996 
  )
22997 
 
22998 
  def __init__(self, orderId=None,):
22999 
    self.orderId = orderId
23000 
 
23001 
  def read(self, iprot):
23002 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23003 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23004 
      return
23005 
    iprot.readStructBegin()
23006 
    while True:
23007 
      (fname, ftype, fid) = iprot.readFieldBegin()
23008 
      if ftype == TType.STOP:
23009 
        break
23010 
      if fid == 1:
23011 
        if ftype == TType.I64:
23012 
          self.orderId = iprot.readI64();
23013 
        else:
23014 
          iprot.skip(ftype)
23015 
      else:
23016 
        iprot.skip(ftype)
23017 
      iprot.readFieldEnd()
23018 
    iprot.readStructEnd()
23019 
 
23020 
  def write(self, oprot):
23021 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23022 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23023 
      return
23024 
    oprot.writeStructBegin('markOrderAsLostInTransit_args')
23025 
    if self.orderId is not None:
23026 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
23027 
      oprot.writeI64(self.orderId)
23028 
      oprot.writeFieldEnd()
23029 
    oprot.writeFieldStop()
23030 
    oprot.writeStructEnd()
23031 
 
23032 
  def validate(self):
23033 
    return
23034 
 
23035 
 
23036 
  def __repr__(self):
23037 
    L = ['%s=%r' % (key, value)
23038 
      for key, value in self.__dict__.iteritems()]
23039 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23040 
 
23041 
  def __eq__(self, other):
23042 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23043 
 
23044 
  def __ne__(self, other):
23045 
    return not (self == other)
23046 
 
23047 
class markOrderAsLostInTransit_result:
23048 
  """
23049 
  Attributes:
23050 
   - success
23051 
   - ex
23052 
  """
23053 
 
23054 
  thrift_spec = (
23055 
    (0, TType.BOOL, 'success', None, None, ), # 0
23056 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
23057 
  )
23058 
 
23059 
  def __init__(self, success=None, ex=None,):
23060 
    self.success = success
23061 
    self.ex = ex
23062 
 
23063 
  def read(self, iprot):
23064 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23065 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23066 
      return
23067 
    iprot.readStructBegin()
23068 
    while True:
23069 
      (fname, ftype, fid) = iprot.readFieldBegin()
23070 
      if ftype == TType.STOP:
23071 
        break
23072 
      if fid == 0:
23073 
        if ftype == TType.BOOL:
23074 
          self.success = iprot.readBool();
23075 
        else:
23076 
          iprot.skip(ftype)
23077 
      elif fid == 1:
23078 
        if ftype == TType.STRUCT:
23079 
          self.ex = TransactionServiceException()
23080 
          self.ex.read(iprot)
23081 
        else:
23082 
          iprot.skip(ftype)
23083 
      else:
23084 
        iprot.skip(ftype)
23085 
      iprot.readFieldEnd()
23086 
    iprot.readStructEnd()
23087 
 
23088 
  def write(self, oprot):
23089 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23090 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23091 
      return
23092 
    oprot.writeStructBegin('markOrderAsLostInTransit_result')
23093 
    if self.success is not None:
23094 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
23095 
      oprot.writeBool(self.success)
23096 
      oprot.writeFieldEnd()
23097 
    if self.ex is not None:
23098 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
23099 
      self.ex.write(oprot)
23100 
      oprot.writeFieldEnd()
23101 
    oprot.writeFieldStop()
23102 
    oprot.writeStructEnd()
23103 
 
23104 
  def validate(self):
23105 
    return
23106 
 
23107 
 
23108 
  def __repr__(self):
23109 
    L = ['%s=%r' % (key, value)
23110 
      for key, value in self.__dict__.iteritems()]
23111 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23112 
 
23113 
  def __eq__(self, other):
23114 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23115 
 
23116 
  def __ne__(self, other):
23117 
    return not (self == other)
23118 
 
4386 anupam.sin 23119 
class getOrderForAwb_args:
23120 
  """
23121 
  Attributes:
23122 
   - awb
23123 
  """
23124 
 
23125 
  thrift_spec = (
23126 
    None, # 0
23127 
    (1, TType.STRING, 'awb', None, None, ), # 1
23128 
  )
23129 
 
23130 
  def __init__(self, awb=None,):
23131 
    self.awb = awb
23132 
 
23133 
  def read(self, iprot):
23134 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23135 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23136 
      return
23137 
    iprot.readStructBegin()
23138 
    while True:
23139 
      (fname, ftype, fid) = iprot.readFieldBegin()
23140 
      if ftype == TType.STOP:
23141 
        break
23142 
      if fid == 1:
23143 
        if ftype == TType.STRING:
23144 
          self.awb = iprot.readString();
23145 
        else:
23146 
          iprot.skip(ftype)
23147 
      else:
23148 
        iprot.skip(ftype)
23149 
      iprot.readFieldEnd()
23150 
    iprot.readStructEnd()
23151 
 
23152 
  def write(self, oprot):
23153 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23154 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23155 
      return
23156 
    oprot.writeStructBegin('getOrderForAwb_args')
23157 
    if self.awb is not None:
23158 
      oprot.writeFieldBegin('awb', TType.STRING, 1)
23159 
      oprot.writeString(self.awb)
23160 
      oprot.writeFieldEnd()
23161 
    oprot.writeFieldStop()
23162 
    oprot.writeStructEnd()
23163 
 
23164 
  def validate(self):
23165 
    return
23166 
 
23167 
 
23168 
  def __repr__(self):
23169 
    L = ['%s=%r' % (key, value)
23170 
      for key, value in self.__dict__.iteritems()]
23171 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23172 
 
23173 
  def __eq__(self, other):
23174 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23175 
 
23176 
  def __ne__(self, other):
23177 
    return not (self == other)
23178 
 
23179 
class getOrderForAwb_result:
23180 
  """
23181 
  Attributes:
23182 
   - success
23183 
   - ex
23184 
  """
23185 
 
23186 
  thrift_spec = (
23187 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
23188 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
23189 
  )
23190 
 
23191 
  def __init__(self, success=None, ex=None,):
23192 
    self.success = success
23193 
    self.ex = ex
23194 
 
23195 
  def read(self, iprot):
23196 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23197 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23198 
      return
23199 
    iprot.readStructBegin()
23200 
    while True:
23201 
      (fname, ftype, fid) = iprot.readFieldBegin()
23202 
      if ftype == TType.STOP:
23203 
        break
23204 
      if fid == 0:
23205 
        if ftype == TType.STRUCT:
23206 
          self.success = Order()
23207 
          self.success.read(iprot)
23208 
        else:
23209 
          iprot.skip(ftype)
23210 
      elif fid == 1:
23211 
        if ftype == TType.STRUCT:
23212 
          self.ex = TransactionServiceException()
23213 
          self.ex.read(iprot)
23214 
        else:
23215 
          iprot.skip(ftype)
23216 
      else:
23217 
        iprot.skip(ftype)
23218 
      iprot.readFieldEnd()
23219 
    iprot.readStructEnd()
23220 
 
23221 
  def write(self, oprot):
23222 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23223 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23224 
      return
23225 
    oprot.writeStructBegin('getOrderForAwb_result')
23226 
    if self.success is not None:
23227 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
23228 
      self.success.write(oprot)
23229 
      oprot.writeFieldEnd()
23230 
    if self.ex is not None:
23231 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
23232 
      self.ex.write(oprot)
23233 
      oprot.writeFieldEnd()
23234 
    oprot.writeFieldStop()
23235 
    oprot.writeStructEnd()
23236 
 
23237 
  def validate(self):
23238 
    return
23239 
 
23240 
 
23241 
  def __repr__(self):
23242 
    L = ['%s=%r' % (key, value)
23243 
      for key, value in self.__dict__.iteritems()]
23244 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23245 
 
23246 
  def __eq__(self, other):
23247 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23248 
 
23249 
  def __ne__(self, other):
23250 
    return not (self == other)
4506 phani.kuma 23251 
 
23252 
class getOrdersForProviderForStatus_args:
23253 
  """
23254 
  Attributes:
23255 
   - logistics_provider_id
4910 phani.kuma 23256 
   - order_status_list
4506 phani.kuma 23257 
  """
23258 
 
23259 
  thrift_spec = (
23260 
    None, # 0
23261 
    (1, TType.I64, 'logistics_provider_id', None, None, ), # 1
4910 phani.kuma 23262 
    (2, TType.LIST, 'order_status_list', (TType.I32,None), None, ), # 2
4506 phani.kuma 23263 
  )
23264 
 
4910 phani.kuma 23265 
  def __init__(self, logistics_provider_id=None, order_status_list=None,):
4506 phani.kuma 23266 
    self.logistics_provider_id = logistics_provider_id
4910 phani.kuma 23267 
    self.order_status_list = order_status_list
4506 phani.kuma 23268 
 
23269 
  def read(self, iprot):
23270 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23271 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23272 
      return
23273 
    iprot.readStructBegin()
23274 
    while True:
23275 
      (fname, ftype, fid) = iprot.readFieldBegin()
23276 
      if ftype == TType.STOP:
23277 
        break
23278 
      if fid == 1:
23279 
        if ftype == TType.I64:
23280 
          self.logistics_provider_id = iprot.readI64();
23281 
        else:
23282 
          iprot.skip(ftype)
23283 
      elif fid == 2:
4910 phani.kuma 23284 
        if ftype == TType.LIST:
23285 
          self.order_status_list = []
6188 rajveer 23286 
          (_etype513, _size510) = iprot.readListBegin()
23287 
          for _i514 in xrange(_size510):
23288 
            _elem515 = iprot.readI32();
23289 
            self.order_status_list.append(_elem515)
4910 phani.kuma 23290 
          iprot.readListEnd()
4506 phani.kuma 23291 
        else:
23292 
          iprot.skip(ftype)
23293 
      else:
23294 
        iprot.skip(ftype)
23295 
      iprot.readFieldEnd()
23296 
    iprot.readStructEnd()
23297 
 
23298 
  def write(self, oprot):
23299 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23300 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23301 
      return
23302 
    oprot.writeStructBegin('getOrdersForProviderForStatus_args')
23303 
    if self.logistics_provider_id is not None:
23304 
      oprot.writeFieldBegin('logistics_provider_id', TType.I64, 1)
23305 
      oprot.writeI64(self.logistics_provider_id)
23306 
      oprot.writeFieldEnd()
4910 phani.kuma 23307 
    if self.order_status_list is not None:
23308 
      oprot.writeFieldBegin('order_status_list', TType.LIST, 2)
23309 
      oprot.writeListBegin(TType.I32, len(self.order_status_list))
6188 rajveer 23310 
      for iter516 in self.order_status_list:
23311 
        oprot.writeI32(iter516)
4910 phani.kuma 23312 
      oprot.writeListEnd()
4506 phani.kuma 23313 
      oprot.writeFieldEnd()
23314 
    oprot.writeFieldStop()
23315 
    oprot.writeStructEnd()
23316 
 
23317 
  def validate(self):
23318 
    return
23319 
 
23320 
 
23321 
  def __repr__(self):
23322 
    L = ['%s=%r' % (key, value)
23323 
      for key, value in self.__dict__.iteritems()]
23324 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23325 
 
23326 
  def __eq__(self, other):
23327 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23328 
 
23329 
  def __ne__(self, other):
23330 
    return not (self == other)
23331 
 
23332 
class getOrdersForProviderForStatus_result:
23333 
  """
23334 
  Attributes:
23335 
   - success
23336 
   - ex
23337 
  """
23338 
 
23339 
  thrift_spec = (
23340 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
23341 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
23342 
  )
23343 
 
23344 
  def __init__(self, success=None, ex=None,):
23345 
    self.success = success
23346 
    self.ex = ex
23347 
 
23348 
  def read(self, iprot):
23349 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23350 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23351 
      return
23352 
    iprot.readStructBegin()
23353 
    while True:
23354 
      (fname, ftype, fid) = iprot.readFieldBegin()
23355 
      if ftype == TType.STOP:
23356 
        break
23357 
      if fid == 0:
23358 
        if ftype == TType.LIST:
23359 
          self.success = []
6188 rajveer 23360 
          (_etype520, _size517) = iprot.readListBegin()
23361 
          for _i521 in xrange(_size517):
23362 
            _elem522 = Order()
23363 
            _elem522.read(iprot)
23364 
            self.success.append(_elem522)
4506 phani.kuma 23365 
          iprot.readListEnd()
23366 
        else:
23367 
          iprot.skip(ftype)
23368 
      elif fid == 1:
23369 
        if ftype == TType.STRUCT:
23370 
          self.ex = TransactionServiceException()
23371 
          self.ex.read(iprot)
23372 
        else:
23373 
          iprot.skip(ftype)
23374 
      else:
23375 
        iprot.skip(ftype)
23376 
      iprot.readFieldEnd()
23377 
    iprot.readStructEnd()
23378 
 
23379 
  def write(self, oprot):
23380 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23381 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23382 
      return
23383 
    oprot.writeStructBegin('getOrdersForProviderForStatus_result')
23384 
    if self.success is not None:
23385 
      oprot.writeFieldBegin('success', TType.LIST, 0)
23386 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 23387 
      for iter523 in self.success:
23388 
        iter523.write(oprot)
4506 phani.kuma 23389 
      oprot.writeListEnd()
23390 
      oprot.writeFieldEnd()
23391 
    if self.ex is not None:
23392 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
23393 
      self.ex.write(oprot)
23394 
      oprot.writeFieldEnd()
23395 
    oprot.writeFieldStop()
23396 
    oprot.writeStructEnd()
23397 
 
23398 
  def validate(self):
23399 
    return
23400 
 
23401 
 
23402 
  def __repr__(self):
23403 
    L = ['%s=%r' % (key, value)
23404 
      for key, value in self.__dict__.iteritems()]
23405 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23406 
 
23407 
  def __eq__(self, other):
23408 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23409 
 
23410 
  def __ne__(self, other):
23411 
    return not (self == other)
4600 varun.gupt 23412 
 
23413 
class getBilledOrdersForVendor_args:
23414 
  """
23415 
  Attributes:
23416 
   - vendorId
23417 
   - billingDateFrom
23418 
   - billingDateTo
23419 
  """
23420 
 
23421 
  thrift_spec = (
23422 
    None, # 0
23423 
    (1, TType.I64, 'vendorId', None, None, ), # 1
23424 
    (2, TType.I64, 'billingDateFrom', None, None, ), # 2
23425 
    (3, TType.I64, 'billingDateTo', None, None, ), # 3
23426 
  )
23427 
 
23428 
  def __init__(self, vendorId=None, billingDateFrom=None, billingDateTo=None,):
23429 
    self.vendorId = vendorId
23430 
    self.billingDateFrom = billingDateFrom
23431 
    self.billingDateTo = billingDateTo
23432 
 
23433 
  def read(self, iprot):
23434 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23435 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23436 
      return
23437 
    iprot.readStructBegin()
23438 
    while True:
23439 
      (fname, ftype, fid) = iprot.readFieldBegin()
23440 
      if ftype == TType.STOP:
23441 
        break
23442 
      if fid == 1:
23443 
        if ftype == TType.I64:
23444 
          self.vendorId = iprot.readI64();
23445 
        else:
23446 
          iprot.skip(ftype)
23447 
      elif fid == 2:
23448 
        if ftype == TType.I64:
23449 
          self.billingDateFrom = iprot.readI64();
23450 
        else:
23451 
          iprot.skip(ftype)
23452 
      elif fid == 3:
23453 
        if ftype == TType.I64:
23454 
          self.billingDateTo = iprot.readI64();
23455 
        else:
23456 
          iprot.skip(ftype)
23457 
      else:
23458 
        iprot.skip(ftype)
23459 
      iprot.readFieldEnd()
23460 
    iprot.readStructEnd()
23461 
 
23462 
  def write(self, oprot):
23463 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23464 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23465 
      return
23466 
    oprot.writeStructBegin('getBilledOrdersForVendor_args')
23467 
    if self.vendorId is not None:
23468 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
23469 
      oprot.writeI64(self.vendorId)
23470 
      oprot.writeFieldEnd()
23471 
    if self.billingDateFrom is not None:
23472 
      oprot.writeFieldBegin('billingDateFrom', TType.I64, 2)
23473 
      oprot.writeI64(self.billingDateFrom)
23474 
      oprot.writeFieldEnd()
23475 
    if self.billingDateTo is not None:
23476 
      oprot.writeFieldBegin('billingDateTo', TType.I64, 3)
23477 
      oprot.writeI64(self.billingDateTo)
23478 
      oprot.writeFieldEnd()
23479 
    oprot.writeFieldStop()
23480 
    oprot.writeStructEnd()
23481 
 
23482 
  def validate(self):
23483 
    return
23484 
 
23485 
 
23486 
  def __repr__(self):
23487 
    L = ['%s=%r' % (key, value)
23488 
      for key, value in self.__dict__.iteritems()]
23489 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23490 
 
23491 
  def __eq__(self, other):
23492 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23493 
 
23494 
  def __ne__(self, other):
23495 
    return not (self == other)
23496 
 
23497 
class getBilledOrdersForVendor_result:
23498 
  """
23499 
  Attributes:
23500 
   - success
23501 
   - ex
23502 
  """
23503 
 
23504 
  thrift_spec = (
23505 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
23506 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
23507 
  )
23508 
 
23509 
  def __init__(self, success=None, ex=None,):
23510 
    self.success = success
23511 
    self.ex = ex
23512 
 
23513 
  def read(self, iprot):
23514 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23515 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23516 
      return
23517 
    iprot.readStructBegin()
23518 
    while True:
23519 
      (fname, ftype, fid) = iprot.readFieldBegin()
23520 
      if ftype == TType.STOP:
23521 
        break
23522 
      if fid == 0:
23523 
        if ftype == TType.LIST:
23524 
          self.success = []
6188 rajveer 23525 
          (_etype527, _size524) = iprot.readListBegin()
23526 
          for _i528 in xrange(_size524):
23527 
            _elem529 = Order()
23528 
            _elem529.read(iprot)
23529 
            self.success.append(_elem529)
4600 varun.gupt 23530 
          iprot.readListEnd()
23531 
        else:
23532 
          iprot.skip(ftype)
23533 
      elif fid == 1:
23534 
        if ftype == TType.STRUCT:
23535 
          self.ex = TransactionServiceException()
23536 
          self.ex.read(iprot)
23537 
        else:
23538 
          iprot.skip(ftype)
23539 
      else:
23540 
        iprot.skip(ftype)
23541 
      iprot.readFieldEnd()
23542 
    iprot.readStructEnd()
23543 
 
23544 
  def write(self, oprot):
23545 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23546 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23547 
      return
23548 
    oprot.writeStructBegin('getBilledOrdersForVendor_result')
23549 
    if self.success is not None:
23550 
      oprot.writeFieldBegin('success', TType.LIST, 0)
23551 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 23552 
      for iter530 in self.success:
23553 
        iter530.write(oprot)
4600 varun.gupt 23554 
      oprot.writeListEnd()
23555 
      oprot.writeFieldEnd()
23556 
    if self.ex is not None:
23557 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
23558 
      self.ex.write(oprot)
23559 
      oprot.writeFieldEnd()
23560 
    oprot.writeFieldStop()
23561 
    oprot.writeStructEnd()
23562 
 
23563 
  def validate(self):
23564 
    return
23565 
 
23566 
 
23567 
  def __repr__(self):
23568 
    L = ['%s=%r' % (key, value)
23569 
      for key, value in self.__dict__.iteritems()]
23570 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23571 
 
23572 
  def __eq__(self, other):
23573 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23574 
 
23575 
  def __ne__(self, other):
23576 
    return not (self == other)
23577 
 
4607 rajveer 23578 
class getSlippedSippingDateOrders_args:
23579 
 
23580 
  thrift_spec = (
23581 
  )
23582 
 
23583 
  def read(self, iprot):
23584 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23585 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23586 
      return
23587 
    iprot.readStructBegin()
23588 
    while True:
23589 
      (fname, ftype, fid) = iprot.readFieldBegin()
23590 
      if ftype == TType.STOP:
23591 
        break
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('getSlippedSippingDateOrders_args')
23602 
    oprot.writeFieldStop()
23603 
    oprot.writeStructEnd()
23604 
 
23605 
  def validate(self):
23606 
    return
23607 
 
23608 
 
23609 
  def __repr__(self):
23610 
    L = ['%s=%r' % (key, value)
23611 
      for key, value in self.__dict__.iteritems()]
23612 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23613 
 
23614 
  def __eq__(self, other):
23615 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23616 
 
23617 
  def __ne__(self, other):
23618 
    return not (self == other)
23619 
 
23620 
class getSlippedSippingDateOrders_result:
23621 
  """
23622 
  Attributes:
23623 
   - success
23624 
   - ex
23625 
  """
23626 
 
23627 
  thrift_spec = (
23628 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
23629 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
23630 
  )
23631 
 
23632 
  def __init__(self, success=None, ex=None,):
23633 
    self.success = success
23634 
    self.ex = ex
23635 
 
23636 
  def read(self, iprot):
23637 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23638 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23639 
      return
23640 
    iprot.readStructBegin()
23641 
    while True:
23642 
      (fname, ftype, fid) = iprot.readFieldBegin()
23643 
      if ftype == TType.STOP:
23644 
        break
23645 
      if fid == 0:
23646 
        if ftype == TType.LIST:
23647 
          self.success = []
6188 rajveer 23648 
          (_etype534, _size531) = iprot.readListBegin()
23649 
          for _i535 in xrange(_size531):
23650 
            _elem536 = Order()
23651 
            _elem536.read(iprot)
23652 
            self.success.append(_elem536)
4607 rajveer 23653 
          iprot.readListEnd()
23654 
        else:
23655 
          iprot.skip(ftype)
23656 
      elif fid == 1:
23657 
        if ftype == TType.STRUCT:
23658 
          self.ex = TransactionServiceException()
23659 
          self.ex.read(iprot)
23660 
        else:
23661 
          iprot.skip(ftype)
23662 
      else:
23663 
        iprot.skip(ftype)
23664 
      iprot.readFieldEnd()
23665 
    iprot.readStructEnd()
23666 
 
23667 
  def write(self, oprot):
23668 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23669 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23670 
      return
23671 
    oprot.writeStructBegin('getSlippedSippingDateOrders_result')
23672 
    if self.success is not None:
23673 
      oprot.writeFieldBegin('success', TType.LIST, 0)
23674 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 23675 
      for iter537 in self.success:
23676 
        iter537.write(oprot)
4607 rajveer 23677 
      oprot.writeListEnd()
23678 
      oprot.writeFieldEnd()
23679 
    if self.ex is not None:
23680 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
23681 
      self.ex.write(oprot)
23682 
      oprot.writeFieldEnd()
23683 
    oprot.writeFieldStop()
23684 
    oprot.writeStructEnd()
23685 
 
23686 
  def validate(self):
23687 
    return
23688 
 
23689 
 
23690 
  def __repr__(self):
23691 
    L = ['%s=%r' % (key, value)
23692 
      for key, value in self.__dict__.iteritems()]
23693 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23694 
 
23695 
  def __eq__(self, other):
23696 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23697 
 
23698 
  def __ne__(self, other):
23699 
    return not (self == other)
23700 
 
4709 rajveer 23701 
class getCancelledOrders_args:
23702 
  """
23703 
  Attributes:
23704 
   - cancelDateFrom
23705 
   - cancelDateTo
23706 
  """
23707 
 
23708 
  thrift_spec = (
23709 
    None, # 0
23710 
    (1, TType.I64, 'cancelDateFrom', None, None, ), # 1
23711 
    (2, TType.I64, 'cancelDateTo', None, None, ), # 2
23712 
  )
23713 
 
23714 
  def __init__(self, cancelDateFrom=None, cancelDateTo=None,):
23715 
    self.cancelDateFrom = cancelDateFrom
23716 
    self.cancelDateTo = cancelDateTo
23717 
 
23718 
  def read(self, iprot):
23719 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23720 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23721 
      return
23722 
    iprot.readStructBegin()
23723 
    while True:
23724 
      (fname, ftype, fid) = iprot.readFieldBegin()
23725 
      if ftype == TType.STOP:
23726 
        break
23727 
      if fid == 1:
23728 
        if ftype == TType.I64:
23729 
          self.cancelDateFrom = iprot.readI64();
23730 
        else:
23731 
          iprot.skip(ftype)
23732 
      elif fid == 2:
23733 
        if ftype == TType.I64:
23734 
          self.cancelDateTo = iprot.readI64();
23735 
        else:
23736 
          iprot.skip(ftype)
23737 
      else:
23738 
        iprot.skip(ftype)
23739 
      iprot.readFieldEnd()
23740 
    iprot.readStructEnd()
23741 
 
23742 
  def write(self, oprot):
23743 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23744 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23745 
      return
23746 
    oprot.writeStructBegin('getCancelledOrders_args')
23747 
    if self.cancelDateFrom is not None:
23748 
      oprot.writeFieldBegin('cancelDateFrom', TType.I64, 1)
23749 
      oprot.writeI64(self.cancelDateFrom)
23750 
      oprot.writeFieldEnd()
23751 
    if self.cancelDateTo is not None:
23752 
      oprot.writeFieldBegin('cancelDateTo', TType.I64, 2)
23753 
      oprot.writeI64(self.cancelDateTo)
23754 
      oprot.writeFieldEnd()
23755 
    oprot.writeFieldStop()
23756 
    oprot.writeStructEnd()
23757 
 
23758 
  def validate(self):
23759 
    return
23760 
 
23761 
 
23762 
  def __repr__(self):
23763 
    L = ['%s=%r' % (key, value)
23764 
      for key, value in self.__dict__.iteritems()]
23765 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23766 
 
23767 
  def __eq__(self, other):
23768 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23769 
 
23770 
  def __ne__(self, other):
23771 
    return not (self == other)
23772 
 
23773 
class getCancelledOrders_result:
23774 
  """
23775 
  Attributes:
23776 
   - success
23777 
   - ex
23778 
  """
23779 
 
23780 
  thrift_spec = (
23781 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
23782 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
23783 
  )
23784 
 
23785 
  def __init__(self, success=None, ex=None,):
23786 
    self.success = success
23787 
    self.ex = ex
23788 
 
23789 
  def read(self, iprot):
23790 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23791 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23792 
      return
23793 
    iprot.readStructBegin()
23794 
    while True:
23795 
      (fname, ftype, fid) = iprot.readFieldBegin()
23796 
      if ftype == TType.STOP:
23797 
        break
23798 
      if fid == 0:
23799 
        if ftype == TType.LIST:
23800 
          self.success = []
6188 rajveer 23801 
          (_etype541, _size538) = iprot.readListBegin()
23802 
          for _i542 in xrange(_size538):
23803 
            _elem543 = Order()
23804 
            _elem543.read(iprot)
23805 
            self.success.append(_elem543)
4709 rajveer 23806 
          iprot.readListEnd()
23807 
        else:
23808 
          iprot.skip(ftype)
23809 
      elif fid == 1:
23810 
        if ftype == TType.STRUCT:
23811 
          self.ex = TransactionServiceException()
23812 
          self.ex.read(iprot)
23813 
        else:
23814 
          iprot.skip(ftype)
23815 
      else:
23816 
        iprot.skip(ftype)
23817 
      iprot.readFieldEnd()
23818 
    iprot.readStructEnd()
23819 
 
23820 
  def write(self, oprot):
23821 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23822 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23823 
      return
23824 
    oprot.writeStructBegin('getCancelledOrders_result')
23825 
    if self.success is not None:
23826 
      oprot.writeFieldBegin('success', TType.LIST, 0)
23827 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 23828 
      for iter544 in self.success:
23829 
        iter544.write(oprot)
4709 rajveer 23830 
      oprot.writeListEnd()
23831 
      oprot.writeFieldEnd()
23832 
    if self.ex is not None:
23833 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
23834 
      self.ex.write(oprot)
23835 
      oprot.writeFieldEnd()
23836 
    oprot.writeFieldStop()
23837 
    oprot.writeStructEnd()
23838 
 
23839 
  def validate(self):
23840 
    return
23841 
 
23842 
 
23843 
  def __repr__(self):
23844 
    L = ['%s=%r' % (key, value)
23845 
      for key, value in self.__dict__.iteritems()]
23846 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23847 
 
23848 
  def __eq__(self, other):
23849 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23850 
 
23851 
  def __ne__(self, other):
23852 
    return not (self == other)
23853 
 
4600 varun.gupt 23854 
class saveBluedartSettlements_args:
23855 
  """
23856 
  Attributes:
23857 
   - mapAWBAndAmount
23858 
  """
23859 
 
23860 
  thrift_spec = (
23861 
    None, # 0
23862 
    (1, TType.MAP, 'mapAWBAndAmount', (TType.I64,None,TType.DOUBLE,None), None, ), # 1
23863 
  )
23864 
 
23865 
  def __init__(self, mapAWBAndAmount=None,):
23866 
    self.mapAWBAndAmount = mapAWBAndAmount
23867 
 
23868 
  def read(self, iprot):
23869 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23870 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23871 
      return
23872 
    iprot.readStructBegin()
23873 
    while True:
23874 
      (fname, ftype, fid) = iprot.readFieldBegin()
23875 
      if ftype == TType.STOP:
23876 
        break
23877 
      if fid == 1:
23878 
        if ftype == TType.MAP:
23879 
          self.mapAWBAndAmount = {}
6188 rajveer 23880 
          (_ktype546, _vtype547, _size545 ) = iprot.readMapBegin()
23881 
          for _i549 in xrange(_size545):
23882 
            _key550 = iprot.readI64();
23883 
            _val551 = iprot.readDouble();
23884 
            self.mapAWBAndAmount[_key550] = _val551
4600 varun.gupt 23885 
          iprot.readMapEnd()
23886 
        else:
23887 
          iprot.skip(ftype)
23888 
      else:
23889 
        iprot.skip(ftype)
23890 
      iprot.readFieldEnd()
23891 
    iprot.readStructEnd()
23892 
 
23893 
  def write(self, oprot):
23894 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23895 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23896 
      return
23897 
    oprot.writeStructBegin('saveBluedartSettlements_args')
23898 
    if self.mapAWBAndAmount is not None:
23899 
      oprot.writeFieldBegin('mapAWBAndAmount', TType.MAP, 1)
23900 
      oprot.writeMapBegin(TType.I64, TType.DOUBLE, len(self.mapAWBAndAmount))
6188 rajveer 23901 
      for kiter552,viter553 in self.mapAWBAndAmount.items():
23902 
        oprot.writeI64(kiter552)
23903 
        oprot.writeDouble(viter553)
4600 varun.gupt 23904 
      oprot.writeMapEnd()
23905 
      oprot.writeFieldEnd()
23906 
    oprot.writeFieldStop()
23907 
    oprot.writeStructEnd()
23908 
 
23909 
  def validate(self):
23910 
    return
23911 
 
23912 
 
23913 
  def __repr__(self):
23914 
    L = ['%s=%r' % (key, value)
23915 
      for key, value in self.__dict__.iteritems()]
23916 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23917 
 
23918 
  def __eq__(self, other):
23919 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23920 
 
23921 
  def __ne__(self, other):
23922 
    return not (self == other)
23923 
 
23924 
class saveBluedartSettlements_result:
23925 
  """
23926 
  Attributes:
23927 
   - ex
23928 
  """
23929 
 
23930 
  thrift_spec = (
23931 
    None, # 0
23932 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
23933 
  )
23934 
 
23935 
  def __init__(self, ex=None,):
23936 
    self.ex = ex
23937 
 
23938 
  def read(self, iprot):
23939 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23940 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23941 
      return
23942 
    iprot.readStructBegin()
23943 
    while True:
23944 
      (fname, ftype, fid) = iprot.readFieldBegin()
23945 
      if ftype == TType.STOP:
23946 
        break
23947 
      if fid == 1:
23948 
        if ftype == TType.STRUCT:
23949 
          self.ex = TransactionServiceException()
23950 
          self.ex.read(iprot)
23951 
        else:
23952 
          iprot.skip(ftype)
23953 
      else:
23954 
        iprot.skip(ftype)
23955 
      iprot.readFieldEnd()
23956 
    iprot.readStructEnd()
23957 
 
23958 
  def write(self, oprot):
23959 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23960 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23961 
      return
23962 
    oprot.writeStructBegin('saveBluedartSettlements_result')
23963 
    if self.ex is not None:
23964 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
23965 
      self.ex.write(oprot)
23966 
      oprot.writeFieldEnd()
23967 
    oprot.writeFieldStop()
23968 
    oprot.writeStructEnd()
23969 
 
23970 
  def validate(self):
23971 
    return
23972 
 
23973 
 
23974 
  def __repr__(self):
23975 
    L = ['%s=%r' % (key, value)
23976 
      for key, value in self.__dict__.iteritems()]
23977 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23978 
 
23979 
  def __eq__(self, other):
23980 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23981 
 
23982 
  def __ne__(self, other):
23983 
    return not (self == other)
23984 
 
23985 
class savePaymentSettlements_args:
23986 
  """
23987 
  Attributes:
23988 
   - settlementDate
23989 
   - paymentGatewayId
4905 varun.gupt 23990 
   - referenceId
4600 varun.gupt 23991 
   - serviceTax
23992 
   - otherCharges
23993 
   - netCollection
23994 
  """
23995 
 
23996 
  thrift_spec = (
23997 
    None, # 0
23998 
    (1, TType.I64, 'settlementDate', None, None, ), # 1
23999 
    (2, TType.I64, 'paymentGatewayId', None, None, ), # 2
4905 varun.gupt 24000 
    (3, TType.I64, 'referenceId', None, None, ), # 3
4600 varun.gupt 24001 
    (4, TType.DOUBLE, 'serviceTax', None, None, ), # 4
24002 
    (5, TType.DOUBLE, 'otherCharges', None, None, ), # 5
24003 
    (6, TType.DOUBLE, 'netCollection', None, None, ), # 6
24004 
  )
24005 
 
4905 varun.gupt 24006 
  def __init__(self, settlementDate=None, paymentGatewayId=None, referenceId=None, serviceTax=None, otherCharges=None, netCollection=None,):
4600 varun.gupt 24007 
    self.settlementDate = settlementDate
24008 
    self.paymentGatewayId = paymentGatewayId
4905 varun.gupt 24009 
    self.referenceId = referenceId
4600 varun.gupt 24010 
    self.serviceTax = serviceTax
24011 
    self.otherCharges = otherCharges
24012 
    self.netCollection = netCollection
24013 
 
24014 
  def read(self, iprot):
24015 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24016 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24017 
      return
24018 
    iprot.readStructBegin()
24019 
    while True:
24020 
      (fname, ftype, fid) = iprot.readFieldBegin()
24021 
      if ftype == TType.STOP:
24022 
        break
24023 
      if fid == 1:
24024 
        if ftype == TType.I64:
24025 
          self.settlementDate = iprot.readI64();
24026 
        else:
24027 
          iprot.skip(ftype)
24028 
      elif fid == 2:
24029 
        if ftype == TType.I64:
24030 
          self.paymentGatewayId = iprot.readI64();
24031 
        else:
24032 
          iprot.skip(ftype)
24033 
      elif fid == 3:
24034 
        if ftype == TType.I64:
4905 varun.gupt 24035 
          self.referenceId = iprot.readI64();
4600 varun.gupt 24036 
        else:
24037 
          iprot.skip(ftype)
24038 
      elif fid == 4:
24039 
        if ftype == TType.DOUBLE:
24040 
          self.serviceTax = iprot.readDouble();
24041 
        else:
24042 
          iprot.skip(ftype)
24043 
      elif fid == 5:
24044 
        if ftype == TType.DOUBLE:
24045 
          self.otherCharges = iprot.readDouble();
24046 
        else:
24047 
          iprot.skip(ftype)
24048 
      elif fid == 6:
24049 
        if ftype == TType.DOUBLE:
24050 
          self.netCollection = iprot.readDouble();
24051 
        else:
24052 
          iprot.skip(ftype)
24053 
      else:
24054 
        iprot.skip(ftype)
24055 
      iprot.readFieldEnd()
24056 
    iprot.readStructEnd()
24057 
 
24058 
  def write(self, oprot):
24059 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24060 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24061 
      return
24062 
    oprot.writeStructBegin('savePaymentSettlements_args')
24063 
    if self.settlementDate is not None:
24064 
      oprot.writeFieldBegin('settlementDate', TType.I64, 1)
24065 
      oprot.writeI64(self.settlementDate)
24066 
      oprot.writeFieldEnd()
24067 
    if self.paymentGatewayId is not None:
24068 
      oprot.writeFieldBegin('paymentGatewayId', TType.I64, 2)
24069 
      oprot.writeI64(self.paymentGatewayId)
24070 
      oprot.writeFieldEnd()
4905 varun.gupt 24071 
    if self.referenceId is not None:
24072 
      oprot.writeFieldBegin('referenceId', TType.I64, 3)
24073 
      oprot.writeI64(self.referenceId)
4600 varun.gupt 24074 
      oprot.writeFieldEnd()
24075 
    if self.serviceTax is not None:
24076 
      oprot.writeFieldBegin('serviceTax', TType.DOUBLE, 4)
24077 
      oprot.writeDouble(self.serviceTax)
24078 
      oprot.writeFieldEnd()
24079 
    if self.otherCharges is not None:
24080 
      oprot.writeFieldBegin('otherCharges', TType.DOUBLE, 5)
24081 
      oprot.writeDouble(self.otherCharges)
24082 
      oprot.writeFieldEnd()
24083 
    if self.netCollection is not None:
24084 
      oprot.writeFieldBegin('netCollection', TType.DOUBLE, 6)
24085 
      oprot.writeDouble(self.netCollection)
24086 
      oprot.writeFieldEnd()
24087 
    oprot.writeFieldStop()
24088 
    oprot.writeStructEnd()
24089 
 
24090 
  def validate(self):
24091 
    return
24092 
 
24093 
 
24094 
  def __repr__(self):
24095 
    L = ['%s=%r' % (key, value)
24096 
      for key, value in self.__dict__.iteritems()]
24097 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24098 
 
24099 
  def __eq__(self, other):
24100 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24101 
 
24102 
  def __ne__(self, other):
24103 
    return not (self == other)
24104 
 
24105 
class savePaymentSettlements_result:
24106 
  """
24107 
  Attributes:
24108 
   - ex
24109 
  """
24110 
 
24111 
  thrift_spec = (
24112 
    None, # 0
24113 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
24114 
  )
24115 
 
24116 
  def __init__(self, ex=None,):
24117 
    self.ex = ex
24118 
 
24119 
  def read(self, iprot):
24120 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24121 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24122 
      return
24123 
    iprot.readStructBegin()
24124 
    while True:
24125 
      (fname, ftype, fid) = iprot.readFieldBegin()
24126 
      if ftype == TType.STOP:
24127 
        break
24128 
      if fid == 1:
24129 
        if ftype == TType.STRUCT:
24130 
          self.ex = TransactionServiceException()
24131 
          self.ex.read(iprot)
24132 
        else:
24133 
          iprot.skip(ftype)
24134 
      else:
24135 
        iprot.skip(ftype)
24136 
      iprot.readFieldEnd()
24137 
    iprot.readStructEnd()
24138 
 
24139 
  def write(self, oprot):
24140 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24141 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24142 
      return
24143 
    oprot.writeStructBegin('savePaymentSettlements_result')
24144 
    if self.ex is not None:
24145 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
24146 
      self.ex.write(oprot)
24147 
      oprot.writeFieldEnd()
24148 
    oprot.writeFieldStop()
24149 
    oprot.writeStructEnd()
24150 
 
24151 
  def validate(self):
24152 
    return
24153 
 
24154 
 
24155 
  def __repr__(self):
24156 
    L = ['%s=%r' % (key, value)
24157 
      for key, value in self.__dict__.iteritems()]
24158 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24159 
 
24160 
  def __eq__(self, other):
24161 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24162 
 
24163 
  def __ne__(self, other):
24164 
    return not (self == other)
24165 
 
24166 
class saveEBSSettlementSummary_args:
24167 
  """
24168 
  Attributes:
24169 
   - settlementId
24170 
   - settlementDate
24171 
   - transactionDateFrom
24172 
   - transactionDateTo
24173 
   - amount
24174 
  """
24175 
 
24176 
  thrift_spec = (
24177 
    None, # 0
24178 
    (1, TType.I64, 'settlementId', None, None, ), # 1
24179 
    (2, TType.I64, 'settlementDate', None, None, ), # 2
24180 
    (3, TType.I64, 'transactionDateFrom', None, None, ), # 3
24181 
    (4, TType.I64, 'transactionDateTo', None, None, ), # 4
24182 
    (5, TType.DOUBLE, 'amount', None, None, ), # 5
24183 
  )
24184 
 
24185 
  def __init__(self, settlementId=None, settlementDate=None, transactionDateFrom=None, transactionDateTo=None, amount=None,):
24186 
    self.settlementId = settlementId
24187 
    self.settlementDate = settlementDate
24188 
    self.transactionDateFrom = transactionDateFrom
24189 
    self.transactionDateTo = transactionDateTo
24190 
    self.amount = amount
24191 
 
24192 
  def read(self, iprot):
24193 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24194 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24195 
      return
24196 
    iprot.readStructBegin()
24197 
    while True:
24198 
      (fname, ftype, fid) = iprot.readFieldBegin()
24199 
      if ftype == TType.STOP:
24200 
        break
24201 
      if fid == 1:
24202 
        if ftype == TType.I64:
24203 
          self.settlementId = iprot.readI64();
24204 
        else:
24205 
          iprot.skip(ftype)
24206 
      elif fid == 2:
24207 
        if ftype == TType.I64:
24208 
          self.settlementDate = iprot.readI64();
24209 
        else:
24210 
          iprot.skip(ftype)
24211 
      elif fid == 3:
24212 
        if ftype == TType.I64:
24213 
          self.transactionDateFrom = iprot.readI64();
24214 
        else:
24215 
          iprot.skip(ftype)
24216 
      elif fid == 4:
24217 
        if ftype == TType.I64:
24218 
          self.transactionDateTo = iprot.readI64();
24219 
        else:
24220 
          iprot.skip(ftype)
24221 
      elif fid == 5:
24222 
        if ftype == TType.DOUBLE:
24223 
          self.amount = iprot.readDouble();
24224 
        else:
24225 
          iprot.skip(ftype)
24226 
      else:
24227 
        iprot.skip(ftype)
24228 
      iprot.readFieldEnd()
24229 
    iprot.readStructEnd()
24230 
 
24231 
  def write(self, oprot):
24232 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24233 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24234 
      return
24235 
    oprot.writeStructBegin('saveEBSSettlementSummary_args')
24236 
    if self.settlementId is not None:
24237 
      oprot.writeFieldBegin('settlementId', TType.I64, 1)
24238 
      oprot.writeI64(self.settlementId)
24239 
      oprot.writeFieldEnd()
24240 
    if self.settlementDate is not None:
24241 
      oprot.writeFieldBegin('settlementDate', TType.I64, 2)
24242 
      oprot.writeI64(self.settlementDate)
24243 
      oprot.writeFieldEnd()
24244 
    if self.transactionDateFrom is not None:
24245 
      oprot.writeFieldBegin('transactionDateFrom', TType.I64, 3)
24246 
      oprot.writeI64(self.transactionDateFrom)
24247 
      oprot.writeFieldEnd()
24248 
    if self.transactionDateTo is not None:
24249 
      oprot.writeFieldBegin('transactionDateTo', TType.I64, 4)
24250 
      oprot.writeI64(self.transactionDateTo)
24251 
      oprot.writeFieldEnd()
24252 
    if self.amount is not None:
24253 
      oprot.writeFieldBegin('amount', TType.DOUBLE, 5)
24254 
      oprot.writeDouble(self.amount)
24255 
      oprot.writeFieldEnd()
24256 
    oprot.writeFieldStop()
24257 
    oprot.writeStructEnd()
24258 
 
24259 
  def validate(self):
24260 
    return
24261 
 
24262 
 
24263 
  def __repr__(self):
24264 
    L = ['%s=%r' % (key, value)
24265 
      for key, value in self.__dict__.iteritems()]
24266 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24267 
 
24268 
  def __eq__(self, other):
24269 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24270 
 
24271 
  def __ne__(self, other):
24272 
    return not (self == other)
24273 
 
24274 
class saveEBSSettlementSummary_result:
24275 
  """
24276 
  Attributes:
24277 
   - ex
24278 
  """
24279 
 
24280 
  thrift_spec = (
24281 
    None, # 0
24282 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
24283 
  )
24284 
 
24285 
  def __init__(self, ex=None,):
24286 
    self.ex = ex
24287 
 
24288 
  def read(self, iprot):
24289 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24290 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24291 
      return
24292 
    iprot.readStructBegin()
24293 
    while True:
24294 
      (fname, ftype, fid) = iprot.readFieldBegin()
24295 
      if ftype == TType.STOP:
24296 
        break
24297 
      if fid == 1:
24298 
        if ftype == TType.STRUCT:
24299 
          self.ex = TransactionServiceException()
24300 
          self.ex.read(iprot)
24301 
        else:
24302 
          iprot.skip(ftype)
24303 
      else:
24304 
        iprot.skip(ftype)
24305 
      iprot.readFieldEnd()
24306 
    iprot.readStructEnd()
24307 
 
24308 
  def write(self, oprot):
24309 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24310 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24311 
      return
24312 
    oprot.writeStructBegin('saveEBSSettlementSummary_result')
24313 
    if self.ex is not None:
24314 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
24315 
      self.ex.write(oprot)
24316 
      oprot.writeFieldEnd()
24317 
    oprot.writeFieldStop()
24318 
    oprot.writeStructEnd()
24319 
 
24320 
  def validate(self):
24321 
    return
24322 
 
24323 
 
24324 
  def __repr__(self):
24325 
    L = ['%s=%r' % (key, value)
24326 
      for key, value in self.__dict__.iteritems()]
24327 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24328 
 
24329 
  def __eq__(self, other):
24330 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24331 
 
24332 
  def __ne__(self, other):
24333 
    return not (self == other)
24334 
 
5386 phani.kuma 24335 
class getSettlementForPrepaid_args:
4600 varun.gupt 24336 
  """
24337 
  Attributes:
5189 varun.gupt 24338 
   - referenceId
24339 
   - isRefund
4600 varun.gupt 24340 
  """
24341 
 
24342 
  thrift_spec = (
24343 
    None, # 0
5189 varun.gupt 24344 
    (1, TType.I64, 'referenceId', None, None, ), # 1
5386 phani.kuma 24345 
    (2, TType.BOOL, 'isRefund', None, None, ), # 2
4600 varun.gupt 24346 
  )
24347 
 
5386 phani.kuma 24348 
  def __init__(self, referenceId=None, isRefund=None,):
5189 varun.gupt 24349 
    self.referenceId = referenceId
24350 
    self.isRefund = isRefund
4600 varun.gupt 24351 
 
24352 
  def read(self, iprot):
24353 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24354 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24355 
      return
24356 
    iprot.readStructBegin()
24357 
    while True:
24358 
      (fname, ftype, fid) = iprot.readFieldBegin()
24359 
      if ftype == TType.STOP:
24360 
        break
24361 
      if fid == 1:
24362 
        if ftype == TType.I64:
5189 varun.gupt 24363 
          self.referenceId = iprot.readI64();
4600 varun.gupt 24364 
        else:
24365 
          iprot.skip(ftype)
5189 varun.gupt 24366 
      elif fid == 2:
24367 
        if ftype == TType.BOOL:
24368 
          self.isRefund = iprot.readBool();
24369 
        else:
24370 
          iprot.skip(ftype)
4600 varun.gupt 24371 
      else:
24372 
        iprot.skip(ftype)
24373 
      iprot.readFieldEnd()
24374 
    iprot.readStructEnd()
24375 
 
24376 
  def write(self, oprot):
24377 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24378 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24379 
      return
5386 phani.kuma 24380 
    oprot.writeStructBegin('getSettlementForPrepaid_args')
5189 varun.gupt 24381 
    if self.referenceId is not None:
24382 
      oprot.writeFieldBegin('referenceId', TType.I64, 1)
24383 
      oprot.writeI64(self.referenceId)
4600 varun.gupt 24384 
      oprot.writeFieldEnd()
5386 phani.kuma 24385 
    if self.isRefund is not None:
24386 
      oprot.writeFieldBegin('isRefund', TType.BOOL, 2)
24387 
      oprot.writeBool(self.isRefund)
5382 varun.gupt 24388 
      oprot.writeFieldEnd()
5386 phani.kuma 24389 
    oprot.writeFieldStop()
24390 
    oprot.writeStructEnd()
24391 
 
24392 
  def validate(self):
24393 
    return
24394 
 
24395 
 
24396 
  def __repr__(self):
24397 
    L = ['%s=%r' % (key, value)
24398 
      for key, value in self.__dict__.iteritems()]
24399 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24400 
 
24401 
  def __eq__(self, other):
24402 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24403 
 
24404 
  def __ne__(self, other):
24405 
    return not (self == other)
24406 
 
24407 
class getSettlementForPrepaid_result:
24408 
  """
24409 
  Attributes:
24410 
   - success
24411 
   - ex
24412 
  """
24413 
 
24414 
  thrift_spec = (
24415 
    (0, TType.STRUCT, 'success', (PaymentSettlement, PaymentSettlement.thrift_spec), None, ), # 0
24416 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
24417 
  )
24418 
 
24419 
  def __init__(self, success=None, ex=None,):
24420 
    self.success = success
24421 
    self.ex = ex
24422 
 
24423 
  def read(self, iprot):
24424 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24425 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24426 
      return
24427 
    iprot.readStructBegin()
24428 
    while True:
24429 
      (fname, ftype, fid) = iprot.readFieldBegin()
24430 
      if ftype == TType.STOP:
24431 
        break
24432 
      if fid == 0:
24433 
        if ftype == TType.STRUCT:
24434 
          self.success = PaymentSettlement()
24435 
          self.success.read(iprot)
24436 
        else:
24437 
          iprot.skip(ftype)
24438 
      elif fid == 1:
24439 
        if ftype == TType.STRUCT:
24440 
          self.ex = TransactionServiceException()
24441 
          self.ex.read(iprot)
24442 
        else:
24443 
          iprot.skip(ftype)
24444 
      else:
24445 
        iprot.skip(ftype)
24446 
      iprot.readFieldEnd()
24447 
    iprot.readStructEnd()
24448 
 
24449 
  def write(self, oprot):
24450 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24451 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24452 
      return
24453 
    oprot.writeStructBegin('getSettlementForPrepaid_result')
24454 
    if self.success is not None:
24455 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
24456 
      self.success.write(oprot)
24457 
      oprot.writeFieldEnd()
24458 
    if self.ex is not None:
24459 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
24460 
      self.ex.write(oprot)
24461 
      oprot.writeFieldEnd()
24462 
    oprot.writeFieldStop()
24463 
    oprot.writeStructEnd()
24464 
 
24465 
  def validate(self):
24466 
    return
24467 
 
24468 
 
24469 
  def __repr__(self):
24470 
    L = ['%s=%r' % (key, value)
24471 
      for key, value in self.__dict__.iteritems()]
24472 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24473 
 
24474 
  def __eq__(self, other):
24475 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24476 
 
24477 
  def __ne__(self, other):
24478 
    return not (self == other)
24479 
 
24480 
class getSettlementForCod_args:
24481 
  """
24482 
  Attributes:
24483 
   - orderId
24484 
   - isRefund
24485 
  """
24486 
 
24487 
  thrift_spec = (
24488 
    None, # 0
24489 
    (1, TType.I64, 'orderId', None, None, ), # 1
24490 
    (2, TType.BOOL, 'isRefund', None, None, ), # 2
24491 
  )
24492 
 
24493 
  def __init__(self, orderId=None, isRefund=None,):
24494 
    self.orderId = orderId
24495 
    self.isRefund = isRefund
24496 
 
24497 
  def read(self, iprot):
24498 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24499 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24500 
      return
24501 
    iprot.readStructBegin()
24502 
    while True:
24503 
      (fname, ftype, fid) = iprot.readFieldBegin()
24504 
      if ftype == TType.STOP:
24505 
        break
24506 
      if fid == 1:
24507 
        if ftype == TType.I64:
24508 
          self.orderId = iprot.readI64();
24509 
        else:
24510 
          iprot.skip(ftype)
24511 
      elif fid == 2:
24512 
        if ftype == TType.BOOL:
24513 
          self.isRefund = iprot.readBool();
24514 
        else:
24515 
          iprot.skip(ftype)
24516 
      else:
24517 
        iprot.skip(ftype)
24518 
      iprot.readFieldEnd()
24519 
    iprot.readStructEnd()
24520 
 
24521 
  def write(self, oprot):
24522 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24523 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24524 
      return
24525 
    oprot.writeStructBegin('getSettlementForCod_args')
24526 
    if self.orderId is not None:
24527 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
24528 
      oprot.writeI64(self.orderId)
24529 
      oprot.writeFieldEnd()
5189 varun.gupt 24530 
    if self.isRefund is not None:
5386 phani.kuma 24531 
      oprot.writeFieldBegin('isRefund', TType.BOOL, 2)
5189 varun.gupt 24532 
      oprot.writeBool(self.isRefund)
24533 
      oprot.writeFieldEnd()
4600 varun.gupt 24534 
    oprot.writeFieldStop()
24535 
    oprot.writeStructEnd()
24536 
 
24537 
  def validate(self):
24538 
    return
24539 
 
24540 
 
24541 
  def __repr__(self):
24542 
    L = ['%s=%r' % (key, value)
24543 
      for key, value in self.__dict__.iteritems()]
24544 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24545 
 
24546 
  def __eq__(self, other):
24547 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24548 
 
24549 
  def __ne__(self, other):
24550 
    return not (self == other)
24551 
 
5386 phani.kuma 24552 
class getSettlementForCod_result:
4600 varun.gupt 24553 
  """
24554 
  Attributes:
24555 
   - success
24556 
   - ex
24557 
  """
24558 
 
24559 
  thrift_spec = (
24560 
    (0, TType.STRUCT, 'success', (PaymentSettlement, PaymentSettlement.thrift_spec), None, ), # 0
24561 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
24562 
  )
24563 
 
24564 
  def __init__(self, success=None, ex=None,):
24565 
    self.success = success
24566 
    self.ex = ex
24567 
 
24568 
  def read(self, iprot):
24569 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24570 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24571 
      return
24572 
    iprot.readStructBegin()
24573 
    while True:
24574 
      (fname, ftype, fid) = iprot.readFieldBegin()
24575 
      if ftype == TType.STOP:
24576 
        break
24577 
      if fid == 0:
24578 
        if ftype == TType.STRUCT:
24579 
          self.success = PaymentSettlement()
24580 
          self.success.read(iprot)
24581 
        else:
24582 
          iprot.skip(ftype)
24583 
      elif fid == 1:
24584 
        if ftype == TType.STRUCT:
24585 
          self.ex = TransactionServiceException()
24586 
          self.ex.read(iprot)
24587 
        else:
24588 
          iprot.skip(ftype)
24589 
      else:
24590 
        iprot.skip(ftype)
24591 
      iprot.readFieldEnd()
24592 
    iprot.readStructEnd()
24593 
 
24594 
  def write(self, oprot):
24595 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24596 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24597 
      return
5386 phani.kuma 24598 
    oprot.writeStructBegin('getSettlementForCod_result')
4600 varun.gupt 24599 
    if self.success is not None:
24600 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
24601 
      self.success.write(oprot)
24602 
      oprot.writeFieldEnd()
24603 
    if self.ex is not None:
24604 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
24605 
      self.ex.write(oprot)
24606 
      oprot.writeFieldEnd()
24607 
    oprot.writeFieldStop()
24608 
    oprot.writeStructEnd()
24609 
 
24610 
  def validate(self):
24611 
    return
24612 
 
24613 
 
24614 
  def __repr__(self):
24615 
    L = ['%s=%r' % (key, value)
24616 
      for key, value in self.__dict__.iteritems()]
24617 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24618 
 
24619 
  def __eq__(self, other):
24620 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24621 
 
24622 
  def __ne__(self, other):
24623 
    return not (self == other)
24624 
 
24625 
class getEBSSettlementSummaries_args:
24626 
 
24627 
  thrift_spec = (
24628 
  )
24629 
 
24630 
  def read(self, iprot):
24631 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24632 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24633 
      return
24634 
    iprot.readStructBegin()
24635 
    while True:
24636 
      (fname, ftype, fid) = iprot.readFieldBegin()
24637 
      if ftype == TType.STOP:
24638 
        break
24639 
      else:
24640 
        iprot.skip(ftype)
24641 
      iprot.readFieldEnd()
24642 
    iprot.readStructEnd()
24643 
 
24644 
  def write(self, oprot):
24645 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24646 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24647 
      return
24648 
    oprot.writeStructBegin('getEBSSettlementSummaries_args')
24649 
    oprot.writeFieldStop()
24650 
    oprot.writeStructEnd()
24651 
 
24652 
  def validate(self):
24653 
    return
24654 
 
24655 
 
24656 
  def __repr__(self):
24657 
    L = ['%s=%r' % (key, value)
24658 
      for key, value in self.__dict__.iteritems()]
24659 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24660 
 
24661 
  def __eq__(self, other):
24662 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24663 
 
24664 
  def __ne__(self, other):
24665 
    return not (self == other)
24666 
 
24667 
class getEBSSettlementSummaries_result:
24668 
  """
24669 
  Attributes:
24670 
   - success
24671 
   - ex
24672 
  """
24673 
 
24674 
  thrift_spec = (
24675 
    (0, TType.MAP, 'success', (TType.I64,None,TType.STRING,None), None, ), # 0
24676 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
24677 
  )
24678 
 
24679 
  def __init__(self, success=None, ex=None,):
24680 
    self.success = success
24681 
    self.ex = ex
24682 
 
24683 
  def read(self, iprot):
24684 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24685 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24686 
      return
24687 
    iprot.readStructBegin()
24688 
    while True:
24689 
      (fname, ftype, fid) = iprot.readFieldBegin()
24690 
      if ftype == TType.STOP:
24691 
        break
24692 
      if fid == 0:
24693 
        if ftype == TType.MAP:
24694 
          self.success = {}
6188 rajveer 24695 
          (_ktype555, _vtype556, _size554 ) = iprot.readMapBegin()
24696 
          for _i558 in xrange(_size554):
24697 
            _key559 = iprot.readI64();
24698 
            _val560 = iprot.readString();
24699 
            self.success[_key559] = _val560
4600 varun.gupt 24700 
          iprot.readMapEnd()
24701 
        else:
24702 
          iprot.skip(ftype)
24703 
      elif fid == 1:
24704 
        if ftype == TType.STRUCT:
24705 
          self.ex = TransactionServiceException()
24706 
          self.ex.read(iprot)
24707 
        else:
24708 
          iprot.skip(ftype)
24709 
      else:
24710 
        iprot.skip(ftype)
24711 
      iprot.readFieldEnd()
24712 
    iprot.readStructEnd()
24713 
 
24714 
  def write(self, oprot):
24715 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24716 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24717 
      return
24718 
    oprot.writeStructBegin('getEBSSettlementSummaries_result')
24719 
    if self.success is not None:
24720 
      oprot.writeFieldBegin('success', TType.MAP, 0)
24721 
      oprot.writeMapBegin(TType.I64, TType.STRING, len(self.success))
6188 rajveer 24722 
      for kiter561,viter562 in self.success.items():
24723 
        oprot.writeI64(kiter561)
24724 
        oprot.writeString(viter562)
4600 varun.gupt 24725 
      oprot.writeMapEnd()
24726 
      oprot.writeFieldEnd()
24727 
    if self.ex is not None:
24728 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
24729 
      self.ex.write(oprot)
24730 
      oprot.writeFieldEnd()
24731 
    oprot.writeFieldStop()
24732 
    oprot.writeStructEnd()
24733 
 
24734 
  def validate(self):
24735 
    return
24736 
 
24737 
 
24738 
  def __repr__(self):
24739 
    L = ['%s=%r' % (key, value)
24740 
      for key, value in self.__dict__.iteritems()]
24741 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24742 
 
24743 
  def __eq__(self, other):
24744 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24745 
 
24746 
  def __ne__(self, other):
24747 
    return not (self == other)
24748 
 
24749 
class markEBSSettlementUploaded_args:
24750 
  """
24751 
  Attributes:
24752 
   - settlementId
24753 
  """
24754 
 
24755 
  thrift_spec = (
24756 
    None, # 0
24757 
    (1, TType.I64, 'settlementId', None, None, ), # 1
24758 
  )
24759 
 
24760 
  def __init__(self, settlementId=None,):
24761 
    self.settlementId = settlementId
24762 
 
24763 
  def read(self, iprot):
24764 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24765 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24766 
      return
24767 
    iprot.readStructBegin()
24768 
    while True:
24769 
      (fname, ftype, fid) = iprot.readFieldBegin()
24770 
      if ftype == TType.STOP:
24771 
        break
24772 
      if fid == 1:
24773 
        if ftype == TType.I64:
24774 
          self.settlementId = iprot.readI64();
24775 
        else:
24776 
          iprot.skip(ftype)
24777 
      else:
24778 
        iprot.skip(ftype)
24779 
      iprot.readFieldEnd()
24780 
    iprot.readStructEnd()
24781 
 
24782 
  def write(self, oprot):
24783 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24784 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24785 
      return
24786 
    oprot.writeStructBegin('markEBSSettlementUploaded_args')
24787 
    if self.settlementId is not None:
24788 
      oprot.writeFieldBegin('settlementId', TType.I64, 1)
24789 
      oprot.writeI64(self.settlementId)
24790 
      oprot.writeFieldEnd()
24791 
    oprot.writeFieldStop()
24792 
    oprot.writeStructEnd()
24793 
 
24794 
  def validate(self):
24795 
    return
24796 
 
24797 
 
24798 
  def __repr__(self):
24799 
    L = ['%s=%r' % (key, value)
24800 
      for key, value in self.__dict__.iteritems()]
24801 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24802 
 
24803 
  def __eq__(self, other):
24804 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24805 
 
24806 
  def __ne__(self, other):
24807 
    return not (self == other)
24808 
 
24809 
class markEBSSettlementUploaded_result:
24810 
  """
24811 
  Attributes:
24812 
   - ex
24813 
  """
24814 
 
24815 
  thrift_spec = (
24816 
    None, # 0
24817 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
24818 
  )
24819 
 
24820 
  def __init__(self, ex=None,):
24821 
    self.ex = ex
24822 
 
24823 
  def read(self, iprot):
24824 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24825 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24826 
      return
24827 
    iprot.readStructBegin()
24828 
    while True:
24829 
      (fname, ftype, fid) = iprot.readFieldBegin()
24830 
      if ftype == TType.STOP:
24831 
        break
24832 
      if fid == 1:
24833 
        if ftype == TType.STRUCT:
24834 
          self.ex = TransactionServiceException()
24835 
          self.ex.read(iprot)
24836 
        else:
24837 
          iprot.skip(ftype)
24838 
      else:
24839 
        iprot.skip(ftype)
24840 
      iprot.readFieldEnd()
24841 
    iprot.readStructEnd()
24842 
 
24843 
  def write(self, oprot):
24844 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24845 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24846 
      return
24847 
    oprot.writeStructBegin('markEBSSettlementUploaded_result')
24848 
    if self.ex is not None:
24849 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
24850 
      self.ex.write(oprot)
24851 
      oprot.writeFieldEnd()
24852 
    oprot.writeFieldStop()
24853 
    oprot.writeStructEnd()
24854 
 
24855 
  def validate(self):
24856 
    return
24857 
 
24858 
 
24859 
  def __repr__(self):
24860 
    L = ['%s=%r' % (key, value)
24861 
      for key, value in self.__dict__.iteritems()]
24862 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24863 
 
24864 
  def __eq__(self, other):
24865 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24866 
 
24867 
  def __ne__(self, other):
24868 
    return not (self == other)
24869 
 
24870 
class getEBSSettlementDate_args:
24871 
  """
24872 
  Attributes:
24873 
   - settlementId
24874 
  """
24875 
 
24876 
  thrift_spec = (
24877 
    None, # 0
24878 
    (1, TType.I64, 'settlementId', None, None, ), # 1
24879 
  )
24880 
 
24881 
  def __init__(self, settlementId=None,):
24882 
    self.settlementId = settlementId
24883 
 
24884 
  def read(self, iprot):
24885 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24886 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24887 
      return
24888 
    iprot.readStructBegin()
24889 
    while True:
24890 
      (fname, ftype, fid) = iprot.readFieldBegin()
24891 
      if ftype == TType.STOP:
24892 
        break
24893 
      if fid == 1:
24894 
        if ftype == TType.I64:
24895 
          self.settlementId = iprot.readI64();
24896 
        else:
24897 
          iprot.skip(ftype)
24898 
      else:
24899 
        iprot.skip(ftype)
24900 
      iprot.readFieldEnd()
24901 
    iprot.readStructEnd()
24902 
 
24903 
  def write(self, oprot):
24904 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24905 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24906 
      return
24907 
    oprot.writeStructBegin('getEBSSettlementDate_args')
24908 
    if self.settlementId is not None:
24909 
      oprot.writeFieldBegin('settlementId', TType.I64, 1)
24910 
      oprot.writeI64(self.settlementId)
24911 
      oprot.writeFieldEnd()
24912 
    oprot.writeFieldStop()
24913 
    oprot.writeStructEnd()
24914 
 
24915 
  def validate(self):
24916 
    return
24917 
 
24918 
 
24919 
  def __repr__(self):
24920 
    L = ['%s=%r' % (key, value)
24921 
      for key, value in self.__dict__.iteritems()]
24922 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24923 
 
24924 
  def __eq__(self, other):
24925 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24926 
 
24927 
  def __ne__(self, other):
24928 
    return not (self == other)
24929 
 
24930 
class getEBSSettlementDate_result:
24931 
  """
24932 
  Attributes:
24933 
   - success
24934 
   - ex
24935 
  """
24936 
 
24937 
  thrift_spec = (
24938 
    (0, TType.I64, 'success', None, None, ), # 0
24939 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
24940 
  )
24941 
 
24942 
  def __init__(self, success=None, ex=None,):
24943 
    self.success = success
24944 
    self.ex = ex
24945 
 
24946 
  def read(self, iprot):
24947 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24948 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24949 
      return
24950 
    iprot.readStructBegin()
24951 
    while True:
24952 
      (fname, ftype, fid) = iprot.readFieldBegin()
24953 
      if ftype == TType.STOP:
24954 
        break
24955 
      if fid == 0:
24956 
        if ftype == TType.I64:
24957 
          self.success = iprot.readI64();
24958 
        else:
24959 
          iprot.skip(ftype)
24960 
      elif fid == 1:
24961 
        if ftype == TType.STRUCT:
24962 
          self.ex = TransactionServiceException()
24963 
          self.ex.read(iprot)
24964 
        else:
24965 
          iprot.skip(ftype)
24966 
      else:
24967 
        iprot.skip(ftype)
24968 
      iprot.readFieldEnd()
24969 
    iprot.readStructEnd()
24970 
 
24971 
  def write(self, oprot):
24972 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24973 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24974 
      return
24975 
    oprot.writeStructBegin('getEBSSettlementDate_result')
24976 
    if self.success is not None:
24977 
      oprot.writeFieldBegin('success', TType.I64, 0)
24978 
      oprot.writeI64(self.success)
24979 
      oprot.writeFieldEnd()
24980 
    if self.ex is not None:
24981 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
24982 
      self.ex.write(oprot)
24983 
      oprot.writeFieldEnd()
24984 
    oprot.writeFieldStop()
24985 
    oprot.writeStructEnd()
24986 
 
24987 
  def validate(self):
24988 
    return
24989 
 
24990 
 
24991 
  def __repr__(self):
24992 
    L = ['%s=%r' % (key, value)
24993 
      for key, value in self.__dict__.iteritems()]
24994 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24995 
 
24996 
  def __eq__(self, other):
24997 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24998 
 
24999 
  def __ne__(self, other):
25000 
    return not (self == other)
4715 varun.gupt 25001 
 
25002 
class getSettlementsByDate_args:
25003 
  """
25004 
  Attributes:
25005 
   - settlementDateFrom
25006 
   - settlementDateTo
25007 
   - isRefund
25008 
  """
25009 
 
25010 
  thrift_spec = (
25011 
    None, # 0
25012 
    (1, TType.I64, 'settlementDateFrom', None, None, ), # 1
25013 
    (2, TType.I64, 'settlementDateTo', None, None, ), # 2
25014 
    (3, TType.BOOL, 'isRefund', None, None, ), # 3
25015 
  )
25016 
 
25017 
  def __init__(self, settlementDateFrom=None, settlementDateTo=None, isRefund=None,):
25018 
    self.settlementDateFrom = settlementDateFrom
25019 
    self.settlementDateTo = settlementDateTo
25020 
    self.isRefund = isRefund
25021 
 
25022 
  def read(self, iprot):
25023 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25024 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25025 
      return
25026 
    iprot.readStructBegin()
25027 
    while True:
25028 
      (fname, ftype, fid) = iprot.readFieldBegin()
25029 
      if ftype == TType.STOP:
25030 
        break
25031 
      if fid == 1:
25032 
        if ftype == TType.I64:
25033 
          self.settlementDateFrom = iprot.readI64();
25034 
        else:
25035 
          iprot.skip(ftype)
25036 
      elif fid == 2:
25037 
        if ftype == TType.I64:
25038 
          self.settlementDateTo = iprot.readI64();
25039 
        else:
25040 
          iprot.skip(ftype)
25041 
      elif fid == 3:
25042 
        if ftype == TType.BOOL:
25043 
          self.isRefund = iprot.readBool();
25044 
        else:
25045 
          iprot.skip(ftype)
25046 
      else:
25047 
        iprot.skip(ftype)
25048 
      iprot.readFieldEnd()
25049 
    iprot.readStructEnd()
25050 
 
25051 
  def write(self, oprot):
25052 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25053 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25054 
      return
25055 
    oprot.writeStructBegin('getSettlementsByDate_args')
25056 
    if self.settlementDateFrom is not None:
25057 
      oprot.writeFieldBegin('settlementDateFrom', TType.I64, 1)
25058 
      oprot.writeI64(self.settlementDateFrom)
25059 
      oprot.writeFieldEnd()
25060 
    if self.settlementDateTo is not None:
25061 
      oprot.writeFieldBegin('settlementDateTo', TType.I64, 2)
25062 
      oprot.writeI64(self.settlementDateTo)
25063 
      oprot.writeFieldEnd()
25064 
    if self.isRefund is not None:
25065 
      oprot.writeFieldBegin('isRefund', TType.BOOL, 3)
25066 
      oprot.writeBool(self.isRefund)
25067 
      oprot.writeFieldEnd()
25068 
    oprot.writeFieldStop()
25069 
    oprot.writeStructEnd()
25070 
 
25071 
  def validate(self):
25072 
    return
25073 
 
25074 
 
25075 
  def __repr__(self):
25076 
    L = ['%s=%r' % (key, value)
25077 
      for key, value in self.__dict__.iteritems()]
25078 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25079 
 
25080 
  def __eq__(self, other):
25081 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25082 
 
25083 
  def __ne__(self, other):
25084 
    return not (self == other)
25085 
 
25086 
class getSettlementsByDate_result:
25087 
  """
25088 
  Attributes:
25089 
   - success
25090 
   - ex
25091 
  """
25092 
 
25093 
  thrift_spec = (
25094 
    (0, TType.LIST, 'success', (TType.STRUCT,(PaymentSettlement, PaymentSettlement.thrift_spec)), None, ), # 0
25095 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
25096 
  )
25097 
 
25098 
  def __init__(self, success=None, ex=None,):
25099 
    self.success = success
25100 
    self.ex = ex
25101 
 
25102 
  def read(self, iprot):
25103 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25104 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25105 
      return
25106 
    iprot.readStructBegin()
25107 
    while True:
25108 
      (fname, ftype, fid) = iprot.readFieldBegin()
25109 
      if ftype == TType.STOP:
25110 
        break
25111 
      if fid == 0:
25112 
        if ftype == TType.LIST:
25113 
          self.success = []
6188 rajveer 25114 
          (_etype566, _size563) = iprot.readListBegin()
25115 
          for _i567 in xrange(_size563):
25116 
            _elem568 = PaymentSettlement()
25117 
            _elem568.read(iprot)
25118 
            self.success.append(_elem568)
4715 varun.gupt 25119 
          iprot.readListEnd()
25120 
        else:
25121 
          iprot.skip(ftype)
25122 
      elif fid == 1:
25123 
        if ftype == TType.STRUCT:
25124 
          self.ex = TransactionServiceException()
25125 
          self.ex.read(iprot)
25126 
        else:
25127 
          iprot.skip(ftype)
25128 
      else:
25129 
        iprot.skip(ftype)
25130 
      iprot.readFieldEnd()
25131 
    iprot.readStructEnd()
25132 
 
25133 
  def write(self, oprot):
25134 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25135 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25136 
      return
25137 
    oprot.writeStructBegin('getSettlementsByDate_result')
25138 
    if self.success is not None:
25139 
      oprot.writeFieldBegin('success', TType.LIST, 0)
25140 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 25141 
      for iter569 in self.success:
25142 
        iter569.write(oprot)
4715 varun.gupt 25143 
      oprot.writeListEnd()
25144 
      oprot.writeFieldEnd()
25145 
    if self.ex is not None:
25146 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
25147 
      self.ex.write(oprot)
25148 
      oprot.writeFieldEnd()
25149 
    oprot.writeFieldStop()
25150 
    oprot.writeStructEnd()
25151 
 
25152 
  def validate(self):
25153 
    return
25154 
 
25155 
 
25156 
  def __repr__(self):
25157 
    L = ['%s=%r' % (key, value)
25158 
      for key, value in self.__dict__.iteritems()]
25159 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25160 
 
25161 
  def __eq__(self, other):
25162 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25163 
 
25164 
  def __ne__(self, other):
25165 
    return not (self == other)
25166 
 
25167 
class getReshippedOrderIds_args:
25168 
  """
25169 
  Attributes:
25170 
   - orderIds
25171 
  """
25172 
 
25173 
  thrift_spec = (
25174 
    None, # 0
25175 
    (1, TType.LIST, 'orderIds', (TType.I64,None), None, ), # 1
25176 
  )
25177 
 
25178 
  def __init__(self, orderIds=None,):
25179 
    self.orderIds = orderIds
25180 
 
25181 
  def read(self, iprot):
25182 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25183 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25184 
      return
25185 
    iprot.readStructBegin()
25186 
    while True:
25187 
      (fname, ftype, fid) = iprot.readFieldBegin()
25188 
      if ftype == TType.STOP:
25189 
        break
25190 
      if fid == 1:
25191 
        if ftype == TType.LIST:
25192 
          self.orderIds = []
6188 rajveer 25193 
          (_etype573, _size570) = iprot.readListBegin()
25194 
          for _i574 in xrange(_size570):
25195 
            _elem575 = iprot.readI64();
25196 
            self.orderIds.append(_elem575)
4715 varun.gupt 25197 
          iprot.readListEnd()
25198 
        else:
25199 
          iprot.skip(ftype)
25200 
      else:
25201 
        iprot.skip(ftype)
25202 
      iprot.readFieldEnd()
25203 
    iprot.readStructEnd()
25204 
 
25205 
  def write(self, oprot):
25206 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25207 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25208 
      return
25209 
    oprot.writeStructBegin('getReshippedOrderIds_args')
25210 
    if self.orderIds is not None:
25211 
      oprot.writeFieldBegin('orderIds', TType.LIST, 1)
25212 
      oprot.writeListBegin(TType.I64, len(self.orderIds))
6188 rajveer 25213 
      for iter576 in self.orderIds:
25214 
        oprot.writeI64(iter576)
4715 varun.gupt 25215 
      oprot.writeListEnd()
25216 
      oprot.writeFieldEnd()
25217 
    oprot.writeFieldStop()
25218 
    oprot.writeStructEnd()
25219 
 
25220 
  def validate(self):
25221 
    return
25222 
 
25223 
 
25224 
  def __repr__(self):
25225 
    L = ['%s=%r' % (key, value)
25226 
      for key, value in self.__dict__.iteritems()]
25227 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25228 
 
25229 
  def __eq__(self, other):
25230 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25231 
 
25232 
  def __ne__(self, other):
25233 
    return not (self == other)
25234 
 
25235 
class getReshippedOrderIds_result:
25236 
  """
25237 
  Attributes:
25238 
   - success
25239 
   - ex
25240 
  """
25241 
 
25242 
  thrift_spec = (
25243 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
25244 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
25245 
  )
25246 
 
25247 
  def __init__(self, success=None, ex=None,):
25248 
    self.success = success
25249 
    self.ex = ex
25250 
 
25251 
  def read(self, iprot):
25252 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25253 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25254 
      return
25255 
    iprot.readStructBegin()
25256 
    while True:
25257 
      (fname, ftype, fid) = iprot.readFieldBegin()
25258 
      if ftype == TType.STOP:
25259 
        break
25260 
      if fid == 0:
25261 
        if ftype == TType.LIST:
25262 
          self.success = []
6188 rajveer 25263 
          (_etype580, _size577) = iprot.readListBegin()
25264 
          for _i581 in xrange(_size577):
25265 
            _elem582 = iprot.readI64();
25266 
            self.success.append(_elem582)
4715 varun.gupt 25267 
          iprot.readListEnd()
25268 
        else:
25269 
          iprot.skip(ftype)
25270 
      elif fid == 1:
25271 
        if ftype == TType.STRUCT:
25272 
          self.ex = TransactionServiceException()
25273 
          self.ex.read(iprot)
25274 
        else:
25275 
          iprot.skip(ftype)
25276 
      else:
25277 
        iprot.skip(ftype)
25278 
      iprot.readFieldEnd()
25279 
    iprot.readStructEnd()
25280 
 
25281 
  def write(self, oprot):
25282 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25283 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25284 
      return
25285 
    oprot.writeStructBegin('getReshippedOrderIds_result')
25286 
    if self.success is not None:
25287 
      oprot.writeFieldBegin('success', TType.LIST, 0)
25288 
      oprot.writeListBegin(TType.I64, len(self.success))
6188 rajveer 25289 
      for iter583 in self.success:
25290 
        oprot.writeI64(iter583)
4715 varun.gupt 25291 
      oprot.writeListEnd()
25292 
      oprot.writeFieldEnd()
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)
4757 mandeep.dh 25314 
 
5481 phani.kuma 25315 
class getBilledOrders_args:
4875 varun.gupt 25316 
  """
25317 
  Attributes:
25318 
   - vendorId
5481 phani.kuma 25319 
   - onlyVendorNotPaid
25320 
   - billingDateFrom
25321 
   - billingDateTo
4875 varun.gupt 25322 
  """
25323 
 
25324 
  thrift_spec = (
25325 
    None, # 0
25326 
    (1, TType.I64, 'vendorId', None, None, ), # 1
5481 phani.kuma 25327 
    (2, TType.BOOL, 'onlyVendorNotPaid', None, None, ), # 2
25328 
    (3, TType.I64, 'billingDateFrom', None, None, ), # 3
25329 
    (4, TType.I64, 'billingDateTo', None, None, ), # 4
4875 varun.gupt 25330 
  )
25331 
 
5481 phani.kuma 25332 
  def __init__(self, vendorId=None, onlyVendorNotPaid=None, billingDateFrom=None, billingDateTo=None,):
4875 varun.gupt 25333 
    self.vendorId = vendorId
5481 phani.kuma 25334 
    self.onlyVendorNotPaid = onlyVendorNotPaid
25335 
    self.billingDateFrom = billingDateFrom
25336 
    self.billingDateTo = billingDateTo
4875 varun.gupt 25337 
 
25338 
  def read(self, iprot):
25339 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25340 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25341 
      return
25342 
    iprot.readStructBegin()
25343 
    while True:
25344 
      (fname, ftype, fid) = iprot.readFieldBegin()
25345 
      if ftype == TType.STOP:
25346 
        break
25347 
      if fid == 1:
25348 
        if ftype == TType.I64:
25349 
          self.vendorId = iprot.readI64();
25350 
        else:
25351 
          iprot.skip(ftype)
5481 phani.kuma 25352 
      elif fid == 2:
25353 
        if ftype == TType.BOOL:
25354 
          self.onlyVendorNotPaid = iprot.readBool();
25355 
        else:
25356 
          iprot.skip(ftype)
25357 
      elif fid == 3:
25358 
        if ftype == TType.I64:
25359 
          self.billingDateFrom = iprot.readI64();
25360 
        else:
25361 
          iprot.skip(ftype)
25362 
      elif fid == 4:
25363 
        if ftype == TType.I64:
25364 
          self.billingDateTo = iprot.readI64();
25365 
        else:
25366 
          iprot.skip(ftype)
4875 varun.gupt 25367 
      else:
25368 
        iprot.skip(ftype)
25369 
      iprot.readFieldEnd()
25370 
    iprot.readStructEnd()
25371 
 
25372 
  def write(self, oprot):
25373 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25374 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25375 
      return
5481 phani.kuma 25376 
    oprot.writeStructBegin('getBilledOrders_args')
4875 varun.gupt 25377 
    if self.vendorId is not None:
25378 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
25379 
      oprot.writeI64(self.vendorId)
25380 
      oprot.writeFieldEnd()
5481 phani.kuma 25381 
    if self.onlyVendorNotPaid is not None:
25382 
      oprot.writeFieldBegin('onlyVendorNotPaid', TType.BOOL, 2)
25383 
      oprot.writeBool(self.onlyVendorNotPaid)
25384 
      oprot.writeFieldEnd()
25385 
    if self.billingDateFrom is not None:
25386 
      oprot.writeFieldBegin('billingDateFrom', TType.I64, 3)
25387 
      oprot.writeI64(self.billingDateFrom)
25388 
      oprot.writeFieldEnd()
25389 
    if self.billingDateTo is not None:
25390 
      oprot.writeFieldBegin('billingDateTo', TType.I64, 4)
25391 
      oprot.writeI64(self.billingDateTo)
25392 
      oprot.writeFieldEnd()
4875 varun.gupt 25393 
    oprot.writeFieldStop()
25394 
    oprot.writeStructEnd()
25395 
 
25396 
  def validate(self):
25397 
    return
25398 
 
25399 
 
25400 
  def __repr__(self):
25401 
    L = ['%s=%r' % (key, value)
25402 
      for key, value in self.__dict__.iteritems()]
25403 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25404 
 
25405 
  def __eq__(self, other):
25406 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25407 
 
25408 
  def __ne__(self, other):
25409 
    return not (self == other)
25410 
 
5481 phani.kuma 25411 
class getBilledOrders_result:
4875 varun.gupt 25412 
  """
25413 
  Attributes:
25414 
   - success
25415 
   - ex
25416 
  """
25417 
 
25418 
  thrift_spec = (
25419 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
25420 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
25421 
  )
25422 
 
25423 
  def __init__(self, success=None, ex=None,):
25424 
    self.success = success
25425 
    self.ex = ex
25426 
 
25427 
  def read(self, iprot):
25428 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25429 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25430 
      return
25431 
    iprot.readStructBegin()
25432 
    while True:
25433 
      (fname, ftype, fid) = iprot.readFieldBegin()
25434 
      if ftype == TType.STOP:
25435 
        break
25436 
      if fid == 0:
25437 
        if ftype == TType.LIST:
25438 
          self.success = []
6188 rajveer 25439 
          (_etype587, _size584) = iprot.readListBegin()
25440 
          for _i588 in xrange(_size584):
25441 
            _elem589 = Order()
25442 
            _elem589.read(iprot)
25443 
            self.success.append(_elem589)
4875 varun.gupt 25444 
          iprot.readListEnd()
25445 
        else:
25446 
          iprot.skip(ftype)
25447 
      elif fid == 1:
25448 
        if ftype == TType.STRUCT:
25449 
          self.ex = TransactionServiceException()
25450 
          self.ex.read(iprot)
25451 
        else:
25452 
          iprot.skip(ftype)
25453 
      else:
25454 
        iprot.skip(ftype)
25455 
      iprot.readFieldEnd()
25456 
    iprot.readStructEnd()
25457 
 
25458 
  def write(self, oprot):
25459 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25460 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25461 
      return
5481 phani.kuma 25462 
    oprot.writeStructBegin('getBilledOrders_result')
4875 varun.gupt 25463 
    if self.success is not None:
25464 
      oprot.writeFieldBegin('success', TType.LIST, 0)
25465 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 25466 
      for iter590 in self.success:
25467 
        iter590.write(oprot)
4875 varun.gupt 25468 
      oprot.writeListEnd()
25469 
      oprot.writeFieldEnd()
25470 
    if self.ex is not None:
25471 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
25472 
      self.ex.write(oprot)
25473 
      oprot.writeFieldEnd()
25474 
    oprot.writeFieldStop()
25475 
    oprot.writeStructEnd()
25476 
 
25477 
  def validate(self):
25478 
    return
25479 
 
25480 
 
25481 
  def __repr__(self):
25482 
    L = ['%s=%r' % (key, value)
25483 
      for key, value in self.__dict__.iteritems()]
25484 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25485 
 
25486 
  def __eq__(self, other):
25487 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25488 
 
25489 
  def __ne__(self, other):
25490 
    return not (self == other)
5031 varun.gupt 25491 
 
25492 
class getStatusDistributionOfOrders_args:
25493 
  """
25494 
  Attributes:
25495 
   - startDate
25496 
   - endDate
25497 
  """
25498 
 
25499 
  thrift_spec = (
25500 
    None, # 0
25501 
    (1, TType.I64, 'startDate', None, None, ), # 1
25502 
    (2, TType.I64, 'endDate', None, None, ), # 2
25503 
  )
25504 
 
25505 
  def __init__(self, startDate=None, endDate=None,):
25506 
    self.startDate = startDate
25507 
    self.endDate = endDate
25508 
 
25509 
  def read(self, iprot):
25510 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25511 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25512 
      return
25513 
    iprot.readStructBegin()
25514 
    while True:
25515 
      (fname, ftype, fid) = iprot.readFieldBegin()
25516 
      if ftype == TType.STOP:
25517 
        break
25518 
      if fid == 1:
25519 
        if ftype == TType.I64:
25520 
          self.startDate = iprot.readI64();
25521 
        else:
25522 
          iprot.skip(ftype)
25523 
      elif fid == 2:
25524 
        if ftype == TType.I64:
25525 
          self.endDate = iprot.readI64();
25526 
        else:
25527 
          iprot.skip(ftype)
25528 
      else:
25529 
        iprot.skip(ftype)
25530 
      iprot.readFieldEnd()
25531 
    iprot.readStructEnd()
25532 
 
25533 
  def write(self, oprot):
25534 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25535 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25536 
      return
25537 
    oprot.writeStructBegin('getStatusDistributionOfOrders_args')
25538 
    if self.startDate is not None:
25539 
      oprot.writeFieldBegin('startDate', TType.I64, 1)
25540 
      oprot.writeI64(self.startDate)
25541 
      oprot.writeFieldEnd()
25542 
    if self.endDate is not None:
25543 
      oprot.writeFieldBegin('endDate', TType.I64, 2)
25544 
      oprot.writeI64(self.endDate)
25545 
      oprot.writeFieldEnd()
25546 
    oprot.writeFieldStop()
25547 
    oprot.writeStructEnd()
25548 
 
25549 
  def validate(self):
25550 
    return
25551 
 
25552 
 
25553 
  def __repr__(self):
25554 
    L = ['%s=%r' % (key, value)
25555 
      for key, value in self.__dict__.iteritems()]
25556 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25557 
 
25558 
  def __eq__(self, other):
25559 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25560 
 
25561 
  def __ne__(self, other):
25562 
    return not (self == other)
25563 
 
25564 
class getStatusDistributionOfOrders_result:
25565 
  """
25566 
  Attributes:
25567 
   - success
25568 
   - ex
25569 
  """
25570 
 
25571 
  thrift_spec = (
25572 
    (0, TType.MAP, 'success', (TType.I64,None,TType.I64,None), None, ), # 0
25573 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
25574 
  )
25575 
 
25576 
  def __init__(self, success=None, ex=None,):
25577 
    self.success = success
25578 
    self.ex = ex
25579 
 
25580 
  def read(self, iprot):
25581 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25582 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25583 
      return
25584 
    iprot.readStructBegin()
25585 
    while True:
25586 
      (fname, ftype, fid) = iprot.readFieldBegin()
25587 
      if ftype == TType.STOP:
25588 
        break
25589 
      if fid == 0:
25590 
        if ftype == TType.MAP:
25591 
          self.success = {}
6188 rajveer 25592 
          (_ktype592, _vtype593, _size591 ) = iprot.readMapBegin()
25593 
          for _i595 in xrange(_size591):
25594 
            _key596 = iprot.readI64();
25595 
            _val597 = iprot.readI64();
25596 
            self.success[_key596] = _val597
5031 varun.gupt 25597 
          iprot.readMapEnd()
25598 
        else:
25599 
          iprot.skip(ftype)
25600 
      elif fid == 1:
25601 
        if ftype == TType.STRUCT:
25602 
          self.ex = TransactionServiceException()
25603 
          self.ex.read(iprot)
25604 
        else:
25605 
          iprot.skip(ftype)
25606 
      else:
25607 
        iprot.skip(ftype)
25608 
      iprot.readFieldEnd()
25609 
    iprot.readStructEnd()
25610 
 
25611 
  def write(self, oprot):
25612 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25613 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25614 
      return
25615 
    oprot.writeStructBegin('getStatusDistributionOfOrders_result')
25616 
    if self.success is not None:
25617 
      oprot.writeFieldBegin('success', TType.MAP, 0)
25618 
      oprot.writeMapBegin(TType.I64, TType.I64, len(self.success))
6188 rajveer 25619 
      for kiter598,viter599 in self.success.items():
25620 
        oprot.writeI64(kiter598)
25621 
        oprot.writeI64(viter599)
5031 varun.gupt 25622 
      oprot.writeMapEnd()
25623 
      oprot.writeFieldEnd()
25624 
    if self.ex is not None:
25625 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
25626 
      self.ex.write(oprot)
25627 
      oprot.writeFieldEnd()
25628 
    oprot.writeFieldStop()
25629 
    oprot.writeStructEnd()
25630 
 
25631 
  def validate(self):
25632 
    return
25633 
 
25634 
 
25635 
  def __repr__(self):
25636 
    L = ['%s=%r' % (key, value)
25637 
      for key, value in self.__dict__.iteritems()]
25638 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25639 
 
25640 
  def __eq__(self, other):
25641 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25642 
 
25643 
  def __ne__(self, other):
25644 
    return not (self == other)
5067 varun.gupt 25645 
 
25646 
class getOrderIdsForStatus_args:
25647 
  """
25648 
  Attributes:
25649 
   - status
25650 
   - startDatetime
25651 
   - endDatetime
25652 
  """
25653 
 
25654 
  thrift_spec = (
25655 
    None, # 0
25656 
    (1, TType.I64, 'status', None, None, ), # 1
25657 
    (2, TType.I64, 'startDatetime', None, None, ), # 2
25658 
    (3, TType.I64, 'endDatetime', None, None, ), # 3
25659 
  )
25660 
 
25661 
  def __init__(self, status=None, startDatetime=None, endDatetime=None,):
25662 
    self.status = status
25663 
    self.startDatetime = startDatetime
25664 
    self.endDatetime = endDatetime
25665 
 
25666 
  def read(self, iprot):
25667 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25668 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25669 
      return
25670 
    iprot.readStructBegin()
25671 
    while True:
25672 
      (fname, ftype, fid) = iprot.readFieldBegin()
25673 
      if ftype == TType.STOP:
25674 
        break
25675 
      if fid == 1:
25676 
        if ftype == TType.I64:
25677 
          self.status = iprot.readI64();
25678 
        else:
25679 
          iprot.skip(ftype)
25680 
      elif fid == 2:
25681 
        if ftype == TType.I64:
25682 
          self.startDatetime = iprot.readI64();
25683 
        else:
25684 
          iprot.skip(ftype)
25685 
      elif fid == 3:
25686 
        if ftype == TType.I64:
25687 
          self.endDatetime = iprot.readI64();
25688 
        else:
25689 
          iprot.skip(ftype)
25690 
      else:
25691 
        iprot.skip(ftype)
25692 
      iprot.readFieldEnd()
25693 
    iprot.readStructEnd()
25694 
 
25695 
  def write(self, oprot):
25696 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25697 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25698 
      return
25699 
    oprot.writeStructBegin('getOrderIdsForStatus_args')
25700 
    if self.status is not None:
25701 
      oprot.writeFieldBegin('status', TType.I64, 1)
25702 
      oprot.writeI64(self.status)
25703 
      oprot.writeFieldEnd()
25704 
    if self.startDatetime is not None:
25705 
      oprot.writeFieldBegin('startDatetime', TType.I64, 2)
25706 
      oprot.writeI64(self.startDatetime)
25707 
      oprot.writeFieldEnd()
25708 
    if self.endDatetime is not None:
25709 
      oprot.writeFieldBegin('endDatetime', TType.I64, 3)
25710 
      oprot.writeI64(self.endDatetime)
25711 
      oprot.writeFieldEnd()
25712 
    oprot.writeFieldStop()
25713 
    oprot.writeStructEnd()
25714 
 
25715 
  def validate(self):
25716 
    return
25717 
 
25718 
 
25719 
  def __repr__(self):
25720 
    L = ['%s=%r' % (key, value)
25721 
      for key, value in self.__dict__.iteritems()]
25722 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25723 
 
25724 
  def __eq__(self, other):
25725 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25726 
 
25727 
  def __ne__(self, other):
25728 
    return not (self == other)
25729 
 
25730 
class getOrderIdsForStatus_result:
25731 
  """
25732 
  Attributes:
25733 
   - success
25734 
   - ex
25735 
  """
25736 
 
25737 
  thrift_spec = (
25738 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
25739 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
25740 
  )
25741 
 
25742 
  def __init__(self, success=None, ex=None,):
25743 
    self.success = success
25744 
    self.ex = ex
25745 
 
25746 
  def read(self, iprot):
25747 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25748 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25749 
      return
25750 
    iprot.readStructBegin()
25751 
    while True:
25752 
      (fname, ftype, fid) = iprot.readFieldBegin()
25753 
      if ftype == TType.STOP:
25754 
        break
25755 
      if fid == 0:
25756 
        if ftype == TType.LIST:
25757 
          self.success = []
6188 rajveer 25758 
          (_etype603, _size600) = iprot.readListBegin()
25759 
          for _i604 in xrange(_size600):
25760 
            _elem605 = iprot.readI64();
25761 
            self.success.append(_elem605)
5067 varun.gupt 25762 
          iprot.readListEnd()
25763 
        else:
25764 
          iprot.skip(ftype)
25765 
      elif fid == 1:
25766 
        if ftype == TType.STRUCT:
25767 
          self.ex = TransactionServiceException()
25768 
          self.ex.read(iprot)
25769 
        else:
25770 
          iprot.skip(ftype)
25771 
      else:
25772 
        iprot.skip(ftype)
25773 
      iprot.readFieldEnd()
25774 
    iprot.readStructEnd()
25775 
 
25776 
  def write(self, oprot):
25777 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25778 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25779 
      return
25780 
    oprot.writeStructBegin('getOrderIdsForStatus_result')
25781 
    if self.success is not None:
25782 
      oprot.writeFieldBegin('success', TType.LIST, 0)
25783 
      oprot.writeListBegin(TType.I64, len(self.success))
6188 rajveer 25784 
      for iter606 in self.success:
25785 
        oprot.writeI64(iter606)
5067 varun.gupt 25786 
      oprot.writeListEnd()
25787 
      oprot.writeFieldEnd()
25788 
    if self.ex is not None:
25789 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
25790 
      self.ex.write(oprot)
25791 
      oprot.writeFieldEnd()
25792 
    oprot.writeFieldStop()
25793 
    oprot.writeStructEnd()
25794 
 
25795 
  def validate(self):
25796 
    return
25797 
 
25798 
 
25799 
  def __repr__(self):
25800 
    L = ['%s=%r' % (key, value)
25801 
      for key, value in self.__dict__.iteritems()]
25802 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25803 
 
25804 
  def __eq__(self, other):
25805 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25806 
 
25807 
  def __ne__(self, other):
25808 
    return not (self == other)
5099 varun.gupt 25809 
 
5348 anupam.sin 25810 
class updateCODAgent_args:
25811 
  """
25812 
  Attributes:
25813 
   - agent
25814 
   - orderId
25815 
  """
25816 
 
25817 
  thrift_spec = (
25818 
    None, # 0
25819 
    (1, TType.STRING, 'agent', None, None, ), # 1
25820 
    (2, TType.I64, 'orderId', None, None, ), # 2
25821 
  )
25822 
 
25823 
  def __init__(self, agent=None, orderId=None,):
25824 
    self.agent = agent
25825 
    self.orderId = orderId
25826 
 
25827 
  def read(self, iprot):
25828 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25829 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25830 
      return
25831 
    iprot.readStructBegin()
25832 
    while True:
25833 
      (fname, ftype, fid) = iprot.readFieldBegin()
25834 
      if ftype == TType.STOP:
25835 
        break
25836 
      if fid == 1:
25837 
        if ftype == TType.STRING:
25838 
          self.agent = iprot.readString();
25839 
        else:
25840 
          iprot.skip(ftype)
25841 
      elif fid == 2:
25842 
        if ftype == TType.I64:
25843 
          self.orderId = iprot.readI64();
25844 
        else:
25845 
          iprot.skip(ftype)
25846 
      else:
25847 
        iprot.skip(ftype)
25848 
      iprot.readFieldEnd()
25849 
    iprot.readStructEnd()
25850 
 
25851 
  def write(self, oprot):
25852 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25853 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25854 
      return
25855 
    oprot.writeStructBegin('updateCODAgent_args')
25856 
    if self.agent is not None:
25857 
      oprot.writeFieldBegin('agent', TType.STRING, 1)
25858 
      oprot.writeString(self.agent)
25859 
      oprot.writeFieldEnd()
25860 
    if self.orderId is not None:
25861 
      oprot.writeFieldBegin('orderId', TType.I64, 2)
25862 
      oprot.writeI64(self.orderId)
25863 
      oprot.writeFieldEnd()
25864 
    oprot.writeFieldStop()
25865 
    oprot.writeStructEnd()
25866 
 
25867 
  def validate(self):
25868 
    return
25869 
 
25870 
 
25871 
  def __repr__(self):
25872 
    L = ['%s=%r' % (key, value)
25873 
      for key, value in self.__dict__.iteritems()]
25874 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25875 
 
25876 
  def __eq__(self, other):
25877 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25878 
 
25879 
  def __ne__(self, other):
25880 
    return not (self == other)
25881 
 
25882 
class updateCODAgent_result:
25883 
  """
25884 
  Attributes:
25885 
   - ex
25886 
  """
25887 
 
25888 
  thrift_spec = (
25889 
    None, # 0
25890 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
25891 
  )
25892 
 
25893 
  def __init__(self, ex=None,):
25894 
    self.ex = ex
25895 
 
25896 
  def read(self, iprot):
25897 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25898 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25899 
      return
25900 
    iprot.readStructBegin()
25901 
    while True:
25902 
      (fname, ftype, fid) = iprot.readFieldBegin()
25903 
      if ftype == TType.STOP:
25904 
        break
25905 
      if fid == 1:
25906 
        if ftype == TType.STRUCT:
25907 
          self.ex = TransactionServiceException()
25908 
          self.ex.read(iprot)
25909 
        else:
25910 
          iprot.skip(ftype)
25911 
      else:
25912 
        iprot.skip(ftype)
25913 
      iprot.readFieldEnd()
25914 
    iprot.readStructEnd()
25915 
 
25916 
  def write(self, oprot):
25917 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25918 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25919 
      return
25920 
    oprot.writeStructBegin('updateCODAgent_result')
25921 
    if self.ex is not None:
25922 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
25923 
      self.ex.write(oprot)
25924 
      oprot.writeFieldEnd()
25925 
    oprot.writeFieldStop()
25926 
    oprot.writeStructEnd()
25927 
 
25928 
  def validate(self):
25929 
    return
25930 
 
25931 
 
25932 
  def __repr__(self):
25933 
    L = ['%s=%r' % (key, value)
25934 
      for key, value in self.__dict__.iteritems()]
25935 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25936 
 
25937 
  def __eq__(self, other):
25938 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25939 
 
25940 
  def __ne__(self, other):
25941 
    return not (self == other)
25942 
 
5099 varun.gupt 25943 
class updateOrderAsPaidToVendor_args:
25944 
  """
25945 
  Attributes:
25946 
   - orderId
25947 
  """
25948 
 
25949 
  thrift_spec = (
25950 
    None, # 0
25951 
    (1, TType.I64, 'orderId', None, None, ), # 1
25952 
  )
25953 
 
25954 
  def __init__(self, orderId=None,):
25955 
    self.orderId = orderId
25956 
 
25957 
  def read(self, iprot):
25958 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25959 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25960 
      return
25961 
    iprot.readStructBegin()
25962 
    while True:
25963 
      (fname, ftype, fid) = iprot.readFieldBegin()
25964 
      if ftype == TType.STOP:
25965 
        break
25966 
      if fid == 1:
25967 
        if ftype == TType.I64:
25968 
          self.orderId = iprot.readI64();
25969 
        else:
25970 
          iprot.skip(ftype)
25971 
      else:
25972 
        iprot.skip(ftype)
25973 
      iprot.readFieldEnd()
25974 
    iprot.readStructEnd()
25975 
 
25976 
  def write(self, oprot):
25977 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25978 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25979 
      return
25980 
    oprot.writeStructBegin('updateOrderAsPaidToVendor_args')
25981 
    if self.orderId is not None:
25982 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
25983 
      oprot.writeI64(self.orderId)
25984 
      oprot.writeFieldEnd()
25985 
    oprot.writeFieldStop()
25986 
    oprot.writeStructEnd()
25987 
 
25988 
  def validate(self):
25989 
    return
25990 
 
25991 
 
25992 
  def __repr__(self):
25993 
    L = ['%s=%r' % (key, value)
25994 
      for key, value in self.__dict__.iteritems()]
25995 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25996 
 
25997 
  def __eq__(self, other):
25998 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25999 
 
26000 
  def __ne__(self, other):
26001 
    return not (self == other)
26002 
 
26003 
class updateOrderAsPaidToVendor_result:
26004 
  """
26005 
  Attributes:
26006 
   - ex
26007 
  """
26008 
 
26009 
  thrift_spec = (
26010 
    None, # 0
26011 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
26012 
  )
26013 
 
26014 
  def __init__(self, ex=None,):
26015 
    self.ex = ex
26016 
 
26017 
  def read(self, iprot):
26018 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26019 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26020 
      return
26021 
    iprot.readStructBegin()
26022 
    while True:
26023 
      (fname, ftype, fid) = iprot.readFieldBegin()
26024 
      if ftype == TType.STOP:
26025 
        break
26026 
      if fid == 1:
26027 
        if ftype == TType.STRUCT:
26028 
          self.ex = TransactionServiceException()
26029 
          self.ex.read(iprot)
26030 
        else:
26031 
          iprot.skip(ftype)
26032 
      else:
26033 
        iprot.skip(ftype)
26034 
      iprot.readFieldEnd()
26035 
    iprot.readStructEnd()
26036 
 
26037 
  def write(self, oprot):
26038 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26039 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26040 
      return
26041 
    oprot.writeStructBegin('updateOrderAsPaidToVendor_result')
26042 
    if self.ex is not None:
26043 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
26044 
      self.ex.write(oprot)
26045 
      oprot.writeFieldEnd()
26046 
    oprot.writeFieldStop()
26047 
    oprot.writeStructEnd()
26048 
 
26049 
  def validate(self):
26050 
    return
26051 
 
26052 
 
26053 
  def __repr__(self):
26054 
    L = ['%s=%r' % (key, value)
26055 
      for key, value in self.__dict__.iteritems()]
26056 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26057 
 
26058 
  def __eq__(self, other):
26059 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26060 
 
26061 
  def __ne__(self, other):
26062 
    return not (self == other)
5208 varun.gupt 26063 
 
5386 phani.kuma 26064 
class updateOrderOnlyAsPaidToVendor_args:
26065 
  """
26066 
  Attributes:
26067 
   - orderId
26068 
  """
26069 
 
26070 
  thrift_spec = (
26071 
    None, # 0
26072 
    (1, TType.I64, 'orderId', None, None, ), # 1
26073 
  )
26074 
 
26075 
  def __init__(self, orderId=None,):
26076 
    self.orderId = orderId
26077 
 
26078 
  def read(self, iprot):
26079 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26080 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26081 
      return
26082 
    iprot.readStructBegin()
26083 
    while True:
26084 
      (fname, ftype, fid) = iprot.readFieldBegin()
26085 
      if ftype == TType.STOP:
26086 
        break
26087 
      if fid == 1:
26088 
        if ftype == TType.I64:
26089 
          self.orderId = iprot.readI64();
26090 
        else:
26091 
          iprot.skip(ftype)
26092 
      else:
26093 
        iprot.skip(ftype)
26094 
      iprot.readFieldEnd()
26095 
    iprot.readStructEnd()
26096 
 
26097 
  def write(self, oprot):
26098 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26099 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26100 
      return
26101 
    oprot.writeStructBegin('updateOrderOnlyAsPaidToVendor_args')
26102 
    if self.orderId is not None:
26103 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
26104 
      oprot.writeI64(self.orderId)
26105 
      oprot.writeFieldEnd()
26106 
    oprot.writeFieldStop()
26107 
    oprot.writeStructEnd()
26108 
 
26109 
  def validate(self):
26110 
    return
26111 
 
26112 
 
26113 
  def __repr__(self):
26114 
    L = ['%s=%r' % (key, value)
26115 
      for key, value in self.__dict__.iteritems()]
26116 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26117 
 
26118 
  def __eq__(self, other):
26119 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26120 
 
26121 
  def __ne__(self, other):
26122 
    return not (self == other)
26123 
 
26124 
class updateOrderOnlyAsPaidToVendor_result:
26125 
  """
26126 
  Attributes:
26127 
   - ex
26128 
  """
26129 
 
26130 
  thrift_spec = (
26131 
    None, # 0
26132 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
26133 
  )
26134 
 
26135 
  def __init__(self, ex=None,):
26136 
    self.ex = ex
26137 
 
26138 
  def read(self, iprot):
26139 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26140 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26141 
      return
26142 
    iprot.readStructBegin()
26143 
    while True:
26144 
      (fname, ftype, fid) = iprot.readFieldBegin()
26145 
      if ftype == TType.STOP:
26146 
        break
26147 
      if fid == 1:
26148 
        if ftype == TType.STRUCT:
26149 
          self.ex = TransactionServiceException()
26150 
          self.ex.read(iprot)
26151 
        else:
26152 
          iprot.skip(ftype)
26153 
      else:
26154 
        iprot.skip(ftype)
26155 
      iprot.readFieldEnd()
26156 
    iprot.readStructEnd()
26157 
 
26158 
  def write(self, oprot):
26159 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26160 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26161 
      return
26162 
    oprot.writeStructBegin('updateOrderOnlyAsPaidToVendor_result')
26163 
    if self.ex is not None:
26164 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
26165 
      self.ex.write(oprot)
26166 
      oprot.writeFieldEnd()
26167 
    oprot.writeFieldStop()
26168 
    oprot.writeStructEnd()
26169 
 
26170 
  def validate(self):
26171 
    return
26172 
 
26173 
 
26174 
  def __repr__(self):
26175 
    L = ['%s=%r' % (key, value)
26176 
      for key, value in self.__dict__.iteritems()]
26177 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26178 
 
26179 
  def __eq__(self, other):
26180 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26181 
 
26182 
  def __ne__(self, other):
26183 
    return not (self == other)
26184 
 
5208 varun.gupt 26185 
class getRefundedOrdersMarkedPaid_args:
26186 
 
26187 
  thrift_spec = (
26188 
  )
26189 
 
26190 
  def read(self, iprot):
26191 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26192 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26193 
      return
26194 
    iprot.readStructBegin()
26195 
    while True:
26196 
      (fname, ftype, fid) = iprot.readFieldBegin()
26197 
      if ftype == TType.STOP:
26198 
        break
26199 
      else:
26200 
        iprot.skip(ftype)
26201 
      iprot.readFieldEnd()
26202 
    iprot.readStructEnd()
26203 
 
26204 
  def write(self, oprot):
26205 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26206 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26207 
      return
26208 
    oprot.writeStructBegin('getRefundedOrdersMarkedPaid_args')
26209 
    oprot.writeFieldStop()
26210 
    oprot.writeStructEnd()
26211 
 
26212 
  def validate(self):
26213 
    return
26214 
 
26215 
 
26216 
  def __repr__(self):
26217 
    L = ['%s=%r' % (key, value)
26218 
      for key, value in self.__dict__.iteritems()]
26219 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26220 
 
26221 
  def __eq__(self, other):
26222 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26223 
 
26224 
  def __ne__(self, other):
26225 
    return not (self == other)
26226 
 
26227 
class getRefundedOrdersMarkedPaid_result:
26228 
  """
26229 
  Attributes:
26230 
   - success
26231 
   - ex
26232 
  """
26233 
 
26234 
  thrift_spec = (
26235 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
26236 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
26237 
  )
26238 
 
26239 
  def __init__(self, success=None, ex=None,):
26240 
    self.success = success
26241 
    self.ex = ex
26242 
 
26243 
  def read(self, iprot):
26244 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26245 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26246 
      return
26247 
    iprot.readStructBegin()
26248 
    while True:
26249 
      (fname, ftype, fid) = iprot.readFieldBegin()
26250 
      if ftype == TType.STOP:
26251 
        break
26252 
      if fid == 0:
26253 
        if ftype == TType.LIST:
26254 
          self.success = []
6188 rajveer 26255 
          (_etype610, _size607) = iprot.readListBegin()
26256 
          for _i611 in xrange(_size607):
26257 
            _elem612 = Order()
26258 
            _elem612.read(iprot)
26259 
            self.success.append(_elem612)
5208 varun.gupt 26260 
          iprot.readListEnd()
26261 
        else:
26262 
          iprot.skip(ftype)
26263 
      elif fid == 1:
26264 
        if ftype == TType.STRUCT:
26265 
          self.ex = TransactionServiceException()
26266 
          self.ex.read(iprot)
26267 
        else:
26268 
          iprot.skip(ftype)
26269 
      else:
26270 
        iprot.skip(ftype)
26271 
      iprot.readFieldEnd()
26272 
    iprot.readStructEnd()
26273 
 
26274 
  def write(self, oprot):
26275 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26276 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26277 
      return
26278 
    oprot.writeStructBegin('getRefundedOrdersMarkedPaid_result')
26279 
    if self.success is not None:
26280 
      oprot.writeFieldBegin('success', TType.LIST, 0)
26281 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 26282 
      for iter613 in self.success:
26283 
        iter613.write(oprot)
5208 varun.gupt 26284 
      oprot.writeListEnd()
26285 
      oprot.writeFieldEnd()
26286 
    if self.ex is not None:
26287 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
26288 
      self.ex.write(oprot)
26289 
      oprot.writeFieldEnd()
26290 
    oprot.writeFieldStop()
26291 
    oprot.writeStructEnd()
26292 
 
26293 
  def validate(self):
26294 
    return
26295 
 
26296 
 
26297 
  def __repr__(self):
26298 
    L = ['%s=%r' % (key, value)
26299 
      for key, value in self.__dict__.iteritems()]
26300 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26301 
 
26302 
  def __eq__(self, other):
26303 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26304 
 
26305 
  def __ne__(self, other):
26306 
    return not (self == other)
5447 anupam.sin 26307 
 
26308 
class getAllVerificationAgents_args:
26309 
  """
26310 
  Attributes:
26311 
   - minOrderId
26312 
   - maxOrderId
26313 
  """
26314 
 
26315 
  thrift_spec = (
26316 
    None, # 0
26317 
    (1, TType.I64, 'minOrderId', None, None, ), # 1
26318 
    (2, TType.I64, 'maxOrderId', None, None, ), # 2
26319 
  )
26320 
 
26321 
  def __init__(self, minOrderId=None, maxOrderId=None,):
26322 
    self.minOrderId = minOrderId
26323 
    self.maxOrderId = maxOrderId
26324 
 
26325 
  def read(self, iprot):
26326 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26327 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26328 
      return
26329 
    iprot.readStructBegin()
26330 
    while True:
26331 
      (fname, ftype, fid) = iprot.readFieldBegin()
26332 
      if ftype == TType.STOP:
26333 
        break
26334 
      if fid == 1:
26335 
        if ftype == TType.I64:
26336 
          self.minOrderId = iprot.readI64();
26337 
        else:
26338 
          iprot.skip(ftype)
26339 
      elif fid == 2:
26340 
        if ftype == TType.I64:
26341 
          self.maxOrderId = iprot.readI64();
26342 
        else:
26343 
          iprot.skip(ftype)
26344 
      else:
26345 
        iprot.skip(ftype)
26346 
      iprot.readFieldEnd()
26347 
    iprot.readStructEnd()
26348 
 
26349 
  def write(self, oprot):
26350 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26351 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26352 
      return
26353 
    oprot.writeStructBegin('getAllVerificationAgents_args')
26354 
    if self.minOrderId is not None:
26355 
      oprot.writeFieldBegin('minOrderId', TType.I64, 1)
26356 
      oprot.writeI64(self.minOrderId)
26357 
      oprot.writeFieldEnd()
26358 
    if self.maxOrderId is not None:
26359 
      oprot.writeFieldBegin('maxOrderId', TType.I64, 2)
26360 
      oprot.writeI64(self.maxOrderId)
26361 
      oprot.writeFieldEnd()
26362 
    oprot.writeFieldStop()
26363 
    oprot.writeStructEnd()
26364 
 
26365 
  def validate(self):
26366 
    return
26367 
 
26368 
 
26369 
  def __repr__(self):
26370 
    L = ['%s=%r' % (key, value)
26371 
      for key, value in self.__dict__.iteritems()]
26372 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26373 
 
26374 
  def __eq__(self, other):
26375 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26376 
 
26377 
  def __ne__(self, other):
26378 
    return not (self == other)
26379 
 
26380 
class getAllVerificationAgents_result:
26381 
  """
26382 
  Attributes:
26383 
   - success
26384 
  """
26385 
 
26386 
  thrift_spec = (
26387 
    (0, TType.LIST, 'success', (TType.STRUCT,(CODVerificationAgent, CODVerificationAgent.thrift_spec)), None, ), # 0
26388 
  )
26389 
 
26390 
  def __init__(self, success=None,):
26391 
    self.success = success
26392 
 
26393 
  def read(self, iprot):
26394 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26395 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26396 
      return
26397 
    iprot.readStructBegin()
26398 
    while True:
26399 
      (fname, ftype, fid) = iprot.readFieldBegin()
26400 
      if ftype == TType.STOP:
26401 
        break
26402 
      if fid == 0:
26403 
        if ftype == TType.LIST:
26404 
          self.success = []
6188 rajveer 26405 
          (_etype617, _size614) = iprot.readListBegin()
26406 
          for _i618 in xrange(_size614):
26407 
            _elem619 = CODVerificationAgent()
26408 
            _elem619.read(iprot)
26409 
            self.success.append(_elem619)
5447 anupam.sin 26410 
          iprot.readListEnd()
26411 
        else:
26412 
          iprot.skip(ftype)
26413 
      else:
26414 
        iprot.skip(ftype)
26415 
      iprot.readFieldEnd()
26416 
    iprot.readStructEnd()
26417 
 
26418 
  def write(self, oprot):
26419 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26420 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26421 
      return
26422 
    oprot.writeStructBegin('getAllVerificationAgents_result')
26423 
    if self.success is not None:
26424 
      oprot.writeFieldBegin('success', TType.LIST, 0)
26425 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 26426 
      for iter620 in self.success:
26427 
        iter620.write(oprot)
5447 anupam.sin 26428 
      oprot.writeListEnd()
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)
5527 anupam.sin 26447 
 
26448 
class getAllAttributesForOrderId_args:
26449 
  """
26450 
  Attributes:
26451 
   - orderId
26452 
  """
26453 
 
26454 
  thrift_spec = (
26455 
    None, # 0
26456 
    (1, TType.I64, 'orderId', None, None, ), # 1
26457 
  )
26458 
 
26459 
  def __init__(self, orderId=None,):
26460 
    self.orderId = orderId
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.I64:
26473 
          self.orderId = iprot.readI64();
26474 
        else:
26475 
          iprot.skip(ftype)
26476 
      else:
26477 
        iprot.skip(ftype)
26478 
      iprot.readFieldEnd()
26479 
    iprot.readStructEnd()
26480 
 
26481 
  def write(self, oprot):
26482 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26483 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26484 
      return
26485 
    oprot.writeStructBegin('getAllAttributesForOrderId_args')
26486 
    if self.orderId is not None:
26487 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
26488 
      oprot.writeI64(self.orderId)
26489 
      oprot.writeFieldEnd()
26490 
    oprot.writeFieldStop()
26491 
    oprot.writeStructEnd()
26492 
 
26493 
  def validate(self):
26494 
    return
26495 
 
26496 
 
26497 
  def __repr__(self):
26498 
    L = ['%s=%r' % (key, value)
26499 
      for key, value in self.__dict__.iteritems()]
26500 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26501 
 
26502 
  def __eq__(self, other):
26503 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26504 
 
26505 
  def __ne__(self, other):
26506 
    return not (self == other)
26507 
 
26508 
class getAllAttributesForOrderId_result:
26509 
  """
26510 
  Attributes:
26511 
   - success
26512 
  """
26513 
 
26514 
  thrift_spec = (
26515 
    (0, TType.LIST, 'success', (TType.STRUCT,(Attribute, Attribute.thrift_spec)), None, ), # 0
26516 
  )
26517 
 
26518 
  def __init__(self, success=None,):
26519 
    self.success = success
26520 
 
26521 
  def read(self, iprot):
26522 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26523 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26524 
      return
26525 
    iprot.readStructBegin()
26526 
    while True:
26527 
      (fname, ftype, fid) = iprot.readFieldBegin()
26528 
      if ftype == TType.STOP:
26529 
        break
26530 
      if fid == 0:
26531 
        if ftype == TType.LIST:
26532 
          self.success = []
6188 rajveer 26533 
          (_etype624, _size621) = iprot.readListBegin()
26534 
          for _i625 in xrange(_size621):
26535 
            _elem626 = Attribute()
26536 
            _elem626.read(iprot)
26537 
            self.success.append(_elem626)
5527 anupam.sin 26538 
          iprot.readListEnd()
26539 
        else:
26540 
          iprot.skip(ftype)
26541 
      else:
26542 
        iprot.skip(ftype)
26543 
      iprot.readFieldEnd()
26544 
    iprot.readStructEnd()
26545 
 
26546 
  def write(self, oprot):
26547 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26548 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26549 
      return
26550 
    oprot.writeStructBegin('getAllAttributesForOrderId_result')
26551 
    if self.success is not None:
26552 
      oprot.writeFieldBegin('success', TType.LIST, 0)
26553 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 26554 
      for iter627 in self.success:
26555 
        iter627.write(oprot)
5527 anupam.sin 26556 
      oprot.writeListEnd()
26557 
      oprot.writeFieldEnd()
26558 
    oprot.writeFieldStop()
26559 
    oprot.writeStructEnd()
26560 
 
26561 
  def validate(self):
26562 
    return
26563 
 
26564 
 
26565 
  def __repr__(self):
26566 
    L = ['%s=%r' % (key, value)
26567 
      for key, value in self.__dict__.iteritems()]
26568 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26569 
 
26570 
  def __eq__(self, other):
26571 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26572 
 
26573 
  def __ne__(self, other):
26574 
    return not (self == other)
26575 
 
5676 rajveer 26576 
class setOrderAttributes_args:
26577 
  """
26578 
  Attributes:
26579 
   - orderId
26580 
   - attributes
26581 
  """
26582 
 
26583 
  thrift_spec = None
26584 
  def __init__(self, orderId=None, attributes=None,):
26585 
    self.orderId = orderId
26586 
    self.attributes = attributes
26587 
 
26588 
  def read(self, iprot):
26589 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26590 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26591 
      return
26592 
    iprot.readStructBegin()
26593 
    while True:
26594 
      (fname, ftype, fid) = iprot.readFieldBegin()
26595 
      if ftype == TType.STOP:
26596 
        break
26597 
      if fid == 1:
26598 
        if ftype == TType.I64:
26599 
          self.orderId = iprot.readI64();
26600 
        else:
26601 
          iprot.skip(ftype)
26602 
      elif fid == -1:
26603 
        if ftype == TType.LIST:
26604 
          self.attributes = []
6188 rajveer 26605 
          (_etype631, _size628) = iprot.readListBegin()
26606 
          for _i632 in xrange(_size628):
26607 
            _elem633 = Attribute()
26608 
            _elem633.read(iprot)
26609 
            self.attributes.append(_elem633)
5676 rajveer 26610 
          iprot.readListEnd()
26611 
        else:
26612 
          iprot.skip(ftype)
26613 
      else:
26614 
        iprot.skip(ftype)
26615 
      iprot.readFieldEnd()
26616 
    iprot.readStructEnd()
26617 
 
26618 
  def write(self, oprot):
26619 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26620 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26621 
      return
26622 
    oprot.writeStructBegin('setOrderAttributes_args')
26623 
    if self.attributes is not None:
26624 
      oprot.writeFieldBegin('attributes', TType.LIST, -1)
26625 
      oprot.writeListBegin(TType.STRUCT, len(self.attributes))
6188 rajveer 26626 
      for iter634 in self.attributes:
26627 
        iter634.write(oprot)
5676 rajveer 26628 
      oprot.writeListEnd()
26629 
      oprot.writeFieldEnd()
26630 
    if self.orderId is not None:
26631 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
26632 
      oprot.writeI64(self.orderId)
26633 
      oprot.writeFieldEnd()
26634 
    oprot.writeFieldStop()
26635 
    oprot.writeStructEnd()
26636 
 
26637 
  def validate(self):
26638 
    return
26639 
 
26640 
 
26641 
  def __repr__(self):
26642 
    L = ['%s=%r' % (key, value)
26643 
      for key, value in self.__dict__.iteritems()]
26644 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26645 
 
26646 
  def __eq__(self, other):
26647 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26648 
 
26649 
  def __ne__(self, other):
26650 
    return not (self == other)
26651 
 
26652 
class setOrderAttributes_result:
26653 
 
26654 
  thrift_spec = (
26655 
  )
26656 
 
26657 
  def read(self, iprot):
26658 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26659 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26660 
      return
26661 
    iprot.readStructBegin()
26662 
    while True:
26663 
      (fname, ftype, fid) = iprot.readFieldBegin()
26664 
      if ftype == TType.STOP:
26665 
        break
26666 
      else:
26667 
        iprot.skip(ftype)
26668 
      iprot.readFieldEnd()
26669 
    iprot.readStructEnd()
26670 
 
26671 
  def write(self, oprot):
26672 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26673 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26674 
      return
26675 
    oprot.writeStructBegin('setOrderAttributes_result')
26676 
    oprot.writeFieldStop()
26677 
    oprot.writeStructEnd()
26678 
 
26679 
  def validate(self):
26680 
    return
26681 
 
26682 
 
26683 
  def __repr__(self):
26684 
    L = ['%s=%r' % (key, value)
26685 
      for key, value in self.__dict__.iteritems()]
26686 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26687 
 
26688 
  def __eq__(self, other):
26689 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26690 
 
26691 
  def __ne__(self, other):
26692 
    return not (self == other)
26693 
 
5527 anupam.sin 26694 
class setOrderAttributeForTransaction_args:
26695 
  """
26696 
  Attributes:
26697 
   - transactionId
26698 
   - attribute
26699 
  """
26700 
 
26701 
  thrift_spec = None
26702 
  def __init__(self, transactionId=None, attribute=None,):
26703 
    self.transactionId = transactionId
26704 
    self.attribute = attribute
26705 
 
26706 
  def read(self, iprot):
26707 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26708 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26709 
      return
26710 
    iprot.readStructBegin()
26711 
    while True:
26712 
      (fname, ftype, fid) = iprot.readFieldBegin()
26713 
      if ftype == TType.STOP:
26714 
        break
26715 
      if fid == 1:
26716 
        if ftype == TType.I64:
26717 
          self.transactionId = iprot.readI64();
26718 
        else:
26719 
          iprot.skip(ftype)
26720 
      elif fid == -1:
26721 
        if ftype == TType.STRUCT:
26722 
          self.attribute = Attribute()
26723 
          self.attribute.read(iprot)
26724 
        else:
26725 
          iprot.skip(ftype)
26726 
      else:
26727 
        iprot.skip(ftype)
26728 
      iprot.readFieldEnd()
26729 
    iprot.readStructEnd()
26730 
 
26731 
  def write(self, oprot):
26732 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26733 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26734 
      return
26735 
    oprot.writeStructBegin('setOrderAttributeForTransaction_args')
26736 
    if self.attribute is not None:
26737 
      oprot.writeFieldBegin('attribute', TType.STRUCT, -1)
26738 
      self.attribute.write(oprot)
26739 
      oprot.writeFieldEnd()
26740 
    if self.transactionId is not None:
26741 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
26742 
      oprot.writeI64(self.transactionId)
26743 
      oprot.writeFieldEnd()
26744 
    oprot.writeFieldStop()
26745 
    oprot.writeStructEnd()
26746 
 
26747 
  def validate(self):
26748 
    return
26749 
 
26750 
 
26751 
  def __repr__(self):
26752 
    L = ['%s=%r' % (key, value)
26753 
      for key, value in self.__dict__.iteritems()]
26754 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26755 
 
26756 
  def __eq__(self, other):
26757 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26758 
 
26759 
  def __ne__(self, other):
26760 
    return not (self == other)
26761 
 
26762 
class setOrderAttributeForTransaction_result:
26763 
 
26764 
  thrift_spec = (
26765 
  )
26766 
 
26767 
  def read(self, iprot):
26768 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26769 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26770 
      return
26771 
    iprot.readStructBegin()
26772 
    while True:
26773 
      (fname, ftype, fid) = iprot.readFieldBegin()
26774 
      if ftype == TType.STOP:
26775 
        break
26776 
      else:
26777 
        iprot.skip(ftype)
26778 
      iprot.readFieldEnd()
26779 
    iprot.readStructEnd()
26780 
 
26781 
  def write(self, oprot):
26782 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26783 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26784 
      return
26785 
    oprot.writeStructBegin('setOrderAttributeForTransaction_result')
26786 
    oprot.writeFieldStop()
26787 
    oprot.writeStructEnd()
26788 
 
26789 
  def validate(self):
26790 
    return
26791 
 
26792 
 
26793 
  def __repr__(self):
26794 
    L = ['%s=%r' % (key, value)
26795 
      for key, value in self.__dict__.iteritems()]
26796 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26797 
 
26798 
  def __eq__(self, other):
26799 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26800 
 
26801 
  def __ne__(self, other):
26802 
    return not (self == other)
5553 rajveer 26803 
 
26804 
class getReceivePendingOrders_args:
26805 
  """
26806 
  Attributes:
26807 
   - storeId
26808 
  """
26809 
 
26810 
  thrift_spec = (
26811 
    None, # 0
26812 
    (1, TType.I64, 'storeId', None, None, ), # 1
26813 
  )
26814 
 
26815 
  def __init__(self, storeId=None,):
26816 
    self.storeId = storeId
26817 
 
26818 
  def read(self, iprot):
26819 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26820 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26821 
      return
26822 
    iprot.readStructBegin()
26823 
    while True:
26824 
      (fname, ftype, fid) = iprot.readFieldBegin()
26825 
      if ftype == TType.STOP:
26826 
        break
26827 
      if fid == 1:
26828 
        if ftype == TType.I64:
26829 
          self.storeId = iprot.readI64();
26830 
        else:
26831 
          iprot.skip(ftype)
26832 
      else:
26833 
        iprot.skip(ftype)
26834 
      iprot.readFieldEnd()
26835 
    iprot.readStructEnd()
26836 
 
26837 
  def write(self, oprot):
26838 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26839 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26840 
      return
26841 
    oprot.writeStructBegin('getReceivePendingOrders_args')
26842 
    if self.storeId is not None:
26843 
      oprot.writeFieldBegin('storeId', TType.I64, 1)
26844 
      oprot.writeI64(self.storeId)
26845 
      oprot.writeFieldEnd()
26846 
    oprot.writeFieldStop()
26847 
    oprot.writeStructEnd()
26848 
 
26849 
  def validate(self):
26850 
    return
26851 
 
26852 
 
26853 
  def __repr__(self):
26854 
    L = ['%s=%r' % (key, value)
26855 
      for key, value in self.__dict__.iteritems()]
26856 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26857 
 
26858 
  def __eq__(self, other):
26859 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26860 
 
26861 
  def __ne__(self, other):
26862 
    return not (self == other)
26863 
 
26864 
class getReceivePendingOrders_result:
26865 
  """
26866 
  Attributes:
26867 
   - success
26868 
  """
26869 
 
26870 
  thrift_spec = (
26871 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
26872 
  )
26873 
 
26874 
  def __init__(self, success=None,):
26875 
    self.success = success
26876 
 
26877 
  def read(self, iprot):
26878 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26879 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26880 
      return
26881 
    iprot.readStructBegin()
26882 
    while True:
26883 
      (fname, ftype, fid) = iprot.readFieldBegin()
26884 
      if ftype == TType.STOP:
26885 
        break
26886 
      if fid == 0:
26887 
        if ftype == TType.LIST:
26888 
          self.success = []
6188 rajveer 26889 
          (_etype638, _size635) = iprot.readListBegin()
26890 
          for _i639 in xrange(_size635):
26891 
            _elem640 = Order()
26892 
            _elem640.read(iprot)
26893 
            self.success.append(_elem640)
5553 rajveer 26894 
          iprot.readListEnd()
26895 
        else:
26896 
          iprot.skip(ftype)
26897 
      else:
26898 
        iprot.skip(ftype)
26899 
      iprot.readFieldEnd()
26900 
    iprot.readStructEnd()
26901 
 
26902 
  def write(self, oprot):
26903 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26904 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26905 
      return
26906 
    oprot.writeStructBegin('getReceivePendingOrders_result')
26907 
    if self.success is not None:
26908 
      oprot.writeFieldBegin('success', TType.LIST, 0)
26909 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 26910 
      for iter641 in self.success:
26911 
        iter641.write(oprot)
5553 rajveer 26912 
      oprot.writeListEnd()
26913 
      oprot.writeFieldEnd()
26914 
    oprot.writeFieldStop()
26915 
    oprot.writeStructEnd()
26916 
 
26917 
  def validate(self):
26918 
    return
26919 
 
26920 
 
26921 
  def __repr__(self):
26922 
    L = ['%s=%r' % (key, value)
26923 
      for key, value in self.__dict__.iteritems()]
26924 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26925 
 
26926 
  def __eq__(self, other):
26927 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26928 
 
26929 
  def __ne__(self, other):
26930 
    return not (self == other)
26931 
 
26932 
class getReceivedAtStoreOrders_args:
26933 
  """
26934 
  Attributes:
26935 
   - storeId
26936 
  """
26937 
 
26938 
  thrift_spec = (
26939 
    None, # 0
26940 
    (1, TType.I64, 'storeId', None, None, ), # 1
26941 
  )
26942 
 
26943 
  def __init__(self, storeId=None,):
26944 
    self.storeId = storeId
26945 
 
26946 
  def read(self, iprot):
26947 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26948 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26949 
      return
26950 
    iprot.readStructBegin()
26951 
    while True:
26952 
      (fname, ftype, fid) = iprot.readFieldBegin()
26953 
      if ftype == TType.STOP:
26954 
        break
26955 
      if fid == 1:
26956 
        if ftype == TType.I64:
26957 
          self.storeId = iprot.readI64();
26958 
        else:
26959 
          iprot.skip(ftype)
26960 
      else:
26961 
        iprot.skip(ftype)
26962 
      iprot.readFieldEnd()
26963 
    iprot.readStructEnd()
26964 
 
26965 
  def write(self, oprot):
26966 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26967 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26968 
      return
26969 
    oprot.writeStructBegin('getReceivedAtStoreOrders_args')
26970 
    if self.storeId is not None:
26971 
      oprot.writeFieldBegin('storeId', TType.I64, 1)
26972 
      oprot.writeI64(self.storeId)
26973 
      oprot.writeFieldEnd()
26974 
    oprot.writeFieldStop()
26975 
    oprot.writeStructEnd()
26976 
 
26977 
  def validate(self):
26978 
    return
26979 
 
26980 
 
26981 
  def __repr__(self):
26982 
    L = ['%s=%r' % (key, value)
26983 
      for key, value in self.__dict__.iteritems()]
26984 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26985 
 
26986 
  def __eq__(self, other):
26987 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26988 
 
26989 
  def __ne__(self, other):
26990 
    return not (self == other)
26991 
 
26992 
class getReceivedAtStoreOrders_result:
26993 
  """
26994 
  Attributes:
26995 
   - success
26996 
  """
26997 
 
26998 
  thrift_spec = (
26999 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
27000 
  )
27001 
 
27002 
  def __init__(self, success=None,):
27003 
    self.success = success
27004 
 
27005 
  def read(self, iprot):
27006 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27007 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27008 
      return
27009 
    iprot.readStructBegin()
27010 
    while True:
27011 
      (fname, ftype, fid) = iprot.readFieldBegin()
27012 
      if ftype == TType.STOP:
27013 
        break
27014 
      if fid == 0:
27015 
        if ftype == TType.LIST:
27016 
          self.success = []
6188 rajveer 27017 
          (_etype645, _size642) = iprot.readListBegin()
27018 
          for _i646 in xrange(_size642):
27019 
            _elem647 = Order()
27020 
            _elem647.read(iprot)
27021 
            self.success.append(_elem647)
5553 rajveer 27022 
          iprot.readListEnd()
27023 
        else:
27024 
          iprot.skip(ftype)
27025 
      else:
27026 
        iprot.skip(ftype)
27027 
      iprot.readFieldEnd()
27028 
    iprot.readStructEnd()
27029 
 
27030 
  def write(self, oprot):
27031 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27032 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27033 
      return
27034 
    oprot.writeStructBegin('getReceivedAtStoreOrders_result')
27035 
    if self.success is not None:
27036 
      oprot.writeFieldBegin('success', TType.LIST, 0)
27037 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 27038 
      for iter648 in self.success:
27039 
        iter648.write(oprot)
5553 rajveer 27040 
      oprot.writeListEnd()
27041 
      oprot.writeFieldEnd()
27042 
    oprot.writeFieldStop()
27043 
    oprot.writeStructEnd()
27044 
 
27045 
  def validate(self):
27046 
    return
27047 
 
27048 
 
27049 
  def __repr__(self):
27050 
    L = ['%s=%r' % (key, value)
27051 
      for key, value in self.__dict__.iteritems()]
27052 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27053 
 
27054 
  def __eq__(self, other):
27055 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27056 
 
27057 
  def __ne__(self, other):
27058 
    return not (self == other)
5593 mandeep.dh 27059 
 
5713 rajveer 27060 
class getOrdersCollectionAtStore_args:
27061 
  """
27062 
  Attributes:
27063 
   - storeId
27064 
   - fromDate
27065 
   - toDate
27066 
   - onlyCod
27067 
  """
27068 
 
27069 
  thrift_spec = (
27070 
    None, # 0
27071 
    (1, TType.I64, 'storeId', None, None, ), # 1
27072 
    (2, TType.I64, 'fromDate', None, None, ), # 2
27073 
    (3, TType.I64, 'toDate', None, None, ), # 3
27074 
    (4, TType.BOOL, 'onlyCod', None, None, ), # 4
27075 
  )
27076 
 
27077 
  def __init__(self, storeId=None, fromDate=None, toDate=None, onlyCod=None,):
27078 
    self.storeId = storeId
27079 
    self.fromDate = fromDate
27080 
    self.toDate = toDate
27081 
    self.onlyCod = onlyCod
27082 
 
27083 
  def read(self, iprot):
27084 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27085 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27086 
      return
27087 
    iprot.readStructBegin()
27088 
    while True:
27089 
      (fname, ftype, fid) = iprot.readFieldBegin()
27090 
      if ftype == TType.STOP:
27091 
        break
27092 
      if fid == 1:
27093 
        if ftype == TType.I64:
27094 
          self.storeId = iprot.readI64();
27095 
        else:
27096 
          iprot.skip(ftype)
27097 
      elif fid == 2:
27098 
        if ftype == TType.I64:
27099 
          self.fromDate = iprot.readI64();
27100 
        else:
27101 
          iprot.skip(ftype)
27102 
      elif fid == 3:
27103 
        if ftype == TType.I64:
27104 
          self.toDate = iprot.readI64();
27105 
        else:
27106 
          iprot.skip(ftype)
27107 
      elif fid == 4:
27108 
        if ftype == TType.BOOL:
27109 
          self.onlyCod = iprot.readBool();
27110 
        else:
27111 
          iprot.skip(ftype)
27112 
      else:
27113 
        iprot.skip(ftype)
27114 
      iprot.readFieldEnd()
27115 
    iprot.readStructEnd()
27116 
 
27117 
  def write(self, oprot):
27118 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27119 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27120 
      return
27121 
    oprot.writeStructBegin('getOrdersCollectionAtStore_args')
27122 
    if self.storeId is not None:
27123 
      oprot.writeFieldBegin('storeId', TType.I64, 1)
27124 
      oprot.writeI64(self.storeId)
27125 
      oprot.writeFieldEnd()
27126 
    if self.fromDate is not None:
27127 
      oprot.writeFieldBegin('fromDate', TType.I64, 2)
27128 
      oprot.writeI64(self.fromDate)
27129 
      oprot.writeFieldEnd()
27130 
    if self.toDate is not None:
27131 
      oprot.writeFieldBegin('toDate', TType.I64, 3)
27132 
      oprot.writeI64(self.toDate)
27133 
      oprot.writeFieldEnd()
27134 
    if self.onlyCod is not None:
27135 
      oprot.writeFieldBegin('onlyCod', TType.BOOL, 4)
27136 
      oprot.writeBool(self.onlyCod)
27137 
      oprot.writeFieldEnd()
27138 
    oprot.writeFieldStop()
27139 
    oprot.writeStructEnd()
27140 
 
27141 
  def validate(self):
27142 
    return
27143 
 
27144 
 
27145 
  def __repr__(self):
27146 
    L = ['%s=%r' % (key, value)
27147 
      for key, value in self.__dict__.iteritems()]
27148 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27149 
 
27150 
  def __eq__(self, other):
27151 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27152 
 
27153 
  def __ne__(self, other):
27154 
    return not (self == other)
27155 
 
27156 
class getOrdersCollectionAtStore_result:
27157 
  """
27158 
  Attributes:
27159 
   - success
27160 
  """
27161 
 
27162 
  thrift_spec = (
27163 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
27164 
  )
27165 
 
27166 
  def __init__(self, success=None,):
27167 
    self.success = success
27168 
 
27169 
  def read(self, iprot):
27170 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27171 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27172 
      return
27173 
    iprot.readStructBegin()
27174 
    while True:
27175 
      (fname, ftype, fid) = iprot.readFieldBegin()
27176 
      if ftype == TType.STOP:
27177 
        break
27178 
      if fid == 0:
27179 
        if ftype == TType.LIST:
27180 
          self.success = []
6188 rajveer 27181 
          (_etype652, _size649) = iprot.readListBegin()
27182 
          for _i653 in xrange(_size649):
27183 
            _elem654 = Order()
27184 
            _elem654.read(iprot)
27185 
            self.success.append(_elem654)
5713 rajveer 27186 
          iprot.readListEnd()
27187 
        else:
27188 
          iprot.skip(ftype)
27189 
      else:
27190 
        iprot.skip(ftype)
27191 
      iprot.readFieldEnd()
27192 
    iprot.readStructEnd()
27193 
 
27194 
  def write(self, oprot):
27195 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27196 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27197 
      return
27198 
    oprot.writeStructBegin('getOrdersCollectionAtStore_result')
27199 
    if self.success is not None:
27200 
      oprot.writeFieldBegin('success', TType.LIST, 0)
27201 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 27202 
      for iter655 in self.success:
27203 
        iter655.write(oprot)
5713 rajveer 27204 
      oprot.writeListEnd()
27205 
      oprot.writeFieldEnd()
27206 
    oprot.writeFieldStop()
27207 
    oprot.writeStructEnd()
27208 
 
27209 
  def validate(self):
27210 
    return
27211 
 
27212 
 
27213 
  def __repr__(self):
27214 
    L = ['%s=%r' % (key, value)
27215 
      for key, value in self.__dict__.iteritems()]
27216 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27217 
 
27218 
  def __eq__(self, other):
27219 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27220 
 
27221 
  def __ne__(self, other):
27222 
    return not (self == other)
27223 
 
5833 rajveer 27224 
class getOrderAttributeValue_args:
27225 
  """
27226 
  Attributes:
27227 
   - orderId
27228 
   - attributeName
27229 
  """
27230 
 
27231 
  thrift_spec = None
27232 
  def __init__(self, orderId=None, attributeName=None,):
27233 
    self.orderId = orderId
27234 
    self.attributeName = attributeName
27235 
 
27236 
  def read(self, iprot):
27237 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27238 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27239 
      return
27240 
    iprot.readStructBegin()
27241 
    while True:
27242 
      (fname, ftype, fid) = iprot.readFieldBegin()
27243 
      if ftype == TType.STOP:
27244 
        break
27245 
      if fid == 1:
27246 
        if ftype == TType.I64:
27247 
          self.orderId = iprot.readI64();
27248 
        else:
27249 
          iprot.skip(ftype)
27250 
      elif fid == -1:
27251 
        if ftype == TType.STRING:
27252 
          self.attributeName = iprot.readString();
27253 
        else:
27254 
          iprot.skip(ftype)
27255 
      else:
27256 
        iprot.skip(ftype)
27257 
      iprot.readFieldEnd()
27258 
    iprot.readStructEnd()
27259 
 
27260 
  def write(self, oprot):
27261 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27262 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27263 
      return
27264 
    oprot.writeStructBegin('getOrderAttributeValue_args')
27265 
    if self.attributeName is not None:
27266 
      oprot.writeFieldBegin('attributeName', TType.STRING, -1)
27267 
      oprot.writeString(self.attributeName)
27268 
      oprot.writeFieldEnd()
27269 
    if self.orderId is not None:
27270 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
27271 
      oprot.writeI64(self.orderId)
27272 
      oprot.writeFieldEnd()
27273 
    oprot.writeFieldStop()
27274 
    oprot.writeStructEnd()
27275 
 
27276 
  def validate(self):
27277 
    return
27278 
 
27279 
 
27280 
  def __repr__(self):
27281 
    L = ['%s=%r' % (key, value)
27282 
      for key, value in self.__dict__.iteritems()]
27283 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27284 
 
27285 
  def __eq__(self, other):
27286 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27287 
 
27288 
  def __ne__(self, other):
27289 
    return not (self == other)
27290 
 
27291 
class getOrderAttributeValue_result:
27292 
  """
27293 
  Attributes:
27294 
   - success
27295 
  """
27296 
 
27297 
  thrift_spec = (
27298 
    (0, TType.STRING, 'success', None, None, ), # 0
27299 
  )
27300 
 
27301 
  def __init__(self, success=None,):
27302 
    self.success = success
27303 
 
27304 
  def read(self, iprot):
27305 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27306 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27307 
      return
27308 
    iprot.readStructBegin()
27309 
    while True:
27310 
      (fname, ftype, fid) = iprot.readFieldBegin()
27311 
      if ftype == TType.STOP:
27312 
        break
27313 
      if fid == 0:
27314 
        if ftype == TType.STRING:
27315 
          self.success = iprot.readString();
27316 
        else:
27317 
          iprot.skip(ftype)
27318 
      else:
27319 
        iprot.skip(ftype)
27320 
      iprot.readFieldEnd()
27321 
    iprot.readStructEnd()
27322 
 
27323 
  def write(self, oprot):
27324 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27325 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27326 
      return
27327 
    oprot.writeStructBegin('getOrderAttributeValue_result')
27328 
    if self.success is not None:
27329 
      oprot.writeFieldBegin('success', TType.STRING, 0)
27330 
      oprot.writeString(self.success)
27331 
      oprot.writeFieldEnd()
27332 
    oprot.writeFieldStop()
27333 
    oprot.writeStructEnd()
27334 
 
27335 
  def validate(self):
27336 
    return
27337 
 
27338 
 
27339 
  def __repr__(self):
27340 
    L = ['%s=%r' % (key, value)
27341 
      for key, value in self.__dict__.iteritems()]
27342 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27343 
 
27344 
  def __eq__(self, other):
27345 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27346 
 
27347 
  def __ne__(self, other):
27348 
    return not (self == other)
27349 
 
6019 rajveer 27350 
class changeJacketNumber_args:
27351 
  """
27352 
  Attributes:
27353 
   - orderId
27354 
   - jacketNumber
27355 
  """
27356 
 
27357 
  thrift_spec = (
27358 
    None, # 0
27359 
    (1, TType.I64, 'orderId', None, None, ), # 1
27360 
    (2, TType.I64, 'jacketNumber', None, None, ), # 2
27361 
  )
27362 
 
27363 
  def __init__(self, orderId=None, jacketNumber=None,):
27364 
    self.orderId = orderId
27365 
    self.jacketNumber = jacketNumber
27366 
 
27367 
  def read(self, iprot):
27368 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27369 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27370 
      return
27371 
    iprot.readStructBegin()
27372 
    while True:
27373 
      (fname, ftype, fid) = iprot.readFieldBegin()
27374 
      if ftype == TType.STOP:
27375 
        break
27376 
      if fid == 1:
27377 
        if ftype == TType.I64:
27378 
          self.orderId = iprot.readI64();
27379 
        else:
27380 
          iprot.skip(ftype)
27381 
      elif fid == 2:
27382 
        if ftype == TType.I64:
27383 
          self.jacketNumber = iprot.readI64();
27384 
        else:
27385 
          iprot.skip(ftype)
27386 
      else:
27387 
        iprot.skip(ftype)
27388 
      iprot.readFieldEnd()
27389 
    iprot.readStructEnd()
27390 
 
27391 
  def write(self, oprot):
27392 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27393 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27394 
      return
27395 
    oprot.writeStructBegin('changeJacketNumber_args')
27396 
    if self.orderId is not None:
27397 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
27398 
      oprot.writeI64(self.orderId)
27399 
      oprot.writeFieldEnd()
27400 
    if self.jacketNumber is not None:
27401 
      oprot.writeFieldBegin('jacketNumber', TType.I64, 2)
27402 
      oprot.writeI64(self.jacketNumber)
27403 
      oprot.writeFieldEnd()
27404 
    oprot.writeFieldStop()
27405 
    oprot.writeStructEnd()
27406 
 
27407 
  def validate(self):
27408 
    return
27409 
 
27410 
 
27411 
  def __repr__(self):
27412 
    L = ['%s=%r' % (key, value)
27413 
      for key, value in self.__dict__.iteritems()]
27414 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27415 
 
27416 
  def __eq__(self, other):
27417 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27418 
 
27419 
  def __ne__(self, other):
27420 
    return not (self == other)
27421 
 
27422 
class changeJacketNumber_result:
27423 
  """
27424 
  Attributes:
27425 
   - success
27426 
  """
27427 
 
27428 
  thrift_spec = (
27429 
    (0, TType.BOOL, 'success', None, None, ), # 0
27430 
  )
27431 
 
27432 
  def __init__(self, success=None,):
27433 
    self.success = success
27434 
 
27435 
  def read(self, iprot):
27436 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27437 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27438 
      return
27439 
    iprot.readStructBegin()
27440 
    while True:
27441 
      (fname, ftype, fid) = iprot.readFieldBegin()
27442 
      if ftype == TType.STOP:
27443 
        break
27444 
      if fid == 0:
27445 
        if ftype == TType.BOOL:
27446 
          self.success = iprot.readBool();
27447 
        else:
27448 
          iprot.skip(ftype)
27449 
      else:
27450 
        iprot.skip(ftype)
27451 
      iprot.readFieldEnd()
27452 
    iprot.readStructEnd()
27453 
 
27454 
  def write(self, oprot):
27455 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27456 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27457 
      return
27458 
    oprot.writeStructBegin('changeJacketNumber_result')
27459 
    if self.success is not None:
27460 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
27461 
      oprot.writeBool(self.success)
27462 
      oprot.writeFieldEnd()
27463 
    oprot.writeFieldStop()
27464 
    oprot.writeStructEnd()
27465 
 
27466 
  def validate(self):
27467 
    return
27468 
 
27469 
 
27470 
  def __repr__(self):
27471 
    L = ['%s=%r' % (key, value)
27472 
      for key, value in self.__dict__.iteritems()]
27473 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27474 
 
27475 
  def __eq__(self, other):
27476 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27477 
 
27478 
  def __ne__(self, other):
27479 
    return not (self == other)
27480 
 
27481 
class markOrderAsRtoInTransit_args:
27482 
  """
27483 
  Attributes:
27484 
   - orderId
27485 
  """
27486 
 
27487 
  thrift_spec = (
27488 
    None, # 0
27489 
    (1, TType.I64, 'orderId', None, None, ), # 1
27490 
  )
27491 
 
27492 
  def __init__(self, orderId=None,):
27493 
    self.orderId = orderId
27494 
 
27495 
  def read(self, iprot):
27496 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27497 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27498 
      return
27499 
    iprot.readStructBegin()
27500 
    while True:
27501 
      (fname, ftype, fid) = iprot.readFieldBegin()
27502 
      if ftype == TType.STOP:
27503 
        break
27504 
      if fid == 1:
27505 
        if ftype == TType.I64:
27506 
          self.orderId = iprot.readI64();
27507 
        else:
27508 
          iprot.skip(ftype)
27509 
      else:
27510 
        iprot.skip(ftype)
27511 
      iprot.readFieldEnd()
27512 
    iprot.readStructEnd()
27513 
 
27514 
  def write(self, oprot):
27515 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27516 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27517 
      return
27518 
    oprot.writeStructBegin('markOrderAsRtoInTransit_args')
27519 
    if self.orderId is not None:
27520 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
27521 
      oprot.writeI64(self.orderId)
27522 
      oprot.writeFieldEnd()
27523 
    oprot.writeFieldStop()
27524 
    oprot.writeStructEnd()
27525 
 
27526 
  def validate(self):
27527 
    return
27528 
 
27529 
 
27530 
  def __repr__(self):
27531 
    L = ['%s=%r' % (key, value)
27532 
      for key, value in self.__dict__.iteritems()]
27533 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27534 
 
27535 
  def __eq__(self, other):
27536 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27537 
 
27538 
  def __ne__(self, other):
27539 
    return not (self == other)
27540 
 
27541 
class markOrderAsRtoInTransit_result:
27542 
  """
27543 
  Attributes:
27544 
   - success
27545 
  """
27546 
 
27547 
  thrift_spec = (
27548 
    (0, TType.BOOL, 'success', None, None, ), # 0
27549 
  )
27550 
 
27551 
  def __init__(self, success=None,):
27552 
    self.success = success
27553 
 
27554 
  def read(self, iprot):
27555 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27556 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27557 
      return
27558 
    iprot.readStructBegin()
27559 
    while True:
27560 
      (fname, ftype, fid) = iprot.readFieldBegin()
27561 
      if ftype == TType.STOP:
27562 
        break
27563 
      if fid == 0:
27564 
        if ftype == TType.BOOL:
27565 
          self.success = iprot.readBool();
27566 
        else:
27567 
          iprot.skip(ftype)
27568 
      else:
27569 
        iprot.skip(ftype)
27570 
      iprot.readFieldEnd()
27571 
    iprot.readStructEnd()
27572 
 
27573 
  def write(self, oprot):
27574 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27575 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27576 
      return
27577 
    oprot.writeStructBegin('markOrderAsRtoInTransit_result')
27578 
    if self.success is not None:
27579 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
27580 
      oprot.writeBool(self.success)
27581 
      oprot.writeFieldEnd()
27582 
    oprot.writeFieldStop()
27583 
    oprot.writeStructEnd()
27584 
 
27585 
  def validate(self):
27586 
    return
27587 
 
27588 
 
27589 
  def __repr__(self):
27590 
    L = ['%s=%r' % (key, value)
27591 
      for key, value in self.__dict__.iteritems()]
27592 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27593 
 
27594 
  def __eq__(self, other):
27595 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27596 
 
27597 
  def __ne__(self, other):
27598 
    return not (self == other)
27599 
 
5593 mandeep.dh 27600 
class acceptOrderForItem_args:
27601 
  """
27602 
  Attributes:
27603 
   - itemId
27604 
   - quantity
27605 
   - fulfilmentWarehouseId
27606 
   - billingWarehouseId
27607 
  """
27608 
 
27609 
  thrift_spec = (
27610 
    None, # 0
27611 
    (1, TType.I64, 'itemId', None, None, ), # 1
27612 
    (2, TType.I64, 'quantity', None, None, ), # 2
27613 
    (3, TType.I64, 'fulfilmentWarehouseId', None, None, ), # 3
27614 
    (4, TType.I64, 'billingWarehouseId', None, None, ), # 4
27615 
  )
27616 
 
27617 
  def __init__(self, itemId=None, quantity=None, fulfilmentWarehouseId=None, billingWarehouseId=None,):
27618 
    self.itemId = itemId
27619 
    self.quantity = quantity
27620 
    self.fulfilmentWarehouseId = fulfilmentWarehouseId
27621 
    self.billingWarehouseId = billingWarehouseId
27622 
 
27623 
  def read(self, iprot):
27624 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27625 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27626 
      return
27627 
    iprot.readStructBegin()
27628 
    while True:
27629 
      (fname, ftype, fid) = iprot.readFieldBegin()
27630 
      if ftype == TType.STOP:
27631 
        break
27632 
      if fid == 1:
27633 
        if ftype == TType.I64:
27634 
          self.itemId = iprot.readI64();
27635 
        else:
27636 
          iprot.skip(ftype)
27637 
      elif fid == 2:
27638 
        if ftype == TType.I64:
27639 
          self.quantity = iprot.readI64();
27640 
        else:
27641 
          iprot.skip(ftype)
27642 
      elif fid == 3:
27643 
        if ftype == TType.I64:
27644 
          self.fulfilmentWarehouseId = iprot.readI64();
27645 
        else:
27646 
          iprot.skip(ftype)
27647 
      elif fid == 4:
27648 
        if ftype == TType.I64:
27649 
          self.billingWarehouseId = iprot.readI64();
27650 
        else:
27651 
          iprot.skip(ftype)
27652 
      else:
27653 
        iprot.skip(ftype)
27654 
      iprot.readFieldEnd()
27655 
    iprot.readStructEnd()
27656 
 
27657 
  def write(self, oprot):
27658 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27659 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27660 
      return
27661 
    oprot.writeStructBegin('acceptOrderForItem_args')
27662 
    if self.itemId is not None:
27663 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
27664 
      oprot.writeI64(self.itemId)
27665 
      oprot.writeFieldEnd()
27666 
    if self.quantity is not None:
27667 
      oprot.writeFieldBegin('quantity', TType.I64, 2)
27668 
      oprot.writeI64(self.quantity)
27669 
      oprot.writeFieldEnd()
27670 
    if self.fulfilmentWarehouseId is not None:
27671 
      oprot.writeFieldBegin('fulfilmentWarehouseId', TType.I64, 3)
27672 
      oprot.writeI64(self.fulfilmentWarehouseId)
27673 
      oprot.writeFieldEnd()
27674 
    if self.billingWarehouseId is not None:
27675 
      oprot.writeFieldBegin('billingWarehouseId', TType.I64, 4)
27676 
      oprot.writeI64(self.billingWarehouseId)
27677 
      oprot.writeFieldEnd()
27678 
    oprot.writeFieldStop()
27679 
    oprot.writeStructEnd()
27680 
 
27681 
  def validate(self):
27682 
    return
27683 
 
27684 
 
27685 
  def __repr__(self):
27686 
    L = ['%s=%r' % (key, value)
27687 
      for key, value in self.__dict__.iteritems()]
27688 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27689 
 
27690 
  def __eq__(self, other):
27691 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27692 
 
27693 
  def __ne__(self, other):
27694 
    return not (self == other)
27695 
 
27696 
class acceptOrderForItem_result:
27697 
 
27698 
  thrift_spec = (
27699 
  )
27700 
 
27701 
  def read(self, iprot):
27702 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27703 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27704 
      return
27705 
    iprot.readStructBegin()
27706 
    while True:
27707 
      (fname, ftype, fid) = iprot.readFieldBegin()
27708 
      if ftype == TType.STOP:
27709 
        break
27710 
      else:
27711 
        iprot.skip(ftype)
27712 
      iprot.readFieldEnd()
27713 
    iprot.readStructEnd()
27714 
 
27715 
  def write(self, oprot):
27716 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27717 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27718 
      return
27719 
    oprot.writeStructBegin('acceptOrderForItem_result')
27720 
    oprot.writeFieldStop()
27721 
    oprot.writeStructEnd()
27722 
 
27723 
  def validate(self):
27724 
    return
27725 
 
27726 
 
27727 
  def __repr__(self):
27728 
    L = ['%s=%r' % (key, value)
27729 
      for key, value in self.__dict__.iteritems()]
27730 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27731 
 
27732 
  def __eq__(self, other):
27733 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27734 
 
27735 
  def __ne__(self, other):
27736 
    return not (self == other)
6000 mandeep.dh 27737 
 
27738 
class createRechargeOrder_args:
27739 
  """
27740 
  Attributes:
27741 
   - rechargeOrder
27742 
  """
27743 
 
27744 
  thrift_spec = (
27745 
    None, # 0
27746 
    (1, TType.STRUCT, 'rechargeOrder', (RechargeOrder, RechargeOrder.thrift_spec), None, ), # 1
27747 
  )
27748 
 
27749 
  def __init__(self, rechargeOrder=None,):
27750 
    self.rechargeOrder = rechargeOrder
27751 
 
27752 
  def read(self, iprot):
27753 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27754 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27755 
      return
27756 
    iprot.readStructBegin()
27757 
    while True:
27758 
      (fname, ftype, fid) = iprot.readFieldBegin()
27759 
      if ftype == TType.STOP:
27760 
        break
27761 
      if fid == 1:
27762 
        if ftype == TType.STRUCT:
27763 
          self.rechargeOrder = RechargeOrder()
27764 
          self.rechargeOrder.read(iprot)
27765 
        else:
27766 
          iprot.skip(ftype)
27767 
      else:
27768 
        iprot.skip(ftype)
27769 
      iprot.readFieldEnd()
27770 
    iprot.readStructEnd()
27771 
 
27772 
  def write(self, oprot):
27773 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27774 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27775 
      return
27776 
    oprot.writeStructBegin('createRechargeOrder_args')
27777 
    if self.rechargeOrder is not None:
27778 
      oprot.writeFieldBegin('rechargeOrder', TType.STRUCT, 1)
27779 
      self.rechargeOrder.write(oprot)
27780 
      oprot.writeFieldEnd()
27781 
    oprot.writeFieldStop()
27782 
    oprot.writeStructEnd()
27783 
 
27784 
  def validate(self):
27785 
    return
27786 
 
27787 
 
27788 
  def __repr__(self):
27789 
    L = ['%s=%r' % (key, value)
27790 
      for key, value in self.__dict__.iteritems()]
27791 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27792 
 
27793 
  def __eq__(self, other):
27794 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27795 
 
27796 
  def __ne__(self, other):
27797 
    return not (self == other)
27798 
 
27799 
class createRechargeOrder_result:
27800 
  """
27801 
  Attributes:
27802 
   - success
27803 
   - ex
27804 
  """
27805 
 
27806 
  thrift_spec = (
27807 
    (0, TType.STRUCT, 'success', (RechargeOrder, RechargeOrder.thrift_spec), None, ), # 0
27808 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
27809 
  )
27810 
 
27811 
  def __init__(self, success=None, ex=None,):
27812 
    self.success = success
27813 
    self.ex = ex
27814 
 
27815 
  def read(self, iprot):
27816 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27817 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27818 
      return
27819 
    iprot.readStructBegin()
27820 
    while True:
27821 
      (fname, ftype, fid) = iprot.readFieldBegin()
27822 
      if ftype == TType.STOP:
27823 
        break
27824 
      if fid == 0:
27825 
        if ftype == TType.STRUCT:
27826 
          self.success = RechargeOrder()
27827 
          self.success.read(iprot)
27828 
        else:
27829 
          iprot.skip(ftype)
27830 
      elif fid == 1:
27831 
        if ftype == TType.STRUCT:
27832 
          self.ex = TransactionServiceException()
27833 
          self.ex.read(iprot)
27834 
        else:
27835 
          iprot.skip(ftype)
27836 
      else:
27837 
        iprot.skip(ftype)
27838 
      iprot.readFieldEnd()
27839 
    iprot.readStructEnd()
27840 
 
27841 
  def write(self, oprot):
27842 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27843 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27844 
      return
27845 
    oprot.writeStructBegin('createRechargeOrder_result')
27846 
    if self.success is not None:
27847 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
27848 
      self.success.write(oprot)
27849 
      oprot.writeFieldEnd()
27850 
    if self.ex is not None:
27851 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
27852 
      self.ex.write(oprot)
27853 
      oprot.writeFieldEnd()
27854 
    oprot.writeFieldStop()
27855 
    oprot.writeStructEnd()
27856 
 
27857 
  def validate(self):
27858 
    return
27859 
 
27860 
 
27861 
  def __repr__(self):
27862 
    L = ['%s=%r' % (key, value)
27863 
      for key, value in self.__dict__.iteritems()]
27864 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27865 
 
27866 
  def __eq__(self, other):
27867 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27868 
 
27869 
  def __ne__(self, other):
27870 
    return not (self == other)
27871 
 
6031 rajveer 27872 
class getRechargeOrder_args:
27873 
  """
27874 
  Attributes:
27875 
   - rechargeRrderId
27876 
  """
27877 
 
27878 
  thrift_spec = (
27879 
    None, # 0
27880 
    (1, TType.I64, 'rechargeRrderId', None, None, ), # 1
27881 
  )
27882 
 
27883 
  def __init__(self, rechargeRrderId=None,):
27884 
    self.rechargeRrderId = rechargeRrderId
27885 
 
27886 
  def read(self, iprot):
27887 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27888 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27889 
      return
27890 
    iprot.readStructBegin()
27891 
    while True:
27892 
      (fname, ftype, fid) = iprot.readFieldBegin()
27893 
      if ftype == TType.STOP:
27894 
        break
27895 
      if fid == 1:
27896 
        if ftype == TType.I64:
27897 
          self.rechargeRrderId = iprot.readI64();
27898 
        else:
27899 
          iprot.skip(ftype)
27900 
      else:
27901 
        iprot.skip(ftype)
27902 
      iprot.readFieldEnd()
27903 
    iprot.readStructEnd()
27904 
 
27905 
  def write(self, oprot):
27906 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27907 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27908 
      return
27909 
    oprot.writeStructBegin('getRechargeOrder_args')
27910 
    if self.rechargeRrderId is not None:
27911 
      oprot.writeFieldBegin('rechargeRrderId', TType.I64, 1)
27912 
      oprot.writeI64(self.rechargeRrderId)
27913 
      oprot.writeFieldEnd()
27914 
    oprot.writeFieldStop()
27915 
    oprot.writeStructEnd()
27916 
 
27917 
  def validate(self):
27918 
    return
27919 
 
27920 
 
27921 
  def __repr__(self):
27922 
    L = ['%s=%r' % (key, value)
27923 
      for key, value in self.__dict__.iteritems()]
27924 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27925 
 
27926 
  def __eq__(self, other):
27927 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27928 
 
27929 
  def __ne__(self, other):
27930 
    return not (self == other)
27931 
 
27932 
class getRechargeOrder_result:
27933 
  """
27934 
  Attributes:
27935 
   - success
27936 
   - ex
27937 
  """
27938 
 
27939 
  thrift_spec = (
27940 
    (0, TType.STRUCT, 'success', (RechargeOrder, RechargeOrder.thrift_spec), None, ), # 0
27941 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
27942 
  )
27943 
 
27944 
  def __init__(self, success=None, ex=None,):
27945 
    self.success = success
27946 
    self.ex = ex
27947 
 
27948 
  def read(self, iprot):
27949 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27950 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27951 
      return
27952 
    iprot.readStructBegin()
27953 
    while True:
27954 
      (fname, ftype, fid) = iprot.readFieldBegin()
27955 
      if ftype == TType.STOP:
27956 
        break
27957 
      if fid == 0:
27958 
        if ftype == TType.STRUCT:
27959 
          self.success = RechargeOrder()
27960 
          self.success.read(iprot)
27961 
        else:
27962 
          iprot.skip(ftype)
27963 
      elif fid == 1:
27964 
        if ftype == TType.STRUCT:
27965 
          self.ex = TransactionServiceException()
27966 
          self.ex.read(iprot)
27967 
        else:
27968 
          iprot.skip(ftype)
27969 
      else:
27970 
        iprot.skip(ftype)
27971 
      iprot.readFieldEnd()
27972 
    iprot.readStructEnd()
27973 
 
27974 
  def write(self, oprot):
27975 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27976 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27977 
      return
27978 
    oprot.writeStructBegin('getRechargeOrder_result')
27979 
    if self.success is not None:
27980 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
27981 
      self.success.write(oprot)
27982 
      oprot.writeFieldEnd()
27983 
    if self.ex is not None:
27984 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
27985 
      self.ex.write(oprot)
27986 
      oprot.writeFieldEnd()
27987 
    oprot.writeFieldStop()
27988 
    oprot.writeStructEnd()
27989 
 
27990 
  def validate(self):
27991 
    return
27992 
 
27993 
 
27994 
  def __repr__(self):
27995 
    L = ['%s=%r' % (key, value)
27996 
      for key, value in self.__dict__.iteritems()]
27997 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27998 
 
27999 
  def __eq__(self, other):
28000 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28001 
 
28002 
  def __ne__(self, other):
28003 
    return not (self == other)
28004 
 
28005 
class getRechargeOrders_args:
28006 
  """
28007 
  Attributes:
28008 
   - userId
28009 
  """
28010 
 
28011 
  thrift_spec = (
28012 
    None, # 0
28013 
    (1, TType.I64, 'userId', None, None, ), # 1
28014 
  )
28015 
 
28016 
  def __init__(self, userId=None,):
28017 
    self.userId = userId
28018 
 
28019 
  def read(self, iprot):
28020 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28021 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28022 
      return
28023 
    iprot.readStructBegin()
28024 
    while True:
28025 
      (fname, ftype, fid) = iprot.readFieldBegin()
28026 
      if ftype == TType.STOP:
28027 
        break
28028 
      if fid == 1:
28029 
        if ftype == TType.I64:
28030 
          self.userId = iprot.readI64();
28031 
        else:
28032 
          iprot.skip(ftype)
28033 
      else:
28034 
        iprot.skip(ftype)
28035 
      iprot.readFieldEnd()
28036 
    iprot.readStructEnd()
28037 
 
28038 
  def write(self, oprot):
28039 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28040 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28041 
      return
28042 
    oprot.writeStructBegin('getRechargeOrders_args')
28043 
    if self.userId is not None:
28044 
      oprot.writeFieldBegin('userId', TType.I64, 1)
28045 
      oprot.writeI64(self.userId)
28046 
      oprot.writeFieldEnd()
28047 
    oprot.writeFieldStop()
28048 
    oprot.writeStructEnd()
28049 
 
28050 
  def validate(self):
28051 
    return
28052 
 
28053 
 
28054 
  def __repr__(self):
28055 
    L = ['%s=%r' % (key, value)
28056 
      for key, value in self.__dict__.iteritems()]
28057 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28058 
 
28059 
  def __eq__(self, other):
28060 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28061 
 
28062 
  def __ne__(self, other):
28063 
    return not (self == other)
28064 
 
28065 
class getRechargeOrders_result:
28066 
  """
28067 
  Attributes:
28068 
   - success
28069 
  """
28070 
 
28071 
  thrift_spec = (
28072 
    (0, TType.LIST, 'success', (TType.STRUCT,(RechargeOrder, RechargeOrder.thrift_spec)), None, ), # 0
28073 
  )
28074 
 
28075 
  def __init__(self, success=None,):
28076 
    self.success = success
28077 
 
28078 
  def read(self, iprot):
28079 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28080 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28081 
      return
28082 
    iprot.readStructBegin()
28083 
    while True:
28084 
      (fname, ftype, fid) = iprot.readFieldBegin()
28085 
      if ftype == TType.STOP:
28086 
        break
28087 
      if fid == 0:
28088 
        if ftype == TType.LIST:
28089 
          self.success = []
6188 rajveer 28090 
          (_etype659, _size656) = iprot.readListBegin()
28091 
          for _i660 in xrange(_size656):
28092 
            _elem661 = RechargeOrder()
28093 
            _elem661.read(iprot)
28094 
            self.success.append(_elem661)
6031 rajveer 28095 
          iprot.readListEnd()
28096 
        else:
28097 
          iprot.skip(ftype)
28098 
      else:
28099 
        iprot.skip(ftype)
28100 
      iprot.readFieldEnd()
28101 
    iprot.readStructEnd()
28102 
 
28103 
  def write(self, oprot):
28104 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28105 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28106 
      return
28107 
    oprot.writeStructBegin('getRechargeOrders_result')
28108 
    if self.success is not None:
28109 
      oprot.writeFieldBegin('success', TType.LIST, 0)
28110 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 28111 
      for iter662 in self.success:
28112 
        iter662.write(oprot)
6031 rajveer 28113 
      oprot.writeListEnd()
28114 
      oprot.writeFieldEnd()
28115 
    oprot.writeFieldStop()
28116 
    oprot.writeStructEnd()
28117 
 
28118 
  def validate(self):
28119 
    return
28120 
 
28121 
 
28122 
  def __repr__(self):
28123 
    L = ['%s=%r' % (key, value)
28124 
      for key, value in self.__dict__.iteritems()]
28125 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28126 
 
28127 
  def __eq__(self, other):
28128 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28129 
 
28130 
  def __ne__(self, other):
28131 
    return not (self == other)
28132 
 
6000 mandeep.dh 28133 
class updateRechargeOrderStatus_args:
28134 
  """
28135 
  Attributes:
28136 
   - rechargeOrderId
28137 
   - rechargeOrderStatus
28138 
  """
28139 
 
28140 
  thrift_spec = (
28141 
    None, # 0
28142 
    (1, TType.I64, 'rechargeOrderId', None, None, ), # 1
28143 
    (2, TType.I32, 'rechargeOrderStatus', None, None, ), # 2
28144 
  )
28145 
 
28146 
  def __init__(self, rechargeOrderId=None, rechargeOrderStatus=None,):
28147 
    self.rechargeOrderId = rechargeOrderId
28148 
    self.rechargeOrderStatus = rechargeOrderStatus
28149 
 
28150 
  def read(self, iprot):
28151 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28152 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28153 
      return
28154 
    iprot.readStructBegin()
28155 
    while True:
28156 
      (fname, ftype, fid) = iprot.readFieldBegin()
28157 
      if ftype == TType.STOP:
28158 
        break
28159 
      if fid == 1:
28160 
        if ftype == TType.I64:
28161 
          self.rechargeOrderId = iprot.readI64();
28162 
        else:
28163 
          iprot.skip(ftype)
28164 
      elif fid == 2:
28165 
        if ftype == TType.I32:
28166 
          self.rechargeOrderStatus = iprot.readI32();
28167 
        else:
28168 
          iprot.skip(ftype)
28169 
      else:
28170 
        iprot.skip(ftype)
28171 
      iprot.readFieldEnd()
28172 
    iprot.readStructEnd()
28173 
 
28174 
  def write(self, oprot):
28175 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28176 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28177 
      return
28178 
    oprot.writeStructBegin('updateRechargeOrderStatus_args')
28179 
    if self.rechargeOrderId is not None:
28180 
      oprot.writeFieldBegin('rechargeOrderId', TType.I64, 1)
28181 
      oprot.writeI64(self.rechargeOrderId)
28182 
      oprot.writeFieldEnd()
28183 
    if self.rechargeOrderStatus is not None:
28184 
      oprot.writeFieldBegin('rechargeOrderStatus', TType.I32, 2)
28185 
      oprot.writeI32(self.rechargeOrderStatus)
28186 
      oprot.writeFieldEnd()
28187 
    oprot.writeFieldStop()
28188 
    oprot.writeStructEnd()
28189 
 
28190 
  def validate(self):
28191 
    return
28192 
 
28193 
 
28194 
  def __repr__(self):
28195 
    L = ['%s=%r' % (key, value)
28196 
      for key, value in self.__dict__.iteritems()]
28197 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28198 
 
28199 
  def __eq__(self, other):
28200 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28201 
 
28202 
  def __ne__(self, other):
28203 
    return not (self == other)
28204 
 
28205 
class updateRechargeOrderStatus_result:
28206 
  """
28207 
  Attributes:
6031 rajveer 28208 
   - success
6000 mandeep.dh 28209 
   - ex
28210 
  """
28211 
 
28212 
  thrift_spec = (
6031 rajveer 28213 
    (0, TType.BOOL, 'success', None, None, ), # 0
6000 mandeep.dh 28214 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
28215 
  )
28216 
 
6031 rajveer 28217 
  def __init__(self, success=None, ex=None,):
28218 
    self.success = success
6000 mandeep.dh 28219 
    self.ex = ex
28220 
 
28221 
  def read(self, iprot):
28222 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28223 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28224 
      return
28225 
    iprot.readStructBegin()
28226 
    while True:
28227 
      (fname, ftype, fid) = iprot.readFieldBegin()
28228 
      if ftype == TType.STOP:
28229 
        break
6031 rajveer 28230 
      if fid == 0:
28231 
        if ftype == TType.BOOL:
28232 
          self.success = iprot.readBool();
28233 
        else:
28234 
          iprot.skip(ftype)
28235 
      elif fid == 1:
6000 mandeep.dh 28236 
        if ftype == TType.STRUCT:
28237 
          self.ex = TransactionServiceException()
28238 
          self.ex.read(iprot)
28239 
        else:
28240 
          iprot.skip(ftype)
28241 
      else:
28242 
        iprot.skip(ftype)
28243 
      iprot.readFieldEnd()
28244 
    iprot.readStructEnd()
28245 
 
28246 
  def write(self, oprot):
28247 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28248 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28249 
      return
28250 
    oprot.writeStructBegin('updateRechargeOrderStatus_result')
6031 rajveer 28251 
    if self.success is not None:
28252 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
28253 
      oprot.writeBool(self.success)
28254 
      oprot.writeFieldEnd()
6000 mandeep.dh 28255 
    if self.ex is not None:
28256 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
28257 
      self.ex.write(oprot)
28258 
      oprot.writeFieldEnd()
28259 
    oprot.writeFieldStop()
28260 
    oprot.writeStructEnd()
28261 
 
28262 
  def validate(self):
28263 
    return
28264 
 
28265 
 
28266 
  def __repr__(self):
28267 
    L = ['%s=%r' % (key, value)
28268 
      for key, value in self.__dict__.iteritems()]
28269 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28270 
 
28271 
  def __eq__(self, other):
28272 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28273 
 
28274 
  def __ne__(self, other):
28275 
    return not (self == other)
28276 
 
28277 
class activateRechargeTxn_args:
28278 
  """
28279 
  Attributes:
6031 rajveer 28280 
   - rechargeOrderId
6000 mandeep.dh 28281 
  """
28282 
 
28283 
  thrift_spec = (
28284 
    None, # 0
6031 rajveer 28285 
    (1, TType.I64, 'rechargeOrderId', None, None, ), # 1
6000 mandeep.dh 28286 
  )
28287 
 
6031 rajveer 28288 
  def __init__(self, rechargeOrderId=None,):
28289 
    self.rechargeOrderId = rechargeOrderId
6000 mandeep.dh 28290 
 
28291 
  def read(self, iprot):
28292 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28293 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28294 
      return
28295 
    iprot.readStructBegin()
28296 
    while True:
28297 
      (fname, ftype, fid) = iprot.readFieldBegin()
28298 
      if ftype == TType.STOP:
28299 
        break
28300 
      if fid == 1:
6031 rajveer 28301 
        if ftype == TType.I64:
28302 
          self.rechargeOrderId = iprot.readI64();
6000 mandeep.dh 28303 
        else:
28304 
          iprot.skip(ftype)
28305 
      else:
28306 
        iprot.skip(ftype)
28307 
      iprot.readFieldEnd()
28308 
    iprot.readStructEnd()
28309 
 
28310 
  def write(self, oprot):
28311 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28312 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28313 
      return
28314 
    oprot.writeStructBegin('activateRechargeTxn_args')
6031 rajveer 28315 
    if self.rechargeOrderId is not None:
28316 
      oprot.writeFieldBegin('rechargeOrderId', TType.I64, 1)
28317 
      oprot.writeI64(self.rechargeOrderId)
6000 mandeep.dh 28318 
      oprot.writeFieldEnd()
28319 
    oprot.writeFieldStop()
28320 
    oprot.writeStructEnd()
28321 
 
28322 
  def validate(self):
28323 
    return
28324 
 
28325 
 
28326 
  def __repr__(self):
28327 
    L = ['%s=%r' % (key, value)
28328 
      for key, value in self.__dict__.iteritems()]
28329 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28330 
 
28331 
  def __eq__(self, other):
28332 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28333 
 
28334 
  def __ne__(self, other):
28335 
    return not (self == other)
28336 
 
28337 
class activateRechargeTxn_result:
28338 
  """
28339 
  Attributes:
28340 
   - success
28341 
   - ex
28342 
  """
28343 
 
28344 
  thrift_spec = (
6031 rajveer 28345 
    (0, TType.BOOL, 'success', None, None, ), # 0
6000 mandeep.dh 28346 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
28347 
  )
28348 
 
28349 
  def __init__(self, success=None, ex=None,):
28350 
    self.success = success
28351 
    self.ex = ex
28352 
 
28353 
  def read(self, iprot):
28354 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28355 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28356 
      return
28357 
    iprot.readStructBegin()
28358 
    while True:
28359 
      (fname, ftype, fid) = iprot.readFieldBegin()
28360 
      if ftype == TType.STOP:
28361 
        break
28362 
      if fid == 0:
6031 rajveer 28363 
        if ftype == TType.BOOL:
28364 
          self.success = iprot.readBool();
6000 mandeep.dh 28365 
        else:
28366 
          iprot.skip(ftype)
28367 
      elif fid == 1:
28368 
        if ftype == TType.STRUCT:
28369 
          self.ex = TransactionServiceException()
28370 
          self.ex.read(iprot)
28371 
        else:
28372 
          iprot.skip(ftype)
28373 
      else:
28374 
        iprot.skip(ftype)
28375 
      iprot.readFieldEnd()
28376 
    iprot.readStructEnd()
28377 
 
28378 
  def write(self, oprot):
28379 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28380 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28381 
      return
28382 
    oprot.writeStructBegin('activateRechargeTxn_result')
28383 
    if self.success is not None:
6031 rajveer 28384 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
28385 
      oprot.writeBool(self.success)
6000 mandeep.dh 28386 
      oprot.writeFieldEnd()
28387 
    if self.ex is not None:
28388 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
28389 
      self.ex.write(oprot)
28390 
      oprot.writeFieldEnd()
28391 
    oprot.writeFieldStop()
28392 
    oprot.writeStructEnd()
28393 
 
28394 
  def validate(self):
28395 
    return
28396 
 
28397 
 
28398 
  def __repr__(self):
28399 
    L = ['%s=%r' % (key, value)
28400 
      for key, value in self.__dict__.iteritems()]
28401 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28402 
 
28403 
  def __eq__(self, other):
28404 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28405 
 
28406 
  def __ne__(self, other):
28407 
    return not (self == other)
28408 
 
6031 rajveer 28409 
class getUserWallet_args:
6000 mandeep.dh 28410 
  """
28411 
  Attributes:
6031 rajveer 28412 
   - userId
6000 mandeep.dh 28413 
  """
28414 
 
28415 
  thrift_spec = (
28416 
    None, # 0
6031 rajveer 28417 
    (1, TType.I64, 'userId', None, None, ), # 1
6000 mandeep.dh 28418 
  )
28419 
 
6031 rajveer 28420 
  def __init__(self, userId=None,):
28421 
    self.userId = userId
6000 mandeep.dh 28422 
 
28423 
  def read(self, iprot):
28424 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28425 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28426 
      return
28427 
    iprot.readStructBegin()
28428 
    while True:
28429 
      (fname, ftype, fid) = iprot.readFieldBegin()
28430 
      if ftype == TType.STOP:
28431 
        break
28432 
      if fid == 1:
28433 
        if ftype == TType.I64:
6031 rajveer 28434 
          self.userId = iprot.readI64();
6000 mandeep.dh 28435 
        else:
28436 
          iprot.skip(ftype)
28437 
      else:
28438 
        iprot.skip(ftype)
28439 
      iprot.readFieldEnd()
28440 
    iprot.readStructEnd()
28441 
 
28442 
  def write(self, oprot):
28443 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28444 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28445 
      return
6031 rajveer 28446 
    oprot.writeStructBegin('getUserWallet_args')
28447 
    if self.userId is not None:
28448 
      oprot.writeFieldBegin('userId', TType.I64, 1)
28449 
      oprot.writeI64(self.userId)
6000 mandeep.dh 28450 
      oprot.writeFieldEnd()
28451 
    oprot.writeFieldStop()
28452 
    oprot.writeStructEnd()
28453 
 
28454 
  def validate(self):
28455 
    return
28456 
 
28457 
 
28458 
  def __repr__(self):
28459 
    L = ['%s=%r' % (key, value)
28460 
      for key, value in self.__dict__.iteritems()]
28461 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28462 
 
28463 
  def __eq__(self, other):
28464 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28465 
 
28466 
  def __ne__(self, other):
28467 
    return not (self == other)
28468 
 
6031 rajveer 28469 
class getUserWallet_result:
6000 mandeep.dh 28470 
  """
28471 
  Attributes:
28472 
   - success
28473 
  """
28474 
 
28475 
  thrift_spec = (
6031 rajveer 28476 
    (0, TType.STRUCT, 'success', (UserWallet, UserWallet.thrift_spec), None, ), # 0
6000 mandeep.dh 28477 
  )
28478 
 
28479 
  def __init__(self, success=None,):
28480 
    self.success = success
28481 
 
28482 
  def read(self, iprot):
28483 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28484 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28485 
      return
28486 
    iprot.readStructBegin()
28487 
    while True:
28488 
      (fname, ftype, fid) = iprot.readFieldBegin()
28489 
      if ftype == TType.STOP:
28490 
        break
28491 
      if fid == 0:
6031 rajveer 28492 
        if ftype == TType.STRUCT:
28493 
          self.success = UserWallet()
28494 
          self.success.read(iprot)
6000 mandeep.dh 28495 
        else:
28496 
          iprot.skip(ftype)
28497 
      else:
28498 
        iprot.skip(ftype)
28499 
      iprot.readFieldEnd()
28500 
    iprot.readStructEnd()
28501 
 
28502 
  def write(self, oprot):
28503 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28504 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28505 
      return
6031 rajveer 28506 
    oprot.writeStructBegin('getUserWallet_result')
6000 mandeep.dh 28507 
    if self.success is not None:
6031 rajveer 28508 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
28509 
      self.success.write(oprot)
6000 mandeep.dh 28510 
      oprot.writeFieldEnd()
28511 
    oprot.writeFieldStop()
28512 
    oprot.writeStructEnd()
28513 
 
28514 
  def validate(self):
28515 
    return
28516 
 
28517 
 
28518 
  def __repr__(self):
28519 
    L = ['%s=%r' % (key, value)
28520 
      for key, value in self.__dict__.iteritems()]
28521 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28522 
 
28523 
  def __eq__(self, other):
28524 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28525 
 
28526 
  def __ne__(self, other):
28527 
    return not (self == other)
28528 
 
6031 rajveer 28529 
class getUserWalletHistory_args:
6000 mandeep.dh 28530 
  """
28531 
  Attributes:
6031 rajveer 28532 
   - userId
6000 mandeep.dh 28533 
  """
28534 
 
28535 
  thrift_spec = (
28536 
    None, # 0
6031 rajveer 28537 
    (1, TType.I64, 'userId', None, None, ), # 1
6000 mandeep.dh 28538 
  )
28539 
 
6031 rajveer 28540 
  def __init__(self, userId=None,):
28541 
    self.userId = userId
6000 mandeep.dh 28542 
 
28543 
  def read(self, iprot):
28544 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28545 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28546 
      return
28547 
    iprot.readStructBegin()
28548 
    while True:
28549 
      (fname, ftype, fid) = iprot.readFieldBegin()
28550 
      if ftype == TType.STOP:
28551 
        break
28552 
      if fid == 1:
28553 
        if ftype == TType.I64:
6031 rajveer 28554 
          self.userId = iprot.readI64();
6000 mandeep.dh 28555 
        else:
28556 
          iprot.skip(ftype)
28557 
      else:
28558 
        iprot.skip(ftype)
28559 
      iprot.readFieldEnd()
28560 
    iprot.readStructEnd()
28561 
 
28562 
  def write(self, oprot):
28563 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28564 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28565 
      return
6031 rajveer 28566 
    oprot.writeStructBegin('getUserWalletHistory_args')
28567 
    if self.userId is not None:
28568 
      oprot.writeFieldBegin('userId', TType.I64, 1)
28569 
      oprot.writeI64(self.userId)
6000 mandeep.dh 28570 
      oprot.writeFieldEnd()
28571 
    oprot.writeFieldStop()
28572 
    oprot.writeStructEnd()
28573 
 
28574 
  def validate(self):
28575 
    return
28576 
 
28577 
 
28578 
  def __repr__(self):
28579 
    L = ['%s=%r' % (key, value)
28580 
      for key, value in self.__dict__.iteritems()]
28581 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28582 
 
28583 
  def __eq__(self, other):
28584 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28585 
 
28586 
  def __ne__(self, other):
28587 
    return not (self == other)
28588 
 
6031 rajveer 28589 
class getUserWalletHistory_result:
6000 mandeep.dh 28590 
  """
28591 
  Attributes:
28592 
   - success
28593 
  """
28594 
 
28595 
  thrift_spec = (
6031 rajveer 28596 
    (0, TType.LIST, 'success', (TType.STRUCT,(UserWalletHistory, UserWalletHistory.thrift_spec)), None, ), # 0
6000 mandeep.dh 28597 
  )
28598 
 
28599 
  def __init__(self, success=None,):
28600 
    self.success = success
28601 
 
28602 
  def read(self, iprot):
28603 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28604 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28605 
      return
28606 
    iprot.readStructBegin()
28607 
    while True:
28608 
      (fname, ftype, fid) = iprot.readFieldBegin()
28609 
      if ftype == TType.STOP:
28610 
        break
28611 
      if fid == 0:
28612 
        if ftype == TType.LIST:
28613 
          self.success = []
6188 rajveer 28614 
          (_etype666, _size663) = iprot.readListBegin()
28615 
          for _i667 in xrange(_size663):
28616 
            _elem668 = UserWalletHistory()
28617 
            _elem668.read(iprot)
28618 
            self.success.append(_elem668)
6000 mandeep.dh 28619 
          iprot.readListEnd()
28620 
        else:
28621 
          iprot.skip(ftype)
28622 
      else:
28623 
        iprot.skip(ftype)
28624 
      iprot.readFieldEnd()
28625 
    iprot.readStructEnd()
28626 
 
28627 
  def write(self, oprot):
28628 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28629 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28630 
      return
6031 rajveer 28631 
    oprot.writeStructBegin('getUserWalletHistory_result')
6000 mandeep.dh 28632 
    if self.success is not None:
28633 
      oprot.writeFieldBegin('success', TType.LIST, 0)
28634 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 28635 
      for iter669 in self.success:
28636 
        iter669.write(oprot)
6000 mandeep.dh 28637 
      oprot.writeListEnd()
28638 
      oprot.writeFieldEnd()
28639 
    oprot.writeFieldStop()
28640 
    oprot.writeStructEnd()
28641 
 
28642 
  def validate(self):
28643 
    return
28644 
 
28645 
 
28646 
  def __repr__(self):
28647 
    L = ['%s=%r' % (key, value)
28648 
      for key, value in self.__dict__.iteritems()]
28649 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28650 
 
28651 
  def __eq__(self, other):
28652 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28653 
 
28654 
  def __ne__(self, other):
28655 
    return not (self == other)
6048 rajveer 28656 
 
6050 anupam.sin 28657 
class getRechargeOrdersForTransaction_args:
28658 
  """
28659 
  Attributes:
28660 
   - txnId
28661 
  """
28662 
 
28663 
  thrift_spec = (
28664 
    None, # 0
28665 
    (1, TType.I64, 'txnId', None, None, ), # 1
28666 
  )
28667 
 
28668 
  def __init__(self, txnId=None,):
28669 
    self.txnId = txnId
28670 
 
28671 
  def read(self, iprot):
28672 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28673 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28674 
      return
28675 
    iprot.readStructBegin()
28676 
    while True:
28677 
      (fname, ftype, fid) = iprot.readFieldBegin()
28678 
      if ftype == TType.STOP:
28679 
        break
28680 
      if fid == 1:
28681 
        if ftype == TType.I64:
28682 
          self.txnId = iprot.readI64();
28683 
        else:
28684 
          iprot.skip(ftype)
28685 
      else:
28686 
        iprot.skip(ftype)
28687 
      iprot.readFieldEnd()
28688 
    iprot.readStructEnd()
28689 
 
28690 
  def write(self, oprot):
28691 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28692 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28693 
      return
28694 
    oprot.writeStructBegin('getRechargeOrdersForTransaction_args')
28695 
    if self.txnId is not None:
28696 
      oprot.writeFieldBegin('txnId', TType.I64, 1)
28697 
      oprot.writeI64(self.txnId)
28698 
      oprot.writeFieldEnd()
28699 
    oprot.writeFieldStop()
28700 
    oprot.writeStructEnd()
28701 
 
28702 
  def validate(self):
28703 
    return
28704 
 
28705 
 
28706 
  def __repr__(self):
28707 
    L = ['%s=%r' % (key, value)
28708 
      for key, value in self.__dict__.iteritems()]
28709 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28710 
 
28711 
  def __eq__(self, other):
28712 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28713 
 
28714 
  def __ne__(self, other):
28715 
    return not (self == other)
28716 
 
28717 
class getRechargeOrdersForTransaction_result:
28718 
  """
28719 
  Attributes:
28720 
   - success
28721 
   - ex
28722 
  """
28723 
 
28724 
  thrift_spec = (
28725 
    (0, TType.STRUCT, 'success', (RechargeOrder, RechargeOrder.thrift_spec), None, ), # 0
28726 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
28727 
  )
28728 
 
28729 
  def __init__(self, success=None, ex=None,):
28730 
    self.success = success
28731 
    self.ex = ex
28732 
 
28733 
  def read(self, iprot):
28734 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28735 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28736 
      return
28737 
    iprot.readStructBegin()
28738 
    while True:
28739 
      (fname, ftype, fid) = iprot.readFieldBegin()
28740 
      if ftype == TType.STOP:
28741 
        break
28742 
      if fid == 0:
28743 
        if ftype == TType.STRUCT:
28744 
          self.success = RechargeOrder()
28745 
          self.success.read(iprot)
28746 
        else:
28747 
          iprot.skip(ftype)
28748 
      elif fid == 1:
28749 
        if ftype == TType.STRUCT:
28750 
          self.ex = TransactionServiceException()
28751 
          self.ex.read(iprot)
28752 
        else:
28753 
          iprot.skip(ftype)
28754 
      else:
28755 
        iprot.skip(ftype)
28756 
      iprot.readFieldEnd()
28757 
    iprot.readStructEnd()
28758 
 
28759 
  def write(self, oprot):
28760 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28761 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28762 
      return
28763 
    oprot.writeStructBegin('getRechargeOrdersForTransaction_result')
28764 
    if self.success is not None:
28765 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
28766 
      self.success.write(oprot)
28767 
      oprot.writeFieldEnd()
28768 
    if self.ex is not None:
28769 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
28770 
      self.ex.write(oprot)
28771 
      oprot.writeFieldEnd()
28772 
    oprot.writeFieldStop()
28773 
    oprot.writeStructEnd()
28774 
 
28775 
  def validate(self):
28776 
    return
28777 
 
28778 
 
28779 
  def __repr__(self):
28780 
    L = ['%s=%r' % (key, value)
28781 
      for key, value in self.__dict__.iteritems()]
28782 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28783 
 
28784 
  def __eq__(self, other):
28785 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28786 
 
28787 
  def __ne__(self, other):
28788 
    return not (self == other)
28789 
 
6048 rajveer 28790 
class getServiceProviders_args:
28791 
  """
28792 
  Attributes:
28793 
   - rechargeType
6206 rajveer 28794 
   - onlyActive
6048 rajveer 28795 
  """
28796 
 
28797 
  thrift_spec = (
28798 
    None, # 0
28799 
    (1, TType.I32, 'rechargeType', None, None, ), # 1
6206 rajveer 28800 
    (2, TType.BOOL, 'onlyActive', None, None, ), # 2
6048 rajveer 28801 
  )
28802 
 
6206 rajveer 28803 
  def __init__(self, rechargeType=None, onlyActive=None,):
6048 rajveer 28804 
    self.rechargeType = rechargeType
6206 rajveer 28805 
    self.onlyActive = onlyActive
6048 rajveer 28806 
 
28807 
  def read(self, iprot):
28808 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28809 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28810 
      return
28811 
    iprot.readStructBegin()
28812 
    while True:
28813 
      (fname, ftype, fid) = iprot.readFieldBegin()
28814 
      if ftype == TType.STOP:
28815 
        break
28816 
      if fid == 1:
28817 
        if ftype == TType.I32:
28818 
          self.rechargeType = iprot.readI32();
28819 
        else:
28820 
          iprot.skip(ftype)
6206 rajveer 28821 
      elif fid == 2:
28822 
        if ftype == TType.BOOL:
28823 
          self.onlyActive = iprot.readBool();
28824 
        else:
28825 
          iprot.skip(ftype)
6048 rajveer 28826 
      else:
28827 
        iprot.skip(ftype)
28828 
      iprot.readFieldEnd()
28829 
    iprot.readStructEnd()
28830 
 
28831 
  def write(self, oprot):
28832 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28833 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28834 
      return
28835 
    oprot.writeStructBegin('getServiceProviders_args')
28836 
    if self.rechargeType is not None:
28837 
      oprot.writeFieldBegin('rechargeType', TType.I32, 1)
28838 
      oprot.writeI32(self.rechargeType)
28839 
      oprot.writeFieldEnd()
6206 rajveer 28840 
    if self.onlyActive is not None:
28841 
      oprot.writeFieldBegin('onlyActive', TType.BOOL, 2)
28842 
      oprot.writeBool(self.onlyActive)
28843 
      oprot.writeFieldEnd()
6048 rajveer 28844 
    oprot.writeFieldStop()
28845 
    oprot.writeStructEnd()
28846 
 
28847 
  def validate(self):
28848 
    return
28849 
 
28850 
 
28851 
  def __repr__(self):
28852 
    L = ['%s=%r' % (key, value)
28853 
      for key, value in self.__dict__.iteritems()]
28854 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28855 
 
28856 
  def __eq__(self, other):
28857 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28858 
 
28859 
  def __ne__(self, other):
28860 
    return not (self == other)
28861 
 
28862 
class getServiceProviders_result:
28863 
  """
28864 
  Attributes:
28865 
   - success
28866 
  """
28867 
 
28868 
  thrift_spec = (
28869 
    (0, TType.MAP, 'success', (TType.I64,None,TType.STRING,None), None, ), # 0
28870 
  )
28871 
 
28872 
  def __init__(self, success=None,):
28873 
    self.success = success
28874 
 
28875 
  def read(self, iprot):
28876 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28877 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28878 
      return
28879 
    iprot.readStructBegin()
28880 
    while True:
28881 
      (fname, ftype, fid) = iprot.readFieldBegin()
28882 
      if ftype == TType.STOP:
28883 
        break
28884 
      if fid == 0:
28885 
        if ftype == TType.MAP:
28886 
          self.success = {}
6188 rajveer 28887 
          (_ktype671, _vtype672, _size670 ) = iprot.readMapBegin()
28888 
          for _i674 in xrange(_size670):
28889 
            _key675 = iprot.readI64();
28890 
            _val676 = iprot.readString();
28891 
            self.success[_key675] = _val676
6048 rajveer 28892 
          iprot.readMapEnd()
28893 
        else:
28894 
          iprot.skip(ftype)
28895 
      else:
28896 
        iprot.skip(ftype)
28897 
      iprot.readFieldEnd()
28898 
    iprot.readStructEnd()
28899 
 
28900 
  def write(self, oprot):
28901 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28902 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28903 
      return
28904 
    oprot.writeStructBegin('getServiceProviders_result')
28905 
    if self.success is not None:
28906 
      oprot.writeFieldBegin('success', TType.MAP, 0)
28907 
      oprot.writeMapBegin(TType.I64, TType.STRING, len(self.success))
6188 rajveer 28908 
      for kiter677,viter678 in self.success.items():
28909 
        oprot.writeI64(kiter677)
28910 
        oprot.writeString(viter678)
6048 rajveer 28911 
      oprot.writeMapEnd()
28912 
      oprot.writeFieldEnd()
28913 
    oprot.writeFieldStop()
28914 
    oprot.writeStructEnd()
28915 
 
28916 
  def validate(self):
28917 
    return
28918 
 
28919 
 
28920 
  def __repr__(self):
28921 
    L = ['%s=%r' % (key, value)
28922 
      for key, value in self.__dict__.iteritems()]
28923 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28924 
 
28925 
  def __eq__(self, other):
28926 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28927 
 
28928 
  def __ne__(self, other):
28929 
    return not (self == other)
28930 
 
28931 
class getServiceProviderForDevice_args:
28932 
  """
28933 
  Attributes:
6049 rajveer 28934 
   - rechargeType
6048 rajveer 28935 
   - deviceNumber
28936 
  """
28937 
 
28938 
  thrift_spec = (
28939 
    None, # 0
6049 rajveer 28940 
    (1, TType.I32, 'rechargeType', None, None, ), # 1
28941 
    (2, TType.STRING, 'deviceNumber', None, None, ), # 2
6048 rajveer 28942 
  )
28943 
 
6049 rajveer 28944 
  def __init__(self, rechargeType=None, deviceNumber=None,):
28945 
    self.rechargeType = rechargeType
6048 rajveer 28946 
    self.deviceNumber = deviceNumber
28947 
 
28948 
  def read(self, iprot):
28949 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28950 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28951 
      return
28952 
    iprot.readStructBegin()
28953 
    while True:
28954 
      (fname, ftype, fid) = iprot.readFieldBegin()
28955 
      if ftype == TType.STOP:
28956 
        break
28957 
      if fid == 1:
6049 rajveer 28958 
        if ftype == TType.I32:
28959 
          self.rechargeType = iprot.readI32();
28960 
        else:
28961 
          iprot.skip(ftype)
28962 
      elif fid == 2:
6048 rajveer 28963 
        if ftype == TType.STRING:
28964 
          self.deviceNumber = iprot.readString();
28965 
        else:
28966 
          iprot.skip(ftype)
28967 
      else:
28968 
        iprot.skip(ftype)
28969 
      iprot.readFieldEnd()
28970 
    iprot.readStructEnd()
28971 
 
28972 
  def write(self, oprot):
28973 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28974 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28975 
      return
28976 
    oprot.writeStructBegin('getServiceProviderForDevice_args')
6049 rajveer 28977 
    if self.rechargeType is not None:
28978 
      oprot.writeFieldBegin('rechargeType', TType.I32, 1)
28979 
      oprot.writeI32(self.rechargeType)
28980 
      oprot.writeFieldEnd()
6048 rajveer 28981 
    if self.deviceNumber is not None:
6049 rajveer 28982 
      oprot.writeFieldBegin('deviceNumber', TType.STRING, 2)
6048 rajveer 28983 
      oprot.writeString(self.deviceNumber)
28984 
      oprot.writeFieldEnd()
28985 
    oprot.writeFieldStop()
28986 
    oprot.writeStructEnd()
28987 
 
28988 
  def validate(self):
28989 
    return
28990 
 
28991 
 
28992 
  def __repr__(self):
28993 
    L = ['%s=%r' % (key, value)
28994 
      for key, value in self.__dict__.iteritems()]
28995 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28996 
 
28997 
  def __eq__(self, other):
28998 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28999 
 
29000 
  def __ne__(self, other):
29001 
    return not (self == other)
29002 
 
29003 
class getServiceProviderForDevice_result:
29004 
  """
29005 
  Attributes:
29006 
   - success
29007 
  """
29008 
 
29009 
  thrift_spec = (
6289 anupam.sin 29010 
    (0, TType.STRUCT, 'success', (DeviceNumberInfo, DeviceNumberInfo.thrift_spec), None, ), # 0
6048 rajveer 29011 
  )
29012 
 
29013 
  def __init__(self, success=None,):
29014 
    self.success = success
29015 
 
29016 
  def read(self, iprot):
29017 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
29018 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
29019 
      return
29020 
    iprot.readStructBegin()
29021 
    while True:
29022 
      (fname, ftype, fid) = iprot.readFieldBegin()
29023 
      if ftype == TType.STOP:
29024 
        break
29025 
      if fid == 0:
6289 anupam.sin 29026 
        if ftype == TType.STRUCT:
29027 
          self.success = DeviceNumberInfo()
29028 
          self.success.read(iprot)
6048 rajveer 29029 
        else:
29030 
          iprot.skip(ftype)
29031 
      else:
29032 
        iprot.skip(ftype)
29033 
      iprot.readFieldEnd()
29034 
    iprot.readStructEnd()
29035 
 
29036 
  def write(self, oprot):
29037 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
29038 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
29039 
      return
29040 
    oprot.writeStructBegin('getServiceProviderForDevice_result')
29041 
    if self.success is not None:
6289 anupam.sin 29042 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
29043 
      self.success.write(oprot)
6048 rajveer 29044 
      oprot.writeFieldEnd()
29045 
    oprot.writeFieldStop()
29046 
    oprot.writeStructEnd()
29047 
 
29048 
  def validate(self):
29049 
    return
29050 
 
29051 
 
29052 
  def __repr__(self):
29053 
    L = ['%s=%r' % (key, value)
29054 
      for key, value in self.__dict__.iteritems()]
29055 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
29056 
 
29057 
  def __eq__(self, other):
29058 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
29059 
 
29060 
  def __ne__(self, other):
29061 
    return not (self == other)
6094 rajveer 29062 
 
6269 rajveer 29063 
class validateRecharge_args:
29064 
  """
29065 
  Attributes:
29066 
   - rechargeType
29067 
   - deviceNumber
6307 anupam.sin 29068 
   - userSelectedProviderId
6591 anupam.sin 29069 
   - clientAddress
6269 rajveer 29070 
  """
29071 
 
29072 
  thrift_spec = (
29073 
    None, # 0
29074 
    (1, TType.I32, 'rechargeType', None, None, ), # 1
29075 
    (2, TType.STRING, 'deviceNumber', None, None, ), # 2
6336 anupam.sin 29076 
    (3, TType.I64, 'userSelectedProviderId', None, None, ), # 3
6591 anupam.sin 29077 
    (4, TType.STRING, 'clientAddress', None, None, ), # 4
6269 rajveer 29078 
  )
29079 
 
6591 anupam.sin 29080 
  def __init__(self, rechargeType=None, deviceNumber=None, userSelectedProviderId=None, clientAddress=None,):
6269 rajveer 29081 
    self.rechargeType = rechargeType
29082 
    self.deviceNumber = deviceNumber
6307 anupam.sin 29083 
    self.userSelectedProviderId = userSelectedProviderId
6591 anupam.sin 29084 
    self.clientAddress = clientAddress
6269 rajveer 29085 
 
29086 
  def read(self, iprot):
29087 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
29088 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
29089 
      return
29090 
    iprot.readStructBegin()
29091 
    while True:
29092 
      (fname, ftype, fid) = iprot.readFieldBegin()
29093 
      if ftype == TType.STOP:
29094 
        break
29095 
      if fid == 1:
29096 
        if ftype == TType.I32:
29097 
          self.rechargeType = iprot.readI32();
29098 
        else:
29099 
          iprot.skip(ftype)
29100 
      elif fid == 2:
29101 
        if ftype == TType.STRING:
29102 
          self.deviceNumber = iprot.readString();
29103 
        else:
29104 
          iprot.skip(ftype)
6307 anupam.sin 29105 
      elif fid == 3:
29106 
        if ftype == TType.I64:
29107 
          self.userSelectedProviderId = iprot.readI64();
29108 
        else:
29109 
          iprot.skip(ftype)
6591 anupam.sin 29110 
      elif fid == 4:
29111 
        if ftype == TType.STRING:
29112 
          self.clientAddress = iprot.readString();
29113 
        else:
29114 
          iprot.skip(ftype)
6269 rajveer 29115 
      else:
29116 
        iprot.skip(ftype)
29117 
      iprot.readFieldEnd()
29118 
    iprot.readStructEnd()
29119 
 
29120 
  def write(self, oprot):
29121 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
29122 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
29123 
      return
29124 
    oprot.writeStructBegin('validateRecharge_args')
29125 
    if self.rechargeType is not None:
29126 
      oprot.writeFieldBegin('rechargeType', TType.I32, 1)
29127 
      oprot.writeI32(self.rechargeType)
29128 
      oprot.writeFieldEnd()
29129 
    if self.deviceNumber is not None:
29130 
      oprot.writeFieldBegin('deviceNumber', TType.STRING, 2)
29131 
      oprot.writeString(self.deviceNumber)
29132 
      oprot.writeFieldEnd()
6307 anupam.sin 29133 
    if self.userSelectedProviderId is not None:
6336 anupam.sin 29134 
      oprot.writeFieldBegin('userSelectedProviderId', TType.I64, 3)
6307 anupam.sin 29135 
      oprot.writeI64(self.userSelectedProviderId)
29136 
      oprot.writeFieldEnd()
6591 anupam.sin 29137 
    if self.clientAddress is not None:
29138 
      oprot.writeFieldBegin('clientAddress', TType.STRING, 4)
29139 
      oprot.writeString(self.clientAddress)
29140 
      oprot.writeFieldEnd()
6269 rajveer 29141 
    oprot.writeFieldStop()
29142 
    oprot.writeStructEnd()
29143 
 
29144 
  def validate(self):
29145 
    return
29146 
 
29147 
 
29148 
  def __repr__(self):
29149 
    L = ['%s=%r' % (key, value)
29150 
      for key, value in self.__dict__.iteritems()]
29151 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
29152 
 
29153 
  def __eq__(self, other):
29154 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
29155 
 
29156 
  def __ne__(self, other):
29157 
    return not (self == other)
29158 
 
29159 
class validateRecharge_result:
29160 
  """
29161 
  Attributes:
29162 
   - success
29163 
  """
29164 
 
29165 
  thrift_spec = (
29166 
    (0, TType.STRING, 'success', None, None, ), # 0
29167 
  )
29168 
 
29169 
  def __init__(self, success=None,):
29170 
    self.success = success
29171 
 
29172 
  def read(self, iprot):
29173 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
29174 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
29175 
      return
29176 
    iprot.readStructBegin()
29177 
    while True:
29178 
      (fname, ftype, fid) = iprot.readFieldBegin()
29179 
      if ftype == TType.STOP:
29180 
        break
29181 
      if fid == 0:
29182 
        if ftype == TType.STRING:
29183 
          self.success = iprot.readString();
29184 
        else:
29185 
          iprot.skip(ftype)
29186 
      else:
29187 
        iprot.skip(ftype)
29188 
      iprot.readFieldEnd()
29189 
    iprot.readStructEnd()
29190 
 
29191 
  def write(self, oprot):
29192 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
29193 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
29194 
      return
29195 
    oprot.writeStructBegin('validateRecharge_result')
29196 
    if self.success is not None:
29197 
      oprot.writeFieldBegin('success', TType.STRING, 0)
29198 
      oprot.writeString(self.success)
29199 
      oprot.writeFieldEnd()
29200 
    oprot.writeFieldStop()
29201 
    oprot.writeStructEnd()
29202 
 
29203 
  def validate(self):
29204 
    return
29205 
 
29206 
 
29207 
  def __repr__(self):
29208 
    L = ['%s=%r' % (key, value)
29209 
      for key, value in self.__dict__.iteritems()]
29210 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
29211 
 
29212 
  def __eq__(self, other):
29213 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
29214 
 
29215 
  def __ne__(self, other):
29216 
    return not (self == other)
29217 
 
6094 rajveer 29218 
class getRechargeOrdersForDevice_args:
29219 
  """
29220 
  Attributes:
29221 
   - deviceNumber
29222 
  """
29223 
 
29224 
  thrift_spec = (
29225 
    None, # 0
29226 
    (1, TType.STRING, 'deviceNumber', None, None, ), # 1
29227 
  )
29228 
 
29229 
  def __init__(self, deviceNumber=None,):
29230 
    self.deviceNumber = deviceNumber
29231 
 
29232 
  def read(self, iprot):
29233 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
29234 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
29235 
      return
29236 
    iprot.readStructBegin()
29237 
    while True:
29238 
      (fname, ftype, fid) = iprot.readFieldBegin()
29239 
      if ftype == TType.STOP:
29240 
        break
29241 
      if fid == 1:
29242 
        if ftype == TType.STRING:
29243 
          self.deviceNumber = iprot.readString();
29244 
        else:
29245 
          iprot.skip(ftype)
29246 
      else:
29247 
        iprot.skip(ftype)
29248 
      iprot.readFieldEnd()
29249 
    iprot.readStructEnd()
29250 
 
29251 
  def write(self, oprot):
29252 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
29253 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
29254 
      return
29255 
    oprot.writeStructBegin('getRechargeOrdersForDevice_args')
29256 
    if self.deviceNumber is not None:
29257 
      oprot.writeFieldBegin('deviceNumber', TType.STRING, 1)
29258 
      oprot.writeString(self.deviceNumber)
29259 
      oprot.writeFieldEnd()
29260 
    oprot.writeFieldStop()
29261 
    oprot.writeStructEnd()
29262 
 
29263 
  def validate(self):
29264 
    return
29265 
 
29266 
 
29267 
  def __repr__(self):
29268 
    L = ['%s=%r' % (key, value)
29269 
      for key, value in self.__dict__.iteritems()]
29270 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
29271 
 
29272 
  def __eq__(self, other):
29273 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
29274 
 
29275 
  def __ne__(self, other):
29276 
    return not (self == other)
29277 
 
29278 
class getRechargeOrdersForDevice_result:
29279 
  """
29280 
  Attributes:
29281 
   - success
29282 
  """
29283 
 
29284 
  thrift_spec = (
29285 
    (0, TType.LIST, 'success', (TType.STRUCT,(RechargeOrder, RechargeOrder.thrift_spec)), None, ), # 0
29286 
  )
29287 
 
29288 
  def __init__(self, success=None,):
29289 
    self.success = success
29290 
 
29291 
  def read(self, iprot):
29292 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
29293 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
29294 
      return
29295 
    iprot.readStructBegin()
29296 
    while True:
29297 
      (fname, ftype, fid) = iprot.readFieldBegin()
29298 
      if ftype == TType.STOP:
29299 
        break
29300 
      if fid == 0:
29301 
        if ftype == TType.LIST:
29302 
          self.success = []
6188 rajveer 29303 
          (_etype682, _size679) = iprot.readListBegin()
29304 
          for _i683 in xrange(_size679):
29305 
            _elem684 = RechargeOrder()
29306 
            _elem684.read(iprot)
29307 
            self.success.append(_elem684)
6094 rajveer 29308 
          iprot.readListEnd()
29309 
        else:
29310 
          iprot.skip(ftype)
29311 
      else:
29312 
        iprot.skip(ftype)
29313 
      iprot.readFieldEnd()
29314 
    iprot.readStructEnd()
29315 
 
29316 
  def write(self, oprot):
29317 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
29318 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
29319 
      return
29320 
    oprot.writeStructBegin('getRechargeOrdersForDevice_result')
29321 
    if self.success is not None:
29322 
      oprot.writeFieldBegin('success', TType.LIST, 0)
29323 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 29324 
      for iter685 in self.success:
29325 
        iter685.write(oprot)
6094 rajveer 29326 
      oprot.writeListEnd()
29327 
      oprot.writeFieldEnd()
29328 
    oprot.writeFieldStop()
29329 
    oprot.writeStructEnd()
29330 
 
29331 
  def validate(self):
29332 
    return
29333 
 
29334 
 
29335 
  def __repr__(self):
29336 
    L = ['%s=%r' % (key, value)
29337 
      for key, value in self.__dict__.iteritems()]
29338 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
29339 
 
29340 
  def __eq__(self, other):
29341 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
29342 
 
29343 
  def __ne__(self, other):
29344 
    return not (self == other)
29345 
 
29346 
class addAmountToWallet_args:
29347 
  """
29348 
  Attributes:
29349 
   - userId
29350 
   - orderId
29351 
   - amount
29352 
  """
29353 
 
29354 
  thrift_spec = (
29355 
    None, # 0
29356 
    (1, TType.I64, 'userId', None, None, ), # 1
29357 
    (2, TType.I64, 'orderId', None, None, ), # 2
29358 
    (3, TType.I64, 'amount', None, None, ), # 3
29359 
  )
29360 
 
29361 
  def __init__(self, userId=None, orderId=None, amount=None,):
29362 
    self.userId = userId
29363 
    self.orderId = orderId
29364 
    self.amount = amount
29365 
 
29366 
  def read(self, iprot):
29367 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
29368 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
29369 
      return
29370 
    iprot.readStructBegin()
29371 
    while True:
29372 
      (fname, ftype, fid) = iprot.readFieldBegin()
29373 
      if ftype == TType.STOP:
29374 
        break
29375 
      if fid == 1:
29376 
        if ftype == TType.I64:
29377 
          self.userId = iprot.readI64();
29378 
        else:
29379 
          iprot.skip(ftype)
29380 
      elif fid == 2:
29381 
        if ftype == TType.I64:
29382 
          self.orderId = iprot.readI64();
29383 
        else:
29384 
          iprot.skip(ftype)
29385 
      elif fid == 3:
29386 
        if ftype == TType.I64:
29387 
          self.amount = iprot.readI64();
29388 
        else:
29389 
          iprot.skip(ftype)
29390 
      else:
29391 
        iprot.skip(ftype)
29392 
      iprot.readFieldEnd()
29393 
    iprot.readStructEnd()
29394 
 
29395 
  def write(self, oprot):
29396 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
29397 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
29398 
      return
29399 
    oprot.writeStructBegin('addAmountToWallet_args')
29400 
    if self.userId is not None:
29401 
      oprot.writeFieldBegin('userId', TType.I64, 1)
29402 
      oprot.writeI64(self.userId)
29403 
      oprot.writeFieldEnd()
29404 
    if self.orderId is not None:
29405 
      oprot.writeFieldBegin('orderId', TType.I64, 2)
29406 
      oprot.writeI64(self.orderId)
29407 
      oprot.writeFieldEnd()
29408 
    if self.amount is not None:
29409 
      oprot.writeFieldBegin('amount', TType.I64, 3)
29410 
      oprot.writeI64(self.amount)
29411 
      oprot.writeFieldEnd()
29412 
    oprot.writeFieldStop()
29413 
    oprot.writeStructEnd()
29414 
 
29415 
  def validate(self):
29416 
    return
29417 
 
29418 
 
29419 
  def __repr__(self):
29420 
    L = ['%s=%r' % (key, value)
29421 
      for key, value in self.__dict__.iteritems()]
29422 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
29423 
 
29424 
  def __eq__(self, other):
29425 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
29426 
 
29427 
  def __ne__(self, other):
29428 
    return not (self == other)
29429 
 
29430 
class addAmountToWallet_result:
29431 
 
29432 
  thrift_spec = (
29433 
  )
29434 
 
29435 
  def read(self, iprot):
29436 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
29437 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
29438 
      return
29439 
    iprot.readStructBegin()
29440 
    while True:
29441 
      (fname, ftype, fid) = iprot.readFieldBegin()
29442 
      if ftype == TType.STOP:
29443 
        break
29444 
      else:
29445 
        iprot.skip(ftype)
29446 
      iprot.readFieldEnd()
29447 
    iprot.readStructEnd()
29448 
 
29449 
  def write(self, oprot):
29450 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
29451 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
29452 
      return
29453 
    oprot.writeStructBegin('addAmountToWallet_result')
29454 
    oprot.writeFieldStop()
29455 
    oprot.writeStructEnd()
29456 
 
29457 
  def validate(self):
29458 
    return
29459 
 
29460 
 
29461 
  def __repr__(self):
29462 
    L = ['%s=%r' % (key, value)
29463 
      for key, value in self.__dict__.iteritems()]
29464 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
29465 
 
29466 
  def __eq__(self, other):
29467 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
29468 
 
29469 
  def __ne__(self, other):
29470 
    return not (self == other)
6154 rajveer 29471 
 
6188 rajveer 29472 
class getRechargeStatistics_args:
29473 
 
29474 
  thrift_spec = (
29475 
  )
29476 
 
29477 
  def read(self, iprot):
29478 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
29479 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
29480 
      return
29481 
    iprot.readStructBegin()
29482 
    while True:
29483 
      (fname, ftype, fid) = iprot.readFieldBegin()
29484 
      if ftype == TType.STOP:
29485 
        break
29486 
      else:
29487 
        iprot.skip(ftype)
29488 
      iprot.readFieldEnd()
29489 
    iprot.readStructEnd()
29490 
 
29491 
  def write(self, oprot):
29492 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
29493 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
29494 
      return
29495 
    oprot.writeStructBegin('getRechargeStatistics_args')
29496 
    oprot.writeFieldStop()
29497 
    oprot.writeStructEnd()
29498 
 
29499 
  def validate(self):
29500 
    return
29501 
 
29502 
 
29503 
  def __repr__(self):
29504 
    L = ['%s=%r' % (key, value)
29505 
      for key, value in self.__dict__.iteritems()]
29506 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
29507 
 
29508 
  def __eq__(self, other):
29509 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
29510 
 
29511 
  def __ne__(self, other):
29512 
    return not (self == other)
29513 
 
29514 
class getRechargeStatistics_result:
29515 
  """
29516 
  Attributes:
29517 
   - success
29518 
  """
29519 
 
29520 
  thrift_spec = (
29521 
    (0, TType.STRUCT, 'success', (RechargeStatistics, RechargeStatistics.thrift_spec), None, ), # 0
29522 
  )
29523 
 
29524 
  def __init__(self, success=None,):
29525 
    self.success = success
29526 
 
29527 
  def read(self, iprot):
29528 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
29529 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
29530 
      return
29531 
    iprot.readStructBegin()
29532 
    while True:
29533 
      (fname, ftype, fid) = iprot.readFieldBegin()
29534 
      if ftype == TType.STOP:
29535 
        break
29536 
      if fid == 0:
29537 
        if ftype == TType.STRUCT:
29538 
          self.success = RechargeStatistics()
29539 
          self.success.read(iprot)
29540 
        else:
29541 
          iprot.skip(ftype)
29542 
      else:
29543 
        iprot.skip(ftype)
29544 
      iprot.readFieldEnd()
29545 
    iprot.readStructEnd()
29546 
 
29547 
  def write(self, oprot):
29548 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
29549 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
29550 
      return
29551 
    oprot.writeStructBegin('getRechargeStatistics_result')
29552 
    if self.success is not None:
29553 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
29554 
      self.success.write(oprot)
29555 
      oprot.writeFieldEnd()
29556 
    oprot.writeFieldStop()
29557 
    oprot.writeStructEnd()
29558 
 
29559 
  def validate(self):
29560 
    return
29561 
 
29562 
 
29563 
  def __repr__(self):
29564 
    L = ['%s=%r' % (key, value)
29565 
      for key, value in self.__dict__.iteritems()]
29566 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
29567 
 
29568 
  def __eq__(self, other):
29569 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
29570 
 
29571 
  def __ne__(self, other):
29572 
    return not (self == other)
29573 
 
6154 rajveer 29574 
class getRechargeOrdersForStatus_args:
29575 
  """
29576 
  Attributes:
29577 
   - status
29578 
  """
29579 
 
29580 
  thrift_spec = (
29581 
    None, # 0
29582 
    (1, TType.I64, 'status', None, None, ), # 1
29583 
  )
29584 
 
29585 
  def __init__(self, status=None,):
29586 
    self.status = status
29587 
 
29588 
  def read(self, iprot):
29589 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
29590 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
29591 
      return
29592 
    iprot.readStructBegin()
29593 
    while True:
29594 
      (fname, ftype, fid) = iprot.readFieldBegin()
29595 
      if ftype == TType.STOP:
29596 
        break
29597 
      if fid == 1:
29598 
        if ftype == TType.I64:
29599 
          self.status = iprot.readI64();
29600 
        else:
29601 
          iprot.skip(ftype)
29602 
      else:
29603 
        iprot.skip(ftype)
29604 
      iprot.readFieldEnd()
29605 
    iprot.readStructEnd()
29606 
 
29607 
  def write(self, oprot):
29608 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
29609 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
29610 
      return
29611 
    oprot.writeStructBegin('getRechargeOrdersForStatus_args')
29612 
    if self.status is not None:
29613 
      oprot.writeFieldBegin('status', TType.I64, 1)
29614 
      oprot.writeI64(self.status)
29615 
      oprot.writeFieldEnd()
29616 
    oprot.writeFieldStop()
29617 
    oprot.writeStructEnd()
29618 
 
29619 
  def validate(self):
29620 
    return
29621 
 
29622 
 
29623 
  def __repr__(self):
29624 
    L = ['%s=%r' % (key, value)
29625 
      for key, value in self.__dict__.iteritems()]
29626 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
29627 
 
29628 
  def __eq__(self, other):
29629 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
29630 
 
29631 
  def __ne__(self, other):
29632 
    return not (self == other)
29633 
 
29634 
class getRechargeOrdersForStatus_result:
29635 
  """
29636 
  Attributes:
29637 
   - success
29638 
  """
29639 
 
29640 
  thrift_spec = (
29641 
    (0, TType.LIST, 'success', (TType.STRUCT,(RechargeOrder, RechargeOrder.thrift_spec)), None, ), # 0
29642 
  )
29643 
 
29644 
  def __init__(self, success=None,):
29645 
    self.success = success
29646 
 
29647 
  def read(self, iprot):
29648 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
29649 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
29650 
      return
29651 
    iprot.readStructBegin()
29652 
    while True:
29653 
      (fname, ftype, fid) = iprot.readFieldBegin()
29654 
      if ftype == TType.STOP:
29655 
        break
29656 
      if fid == 0:
29657 
        if ftype == TType.LIST:
29658 
          self.success = []
6188 rajveer 29659 
          (_etype689, _size686) = iprot.readListBegin()
29660 
          for _i690 in xrange(_size686):
29661 
            _elem691 = RechargeOrder()
29662 
            _elem691.read(iprot)
29663 
            self.success.append(_elem691)
6154 rajveer 29664 
          iprot.readListEnd()
29665 
        else:
29666 
          iprot.skip(ftype)
29667 
      else:
29668 
        iprot.skip(ftype)
29669 
      iprot.readFieldEnd()
29670 
    iprot.readStructEnd()
29671 
 
29672 
  def write(self, oprot):
29673 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
29674 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
29675 
      return
29676 
    oprot.writeStructBegin('getRechargeOrdersForStatus_result')
29677 
    if self.success is not None:
29678 
      oprot.writeFieldBegin('success', TType.LIST, 0)
29679 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 29680 
      for iter692 in self.success:
29681 
        iter692.write(oprot)
6154 rajveer 29682 
      oprot.writeListEnd()
29683 
      oprot.writeFieldEnd()
29684 
    oprot.writeFieldStop()
29685 
    oprot.writeStructEnd()
29686 
 
29687 
  def validate(self):
29688 
    return
29689 
 
29690 
 
29691 
  def __repr__(self):
29692 
    L = ['%s=%r' % (key, value)
29693 
      for key, value in self.__dict__.iteritems()]
29694 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
29695 
 
29696 
  def __eq__(self, other):
29697 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
29698 
 
29699 
  def __ne__(self, other):
29700 
    return not (self == other)
6159 rajveer 29701 
 
29702 
class getPlansForOperator_args:
29703 
  """
29704 
  Attributes:
29705 
   - operatorId
29706 
  """
29707 
 
29708 
  thrift_spec = (
29709 
    None, # 0
29710 
    (1, TType.I64, 'operatorId', None, None, ), # 1
29711 
  )
29712 
 
29713 
  def __init__(self, operatorId=None,):
29714 
    self.operatorId = operatorId
29715 
 
29716 
  def read(self, iprot):
29717 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
29718 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
29719 
      return
29720 
    iprot.readStructBegin()
29721 
    while True:
29722 
      (fname, ftype, fid) = iprot.readFieldBegin()
29723 
      if ftype == TType.STOP:
29724 
        break
29725 
      if fid == 1:
29726 
        if ftype == TType.I64:
29727 
          self.operatorId = iprot.readI64();
29728 
        else:
29729 
          iprot.skip(ftype)
29730 
      else:
29731 
        iprot.skip(ftype)
29732 
      iprot.readFieldEnd()
29733 
    iprot.readStructEnd()
29734 
 
29735 
  def write(self, oprot):
29736 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
29737 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
29738 
      return
29739 
    oprot.writeStructBegin('getPlansForOperator_args')
29740 
    if self.operatorId is not None:
29741 
      oprot.writeFieldBegin('operatorId', TType.I64, 1)
29742 
      oprot.writeI64(self.operatorId)
29743 
      oprot.writeFieldEnd()
29744 
    oprot.writeFieldStop()
29745 
    oprot.writeStructEnd()
29746 
 
29747 
  def validate(self):
29748 
    return
29749 
 
29750 
 
29751 
  def __repr__(self):
29752 
    L = ['%s=%r' % (key, value)
29753 
      for key, value in self.__dict__.iteritems()]
29754 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
29755 
 
29756 
  def __eq__(self, other):
29757 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
29758 
 
29759 
  def __ne__(self, other):
29760 
    return not (self == other)
29761 
 
29762 
class getPlansForOperator_result:
29763 
  """
29764 
  Attributes:
29765 
   - success
29766 
  """
29767 
 
29768 
  thrift_spec = (
29769 
    (0, TType.LIST, 'success', (TType.STRUCT,(RechargePlan, RechargePlan.thrift_spec)), None, ), # 0
29770 
  )
29771 
 
29772 
  def __init__(self, success=None,):
29773 
    self.success = success
29774 
 
29775 
  def read(self, iprot):
29776 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
29777 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
29778 
      return
29779 
    iprot.readStructBegin()
29780 
    while True:
29781 
      (fname, ftype, fid) = iprot.readFieldBegin()
29782 
      if ftype == TType.STOP:
29783 
        break
29784 
      if fid == 0:
29785 
        if ftype == TType.LIST:
29786 
          self.success = []
6188 rajveer 29787 
          (_etype696, _size693) = iprot.readListBegin()
29788 
          for _i697 in xrange(_size693):
29789 
            _elem698 = RechargePlan()
29790 
            _elem698.read(iprot)
29791 
            self.success.append(_elem698)
6159 rajveer 29792 
          iprot.readListEnd()
29793 
        else:
29794 
          iprot.skip(ftype)
29795 
      else:
29796 
        iprot.skip(ftype)
29797 
      iprot.readFieldEnd()
29798 
    iprot.readStructEnd()
29799 
 
29800 
  def write(self, oprot):
29801 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
29802 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
29803 
      return
29804 
    oprot.writeStructBegin('getPlansForOperator_result')
29805 
    if self.success is not None:
29806 
      oprot.writeFieldBegin('success', TType.LIST, 0)
29807 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 29808 
      for iter699 in self.success:
29809 
        iter699.write(oprot)
6159 rajveer 29810 
      oprot.writeListEnd()
29811 
      oprot.writeFieldEnd()
29812 
    oprot.writeFieldStop()
29813 
    oprot.writeStructEnd()
29814 
 
29815 
  def validate(self):
29816 
    return
29817 
 
29818 
 
29819 
  def __repr__(self):
29820 
    L = ['%s=%r' % (key, value)
29821 
      for key, value in self.__dict__.iteritems()]
29822 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
29823 
 
29824 
  def __eq__(self, other):
29825 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
29826 
 
29827 
  def __ne__(self, other):
29828 
    return not (self == other)
6289 anupam.sin 29829 
 
29830 
class getRechargeDenominations_args:
29831 
  """
29832 
  Attributes:
29833 
   - operatorId
6307 anupam.sin 29834 
   - circleCode
6289 anupam.sin 29835 
   - denominationType
29836 
  """
29837 
 
29838 
  thrift_spec = (
29839 
    None, # 0
29840 
    (1, TType.I64, 'operatorId', None, None, ), # 1
6307 anupam.sin 29841 
    (2, TType.STRING, 'circleCode', None, None, ), # 2
6289 anupam.sin 29842 
    (3, TType.I32, 'denominationType', None, None, ), # 3
29843 
  )
29844 
 
6307 anupam.sin 29845 
  def __init__(self, operatorId=None, circleCode=None, denominationType=None,):
6289 anupam.sin 29846 
    self.operatorId = operatorId
6307 anupam.sin 29847 
    self.circleCode = circleCode
6289 anupam.sin 29848 
    self.denominationType = denominationType
29849 
 
29850 
  def read(self, iprot):
29851 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
29852 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
29853 
      return
29854 
    iprot.readStructBegin()
29855 
    while True:
29856 
      (fname, ftype, fid) = iprot.readFieldBegin()
29857 
      if ftype == TType.STOP:
29858 
        break
29859 
      if fid == 1:
29860 
        if ftype == TType.I64:
29861 
          self.operatorId = iprot.readI64();
29862 
        else:
29863 
          iprot.skip(ftype)
29864 
      elif fid == 2:
29865 
        if ftype == TType.STRING:
6307 anupam.sin 29866 
          self.circleCode = iprot.readString();
6289 anupam.sin 29867 
        else:
29868 
          iprot.skip(ftype)
29869 
      elif fid == 3:
29870 
        if ftype == TType.I32:
29871 
          self.denominationType = iprot.readI32();
29872 
        else:
29873 
          iprot.skip(ftype)
29874 
      else:
29875 
        iprot.skip(ftype)
29876 
      iprot.readFieldEnd()
29877 
    iprot.readStructEnd()
29878 
 
29879 
  def write(self, oprot):
29880 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
29881 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
29882 
      return
29883 
    oprot.writeStructBegin('getRechargeDenominations_args')
29884 
    if self.operatorId is not None:
29885 
      oprot.writeFieldBegin('operatorId', TType.I64, 1)
29886 
      oprot.writeI64(self.operatorId)
29887 
      oprot.writeFieldEnd()
6307 anupam.sin 29888 
    if self.circleCode is not None:
29889 
      oprot.writeFieldBegin('circleCode', TType.STRING, 2)
29890 
      oprot.writeString(self.circleCode)
6289 anupam.sin 29891 
      oprot.writeFieldEnd()
29892 
    if self.denominationType is not None:
29893 
      oprot.writeFieldBegin('denominationType', TType.I32, 3)
29894 
      oprot.writeI32(self.denominationType)
29895 
      oprot.writeFieldEnd()
29896 
    oprot.writeFieldStop()
29897 
    oprot.writeStructEnd()
29898 
 
29899 
  def validate(self):
29900 
    return
29901 
 
29902 
 
29903 
  def __repr__(self):
29904 
    L = ['%s=%r' % (key, value)
29905 
      for key, value in self.__dict__.iteritems()]
29906 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
29907 
 
29908 
  def __eq__(self, other):
29909 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
29910 
 
29911 
  def __ne__(self, other):
29912 
    return not (self == other)
29913 
 
29914 
class getRechargeDenominations_result:
29915 
  """
29916 
  Attributes:
29917 
   - success
29918 
   - ex
29919 
  """
29920 
 
29921 
  thrift_spec = (
29922 
    (0, TType.LIST, 'success', (TType.STRUCT,(RechargeDenomination, RechargeDenomination.thrift_spec)), None, ), # 0
29923 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
29924 
  )
29925 
 
29926 
  def __init__(self, success=None, ex=None,):
29927 
    self.success = success
29928 
    self.ex = ex
29929 
 
29930 
  def read(self, iprot):
29931 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
29932 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
29933 
      return
29934 
    iprot.readStructBegin()
29935 
    while True:
29936 
      (fname, ftype, fid) = iprot.readFieldBegin()
29937 
      if ftype == TType.STOP:
29938 
        break
29939 
      if fid == 0:
29940 
        if ftype == TType.LIST:
29941 
          self.success = []
29942 
          (_etype703, _size700) = iprot.readListBegin()
29943 
          for _i704 in xrange(_size700):
29944 
            _elem705 = RechargeDenomination()
29945 
            _elem705.read(iprot)
29946 
            self.success.append(_elem705)
29947 
          iprot.readListEnd()
29948 
        else:
29949 
          iprot.skip(ftype)
29950 
      elif fid == 1:
29951 
        if ftype == TType.STRUCT:
29952 
          self.ex = TransactionServiceException()
29953 
          self.ex.read(iprot)
29954 
        else:
29955 
          iprot.skip(ftype)
29956 
      else:
29957 
        iprot.skip(ftype)
29958 
      iprot.readFieldEnd()
29959 
    iprot.readStructEnd()
29960 
 
29961 
  def write(self, oprot):
29962 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
29963 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
29964 
      return
29965 
    oprot.writeStructBegin('getRechargeDenominations_result')
29966 
    if self.success is not None:
29967 
      oprot.writeFieldBegin('success', TType.LIST, 0)
29968 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
29969 
      for iter706 in self.success:
29970 
        iter706.write(oprot)
29971 
      oprot.writeListEnd()
29972 
      oprot.writeFieldEnd()
29973 
    if self.ex is not None:
29974 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
29975 
      self.ex.write(oprot)
29976 
      oprot.writeFieldEnd()
29977 
    oprot.writeFieldStop()
29978 
    oprot.writeStructEnd()
29979 
 
29980 
  def validate(self):
29981 
    return
29982 
 
29983 
 
29984 
  def __repr__(self):
29985 
    L = ['%s=%r' % (key, value)
29986 
      for key, value in self.__dict__.iteritems()]
29987 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
29988 
 
29989 
  def __eq__(self, other):
29990 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
29991 
 
29992 
  def __ne__(self, other):
29993 
    return not (self == other)
6371 rajveer 29994 
 
29995 
class updateAvailabilityStatus_args:
29996 
  """
29997 
  Attributes:
29998 
   - operatorId
29999 
   - circleId
30000 
   - isAvailable
30001 
  """
30002 
 
30003 
  thrift_spec = (
30004 
    None, # 0
30005 
    (1, TType.I64, 'operatorId', None, None, ), # 1
30006 
    (2, TType.I64, 'circleId', None, None, ), # 2
30007 
    (3, TType.BOOL, 'isAvailable', None, None, ), # 3
30008 
  )
30009 
 
30010 
  def __init__(self, operatorId=None, circleId=None, isAvailable=None,):
30011 
    self.operatorId = operatorId
30012 
    self.circleId = circleId
30013 
    self.isAvailable = isAvailable
30014 
 
30015 
  def read(self, iprot):
30016 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
30017 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
30018 
      return
30019 
    iprot.readStructBegin()
30020 
    while True:
30021 
      (fname, ftype, fid) = iprot.readFieldBegin()
30022 
      if ftype == TType.STOP:
30023 
        break
30024 
      if fid == 1:
30025 
        if ftype == TType.I64:
30026 
          self.operatorId = iprot.readI64();
30027 
        else:
30028 
          iprot.skip(ftype)
30029 
      elif fid == 2:
30030 
        if ftype == TType.I64:
30031 
          self.circleId = iprot.readI64();
30032 
        else:
30033 
          iprot.skip(ftype)
30034 
      elif fid == 3:
30035 
        if ftype == TType.BOOL:
30036 
          self.isAvailable = iprot.readBool();
30037 
        else:
30038 
          iprot.skip(ftype)
30039 
      else:
30040 
        iprot.skip(ftype)
30041 
      iprot.readFieldEnd()
30042 
    iprot.readStructEnd()
30043 
 
30044 
  def write(self, oprot):
30045 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
30046 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
30047 
      return
30048 
    oprot.writeStructBegin('updateAvailabilityStatus_args')
30049 
    if self.operatorId is not None:
30050 
      oprot.writeFieldBegin('operatorId', TType.I64, 1)
30051 
      oprot.writeI64(self.operatorId)
30052 
      oprot.writeFieldEnd()
30053 
    if self.circleId is not None:
30054 
      oprot.writeFieldBegin('circleId', TType.I64, 2)
30055 
      oprot.writeI64(self.circleId)
30056 
      oprot.writeFieldEnd()
30057 
    if self.isAvailable is not None:
30058 
      oprot.writeFieldBegin('isAvailable', TType.BOOL, 3)
30059 
      oprot.writeBool(self.isAvailable)
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 updateAvailabilityStatus_result:
30080 
 
30081 
  thrift_spec = (
30082 
  )
30083 
 
30084 
  def read(self, iprot):
30085 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
30086 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
30087 
      return
30088 
    iprot.readStructBegin()
30089 
    while True:
30090 
      (fname, ftype, fid) = iprot.readFieldBegin()
30091 
      if ftype == TType.STOP:
30092 
        break
30093 
      else:
30094 
        iprot.skip(ftype)
30095 
      iprot.readFieldEnd()
30096 
    iprot.readStructEnd()
30097 
 
30098 
  def write(self, oprot):
30099 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
30100 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
30101 
      return
30102 
    oprot.writeStructBegin('updateAvailabilityStatus_result')
30103 
    oprot.writeFieldStop()
30104 
    oprot.writeStructEnd()
30105 
 
30106 
  def validate(self):
30107 
    return
30108 
 
30109 
 
30110 
  def __repr__(self):
30111 
    L = ['%s=%r' % (key, value)
30112 
      for key, value in self.__dict__.iteritems()]
30113 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
30114 
 
30115 
  def __eq__(self, other):
30116 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
30117 
 
30118 
  def __ne__(self, other):
30119 
    return not (self == other)
6389 rajveer 30120 
 
30121 
class getAvailableEmiSchemes_args:
30122 
 
30123 
  thrift_spec = (
30124 
  )
30125 
 
30126 
  def read(self, iprot):
30127 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
30128 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
30129 
      return
30130 
    iprot.readStructBegin()
30131 
    while True:
30132 
      (fname, ftype, fid) = iprot.readFieldBegin()
30133 
      if ftype == TType.STOP:
30134 
        break
30135 
      else:
30136 
        iprot.skip(ftype)
30137 
      iprot.readFieldEnd()
30138 
    iprot.readStructEnd()
30139 
 
30140 
  def write(self, oprot):
30141 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
30142 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
30143 
      return
30144 
    oprot.writeStructBegin('getAvailableEmiSchemes_args')
30145 
    oprot.writeFieldStop()
30146 
    oprot.writeStructEnd()
30147 
 
30148 
  def validate(self):
30149 
    return
30150 
 
30151 
 
30152 
  def __repr__(self):
30153 
    L = ['%s=%r' % (key, value)
30154 
      for key, value in self.__dict__.iteritems()]
30155 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
30156 
 
30157 
  def __eq__(self, other):
30158 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
30159 
 
30160 
  def __ne__(self, other):
30161 
    return not (self == other)
30162 
 
30163 
class getAvailableEmiSchemes_result:
30164 
  """
30165 
  Attributes:
30166 
   - success
30167 
  """
30168 
 
30169 
  thrift_spec = (
30170 
    (0, TType.LIST, 'success', (TType.STRUCT,(EmiScheme, EmiScheme.thrift_spec)), None, ), # 0
30171 
  )
30172 
 
30173 
  def __init__(self, success=None,):
30174 
    self.success = success
30175 
 
30176 
  def read(self, iprot):
30177 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
30178 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
30179 
      return
30180 
    iprot.readStructBegin()
30181 
    while True:
30182 
      (fname, ftype, fid) = iprot.readFieldBegin()
30183 
      if ftype == TType.STOP:
30184 
        break
30185 
      if fid == 0:
30186 
        if ftype == TType.LIST:
30187 
          self.success = []
30188 
          (_etype710, _size707) = iprot.readListBegin()
30189 
          for _i711 in xrange(_size707):
30190 
            _elem712 = EmiScheme()
30191 
            _elem712.read(iprot)
30192 
            self.success.append(_elem712)
30193 
          iprot.readListEnd()
30194 
        else:
30195 
          iprot.skip(ftype)
30196 
      else:
30197 
        iprot.skip(ftype)
30198 
      iprot.readFieldEnd()
30199 
    iprot.readStructEnd()
30200 
 
30201 
  def write(self, oprot):
30202 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
30203 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
30204 
      return
30205 
    oprot.writeStructBegin('getAvailableEmiSchemes_result')
30206 
    if self.success is not None:
30207 
      oprot.writeFieldBegin('success', TType.LIST, 0)
30208 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
30209 
      for iter713 in self.success:
30210 
        iter713.write(oprot)
30211 
      oprot.writeListEnd()
30212 
      oprot.writeFieldEnd()
30213 
    oprot.writeFieldStop()
30214 
    oprot.writeStructEnd()
30215 
 
30216 
  def validate(self):
30217 
    return
30218 
 
30219 
 
30220 
  def __repr__(self):
30221 
    L = ['%s=%r' % (key, value)
30222 
      for key, value in self.__dict__.iteritems()]
30223 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
30224 
 
30225 
  def __eq__(self, other):
30226 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
30227 
 
30228 
  def __ne__(self, other):
30229 
    return not (self == other)
30230 
 
30231 
class getMiscCharges_args:
30232 
  """
30233 
  Attributes:
30234 
   - transactionId
30235 
  """
30236 
 
30237 
  thrift_spec = (
30238 
    None, # 0
30239 
    (1, TType.I64, 'transactionId', None, None, ), # 1
30240 
  )
30241 
 
30242 
  def __init__(self, transactionId=None,):
30243 
    self.transactionId = transactionId
30244 
 
30245 
  def read(self, iprot):
30246 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
30247 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
30248 
      return
30249 
    iprot.readStructBegin()
30250 
    while True:
30251 
      (fname, ftype, fid) = iprot.readFieldBegin()
30252 
      if ftype == TType.STOP:
30253 
        break
30254 
      if fid == 1:
30255 
        if ftype == TType.I64:
30256 
          self.transactionId = iprot.readI64();
30257 
        else:
30258 
          iprot.skip(ftype)
30259 
      else:
30260 
        iprot.skip(ftype)
30261 
      iprot.readFieldEnd()
30262 
    iprot.readStructEnd()
30263 
 
30264 
  def write(self, oprot):
30265 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
30266 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
30267 
      return
30268 
    oprot.writeStructBegin('getMiscCharges_args')
30269 
    if self.transactionId is not None:
30270 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
30271 
      oprot.writeI64(self.transactionId)
30272 
      oprot.writeFieldEnd()
30273 
    oprot.writeFieldStop()
30274 
    oprot.writeStructEnd()
30275 
 
30276 
  def validate(self):
30277 
    return
30278 
 
30279 
 
30280 
  def __repr__(self):
30281 
    L = ['%s=%r' % (key, value)
30282 
      for key, value in self.__dict__.iteritems()]
30283 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
30284 
 
30285 
  def __eq__(self, other):
30286 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
30287 
 
30288 
  def __ne__(self, other):
30289 
    return not (self == other)
30290 
 
30291 
class getMiscCharges_result:
30292 
  """
30293 
  Attributes:
30294 
   - success
30295 
  """
30296 
 
30297 
  thrift_spec = (
6412 rajveer 30298 
    (0, TType.MAP, 'success', (TType.I64,None,TType.DOUBLE,None), None, ), # 0
6389 rajveer 30299 
  )
30300 
 
30301 
  def __init__(self, success=None,):
30302 
    self.success = success
30303 
 
30304 
  def read(self, iprot):
30305 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
30306 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
30307 
      return
30308 
    iprot.readStructBegin()
30309 
    while True:
30310 
      (fname, ftype, fid) = iprot.readFieldBegin()
30311 
      if ftype == TType.STOP:
30312 
        break
30313 
      if fid == 0:
30314 
        if ftype == TType.MAP:
30315 
          self.success = {}
30316 
          (_ktype715, _vtype716, _size714 ) = iprot.readMapBegin()
30317 
          for _i718 in xrange(_size714):
30318 
            _key719 = iprot.readI64();
6412 rajveer 30319 
            _val720 = iprot.readDouble();
6389 rajveer 30320 
            self.success[_key719] = _val720
30321 
          iprot.readMapEnd()
30322 
        else:
30323 
          iprot.skip(ftype)
30324 
      else:
30325 
        iprot.skip(ftype)
30326 
      iprot.readFieldEnd()
30327 
    iprot.readStructEnd()
30328 
 
30329 
  def write(self, oprot):
30330 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
30331 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
30332 
      return
30333 
    oprot.writeStructBegin('getMiscCharges_result')
30334 
    if self.success is not None:
30335 
      oprot.writeFieldBegin('success', TType.MAP, 0)
6412 rajveer 30336 
      oprot.writeMapBegin(TType.I64, TType.DOUBLE, len(self.success))
6389 rajveer 30337 
      for kiter721,viter722 in self.success.items():
30338 
        oprot.writeI64(kiter721)
6412 rajveer 30339 
        oprot.writeDouble(viter722)
6389 rajveer 30340 
      oprot.writeMapEnd()
30341 
      oprot.writeFieldEnd()
30342 
    oprot.writeFieldStop()
30343 
    oprot.writeStructEnd()
30344 
 
30345 
  def validate(self):
30346 
    return
30347 
 
30348 
 
30349 
  def __repr__(self):
30350 
    L = ['%s=%r' % (key, value)
30351 
      for key, value in self.__dict__.iteritems()]
30352 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
30353 
 
30354 
  def __eq__(self, other):
30355 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
30356 
 
30357 
  def __ne__(self, other):
30358 
    return not (self == other)
6507 anupam.sin 30359 
 
30360 
class refundRechargeOrder_args:
30361 
  """
30362 
  Attributes:
30363 
   - rechargeOrderId
30364 
  """
30365 
 
30366 
  thrift_spec = (
30367 
    None, # 0
30368 
    (1, TType.I64, 'rechargeOrderId', None, None, ), # 1
30369 
  )
30370 
 
30371 
  def __init__(self, rechargeOrderId=None,):
30372 
    self.rechargeOrderId = rechargeOrderId
30373 
 
30374 
  def read(self, iprot):
30375 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
30376 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
30377 
      return
30378 
    iprot.readStructBegin()
30379 
    while True:
30380 
      (fname, ftype, fid) = iprot.readFieldBegin()
30381 
      if ftype == TType.STOP:
30382 
        break
30383 
      if fid == 1:
30384 
        if ftype == TType.I64:
30385 
          self.rechargeOrderId = iprot.readI64();
30386 
        else:
30387 
          iprot.skip(ftype)
30388 
      else:
30389 
        iprot.skip(ftype)
30390 
      iprot.readFieldEnd()
30391 
    iprot.readStructEnd()
30392 
 
30393 
  def write(self, oprot):
30394 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
30395 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
30396 
      return
30397 
    oprot.writeStructBegin('refundRechargeOrder_args')
30398 
    if self.rechargeOrderId is not None:
30399 
      oprot.writeFieldBegin('rechargeOrderId', TType.I64, 1)
30400 
      oprot.writeI64(self.rechargeOrderId)
30401 
      oprot.writeFieldEnd()
30402 
    oprot.writeFieldStop()
30403 
    oprot.writeStructEnd()
30404 
 
30405 
  def validate(self):
30406 
    return
30407 
 
30408 
 
30409 
  def __repr__(self):
30410 
    L = ['%s=%r' % (key, value)
30411 
      for key, value in self.__dict__.iteritems()]
30412 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
30413 
 
30414 
  def __eq__(self, other):
30415 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
30416 
 
30417 
  def __ne__(self, other):
30418 
    return not (self == other)
30419 
 
30420 
class refundRechargeOrder_result:
30421 
  """
30422 
  Attributes:
30423 
   - success
30424 
   - ex
30425 
  """
30426 
 
30427 
  thrift_spec = (
30428 
    (0, TType.BOOL, 'success', None, None, ), # 0
30429 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
30430 
  )
30431 
 
30432 
  def __init__(self, success=None, ex=None,):
30433 
    self.success = success
30434 
    self.ex = ex
30435 
 
30436 
  def read(self, iprot):
30437 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
30438 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
30439 
      return
30440 
    iprot.readStructBegin()
30441 
    while True:
30442 
      (fname, ftype, fid) = iprot.readFieldBegin()
30443 
      if ftype == TType.STOP:
30444 
        break
30445 
      if fid == 0:
30446 
        if ftype == TType.BOOL:
30447 
          self.success = iprot.readBool();
30448 
        else:
30449 
          iprot.skip(ftype)
30450 
      elif fid == 1:
30451 
        if ftype == TType.STRUCT:
30452 
          self.ex = TransactionServiceException()
30453 
          self.ex.read(iprot)
30454 
        else:
30455 
          iprot.skip(ftype)
30456 
      else:
30457 
        iprot.skip(ftype)
30458 
      iprot.readFieldEnd()
30459 
    iprot.readStructEnd()
30460 
 
30461 
  def write(self, oprot):
30462 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
30463 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
30464 
      return
30465 
    oprot.writeStructBegin('refundRechargeOrder_result')
30466 
    if self.success is not None:
30467 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
30468 
      oprot.writeBool(self.success)
30469 
      oprot.writeFieldEnd()
30470 
    if self.ex is not None:
30471 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
30472 
      self.ex.write(oprot)
30473 
      oprot.writeFieldEnd()
30474 
    oprot.writeFieldStop()
30475 
    oprot.writeStructEnd()
30476 
 
30477 
  def validate(self):
30478 
    return
30479 
 
30480 
 
30481 
  def __repr__(self):
30482 
    L = ['%s=%r' % (key, value)
30483 
      for key, value in self.__dict__.iteritems()]
30484 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
30485 
 
30486 
  def __eq__(self, other):
30487 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
30488 
 
30489 
  def __ne__(self, other):
30490 
    return not (self == other)
6821 amar.kumar 30491 
 
30492 
class getPhysicalOrders_args:
30493 
  """
30494 
  Attributes:
30495 
   - fromDate
30496 
   - toDate
30497 
  """
30498 
 
30499 
  thrift_spec = (
30500 
    None, # 0
30501 
    (1, TType.I64, 'fromDate', None, None, ), # 1
30502 
    (2, TType.I64, 'toDate', None, None, ), # 2
30503 
  )
30504 
 
30505 
  def __init__(self, fromDate=None, toDate=None,):
30506 
    self.fromDate = fromDate
30507 
    self.toDate = toDate
30508 
 
30509 
  def read(self, iprot):
30510 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
30511 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
30512 
      return
30513 
    iprot.readStructBegin()
30514 
    while True:
30515 
      (fname, ftype, fid) = iprot.readFieldBegin()
30516 
      if ftype == TType.STOP:
30517 
        break
30518 
      if fid == 1:
30519 
        if ftype == TType.I64:
30520 
          self.fromDate = iprot.readI64();
30521 
        else:
30522 
          iprot.skip(ftype)
30523 
      elif fid == 2:
30524 
        if ftype == TType.I64:
30525 
          self.toDate = iprot.readI64();
30526 
        else:
30527 
          iprot.skip(ftype)
30528 
      else:
30529 
        iprot.skip(ftype)
30530 
      iprot.readFieldEnd()
30531 
    iprot.readStructEnd()
30532 
 
30533 
  def write(self, oprot):
30534 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
30535 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
30536 
      return
30537 
    oprot.writeStructBegin('getPhysicalOrders_args')
30538 
    if self.fromDate is not None:
30539 
      oprot.writeFieldBegin('fromDate', TType.I64, 1)
30540 
      oprot.writeI64(self.fromDate)
30541 
      oprot.writeFieldEnd()
30542 
    if self.toDate is not None:
30543 
      oprot.writeFieldBegin('toDate', TType.I64, 2)
30544 
      oprot.writeI64(self.toDate)
30545 
      oprot.writeFieldEnd()
30546 
    oprot.writeFieldStop()
30547 
    oprot.writeStructEnd()
30548 
 
30549 
  def validate(self):
30550 
    return
30551 
 
30552 
 
30553 
  def __repr__(self):
30554 
    L = ['%s=%r' % (key, value)
30555 
      for key, value in self.__dict__.iteritems()]
30556 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
30557 
 
30558 
  def __eq__(self, other):
30559 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
30560 
 
30561 
  def __ne__(self, other):
30562 
    return not (self == other)
30563 
 
30564 
class getPhysicalOrders_result:
30565 
  """
30566 
  Attributes:
30567 
   - success
30568 
  """
30569 
 
30570 
  thrift_spec = (
30571 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
30572 
  )
30573 
 
30574 
  def __init__(self, success=None,):
30575 
    self.success = success
30576 
 
30577 
  def read(self, iprot):
30578 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
30579 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
30580 
      return
30581 
    iprot.readStructBegin()
30582 
    while True:
30583 
      (fname, ftype, fid) = iprot.readFieldBegin()
30584 
      if ftype == TType.STOP:
30585 
        break
30586 
      if fid == 0:
30587 
        if ftype == TType.LIST:
30588 
          self.success = []
30589 
          (_etype726, _size723) = iprot.readListBegin()
30590 
          for _i727 in xrange(_size723):
30591 
            _elem728 = Order()
30592 
            _elem728.read(iprot)
30593 
            self.success.append(_elem728)
30594 
          iprot.readListEnd()
30595 
        else:
30596 
          iprot.skip(ftype)
30597 
      else:
30598 
        iprot.skip(ftype)
30599 
      iprot.readFieldEnd()
30600 
    iprot.readStructEnd()
30601 
 
30602 
  def write(self, oprot):
30603 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
30604 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
30605 
      return
30606 
    oprot.writeStructBegin('getPhysicalOrders_result')
30607 
    if self.success is not None:
30608 
      oprot.writeFieldBegin('success', TType.LIST, 0)
30609 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
30610 
      for iter729 in self.success:
30611 
        iter729.write(oprot)
30612 
      oprot.writeListEnd()
30613 
      oprot.writeFieldEnd()
30614 
    oprot.writeFieldStop()
30615 
    oprot.writeStructEnd()
30616 
 
30617 
  def validate(self):
30618 
    return
30619 
 
30620 
 
30621 
  def __repr__(self):
30622 
    L = ['%s=%r' % (key, value)
30623 
      for key, value in self.__dict__.iteritems()]
30624 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
30625 
 
30626 
  def __eq__(self, other):
30627 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
30628 
 
30629 
  def __ne__(self, other):
30630 
    return not (self == other)
6906 rajveer 30631 
 
30632 
class getDocument_args:
30633 
  """
30634 
  Attributes:
30635 
   - docType
30636 
   - docSource
30637 
  """
30638 
 
30639 
  thrift_spec = (
30640 
    None, # 0
30641 
    (1, TType.I64, 'docType', None, None, ), # 1
30642 
    (2, TType.I64, 'docSource', None, None, ), # 2
30643 
  )
30644 
 
30645 
  def __init__(self, docType=None, docSource=None,):
30646 
    self.docType = docType
30647 
    self.docSource = docSource
30648 
 
30649 
  def read(self, iprot):
30650 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
30651 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
30652 
      return
30653 
    iprot.readStructBegin()
30654 
    while True:
30655 
      (fname, ftype, fid) = iprot.readFieldBegin()
30656 
      if ftype == TType.STOP:
30657 
        break
30658 
      if fid == 1:
30659 
        if ftype == TType.I64:
30660 
          self.docType = iprot.readI64();
30661 
        else:
30662 
          iprot.skip(ftype)
30663 
      elif fid == 2:
30664 
        if ftype == TType.I64:
30665 
          self.docSource = iprot.readI64();
30666 
        else:
30667 
          iprot.skip(ftype)
30668 
      else:
30669 
        iprot.skip(ftype)
30670 
      iprot.readFieldEnd()
30671 
    iprot.readStructEnd()
30672 
 
30673 
  def write(self, oprot):
30674 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
30675 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
30676 
      return
30677 
    oprot.writeStructBegin('getDocument_args')
30678 
    if self.docType is not None:
30679 
      oprot.writeFieldBegin('docType', TType.I64, 1)
30680 
      oprot.writeI64(self.docType)
30681 
      oprot.writeFieldEnd()
30682 
    if self.docSource is not None:
30683 
      oprot.writeFieldBegin('docSource', TType.I64, 2)
30684 
      oprot.writeI64(self.docSource)
30685 
      oprot.writeFieldEnd()
30686 
    oprot.writeFieldStop()
30687 
    oprot.writeStructEnd()
30688 
 
30689 
  def validate(self):
30690 
    return
30691 
 
30692 
 
30693 
  def __repr__(self):
30694 
    L = ['%s=%r' % (key, value)
30695 
      for key, value in self.__dict__.iteritems()]
30696 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
30697 
 
30698 
  def __eq__(self, other):
30699 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
30700 
 
30701 
  def __ne__(self, other):
30702 
    return not (self == other)
30703 
 
30704 
class getDocument_result:
30705 
  """
30706 
  Attributes:
30707 
   - success
30708 
  """
30709 
 
30710 
  thrift_spec = (
30711 
    (0, TType.STRING, 'success', None, None, ), # 0
30712 
  )
30713 
 
30714 
  def __init__(self, success=None,):
30715 
    self.success = success
30716 
 
30717 
  def read(self, iprot):
30718 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
30719 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
30720 
      return
30721 
    iprot.readStructBegin()
30722 
    while True:
30723 
      (fname, ftype, fid) = iprot.readFieldBegin()
30724 
      if ftype == TType.STOP:
30725 
        break
30726 
      if fid == 0:
30727 
        if ftype == TType.STRING:
30728 
          self.success = iprot.readString();
30729 
        else:
30730 
          iprot.skip(ftype)
30731 
      else:
30732 
        iprot.skip(ftype)
30733 
      iprot.readFieldEnd()
30734 
    iprot.readStructEnd()
30735 
 
30736 
  def write(self, oprot):
30737 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
30738 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
30739 
      return
30740 
    oprot.writeStructBegin('getDocument_result')
30741 
    if self.success is not None:
30742 
      oprot.writeFieldBegin('success', TType.STRING, 0)
30743 
      oprot.writeString(self.success)
30744 
      oprot.writeFieldEnd()
30745 
    oprot.writeFieldStop()
30746 
    oprot.writeStructEnd()
30747 
 
30748 
  def validate(self):
30749 
    return
30750 
 
30751 
 
30752 
  def __repr__(self):
30753 
    L = ['%s=%r' % (key, value)
30754 
      for key, value in self.__dict__.iteritems()]
30755 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
30756 
 
30757 
  def __eq__(self, other):
30758 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
30759 
 
30760 
  def __ne__(self, other):
30761 
    return not (self == other)
6985 anupam.sin 30762 
 
30763 
class changeShippingAddress_args:
30764 
  """
30765 
  Attributes:
30766 
   - orderId
30767 
   - line1
30768 
   - line2
30769 
   - city
30770 
   - state
30771 
   - pin
30772 
  """
30773 
 
30774 
  thrift_spec = (
30775 
    None, # 0
30776 
    (1, TType.I64, 'orderId', None, None, ), # 1
30777 
    (2, TType.STRING, 'line1', None, None, ), # 2
30778 
    (3, TType.STRING, 'line2', None, None, ), # 3
30779 
    (4, TType.STRING, 'city', None, None, ), # 4
30780 
    (5, TType.STRING, 'state', None, None, ), # 5
30781 
    (6, TType.STRING, 'pin', None, None, ), # 6
30782 
  )
30783 
 
30784 
  def __init__(self, orderId=None, line1=None, line2=None, city=None, state=None, pin=None,):
30785 
    self.orderId = orderId
30786 
    self.line1 = line1
30787 
    self.line2 = line2
30788 
    self.city = city
30789 
    self.state = state
30790 
    self.pin = pin
30791 
 
30792 
  def read(self, iprot):
30793 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
30794 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
30795 
      return
30796 
    iprot.readStructBegin()
30797 
    while True:
30798 
      (fname, ftype, fid) = iprot.readFieldBegin()
30799 
      if ftype == TType.STOP:
30800 
        break
30801 
      if fid == 1:
30802 
        if ftype == TType.I64:
30803 
          self.orderId = iprot.readI64();
30804 
        else:
30805 
          iprot.skip(ftype)
30806 
      elif fid == 2:
30807 
        if ftype == TType.STRING:
30808 
          self.line1 = iprot.readString();
30809 
        else:
30810 
          iprot.skip(ftype)
30811 
      elif fid == 3:
30812 
        if ftype == TType.STRING:
30813 
          self.line2 = iprot.readString();
30814 
        else:
30815 
          iprot.skip(ftype)
30816 
      elif fid == 4:
30817 
        if ftype == TType.STRING:
30818 
          self.city = iprot.readString();
30819 
        else:
30820 
          iprot.skip(ftype)
30821 
      elif fid == 5:
30822 
        if ftype == TType.STRING:
30823 
          self.state = iprot.readString();
30824 
        else:
30825 
          iprot.skip(ftype)
30826 
      elif fid == 6:
30827 
        if ftype == TType.STRING:
30828 
          self.pin = iprot.readString();
30829 
        else:
30830 
          iprot.skip(ftype)
30831 
      else:
30832 
        iprot.skip(ftype)
30833 
      iprot.readFieldEnd()
30834 
    iprot.readStructEnd()
30835 
 
30836 
  def write(self, oprot):
30837 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
30838 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
30839 
      return
30840 
    oprot.writeStructBegin('changeShippingAddress_args')
30841 
    if self.orderId is not None:
30842 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
30843 
      oprot.writeI64(self.orderId)
30844 
      oprot.writeFieldEnd()
30845 
    if self.line1 is not None:
30846 
      oprot.writeFieldBegin('line1', TType.STRING, 2)
30847 
      oprot.writeString(self.line1)
30848 
      oprot.writeFieldEnd()
30849 
    if self.line2 is not None:
30850 
      oprot.writeFieldBegin('line2', TType.STRING, 3)
30851 
      oprot.writeString(self.line2)
30852 
      oprot.writeFieldEnd()
30853 
    if self.city is not None:
30854 
      oprot.writeFieldBegin('city', TType.STRING, 4)
30855 
      oprot.writeString(self.city)
30856 
      oprot.writeFieldEnd()
30857 
    if self.state is not None:
30858 
      oprot.writeFieldBegin('state', TType.STRING, 5)
30859 
      oprot.writeString(self.state)
30860 
      oprot.writeFieldEnd()
30861 
    if self.pin is not None:
30862 
      oprot.writeFieldBegin('pin', TType.STRING, 6)
30863 
      oprot.writeString(self.pin)
30864 
      oprot.writeFieldEnd()
30865 
    oprot.writeFieldStop()
30866 
    oprot.writeStructEnd()
30867 
 
30868 
  def validate(self):
30869 
    return
30870 
 
30871 
 
30872 
  def __repr__(self):
30873 
    L = ['%s=%r' % (key, value)
30874 
      for key, value in self.__dict__.iteritems()]
30875 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
30876 
 
30877 
  def __eq__(self, other):
30878 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
30879 
 
30880 
  def __ne__(self, other):
30881 
    return not (self == other)
30882 
 
30883 
class changeShippingAddress_result:
30884 
  """
30885 
  Attributes:
30886 
   - success
30887 
  """
30888 
 
30889 
  thrift_spec = (
30890 
    (0, TType.BOOL, 'success', None, None, ), # 0
30891 
  )
30892 
 
30893 
  def __init__(self, success=None,):
30894 
    self.success = success
30895 
 
30896 
  def read(self, iprot):
30897 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
30898 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
30899 
      return
30900 
    iprot.readStructBegin()
30901 
    while True:
30902 
      (fname, ftype, fid) = iprot.readFieldBegin()
30903 
      if ftype == TType.STOP:
30904 
        break
30905 
      if fid == 0:
30906 
        if ftype == TType.BOOL:
30907 
          self.success = iprot.readBool();
30908 
        else:
30909 
          iprot.skip(ftype)
30910 
      else:
30911 
        iprot.skip(ftype)
30912 
      iprot.readFieldEnd()
30913 
    iprot.readStructEnd()
30914 
 
30915 
  def write(self, oprot):
30916 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
30917 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
30918 
      return
30919 
    oprot.writeStructBegin('changeShippingAddress_result')
30920 
    if self.success is not None:
30921 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
30922 
      oprot.writeBool(self.success)
30923 
      oprot.writeFieldEnd()
30924 
    oprot.writeFieldStop()
30925 
    oprot.writeStructEnd()
30926 
 
30927 
  def validate(self):
30928 
    return
30929 
 
30930 
 
30931 
  def __repr__(self):
30932 
    L = ['%s=%r' % (key, value)
30933 
      for key, value in self.__dict__.iteritems()]
30934 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
30935 
 
30936 
  def __eq__(self, other):
30937 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
30938 
 
30939 
  def __ne__(self, other):
30940 
    return not (self == other)
6988 rajveer 30941 
 
30942 
class retrieveInvoice_args:
30943 
  """
30944 
  Attributes:
30945 
   - orderId
7075 rajveer 30946 
   - userId
6988 rajveer 30947 
  """
30948 
 
30949 
  thrift_spec = (
30950 
    None, # 0
30951 
    (1, TType.I64, 'orderId', None, None, ), # 1
7075 rajveer 30952 
    (2, TType.I64, 'userId', None, None, ), # 2
6988 rajveer 30953 
  )
30954 
 
7075 rajveer 30955 
  def __init__(self, orderId=None, userId=None,):
6988 rajveer 30956 
    self.orderId = orderId
7075 rajveer 30957 
    self.userId = userId
6988 rajveer 30958 
 
30959 
  def read(self, iprot):
30960 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
30961 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
30962 
      return
30963 
    iprot.readStructBegin()
30964 
    while True:
30965 
      (fname, ftype, fid) = iprot.readFieldBegin()
30966 
      if ftype == TType.STOP:
30967 
        break
30968 
      if fid == 1:
30969 
        if ftype == TType.I64:
30970 
          self.orderId = iprot.readI64();
30971 
        else:
30972 
          iprot.skip(ftype)
7075 rajveer 30973 
      elif fid == 2:
30974 
        if ftype == TType.I64:
30975 
          self.userId = iprot.readI64();
30976 
        else:
30977 
          iprot.skip(ftype)
6988 rajveer 30978 
      else:
30979 
        iprot.skip(ftype)
30980 
      iprot.readFieldEnd()
30981 
    iprot.readStructEnd()
30982 
 
30983 
  def write(self, oprot):
30984 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
30985 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
30986 
      return
30987 
    oprot.writeStructBegin('retrieveInvoice_args')
30988 
    if self.orderId is not None:
30989 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
30990 
      oprot.writeI64(self.orderId)
30991 
      oprot.writeFieldEnd()
7075 rajveer 30992 
    if self.userId is not None:
30993 
      oprot.writeFieldBegin('userId', TType.I64, 2)
30994 
      oprot.writeI64(self.userId)
30995 
      oprot.writeFieldEnd()
6988 rajveer 30996 
    oprot.writeFieldStop()
30997 
    oprot.writeStructEnd()
30998 
 
30999 
  def validate(self):
31000 
    return
31001 
 
31002 
 
31003 
  def __repr__(self):
31004 
    L = ['%s=%r' % (key, value)
31005 
      for key, value in self.__dict__.iteritems()]
31006 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
31007 
 
31008 
  def __eq__(self, other):
31009 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
31010 
 
31011 
  def __ne__(self, other):
31012 
    return not (self == other)
31013 
 
31014 
class retrieveInvoice_result:
31015 
  """
31016 
  Attributes:
31017 
   - success
31018 
  """
31019 
 
31020 
  thrift_spec = (
31021 
    (0, TType.STRING, 'success', None, None, ), # 0
31022 
  )
31023 
 
31024 
  def __init__(self, success=None,):
31025 
    self.success = success
31026 
 
31027 
  def read(self, iprot):
31028 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
31029 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
31030 
      return
31031 
    iprot.readStructBegin()
31032 
    while True:
31033 
      (fname, ftype, fid) = iprot.readFieldBegin()
31034 
      if ftype == TType.STOP:
31035 
        break
31036 
      if fid == 0:
31037 
        if ftype == TType.STRING:
31038 
          self.success = iprot.readString();
31039 
        else:
31040 
          iprot.skip(ftype)
31041 
      else:
31042 
        iprot.skip(ftype)
31043 
      iprot.readFieldEnd()
31044 
    iprot.readStructEnd()
31045 
 
31046 
  def write(self, oprot):
31047 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
31048 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
31049 
      return
31050 
    oprot.writeStructBegin('retrieveInvoice_result')
31051 
    if self.success is not None:
31052 
      oprot.writeFieldBegin('success', TType.STRING, 0)
31053 
      oprot.writeString(self.success)
31054 
      oprot.writeFieldEnd()
31055 
    oprot.writeFieldStop()
31056 
    oprot.writeStructEnd()
31057 
 
31058 
  def validate(self):
31059 
    return
31060 
 
31061 
 
31062 
  def __repr__(self):
31063 
    L = ['%s=%r' % (key, value)
31064 
      for key, value in self.__dict__.iteritems()]
31065 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
31066 
 
31067 
  def __eq__(self, other):
31068 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
31069 
 
31070 
  def __ne__(self, other):
31071 
    return not (self == other)
7026 rajveer 31072 
 
31073 
class receiveUpdatesForRedExpress_args:
31074 
  """
31075 
  Attributes:
31076 
   - awbNumber
31077 
  """
31078 
 
31079 
  thrift_spec = (
31080 
    None, # 0
31081 
    (1, TType.STRING, 'awbNumber', None, None, ), # 1
31082 
  )
31083 
 
31084 
  def __init__(self, awbNumber=None,):
31085 
    self.awbNumber = awbNumber
31086 
 
31087 
  def read(self, iprot):
31088 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
31089 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
31090 
      return
31091 
    iprot.readStructBegin()
31092 
    while True:
31093 
      (fname, ftype, fid) = iprot.readFieldBegin()
31094 
      if ftype == TType.STOP:
31095 
        break
31096 
      if fid == 1:
31097 
        if ftype == TType.STRING:
31098 
          self.awbNumber = iprot.readString();
31099 
        else:
31100 
          iprot.skip(ftype)
31101 
      else:
31102 
        iprot.skip(ftype)
31103 
      iprot.readFieldEnd()
31104 
    iprot.readStructEnd()
31105 
 
31106 
  def write(self, oprot):
31107 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
31108 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
31109 
      return
31110 
    oprot.writeStructBegin('receiveUpdatesForRedExpress_args')
31111 
    if self.awbNumber is not None:
31112 
      oprot.writeFieldBegin('awbNumber', TType.STRING, 1)
31113 
      oprot.writeString(self.awbNumber)
31114 
      oprot.writeFieldEnd()
31115 
    oprot.writeFieldStop()
31116 
    oprot.writeStructEnd()
31117 
 
31118 
  def validate(self):
31119 
    return
31120 
 
31121 
 
31122 
  def __repr__(self):
31123 
    L = ['%s=%r' % (key, value)
31124 
      for key, value in self.__dict__.iteritems()]
31125 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
31126 
 
31127 
  def __eq__(self, other):
31128 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
31129 
 
31130 
  def __ne__(self, other):
31131 
    return not (self == other)
31132 
 
31133 
class receiveUpdatesForRedExpress_result:
31134 
  """
31135 
  Attributes:
31136 
   - success
31137 
  """
31138 
 
31139 
  thrift_spec = (
31140 
    (0, TType.LIST, 'success', (TType.STRING,None), None, ), # 0
31141 
  )
31142 
 
31143 
  def __init__(self, success=None,):
31144 
    self.success = success
31145 
 
31146 
  def read(self, iprot):
31147 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
31148 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
31149 
      return
31150 
    iprot.readStructBegin()
31151 
    while True:
31152 
      (fname, ftype, fid) = iprot.readFieldBegin()
31153 
      if ftype == TType.STOP:
31154 
        break
31155 
      if fid == 0:
31156 
        if ftype == TType.LIST:
31157 
          self.success = []
31158 
          (_etype733, _size730) = iprot.readListBegin()
31159 
          for _i734 in xrange(_size730):
31160 
            _elem735 = iprot.readString();
31161 
            self.success.append(_elem735)
31162 
          iprot.readListEnd()
31163 
        else:
31164 
          iprot.skip(ftype)
31165 
      else:
31166 
        iprot.skip(ftype)
31167 
      iprot.readFieldEnd()
31168 
    iprot.readStructEnd()
31169 
 
31170 
  def write(self, oprot):
31171 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
31172 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
31173 
      return
31174 
    oprot.writeStructBegin('receiveUpdatesForRedExpress_result')
31175 
    if self.success is not None:
31176 
      oprot.writeFieldBegin('success', TType.LIST, 0)
31177 
      oprot.writeListBegin(TType.STRING, len(self.success))
31178 
      for iter736 in self.success:
31179 
        oprot.writeString(iter736)
31180 
      oprot.writeListEnd()
31181 
      oprot.writeFieldEnd()
31182 
    oprot.writeFieldStop()
31183 
    oprot.writeStructEnd()
31184 
 
31185 
  def validate(self):
31186 
    return
31187 
 
31188 
 
31189 
  def __repr__(self):
31190 
    L = ['%s=%r' % (key, value)
31191 
      for key, value in self.__dict__.iteritems()]
31192 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
31193 
 
31194 
  def __eq__(self, other):
31195 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
31196 
 
31197 
  def __ne__(self, other):
31198 
    return not (self == other)
7073 anupam.sin 31199 
 
31200 
class createRechargeTransaction_args:
31201 
  """
31202 
  Attributes:
31203 
   - thriftRechargeTransaction
31204 
  """
31205 
 
31206 
  thrift_spec = (
31207 
    None, # 0
31208 
    (1, TType.STRUCT, 'thriftRechargeTransaction', (RechargeTransaction, RechargeTransaction.thrift_spec), None, ), # 1
31209 
  )
31210 
 
31211 
  def __init__(self, thriftRechargeTransaction=None,):
31212 
    self.thriftRechargeTransaction = thriftRechargeTransaction
31213 
 
31214 
  def read(self, iprot):
31215 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
31216 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
31217 
      return
31218 
    iprot.readStructBegin()
31219 
    while True:
31220 
      (fname, ftype, fid) = iprot.readFieldBegin()
31221 
      if ftype == TType.STOP:
31222 
        break
31223 
      if fid == 1:
31224 
        if ftype == TType.STRUCT:
31225 
          self.thriftRechargeTransaction = RechargeTransaction()
31226 
          self.thriftRechargeTransaction.read(iprot)
31227 
        else:
31228 
          iprot.skip(ftype)
31229 
      else:
31230 
        iprot.skip(ftype)
31231 
      iprot.readFieldEnd()
31232 
    iprot.readStructEnd()
31233 
 
31234 
  def write(self, oprot):
31235 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
31236 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
31237 
      return
31238 
    oprot.writeStructBegin('createRechargeTransaction_args')
31239 
    if self.thriftRechargeTransaction is not None:
31240 
      oprot.writeFieldBegin('thriftRechargeTransaction', TType.STRUCT, 1)
31241 
      self.thriftRechargeTransaction.write(oprot)
31242 
      oprot.writeFieldEnd()
31243 
    oprot.writeFieldStop()
31244 
    oprot.writeStructEnd()
31245 
 
31246 
  def validate(self):
31247 
    return
31248 
 
31249 
 
31250 
  def __repr__(self):
31251 
    L = ['%s=%r' % (key, value)
31252 
      for key, value in self.__dict__.iteritems()]
31253 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
31254 
 
31255 
  def __eq__(self, other):
31256 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
31257 
 
31258 
  def __ne__(self, other):
31259 
    return not (self == other)
31260 
 
31261 
class createRechargeTransaction_result:
31262 
  """
31263 
  Attributes:
31264 
   - success
31265 
  """
31266 
 
31267 
  thrift_spec = (
31268 
    (0, TType.STRUCT, 'success', (RechargeTransaction, RechargeTransaction.thrift_spec), None, ), # 0
31269 
  )
31270 
 
31271 
  def __init__(self, success=None,):
31272 
    self.success = success
31273 
 
31274 
  def read(self, iprot):
31275 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
31276 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
31277 
      return
31278 
    iprot.readStructBegin()
31279 
    while True:
31280 
      (fname, ftype, fid) = iprot.readFieldBegin()
31281 
      if ftype == TType.STOP:
31282 
        break
31283 
      if fid == 0:
31284 
        if ftype == TType.STRUCT:
31285 
          self.success = RechargeTransaction()
31286 
          self.success.read(iprot)
31287 
        else:
31288 
          iprot.skip(ftype)
31289 
      else:
31290 
        iprot.skip(ftype)
31291 
      iprot.readFieldEnd()
31292 
    iprot.readStructEnd()
31293 
 
31294 
  def write(self, oprot):
31295 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
31296 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
31297 
      return
31298 
    oprot.writeStructBegin('createRechargeTransaction_result')
31299 
    if self.success is not None:
31300 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
31301 
      self.success.write(oprot)
31302 
      oprot.writeFieldEnd()
31303 
    oprot.writeFieldStop()
31304 
    oprot.writeStructEnd()
31305 
 
31306 
  def validate(self):
31307 
    return
31308 
 
31309 
 
31310 
  def __repr__(self):
31311 
    L = ['%s=%r' % (key, value)
31312 
      for key, value in self.__dict__.iteritems()]
31313 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
31314 
 
31315 
  def __eq__(self, other):
31316 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
31317 
 
31318 
  def __ne__(self, other):
31319 
    return not (self == other)
7080 anupam.sin 31320 
 
7085 rajveer 31321 
class getRechargeTransactions_args:
31322 
  """
31323 
  Attributes:
31324 
   - storeId
31325 
  """
31326 
 
31327 
  thrift_spec = (
31328 
    None, # 0
31329 
    (1, TType.I64, 'storeId', None, None, ), # 1
31330 
  )
31331 
 
31332 
  def __init__(self, storeId=None,):
31333 
    self.storeId = storeId
31334 
 
31335 
  def read(self, iprot):
31336 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
31337 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
31338 
      return
31339 
    iprot.readStructBegin()
31340 
    while True:
31341 
      (fname, ftype, fid) = iprot.readFieldBegin()
31342 
      if ftype == TType.STOP:
31343 
        break
31344 
      if fid == 1:
31345 
        if ftype == TType.I64:
31346 
          self.storeId = iprot.readI64();
31347 
        else:
31348 
          iprot.skip(ftype)
31349 
      else:
31350 
        iprot.skip(ftype)
31351 
      iprot.readFieldEnd()
31352 
    iprot.readStructEnd()
31353 
 
31354 
  def write(self, oprot):
31355 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
31356 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
31357 
      return
31358 
    oprot.writeStructBegin('getRechargeTransactions_args')
31359 
    if self.storeId is not None:
31360 
      oprot.writeFieldBegin('storeId', TType.I64, 1)
31361 
      oprot.writeI64(self.storeId)
31362 
      oprot.writeFieldEnd()
31363 
    oprot.writeFieldStop()
31364 
    oprot.writeStructEnd()
31365 
 
31366 
  def validate(self):
31367 
    return
31368 
 
31369 
 
31370 
  def __repr__(self):
31371 
    L = ['%s=%r' % (key, value)
31372 
      for key, value in self.__dict__.iteritems()]
31373 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
31374 
 
31375 
  def __eq__(self, other):
31376 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
31377 
 
31378 
  def __ne__(self, other):
31379 
    return not (self == other)
31380 
 
31381 
class getRechargeTransactions_result:
31382 
  """
31383 
  Attributes:
31384 
   - success
31385 
  """
31386 
 
31387 
  thrift_spec = (
31388 
    (0, TType.LIST, 'success', (TType.STRUCT,(RechargeTransaction, RechargeTransaction.thrift_spec)), None, ), # 0
31389 
  )
31390 
 
31391 
  def __init__(self, success=None,):
31392 
    self.success = success
31393 
 
31394 
  def read(self, iprot):
31395 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
31396 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
31397 
      return
31398 
    iprot.readStructBegin()
31399 
    while True:
31400 
      (fname, ftype, fid) = iprot.readFieldBegin()
31401 
      if ftype == TType.STOP:
31402 
        break
31403 
      if fid == 0:
31404 
        if ftype == TType.LIST:
31405 
          self.success = []
31406 
          (_etype740, _size737) = iprot.readListBegin()
31407 
          for _i741 in xrange(_size737):
31408 
            _elem742 = RechargeTransaction()
31409 
            _elem742.read(iprot)
31410 
            self.success.append(_elem742)
31411 
          iprot.readListEnd()
31412 
        else:
31413 
          iprot.skip(ftype)
31414 
      else:
31415 
        iprot.skip(ftype)
31416 
      iprot.readFieldEnd()
31417 
    iprot.readStructEnd()
31418 
 
31419 
  def write(self, oprot):
31420 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
31421 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
31422 
      return
31423 
    oprot.writeStructBegin('getRechargeTransactions_result')
31424 
    if self.success is not None:
31425 
      oprot.writeFieldBegin('success', TType.LIST, 0)
31426 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
31427 
      for iter743 in self.success:
31428 
        iter743.write(oprot)
31429 
      oprot.writeListEnd()
31430 
      oprot.writeFieldEnd()
31431 
    oprot.writeFieldStop()
31432 
    oprot.writeStructEnd()
31433 
 
31434 
  def validate(self):
31435 
    return
31436 
 
31437 
 
31438 
  def __repr__(self):
31439 
    L = ['%s=%r' % (key, value)
31440 
      for key, value in self.__dict__.iteritems()]
31441 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
31442 
 
31443 
  def __eq__(self, other):
31444 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
31445 
 
31446 
  def __ne__(self, other):
31447 
    return not (self == other)
31448 
 
7151 amit.gupta 31449 
class getRechargeTrans_args:
31450 
  """
31451 
  Attributes:
31452 
   - storeId
31453 
   - startDate
31454 
   - endDate
31455 
   - status
31456 
  """
31457 
 
31458 
  thrift_spec = (
31459 
    None, # 0
31460 
    (1, TType.I64, 'storeId', None, None, ), # 1
31461 
    (2, TType.I64, 'startDate', None, None, ), # 2
31462 
    (3, TType.I64, 'endDate', None, None, ), # 3
31463 
    (4, TType.I32, 'status', None, None, ), # 4
31464 
  )
31465 
 
31466 
  def __init__(self, storeId=None, startDate=None, endDate=None, status=None,):
31467 
    self.storeId = storeId
31468 
    self.startDate = startDate
31469 
    self.endDate = endDate
31470 
    self.status = status
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 == 1:
31482 
        if ftype == TType.I64:
31483 
          self.storeId = iprot.readI64();
31484 
        else:
31485 
          iprot.skip(ftype)
31486 
      elif fid == 2:
31487 
        if ftype == TType.I64:
31488 
          self.startDate = iprot.readI64();
31489 
        else:
31490 
          iprot.skip(ftype)
31491 
      elif fid == 3:
31492 
        if ftype == TType.I64:
31493 
          self.endDate = iprot.readI64();
31494 
        else:
31495 
          iprot.skip(ftype)
31496 
      elif fid == 4:
31497 
        if ftype == TType.I32:
31498 
          self.status = iprot.readI32();
31499 
        else:
31500 
          iprot.skip(ftype)
31501 
      else:
31502 
        iprot.skip(ftype)
31503 
      iprot.readFieldEnd()
31504 
    iprot.readStructEnd()
31505 
 
31506 
  def write(self, oprot):
31507 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
31508 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
31509 
      return
31510 
    oprot.writeStructBegin('getRechargeTrans_args')
31511 
    if self.storeId is not None:
31512 
      oprot.writeFieldBegin('storeId', TType.I64, 1)
31513 
      oprot.writeI64(self.storeId)
31514 
      oprot.writeFieldEnd()
31515 
    if self.startDate is not None:
31516 
      oprot.writeFieldBegin('startDate', TType.I64, 2)
31517 
      oprot.writeI64(self.startDate)
31518 
      oprot.writeFieldEnd()
31519 
    if self.endDate is not None:
31520 
      oprot.writeFieldBegin('endDate', TType.I64, 3)
31521 
      oprot.writeI64(self.endDate)
31522 
      oprot.writeFieldEnd()
31523 
    if self.status is not None:
31524 
      oprot.writeFieldBegin('status', TType.I32, 4)
31525 
      oprot.writeI32(self.status)
31526 
      oprot.writeFieldEnd()
31527 
    oprot.writeFieldStop()
31528 
    oprot.writeStructEnd()
31529 
 
31530 
  def validate(self):
31531 
    return
31532 
 
31533 
 
31534 
  def __repr__(self):
31535 
    L = ['%s=%r' % (key, value)
31536 
      for key, value in self.__dict__.iteritems()]
31537 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
31538 
 
31539 
  def __eq__(self, other):
31540 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
31541 
 
31542 
  def __ne__(self, other):
31543 
    return not (self == other)
31544 
 
31545 
class getRechargeTrans_result:
31546 
  """
31547 
  Attributes:
31548 
   - success
31549 
  """
31550 
 
31551 
  thrift_spec = (
31552 
    (0, TType.LIST, 'success', (TType.STRUCT,(RechargeTransaction, RechargeTransaction.thrift_spec)), None, ), # 0
31553 
  )
31554 
 
31555 
  def __init__(self, success=None,):
31556 
    self.success = success
31557 
 
31558 
  def read(self, iprot):
31559 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
31560 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
31561 
      return
31562 
    iprot.readStructBegin()
31563 
    while True:
31564 
      (fname, ftype, fid) = iprot.readFieldBegin()
31565 
      if ftype == TType.STOP:
31566 
        break
31567 
      if fid == 0:
31568 
        if ftype == TType.LIST:
31569 
          self.success = []
31570 
          (_etype747, _size744) = iprot.readListBegin()
31571 
          for _i748 in xrange(_size744):
31572 
            _elem749 = RechargeTransaction()
31573 
            _elem749.read(iprot)
31574 
            self.success.append(_elem749)
31575 
          iprot.readListEnd()
31576 
        else:
31577 
          iprot.skip(ftype)
31578 
      else:
31579 
        iprot.skip(ftype)
31580 
      iprot.readFieldEnd()
31581 
    iprot.readStructEnd()
31582 
 
31583 
  def write(self, oprot):
31584 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
31585 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
31586 
      return
31587 
    oprot.writeStructBegin('getRechargeTrans_result')
31588 
    if self.success is not None:
31589 
      oprot.writeFieldBegin('success', TType.LIST, 0)
31590 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
31591 
      for iter750 in self.success:
31592 
        iter750.write(oprot)
31593 
      oprot.writeListEnd()
31594 
      oprot.writeFieldEnd()
31595 
    oprot.writeFieldStop()
31596 
    oprot.writeStructEnd()
31597 
 
31598 
  def validate(self):
31599 
    return
31600 
 
31601 
 
31602 
  def __repr__(self):
31603 
    L = ['%s=%r' % (key, value)
31604 
      for key, value in self.__dict__.iteritems()]
31605 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
31606 
 
31607 
  def __eq__(self, other):
31608 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
31609 
 
31610 
  def __ne__(self, other):
31611 
    return not (self == other)
31612 
 
7080 anupam.sin 31613 
class getRechargeTransaction_args:
31614 
  """
31615 
  Attributes:
31616 
   - rechargeId
31617 
  """
31618 
 
31619 
  thrift_spec = (
31620 
    None, # 0
31621 
    (1, TType.I64, 'rechargeId', None, None, ), # 1
31622 
  )
31623 
 
31624 
  def __init__(self, rechargeId=None,):
31625 
    self.rechargeId = rechargeId
31626 
 
31627 
  def read(self, iprot):
31628 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
31629 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
31630 
      return
31631 
    iprot.readStructBegin()
31632 
    while True:
31633 
      (fname, ftype, fid) = iprot.readFieldBegin()
31634 
      if ftype == TType.STOP:
31635 
        break
31636 
      if fid == 1:
31637 
        if ftype == TType.I64:
31638 
          self.rechargeId = iprot.readI64();
31639 
        else:
31640 
          iprot.skip(ftype)
31641 
      else:
31642 
        iprot.skip(ftype)
31643 
      iprot.readFieldEnd()
31644 
    iprot.readStructEnd()
31645 
 
31646 
  def write(self, oprot):
31647 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
31648 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
31649 
      return
31650 
    oprot.writeStructBegin('getRechargeTransaction_args')
31651 
    if self.rechargeId is not None:
31652 
      oprot.writeFieldBegin('rechargeId', TType.I64, 1)
31653 
      oprot.writeI64(self.rechargeId)
31654 
      oprot.writeFieldEnd()
31655 
    oprot.writeFieldStop()
31656 
    oprot.writeStructEnd()
31657 
 
31658 
  def validate(self):
31659 
    return
31660 
 
31661 
 
31662 
  def __repr__(self):
31663 
    L = ['%s=%r' % (key, value)
31664 
      for key, value in self.__dict__.iteritems()]
31665 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
31666 
 
31667 
  def __eq__(self, other):
31668 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
31669 
 
31670 
  def __ne__(self, other):
31671 
    return not (self == other)
31672 
 
31673 
class getRechargeTransaction_result:
31674 
  """
31675 
  Attributes:
31676 
   - success
31677 
  """
31678 
 
31679 
  thrift_spec = (
31680 
    (0, TType.STRUCT, 'success', (RechargeTransaction, RechargeTransaction.thrift_spec), None, ), # 0
31681 
  )
31682 
 
31683 
  def __init__(self, success=None,):
31684 
    self.success = success
31685 
 
31686 
  def read(self, iprot):
31687 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
31688 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
31689 
      return
31690 
    iprot.readStructBegin()
31691 
    while True:
31692 
      (fname, ftype, fid) = iprot.readFieldBegin()
31693 
      if ftype == TType.STOP:
31694 
        break
31695 
      if fid == 0:
31696 
        if ftype == TType.STRUCT:
31697 
          self.success = RechargeTransaction()
31698 
          self.success.read(iprot)
31699 
        else:
31700 
          iprot.skip(ftype)
31701 
      else:
31702 
        iprot.skip(ftype)
31703 
      iprot.readFieldEnd()
31704 
    iprot.readStructEnd()
31705 
 
31706 
  def write(self, oprot):
31707 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
31708 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
31709 
      return
31710 
    oprot.writeStructBegin('getRechargeTransaction_result')
31711 
    if self.success is not None:
31712 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
31713 
      self.success.write(oprot)
31714 
      oprot.writeFieldEnd()
31715 
    oprot.writeFieldStop()
31716 
    oprot.writeStructEnd()
31717 
 
31718 
  def validate(self):
31719 
    return
31720 
 
31721 
 
31722 
  def __repr__(self):
31723 
    L = ['%s=%r' % (key, value)
31724 
      for key, value in self.__dict__.iteritems()]
31725 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
31726 
 
31727 
  def __eq__(self, other):
31728 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
31729 
 
31730 
  def __ne__(self, other):
31731 
    return not (self == other)
31732 
 
31733 
class getFRCs_args:
31734 
  """
31735 
  Attributes:
31736 
   - circleId
31737 
   - operatorId
31738 
  """
31739 
 
31740 
  thrift_spec = (
31741 
    None, # 0
31742 
    (1, TType.I64, 'circleId', None, None, ), # 1
31743 
    (2, TType.I64, 'operatorId', None, None, ), # 2
31744 
  )
31745 
 
31746 
  def __init__(self, circleId=None, operatorId=None,):
31747 
    self.circleId = circleId
31748 
    self.operatorId = operatorId
31749 
 
31750 
  def read(self, iprot):
31751 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
31752 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
31753 
      return
31754 
    iprot.readStructBegin()
31755 
    while True:
31756 
      (fname, ftype, fid) = iprot.readFieldBegin()
31757 
      if ftype == TType.STOP:
31758 
        break
31759 
      if fid == 1:
31760 
        if ftype == TType.I64:
31761 
          self.circleId = iprot.readI64();
31762 
        else:
31763 
          iprot.skip(ftype)
31764 
      elif fid == 2:
31765 
        if ftype == TType.I64:
31766 
          self.operatorId = iprot.readI64();
31767 
        else:
31768 
          iprot.skip(ftype)
31769 
      else:
31770 
        iprot.skip(ftype)
31771 
      iprot.readFieldEnd()
31772 
    iprot.readStructEnd()
31773 
 
31774 
  def write(self, oprot):
31775 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
31776 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
31777 
      return
31778 
    oprot.writeStructBegin('getFRCs_args')
31779 
    if self.circleId is not None:
31780 
      oprot.writeFieldBegin('circleId', TType.I64, 1)
31781 
      oprot.writeI64(self.circleId)
31782 
      oprot.writeFieldEnd()
31783 
    if self.operatorId is not None:
31784 
      oprot.writeFieldBegin('operatorId', TType.I64, 2)
31785 
      oprot.writeI64(self.operatorId)
31786 
      oprot.writeFieldEnd()
31787 
    oprot.writeFieldStop()
31788 
    oprot.writeStructEnd()
31789 
 
31790 
  def validate(self):
31791 
    return
31792 
 
31793 
 
31794 
  def __repr__(self):
31795 
    L = ['%s=%r' % (key, value)
31796 
      for key, value in self.__dict__.iteritems()]
31797 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
31798 
 
31799 
  def __eq__(self, other):
31800 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
31801 
 
31802 
  def __ne__(self, other):
31803 
    return not (self == other)
31804 
 
31805 
class getFRCs_result:
31806 
  """
31807 
  Attributes:
31808 
   - success
31809 
  """
31810 
 
31811 
  thrift_spec = (
31812 
    (0, TType.LIST, 'success', (TType.STRUCT,(FRC, FRC.thrift_spec)), None, ), # 0
31813 
  )
31814 
 
31815 
  def __init__(self, success=None,):
31816 
    self.success = success
31817 
 
31818 
  def read(self, iprot):
31819 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
31820 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
31821 
      return
31822 
    iprot.readStructBegin()
31823 
    while True:
31824 
      (fname, ftype, fid) = iprot.readFieldBegin()
31825 
      if ftype == TType.STOP:
31826 
        break
31827 
      if fid == 0:
31828 
        if ftype == TType.LIST:
31829 
          self.success = []
7151 amit.gupta 31830 
          (_etype754, _size751) = iprot.readListBegin()
31831 
          for _i755 in xrange(_size751):
31832 
            _elem756 = FRC()
31833 
            _elem756.read(iprot)
31834 
            self.success.append(_elem756)
7080 anupam.sin 31835 
          iprot.readListEnd()
31836 
        else:
31837 
          iprot.skip(ftype)
31838 
      else:
31839 
        iprot.skip(ftype)
31840 
      iprot.readFieldEnd()
31841 
    iprot.readStructEnd()
31842 
 
31843 
  def write(self, oprot):
31844 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
31845 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
31846 
      return
31847 
    oprot.writeStructBegin('getFRCs_result')
31848 
    if self.success is not None:
31849 
      oprot.writeFieldBegin('success', TType.LIST, 0)
31850 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
7151 amit.gupta 31851 
      for iter757 in self.success:
31852 
        iter757.write(oprot)
7080 anupam.sin 31853 
      oprot.writeListEnd()
31854 
      oprot.writeFieldEnd()
31855 
    oprot.writeFieldStop()
31856 
    oprot.writeStructEnd()
31857 
 
31858 
  def validate(self):
31859 
    return
31860 
 
31861 
 
31862 
  def __repr__(self):
31863 
    L = ['%s=%r' % (key, value)
31864 
      for key, value in self.__dict__.iteritems()]
31865 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
31866 
 
31867 
  def __eq__(self, other):
31868 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
31869 
 
31870 
  def __ne__(self, other):
31871 
    return not (self == other)
7096 anupam.sin 31872 
 
31873 
class getHotspotStore_args:
31874 
  """
31875 
  Attributes:
31876 
   - id
31877 
   - hotspotid
31878 
  """
31879 
 
31880 
  thrift_spec = (
31881 
    None, # 0
31882 
    (1, TType.I64, 'id', None, None, ), # 1
31883 
    (2, TType.STRING, 'hotspotid', None, None, ), # 2
31884 
  )
31885 
 
31886 
  def __init__(self, id=None, hotspotid=None,):
31887 
    self.id = id
31888 
    self.hotspotid = hotspotid
31889 
 
31890 
  def read(self, iprot):
31891 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
31892 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
31893 
      return
31894 
    iprot.readStructBegin()
31895 
    while True:
31896 
      (fname, ftype, fid) = iprot.readFieldBegin()
31897 
      if ftype == TType.STOP:
31898 
        break
31899 
      if fid == 1:
31900 
        if ftype == TType.I64:
31901 
          self.id = iprot.readI64();
31902 
        else:
31903 
          iprot.skip(ftype)
31904 
      elif fid == 2:
31905 
        if ftype == TType.STRING:
31906 
          self.hotspotid = iprot.readString();
31907 
        else:
31908 
          iprot.skip(ftype)
31909 
      else:
31910 
        iprot.skip(ftype)
31911 
      iprot.readFieldEnd()
31912 
    iprot.readStructEnd()
31913 
 
31914 
  def write(self, oprot):
31915 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
31916 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
31917 
      return
31918 
    oprot.writeStructBegin('getHotspotStore_args')
31919 
    if self.id is not None:
31920 
      oprot.writeFieldBegin('id', TType.I64, 1)
31921 
      oprot.writeI64(self.id)
31922 
      oprot.writeFieldEnd()
31923 
    if self.hotspotid is not None:
31924 
      oprot.writeFieldBegin('hotspotid', TType.STRING, 2)
31925 
      oprot.writeString(self.hotspotid)
31926 
      oprot.writeFieldEnd()
31927 
    oprot.writeFieldStop()
31928 
    oprot.writeStructEnd()
31929 
 
31930 
  def validate(self):
31931 
    return
31932 
 
31933 
 
31934 
  def __repr__(self):
31935 
    L = ['%s=%r' % (key, value)
31936 
      for key, value in self.__dict__.iteritems()]
31937 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
31938 
 
31939 
  def __eq__(self, other):
31940 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
31941 
 
31942 
  def __ne__(self, other):
31943 
    return not (self == other)
31944 
 
31945 
class getHotspotStore_result:
31946 
  """
31947 
  Attributes:
31948 
   - success
31949 
  """
31950 
 
31951 
  thrift_spec = (
31952 
    (0, TType.STRUCT, 'success', (HotspotStore, HotspotStore.thrift_spec), None, ), # 0
31953 
  )
31954 
 
31955 
  def __init__(self, success=None,):
31956 
    self.success = success
31957 
 
31958 
  def read(self, iprot):
31959 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
31960 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
31961 
      return
31962 
    iprot.readStructBegin()
31963 
    while True:
31964 
      (fname, ftype, fid) = iprot.readFieldBegin()
31965 
      if ftype == TType.STOP:
31966 
        break
31967 
      if fid == 0:
31968 
        if ftype == TType.STRUCT:
31969 
          self.success = HotspotStore()
31970 
          self.success.read(iprot)
31971 
        else:
31972 
          iprot.skip(ftype)
31973 
      else:
31974 
        iprot.skip(ftype)
31975 
      iprot.readFieldEnd()
31976 
    iprot.readStructEnd()
31977 
 
31978 
  def write(self, oprot):
31979 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
31980 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
31981 
      return
31982 
    oprot.writeStructBegin('getHotspotStore_result')
31983 
    if self.success is not None:
31984 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
31985 
      self.success.write(oprot)
31986 
      oprot.writeFieldEnd()
31987 
    oprot.writeFieldStop()
31988 
    oprot.writeStructEnd()
31989 
 
31990 
  def validate(self):
31991 
    return
31992 
 
31993 
 
31994 
  def __repr__(self):
31995 
    L = ['%s=%r' % (key, value)
31996 
      for key, value in self.__dict__.iteritems()]
31997 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
31998 
 
31999 
  def __eq__(self, other):
32000 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
32001 
 
32002 
  def __ne__(self, other):
32003 
    return not (self == other)
32004 
 
32005 
class getTelecomCircle_args:
32006 
  """
32007 
  Attributes:
32008 
   - id
32009 
   - code
32010 
  """
32011 
 
32012 
  thrift_spec = (
32013 
    None, # 0
32014 
    (1, TType.I64, 'id', None, None, ), # 1
32015 
    (2, TType.STRING, 'code', None, None, ), # 2
32016 
  )
32017 
 
32018 
  def __init__(self, id=None, code=None,):
32019 
    self.id = id
32020 
    self.code = code
32021 
 
32022 
  def read(self, iprot):
32023 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
32024 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
32025 
      return
32026 
    iprot.readStructBegin()
32027 
    while True:
32028 
      (fname, ftype, fid) = iprot.readFieldBegin()
32029 
      if ftype == TType.STOP:
32030 
        break
32031 
      if fid == 1:
32032 
        if ftype == TType.I64:
32033 
          self.id = iprot.readI64();
32034 
        else:
32035 
          iprot.skip(ftype)
32036 
      elif fid == 2:
32037 
        if ftype == TType.STRING:
32038 
          self.code = iprot.readString();
32039 
        else:
32040 
          iprot.skip(ftype)
32041 
      else:
32042 
        iprot.skip(ftype)
32043 
      iprot.readFieldEnd()
32044 
    iprot.readStructEnd()
32045 
 
32046 
  def write(self, oprot):
32047 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
32048 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
32049 
      return
32050 
    oprot.writeStructBegin('getTelecomCircle_args')
32051 
    if self.id is not None:
32052 
      oprot.writeFieldBegin('id', TType.I64, 1)
32053 
      oprot.writeI64(self.id)
32054 
      oprot.writeFieldEnd()
32055 
    if self.code is not None:
32056 
      oprot.writeFieldBegin('code', TType.STRING, 2)
32057 
      oprot.writeString(self.code)
32058 
      oprot.writeFieldEnd()
32059 
    oprot.writeFieldStop()
32060 
    oprot.writeStructEnd()
32061 
 
32062 
  def validate(self):
32063 
    return
32064 
 
32065 
 
32066 
  def __repr__(self):
32067 
    L = ['%s=%r' % (key, value)
32068 
      for key, value in self.__dict__.iteritems()]
32069 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
32070 
 
32071 
  def __eq__(self, other):
32072 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
32073 
 
32074 
  def __ne__(self, other):
32075 
    return not (self == other)
32076 
 
32077 
class getTelecomCircle_result:
32078 
  """
32079 
  Attributes:
32080 
   - success
32081 
  """
32082 
 
32083 
  thrift_spec = (
32084 
    (0, TType.STRUCT, 'success', (TelecomCircle, TelecomCircle.thrift_spec), None, ), # 0
32085 
  )
32086 
 
32087 
  def __init__(self, success=None,):
32088 
    self.success = success
32089 
 
32090 
  def read(self, iprot):
32091 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
32092 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
32093 
      return
32094 
    iprot.readStructBegin()
32095 
    while True:
32096 
      (fname, ftype, fid) = iprot.readFieldBegin()
32097 
      if ftype == TType.STOP:
32098 
        break
32099 
      if fid == 0:
32100 
        if ftype == TType.STRUCT:
32101 
          self.success = TelecomCircle()
32102 
          self.success.read(iprot)
32103 
        else:
32104 
          iprot.skip(ftype)
32105 
      else:
32106 
        iprot.skip(ftype)
32107 
      iprot.readFieldEnd()
32108 
    iprot.readStructEnd()
32109 
 
32110 
  def write(self, oprot):
32111 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
32112 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
32113 
      return
32114 
    oprot.writeStructBegin('getTelecomCircle_result')
32115 
    if self.success is not None:
32116 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
32117 
      self.success.write(oprot)
32118 
      oprot.writeFieldEnd()
32119 
    oprot.writeFieldStop()
32120 
    oprot.writeStructEnd()
32121 
 
32122 
  def validate(self):
32123 
    return
32124 
 
32125 
 
32126 
  def __repr__(self):
32127 
    L = ['%s=%r' % (key, value)
32128 
      for key, value in self.__dict__.iteritems()]
32129 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
32130 
 
32131 
  def __eq__(self, other):
32132 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
32133 
 
32134 
  def __ne__(self, other):
32135 
    return not (self == other)
7109 anupam.sin 32136 
 
32137 
class retrieveHotspotRechargeInvoice_args:
32138 
  """
32139 
  Attributes:
32140 
   - rechargeId
32141 
  """
32142 
 
32143 
  thrift_spec = (
32144 
    None, # 0
32145 
    (1, TType.I64, 'rechargeId', None, None, ), # 1
32146 
  )
32147 
 
32148 
  def __init__(self, rechargeId=None,):
32149 
    self.rechargeId = rechargeId
32150 
 
32151 
  def read(self, iprot):
32152 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
32153 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
32154 
      return
32155 
    iprot.readStructBegin()
32156 
    while True:
32157 
      (fname, ftype, fid) = iprot.readFieldBegin()
32158 
      if ftype == TType.STOP:
32159 
        break
32160 
      if fid == 1:
32161 
        if ftype == TType.I64:
32162 
          self.rechargeId = iprot.readI64();
32163 
        else:
32164 
          iprot.skip(ftype)
32165 
      else:
32166 
        iprot.skip(ftype)
32167 
      iprot.readFieldEnd()
32168 
    iprot.readStructEnd()
32169 
 
32170 
  def write(self, oprot):
32171 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
32172 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
32173 
      return
32174 
    oprot.writeStructBegin('retrieveHotspotRechargeInvoice_args')
32175 
    if self.rechargeId is not None:
32176 
      oprot.writeFieldBegin('rechargeId', TType.I64, 1)
32177 
      oprot.writeI64(self.rechargeId)
32178 
      oprot.writeFieldEnd()
32179 
    oprot.writeFieldStop()
32180 
    oprot.writeStructEnd()
32181 
 
32182 
  def validate(self):
32183 
    return
32184 
 
32185 
 
32186 
  def __repr__(self):
32187 
    L = ['%s=%r' % (key, value)
32188 
      for key, value in self.__dict__.iteritems()]
32189 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
32190 
 
32191 
  def __eq__(self, other):
32192 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
32193 
 
32194 
  def __ne__(self, other):
32195 
    return not (self == other)
32196 
 
32197 
class retrieveHotspotRechargeInvoice_result:
32198 
  """
32199 
  Attributes:
32200 
   - success
32201 
  """
32202 
 
32203 
  thrift_spec = (
32204 
    (0, TType.STRING, 'success', None, None, ), # 0
32205 
  )
32206 
 
32207 
  def __init__(self, success=None,):
32208 
    self.success = success
32209 
 
32210 
  def read(self, iprot):
32211 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
32212 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
32213 
      return
32214 
    iprot.readStructBegin()
32215 
    while True:
32216 
      (fname, ftype, fid) = iprot.readFieldBegin()
32217 
      if ftype == TType.STOP:
32218 
        break
32219 
      if fid == 0:
32220 
        if ftype == TType.STRING:
32221 
          self.success = iprot.readString();
32222 
        else:
32223 
          iprot.skip(ftype)
32224 
      else:
32225 
        iprot.skip(ftype)
32226 
      iprot.readFieldEnd()
32227 
    iprot.readStructEnd()
32228 
 
32229 
  def write(self, oprot):
32230 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
32231 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
32232 
      return
32233 
    oprot.writeStructBegin('retrieveHotspotRechargeInvoice_result')
32234 
    if self.success is not None:
32235 
      oprot.writeFieldBegin('success', TType.STRING, 0)
32236 
      oprot.writeString(self.success)
32237 
      oprot.writeFieldEnd()
32238 
    oprot.writeFieldStop()
32239 
    oprot.writeStructEnd()
32240 
 
32241 
  def validate(self):
32242 
    return
32243 
 
32244 
 
32245 
  def __repr__(self):
32246 
    L = ['%s=%r' % (key, value)
32247 
      for key, value in self.__dict__.iteritems()]
32248 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
32249 
 
32250 
  def __eq__(self, other):
32251 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
32252 
 
32253 
  def __ne__(self, other):
32254 
    return not (self == other)
7169 anupam.sin 32255 
 
7190 amar.kumar 32256 
class splitFreebieOrder_args:
32257 
  """
32258 
  Attributes:
32259 
   - orderId
32260 
   - splitReason
32261 
   - shippingDate
32262 
  """
32263 
 
32264 
  thrift_spec = (
32265 
    None, # 0
32266 
    (1, TType.I64, 'orderId', None, None, ), # 1
32267 
    (2, TType.STRING, 'splitReason', None, None, ), # 2
32268 
    (3, TType.I64, 'shippingDate', None, None, ), # 3
32269 
  )
32270 
 
32271 
  def __init__(self, orderId=None, splitReason=None, shippingDate=None,):
32272 
    self.orderId = orderId
32273 
    self.splitReason = splitReason
32274 
    self.shippingDate = shippingDate
32275 
 
32276 
  def read(self, iprot):
32277 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
32278 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
32279 
      return
32280 
    iprot.readStructBegin()
32281 
    while True:
32282 
      (fname, ftype, fid) = iprot.readFieldBegin()
32283 
      if ftype == TType.STOP:
32284 
        break
32285 
      if fid == 1:
32286 
        if ftype == TType.I64:
32287 
          self.orderId = iprot.readI64();
32288 
        else:
32289 
          iprot.skip(ftype)
32290 
      elif fid == 2:
32291 
        if ftype == TType.STRING:
32292 
          self.splitReason = iprot.readString();
32293 
        else:
32294 
          iprot.skip(ftype)
32295 
      elif fid == 3:
32296 
        if ftype == TType.I64:
32297 
          self.shippingDate = iprot.readI64();
32298 
        else:
32299 
          iprot.skip(ftype)
32300 
      else:
32301 
        iprot.skip(ftype)
32302 
      iprot.readFieldEnd()
32303 
    iprot.readStructEnd()
32304 
 
32305 
  def write(self, oprot):
32306 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
32307 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
32308 
      return
32309 
    oprot.writeStructBegin('splitFreebieOrder_args')
32310 
    if self.orderId is not None:
32311 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
32312 
      oprot.writeI64(self.orderId)
32313 
      oprot.writeFieldEnd()
32314 
    if self.splitReason is not None:
32315 
      oprot.writeFieldBegin('splitReason', TType.STRING, 2)
32316 
      oprot.writeString(self.splitReason)
32317 
      oprot.writeFieldEnd()
32318 
    if self.shippingDate is not None:
32319 
      oprot.writeFieldBegin('shippingDate', TType.I64, 3)
32320 
      oprot.writeI64(self.shippingDate)
32321 
      oprot.writeFieldEnd()
32322 
    oprot.writeFieldStop()
32323 
    oprot.writeStructEnd()
32324 
 
32325 
  def validate(self):
32326 
    return
32327 
 
32328 
 
32329 
  def __repr__(self):
32330 
    L = ['%s=%r' % (key, value)
32331 
      for key, value in self.__dict__.iteritems()]
32332 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
32333 
 
32334 
  def __eq__(self, other):
32335 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
32336 
 
32337 
  def __ne__(self, other):
32338 
    return not (self == other)
32339 
 
32340 
class splitFreebieOrder_result:
32341 
  """
32342 
  Attributes:
32343 
   - success
32344 
  """
32345 
 
32346 
  thrift_spec = (
32347 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
32348 
  )
32349 
 
32350 
  def __init__(self, success=None,):
32351 
    self.success = success
32352 
 
32353 
  def read(self, iprot):
32354 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
32355 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
32356 
      return
32357 
    iprot.readStructBegin()
32358 
    while True:
32359 
      (fname, ftype, fid) = iprot.readFieldBegin()
32360 
      if ftype == TType.STOP:
32361 
        break
32362 
      if fid == 0:
32363 
        if ftype == TType.STRUCT:
32364 
          self.success = Order()
32365 
          self.success.read(iprot)
32366 
        else:
32367 
          iprot.skip(ftype)
32368 
      else:
32369 
        iprot.skip(ftype)
32370 
      iprot.readFieldEnd()
32371 
    iprot.readStructEnd()
32372 
 
32373 
  def write(self, oprot):
32374 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
32375 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
32376 
      return
32377 
    oprot.writeStructBegin('splitFreebieOrder_result')
32378 
    if self.success is not None:
32379 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
32380 
      self.success.write(oprot)
32381 
      oprot.writeFieldEnd()
32382 
    oprot.writeFieldStop()
32383 
    oprot.writeStructEnd()
32384 
 
32385 
  def validate(self):
32386 
    return
32387 
 
32388 
 
32389 
  def __repr__(self):
32390 
    L = ['%s=%r' % (key, value)
32391 
      for key, value in self.__dict__.iteritems()]
32392 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
32393 
 
32394 
  def __eq__(self, other):
32395 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
32396 
 
32397 
  def __ne__(self, other):
32398 
    return not (self == other)
32399 
 
7169 anupam.sin 32400 
class getRechargeTransactionsByNumber_args:
32401 
  """
32402 
  Attributes:
32403 
   - number
7172 anupam.sin 32404 
   - storeId
7169 anupam.sin 32405 
  """
32406 
 
32407 
  thrift_spec = (
32408 
    None, # 0
32409 
    (1, TType.STRING, 'number', None, None, ), # 1
7172 anupam.sin 32410 
    (2, TType.I64, 'storeId', None, None, ), # 2
7169 anupam.sin 32411 
  )
32412 
 
7172 anupam.sin 32413 
  def __init__(self, number=None, storeId=None,):
7169 anupam.sin 32414 
    self.number = number
7172 anupam.sin 32415 
    self.storeId = storeId
7169 anupam.sin 32416 
 
32417 
  def read(self, iprot):
32418 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
32419 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
32420 
      return
32421 
    iprot.readStructBegin()
32422 
    while True:
32423 
      (fname, ftype, fid) = iprot.readFieldBegin()
32424 
      if ftype == TType.STOP:
32425 
        break
32426 
      if fid == 1:
32427 
        if ftype == TType.STRING:
32428 
          self.number = iprot.readString();
32429 
        else:
32430 
          iprot.skip(ftype)
7172 anupam.sin 32431 
      elif fid == 2:
32432 
        if ftype == TType.I64:
32433 
          self.storeId = iprot.readI64();
32434 
        else:
32435 
          iprot.skip(ftype)
7169 anupam.sin 32436 
      else:
32437 
        iprot.skip(ftype)
32438 
      iprot.readFieldEnd()
32439 
    iprot.readStructEnd()
32440 
 
32441 
  def write(self, oprot):
32442 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
32443 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
32444 
      return
32445 
    oprot.writeStructBegin('getRechargeTransactionsByNumber_args')
32446 
    if self.number is not None:
32447 
      oprot.writeFieldBegin('number', TType.STRING, 1)
32448 
      oprot.writeString(self.number)
32449 
      oprot.writeFieldEnd()
7172 anupam.sin 32450 
    if self.storeId is not None:
32451 
      oprot.writeFieldBegin('storeId', TType.I64, 2)
32452 
      oprot.writeI64(self.storeId)
32453 
      oprot.writeFieldEnd()
7169 anupam.sin 32454 
    oprot.writeFieldStop()
32455 
    oprot.writeStructEnd()
32456 
 
32457 
  def validate(self):
32458 
    return
32459 
 
32460 
 
32461 
  def __repr__(self):
32462 
    L = ['%s=%r' % (key, value)
32463 
      for key, value in self.__dict__.iteritems()]
32464 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
32465 
 
32466 
  def __eq__(self, other):
32467 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
32468 
 
32469 
  def __ne__(self, other):
32470 
    return not (self == other)
32471 
 
32472 
class getRechargeTransactionsByNumber_result:
32473 
  """
32474 
  Attributes:
32475 
   - success
32476 
  """
32477 
 
32478 
  thrift_spec = (
32479 
    (0, TType.LIST, 'success', (TType.STRUCT,(RechargeTransaction, RechargeTransaction.thrift_spec)), None, ), # 0
32480 
  )
32481 
 
32482 
  def __init__(self, success=None,):
32483 
    self.success = success
32484 
 
32485 
  def read(self, iprot):
32486 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
32487 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
32488 
      return
32489 
    iprot.readStructBegin()
32490 
    while True:
32491 
      (fname, ftype, fid) = iprot.readFieldBegin()
32492 
      if ftype == TType.STOP:
32493 
        break
32494 
      if fid == 0:
32495 
        if ftype == TType.LIST:
32496 
          self.success = []
32497 
          (_etype761, _size758) = iprot.readListBegin()
32498 
          for _i762 in xrange(_size758):
32499 
            _elem763 = RechargeTransaction()
32500 
            _elem763.read(iprot)
32501 
            self.success.append(_elem763)
32502 
          iprot.readListEnd()
32503 
        else:
32504 
          iprot.skip(ftype)
32505 
      else:
32506 
        iprot.skip(ftype)
32507 
      iprot.readFieldEnd()
32508 
    iprot.readStructEnd()
32509 
 
32510 
  def write(self, oprot):
32511 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
32512 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
32513 
      return
32514 
    oprot.writeStructBegin('getRechargeTransactionsByNumber_result')
32515 
    if self.success is not None:
32516 
      oprot.writeFieldBegin('success', TType.LIST, 0)
32517 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
32518 
      for iter764 in self.success:
32519 
        iter764.write(oprot)
32520 
      oprot.writeListEnd()
32521 
      oprot.writeFieldEnd()
32522 
    oprot.writeFieldStop()
32523 
    oprot.writeStructEnd()
32524 
 
32525 
  def validate(self):
32526 
    return
32527 
 
32528 
 
32529 
  def __repr__(self):
32530 
    L = ['%s=%r' % (key, value)
32531 
      for key, value in self.__dict__.iteritems()]
32532 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
32533 
 
32534 
  def __eq__(self, other):
32535 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
32536 
 
32537 
  def __ne__(self, other):
32538 
    return not (self == other)
32539 
 
32540 
class updateHotspotStorePassword_args:
32541 
  """
32542 
  Attributes:
32543 
   - storeId
32544 
   - password
32545 
  """
32546 
 
32547 
  thrift_spec = (
32548 
    None, # 0
32549 
    (1, TType.I64, 'storeId', None, None, ), # 1
32550 
    (2, TType.STRING, 'password', None, None, ), # 2
32551 
  )
32552 
 
32553 
  def __init__(self, storeId=None, password=None,):
32554 
    self.storeId = storeId
32555 
    self.password = password
32556 
 
32557 
  def read(self, iprot):
32558 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
32559 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
32560 
      return
32561 
    iprot.readStructBegin()
32562 
    while True:
32563 
      (fname, ftype, fid) = iprot.readFieldBegin()
32564 
      if ftype == TType.STOP:
32565 
        break
32566 
      if fid == 1:
32567 
        if ftype == TType.I64:
32568 
          self.storeId = iprot.readI64();
32569 
        else:
32570 
          iprot.skip(ftype)
32571 
      elif fid == 2:
32572 
        if ftype == TType.STRING:
32573 
          self.password = iprot.readString();
32574 
        else:
32575 
          iprot.skip(ftype)
32576 
      else:
32577 
        iprot.skip(ftype)
32578 
      iprot.readFieldEnd()
32579 
    iprot.readStructEnd()
32580 
 
32581 
  def write(self, oprot):
32582 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
32583 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
32584 
      return
32585 
    oprot.writeStructBegin('updateHotspotStorePassword_args')
32586 
    if self.storeId is not None:
32587 
      oprot.writeFieldBegin('storeId', TType.I64, 1)
32588 
      oprot.writeI64(self.storeId)
32589 
      oprot.writeFieldEnd()
32590 
    if self.password is not None:
32591 
      oprot.writeFieldBegin('password', TType.STRING, 2)
32592 
      oprot.writeString(self.password)
32593 
      oprot.writeFieldEnd()
32594 
    oprot.writeFieldStop()
32595 
    oprot.writeStructEnd()
32596 
 
32597 
  def validate(self):
32598 
    return
32599 
 
32600 
 
32601 
  def __repr__(self):
32602 
    L = ['%s=%r' % (key, value)
32603 
      for key, value in self.__dict__.iteritems()]
32604 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
32605 
 
32606 
  def __eq__(self, other):
32607 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
32608 
 
32609 
  def __ne__(self, other):
32610 
    return not (self == other)
32611 
 
32612 
class updateHotspotStorePassword_result:
32613 
  """
32614 
  Attributes:
32615 
   - success
32616 
  """
32617 
 
32618 
  thrift_spec = (
32619 
    (0, TType.BOOL, 'success', None, None, ), # 0
32620 
  )
32621 
 
32622 
  def __init__(self, success=None,):
32623 
    self.success = success
32624 
 
32625 
  def read(self, iprot):
32626 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
32627 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
32628 
      return
32629 
    iprot.readStructBegin()
32630 
    while True:
32631 
      (fname, ftype, fid) = iprot.readFieldBegin()
32632 
      if ftype == TType.STOP:
32633 
        break
32634 
      if fid == 0:
32635 
        if ftype == TType.BOOL:
32636 
          self.success = iprot.readBool();
32637 
        else:
32638 
          iprot.skip(ftype)
32639 
      else:
32640 
        iprot.skip(ftype)
32641 
      iprot.readFieldEnd()
32642 
    iprot.readStructEnd()
32643 
 
32644 
  def write(self, oprot):
32645 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
32646 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
32647 
      return
32648 
    oprot.writeStructBegin('updateHotspotStorePassword_result')
32649 
    if self.success is not None:
32650 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
32651 
      oprot.writeBool(self.success)
32652 
      oprot.writeFieldEnd()
32653 
    oprot.writeFieldStop()
32654 
    oprot.writeStructEnd()
32655 
 
32656 
  def validate(self):
32657 
    return
32658 
 
32659 
 
32660 
  def __repr__(self):
32661 
    L = ['%s=%r' % (key, value)
32662 
      for key, value in self.__dict__.iteritems()]
32663 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
32664 
 
32665 
  def __eq__(self, other):
32666 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
32667 
 
32668 
  def __ne__(self, other):
32669 
    return not (self == other)
7263 anupam.sin 32670 
 
7285 rajveer 32671 
class topupCompanyWallet_args:
7263 anupam.sin 32672 
  """
32673 
  Attributes:
7285 rajveer 32674 
   - companyId
32675 
   - amount
7263 anupam.sin 32676 
  """
32677 
 
32678 
  thrift_spec = (
32679 
    None, # 0
7285 rajveer 32680 
    (1, TType.I64, 'companyId', None, None, ), # 1
32681 
    (2, TType.I64, 'amount', None, None, ), # 2
7263 anupam.sin 32682 
  )
32683 
 
7285 rajveer 32684 
  def __init__(self, companyId=None, amount=None,):
32685 
    self.companyId = companyId
32686 
    self.amount = amount
7263 anupam.sin 32687 
 
32688 
  def read(self, iprot):
32689 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
32690 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
32691 
      return
32692 
    iprot.readStructBegin()
32693 
    while True:
32694 
      (fname, ftype, fid) = iprot.readFieldBegin()
32695 
      if ftype == TType.STOP:
32696 
        break
32697 
      if fid == 1:
32698 
        if ftype == TType.I64:
7285 rajveer 32699 
          self.companyId = iprot.readI64();
7263 anupam.sin 32700 
        else:
32701 
          iprot.skip(ftype)
7285 rajveer 32702 
      elif fid == 2:
32703 
        if ftype == TType.I64:
32704 
          self.amount = iprot.readI64();
32705 
        else:
32706 
          iprot.skip(ftype)
7263 anupam.sin 32707 
      else:
32708 
        iprot.skip(ftype)
32709 
      iprot.readFieldEnd()
32710 
    iprot.readStructEnd()
32711 
 
32712 
  def write(self, oprot):
32713 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
32714 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
32715 
      return
7285 rajveer 32716 
    oprot.writeStructBegin('topupCompanyWallet_args')
32717 
    if self.companyId is not None:
32718 
      oprot.writeFieldBegin('companyId', TType.I64, 1)
32719 
      oprot.writeI64(self.companyId)
7263 anupam.sin 32720 
      oprot.writeFieldEnd()
7285 rajveer 32721 
    if self.amount is not None:
32722 
      oprot.writeFieldBegin('amount', TType.I64, 2)
32723 
      oprot.writeI64(self.amount)
32724 
      oprot.writeFieldEnd()
7263 anupam.sin 32725 
    oprot.writeFieldStop()
32726 
    oprot.writeStructEnd()
32727 
 
32728 
  def validate(self):
32729 
    return
32730 
 
32731 
 
32732 
  def __repr__(self):
32733 
    L = ['%s=%r' % (key, value)
32734 
      for key, value in self.__dict__.iteritems()]
32735 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
32736 
 
32737 
  def __eq__(self, other):
32738 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
32739 
 
32740 
  def __ne__(self, other):
32741 
    return not (self == other)
32742 
 
7285 rajveer 32743 
class topupCompanyWallet_result:
7263 anupam.sin 32744 
  """
32745 
  Attributes:
32746 
   - success
32747 
  """
32748 
 
32749 
  thrift_spec = (
7285 rajveer 32750 
    (0, TType.I64, 'success', None, None, ), # 0
7263 anupam.sin 32751 
  )
32752 
 
32753 
  def __init__(self, success=None,):
32754 
    self.success = success
32755 
 
32756 
  def read(self, iprot):
32757 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
32758 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
32759 
      return
32760 
    iprot.readStructBegin()
32761 
    while True:
32762 
      (fname, ftype, fid) = iprot.readFieldBegin()
32763 
      if ftype == TType.STOP:
32764 
        break
32765 
      if fid == 0:
7285 rajveer 32766 
        if ftype == TType.I64:
32767 
          self.success = iprot.readI64();
7263 anupam.sin 32768 
        else:
32769 
          iprot.skip(ftype)
32770 
      else:
32771 
        iprot.skip(ftype)
32772 
      iprot.readFieldEnd()
32773 
    iprot.readStructEnd()
32774 
 
32775 
  def write(self, oprot):
32776 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
32777 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
32778 
      return
7285 rajveer 32779 
    oprot.writeStructBegin('topupCompanyWallet_result')
7263 anupam.sin 32780 
    if self.success is not None:
7285 rajveer 32781 
      oprot.writeFieldBegin('success', TType.I64, 0)
32782 
      oprot.writeI64(self.success)
7263 anupam.sin 32783 
      oprot.writeFieldEnd()
32784 
    oprot.writeFieldStop()
32785 
    oprot.writeStructEnd()
32786 
 
32787 
  def validate(self):
32788 
    return
32789 
 
32790 
 
32791 
  def __repr__(self):
32792 
    L = ['%s=%r' % (key, value)
32793 
      for key, value in self.__dict__.iteritems()]
32794 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
32795 
 
32796 
  def __eq__(self, other):
32797 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
32798 
 
32799 
  def __ne__(self, other):
32800 
    return not (self == other)
7267 anupam.sin 32801 
 
7285 rajveer 32802 
class getWalletBalanceForCompany_args:
32803 
  """
32804 
  Attributes:
32805 
   - companyId
32806 
  """
7267 anupam.sin 32807 
 
32808 
  thrift_spec = (
7285 rajveer 32809 
    None, # 0
32810 
    (1, TType.I64, 'companyId', None, None, ), # 1
7267 anupam.sin 32811 
  )
32812 
 
7285 rajveer 32813 
  def __init__(self, companyId=None,):
32814 
    self.companyId = companyId
32815 
 
7267 anupam.sin 32816 
  def read(self, iprot):
32817 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
32818 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
32819 
      return
32820 
    iprot.readStructBegin()
32821 
    while True:
32822 
      (fname, ftype, fid) = iprot.readFieldBegin()
32823 
      if ftype == TType.STOP:
32824 
        break
7285 rajveer 32825 
      if fid == 1:
32826 
        if ftype == TType.I64:
32827 
          self.companyId = iprot.readI64();
32828 
        else:
32829 
          iprot.skip(ftype)
7267 anupam.sin 32830 
      else:
32831 
        iprot.skip(ftype)
32832 
      iprot.readFieldEnd()
32833 
    iprot.readStructEnd()
32834 
 
32835 
  def write(self, oprot):
32836 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
32837 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
32838 
      return
7285 rajveer 32839 
    oprot.writeStructBegin('getWalletBalanceForCompany_args')
32840 
    if self.companyId is not None:
32841 
      oprot.writeFieldBegin('companyId', TType.I64, 1)
32842 
      oprot.writeI64(self.companyId)
32843 
      oprot.writeFieldEnd()
7267 anupam.sin 32844 
    oprot.writeFieldStop()
32845 
    oprot.writeStructEnd()
32846 
 
32847 
  def validate(self):
32848 
    return
32849 
 
32850 
 
32851 
  def __repr__(self):
32852 
    L = ['%s=%r' % (key, value)
32853 
      for key, value in self.__dict__.iteritems()]
32854 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
32855 
 
32856 
  def __eq__(self, other):
32857 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
32858 
 
32859 
  def __ne__(self, other):
32860 
    return not (self == other)
32861 
 
7285 rajveer 32862 
class getWalletBalanceForCompany_result:
7267 anupam.sin 32863 
  """
32864 
  Attributes:
32865 
   - success
32866 
  """
32867 
 
32868 
  thrift_spec = (
7285 rajveer 32869 
    (0, TType.I64, 'success', None, None, ), # 0
7267 anupam.sin 32870 
  )
32871 
 
32872 
  def __init__(self, success=None,):
32873 
    self.success = success
32874 
 
32875 
  def read(self, iprot):
32876 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
32877 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
32878 
      return
32879 
    iprot.readStructBegin()
32880 
    while True:
32881 
      (fname, ftype, fid) = iprot.readFieldBegin()
32882 
      if ftype == TType.STOP:
32883 
        break
32884 
      if fid == 0:
7285 rajveer 32885 
        if ftype == TType.I64:
32886 
          self.success = iprot.readI64();
7267 anupam.sin 32887 
        else:
32888 
          iprot.skip(ftype)
32889 
      else:
32890 
        iprot.skip(ftype)
32891 
      iprot.readFieldEnd()
32892 
    iprot.readStructEnd()
32893 
 
32894 
  def write(self, oprot):
32895 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
32896 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
32897 
      return
7285 rajveer 32898 
    oprot.writeStructBegin('getWalletBalanceForCompany_result')
7267 anupam.sin 32899 
    if self.success is not None:
7285 rajveer 32900 
      oprot.writeFieldBegin('success', TType.I64, 0)
32901 
      oprot.writeI64(self.success)
7267 anupam.sin 32902 
      oprot.writeFieldEnd()
32903 
    oprot.writeFieldStop()
32904 
    oprot.writeStructEnd()
32905 
 
32906 
  def validate(self):
32907 
    return
32908 
 
32909 
 
32910 
  def __repr__(self):
32911 
    L = ['%s=%r' % (key, value)
32912 
      for key, value in self.__dict__.iteritems()]
32913 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
32914 
 
32915 
  def __eq__(self, other):
32916 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
32917 
 
32918 
  def __ne__(self, other):
32919 
    return not (self == other)
32920 
 
7285 rajveer 32921 
class getSourceDetail_args:
7267 anupam.sin 32922 
  """
32923 
  Attributes:
7285 rajveer 32924 
   - source
7267 anupam.sin 32925 
  """
32926 
 
32927 
  thrift_spec = (
32928 
    None, # 0
7285 rajveer 32929 
    (1, TType.I64, 'source', None, None, ), # 1
7267 anupam.sin 32930 
  )
32931 
 
7285 rajveer 32932 
  def __init__(self, source=None,):
32933 
    self.source = source
7267 anupam.sin 32934 
 
32935 
  def read(self, iprot):
32936 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
32937 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
32938 
      return
32939 
    iprot.readStructBegin()
32940 
    while True:
32941 
      (fname, ftype, fid) = iprot.readFieldBegin()
32942 
      if ftype == TType.STOP:
32943 
        break
32944 
      if fid == 1:
7285 rajveer 32945 
        if ftype == TType.I64:
32946 
          self.source = iprot.readI64();
7267 anupam.sin 32947 
        else:
32948 
          iprot.skip(ftype)
32949 
      else:
32950 
        iprot.skip(ftype)
32951 
      iprot.readFieldEnd()
32952 
    iprot.readStructEnd()
32953 
 
32954 
  def write(self, oprot):
32955 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
32956 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
32957 
      return
7285 rajveer 32958 
    oprot.writeStructBegin('getSourceDetail_args')
32959 
    if self.source is not None:
32960 
      oprot.writeFieldBegin('source', TType.I64, 1)
32961 
      oprot.writeI64(self.source)
7267 anupam.sin 32962 
      oprot.writeFieldEnd()
32963 
    oprot.writeFieldStop()
32964 
    oprot.writeStructEnd()
32965 
 
32966 
  def validate(self):
32967 
    return
32968 
 
32969 
 
32970 
  def __repr__(self):
32971 
    L = ['%s=%r' % (key, value)
32972 
      for key, value in self.__dict__.iteritems()]
32973 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
32974 
 
32975 
  def __eq__(self, other):
32976 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
32977 
 
32978 
  def __ne__(self, other):
32979 
    return not (self == other)
32980 
 
7285 rajveer 32981 
class getSourceDetail_result:
7267 anupam.sin 32982 
  """
32983 
  Attributes:
32984 
   - success
32985 
  """
32986 
 
32987 
  thrift_spec = (
7285 rajveer 32988 
    (0, TType.STRUCT, 'success', (SourceDetail, SourceDetail.thrift_spec), None, ), # 0
7267 anupam.sin 32989 
  )
32990 
 
32991 
  def __init__(self, success=None,):
32992 
    self.success = success
32993 
 
32994 
  def read(self, iprot):
32995 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
32996 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
32997 
      return
32998 
    iprot.readStructBegin()
32999 
    while True:
33000 
      (fname, ftype, fid) = iprot.readFieldBegin()
33001 
      if ftype == TType.STOP:
33002 
        break
33003 
      if fid == 0:
7285 rajveer 33004 
        if ftype == TType.STRUCT:
33005 
          self.success = SourceDetail()
33006 
          self.success.read(iprot)
7267 anupam.sin 33007 
        else:
33008 
          iprot.skip(ftype)
33009 
      else:
33010 
        iprot.skip(ftype)
33011 
      iprot.readFieldEnd()
33012 
    iprot.readStructEnd()
33013 
 
33014 
  def write(self, oprot):
33015 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
33016 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
33017 
      return
7285 rajveer 33018 
    oprot.writeStructBegin('getSourceDetail_result')
7267 anupam.sin 33019 
    if self.success is not None:
7285 rajveer 33020 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
33021 
      self.success.write(oprot)
7267 anupam.sin 33022 
      oprot.writeFieldEnd()
33023 
    oprot.writeFieldStop()
33024 
    oprot.writeStructEnd()
33025 
 
33026 
  def validate(self):
33027 
    return
33028 
 
33029 
 
33030 
  def __repr__(self):
33031 
    L = ['%s=%r' % (key, value)
33032 
      for key, value in self.__dict__.iteritems()]
33033 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
33034 
 
33035 
  def __eq__(self, other):
33036 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
33037 
 
33038 
  def __ne__(self, other):
33039 
    return not (self == other)