Subversion Repositories SmartDukaan

Rev

Rev 7109 | Rev 7169 | 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 
 
5527 anupam.sin 58 
  def changeTransactionStatus(self, transactionId, status, description, pickUp, orderType):
94 ashish 59 
    """
60 
    Parameters:
61 
     - transactionId
62 
     - status
63 
     - description
5527 anupam.sin 64 
     - pickUp
65 
     - orderType
94 ashish 66 
    """
67 
    pass
68 
 
1398 varun.gupt 69 
  def enqueueTransactionInfoEmail(self, transactionId):
1382 varun.gupt 70 
    """
71 
    Parameters:
72 
     - transactionId
73 
    """
74 
    pass
75 
 
4801 anupam.sin 76 
  def getAllOrders(self, statuses, from_date, to_date, warehouse_id):
94 ashish 77 
    """
78 
    Parameters:
4801 anupam.sin 79 
     - statuses
483 rajveer 80 
     - from_date
81 
     - to_date
82 
     - warehouse_id
94 ashish 83 
    """
84 
    pass
85 
 
4133 chandransh 86 
  def getOrdersInBatch(self, statuses, offset, limit, warehouse_id):
87 
    """
88 
    Returns at most 'limit' orders with the given statuses for the given warehouse starting from the given offset.
89 
    Pass the status as null and the limit as 0 to ignore them.
90 
 
91 
    Parameters:
92 
     - statuses
93 
     - offset
94 
     - limit
95 
     - warehouse_id
96 
    """
97 
    pass
98 
 
99 
  def getOrderCount(self, statuses, warehouseId):
100 
    """
101 
    Returns the count of orders with the given statuses assigned to the given warehouse.
102 
 
103 
    Parameters:
104 
     - statuses
105 
     - warehouseId
106 
    """
107 
    pass
108 
 
999 varun.gupt 109 
  def getOrdersByBillingDate(self, status, start_billing_date, end_billing_date, warehouse_id):
110 
    """
1132 chandransh 111 
    Returns orders within a range of their billing dates
3431 rajveer 112 
 
999 varun.gupt 113 
    Parameters:
114 
     - status
115 
     - start_billing_date
116 
     - end_billing_date
117 
     - warehouse_id
118 
    """
119 
    pass
120 
 
3451 chandransh 121 
  def getOrdersByShippingDate(self, fromShippingDate, toShippingDate, providerId, warehouseId, cod):
3427 chandransh 122 
    """
123 
    Returns orders for a particular provider and warehouse which were shipped between the given dates.
3451 chandransh 124 
    Returned orders comprise of COD orders if cod parameter is true. It comprises of prepaid orders otherwise.
125 
    Pass providerId and warehouseId as -1 to ignore both these parameters.
3431 rajveer 126 
 
3427 chandransh 127 
    Parameters:
128 
     - fromShippingDate
129 
     - toShippingDate
130 
     - providerId
131 
     - warehouseId
3451 chandransh 132 
     - cod
3427 chandransh 133 
    """
134 
    pass
135 
 
1382 varun.gupt 136 
  def getReturnableOrdersForCustomer(self, customer_id, limit):
137 
    """
138 
    Returns order ids for orders which can be returned
3431 rajveer 139 
 
1382 varun.gupt 140 
    Parameters:
141 
     - customer_id
142 
     - limit
143 
    """
144 
    pass
145 
 
146 
  def getCancellableOrdersForCustomer(self, customer_id, limit):
147 
    """
148 
    Returns order ids for orders which can be cancelled
3431 rajveer 149 
 
1382 varun.gupt 150 
    Parameters:
151 
     - customer_id
152 
     - limit
153 
    """
154 
    pass
155 
 
483 rajveer 156 
  def changeOrderStatus(self, orderId, status, description):
94 ashish 157 
    """
158 
    Parameters:
483 rajveer 159 
     - orderId
160 
     - status
161 
     - description
94 ashish 162 
    """
163 
    pass
164 
 
1528 ankur.sing 165 
  def getOrdersForTransaction(self, transactionId, customerId):
94 ashish 166 
    """
1528 ankur.sing 167 
    Returns list of orders for given transaction Id. Also filters based on customer Id so that
168 
    only user who owns the transaction can view its order details.
3431 rajveer 169 
 
94 ashish 170 
    Parameters:
171 
     - transactionId
1528 ankur.sing 172 
     - customerId
94 ashish 173 
    """
174 
    pass
175 
 
3014 chandransh 176 
  def getOrdersForCustomer(self, customerId, from_date, to_date, statuses):
94 ashish 177 
    """
3014 chandransh 178 
    Returns list of orders for the given customer created between the given dates and having the given statuses.
179 
    Pass and empty list to ignore filtering on statuses.
3431 rajveer 180 
 
94 ashish 181 
    Parameters:
483 rajveer 182 
     - customerId
183 
     - from_date
184 
     - to_date
3014 chandransh 185 
     - statuses
94 ashish 186 
    """
187 
    pass
188 
 
483 rajveer 189 
  def createOrder(self, order):
94 ashish 190 
    """
191 
    Parameters:
483 rajveer 192 
     - order
94 ashish 193 
    """
194 
    pass
195 
 
483 rajveer 196 
  def getOrder(self, id):
94 ashish 197 
    """
198 
    Parameters:
483 rajveer 199 
     - id
94 ashish 200 
    """
201 
    pass
202 
 
483 rajveer 203 
  def getLineItemsForOrder(self, orderId):
94 ashish 204 
    """
205 
    Parameters:
483 rajveer 206 
     - orderId
94 ashish 207 
    """
208 
    pass
209 
 
4999 phani.kuma 210 
  def getOrderList(self, order_ids):
211 
    """
212 
    Parameters:
213 
     - order_ids
214 
    """
215 
    pass
216 
 
5386 phani.kuma 217 
  def getOrderListForVendor(self, order_ids, vendorId):
218 
    """
219 
    Parameters:
220 
     - order_ids
221 
     - vendorId
222 
    """
223 
    pass
224 
 
1528 ankur.sing 225 
  def getOrderForCustomer(self, orderId, customerId):
226 
    """
227 
    Returns an order for the order Id. Also checks if the order belongs to the customer whose Id is passed.
228 
    Throws exception if either order Id is invalid or order does not below to the customer whose Id is passed.
3431 rajveer 229 
 
1528 ankur.sing 230 
    Parameters:
231 
     - orderId
232 
     - customerId
233 
    """
234 
    pass
235 
 
4444 rajveer 236 
  def getAlerts(self, type, warehouseId, status, timestamp):
3064 chandransh 237 
    """
238 
    Parameters:
4394 rajveer 239 
     - type
4444 rajveer 240 
     - warehouseId
4394 rajveer 241 
     - status
242 
     - timestamp
3064 chandransh 243 
    """
244 
    pass
245 
 
4444 rajveer 246 
  def addAlert(self, type, warehouseId, description):
3064 chandransh 247 
    """
248 
    Parameters:
249 
     - type
4444 rajveer 250 
     - warehouseId
4394 rajveer 251 
     - description
3064 chandransh 252 
    """
253 
    pass
254 
 
4444 rajveer 255 
  def markAlertsAsSeen(self, warehouseId):
256 
    """
257 
    Parameters:
258 
     - warehouseId
259 
    """
260 
    pass
261 
 
3064 chandransh 262 
  def getValidOrderCount(self, ):
263 
    """
264 
    Return the number of valid orders. (OrderStatus >= OrderStatus.SUBMITTED_FOR_PROCESSING)
265 
    """
266 
    pass
267 
 
268 
  def getNoOfCustomersWithSuccessfulTransaction(self, ):
269 
    """
270 
    Returns the number of distinct customers who have done successful transactions
271 
    """
272 
    pass
273 
 
274 
  def getValidOrdersAmountRange(self, ):
275 
    """
276 
    Returns the minimum and maximum amounts of a valid order. (OrderStatus >= OrderStatus.SUBMITTED_FOR_PROCESSING)
277 
    List contains two values, first minimum amount and second maximum amount.
278 
    """
279 
    pass
280 
 
5874 rajveer 281 
  def getValidOrders(self, limit, onlyStore):
3064 chandransh 282 
    """
283 
    Returns list of Orders in descending order by Order creation date. List is restricted to limit Orders.
284 
    If limit is passed as 0, then all valid Orders are returned.
3431 rajveer 285 
 
3064 chandransh 286 
    Parameters:
287 
     - limit
5874 rajveer 288 
     - onlyStore
3064 chandransh 289 
    """
290 
    pass
291 
 
1220 chandransh 292 
  def batchOrders(self, warehouseId):
293 
    """
294 
    Create a batch of all the pending orders for the given warehouse.
295 
    The returned list is orderd by created_timestamp.
296 
    If there are no pending orders, an empty list is returned.
3431 rajveer 297 
 
1220 chandransh 298 
    Parameters:
299 
     - warehouseId
300 
    """
301 
    pass
302 
 
1208 chandransh 303 
  def markOrderAsOutOfStock(self, orderId):
304 
    """
305 
    Mark the given order as out of stock. Throws an exception if the order with the given Id couldn't be found.
3431 rajveer 306 
 
1208 chandransh 307 
    Parameters:
308 
     - orderId
309 
    """
310 
    pass
311 
 
3064 chandransh 312 
  def verifyOrder(self, orderId):
759 chandransh 313 
    """
3064 chandransh 314 
    Marks the given order as SUBMITTED_FOR_PROCESSING and updates the verified
315 
    timestamp. It is intended to be used for COD orders but can be harmlessly
316 
    used for all other orders as well.
317 
    Throws an exception if no such order exists.
3431 rajveer 318 
 
759 chandransh 319 
    Parameters:
3064 chandransh 320 
     - orderId
321 
    """
322 
    pass
323 
 
324 
  def acceptOrder(self, orderId):
325 
    """
326 
    Marks the given order as ACCEPTED and updates the accepted timestamp. If the
327 
    given order is not a COD order, it also captures the payment if the same has
328 
    not been captured.
329 
    Throws an exception if no such order exists.
3431 rajveer 330 
 
3064 chandransh 331 
    Parameters:
332 
     - orderId
333 
    """
334 
    pass
335 
 
5110 mandeep.dh 336 
  def addBillingDetails(self, orderId, invoice_number, serialNumber, itemNumber, billed_by, jacketNumber, billingType, fulfilmentWarehouseId, authorize):
3064 chandransh 337 
    """
338 
    Add billing details such as the bill number and the biller to the Order.
4658 mandeep.dh 339 
    Adds jacket number, item number and Serial no. to the order. Doesn't update
3064 chandransh 340 
    the IMEI no. if a -1 is supplied.
341 
    Also, it generates an invoice number for the order, marks the order as
342 
    BILLED and sets the billing timestamp.
343 
    Returns false if it doesn't find the order with the given ID.
3431 rajveer 344 
 
3064 chandransh 345 
    Parameters:
346 
     - orderId
4283 anupam.sin 347 
     - invoice_number
4658 mandeep.dh 348 
     - serialNumber
3064 chandransh 349 
     - itemNumber
4283 anupam.sin 350 
     - billed_by
351 
     - jacketNumber
3064 chandransh 352 
     - billingType
5110 mandeep.dh 353 
     - fulfilmentWarehouseId
4763 rajveer 354 
     - authorize
3064 chandransh 355 
    """
356 
    pass
357 
 
6756 amar.kumar 358 
  def addInvoiceNumber(self, orderId, invoiceNumber, color, serialNumber, itemNumber):
4579 rajveer 359 
    """
360 
    Add the invoice number to the order.
361 
 
362 
    Parameters:
363 
     - orderId
364 
     - invoiceNumber
4763 rajveer 365 
     - color
6756 amar.kumar 366 
     - serialNumber
367 
     - itemNumber
4579 rajveer 368 
    """
369 
    pass
370 
 
4910 phani.kuma 371 
  def markOrdersAsShippedFromWarehouse(self, warehouseId, providerId, cod, orderIds):
3064 chandransh 372 
    """
373 
    Depending on the third parameter, marks either all prepaid or all cod orders BILLED by the
4910 phani.kuma 374 
    given warehouse and were picked up by the given provider as SHIPPED_FROM_WH.
4410 rajveer 375 
 
376 
    Parameters:
377 
     - warehouseId
378 
     - providerId
379 
     - cod
4910 phani.kuma 380 
     - orderIds
4410 rajveer 381 
    """
382 
    pass
383 
 
5713 rajveer 384 
  def markOrdersAsReturnedFromStore(self, providerId, orderIds, awbs):
5676 rajveer 385 
    """
386 
    Parameters:
387 
     - providerId
388 
     - orderIds
5713 rajveer 389 
     - awbs
5676 rajveer 390 
    """
391 
    pass
392 
 
4910 phani.kuma 393 
  def markOrdersAsPickedUp(self, providerId, pickupDetails):
4410 rajveer 394 
    """
4910 phani.kuma 395 
    Marks all SHIPPED_FROM_WH orders of the previous day for a provider as SHIPPED_TO_LOGISTICS.
396 
    Raises an exception if we encounter report for an AWB number that we did not ship.
3431 rajveer 397 
 
3064 chandransh 398 
    Parameters:
759 chandransh 399 
     - providerId
4910 phani.kuma 400 
     - pickupDetails
759 chandransh 401 
    """
402 
    pass
403 
 
4910 phani.kuma 404 
  def getOrdersNotPickedUp(self, providerId):
1113 chandransh 405 
    """
406 
    Returns a list of orders that were shipped from warehouse but did not appear in the pick-up report.
3431 rajveer 407 
 
1113 chandransh 408 
    Parameters:
409 
     - providerId
410 
    """
411 
    pass
412 
 
1132 chandransh 413 
  def markOrdersAsDelivered(self, providerId, deliveredOrders):
414 
    """
415 
    Marks all orders with AWBs in the given map as delivered. Also sets the delivery timestamp and
416 
    the name of the receiver.
417 
    Raises an exception if we encounter report for an AWB number that we did not ship.
3431 rajveer 418 
 
1132 chandransh 419 
    Parameters:
420 
     - providerId
421 
     - deliveredOrders
422 
    """
423 
    pass
424 
 
4910 phani.kuma 425 
  def markAsRTOrders(self, providerId, returnedOrders):
1135 chandransh 426 
    """
4910 phani.kuma 427 
    Mark all orders with AWBs in the given map as RTO. Also sets the delivery timestamp.
1135 chandransh 428 
    Raises an exception if we encounter report for an AWB number that we did not ship.
3431 rajveer 429 
 
1135 chandransh 430 
    Parameters:
431 
     - providerId
432 
     - returnedOrders
433 
    """
434 
    pass
435 
 
4910 phani.kuma 436 
  def getRTOrders(self, providerId):
437 
    """
438 
    Returns a list of orders that were returned by courier.
439 
 
440 
    Parameters:
441 
     - providerId
442 
    """
443 
    pass
444 
 
1246 chandransh 445 
  def updateNonDeliveryReason(self, providerId, undeliveredOrders):
446 
    """
447 
    Update the status description of orders whose AWB numbers are keys of the Map.
3431 rajveer 448 
 
1246 chandransh 449 
    Parameters:
450 
     - providerId
451 
     - undeliveredOrders
452 
    """
453 
    pass
454 
 
4910 phani.kuma 455 
  def getNonDeliveredOrdersbyCourier(self, providerId):
456 
    """
457 
    Returns a list of orders that were picked up or shipped four days ago but did not get delivered.
458 
 
459 
    Parameters:
460 
     - providerId
461 
    """
462 
    pass
463 
 
464 
  def markOrdersAsLocalConnected(self, providerId, local_connected_orders):
465 
    """
466 
    Mark all orders with AWBs in the given map as local connected. Also sets the local connected timestamp.
467 
 
468 
    Parameters:
469 
     - providerId
470 
     - local_connected_orders
471 
    """
472 
    pass
473 
 
474 
  def getOrdersNotLocalConnected(self, providerId):
475 
    """
476 
    Returns a list of orders that were picked up or shipped but pending local connection.
477 
 
478 
    Parameters:
479 
     - providerId
480 
    """
481 
    pass
482 
 
483 
  def markOrdersAsDestinationCityReached(self, providerId, destination_city_reached_orders):
484 
    """
485 
    Mark all orders with AWBs in the given map as reached destination city. Also sets the reached destination timestamp.
486 
 
487 
    Parameters:
488 
     - providerId
489 
     - destination_city_reached_orders
490 
    """
491 
    pass
492 
 
493 
  def markOrdersAsFirstDeliveryAttempted(self, providerId, first_atdl_orders):
494 
    """
495 
    Mark all orders with AWBs in the given map as first delivery attempt made. Also sets the first delivery attempted timestamp.
496 
 
497 
    Parameters:
498 
     - providerId
499 
     - first_atdl_orders
500 
    """
501 
    pass
502 
 
1408 ankur.sing 503 
  def getUndeliveredOrders(self, providerId, warehouseId):
504 
    """
505 
    Returns the list of orders whose delivery time has passed but have not been
506 
    delivered yet for the given provider and warehouse. To get a complete list of
507 
    undelivered orders, pass them as -1.
508 
    Returns an empty list if no such orders exist.
3431 rajveer 509 
 
1408 ankur.sing 510 
    Parameters:
511 
     - providerId
512 
     - warehouseId
513 
    """
514 
    pass
515 
 
4783 phani.kuma 516 
  def getUndeliveredOrdersExpectedDeliveryDateNotMet(self, ):
517 
    """
518 
    Returns the list of orders whose expected delivery date has passed but have not been
519 
    delivered yet.
520 
    Returns an empty list if no such orders exist.
521 
    """
522 
    pass
523 
 
2536 chandransh 524 
  def toggleDOAFlag(self, orderId):
525 
    """
526 
    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.
527 
    Returns the final flag status.
528 
    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 529 
 
2536 chandransh 530 
    Parameters:
531 
     - orderId
532 
    """
533 
    pass
1886 ankur.sing 534 
 
4712 rajveer 535 
  def markOrderAsDelivered(self, orderId, deliveryTimestamp, receiver):
536 
    """
537 
    Parameters:
538 
     - orderId
539 
     - deliveryTimestamp
540 
     - receiver
541 
    """
542 
    pass
543 
 
5553 rajveer 544 
  def markOrderAsReceivedAtStore(self, orderId, deliveryTimestamp):
545 
    """
546 
    Parameters:
547 
     - orderId
548 
     - deliveryTimestamp
549 
    """
550 
    pass
551 
 
4454 rajveer 552 
  def markOrderDoaRequestReceived(self, orderId):
553 
    """
554 
    Once user raise the request for a DOA, order status will be changed from DELVIERY_SUCCESS to DOA_REQUEST_RECEIVED
555 
 
556 
    Parameters:
557 
     - orderId
558 
    """
559 
    pass
560 
 
561 
  def markOrderDoaRequestAuthorized(self, orderId, isAuthorized):
562 
    """
563 
    CRM person can authorize or deny the request reised by customer. If he authorizes order will change from DOA_REQUEST_RECEIVED
564 
    to DOA_REQUEST_AUTHORIZED. If he denies, status will be changed back to DELVIERY_SUCCESS.
565 
 
566 
    Parameters:
567 
     - orderId
568 
     - isAuthorized
569 
    """
570 
    pass
571 
 
4488 rajveer 572 
  def markOrderReturnRequestReceived(self, orderId):
573 
    """
574 
    Once user raise the request for a RET, order status will be changed from DELVIERY_SUCCESS to RET_REQUEST_RECEIVED
575 
 
576 
    Parameters:
577 
     - orderId
578 
    """
579 
    pass
580 
 
581 
  def markOrderReturnRequestAuthorized(self, orderId, isAuthorized):
582 
    """
583 
    CRM person can authorize or deny the request reised by customer. If he authorizes order will change from RET_REQUEST_RECEIVED
584 
    to RET_REQUEST_AUTHORIZED. If he denies, status will be changed back to DELVIERY_SUCCESS.
585 
 
586 
    Parameters:
587 
     - orderId
588 
     - isAuthorized
589 
    """
590 
    pass
591 
 
4579 rajveer 592 
  def requestPickupNumber(self, orderId, providerId):
2536 chandransh 593 
    """
594 
    Sends out an email to the account manager of the original courier provider used to ship the order.
4452 rajveer 595 
    If the order status was DELIVERY_SUCCESS, it is changed to be DOA_PICKUP_REQUEST_RAISED.
596 
    If the order status was DOA_PICKUP_REQUEST_RAISED, it is left unchanged.
2536 chandransh 597 
    For any other status, it returns false.
598 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 599 
 
2536 chandransh 600 
    Parameters:
601 
     - orderId
4579 rajveer 602 
     - providerId
2536 chandransh 603 
    """
604 
    pass
605 
 
4602 rajveer 606 
  def authorizePickup(self, orderId, pickupNumber, providerId):
2536 chandransh 607 
    """
4452 rajveer 608 
    If the order status is DOA_PICKUP_REQUEST_RAISED, it does the following
2536 chandransh 609 
    	1. Sends out an email to the customer with the dispatch advice that he has to print as an attachment.
610 
    	2. Changes order status to be DOA_PICKUP_AUTHORIZED.
611 
    	3. Returns true
2591 chandransh 612 
    If the order is in any other status, it returns false.
2536 chandransh 613 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 614 
 
2536 chandransh 615 
    Parameters:
616 
     - orderId
617 
     - pickupNumber
4602 rajveer 618 
     - providerId
2536 chandransh 619 
    """
620 
    pass
621 
 
2764 chandransh 622 
  def markDoasAsPickedUp(self, providerId, pickupDetails):
623 
    """
624 
    Marks all DOA_PICKUP_AUTHORIZED orders of the previous day for a provider as DOA_RETURN_IN_TRANSIT.
3431 rajveer 625 
 
2764 chandransh 626 
    Parameters:
627 
     - providerId
628 
     - pickupDetails
629 
    """
630 
    pass
631 
 
4910 phani.kuma 632 
  def getDoasNotPickedUp(self, providerId):
633 
    """
634 
    Returns a list of orders that were authorized for pickup but did not appear in the pick-up report.
635 
 
636 
    Parameters:
637 
     - providerId
638 
    """
639 
    pass
640 
 
4741 phani.kuma 641 
  def markReturnOrdersAsPickedUp(self, providerId, pickupDetails):
642 
    """
643 
    Marks all RET_PICKUP_CONFIRMED orders of the previous day for a provider as RET_RETURN_IN_TRANSIT.
644 
 
645 
    Parameters:
646 
     - providerId
647 
     - pickupDetails
648 
    """
649 
    pass
650 
 
4910 phani.kuma 651 
  def getReturnOrdersNotPickedUp(self, providerId):
652 
    """
653 
    Returns a list of orders that were authorized for pickup but did not appear in the pick-up report.
654 
 
655 
    Parameters:
656 
     - providerId
657 
    """
658 
    pass
659 
 
4479 rajveer 660 
  def receiveReturn(self, orderId, receiveCondition):
2591 chandransh 661 
    """
4452 rajveer 662 
    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 663 
    If the order status is RTO_IN_TRANSIT, marks the order status as RTO_RECEIVED_PRESTINE and returns true.
2591 chandransh 664 
    If the order is in any other state, it returns false.
665 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 666 
 
2591 chandransh 667 
    Parameters:
668 
     - orderId
4479 rajveer 669 
     - receiveCondition
2591 chandransh 670 
    """
671 
    pass
2536 chandransh 672 
 
2591 chandransh 673 
  def validateDoa(self, orderId, isValid):
674 
    """
4452 rajveer 675 
    Used to validate the DOA certificate for an order in the DOA_RECEIVED_PRESTINE state. If the certificate is valid,
2616 chandransh 676 
    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 677 
    If the order is in any other state, it returns false.
678 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 679 
 
2591 chandransh 680 
    Parameters:
681 
     - orderId
682 
     - isValid
683 
    """
684 
    pass
685 
 
4495 rajveer 686 
  def validateReturnProduct(self, orderId, isUsable):
687 
    """
688 
    Parameters:
689 
     - orderId
690 
     - isUsable
691 
    """
692 
    pass
693 
 
2616 chandransh 694 
  def reshipOrder(self, orderId):
695 
    """
4484 rajveer 696 
    If the order is in RTO_RECEIVED_PRESTINE or DOA_CERT_INVALID state, it does the following:
2616 chandransh 697 
    	1. Creates a new order for processing in the BILLED state. All billing information is saved.
4484 rajveer 698 
    	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 699 
 
700 
    If the order is in DOA_CERT_VALID state, it does the following:
701 
    	1. Creates a new order for processing in the SUBMITTED_FOR_PROCESSING state.
702 
    	2. Creates a return order for the warehouse executive to return the DOA material.
4452 rajveer 703 
    	3. Marks the current order as the final DOA_VALID_RESHIPPED state.
3431 rajveer 704 
 
2616 chandransh 705 
    Returns the id of the newly created order.
3431 rajveer 706 
 
2616 chandransh 707 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 708 
 
2616 chandransh 709 
    Parameters:
710 
     - orderId
711 
    """
712 
    pass
2591 chandransh 713 
 
3226 chandransh 714 
  def refundOrder(self, orderId, refundedBy, reason):
2616 chandransh 715 
    """
4484 rajveer 716 
    If the order is in RTO_RECEIVED_PRESTINE, DOA_CERT_VALID or DOA_CERT_INVALID state, it does the following:
2616 chandransh 717 
    	1. Creates a refund request for batch processing.
718 
    	2. Creates a return order for the warehouse executive to return the shipped material.
4484 rajveer 719 
    	3. Marks the current order as RTO_REFUNDED, DOA_VALID_REFUNDED or DOA_INVALID_REFUNDED final states.
3431 rajveer 720 
 
2616 chandransh 721 
    If the order is in SUBMITTED_FOR_PROCESSING or INVENTORY_LOW state, it does the following:
722 
    	1. Creates a refund request for batch processing.
3226 chandransh 723 
    	2. Cancels the reservation of the item in the warehouse.
724 
    	3. Marks the current order as the REFUNDED final state.
3431 rajveer 725 
 
3226 chandransh 726 
    For all COD orders, if the order is in INIT, SUBMITTED_FOR_PROCESSING or INVENTORY_LOW state, it does the following:
727 
    	1. Cancels the reservation of the item in the warehouse.
728 
    	2. Marks the current order as CANCELED.
729 
 
730 
    In all cases, it updates the reason for cancellation or refund and the person who performed the action.
731 
 
2616 chandransh 732 
    Returns True if it is successful, False otherwise.
3431 rajveer 733 
 
2616 chandransh 734 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 735 
 
2616 chandransh 736 
    Parameters:
737 
     - orderId
3226 chandransh 738 
     - refundedBy
739 
     - reason
2616 chandransh 740 
    """
741 
    pass
742 
 
2690 chandransh 743 
  def getReturnOrders(self, warehouseId, fromDate, toDate):
744 
    """
745 
    Get all return orders created between the from and to dates for the given warehouse.
746 
    Ignores the warehouse if it is passed as -1.
3431 rajveer 747 
 
2690 chandransh 748 
    Parameters:
749 
     - warehouseId
750 
     - fromDate
751 
     - toDate
752 
    """
753 
    pass
2616 chandransh 754 
 
5481 phani.kuma 755 
  def getAllReturnOrders(self, onlyNotProcessed, fromDate, toDate):
756 
    """
757 
    Get all return orders created between the from and to dates.
758 
 
759 
    Parameters:
760 
     - onlyNotProcessed
761 
     - fromDate
762 
     - toDate
763 
    """
764 
    pass
765 
 
2700 chandransh 766 
  def getReturnOrder(self, id):
767 
    """
768 
    Returns the ReturnOrder corresponding to the given id.
769 
    Throws an exception if the return order with the given id couldn't be found.
3431 rajveer 770 
 
2700 chandransh 771 
    Parameters:
772 
     - id
773 
    """
774 
    pass
775 
 
2690 chandransh 776 
  def processReturn(self, returnOrderId):
777 
    """
778 
    Marks the return order with the given id as processed. Raises an exception if no such return order exists.
3431 rajveer 779 
 
2690 chandransh 780 
    Parameters:
781 
     - returnOrderId
782 
    """
783 
    pass
784 
 
3451 chandransh 785 
  def updateWeight(self, orderId, weight):
786 
    """
787 
    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 788 
 
3451 chandransh 789 
    Parameters:
790 
     - orderId
791 
     - weight
792 
    """
793 
    pass
794 
 
3469 chandransh 795 
  def changeItem(self, orderId, itemId):
796 
    """
797 
    Change the item to be shipped for this order. Also adjusts the reservation in the inventory accordingly.
798 
    Currently, it also ensures that only a different color of the given item is shipped.
3451 chandransh 799 
 
3469 chandransh 800 
    Parameters:
801 
     - orderId
802 
     - itemId
803 
    """
804 
    pass
805 
 
806 
  def shiftToWarehouse(self, orderId, warehouseId):
807 
    """
808 
    Moves the given order to the given warehouse. Also adjusts the inventory reservations accordingly.
809 
 
810 
    Parameters:
811 
     - orderId
812 
     - warehouseId
813 
    """
814 
    pass
815 
 
4647 rajveer 816 
  def addDelayReason(self, orderId, delayReason, furtherDelay, delayReasonText):
3553 chandransh 817 
    """
818 
    Adds the given delay reason to the given order.
3986 chandransh 819 
    Increases the expected delivery time of the given order by the given no. of days.
3553 chandransh 820 
    Raises an exception if no order with the given id can be found.
3469 chandransh 821 
 
3553 chandransh 822 
    Parameters:
823 
     - orderId
824 
     - delayReason
3986 chandransh 825 
     - furtherDelay
4647 rajveer 826 
     - delayReasonText
3553 chandransh 827 
    """
828 
    pass
829 
 
3956 chandransh 830 
  def reconcileCodCollection(self, collectedAmountMap, xferBy, xferTxnId, xferDate):
831 
    """
832 
    Marks the COD orders with given AWB nos. as having been processed.
833 
    Updates the captured amount for the corresponding payment.
3553 chandransh 834 
 
3956 chandransh 835 
    Returns a map of AWBs which were not processed and the associated reason. An AWB is not processed if:
836 
    1. There is no order corresponding to an AWB number.
837 
    2. The captured amount for a payment exceeds the total payment.
838 
    3. The order corresponding to an AWB no. is in a state prior to DELIVERY_SUCCESS.
839 
 
840 
    Parameters:
841 
     - collectedAmountMap
842 
     - xferBy
843 
     - xferTxnId
844 
     - xferDate
845 
    """
846 
    pass
847 
 
4008 mandeep.dh 848 
  def getTransactionsRequiringExtraProcessing(self, category):
849 
    """
4065 mandeep.dh 850 
    Returns the list of transaction ids that require some extra processing and
4008 mandeep.dh 851 
    which belong to a particular category. This is currently used by CRM
4065 mandeep.dh 852 
    application. If no such transaction ids are present, it returns an empty list.
3956 chandransh 853 
 
4008 mandeep.dh 854 
    Parameters:
855 
     - category
856 
    """
857 
    pass
858 
 
859 
  def markTransactionAsProcessed(self, transactionId, category):
860 
    """
861 
    Marks a particular transaction as processed for a particular cateogory.
4065 mandeep.dh 862 
    It essentially deletes the transaction id record for a particular
863 
    processing type category (if present) from DB.
864 
    This is currently used by CRM application.
4008 mandeep.dh 865 
 
866 
    Parameters:
867 
     - transactionId
868 
     - category
869 
    """
870 
    pass
871 
 
4018 chandransh 872 
  def getItemWiseRiskyOrdersCount(self, ):
873 
    """
874 
    Returns a map containing the number of risky orders keyed by item id. A risky order
875 
    is defined as one whose shipping date is about to expire.
876 
    """
877 
    pass
4008 mandeep.dh 878 
 
4295 varun.gupt 879 
  def getOrdersForItemIds(self, itemIds):
880 
    """
881 
    Returns a list of all orders which have items with given id
882 
 
883 
    Parameters:
884 
     - itemIds
885 
    """
886 
    pass
887 
 
4247 rajveer 888 
  def markOrderCancellationRequestReceived(self, orderId):
889 
    """
890 
    Mark order as cancellation request received. If customer sends request of cancellation of
891 
    a particular order, this method will be called. It will just change status of the order
892 
    depending on its current status. It also records the previous status, so that we can move
893 
    back to that status if cancellation request is denied.
4018 chandransh 894 
 
4247 rajveer 895 
    Parameters:
896 
     - orderId
897 
    """
898 
    pass
899 
 
900 
  def markOrderCancellationRequestConfirmed(self, orderId):
901 
    """
902 
    If we decide to to cancel order, CRM will call this method to move the status of order to
903 
    cancellation request confirmed. After this OM will be able to cancel the order.
904 
 
905 
    Parameters:
906 
     - orderId
907 
    """
908 
    pass
909 
 
910 
  def markOrderCancellationRequestDenied(self, orderId):
911 
    """
912 
    If we decide to not to cancel order, we will move the order ro previous status.
913 
 
914 
    Parameters:
915 
     - orderId
916 
    """
917 
    pass
918 
 
4258 rajveer 919 
  def markTransactionAsPaymentFlagRemoved(self, transactionId):
4247 rajveer 920 
    """
4258 rajveer 921 
    If we and/or payment gateway has decided to accept the payment, this method needs to be called.
922 
    Changed transaction and all orders status to payment accepted.
4247 rajveer 923 
 
924 
    Parameters:
4258 rajveer 925 
     - transactionId
4247 rajveer 926 
    """
927 
    pass
928 
 
4259 anupam.sin 929 
  def refundTransaction(self, transactionId, refundedBy, reason):
930 
    """
931 
    This method is called when a flagged payment is deemed unserviceable and the corresponding orders
932 
    need to be cancelled
4247 rajveer 933 
 
4259 anupam.sin 934 
    Parameters:
935 
     - transactionId
936 
     - refundedBy
937 
     - reason
938 
    """
939 
    pass
940 
 
4324 mandeep.dh 941 
  def updateShipmentAddress(self, orderId, addressId):
942 
    """
943 
    Updates shipment address of an order. Delivery and shipping date estimates
944 
    etc. are also updated here.
945 
 
946 
    Throws TransactionServiceException in case address change is not
947 
    possible due to certain reasons such as new pincode in address is
948 
    not serviceable etc.
949 
 
950 
    Parameters:
951 
     - orderId
952 
     - addressId
953 
    """
954 
    pass
955 
 
4285 rajveer 956 
  def acceptOrdersForItemId(self, itemId, inventory):
957 
    """
958 
    Marks the orders as ACCEPTED for the given itemId and inventory. It also updates the accepted timestamp. If the
959 
    given order is not a COD order, it also captures the payment if the same has not been captured.
4259 anupam.sin 960 
 
4285 rajveer 961 
    Parameters:
962 
     - itemId
963 
     - inventory
964 
    """
965 
    pass
966 
 
4369 rajveer 967 
  def markOrdersAsPORaised(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 968 
    """
969 
    Parameters:
970 
     - vendorId
971 
     - itemId
972 
     - quantity
973 
     - estimate
4369 rajveer 974 
     - isReminder
4303 rajveer 975 
    """
976 
    pass
4285 rajveer 977 
 
4369 rajveer 978 
  def markOrdersAsReversalInitiated(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 979 
    """
980 
    Parameters:
981 
     - vendorId
982 
     - itemId
983 
     - quantity
984 
     - estimate
4369 rajveer 985 
     - isReminder
4303 rajveer 986 
    """
987 
    pass
988 
 
4369 rajveer 989 
  def markOrdersAsNotAvailabke(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 990 
    """
991 
    Parameters:
992 
     - vendorId
993 
     - itemId
994 
     - quantity
995 
     - estimate
4369 rajveer 996 
     - isReminder
4303 rajveer 997 
    """
998 
    pass
999 
 
4369 rajveer 1000 
  def markOrdersAsTimeout(self, vendorId):
1001 
    """
1002 
    Parameters:
1003 
     - vendorId
1004 
    """
1005 
    pass
4303 rajveer 1006 
 
4662 rajveer 1007 
  def markOrderAsLostInTransit(self, orderId):
1008 
    """
1009 
    Mark order as LOST_IN_TRANSIT
1010 
 
1011 
    Parameters:
1012 
     - orderId
1013 
    """
1014 
    pass
1015 
 
4386 anupam.sin 1016 
  def getOrderForAwb(self, awb):
1017 
    """
1018 
    Returns the order corresponding to an AWB number
4369 rajveer 1019 
 
4386 anupam.sin 1020 
    Parameters:
1021 
     - awb
1022 
    """
1023 
    pass
1024 
 
4910 phani.kuma 1025 
  def getOrdersForProviderForStatus(self, logistics_provider_id, order_status_list):
4506 phani.kuma 1026 
    """
4910 phani.kuma 1027 
    Returns the order corresponding to a logistics provider id for a given list of order status
4386 anupam.sin 1028 
 
4506 phani.kuma 1029 
    Parameters:
1030 
     - logistics_provider_id
4910 phani.kuma 1031 
     - order_status_list
4506 phani.kuma 1032 
    """
1033 
    pass
1034 
 
4600 varun.gupt 1035 
  def getBilledOrdersForVendor(self, vendorId, billingDateFrom, billingDateTo):
1036 
    """
1037 
    Returns list of orders fullfiled from a certain vendor and billed in a given date range
4506 phani.kuma 1038 
 
4600 varun.gupt 1039 
    Parameters:
1040 
     - vendorId
1041 
     - billingDateFrom
1042 
     - billingDateTo
1043 
    """
1044 
    pass
1045 
 
4607 rajveer 1046 
  def getSlippedSippingDateOrders(self, ):
1047 
    pass
1048 
 
4709 rajveer 1049 
  def getCancelledOrders(self, cancelDateFrom, cancelDateTo):
1050 
    """
1051 
    Parameters:
1052 
     - cancelDateFrom
1053 
     - cancelDateTo
1054 
    """
1055 
    pass
1056 
 
4600 varun.gupt 1057 
  def saveBluedartSettlements(self, mapAWBAndAmount):
1058 
    """
1059 
    Parameters:
1060 
     - mapAWBAndAmount
1061 
    """
1062 
    pass
1063 
 
4905 varun.gupt 1064 
  def savePaymentSettlements(self, settlementDate, paymentGatewayId, referenceId, serviceTax, otherCharges, netCollection):
4600 varun.gupt 1065 
    """
1066 
    Parameters:
1067 
     - settlementDate
1068 
     - paymentGatewayId
4905 varun.gupt 1069 
     - referenceId
4600 varun.gupt 1070 
     - serviceTax
1071 
     - otherCharges
1072 
     - netCollection
1073 
    """
1074 
    pass
1075 
 
1076 
  def saveEBSSettlementSummary(self, settlementId, settlementDate, transactionDateFrom, transactionDateTo, amount):
1077 
    """
1078 
    Parameters:
1079 
     - settlementId
1080 
     - settlementDate
1081 
     - transactionDateFrom
1082 
     - transactionDateTo
1083 
     - amount
1084 
    """
1085 
    pass
1086 
 
5386 phani.kuma 1087 
  def getSettlementForPrepaid(self, referenceId, isRefund):
4600 varun.gupt 1088 
    """
1089 
    Parameters:
5189 varun.gupt 1090 
     - referenceId
1091 
     - isRefund
4600 varun.gupt 1092 
    """
1093 
    pass
1094 
 
5386 phani.kuma 1095 
  def getSettlementForCod(self, orderId, isRefund):
1096 
    """
1097 
    Parameters:
1098 
     - orderId
1099 
     - isRefund
1100 
    """
1101 
    pass
1102 
 
4600 varun.gupt 1103 
  def getEBSSettlementSummaries(self, ):
1104 
    pass
1105 
 
1106 
  def markEBSSettlementUploaded(self, settlementId):
1107 
    """
1108 
    Parameters:
1109 
     - settlementId
1110 
    """
1111 
    pass
1112 
 
1113 
  def getEBSSettlementDate(self, settlementId):
1114 
    """
1115 
    Parameters:
1116 
     - settlementId
1117 
    """
1118 
    pass
1119 
 
4715 varun.gupt 1120 
  def getSettlementsByDate(self, settlementDateFrom, settlementDateTo, isRefund):
1121 
    """
1122 
    Parameters:
1123 
     - settlementDateFrom
1124 
     - settlementDateTo
1125 
     - isRefund
1126 
    """
1127 
    pass
4600 varun.gupt 1128 
 
4715 varun.gupt 1129 
  def getReshippedOrderIds(self, orderIds):
1130 
    """
1131 
    Returns list of Order Ids, which belong to reshiped orders, shortlisted from a given list of Order Ids
1132 
 
1133 
    Parameters:
1134 
     - orderIds
1135 
    """
1136 
    pass
1137 
 
5481 phani.kuma 1138 
  def getBilledOrders(self, vendorId, onlyVendorNotPaid, billingDateFrom, billingDateTo):
4875 varun.gupt 1139 
    """
1140 
    Parameters:
1141 
     - vendorId
5481 phani.kuma 1142 
     - onlyVendorNotPaid
1143 
     - billingDateFrom
1144 
     - billingDateTo
4875 varun.gupt 1145 
    """
1146 
    pass
4757 mandeep.dh 1147 
 
5031 varun.gupt 1148 
  def getStatusDistributionOfOrders(self, startDate, endDate):
1149 
    """
1150 
    Parameters:
1151 
     - startDate
1152 
     - endDate
1153 
    """
1154 
    pass
4875 varun.gupt 1155 
 
5067 varun.gupt 1156 
  def getOrderIdsForStatus(self, status, startDatetime, endDatetime):
1157 
    """
1158 
    Parameters:
1159 
     - status
1160 
     - startDatetime
1161 
     - endDatetime
1162 
    """
1163 
    pass
5031 varun.gupt 1164 
 
5348 anupam.sin 1165 
  def updateCODAgent(self, agent, orderId):
1166 
    """
1167 
    Updates the agent who handled the COD verification call
1168 
 
1169 
    Parameters:
1170 
     - agent
1171 
     - orderId
1172 
    """
1173 
    pass
1174 
 
5099 varun.gupt 1175 
  def updateOrderAsPaidToVendor(self, orderId):
1176 
    """
1177 
    Parameters:
1178 
     - orderId
1179 
    """
1180 
    pass
5067 varun.gupt 1181 
 
5386 phani.kuma 1182 
  def updateOrderOnlyAsPaidToVendor(self, orderId):
1183 
    """
1184 
    Parameters:
1185 
     - orderId
1186 
    """
1187 
    pass
1188 
 
5208 varun.gupt 1189 
  def getRefundedOrdersMarkedPaid(self, ):
1190 
    pass
5099 varun.gupt 1191 
 
5447 anupam.sin 1192 
  def getAllVerificationAgents(self, minOrderId, maxOrderId):
1193 
    """
1194 
    gets all COD Verification Agents for all orderIds from a minId to maxId
5208 varun.gupt 1195 
 
5447 anupam.sin 1196 
 
1197 
    Parameters:
1198 
     - minOrderId
1199 
     - maxOrderId
1200 
    """
1201 
    pass
1202 
 
5527 anupam.sin 1203 
  def getAllAttributesForOrderId(self, orderId):
1204 
    """
1205 
    gets all attributes for a given orderId
5447 anupam.sin 1206 
 
5527 anupam.sin 1207 
    Parameters:
1208 
     - orderId
1209 
    """
1210 
    pass
1211 
 
5676 rajveer 1212 
  def setOrderAttributes(self, orderId, attributes):
1213 
    """
1214 
    sets attributes for an order
1215 
 
1216 
    Parameters:
1217 
     - orderId
1218 
     - attributes
1219 
    """
1220 
    pass
1221 
 
5527 anupam.sin 1222 
  def setOrderAttributeForTransaction(self, transactionId, attribute):
1223 
    """
1224 
    sets attributes for all orders in a transaction
1225 
 
1226 
    Parameters:
1227 
     - transactionId
1228 
     - attribute
1229 
    """
1230 
    pass
1231 
 
5553 rajveer 1232 
  def getReceivePendingOrders(self, storeId):
1233 
    """
1234 
    Parameters:
1235 
     - storeId
1236 
    """
1237 
    pass
5527 anupam.sin 1238 
 
5553 rajveer 1239 
  def getReceivedAtStoreOrders(self, storeId):
1240 
    """
1241 
    Parameters:
1242 
     - storeId
1243 
    """
1244 
    pass
1245 
 
5713 rajveer 1246 
  def getOrdersCollectionAtStore(self, storeId, fromDate, toDate, onlyCod):
1247 
    """
1248 
    Parameters:
1249 
     - storeId
1250 
     - fromDate
1251 
     - toDate
1252 
     - onlyCod
1253 
    """
1254 
    pass
1255 
 
5833 rajveer 1256 
  def getOrderAttributeValue(self, orderId, attributeName):
1257 
    """
1258 
    Parameters:
1259 
     - orderId
1260 
     - attributeName
1261 
    """
1262 
    pass
1263 
 
6019 rajveer 1264 
  def changeJacketNumber(self, orderId, jacketNumber):
1265 
    """
1266 
    Parameters:
1267 
     - orderId
1268 
     - jacketNumber
1269 
    """
1270 
    pass
1271 
 
1272 
  def markOrderAsRtoInTransit(self, orderId):
1273 
    """
1274 
    Parameters:
1275 
     - orderId
1276 
    """
1277 
    pass
1278 
 
5593 mandeep.dh 1279 
  def acceptOrderForItem(self, itemId, quantity, fulfilmentWarehouseId, billingWarehouseId):
1280 
    """
1281 
    Accepts appropriate order for an item in a given billingWarehouse. Usually
1282 
    invoked while scanning IN of items.
5553 rajveer 1283 
 
5593 mandeep.dh 1284 
    Parameters:
1285 
     - itemId
1286 
     - quantity
1287 
     - fulfilmentWarehouseId
1288 
     - billingWarehouseId
1289 
    """
1290 
    pass
1291 
 
6000 mandeep.dh 1292 
  def createRechargeOrder(self, rechargeOrder):
1293 
    """
1294 
    Parameters:
1295 
     - rechargeOrder
1296 
    """
1297 
    pass
5593 mandeep.dh 1298 
 
6031 rajveer 1299 
  def getRechargeOrder(self, rechargeRrderId):
1300 
    """
1301 
    Parameters:
1302 
     - rechargeRrderId
1303 
    """
1304 
    pass
1305 
 
1306 
  def getRechargeOrders(self, userId):
1307 
    """
1308 
    Parameters:
1309 
     - userId
1310 
    """
1311 
    pass
1312 
 
6000 mandeep.dh 1313 
  def updateRechargeOrderStatus(self, rechargeOrderId, rechargeOrderStatus):
1314 
    """
1315 
    Parameters:
1316 
     - rechargeOrderId
1317 
     - rechargeOrderStatus
1318 
    """
1319 
    pass
1320 
 
6031 rajveer 1321 
  def activateRechargeTxn(self, rechargeOrderId):
6000 mandeep.dh 1322 
    """
1323 
    Parameters:
6031 rajveer 1324 
     - rechargeOrderId
6000 mandeep.dh 1325 
    """
1326 
    pass
1327 
 
6031 rajveer 1328 
  def getUserWallet(self, userId):
6000 mandeep.dh 1329 
    """
1330 
    Parameters:
6031 rajveer 1331 
     - userId
6000 mandeep.dh 1332 
    """
1333 
    pass
1334 
 
6031 rajveer 1335 
  def getUserWalletHistory(self, userId):
6000 mandeep.dh 1336 
    """
1337 
    Parameters:
6031 rajveer 1338 
     - userId
6000 mandeep.dh 1339 
    """
1340 
    pass
1341 
 
6050 anupam.sin 1342 
  def getRechargeOrdersForTransaction(self, txnId):
1343 
    """
1344 
    Returns a recharge order for a given transactionId
1345 
 
1346 
    Parameters:
1347 
     - txnId
1348 
    """
1349 
    pass
1350 
 
6206 rajveer 1351 
  def getServiceProviders(self, rechargeType, onlyActive):
6048 rajveer 1352 
    """
1353 
    Parameters:
1354 
     - rechargeType
6206 rajveer 1355 
     - onlyActive
6048 rajveer 1356 
    """
1357 
    pass
6000 mandeep.dh 1358 
 
6049 rajveer 1359 
  def getServiceProviderForDevice(self, rechargeType, deviceNumber):
6048 rajveer 1360 
    """
1361 
    Parameters:
6049 rajveer 1362 
     - rechargeType
6048 rajveer 1363 
     - deviceNumber
1364 
    """
1365 
    pass
1366 
 
6591 anupam.sin 1367 
  def validateRecharge(self, rechargeType, deviceNumber, userSelectedProviderId, clientAddress):
6269 rajveer 1368 
    """
1369 
    Parameters:
1370 
     - rechargeType
1371 
     - deviceNumber
6307 anupam.sin 1372 
     - userSelectedProviderId
6591 anupam.sin 1373 
     - clientAddress
6269 rajveer 1374 
    """
1375 
    pass
1376 
 
6094 rajveer 1377 
  def getRechargeOrdersForDevice(self, deviceNumber):
1378 
    """
1379 
    Parameters:
1380 
     - deviceNumber
1381 
    """
1382 
    pass
6048 rajveer 1383 
 
6094 rajveer 1384 
  def addAmountToWallet(self, userId, orderId, amount):
1385 
    """
1386 
    Parameters:
1387 
     - userId
1388 
     - orderId
1389 
     - amount
1390 
    """
1391 
    pass
1392 
 
6188 rajveer 1393 
  def getRechargeStatistics(self, ):
1394 
    pass
1395 
 
6154 rajveer 1396 
  def getRechargeOrdersForStatus(self, status):
1397 
    """
1398 
    Parameters:
1399 
     - status
1400 
    """
1401 
    pass
6094 rajveer 1402 
 
6159 rajveer 1403 
  def getPlansForOperator(self, operatorId):
1404 
    """
1405 
    Parameters:
1406 
     - operatorId
1407 
    """
1408 
    pass
6154 rajveer 1409 
 
6307 anupam.sin 1410 
  def getRechargeDenominations(self, operatorId, circleCode, denominationType):
6289 anupam.sin 1411 
    """
1412 
    Returns denominations for a given operator and circle
6159 rajveer 1413 
 
6289 anupam.sin 1414 
    Parameters:
1415 
     - operatorId
6307 anupam.sin 1416 
     - circleCode
6289 anupam.sin 1417 
     - denominationType
1418 
    """
1419 
    pass
1420 
 
6371 rajveer 1421 
  def updateAvailabilityStatus(self, operatorId, circleId, isAvailable):
1422 
    """
1423 
    Parameters:
1424 
     - operatorId
1425 
     - circleId
1426 
     - isAvailable
1427 
    """
1428 
    pass
6289 anupam.sin 1429 
 
6389 rajveer 1430 
  def getAvailableEmiSchemes(self, ):
1431 
    pass
6371 rajveer 1432 
 
6389 rajveer 1433 
  def getMiscCharges(self, transactionId):
1434 
    """
1435 
    Parameters:
1436 
     - transactionId
1437 
    """
1438 
    pass
1439 
 
6507 anupam.sin 1440 
  def refundRechargeOrder(self, rechargeOrderId):
1441 
    """
1442 
    Parameters:
1443 
     - rechargeOrderId
1444 
    """
1445 
    pass
6389 rajveer 1446 
 
6821 amar.kumar 1447 
  def getPhysicalOrders(self, fromDate, toDate):
1448 
    """
1449 
    Parameters:
1450 
     - fromDate
1451 
     - toDate
1452 
    """
1453 
    pass
6507 anupam.sin 1454 
 
6906 rajveer 1455 
  def getDocument(self, docType, docSource):
1456 
    """
1457 
    Parameters:
1458 
     - docType
1459 
     - docSource
1460 
    """
1461 
    pass
6821 amar.kumar 1462 
 
6985 anupam.sin 1463 
  def changeShippingAddress(self, orderId, line1, line2, city, state, pin):
1464 
    """
1465 
    Parameters:
1466 
     - orderId
1467 
     - line1
1468 
     - line2
1469 
     - city
1470 
     - state
1471 
     - pin
1472 
    """
1473 
    pass
6906 rajveer 1474 
 
7075 rajveer 1475 
  def retrieveInvoice(self, orderId, userId):
6988 rajveer 1476 
    """
1477 
    Parameters:
1478 
     - orderId
7075 rajveer 1479 
     - userId
6988 rajveer 1480 
    """
1481 
    pass
6985 anupam.sin 1482 
 
7026 rajveer 1483 
  def receiveUpdatesForRedExpress(self, awbNumber):
1484 
    """
1485 
    Parameters:
1486 
     - awbNumber
1487 
    """
1488 
    pass
6988 rajveer 1489 
 
7073 anupam.sin 1490 
  def createRechargeTransaction(self, thriftRechargeTransaction):
1491 
    """
1492 
    Parameters:
1493 
     - thriftRechargeTransaction
1494 
    """
1495 
    pass
7026 rajveer 1496 
 
7085 rajveer 1497 
  def getRechargeTransactions(self, storeId):
1498 
    """
1499 
    Parameters:
1500 
     - storeId
1501 
    """
1502 
    pass
1503 
 
7151 amit.gupta 1504 
  def getRechargeTrans(self, storeId, startDate, endDate, status):
1505 
    """
1506 
    Parameters:
1507 
     - storeId
1508 
     - startDate
1509 
     - endDate
1510 
     - status
1511 
    """
1512 
    pass
1513 
 
7080 anupam.sin 1514 
  def getRechargeTransaction(self, rechargeId):
1515 
    """
1516 
    Parameters:
1517 
     - rechargeId
1518 
    """
1519 
    pass
7073 anupam.sin 1520 
 
7080 anupam.sin 1521 
  def getFRCs(self, circleId, operatorId):
1522 
    """
1523 
    Parameters:
1524 
     - circleId
1525 
     - operatorId
1526 
    """
1527 
    pass
1528 
 
7096 anupam.sin 1529 
  def getHotspotStore(self, id, hotspotid):
1530 
    """
1531 
    Parameters:
1532 
     - id
1533 
     - hotspotid
1534 
    """
1535 
    pass
7080 anupam.sin 1536 
 
7096 anupam.sin 1537 
  def getTelecomCircle(self, id, code):
1538 
    """
1539 
    Parameters:
1540 
     - id
1541 
     - code
1542 
    """
1543 
    pass
1544 
 
7109 anupam.sin 1545 
  def retrieveHotspotRechargeInvoice(self, rechargeId):
1546 
    """
1547 
    Parameters:
1548 
     - rechargeId
1549 
    """
1550 
    pass
7096 anupam.sin 1551 
 
7109 anupam.sin 1552 
 
3376 rajveer 1553 
class Client(shop2020.thriftpy.generic.GenericService.Client, Iface):
94 ashish 1554 
  def __init__(self, iprot, oprot=None):
3376 rajveer 1555 
    shop2020.thriftpy.generic.GenericService.Client.__init__(self, iprot, oprot)
94 ashish 1556 
 
1557 
  def createTransaction(self, transaction):
1558 
    """
1559 
    Parameters:
1560 
     - transaction
1561 
    """
1562 
    self.send_createTransaction(transaction)
132 ashish 1563 
    return self.recv_createTransaction()
94 ashish 1564 
 
1565 
  def send_createTransaction(self, transaction):
1566 
    self._oprot.writeMessageBegin('createTransaction', TMessageType.CALL, self._seqid)
1567 
    args = createTransaction_args()
1568 
    args.transaction = transaction
1569 
    args.write(self._oprot)
1570 
    self._oprot.writeMessageEnd()
1571 
    self._oprot.trans.flush()
1572 
 
1573 
  def recv_createTransaction(self, ):
1574 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1575 
    if mtype == TMessageType.EXCEPTION:
1576 
      x = TApplicationException()
1577 
      x.read(self._iprot)
1578 
      self._iprot.readMessageEnd()
1579 
      raise x
1580 
    result = createTransaction_result()
1581 
    result.read(self._iprot)
1582 
    self._iprot.readMessageEnd()
3431 rajveer 1583 
    if result.success is not None:
132 ashish 1584 
      return result.success
3431 rajveer 1585 
    if result.ex is not None:
94 ashish 1586 
      raise result.ex
132 ashish 1587 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createTransaction failed: unknown result");
94 ashish 1588 
 
1589 
  def getTransaction(self, id):
1590 
    """
1591 
    Parameters:
1592 
     - id
1593 
    """
1594 
    self.send_getTransaction(id)
1595 
    return self.recv_getTransaction()
1596 
 
1597 
  def send_getTransaction(self, id):
1598 
    self._oprot.writeMessageBegin('getTransaction', TMessageType.CALL, self._seqid)
1599 
    args = getTransaction_args()
1600 
    args.id = id
1601 
    args.write(self._oprot)
1602 
    self._oprot.writeMessageEnd()
1603 
    self._oprot.trans.flush()
1604 
 
1605 
  def recv_getTransaction(self, ):
1606 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1607 
    if mtype == TMessageType.EXCEPTION:
1608 
      x = TApplicationException()
1609 
      x.read(self._iprot)
1610 
      self._iprot.readMessageEnd()
1611 
      raise x
1612 
    result = getTransaction_result()
1613 
    result.read(self._iprot)
1614 
    self._iprot.readMessageEnd()
3431 rajveer 1615 
    if result.success is not None:
94 ashish 1616 
      return result.success
3431 rajveer 1617 
    if result.ex is not None:
94 ashish 1618 
      raise result.ex
1619 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransaction failed: unknown result");
1620 
 
1621 
  def getTransactionsForCustomer(self, customerId, from_date, to_date, status):
1622 
    """
1623 
    Parameters:
1624 
     - customerId
1625 
     - from_date
1626 
     - to_date
1627 
     - status
1628 
    """
1629 
    self.send_getTransactionsForCustomer(customerId, from_date, to_date, status)
1630 
    return self.recv_getTransactionsForCustomer()
1631 
 
1632 
  def send_getTransactionsForCustomer(self, customerId, from_date, to_date, status):
1633 
    self._oprot.writeMessageBegin('getTransactionsForCustomer', TMessageType.CALL, self._seqid)
1634 
    args = getTransactionsForCustomer_args()
1635 
    args.customerId = customerId
1636 
    args.from_date = from_date
1637 
    args.to_date = to_date
1638 
    args.status = status
1639 
    args.write(self._oprot)
1640 
    self._oprot.writeMessageEnd()
1641 
    self._oprot.trans.flush()
1642 
 
1643 
  def recv_getTransactionsForCustomer(self, ):
1644 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1645 
    if mtype == TMessageType.EXCEPTION:
1646 
      x = TApplicationException()
1647 
      x.read(self._iprot)
1648 
      self._iprot.readMessageEnd()
1649 
      raise x
1650 
    result = getTransactionsForCustomer_result()
1651 
    result.read(self._iprot)
1652 
    self._iprot.readMessageEnd()
3431 rajveer 1653 
    if result.success is not None:
94 ashish 1654 
      return result.success
3431 rajveer 1655 
    if result.ex is not None:
94 ashish 1656 
      raise result.ex
1657 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransactionsForCustomer failed: unknown result");
1658 
 
132 ashish 1659 
  def getTransactionsForShoppingCartId(self, shoppingCartId):
1660 
    """
1661 
    Parameters:
1662 
     - shoppingCartId
1663 
    """
1664 
    self.send_getTransactionsForShoppingCartId(shoppingCartId)
1665 
    return self.recv_getTransactionsForShoppingCartId()
1666 
 
1667 
  def send_getTransactionsForShoppingCartId(self, shoppingCartId):
1668 
    self._oprot.writeMessageBegin('getTransactionsForShoppingCartId', TMessageType.CALL, self._seqid)
1669 
    args = getTransactionsForShoppingCartId_args()
1670 
    args.shoppingCartId = shoppingCartId
1671 
    args.write(self._oprot)
1672 
    self._oprot.writeMessageEnd()
1673 
    self._oprot.trans.flush()
1674 
 
1675 
  def recv_getTransactionsForShoppingCartId(self, ):
1676 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1677 
    if mtype == TMessageType.EXCEPTION:
1678 
      x = TApplicationException()
1679 
      x.read(self._iprot)
1680 
      self._iprot.readMessageEnd()
1681 
      raise x
1682 
    result = getTransactionsForShoppingCartId_result()
1683 
    result.read(self._iprot)
1684 
    self._iprot.readMessageEnd()
3431 rajveer 1685 
    if result.success is not None:
132 ashish 1686 
      return result.success
3431 rajveer 1687 
    if result.ex is not None:
132 ashish 1688 
      raise result.ex
1689 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransactionsForShoppingCartId failed: unknown result");
1690 
 
94 ashish 1691 
  def getTransactionStatus(self, transactionId):
1692 
    """
1693 
    Parameters:
1694 
     - transactionId
1695 
    """
1696 
    self.send_getTransactionStatus(transactionId)
1697 
    return self.recv_getTransactionStatus()
1698 
 
1699 
  def send_getTransactionStatus(self, transactionId):
1700 
    self._oprot.writeMessageBegin('getTransactionStatus', TMessageType.CALL, self._seqid)
1701 
    args = getTransactionStatus_args()
1702 
    args.transactionId = transactionId
1703 
    args.write(self._oprot)
1704 
    self._oprot.writeMessageEnd()
1705 
    self._oprot.trans.flush()
1706 
 
1707 
  def recv_getTransactionStatus(self, ):
1708 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1709 
    if mtype == TMessageType.EXCEPTION:
1710 
      x = TApplicationException()
1711 
      x.read(self._iprot)
1712 
      self._iprot.readMessageEnd()
1713 
      raise x
1714 
    result = getTransactionStatus_result()
1715 
    result.read(self._iprot)
1716 
    self._iprot.readMessageEnd()
3431 rajveer 1717 
    if result.success is not None:
94 ashish 1718 
      return result.success
3431 rajveer 1719 
    if result.ex is not None:
94 ashish 1720 
      raise result.ex
1721 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransactionStatus failed: unknown result");
1722 
 
5527 anupam.sin 1723 
  def changeTransactionStatus(self, transactionId, status, description, pickUp, orderType):
94 ashish 1724 
    """
1725 
    Parameters:
1726 
     - transactionId
1727 
     - status
1728 
     - description
5527 anupam.sin 1729 
     - pickUp
1730 
     - orderType
94 ashish 1731 
    """
5527 anupam.sin 1732 
    self.send_changeTransactionStatus(transactionId, status, description, pickUp, orderType)
94 ashish 1733 
    return self.recv_changeTransactionStatus()
1734 
 
5527 anupam.sin 1735 
  def send_changeTransactionStatus(self, transactionId, status, description, pickUp, orderType):
94 ashish 1736 
    self._oprot.writeMessageBegin('changeTransactionStatus', TMessageType.CALL, self._seqid)
1737 
    args = changeTransactionStatus_args()
1738 
    args.transactionId = transactionId
1739 
    args.status = status
1740 
    args.description = description
5527 anupam.sin 1741 
    args.pickUp = pickUp
1742 
    args.orderType = orderType
94 ashish 1743 
    args.write(self._oprot)
1744 
    self._oprot.writeMessageEnd()
1745 
    self._oprot.trans.flush()
1746 
 
1747 
  def recv_changeTransactionStatus(self, ):
1748 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1749 
    if mtype == TMessageType.EXCEPTION:
1750 
      x = TApplicationException()
1751 
      x.read(self._iprot)
1752 
      self._iprot.readMessageEnd()
1753 
      raise x
1754 
    result = changeTransactionStatus_result()
1755 
    result.read(self._iprot)
1756 
    self._iprot.readMessageEnd()
3431 rajveer 1757 
    if result.success is not None:
94 ashish 1758 
      return result.success
3431 rajveer 1759 
    if result.ex is not None:
94 ashish 1760 
      raise result.ex
1761 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "changeTransactionStatus failed: unknown result");
1762 
 
1398 varun.gupt 1763 
  def enqueueTransactionInfoEmail(self, transactionId):
1382 varun.gupt 1764 
    """
1765 
    Parameters:
1766 
     - transactionId
1767 
    """
1398 varun.gupt 1768 
    self.send_enqueueTransactionInfoEmail(transactionId)
1769 
    return self.recv_enqueueTransactionInfoEmail()
1382 varun.gupt 1770 
 
1398 varun.gupt 1771 
  def send_enqueueTransactionInfoEmail(self, transactionId):
1772 
    self._oprot.writeMessageBegin('enqueueTransactionInfoEmail', TMessageType.CALL, self._seqid)
1773 
    args = enqueueTransactionInfoEmail_args()
1382 varun.gupt 1774 
    args.transactionId = transactionId
1775 
    args.write(self._oprot)
1776 
    self._oprot.writeMessageEnd()
1777 
    self._oprot.trans.flush()
1778 
 
1398 varun.gupt 1779 
  def recv_enqueueTransactionInfoEmail(self, ):
1382 varun.gupt 1780 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1781 
    if mtype == TMessageType.EXCEPTION:
1782 
      x = TApplicationException()
1783 
      x.read(self._iprot)
1784 
      self._iprot.readMessageEnd()
1785 
      raise x
1398 varun.gupt 1786 
    result = enqueueTransactionInfoEmail_result()
1382 varun.gupt 1787 
    result.read(self._iprot)
1788 
    self._iprot.readMessageEnd()
3431 rajveer 1789 
    if result.success is not None:
1382 varun.gupt 1790 
      return result.success
3431 rajveer 1791 
    if result.ex is not None:
1382 varun.gupt 1792 
      raise result.ex
1398 varun.gupt 1793 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "enqueueTransactionInfoEmail failed: unknown result");
1382 varun.gupt 1794 
 
4801 anupam.sin 1795 
  def getAllOrders(self, statuses, from_date, to_date, warehouse_id):
94 ashish 1796 
    """
1797 
    Parameters:
4801 anupam.sin 1798 
     - statuses
483 rajveer 1799 
     - from_date
1800 
     - to_date
1801 
     - warehouse_id
94 ashish 1802 
    """
4801 anupam.sin 1803 
    self.send_getAllOrders(statuses, from_date, to_date, warehouse_id)
483 rajveer 1804 
    return self.recv_getAllOrders()
94 ashish 1805 
 
4801 anupam.sin 1806 
  def send_getAllOrders(self, statuses, from_date, to_date, warehouse_id):
483 rajveer 1807 
    self._oprot.writeMessageBegin('getAllOrders', TMessageType.CALL, self._seqid)
1808 
    args = getAllOrders_args()
4801 anupam.sin 1809 
    args.statuses = statuses
483 rajveer 1810 
    args.from_date = from_date
1811 
    args.to_date = to_date
1812 
    args.warehouse_id = warehouse_id
94 ashish 1813 
    args.write(self._oprot)
1814 
    self._oprot.writeMessageEnd()
1815 
    self._oprot.trans.flush()
1816 
 
483 rajveer 1817 
  def recv_getAllOrders(self, ):
94 ashish 1818 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1819 
    if mtype == TMessageType.EXCEPTION:
1820 
      x = TApplicationException()
1821 
      x.read(self._iprot)
1822 
      self._iprot.readMessageEnd()
1823 
      raise x
483 rajveer 1824 
    result = getAllOrders_result()
94 ashish 1825 
    result.read(self._iprot)
1826 
    self._iprot.readMessageEnd()
3431 rajveer 1827 
    if result.success is not None:
94 ashish 1828 
      return result.success
3431 rajveer 1829 
    if result.ex is not None:
94 ashish 1830 
      raise result.ex
483 rajveer 1831 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllOrders failed: unknown result");
94 ashish 1832 
 
4133 chandransh 1833 
  def getOrdersInBatch(self, statuses, offset, limit, warehouse_id):
1834 
    """
1835 
    Returns at most 'limit' orders with the given statuses for the given warehouse starting from the given offset.
1836 
    Pass the status as null and the limit as 0 to ignore them.
1837 
 
1838 
    Parameters:
1839 
     - statuses
1840 
     - offset
1841 
     - limit
1842 
     - warehouse_id
1843 
    """
1844 
    self.send_getOrdersInBatch(statuses, offset, limit, warehouse_id)
1845 
    return self.recv_getOrdersInBatch()
1846 
 
1847 
  def send_getOrdersInBatch(self, statuses, offset, limit, warehouse_id):
1848 
    self._oprot.writeMessageBegin('getOrdersInBatch', TMessageType.CALL, self._seqid)
1849 
    args = getOrdersInBatch_args()
1850 
    args.statuses = statuses
1851 
    args.offset = offset
1852 
    args.limit = limit
1853 
    args.warehouse_id = warehouse_id
1854 
    args.write(self._oprot)
1855 
    self._oprot.writeMessageEnd()
1856 
    self._oprot.trans.flush()
1857 
 
1858 
  def recv_getOrdersInBatch(self, ):
1859 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1860 
    if mtype == TMessageType.EXCEPTION:
1861 
      x = TApplicationException()
1862 
      x.read(self._iprot)
1863 
      self._iprot.readMessageEnd()
1864 
      raise x
1865 
    result = getOrdersInBatch_result()
1866 
    result.read(self._iprot)
1867 
    self._iprot.readMessageEnd()
1868 
    if result.success is not None:
1869 
      return result.success
1870 
    if result.ex is not None:
1871 
      raise result.ex
1872 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersInBatch failed: unknown result");
1873 
 
1874 
  def getOrderCount(self, statuses, warehouseId):
1875 
    """
1876 
    Returns the count of orders with the given statuses assigned to the given warehouse.
1877 
 
1878 
    Parameters:
1879 
     - statuses
1880 
     - warehouseId
1881 
    """
1882 
    self.send_getOrderCount(statuses, warehouseId)
1883 
    return self.recv_getOrderCount()
1884 
 
1885 
  def send_getOrderCount(self, statuses, warehouseId):
1886 
    self._oprot.writeMessageBegin('getOrderCount', TMessageType.CALL, self._seqid)
1887 
    args = getOrderCount_args()
1888 
    args.statuses = statuses
1889 
    args.warehouseId = warehouseId
1890 
    args.write(self._oprot)
1891 
    self._oprot.writeMessageEnd()
1892 
    self._oprot.trans.flush()
1893 
 
1894 
  def recv_getOrderCount(self, ):
1895 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1896 
    if mtype == TMessageType.EXCEPTION:
1897 
      x = TApplicationException()
1898 
      x.read(self._iprot)
1899 
      self._iprot.readMessageEnd()
1900 
      raise x
1901 
    result = getOrderCount_result()
1902 
    result.read(self._iprot)
1903 
    self._iprot.readMessageEnd()
1904 
    if result.success is not None:
1905 
      return result.success
1906 
    if result.ex is not None:
1907 
      raise result.ex
1908 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderCount failed: unknown result");
1909 
 
999 varun.gupt 1910 
  def getOrdersByBillingDate(self, status, start_billing_date, end_billing_date, warehouse_id):
1911 
    """
1132 chandransh 1912 
    Returns orders within a range of their billing dates
3431 rajveer 1913 
 
999 varun.gupt 1914 
    Parameters:
1915 
     - status
1916 
     - start_billing_date
1917 
     - end_billing_date
1918 
     - warehouse_id
1919 
    """
1920 
    self.send_getOrdersByBillingDate(status, start_billing_date, end_billing_date, warehouse_id)
1921 
    return self.recv_getOrdersByBillingDate()
1922 
 
1923 
  def send_getOrdersByBillingDate(self, status, start_billing_date, end_billing_date, warehouse_id):
1924 
    self._oprot.writeMessageBegin('getOrdersByBillingDate', TMessageType.CALL, self._seqid)
1925 
    args = getOrdersByBillingDate_args()
1926 
    args.status = status
1927 
    args.start_billing_date = start_billing_date
1928 
    args.end_billing_date = end_billing_date
1929 
    args.warehouse_id = warehouse_id
1930 
    args.write(self._oprot)
1931 
    self._oprot.writeMessageEnd()
1932 
    self._oprot.trans.flush()
1933 
 
1934 
  def recv_getOrdersByBillingDate(self, ):
1935 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1936 
    if mtype == TMessageType.EXCEPTION:
1937 
      x = TApplicationException()
1938 
      x.read(self._iprot)
1939 
      self._iprot.readMessageEnd()
1940 
      raise x
1941 
    result = getOrdersByBillingDate_result()
1942 
    result.read(self._iprot)
1943 
    self._iprot.readMessageEnd()
3431 rajveer 1944 
    if result.success is not None:
999 varun.gupt 1945 
      return result.success
3431 rajveer 1946 
    if result.ex is not None:
999 varun.gupt 1947 
      raise result.ex
1948 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersByBillingDate failed: unknown result");
1949 
 
3451 chandransh 1950 
  def getOrdersByShippingDate(self, fromShippingDate, toShippingDate, providerId, warehouseId, cod):
3427 chandransh 1951 
    """
1952 
    Returns orders for a particular provider and warehouse which were shipped between the given dates.
3451 chandransh 1953 
    Returned orders comprise of COD orders if cod parameter is true. It comprises of prepaid orders otherwise.
1954 
    Pass providerId and warehouseId as -1 to ignore both these parameters.
3431 rajveer 1955 
 
3427 chandransh 1956 
    Parameters:
1957 
     - fromShippingDate
1958 
     - toShippingDate
1959 
     - providerId
1960 
     - warehouseId
3451 chandransh 1961 
     - cod
3427 chandransh 1962 
    """
3451 chandransh 1963 
    self.send_getOrdersByShippingDate(fromShippingDate, toShippingDate, providerId, warehouseId, cod)
3427 chandransh 1964 
    return self.recv_getOrdersByShippingDate()
1965 
 
3451 chandransh 1966 
  def send_getOrdersByShippingDate(self, fromShippingDate, toShippingDate, providerId, warehouseId, cod):
3427 chandransh 1967 
    self._oprot.writeMessageBegin('getOrdersByShippingDate', TMessageType.CALL, self._seqid)
1968 
    args = getOrdersByShippingDate_args()
1969 
    args.fromShippingDate = fromShippingDate
1970 
    args.toShippingDate = toShippingDate
1971 
    args.providerId = providerId
1972 
    args.warehouseId = warehouseId
3451 chandransh 1973 
    args.cod = cod
3427 chandransh 1974 
    args.write(self._oprot)
1975 
    self._oprot.writeMessageEnd()
1976 
    self._oprot.trans.flush()
1977 
 
1978 
  def recv_getOrdersByShippingDate(self, ):
1979 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1980 
    if mtype == TMessageType.EXCEPTION:
1981 
      x = TApplicationException()
1982 
      x.read(self._iprot)
1983 
      self._iprot.readMessageEnd()
1984 
      raise x
1985 
    result = getOrdersByShippingDate_result()
1986 
    result.read(self._iprot)
1987 
    self._iprot.readMessageEnd()
3431 rajveer 1988 
    if result.success is not None:
3427 chandransh 1989 
      return result.success
3431 rajveer 1990 
    if result.ex is not None:
3427 chandransh 1991 
      raise result.ex
1992 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersByShippingDate failed: unknown result");
1993 
 
1382 varun.gupt 1994 
  def getReturnableOrdersForCustomer(self, customer_id, limit):
1995 
    """
1996 
    Returns order ids for orders which can be returned
3431 rajveer 1997 
 
1382 varun.gupt 1998 
    Parameters:
1999 
     - customer_id
2000 
     - limit
2001 
    """
2002 
    self.send_getReturnableOrdersForCustomer(customer_id, limit)
2003 
    return self.recv_getReturnableOrdersForCustomer()
2004 
 
2005 
  def send_getReturnableOrdersForCustomer(self, customer_id, limit):
2006 
    self._oprot.writeMessageBegin('getReturnableOrdersForCustomer', TMessageType.CALL, self._seqid)
2007 
    args = getReturnableOrdersForCustomer_args()
2008 
    args.customer_id = customer_id
2009 
    args.limit = limit
2010 
    args.write(self._oprot)
2011 
    self._oprot.writeMessageEnd()
2012 
    self._oprot.trans.flush()
2013 
 
2014 
  def recv_getReturnableOrdersForCustomer(self, ):
2015 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2016 
    if mtype == TMessageType.EXCEPTION:
2017 
      x = TApplicationException()
2018 
      x.read(self._iprot)
2019 
      self._iprot.readMessageEnd()
2020 
      raise x
2021 
    result = getReturnableOrdersForCustomer_result()
2022 
    result.read(self._iprot)
2023 
    self._iprot.readMessageEnd()
3431 rajveer 2024 
    if result.success is not None:
1382 varun.gupt 2025 
      return result.success
3431 rajveer 2026 
    if result.ex is not None:
1382 varun.gupt 2027 
      raise result.ex
2028 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReturnableOrdersForCustomer failed: unknown result");
2029 
 
2030 
  def getCancellableOrdersForCustomer(self, customer_id, limit):
2031 
    """
2032 
    Returns order ids for orders which can be cancelled
3431 rajveer 2033 
 
1382 varun.gupt 2034 
    Parameters:
2035 
     - customer_id
2036 
     - limit
2037 
    """
2038 
    self.send_getCancellableOrdersForCustomer(customer_id, limit)
2039 
    return self.recv_getCancellableOrdersForCustomer()
2040 
 
2041 
  def send_getCancellableOrdersForCustomer(self, customer_id, limit):
2042 
    self._oprot.writeMessageBegin('getCancellableOrdersForCustomer', TMessageType.CALL, self._seqid)
2043 
    args = getCancellableOrdersForCustomer_args()
2044 
    args.customer_id = customer_id
2045 
    args.limit = limit
2046 
    args.write(self._oprot)
2047 
    self._oprot.writeMessageEnd()
2048 
    self._oprot.trans.flush()
2049 
 
2050 
  def recv_getCancellableOrdersForCustomer(self, ):
2051 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2052 
    if mtype == TMessageType.EXCEPTION:
2053 
      x = TApplicationException()
2054 
      x.read(self._iprot)
2055 
      self._iprot.readMessageEnd()
2056 
      raise x
2057 
    result = getCancellableOrdersForCustomer_result()
2058 
    result.read(self._iprot)
2059 
    self._iprot.readMessageEnd()
3431 rajveer 2060 
    if result.success is not None:
1382 varun.gupt 2061 
      return result.success
3431 rajveer 2062 
    if result.ex is not None:
1382 varun.gupt 2063 
      raise result.ex
2064 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCancellableOrdersForCustomer failed: unknown result");
2065 
 
483 rajveer 2066 
  def changeOrderStatus(self, orderId, status, description):
94 ashish 2067 
    """
2068 
    Parameters:
483 rajveer 2069 
     - orderId
2070 
     - status
2071 
     - description
94 ashish 2072 
    """
483 rajveer 2073 
    self.send_changeOrderStatus(orderId, status, description)
2074 
    return self.recv_changeOrderStatus()
94 ashish 2075 
 
483 rajveer 2076 
  def send_changeOrderStatus(self, orderId, status, description):
2077 
    self._oprot.writeMessageBegin('changeOrderStatus', TMessageType.CALL, self._seqid)
2078 
    args = changeOrderStatus_args()
2079 
    args.orderId = orderId
2080 
    args.status = status
2081 
    args.description = description
94 ashish 2082 
    args.write(self._oprot)
2083 
    self._oprot.writeMessageEnd()
2084 
    self._oprot.trans.flush()
2085 
 
483 rajveer 2086 
  def recv_changeOrderStatus(self, ):
94 ashish 2087 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2088 
    if mtype == TMessageType.EXCEPTION:
2089 
      x = TApplicationException()
2090 
      x.read(self._iprot)
2091 
      self._iprot.readMessageEnd()
2092 
      raise x
483 rajveer 2093 
    result = changeOrderStatus_result()
94 ashish 2094 
    result.read(self._iprot)
2095 
    self._iprot.readMessageEnd()
3431 rajveer 2096 
    if result.success is not None:
94 ashish 2097 
      return result.success
3431 rajveer 2098 
    if result.ex is not None:
94 ashish 2099 
      raise result.ex
483 rajveer 2100 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "changeOrderStatus failed: unknown result");
94 ashish 2101 
 
1528 ankur.sing 2102 
  def getOrdersForTransaction(self, transactionId, customerId):
94 ashish 2103 
    """
1528 ankur.sing 2104 
    Returns list of orders for given transaction Id. Also filters based on customer Id so that
2105 
    only user who owns the transaction can view its order details.
3431 rajveer 2106 
 
94 ashish 2107 
    Parameters:
2108 
     - transactionId
1528 ankur.sing 2109 
     - customerId
94 ashish 2110 
    """
1528 ankur.sing 2111 
    self.send_getOrdersForTransaction(transactionId, customerId)
483 rajveer 2112 
    return self.recv_getOrdersForTransaction()
94 ashish 2113 
 
1528 ankur.sing 2114 
  def send_getOrdersForTransaction(self, transactionId, customerId):
483 rajveer 2115 
    self._oprot.writeMessageBegin('getOrdersForTransaction', TMessageType.CALL, self._seqid)
2116 
    args = getOrdersForTransaction_args()
94 ashish 2117 
    args.transactionId = transactionId
1528 ankur.sing 2118 
    args.customerId = customerId
94 ashish 2119 
    args.write(self._oprot)
2120 
    self._oprot.writeMessageEnd()
2121 
    self._oprot.trans.flush()
2122 
 
483 rajveer 2123 
  def recv_getOrdersForTransaction(self, ):
94 ashish 2124 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2125 
    if mtype == TMessageType.EXCEPTION:
2126 
      x = TApplicationException()
2127 
      x.read(self._iprot)
2128 
      self._iprot.readMessageEnd()
2129 
      raise x
483 rajveer 2130 
    result = getOrdersForTransaction_result()
94 ashish 2131 
    result.read(self._iprot)
2132 
    self._iprot.readMessageEnd()
3431 rajveer 2133 
    if result.success is not None:
94 ashish 2134 
      return result.success
3431 rajveer 2135 
    if result.ex is not None:
94 ashish 2136 
      raise result.ex
483 rajveer 2137 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersForTransaction failed: unknown result");
94 ashish 2138 
 
3014 chandransh 2139 
  def getOrdersForCustomer(self, customerId, from_date, to_date, statuses):
94 ashish 2140 
    """
3014 chandransh 2141 
    Returns list of orders for the given customer created between the given dates and having the given statuses.
2142 
    Pass and empty list to ignore filtering on statuses.
3431 rajveer 2143 
 
94 ashish 2144 
    Parameters:
483 rajveer 2145 
     - customerId
2146 
     - from_date
2147 
     - to_date
3014 chandransh 2148 
     - statuses
94 ashish 2149 
    """
3014 chandransh 2150 
    self.send_getOrdersForCustomer(customerId, from_date, to_date, statuses)
483 rajveer 2151 
    return self.recv_getOrdersForCustomer()
94 ashish 2152 
 
3014 chandransh 2153 
  def send_getOrdersForCustomer(self, customerId, from_date, to_date, statuses):
483 rajveer 2154 
    self._oprot.writeMessageBegin('getOrdersForCustomer', TMessageType.CALL, self._seqid)
2155 
    args = getOrdersForCustomer_args()
2156 
    args.customerId = customerId
2157 
    args.from_date = from_date
2158 
    args.to_date = to_date
3014 chandransh 2159 
    args.statuses = statuses
94 ashish 2160 
    args.write(self._oprot)
2161 
    self._oprot.writeMessageEnd()
2162 
    self._oprot.trans.flush()
2163 
 
483 rajveer 2164 
  def recv_getOrdersForCustomer(self, ):
94 ashish 2165 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2166 
    if mtype == TMessageType.EXCEPTION:
2167 
      x = TApplicationException()
2168 
      x.read(self._iprot)
2169 
      self._iprot.readMessageEnd()
2170 
      raise x
483 rajveer 2171 
    result = getOrdersForCustomer_result()
94 ashish 2172 
    result.read(self._iprot)
2173 
    self._iprot.readMessageEnd()
3431 rajveer 2174 
    if result.success is not None:
94 ashish 2175 
      return result.success
3431 rajveer 2176 
    if result.ex is not None:
94 ashish 2177 
      raise result.ex
483 rajveer 2178 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersForCustomer failed: unknown result");
94 ashish 2179 
 
483 rajveer 2180 
  def createOrder(self, order):
94 ashish 2181 
    """
2182 
    Parameters:
483 rajveer 2183 
     - order
94 ashish 2184 
    """
483 rajveer 2185 
    self.send_createOrder(order)
2186 
    return self.recv_createOrder()
94 ashish 2187 
 
483 rajveer 2188 
  def send_createOrder(self, order):
2189 
    self._oprot.writeMessageBegin('createOrder', TMessageType.CALL, self._seqid)
2190 
    args = createOrder_args()
2191 
    args.order = order
94 ashish 2192 
    args.write(self._oprot)
2193 
    self._oprot.writeMessageEnd()
2194 
    self._oprot.trans.flush()
2195 
 
483 rajveer 2196 
  def recv_createOrder(self, ):
94 ashish 2197 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2198 
    if mtype == TMessageType.EXCEPTION:
2199 
      x = TApplicationException()
2200 
      x.read(self._iprot)
2201 
      self._iprot.readMessageEnd()
2202 
      raise x
483 rajveer 2203 
    result = createOrder_result()
94 ashish 2204 
    result.read(self._iprot)
2205 
    self._iprot.readMessageEnd()
3431 rajveer 2206 
    if result.success is not None:
94 ashish 2207 
      return result.success
3431 rajveer 2208 
    if result.ex is not None:
94 ashish 2209 
      raise result.ex
483 rajveer 2210 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createOrder failed: unknown result");
94 ashish 2211 
 
483 rajveer 2212 
  def getOrder(self, id):
94 ashish 2213 
    """
2214 
    Parameters:
483 rajveer 2215 
     - id
94 ashish 2216 
    """
483 rajveer 2217 
    self.send_getOrder(id)
2218 
    return self.recv_getOrder()
94 ashish 2219 
 
483 rajveer 2220 
  def send_getOrder(self, id):
2221 
    self._oprot.writeMessageBegin('getOrder', TMessageType.CALL, self._seqid)
2222 
    args = getOrder_args()
2223 
    args.id = id
94 ashish 2224 
    args.write(self._oprot)
2225 
    self._oprot.writeMessageEnd()
2226 
    self._oprot.trans.flush()
2227 
 
483 rajveer 2228 
  def recv_getOrder(self, ):
94 ashish 2229 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2230 
    if mtype == TMessageType.EXCEPTION:
2231 
      x = TApplicationException()
2232 
      x.read(self._iprot)
2233 
      self._iprot.readMessageEnd()
2234 
      raise x
483 rajveer 2235 
    result = getOrder_result()
94 ashish 2236 
    result.read(self._iprot)
2237 
    self._iprot.readMessageEnd()
3431 rajveer 2238 
    if result.success is not None:
94 ashish 2239 
      return result.success
3431 rajveer 2240 
    if result.ex is not None:
94 ashish 2241 
      raise result.ex
483 rajveer 2242 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrder failed: unknown result");
94 ashish 2243 
 
483 rajveer 2244 
  def getLineItemsForOrder(self, orderId):
94 ashish 2245 
    """
2246 
    Parameters:
483 rajveer 2247 
     - orderId
94 ashish 2248 
    """
483 rajveer 2249 
    self.send_getLineItemsForOrder(orderId)
2250 
    return self.recv_getLineItemsForOrder()
94 ashish 2251 
 
483 rajveer 2252 
  def send_getLineItemsForOrder(self, orderId):
2253 
    self._oprot.writeMessageBegin('getLineItemsForOrder', TMessageType.CALL, self._seqid)
2254 
    args = getLineItemsForOrder_args()
2255 
    args.orderId = orderId
94 ashish 2256 
    args.write(self._oprot)
2257 
    self._oprot.writeMessageEnd()
2258 
    self._oprot.trans.flush()
2259 
 
483 rajveer 2260 
  def recv_getLineItemsForOrder(self, ):
94 ashish 2261 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2262 
    if mtype == TMessageType.EXCEPTION:
2263 
      x = TApplicationException()
2264 
      x.read(self._iprot)
2265 
      self._iprot.readMessageEnd()
2266 
      raise x
483 rajveer 2267 
    result = getLineItemsForOrder_result()
94 ashish 2268 
    result.read(self._iprot)
2269 
    self._iprot.readMessageEnd()
3431 rajveer 2270 
    if result.success is not None:
94 ashish 2271 
      return result.success
3431 rajveer 2272 
    if result.ex is not None:
94 ashish 2273 
      raise result.ex
483 rajveer 2274 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getLineItemsForOrder failed: unknown result");
94 ashish 2275 
 
4999 phani.kuma 2276 
  def getOrderList(self, order_ids):
2277 
    """
2278 
    Parameters:
2279 
     - order_ids
2280 
    """
2281 
    self.send_getOrderList(order_ids)
2282 
    return self.recv_getOrderList()
2283 
 
2284 
  def send_getOrderList(self, order_ids):
2285 
    self._oprot.writeMessageBegin('getOrderList', TMessageType.CALL, self._seqid)
2286 
    args = getOrderList_args()
2287 
    args.order_ids = order_ids
2288 
    args.write(self._oprot)
2289 
    self._oprot.writeMessageEnd()
2290 
    self._oprot.trans.flush()
2291 
 
2292 
  def recv_getOrderList(self, ):
2293 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2294 
    if mtype == TMessageType.EXCEPTION:
2295 
      x = TApplicationException()
2296 
      x.read(self._iprot)
2297 
      self._iprot.readMessageEnd()
2298 
      raise x
2299 
    result = getOrderList_result()
2300 
    result.read(self._iprot)
2301 
    self._iprot.readMessageEnd()
2302 
    if result.success is not None:
2303 
      return result.success
2304 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderList failed: unknown result");
2305 
 
5386 phani.kuma 2306 
  def getOrderListForVendor(self, order_ids, vendorId):
2307 
    """
2308 
    Parameters:
2309 
     - order_ids
2310 
     - vendorId
2311 
    """
2312 
    self.send_getOrderListForVendor(order_ids, vendorId)
2313 
    return self.recv_getOrderListForVendor()
2314 
 
2315 
  def send_getOrderListForVendor(self, order_ids, vendorId):
2316 
    self._oprot.writeMessageBegin('getOrderListForVendor', TMessageType.CALL, self._seqid)
2317 
    args = getOrderListForVendor_args()
2318 
    args.order_ids = order_ids
2319 
    args.vendorId = vendorId
2320 
    args.write(self._oprot)
2321 
    self._oprot.writeMessageEnd()
2322 
    self._oprot.trans.flush()
2323 
 
2324 
  def recv_getOrderListForVendor(self, ):
2325 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2326 
    if mtype == TMessageType.EXCEPTION:
2327 
      x = TApplicationException()
2328 
      x.read(self._iprot)
2329 
      self._iprot.readMessageEnd()
2330 
      raise x
2331 
    result = getOrderListForVendor_result()
2332 
    result.read(self._iprot)
2333 
    self._iprot.readMessageEnd()
2334 
    if result.success is not None:
2335 
      return result.success
2336 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderListForVendor failed: unknown result");
2337 
 
1528 ankur.sing 2338 
  def getOrderForCustomer(self, orderId, customerId):
2339 
    """
2340 
    Returns an order for the order Id. Also checks if the order belongs to the customer whose Id is passed.
2341 
    Throws exception if either order Id is invalid or order does not below to the customer whose Id is passed.
3431 rajveer 2342 
 
1528 ankur.sing 2343 
    Parameters:
2344 
     - orderId
2345 
     - customerId
2346 
    """
2347 
    self.send_getOrderForCustomer(orderId, customerId)
2348 
    return self.recv_getOrderForCustomer()
2349 
 
2350 
  def send_getOrderForCustomer(self, orderId, customerId):
2351 
    self._oprot.writeMessageBegin('getOrderForCustomer', TMessageType.CALL, self._seqid)
2352 
    args = getOrderForCustomer_args()
2353 
    args.orderId = orderId
2354 
    args.customerId = customerId
2355 
    args.write(self._oprot)
2356 
    self._oprot.writeMessageEnd()
2357 
    self._oprot.trans.flush()
2358 
 
2359 
  def recv_getOrderForCustomer(self, ):
2360 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2361 
    if mtype == TMessageType.EXCEPTION:
2362 
      x = TApplicationException()
2363 
      x.read(self._iprot)
2364 
      self._iprot.readMessageEnd()
2365 
      raise x
2366 
    result = getOrderForCustomer_result()
2367 
    result.read(self._iprot)
2368 
    self._iprot.readMessageEnd()
3431 rajveer 2369 
    if result.success is not None:
1528 ankur.sing 2370 
      return result.success
3431 rajveer 2371 
    if result.ex is not None:
1528 ankur.sing 2372 
      raise result.ex
2373 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderForCustomer failed: unknown result");
2374 
 
4444 rajveer 2375 
  def getAlerts(self, type, warehouseId, status, timestamp):
3064 chandransh 2376 
    """
2377 
    Parameters:
4394 rajveer 2378 
     - type
4444 rajveer 2379 
     - warehouseId
4394 rajveer 2380 
     - status
2381 
     - timestamp
3064 chandransh 2382 
    """
4444 rajveer 2383 
    self.send_getAlerts(type, warehouseId, status, timestamp)
3064 chandransh 2384 
    return self.recv_getAlerts()
2385 
 
4444 rajveer 2386 
  def send_getAlerts(self, type, warehouseId, status, timestamp):
3064 chandransh 2387 
    self._oprot.writeMessageBegin('getAlerts', TMessageType.CALL, self._seqid)
2388 
    args = getAlerts_args()
4394 rajveer 2389 
    args.type = type
4444 rajveer 2390 
    args.warehouseId = warehouseId
4394 rajveer 2391 
    args.status = status
2392 
    args.timestamp = timestamp
3064 chandransh 2393 
    args.write(self._oprot)
2394 
    self._oprot.writeMessageEnd()
2395 
    self._oprot.trans.flush()
2396 
 
2397 
  def recv_getAlerts(self, ):
2398 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2399 
    if mtype == TMessageType.EXCEPTION:
2400 
      x = TApplicationException()
2401 
      x.read(self._iprot)
2402 
      self._iprot.readMessageEnd()
2403 
      raise x
2404 
    result = getAlerts_result()
2405 
    result.read(self._iprot)
2406 
    self._iprot.readMessageEnd()
3431 rajveer 2407 
    if result.success is not None:
3064 chandransh 2408 
      return result.success
2409 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAlerts failed: unknown result");
2410 
 
4444 rajveer 2411 
  def addAlert(self, type, warehouseId, description):
3064 chandransh 2412 
    """
2413 
    Parameters:
2414 
     - type
4444 rajveer 2415 
     - warehouseId
4394 rajveer 2416 
     - description
3064 chandransh 2417 
    """
4444 rajveer 2418 
    self.send_addAlert(type, warehouseId, description)
4394 rajveer 2419 
    self.recv_addAlert()
3064 chandransh 2420 
 
4444 rajveer 2421 
  def send_addAlert(self, type, warehouseId, description):
4394 rajveer 2422 
    self._oprot.writeMessageBegin('addAlert', TMessageType.CALL, self._seqid)
2423 
    args = addAlert_args()
3064 chandransh 2424 
    args.type = type
4444 rajveer 2425 
    args.warehouseId = warehouseId
4394 rajveer 2426 
    args.description = description
3064 chandransh 2427 
    args.write(self._oprot)
2428 
    self._oprot.writeMessageEnd()
2429 
    self._oprot.trans.flush()
2430 
 
4394 rajveer 2431 
  def recv_addAlert(self, ):
3064 chandransh 2432 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2433 
    if mtype == TMessageType.EXCEPTION:
2434 
      x = TApplicationException()
2435 
      x.read(self._iprot)
2436 
      self._iprot.readMessageEnd()
2437 
      raise x
4394 rajveer 2438 
    result = addAlert_result()
3064 chandransh 2439 
    result.read(self._iprot)
2440 
    self._iprot.readMessageEnd()
2441 
    return
2442 
 
4444 rajveer 2443 
  def markAlertsAsSeen(self, warehouseId):
2444 
    """
2445 
    Parameters:
2446 
     - warehouseId
2447 
    """
2448 
    self.send_markAlertsAsSeen(warehouseId)
2449 
    self.recv_markAlertsAsSeen()
2450 
 
2451 
  def send_markAlertsAsSeen(self, warehouseId):
2452 
    self._oprot.writeMessageBegin('markAlertsAsSeen', TMessageType.CALL, self._seqid)
2453 
    args = markAlertsAsSeen_args()
2454 
    args.warehouseId = warehouseId
2455 
    args.write(self._oprot)
2456 
    self._oprot.writeMessageEnd()
2457 
    self._oprot.trans.flush()
2458 
 
2459 
  def recv_markAlertsAsSeen(self, ):
2460 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2461 
    if mtype == TMessageType.EXCEPTION:
2462 
      x = TApplicationException()
2463 
      x.read(self._iprot)
2464 
      self._iprot.readMessageEnd()
2465 
      raise x
2466 
    result = markAlertsAsSeen_result()
2467 
    result.read(self._iprot)
2468 
    self._iprot.readMessageEnd()
2469 
    return
2470 
 
3064 chandransh 2471 
  def getValidOrderCount(self, ):
2472 
    """
2473 
    Return the number of valid orders. (OrderStatus >= OrderStatus.SUBMITTED_FOR_PROCESSING)
2474 
    """
2475 
    self.send_getValidOrderCount()
2476 
    return self.recv_getValidOrderCount()
2477 
 
2478 
  def send_getValidOrderCount(self, ):
2479 
    self._oprot.writeMessageBegin('getValidOrderCount', TMessageType.CALL, self._seqid)
2480 
    args = getValidOrderCount_args()
2481 
    args.write(self._oprot)
2482 
    self._oprot.writeMessageEnd()
2483 
    self._oprot.trans.flush()
2484 
 
2485 
  def recv_getValidOrderCount(self, ):
2486 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2487 
    if mtype == TMessageType.EXCEPTION:
2488 
      x = TApplicationException()
2489 
      x.read(self._iprot)
2490 
      self._iprot.readMessageEnd()
2491 
      raise x
2492 
    result = getValidOrderCount_result()
2493 
    result.read(self._iprot)
2494 
    self._iprot.readMessageEnd()
3431 rajveer 2495 
    if result.success is not None:
3064 chandransh 2496 
      return result.success
2497 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getValidOrderCount failed: unknown result");
2498 
 
2499 
  def getNoOfCustomersWithSuccessfulTransaction(self, ):
2500 
    """
2501 
    Returns the number of distinct customers who have done successful transactions
2502 
    """
2503 
    self.send_getNoOfCustomersWithSuccessfulTransaction()
2504 
    return self.recv_getNoOfCustomersWithSuccessfulTransaction()
2505 
 
2506 
  def send_getNoOfCustomersWithSuccessfulTransaction(self, ):
2507 
    self._oprot.writeMessageBegin('getNoOfCustomersWithSuccessfulTransaction', TMessageType.CALL, self._seqid)
2508 
    args = getNoOfCustomersWithSuccessfulTransaction_args()
2509 
    args.write(self._oprot)
2510 
    self._oprot.writeMessageEnd()
2511 
    self._oprot.trans.flush()
2512 
 
2513 
  def recv_getNoOfCustomersWithSuccessfulTransaction(self, ):
2514 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2515 
    if mtype == TMessageType.EXCEPTION:
2516 
      x = TApplicationException()
2517 
      x.read(self._iprot)
2518 
      self._iprot.readMessageEnd()
2519 
      raise x
2520 
    result = getNoOfCustomersWithSuccessfulTransaction_result()
2521 
    result.read(self._iprot)
2522 
    self._iprot.readMessageEnd()
3431 rajveer 2523 
    if result.success is not None:
3064 chandransh 2524 
      return result.success
2525 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getNoOfCustomersWithSuccessfulTransaction failed: unknown result");
2526 
 
2527 
  def getValidOrdersAmountRange(self, ):
2528 
    """
2529 
    Returns the minimum and maximum amounts of a valid order. (OrderStatus >= OrderStatus.SUBMITTED_FOR_PROCESSING)
2530 
    List contains two values, first minimum amount and second maximum amount.
2531 
    """
2532 
    self.send_getValidOrdersAmountRange()
2533 
    return self.recv_getValidOrdersAmountRange()
2534 
 
2535 
  def send_getValidOrdersAmountRange(self, ):
2536 
    self._oprot.writeMessageBegin('getValidOrdersAmountRange', TMessageType.CALL, self._seqid)
2537 
    args = getValidOrdersAmountRange_args()
2538 
    args.write(self._oprot)
2539 
    self._oprot.writeMessageEnd()
2540 
    self._oprot.trans.flush()
2541 
 
2542 
  def recv_getValidOrdersAmountRange(self, ):
2543 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2544 
    if mtype == TMessageType.EXCEPTION:
2545 
      x = TApplicationException()
2546 
      x.read(self._iprot)
2547 
      self._iprot.readMessageEnd()
2548 
      raise x
2549 
    result = getValidOrdersAmountRange_result()
2550 
    result.read(self._iprot)
2551 
    self._iprot.readMessageEnd()
3431 rajveer 2552 
    if result.success is not None:
3064 chandransh 2553 
      return result.success
2554 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getValidOrdersAmountRange failed: unknown result");
2555 
 
5874 rajveer 2556 
  def getValidOrders(self, limit, onlyStore):
3064 chandransh 2557 
    """
2558 
    Returns list of Orders in descending order by Order creation date. List is restricted to limit Orders.
2559 
    If limit is passed as 0, then all valid Orders are returned.
3431 rajveer 2560 
 
3064 chandransh 2561 
    Parameters:
2562 
     - limit
5874 rajveer 2563 
     - onlyStore
3064 chandransh 2564 
    """
5874 rajveer 2565 
    self.send_getValidOrders(limit, onlyStore)
3064 chandransh 2566 
    return self.recv_getValidOrders()
2567 
 
5874 rajveer 2568 
  def send_getValidOrders(self, limit, onlyStore):
3064 chandransh 2569 
    self._oprot.writeMessageBegin('getValidOrders', TMessageType.CALL, self._seqid)
2570 
    args = getValidOrders_args()
2571 
    args.limit = limit
5874 rajveer 2572 
    args.onlyStore = onlyStore
3064 chandransh 2573 
    args.write(self._oprot)
2574 
    self._oprot.writeMessageEnd()
2575 
    self._oprot.trans.flush()
2576 
 
2577 
  def recv_getValidOrders(self, ):
2578 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2579 
    if mtype == TMessageType.EXCEPTION:
2580 
      x = TApplicationException()
2581 
      x.read(self._iprot)
2582 
      self._iprot.readMessageEnd()
2583 
      raise x
2584 
    result = getValidOrders_result()
2585 
    result.read(self._iprot)
2586 
    self._iprot.readMessageEnd()
3431 rajveer 2587 
    if result.success is not None:
3064 chandransh 2588 
      return result.success
2589 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getValidOrders failed: unknown result");
2590 
 
1220 chandransh 2591 
  def batchOrders(self, warehouseId):
2592 
    """
2593 
    Create a batch of all the pending orders for the given warehouse.
2594 
    The returned list is orderd by created_timestamp.
2595 
    If there are no pending orders, an empty list is returned.
3431 rajveer 2596 
 
1220 chandransh 2597 
    Parameters:
2598 
     - warehouseId
2599 
    """
2600 
    self.send_batchOrders(warehouseId)
2601 
    return self.recv_batchOrders()
2602 
 
2603 
  def send_batchOrders(self, warehouseId):
2604 
    self._oprot.writeMessageBegin('batchOrders', TMessageType.CALL, self._seqid)
2605 
    args = batchOrders_args()
2606 
    args.warehouseId = warehouseId
2607 
    args.write(self._oprot)
2608 
    self._oprot.writeMessageEnd()
2609 
    self._oprot.trans.flush()
2610 
 
2611 
  def recv_batchOrders(self, ):
2612 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2613 
    if mtype == TMessageType.EXCEPTION:
2614 
      x = TApplicationException()
2615 
      x.read(self._iprot)
2616 
      self._iprot.readMessageEnd()
2617 
      raise x
2618 
    result = batchOrders_result()
2619 
    result.read(self._iprot)
2620 
    self._iprot.readMessageEnd()
3431 rajveer 2621 
    if result.success is not None:
1220 chandransh 2622 
      return result.success
3431 rajveer 2623 
    if result.ex is not None:
1220 chandransh 2624 
      raise result.ex
2625 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "batchOrders failed: unknown result");
2626 
 
1208 chandransh 2627 
  def markOrderAsOutOfStock(self, orderId):
2628 
    """
2629 
    Mark the given order as out of stock. Throws an exception if the order with the given Id couldn't be found.
3431 rajveer 2630 
 
1208 chandransh 2631 
    Parameters:
2632 
     - orderId
2633 
    """
2634 
    self.send_markOrderAsOutOfStock(orderId)
2635 
    return self.recv_markOrderAsOutOfStock()
2636 
 
2637 
  def send_markOrderAsOutOfStock(self, orderId):
2638 
    self._oprot.writeMessageBegin('markOrderAsOutOfStock', TMessageType.CALL, self._seqid)
2639 
    args = markOrderAsOutOfStock_args()
2640 
    args.orderId = orderId
2641 
    args.write(self._oprot)
2642 
    self._oprot.writeMessageEnd()
2643 
    self._oprot.trans.flush()
2644 
 
2645 
  def recv_markOrderAsOutOfStock(self, ):
2646 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2647 
    if mtype == TMessageType.EXCEPTION:
2648 
      x = TApplicationException()
2649 
      x.read(self._iprot)
2650 
      self._iprot.readMessageEnd()
2651 
      raise x
2652 
    result = markOrderAsOutOfStock_result()
2653 
    result.read(self._iprot)
2654 
    self._iprot.readMessageEnd()
3431 rajveer 2655 
    if result.success is not None:
1208 chandransh 2656 
      return result.success
3431 rajveer 2657 
    if result.ex is not None:
1208 chandransh 2658 
      raise result.ex
2659 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderAsOutOfStock failed: unknown result");
2660 
 
3064 chandransh 2661 
  def verifyOrder(self, orderId):
759 chandransh 2662 
    """
3064 chandransh 2663 
    Marks the given order as SUBMITTED_FOR_PROCESSING and updates the verified
2664 
    timestamp. It is intended to be used for COD orders but can be harmlessly
2665 
    used for all other orders as well.
2666 
    Throws an exception if no such order exists.
3431 rajveer 2667 
 
759 chandransh 2668 
    Parameters:
3064 chandransh 2669 
     - orderId
759 chandransh 2670 
    """
3064 chandransh 2671 
    self.send_verifyOrder(orderId)
2672 
    return self.recv_verifyOrder()
759 chandransh 2673 
 
3064 chandransh 2674 
  def send_verifyOrder(self, orderId):
2675 
    self._oprot.writeMessageBegin('verifyOrder', TMessageType.CALL, self._seqid)
2676 
    args = verifyOrder_args()
2677 
    args.orderId = orderId
759 chandransh 2678 
    args.write(self._oprot)
2679 
    self._oprot.writeMessageEnd()
2680 
    self._oprot.trans.flush()
2681 
 
3064 chandransh 2682 
  def recv_verifyOrder(self, ):
759 chandransh 2683 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2684 
    if mtype == TMessageType.EXCEPTION:
2685 
      x = TApplicationException()
2686 
      x.read(self._iprot)
2687 
      self._iprot.readMessageEnd()
2688 
      raise x
3064 chandransh 2689 
    result = verifyOrder_result()
759 chandransh 2690 
    result.read(self._iprot)
2691 
    self._iprot.readMessageEnd()
3431 rajveer 2692 
    if result.success is not None:
759 chandransh 2693 
      return result.success
3431 rajveer 2694 
    if result.ex is not None:
759 chandransh 2695 
      raise result.ex
3064 chandransh 2696 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "verifyOrder failed: unknown result");
759 chandransh 2697 
 
3064 chandransh 2698 
  def acceptOrder(self, orderId):
1113 chandransh 2699 
    """
3064 chandransh 2700 
    Marks the given order as ACCEPTED and updates the accepted timestamp. If the
2701 
    given order is not a COD order, it also captures the payment if the same has
2702 
    not been captured.
2703 
    Throws an exception if no such order exists.
3431 rajveer 2704 
 
1113 chandransh 2705 
    Parameters:
3064 chandransh 2706 
     - orderId
1113 chandransh 2707 
    """
3064 chandransh 2708 
    self.send_acceptOrder(orderId)
2709 
    return self.recv_acceptOrder()
1113 chandransh 2710 
 
3064 chandransh 2711 
  def send_acceptOrder(self, orderId):
2712 
    self._oprot.writeMessageBegin('acceptOrder', TMessageType.CALL, self._seqid)
2713 
    args = acceptOrder_args()
2714 
    args.orderId = orderId
1113 chandransh 2715 
    args.write(self._oprot)
2716 
    self._oprot.writeMessageEnd()
2717 
    self._oprot.trans.flush()
2718 
 
3064 chandransh 2719 
  def recv_acceptOrder(self, ):
1113 chandransh 2720 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2721 
    if mtype == TMessageType.EXCEPTION:
2722 
      x = TApplicationException()
2723 
      x.read(self._iprot)
2724 
      self._iprot.readMessageEnd()
2725 
      raise x
3064 chandransh 2726 
    result = acceptOrder_result()
1113 chandransh 2727 
    result.read(self._iprot)
2728 
    self._iprot.readMessageEnd()
3431 rajveer 2729 
    if result.success is not None:
1113 chandransh 2730 
      return result.success
3431 rajveer 2731 
    if result.ex is not None:
1113 chandransh 2732 
      raise result.ex
3064 chandransh 2733 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "acceptOrder failed: unknown result");
1113 chandransh 2734 
 
5110 mandeep.dh 2735 
  def addBillingDetails(self, orderId, invoice_number, serialNumber, itemNumber, billed_by, jacketNumber, billingType, fulfilmentWarehouseId, authorize):
1132 chandransh 2736 
    """
3064 chandransh 2737 
    Add billing details such as the bill number and the biller to the Order.
4658 mandeep.dh 2738 
    Adds jacket number, item number and Serial no. to the order. Doesn't update
4283 anupam.sin 2739 
    the IMEI no. if a -1 is supplied.
2740 
    Also, it generates an invoice number for the order, marks the order as
2741 
    BILLED and sets the billing timestamp.
2742 
    Returns false if it doesn't find the order with the given ID.
3431 rajveer 2743 
 
1135 chandransh 2744 
    Parameters:
3064 chandransh 2745 
     - orderId
2746 
     - invoice_number
4658 mandeep.dh 2747 
     - serialNumber
4283 anupam.sin 2748 
     - itemNumber
3064 chandransh 2749 
     - billed_by
4264 rajveer 2750 
     - jacketNumber
4283 anupam.sin 2751 
     - billingType
5110 mandeep.dh 2752 
     - fulfilmentWarehouseId
4763 rajveer 2753 
     - authorize
1135 chandransh 2754 
    """
5110 mandeep.dh 2755 
    self.send_addBillingDetails(orderId, invoice_number, serialNumber, itemNumber, billed_by, jacketNumber, billingType, fulfilmentWarehouseId, authorize)
3064 chandransh 2756 
    return self.recv_addBillingDetails()
1135 chandransh 2757 
 
5110 mandeep.dh 2758 
  def send_addBillingDetails(self, orderId, invoice_number, serialNumber, itemNumber, billed_by, jacketNumber, billingType, fulfilmentWarehouseId, authorize):
3064 chandransh 2759 
    self._oprot.writeMessageBegin('addBillingDetails', TMessageType.CALL, self._seqid)
2760 
    args = addBillingDetails_args()
2761 
    args.orderId = orderId
2762 
    args.invoice_number = invoice_number
4658 mandeep.dh 2763 
    args.serialNumber = serialNumber
4283 anupam.sin 2764 
    args.itemNumber = itemNumber
3064 chandransh 2765 
    args.billed_by = billed_by
4264 rajveer 2766 
    args.jacketNumber = jacketNumber
4283 anupam.sin 2767 
    args.billingType = billingType
5110 mandeep.dh 2768 
    args.fulfilmentWarehouseId = fulfilmentWarehouseId
4763 rajveer 2769 
    args.authorize = authorize
1135 chandransh 2770 
    args.write(self._oprot)
2771 
    self._oprot.writeMessageEnd()
2772 
    self._oprot.trans.flush()
2773 
 
3064 chandransh 2774 
  def recv_addBillingDetails(self, ):
1135 chandransh 2775 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2776 
    if mtype == TMessageType.EXCEPTION:
2777 
      x = TApplicationException()
2778 
      x.read(self._iprot)
2779 
      self._iprot.readMessageEnd()
2780 
      raise x
3064 chandransh 2781 
    result = addBillingDetails_result()
1135 chandransh 2782 
    result.read(self._iprot)
2783 
    self._iprot.readMessageEnd()
3431 rajveer 2784 
    if result.success is not None:
3064 chandransh 2785 
      return result.success
3431 rajveer 2786 
    if result.ex is not None:
1135 chandransh 2787 
      raise result.ex
3064 chandransh 2788 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addBillingDetails failed: unknown result");
1135 chandransh 2789 
 
6756 amar.kumar 2790 
  def addInvoiceNumber(self, orderId, invoiceNumber, color, serialNumber, itemNumber):
4579 rajveer 2791 
    """
2792 
    Add the invoice number to the order.
2793 
 
2794 
    Parameters:
2795 
     - orderId
2796 
     - invoiceNumber
4763 rajveer 2797 
     - color
6756 amar.kumar 2798 
     - serialNumber
2799 
     - itemNumber
4579 rajveer 2800 
    """
6756 amar.kumar 2801 
    self.send_addInvoiceNumber(orderId, invoiceNumber, color, serialNumber, itemNumber)
4579 rajveer 2802 
    self.recv_addInvoiceNumber()
2803 
 
6756 amar.kumar 2804 
  def send_addInvoiceNumber(self, orderId, invoiceNumber, color, serialNumber, itemNumber):
4579 rajveer 2805 
    self._oprot.writeMessageBegin('addInvoiceNumber', TMessageType.CALL, self._seqid)
2806 
    args = addInvoiceNumber_args()
2807 
    args.orderId = orderId
2808 
    args.invoiceNumber = invoiceNumber
4763 rajveer 2809 
    args.color = color
6756 amar.kumar 2810 
    args.serialNumber = serialNumber
2811 
    args.itemNumber = itemNumber
4579 rajveer 2812 
    args.write(self._oprot)
2813 
    self._oprot.writeMessageEnd()
2814 
    self._oprot.trans.flush()
2815 
 
2816 
  def recv_addInvoiceNumber(self, ):
2817 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2818 
    if mtype == TMessageType.EXCEPTION:
2819 
      x = TApplicationException()
2820 
      x.read(self._iprot)
2821 
      self._iprot.readMessageEnd()
2822 
      raise x
2823 
    result = addInvoiceNumber_result()
2824 
    result.read(self._iprot)
2825 
    self._iprot.readMessageEnd()
2826 
    if result.ex is not None:
2827 
      raise result.ex
2828 
    return
2829 
 
4910 phani.kuma 2830 
  def markOrdersAsShippedFromWarehouse(self, warehouseId, providerId, cod, orderIds):
1408 ankur.sing 2831 
    """
3064 chandransh 2832 
    Depending on the third parameter, marks either all prepaid or all cod orders BILLED by the
4910 phani.kuma 2833 
    given warehouse and were picked up by the given provider as SHIPPED_FROM_WH.
3431 rajveer 2834 
 
1408 ankur.sing 2835 
    Parameters:
3064 chandransh 2836 
     - warehouseId
1408 ankur.sing 2837 
     - providerId
3064 chandransh 2838 
     - cod
4910 phani.kuma 2839 
     - orderIds
1408 ankur.sing 2840 
    """
4910 phani.kuma 2841 
    self.send_markOrdersAsShippedFromWarehouse(warehouseId, providerId, cod, orderIds)
2842 
    return self.recv_markOrdersAsShippedFromWarehouse()
1408 ankur.sing 2843 
 
4910 phani.kuma 2844 
  def send_markOrdersAsShippedFromWarehouse(self, warehouseId, providerId, cod, orderIds):
2845 
    self._oprot.writeMessageBegin('markOrdersAsShippedFromWarehouse', TMessageType.CALL, self._seqid)
2846 
    args = markOrdersAsShippedFromWarehouse_args()
3064 chandransh 2847 
    args.warehouseId = warehouseId
1408 ankur.sing 2848 
    args.providerId = providerId
3064 chandransh 2849 
    args.cod = cod
4910 phani.kuma 2850 
    args.orderIds = orderIds
1408 ankur.sing 2851 
    args.write(self._oprot)
2852 
    self._oprot.writeMessageEnd()
2853 
    self._oprot.trans.flush()
2854 
 
4910 phani.kuma 2855 
  def recv_markOrdersAsShippedFromWarehouse(self, ):
1408 ankur.sing 2856 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2857 
    if mtype == TMessageType.EXCEPTION:
2858 
      x = TApplicationException()
2859 
      x.read(self._iprot)
2860 
      self._iprot.readMessageEnd()
2861 
      raise x
4910 phani.kuma 2862 
    result = markOrdersAsShippedFromWarehouse_result()
1408 ankur.sing 2863 
    result.read(self._iprot)
2864 
    self._iprot.readMessageEnd()
3431 rajveer 2865 
    if result.success is not None:
1408 ankur.sing 2866 
      return result.success
3431 rajveer 2867 
    if result.ex is not None:
3064 chandransh 2868 
      raise result.ex
4910 phani.kuma 2869 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrdersAsShippedFromWarehouse failed: unknown result");
1408 ankur.sing 2870 
 
5713 rajveer 2871 
  def markOrdersAsReturnedFromStore(self, providerId, orderIds, awbs):
5676 rajveer 2872 
    """
2873 
    Parameters:
2874 
     - providerId
2875 
     - orderIds
5713 rajveer 2876 
     - awbs
5676 rajveer 2877 
    """
5713 rajveer 2878 
    self.send_markOrdersAsReturnedFromStore(providerId, orderIds, awbs)
5676 rajveer 2879 
    return self.recv_markOrdersAsReturnedFromStore()
2880 
 
5713 rajveer 2881 
  def send_markOrdersAsReturnedFromStore(self, providerId, orderIds, awbs):
5676 rajveer 2882 
    self._oprot.writeMessageBegin('markOrdersAsReturnedFromStore', TMessageType.CALL, self._seqid)
2883 
    args = markOrdersAsReturnedFromStore_args()
2884 
    args.providerId = providerId
2885 
    args.orderIds = orderIds
5713 rajveer 2886 
    args.awbs = awbs
5676 rajveer 2887 
    args.write(self._oprot)
2888 
    self._oprot.writeMessageEnd()
2889 
    self._oprot.trans.flush()
2890 
 
2891 
  def recv_markOrdersAsReturnedFromStore(self, ):
2892 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2893 
    if mtype == TMessageType.EXCEPTION:
2894 
      x = TApplicationException()
2895 
      x.read(self._iprot)
2896 
      self._iprot.readMessageEnd()
2897 
      raise x
2898 
    result = markOrdersAsReturnedFromStore_result()
2899 
    result.read(self._iprot)
2900 
    self._iprot.readMessageEnd()
2901 
    if result.success is not None:
2902 
      return result.success
2903 
    if result.ex is not None:
2904 
      raise result.ex
2905 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrdersAsReturnedFromStore failed: unknown result");
2906 
 
4910 phani.kuma 2907 
  def markOrdersAsPickedUp(self, providerId, pickupDetails):
4410 rajveer 2908 
    """
4910 phani.kuma 2909 
    Marks all SHIPPED_FROM_WH orders of the previous day for a provider as SHIPPED_TO_LOGISTICS.
2910 
    Raises an exception if we encounter report for an AWB number that we did not ship.
4410 rajveer 2911 
 
2912 
    Parameters:
2913 
     - providerId
4910 phani.kuma 2914 
     - pickupDetails
4410 rajveer 2915 
    """
4910 phani.kuma 2916 
    self.send_markOrdersAsPickedUp(providerId, pickupDetails)
2917 
    self.recv_markOrdersAsPickedUp()
4410 rajveer 2918 
 
4910 phani.kuma 2919 
  def send_markOrdersAsPickedUp(self, providerId, pickupDetails):
2920 
    self._oprot.writeMessageBegin('markOrdersAsPickedUp', TMessageType.CALL, self._seqid)
2921 
    args = markOrdersAsPickedUp_args()
4410 rajveer 2922 
    args.providerId = providerId
4910 phani.kuma 2923 
    args.pickupDetails = pickupDetails
4410 rajveer 2924 
    args.write(self._oprot)
2925 
    self._oprot.writeMessageEnd()
2926 
    self._oprot.trans.flush()
2927 
 
4910 phani.kuma 2928 
  def recv_markOrdersAsPickedUp(self, ):
4410 rajveer 2929 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2930 
    if mtype == TMessageType.EXCEPTION:
2931 
      x = TApplicationException()
2932 
      x.read(self._iprot)
2933 
      self._iprot.readMessageEnd()
2934 
      raise x
4910 phani.kuma 2935 
    result = markOrdersAsPickedUp_result()
4410 rajveer 2936 
    result.read(self._iprot)
2937 
    self._iprot.readMessageEnd()
2938 
    if result.ex is not None:
2939 
      raise result.ex
4910 phani.kuma 2940 
    return
4410 rajveer 2941 
 
4910 phani.kuma 2942 
  def getOrdersNotPickedUp(self, providerId):
94 ashish 2943 
    """
3064 chandransh 2944 
    Returns a list of orders that were shipped from warehouse but did not appear in the pick-up report.
3431 rajveer 2945 
 
94 ashish 2946 
    Parameters:
3064 chandransh 2947 
     - providerId
304 ashish 2948 
    """
4910 phani.kuma 2949 
    self.send_getOrdersNotPickedUp(providerId)
2950 
    return self.recv_getOrdersNotPickedUp()
94 ashish 2951 
 
4910 phani.kuma 2952 
  def send_getOrdersNotPickedUp(self, providerId):
2953 
    self._oprot.writeMessageBegin('getOrdersNotPickedUp', TMessageType.CALL, self._seqid)
2954 
    args = getOrdersNotPickedUp_args()
3064 chandransh 2955 
    args.providerId = providerId
304 ashish 2956 
    args.write(self._oprot)
2957 
    self._oprot.writeMessageEnd()
2958 
    self._oprot.trans.flush()
2959 
 
4910 phani.kuma 2960 
  def recv_getOrdersNotPickedUp(self, ):
304 ashish 2961 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2962 
    if mtype == TMessageType.EXCEPTION:
2963 
      x = TApplicationException()
2964 
      x.read(self._iprot)
2965 
      self._iprot.readMessageEnd()
2966 
      raise x
4910 phani.kuma 2967 
    result = getOrdersNotPickedUp_result()
304 ashish 2968 
    result.read(self._iprot)
2969 
    self._iprot.readMessageEnd()
3431 rajveer 2970 
    if result.success is not None:
304 ashish 2971 
      return result.success
4910 phani.kuma 2972 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersNotPickedUp failed: unknown result");
304 ashish 2973 
 
3064 chandransh 2974 
  def markOrdersAsDelivered(self, providerId, deliveredOrders):
304 ashish 2975 
    """
3064 chandransh 2976 
    Marks all orders with AWBs in the given map as delivered. Also sets the delivery timestamp and
2977 
    the name of the receiver.
2978 
    Raises an exception if we encounter report for an AWB number that we did not ship.
3431 rajveer 2979 
 
304 ashish 2980 
    Parameters:
3064 chandransh 2981 
     - providerId
2982 
     - deliveredOrders
304 ashish 2983 
    """
3064 chandransh 2984 
    self.send_markOrdersAsDelivered(providerId, deliveredOrders)
2985 
    self.recv_markOrdersAsDelivered()
304 ashish 2986 
 
3064 chandransh 2987 
  def send_markOrdersAsDelivered(self, providerId, deliveredOrders):
2988 
    self._oprot.writeMessageBegin('markOrdersAsDelivered', TMessageType.CALL, self._seqid)
2989 
    args = markOrdersAsDelivered_args()
2990 
    args.providerId = providerId
2991 
    args.deliveredOrders = deliveredOrders
304 ashish 2992 
    args.write(self._oprot)
2993 
    self._oprot.writeMessageEnd()
2994 
    self._oprot.trans.flush()
2995 
 
3064 chandransh 2996 
  def recv_markOrdersAsDelivered(self, ):
304 ashish 2997 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2998 
    if mtype == TMessageType.EXCEPTION:
2999 
      x = TApplicationException()
3000 
      x.read(self._iprot)
3001 
      self._iprot.readMessageEnd()
3002 
      raise x
3064 chandransh 3003 
    result = markOrdersAsDelivered_result()
304 ashish 3004 
    result.read(self._iprot)
3005 
    self._iprot.readMessageEnd()
3431 rajveer 3006 
    if result.ex is not None:
3064 chandransh 3007 
      raise result.ex
304 ashish 3008 
    return
3009 
 
4910 phani.kuma 3010 
  def markAsRTOrders(self, providerId, returnedOrders):
1596 ankur.sing 3011 
    """
4910 phani.kuma 3012 
    Mark all orders with AWBs in the given map as RTO. Also sets the delivery timestamp.
3064 chandransh 3013 
    Raises an exception if we encounter report for an AWB number that we did not ship.
3431 rajveer 3014 
 
3064 chandransh 3015 
    Parameters:
3016 
     - providerId
3017 
     - returnedOrders
1596 ankur.sing 3018 
    """
4910 phani.kuma 3019 
    self.send_markAsRTOrders(providerId, returnedOrders)
3020 
    self.recv_markAsRTOrders()
304 ashish 3021 
 
4910 phani.kuma 3022 
  def send_markAsRTOrders(self, providerId, returnedOrders):
3023 
    self._oprot.writeMessageBegin('markAsRTOrders', TMessageType.CALL, self._seqid)
3024 
    args = markAsRTOrders_args()
3064 chandransh 3025 
    args.providerId = providerId
3026 
    args.returnedOrders = returnedOrders
1596 ankur.sing 3027 
    args.write(self._oprot)
3028 
    self._oprot.writeMessageEnd()
3029 
    self._oprot.trans.flush()
3030 
 
4910 phani.kuma 3031 
  def recv_markAsRTOrders(self, ):
1596 ankur.sing 3032 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3033 
    if mtype == TMessageType.EXCEPTION:
3034 
      x = TApplicationException()
3035 
      x.read(self._iprot)
3036 
      self._iprot.readMessageEnd()
3037 
      raise x
4910 phani.kuma 3038 
    result = markAsRTOrders_result()
1596 ankur.sing 3039 
    result.read(self._iprot)
3040 
    self._iprot.readMessageEnd()
3431 rajveer 3041 
    if result.ex is not None:
3064 chandransh 3042 
      raise result.ex
3043 
    return
1596 ankur.sing 3044 
 
4910 phani.kuma 3045 
  def getRTOrders(self, providerId):
3046 
    """
3047 
    Returns a list of orders that were returned by courier.
3048 
 
3049 
    Parameters:
3050 
     - providerId
3051 
    """
3052 
    self.send_getRTOrders(providerId)
3053 
    return self.recv_getRTOrders()
3054 
 
3055 
  def send_getRTOrders(self, providerId):
3056 
    self._oprot.writeMessageBegin('getRTOrders', TMessageType.CALL, self._seqid)
3057 
    args = getRTOrders_args()
3058 
    args.providerId = providerId
3059 
    args.write(self._oprot)
3060 
    self._oprot.writeMessageEnd()
3061 
    self._oprot.trans.flush()
3062 
 
3063 
  def recv_getRTOrders(self, ):
3064 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3065 
    if mtype == TMessageType.EXCEPTION:
3066 
      x = TApplicationException()
3067 
      x.read(self._iprot)
3068 
      self._iprot.readMessageEnd()
3069 
      raise x
3070 
    result = getRTOrders_result()
3071 
    result.read(self._iprot)
3072 
    self._iprot.readMessageEnd()
3073 
    if result.success is not None:
3074 
      return result.success
3075 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getRTOrders failed: unknown result");
3076 
 
3064 chandransh 3077 
  def updateNonDeliveryReason(self, providerId, undeliveredOrders):
1627 ankur.sing 3078 
    """
3064 chandransh 3079 
    Update the status description of orders whose AWB numbers are keys of the Map.
3431 rajveer 3080 
 
3064 chandransh 3081 
    Parameters:
3082 
     - providerId
3083 
     - undeliveredOrders
1627 ankur.sing 3084 
    """
3064 chandransh 3085 
    self.send_updateNonDeliveryReason(providerId, undeliveredOrders)
4910 phani.kuma 3086 
    self.recv_updateNonDeliveryReason()
1596 ankur.sing 3087 
 
3064 chandransh 3088 
  def send_updateNonDeliveryReason(self, providerId, undeliveredOrders):
3089 
    self._oprot.writeMessageBegin('updateNonDeliveryReason', TMessageType.CALL, self._seqid)
3090 
    args = updateNonDeliveryReason_args()
3091 
    args.providerId = providerId
3092 
    args.undeliveredOrders = undeliveredOrders
1627 ankur.sing 3093 
    args.write(self._oprot)
3094 
    self._oprot.writeMessageEnd()
3095 
    self._oprot.trans.flush()
3096 
 
3064 chandransh 3097 
  def recv_updateNonDeliveryReason(self, ):
1627 ankur.sing 3098 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3099 
    if mtype == TMessageType.EXCEPTION:
3100 
      x = TApplicationException()
3101 
      x.read(self._iprot)
3102 
      self._iprot.readMessageEnd()
3103 
      raise x
3064 chandransh 3104 
    result = updateNonDeliveryReason_result()
1627 ankur.sing 3105 
    result.read(self._iprot)
3106 
    self._iprot.readMessageEnd()
4910 phani.kuma 3107 
    if result.ex is not None:
3108 
      raise result.ex
3109 
    return
3110 
 
3111 
  def getNonDeliveredOrdersbyCourier(self, providerId):
3112 
    """
3113 
    Returns a list of orders that were picked up or shipped four days ago but did not get delivered.
3114 
 
3115 
    Parameters:
3116 
     - providerId
3117 
    """
3118 
    self.send_getNonDeliveredOrdersbyCourier(providerId)
3119 
    return self.recv_getNonDeliveredOrdersbyCourier()
3120 
 
3121 
  def send_getNonDeliveredOrdersbyCourier(self, providerId):
3122 
    self._oprot.writeMessageBegin('getNonDeliveredOrdersbyCourier', TMessageType.CALL, self._seqid)
3123 
    args = getNonDeliveredOrdersbyCourier_args()
3124 
    args.providerId = providerId
3125 
    args.write(self._oprot)
3126 
    self._oprot.writeMessageEnd()
3127 
    self._oprot.trans.flush()
3128 
 
3129 
  def recv_getNonDeliveredOrdersbyCourier(self, ):
3130 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3131 
    if mtype == TMessageType.EXCEPTION:
3132 
      x = TApplicationException()
3133 
      x.read(self._iprot)
3134 
      self._iprot.readMessageEnd()
3135 
      raise x
3136 
    result = getNonDeliveredOrdersbyCourier_result()
3137 
    result.read(self._iprot)
3138 
    self._iprot.readMessageEnd()
4581 phani.kuma 3139 
    if result.success is not None:
3140 
      return result.success
4910 phani.kuma 3141 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getNonDeliveredOrdersbyCourier failed: unknown result");
3142 
 
3143 
  def markOrdersAsLocalConnected(self, providerId, local_connected_orders):
3144 
    """
3145 
    Mark all orders with AWBs in the given map as local connected. Also sets the local connected timestamp.
3146 
 
3147 
    Parameters:
3148 
     - providerId
3149 
     - local_connected_orders
3150 
    """
3151 
    self.send_markOrdersAsLocalConnected(providerId, local_connected_orders)
3152 
    self.recv_markOrdersAsLocalConnected()
3153 
 
3154 
  def send_markOrdersAsLocalConnected(self, providerId, local_connected_orders):
3155 
    self._oprot.writeMessageBegin('markOrdersAsLocalConnected', TMessageType.CALL, self._seqid)
3156 
    args = markOrdersAsLocalConnected_args()
3157 
    args.providerId = providerId
3158 
    args.local_connected_orders = local_connected_orders
3159 
    args.write(self._oprot)
3160 
    self._oprot.writeMessageEnd()
3161 
    self._oprot.trans.flush()
3162 
 
3163 
  def recv_markOrdersAsLocalConnected(self, ):
3164 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3165 
    if mtype == TMessageType.EXCEPTION:
3166 
      x = TApplicationException()
3167 
      x.read(self._iprot)
3168 
      self._iprot.readMessageEnd()
3169 
      raise x
3170 
    result = markOrdersAsLocalConnected_result()
3171 
    result.read(self._iprot)
3172 
    self._iprot.readMessageEnd()
3431 rajveer 3173 
    if result.ex is not None:
3064 chandransh 3174 
      raise result.ex
4910 phani.kuma 3175 
    return
1627 ankur.sing 3176 
 
4910 phani.kuma 3177 
  def getOrdersNotLocalConnected(self, providerId):
3178 
    """
3179 
    Returns a list of orders that were picked up or shipped but pending local connection.
3180 
 
3181 
    Parameters:
3182 
     - providerId
3183 
    """
3184 
    self.send_getOrdersNotLocalConnected(providerId)
3185 
    return self.recv_getOrdersNotLocalConnected()
3186 
 
3187 
  def send_getOrdersNotLocalConnected(self, providerId):
3188 
    self._oprot.writeMessageBegin('getOrdersNotLocalConnected', TMessageType.CALL, self._seqid)
3189 
    args = getOrdersNotLocalConnected_args()
3190 
    args.providerId = providerId
3191 
    args.write(self._oprot)
3192 
    self._oprot.writeMessageEnd()
3193 
    self._oprot.trans.flush()
3194 
 
3195 
  def recv_getOrdersNotLocalConnected(self, ):
3196 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3197 
    if mtype == TMessageType.EXCEPTION:
3198 
      x = TApplicationException()
3199 
      x.read(self._iprot)
3200 
      self._iprot.readMessageEnd()
3201 
      raise x
3202 
    result = getOrdersNotLocalConnected_result()
3203 
    result.read(self._iprot)
3204 
    self._iprot.readMessageEnd()
3205 
    if result.success is not None:
3206 
      return result.success
3207 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersNotLocalConnected failed: unknown result");
3208 
 
3209 
  def markOrdersAsDestinationCityReached(self, providerId, destination_city_reached_orders):
3210 
    """
3211 
    Mark all orders with AWBs in the given map as reached destination city. Also sets the reached destination timestamp.
3212 
 
3213 
    Parameters:
3214 
     - providerId
3215 
     - destination_city_reached_orders
3216 
    """
3217 
    self.send_markOrdersAsDestinationCityReached(providerId, destination_city_reached_orders)
3218 
    self.recv_markOrdersAsDestinationCityReached()
3219 
 
3220 
  def send_markOrdersAsDestinationCityReached(self, providerId, destination_city_reached_orders):
3221 
    self._oprot.writeMessageBegin('markOrdersAsDestinationCityReached', TMessageType.CALL, self._seqid)
3222 
    args = markOrdersAsDestinationCityReached_args()
3223 
    args.providerId = providerId
3224 
    args.destination_city_reached_orders = destination_city_reached_orders
3225 
    args.write(self._oprot)
3226 
    self._oprot.writeMessageEnd()
3227 
    self._oprot.trans.flush()
3228 
 
3229 
  def recv_markOrdersAsDestinationCityReached(self, ):
3230 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3231 
    if mtype == TMessageType.EXCEPTION:
3232 
      x = TApplicationException()
3233 
      x.read(self._iprot)
3234 
      self._iprot.readMessageEnd()
3235 
      raise x
3236 
    result = markOrdersAsDestinationCityReached_result()
3237 
    result.read(self._iprot)
3238 
    self._iprot.readMessageEnd()
3239 
    if result.ex is not None:
3240 
      raise result.ex
3241 
    return
3242 
 
3243 
  def markOrdersAsFirstDeliveryAttempted(self, providerId, first_atdl_orders):
3244 
    """
3245 
    Mark all orders with AWBs in the given map as first delivery attempt made. Also sets the first delivery attempted timestamp.
3246 
 
3247 
    Parameters:
3248 
     - providerId
3249 
     - first_atdl_orders
3250 
    """
3251 
    self.send_markOrdersAsFirstDeliveryAttempted(providerId, first_atdl_orders)
3252 
    self.recv_markOrdersAsFirstDeliveryAttempted()
3253 
 
3254 
  def send_markOrdersAsFirstDeliveryAttempted(self, providerId, first_atdl_orders):
3255 
    self._oprot.writeMessageBegin('markOrdersAsFirstDeliveryAttempted', TMessageType.CALL, self._seqid)
3256 
    args = markOrdersAsFirstDeliveryAttempted_args()
3257 
    args.providerId = providerId
3258 
    args.first_atdl_orders = first_atdl_orders
3259 
    args.write(self._oprot)
3260 
    self._oprot.writeMessageEnd()
3261 
    self._oprot.trans.flush()
3262 
 
3263 
  def recv_markOrdersAsFirstDeliveryAttempted(self, ):
3264 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3265 
    if mtype == TMessageType.EXCEPTION:
3266 
      x = TApplicationException()
3267 
      x.read(self._iprot)
3268 
      self._iprot.readMessageEnd()
3269 
      raise x
3270 
    result = markOrdersAsFirstDeliveryAttempted_result()
3271 
    result.read(self._iprot)
3272 
    self._iprot.readMessageEnd()
3273 
    if result.ex is not None:
3274 
      raise result.ex
3275 
    return
3276 
 
3064 chandransh 3277 
  def getUndeliveredOrders(self, providerId, warehouseId):
1627 ankur.sing 3278 
    """
3064 chandransh 3279 
    Returns the list of orders whose delivery time has passed but have not been
3280 
    delivered yet for the given provider and warehouse. To get a complete list of
3281 
    undelivered orders, pass them as -1.
3282 
    Returns an empty list if no such orders exist.
3431 rajveer 3283 
 
1886 ankur.sing 3284 
    Parameters:
3064 chandransh 3285 
     - providerId
3286 
     - warehouseId
1886 ankur.sing 3287 
    """
3064 chandransh 3288 
    self.send_getUndeliveredOrders(providerId, warehouseId)
3289 
    return self.recv_getUndeliveredOrders()
1627 ankur.sing 3290 
 
3064 chandransh 3291 
  def send_getUndeliveredOrders(self, providerId, warehouseId):
3292 
    self._oprot.writeMessageBegin('getUndeliveredOrders', TMessageType.CALL, self._seqid)
3293 
    args = getUndeliveredOrders_args()
3294 
    args.providerId = providerId
3295 
    args.warehouseId = warehouseId
1886 ankur.sing 3296 
    args.write(self._oprot)
3297 
    self._oprot.writeMessageEnd()
3298 
    self._oprot.trans.flush()
3299 
 
3064 chandransh 3300 
  def recv_getUndeliveredOrders(self, ):
1886 ankur.sing 3301 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3302 
    if mtype == TMessageType.EXCEPTION:
3303 
      x = TApplicationException()
3304 
      x.read(self._iprot)
3305 
      self._iprot.readMessageEnd()
3306 
      raise x
3064 chandransh 3307 
    result = getUndeliveredOrders_result()
1886 ankur.sing 3308 
    result.read(self._iprot)
3309 
    self._iprot.readMessageEnd()
3431 rajveer 3310 
    if result.success is not None:
1886 ankur.sing 3311 
      return result.success
3064 chandransh 3312 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUndeliveredOrders failed: unknown result");
1886 ankur.sing 3313 
 
4783 phani.kuma 3314 
  def getUndeliveredOrdersExpectedDeliveryDateNotMet(self, ):
3315 
    """
3316 
    Returns the list of orders whose expected delivery date has passed but have not been
3317 
    delivered yet.
3318 
    Returns an empty list if no such orders exist.
3319 
    """
3320 
    self.send_getUndeliveredOrdersExpectedDeliveryDateNotMet()
3321 
    return self.recv_getUndeliveredOrdersExpectedDeliveryDateNotMet()
3322 
 
3323 
  def send_getUndeliveredOrdersExpectedDeliveryDateNotMet(self, ):
3324 
    self._oprot.writeMessageBegin('getUndeliveredOrdersExpectedDeliveryDateNotMet', TMessageType.CALL, self._seqid)
3325 
    args = getUndeliveredOrdersExpectedDeliveryDateNotMet_args()
3326 
    args.write(self._oprot)
3327 
    self._oprot.writeMessageEnd()
3328 
    self._oprot.trans.flush()
3329 
 
3330 
  def recv_getUndeliveredOrdersExpectedDeliveryDateNotMet(self, ):
3331 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3332 
    if mtype == TMessageType.EXCEPTION:
3333 
      x = TApplicationException()
3334 
      x.read(self._iprot)
3335 
      self._iprot.readMessageEnd()
3336 
      raise x
3337 
    result = getUndeliveredOrdersExpectedDeliveryDateNotMet_result()
3338 
    result.read(self._iprot)
3339 
    self._iprot.readMessageEnd()
3340 
    if result.success is not None:
3341 
      return result.success
3342 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUndeliveredOrdersExpectedDeliveryDateNotMet failed: unknown result");
3343 
 
2536 chandransh 3344 
  def toggleDOAFlag(self, orderId):
3345 
    """
3346 
    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.
3347 
    Returns the final flag status.
3348 
    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 3349 
 
2536 chandransh 3350 
    Parameters:
3351 
     - orderId
3352 
    """
3353 
    self.send_toggleDOAFlag(orderId)
3354 
    return self.recv_toggleDOAFlag()
1886 ankur.sing 3355 
 
2536 chandransh 3356 
  def send_toggleDOAFlag(self, orderId):
3357 
    self._oprot.writeMessageBegin('toggleDOAFlag', TMessageType.CALL, self._seqid)
3358 
    args = toggleDOAFlag_args()
3359 
    args.orderId = orderId
3360 
    args.write(self._oprot)
3361 
    self._oprot.writeMessageEnd()
3362 
    self._oprot.trans.flush()
3363 
 
3364 
  def recv_toggleDOAFlag(self, ):
3365 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3366 
    if mtype == TMessageType.EXCEPTION:
3367 
      x = TApplicationException()
3368 
      x.read(self._iprot)
3369 
      self._iprot.readMessageEnd()
3370 
      raise x
3371 
    result = toggleDOAFlag_result()
3372 
    result.read(self._iprot)
3373 
    self._iprot.readMessageEnd()
3431 rajveer 3374 
    if result.success is not None:
2536 chandransh 3375 
      return result.success
3431 rajveer 3376 
    if result.ex is not None:
2536 chandransh 3377 
      raise result.ex
3378 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "toggleDOAFlag failed: unknown result");
3379 
 
4712 rajveer 3380 
  def markOrderAsDelivered(self, orderId, deliveryTimestamp, receiver):
3381 
    """
3382 
    Parameters:
3383 
     - orderId
3384 
     - deliveryTimestamp
3385 
     - receiver
3386 
    """
3387 
    self.send_markOrderAsDelivered(orderId, deliveryTimestamp, receiver)
3388 
    self.recv_markOrderAsDelivered()
3389 
 
3390 
  def send_markOrderAsDelivered(self, orderId, deliveryTimestamp, receiver):
3391 
    self._oprot.writeMessageBegin('markOrderAsDelivered', TMessageType.CALL, self._seqid)
3392 
    args = markOrderAsDelivered_args()
3393 
    args.orderId = orderId
3394 
    args.deliveryTimestamp = deliveryTimestamp
3395 
    args.receiver = receiver
3396 
    args.write(self._oprot)
3397 
    self._oprot.writeMessageEnd()
3398 
    self._oprot.trans.flush()
3399 
 
3400 
  def recv_markOrderAsDelivered(self, ):
3401 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3402 
    if mtype == TMessageType.EXCEPTION:
3403 
      x = TApplicationException()
3404 
      x.read(self._iprot)
3405 
      self._iprot.readMessageEnd()
3406 
      raise x
3407 
    result = markOrderAsDelivered_result()
3408 
    result.read(self._iprot)
3409 
    self._iprot.readMessageEnd()
3410 
    if result.ex is not None:
3411 
      raise result.ex
3412 
    return
3413 
 
5553 rajveer 3414 
  def markOrderAsReceivedAtStore(self, orderId, deliveryTimestamp):
3415 
    """
3416 
    Parameters:
3417 
     - orderId
3418 
     - deliveryTimestamp
3419 
    """
3420 
    self.send_markOrderAsReceivedAtStore(orderId, deliveryTimestamp)
3421 
    self.recv_markOrderAsReceivedAtStore()
3422 
 
3423 
  def send_markOrderAsReceivedAtStore(self, orderId, deliveryTimestamp):
3424 
    self._oprot.writeMessageBegin('markOrderAsReceivedAtStore', TMessageType.CALL, self._seqid)
3425 
    args = markOrderAsReceivedAtStore_args()
3426 
    args.orderId = orderId
3427 
    args.deliveryTimestamp = deliveryTimestamp
3428 
    args.write(self._oprot)
3429 
    self._oprot.writeMessageEnd()
3430 
    self._oprot.trans.flush()
3431 
 
3432 
  def recv_markOrderAsReceivedAtStore(self, ):
3433 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3434 
    if mtype == TMessageType.EXCEPTION:
3435 
      x = TApplicationException()
3436 
      x.read(self._iprot)
3437 
      self._iprot.readMessageEnd()
3438 
      raise x
3439 
    result = markOrderAsReceivedAtStore_result()
3440 
    result.read(self._iprot)
3441 
    self._iprot.readMessageEnd()
3442 
    if result.ex is not None:
3443 
      raise result.ex
3444 
    return
3445 
 
4454 rajveer 3446 
  def markOrderDoaRequestReceived(self, orderId):
3447 
    """
3448 
    Once user raise the request for a DOA, order status will be changed from DELVIERY_SUCCESS to DOA_REQUEST_RECEIVED
3449 
 
3450 
    Parameters:
3451 
     - orderId
3452 
    """
3453 
    self.send_markOrderDoaRequestReceived(orderId)
3454 
    return self.recv_markOrderDoaRequestReceived()
3455 
 
3456 
  def send_markOrderDoaRequestReceived(self, orderId):
3457 
    self._oprot.writeMessageBegin('markOrderDoaRequestReceived', TMessageType.CALL, self._seqid)
3458 
    args = markOrderDoaRequestReceived_args()
3459 
    args.orderId = orderId
3460 
    args.write(self._oprot)
3461 
    self._oprot.writeMessageEnd()
3462 
    self._oprot.trans.flush()
3463 
 
3464 
  def recv_markOrderDoaRequestReceived(self, ):
3465 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3466 
    if mtype == TMessageType.EXCEPTION:
3467 
      x = TApplicationException()
3468 
      x.read(self._iprot)
3469 
      self._iprot.readMessageEnd()
3470 
      raise x
3471 
    result = markOrderDoaRequestReceived_result()
3472 
    result.read(self._iprot)
3473 
    self._iprot.readMessageEnd()
3474 
    if result.success is not None:
3475 
      return result.success
3476 
    if result.ex is not None:
3477 
      raise result.ex
3478 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderDoaRequestReceived failed: unknown result");
3479 
 
3480 
  def markOrderDoaRequestAuthorized(self, orderId, isAuthorized):
3481 
    """
3482 
    CRM person can authorize or deny the request reised by customer. If he authorizes order will change from DOA_REQUEST_RECEIVED
3483 
    to DOA_REQUEST_AUTHORIZED. If he denies, status will be changed back to DELVIERY_SUCCESS.
3484 
 
3485 
    Parameters:
3486 
     - orderId
3487 
     - isAuthorized
3488 
    """
3489 
    self.send_markOrderDoaRequestAuthorized(orderId, isAuthorized)
3490 
    return self.recv_markOrderDoaRequestAuthorized()
3491 
 
3492 
  def send_markOrderDoaRequestAuthorized(self, orderId, isAuthorized):
3493 
    self._oprot.writeMessageBegin('markOrderDoaRequestAuthorized', TMessageType.CALL, self._seqid)
3494 
    args = markOrderDoaRequestAuthorized_args()
3495 
    args.orderId = orderId
3496 
    args.isAuthorized = isAuthorized
3497 
    args.write(self._oprot)
3498 
    self._oprot.writeMessageEnd()
3499 
    self._oprot.trans.flush()
3500 
 
3501 
  def recv_markOrderDoaRequestAuthorized(self, ):
3502 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3503 
    if mtype == TMessageType.EXCEPTION:
3504 
      x = TApplicationException()
3505 
      x.read(self._iprot)
3506 
      self._iprot.readMessageEnd()
3507 
      raise x
3508 
    result = markOrderDoaRequestAuthorized_result()
3509 
    result.read(self._iprot)
3510 
    self._iprot.readMessageEnd()
3511 
    if result.success is not None:
3512 
      return result.success
3513 
    if result.ex is not None:
3514 
      raise result.ex
3515 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderDoaRequestAuthorized failed: unknown result");
3516 
 
4488 rajveer 3517 
  def markOrderReturnRequestReceived(self, orderId):
3518 
    """
3519 
    Once user raise the request for a RET, order status will be changed from DELVIERY_SUCCESS to RET_REQUEST_RECEIVED
3520 
 
3521 
    Parameters:
3522 
     - orderId
3523 
    """
3524 
    self.send_markOrderReturnRequestReceived(orderId)
3525 
    return self.recv_markOrderReturnRequestReceived()
3526 
 
3527 
  def send_markOrderReturnRequestReceived(self, orderId):
3528 
    self._oprot.writeMessageBegin('markOrderReturnRequestReceived', TMessageType.CALL, self._seqid)
3529 
    args = markOrderReturnRequestReceived_args()
3530 
    args.orderId = orderId
3531 
    args.write(self._oprot)
3532 
    self._oprot.writeMessageEnd()
3533 
    self._oprot.trans.flush()
3534 
 
3535 
  def recv_markOrderReturnRequestReceived(self, ):
3536 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3537 
    if mtype == TMessageType.EXCEPTION:
3538 
      x = TApplicationException()
3539 
      x.read(self._iprot)
3540 
      self._iprot.readMessageEnd()
3541 
      raise x
3542 
    result = markOrderReturnRequestReceived_result()
3543 
    result.read(self._iprot)
3544 
    self._iprot.readMessageEnd()
3545 
    if result.success is not None:
3546 
      return result.success
3547 
    if result.ex is not None:
3548 
      raise result.ex
3549 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderReturnRequestReceived failed: unknown result");
3550 
 
3551 
  def markOrderReturnRequestAuthorized(self, orderId, isAuthorized):
3552 
    """
3553 
    CRM person can authorize or deny the request reised by customer. If he authorizes order will change from RET_REQUEST_RECEIVED
3554 
    to RET_REQUEST_AUTHORIZED. If he denies, status will be changed back to DELVIERY_SUCCESS.
3555 
 
3556 
    Parameters:
3557 
     - orderId
3558 
     - isAuthorized
3559 
    """
3560 
    self.send_markOrderReturnRequestAuthorized(orderId, isAuthorized)
3561 
    return self.recv_markOrderReturnRequestAuthorized()
3562 
 
3563 
  def send_markOrderReturnRequestAuthorized(self, orderId, isAuthorized):
3564 
    self._oprot.writeMessageBegin('markOrderReturnRequestAuthorized', TMessageType.CALL, self._seqid)
3565 
    args = markOrderReturnRequestAuthorized_args()
3566 
    args.orderId = orderId
3567 
    args.isAuthorized = isAuthorized
3568 
    args.write(self._oprot)
3569 
    self._oprot.writeMessageEnd()
3570 
    self._oprot.trans.flush()
3571 
 
3572 
  def recv_markOrderReturnRequestAuthorized(self, ):
3573 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3574 
    if mtype == TMessageType.EXCEPTION:
3575 
      x = TApplicationException()
3576 
      x.read(self._iprot)
3577 
      self._iprot.readMessageEnd()
3578 
      raise x
3579 
    result = markOrderReturnRequestAuthorized_result()
3580 
    result.read(self._iprot)
3581 
    self._iprot.readMessageEnd()
3582 
    if result.success is not None:
3583 
      return result.success
3584 
    if result.ex is not None:
3585 
      raise result.ex
3586 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderReturnRequestAuthorized failed: unknown result");
3587 
 
4579 rajveer 3588 
  def requestPickupNumber(self, orderId, providerId):
2536 chandransh 3589 
    """
3590 
    Sends out an email to the account manager of the original courier provider used to ship the order.
4452 rajveer 3591 
    If the order status was DELIVERY_SUCCESS, it is changed to be DOA_PICKUP_REQUEST_RAISED.
3592 
    If the order status was DOA_PICKUP_REQUEST_RAISED, it is left unchanged.
2536 chandransh 3593 
    For any other status, it returns false.
3594 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 3595 
 
2536 chandransh 3596 
    Parameters:
3597 
     - orderId
4579 rajveer 3598 
     - providerId
2536 chandransh 3599 
    """
4579 rajveer 3600 
    self.send_requestPickupNumber(orderId, providerId)
2536 chandransh 3601 
    return self.recv_requestPickupNumber()
3602 
 
4579 rajveer 3603 
  def send_requestPickupNumber(self, orderId, providerId):
2536 chandransh 3604 
    self._oprot.writeMessageBegin('requestPickupNumber', TMessageType.CALL, self._seqid)
3605 
    args = requestPickupNumber_args()
3606 
    args.orderId = orderId
4579 rajveer 3607 
    args.providerId = providerId
2536 chandransh 3608 
    args.write(self._oprot)
3609 
    self._oprot.writeMessageEnd()
3610 
    self._oprot.trans.flush()
3611 
 
3612 
  def recv_requestPickupNumber(self, ):
3613 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3614 
    if mtype == TMessageType.EXCEPTION:
3615 
      x = TApplicationException()
3616 
      x.read(self._iprot)
3617 
      self._iprot.readMessageEnd()
3618 
      raise x
3619 
    result = requestPickupNumber_result()
3620 
    result.read(self._iprot)
3621 
    self._iprot.readMessageEnd()
3431 rajveer 3622 
    if result.success is not None:
2536 chandransh 3623 
      return result.success
3431 rajveer 3624 
    if result.ex is not None:
2536 chandransh 3625 
      raise result.ex
3626 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "requestPickupNumber failed: unknown result");
3627 
 
4602 rajveer 3628 
  def authorizePickup(self, orderId, pickupNumber, providerId):
2536 chandransh 3629 
    """
4452 rajveer 3630 
    If the order status is DOA_PICKUP_REQUEST_RAISED, it does the following
2536 chandransh 3631 
    	1. Sends out an email to the customer with the dispatch advice that he has to print as an attachment.
3632 
    	2. Changes order status to be DOA_PICKUP_AUTHORIZED.
3633 
    	3. Returns true
2591 chandransh 3634 
    If the order is in any other status, it returns false.
2536 chandransh 3635 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 3636 
 
2536 chandransh 3637 
    Parameters:
3638 
     - orderId
3639 
     - pickupNumber
4602 rajveer 3640 
     - providerId
2536 chandransh 3641 
    """
4602 rajveer 3642 
    self.send_authorizePickup(orderId, pickupNumber, providerId)
2536 chandransh 3643 
    return self.recv_authorizePickup()
3644 
 
4602 rajveer 3645 
  def send_authorizePickup(self, orderId, pickupNumber, providerId):
2536 chandransh 3646 
    self._oprot.writeMessageBegin('authorizePickup', TMessageType.CALL, self._seqid)
3647 
    args = authorizePickup_args()
3648 
    args.orderId = orderId
3649 
    args.pickupNumber = pickupNumber
4602 rajveer 3650 
    args.providerId = providerId
2536 chandransh 3651 
    args.write(self._oprot)
3652 
    self._oprot.writeMessageEnd()
3653 
    self._oprot.trans.flush()
3654 
 
3655 
  def recv_authorizePickup(self, ):
3656 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3657 
    if mtype == TMessageType.EXCEPTION:
3658 
      x = TApplicationException()
3659 
      x.read(self._iprot)
3660 
      self._iprot.readMessageEnd()
3661 
      raise x
3662 
    result = authorizePickup_result()
3663 
    result.read(self._iprot)
3664 
    self._iprot.readMessageEnd()
3431 rajveer 3665 
    if result.success is not None:
2536 chandransh 3666 
      return result.success
3431 rajveer 3667 
    if result.ex is not None:
2536 chandransh 3668 
      raise result.ex
3669 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "authorizePickup failed: unknown result");
3670 
 
2764 chandransh 3671 
  def markDoasAsPickedUp(self, providerId, pickupDetails):
3672 
    """
3673 
    Marks all DOA_PICKUP_AUTHORIZED orders of the previous day for a provider as DOA_RETURN_IN_TRANSIT.
3431 rajveer 3674 
 
2764 chandransh 3675 
    Parameters:
3676 
     - providerId
3677 
     - pickupDetails
3678 
    """
3679 
    self.send_markDoasAsPickedUp(providerId, pickupDetails)
4910 phani.kuma 3680 
    self.recv_markDoasAsPickedUp()
2764 chandransh 3681 
 
3682 
  def send_markDoasAsPickedUp(self, providerId, pickupDetails):
3683 
    self._oprot.writeMessageBegin('markDoasAsPickedUp', TMessageType.CALL, self._seqid)
3684 
    args = markDoasAsPickedUp_args()
3685 
    args.providerId = providerId
3686 
    args.pickupDetails = pickupDetails
3687 
    args.write(self._oprot)
3688 
    self._oprot.writeMessageEnd()
3689 
    self._oprot.trans.flush()
3690 
 
3691 
  def recv_markDoasAsPickedUp(self, ):
3692 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3693 
    if mtype == TMessageType.EXCEPTION:
3694 
      x = TApplicationException()
3695 
      x.read(self._iprot)
3696 
      self._iprot.readMessageEnd()
3697 
      raise x
3698 
    result = markDoasAsPickedUp_result()
3699 
    result.read(self._iprot)
3700 
    self._iprot.readMessageEnd()
4910 phani.kuma 3701 
    return
3702 
 
3703 
  def getDoasNotPickedUp(self, providerId):
3704 
    """
3705 
    Returns a list of orders that were authorized for pickup but did not appear in the pick-up report.
3706 
 
3707 
    Parameters:
3708 
     - providerId
3709 
    """
3710 
    self.send_getDoasNotPickedUp(providerId)
3711 
    return self.recv_getDoasNotPickedUp()
3712 
 
3713 
  def send_getDoasNotPickedUp(self, providerId):
3714 
    self._oprot.writeMessageBegin('getDoasNotPickedUp', TMessageType.CALL, self._seqid)
3715 
    args = getDoasNotPickedUp_args()
3716 
    args.providerId = providerId
3717 
    args.write(self._oprot)
3718 
    self._oprot.writeMessageEnd()
3719 
    self._oprot.trans.flush()
3720 
 
3721 
  def recv_getDoasNotPickedUp(self, ):
3722 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3723 
    if mtype == TMessageType.EXCEPTION:
3724 
      x = TApplicationException()
3725 
      x.read(self._iprot)
3726 
      self._iprot.readMessageEnd()
3727 
      raise x
3728 
    result = getDoasNotPickedUp_result()
3729 
    result.read(self._iprot)
3730 
    self._iprot.readMessageEnd()
3431 rajveer 3731 
    if result.success is not None:
2764 chandransh 3732 
      return result.success
4910 phani.kuma 3733 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getDoasNotPickedUp failed: unknown result");
2764 chandransh 3734 
 
4741 phani.kuma 3735 
  def markReturnOrdersAsPickedUp(self, providerId, pickupDetails):
3736 
    """
3737 
    Marks all RET_PICKUP_CONFIRMED orders of the previous day for a provider as RET_RETURN_IN_TRANSIT.
3738 
 
3739 
    Parameters:
3740 
     - providerId
3741 
     - pickupDetails
3742 
    """
3743 
    self.send_markReturnOrdersAsPickedUp(providerId, pickupDetails)
4910 phani.kuma 3744 
    self.recv_markReturnOrdersAsPickedUp()
4741 phani.kuma 3745 
 
3746 
  def send_markReturnOrdersAsPickedUp(self, providerId, pickupDetails):
3747 
    self._oprot.writeMessageBegin('markReturnOrdersAsPickedUp', TMessageType.CALL, self._seqid)
3748 
    args = markReturnOrdersAsPickedUp_args()
3749 
    args.providerId = providerId
3750 
    args.pickupDetails = pickupDetails
3751 
    args.write(self._oprot)
3752 
    self._oprot.writeMessageEnd()
3753 
    self._oprot.trans.flush()
3754 
 
3755 
  def recv_markReturnOrdersAsPickedUp(self, ):
3756 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3757 
    if mtype == TMessageType.EXCEPTION:
3758 
      x = TApplicationException()
3759 
      x.read(self._iprot)
3760 
      self._iprot.readMessageEnd()
3761 
      raise x
3762 
    result = markReturnOrdersAsPickedUp_result()
3763 
    result.read(self._iprot)
3764 
    self._iprot.readMessageEnd()
4910 phani.kuma 3765 
    return
3766 
 
3767 
  def getReturnOrdersNotPickedUp(self, providerId):
3768 
    """
3769 
    Returns a list of orders that were authorized for pickup but did not appear in the pick-up report.
3770 
 
3771 
    Parameters:
3772 
     - providerId
3773 
    """
3774 
    self.send_getReturnOrdersNotPickedUp(providerId)
3775 
    return self.recv_getReturnOrdersNotPickedUp()
3776 
 
3777 
  def send_getReturnOrdersNotPickedUp(self, providerId):
3778 
    self._oprot.writeMessageBegin('getReturnOrdersNotPickedUp', TMessageType.CALL, self._seqid)
3779 
    args = getReturnOrdersNotPickedUp_args()
3780 
    args.providerId = providerId
3781 
    args.write(self._oprot)
3782 
    self._oprot.writeMessageEnd()
3783 
    self._oprot.trans.flush()
3784 
 
3785 
  def recv_getReturnOrdersNotPickedUp(self, ):
3786 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3787 
    if mtype == TMessageType.EXCEPTION:
3788 
      x = TApplicationException()
3789 
      x.read(self._iprot)
3790 
      self._iprot.readMessageEnd()
3791 
      raise x
3792 
    result = getReturnOrdersNotPickedUp_result()
3793 
    result.read(self._iprot)
3794 
    self._iprot.readMessageEnd()
4741 phani.kuma 3795 
    if result.success is not None:
3796 
      return result.success
4910 phani.kuma 3797 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReturnOrdersNotPickedUp failed: unknown result");
4741 phani.kuma 3798 
 
4479 rajveer 3799 
  def receiveReturn(self, orderId, receiveCondition):
2591 chandransh 3800 
    """
4452 rajveer 3801 
    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 3802 
    If the order status is RTO_IN_TRANSIT, marks the order status as RTO_RECEIVED_PRESTINE and returns true.
2591 chandransh 3803 
    If the order is in any other state, it returns false.
3804 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 3805 
 
2591 chandransh 3806 
    Parameters:
3807 
     - orderId
4479 rajveer 3808 
     - receiveCondition
2591 chandransh 3809 
    """
4479 rajveer 3810 
    self.send_receiveReturn(orderId, receiveCondition)
2616 chandransh 3811 
    return self.recv_receiveReturn()
2536 chandransh 3812 
 
4479 rajveer 3813 
  def send_receiveReturn(self, orderId, receiveCondition):
2616 chandransh 3814 
    self._oprot.writeMessageBegin('receiveReturn', TMessageType.CALL, self._seqid)
3815 
    args = receiveReturn_args()
2591 chandransh 3816 
    args.orderId = orderId
4479 rajveer 3817 
    args.receiveCondition = receiveCondition
2591 chandransh 3818 
    args.write(self._oprot)
3819 
    self._oprot.writeMessageEnd()
3820 
    self._oprot.trans.flush()
3821 
 
2616 chandransh 3822 
  def recv_receiveReturn(self, ):
2591 chandransh 3823 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3824 
    if mtype == TMessageType.EXCEPTION:
3825 
      x = TApplicationException()
3826 
      x.read(self._iprot)
3827 
      self._iprot.readMessageEnd()
3828 
      raise x
2616 chandransh 3829 
    result = receiveReturn_result()
2591 chandransh 3830 
    result.read(self._iprot)
3831 
    self._iprot.readMessageEnd()
3431 rajveer 3832 
    if result.success is not None:
2591 chandransh 3833 
      return result.success
3431 rajveer 3834 
    if result.ex is not None:
2591 chandransh 3835 
      raise result.ex
2616 chandransh 3836 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "receiveReturn failed: unknown result");
2591 chandransh 3837 
 
3838 
  def validateDoa(self, orderId, isValid):
3839 
    """
4452 rajveer 3840 
    Used to validate the DOA certificate for an order in the DOA_RECEIVED_PRESTINE state. If the certificate is valid,
2616 chandransh 3841 
    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 3842 
    If the order is in any other state, it returns false.
3843 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 3844 
 
2591 chandransh 3845 
    Parameters:
3846 
     - orderId
3847 
     - isValid
3848 
    """
3849 
    self.send_validateDoa(orderId, isValid)
3850 
    return self.recv_validateDoa()
3851 
 
3852 
  def send_validateDoa(self, orderId, isValid):
3853 
    self._oprot.writeMessageBegin('validateDoa', TMessageType.CALL, self._seqid)
3854 
    args = validateDoa_args()
3855 
    args.orderId = orderId
3856 
    args.isValid = isValid
3857 
    args.write(self._oprot)
3858 
    self._oprot.writeMessageEnd()
3859 
    self._oprot.trans.flush()
3860 
 
3861 
  def recv_validateDoa(self, ):
3862 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3863 
    if mtype == TMessageType.EXCEPTION:
3864 
      x = TApplicationException()
3865 
      x.read(self._iprot)
3866 
      self._iprot.readMessageEnd()
3867 
      raise x
3868 
    result = validateDoa_result()
3869 
    result.read(self._iprot)
3870 
    self._iprot.readMessageEnd()
3431 rajveer 3871 
    if result.success is not None:
2591 chandransh 3872 
      return result.success
3431 rajveer 3873 
    if result.ex is not None:
2591 chandransh 3874 
      raise result.ex
3875 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "validateDoa failed: unknown result");
3876 
 
4495 rajveer 3877 
  def validateReturnProduct(self, orderId, isUsable):
3878 
    """
3879 
    Parameters:
3880 
     - orderId
3881 
     - isUsable
3882 
    """
3883 
    self.send_validateReturnProduct(orderId, isUsable)
3884 
    return self.recv_validateReturnProduct()
3885 
 
3886 
  def send_validateReturnProduct(self, orderId, isUsable):
3887 
    self._oprot.writeMessageBegin('validateReturnProduct', TMessageType.CALL, self._seqid)
3888 
    args = validateReturnProduct_args()
3889 
    args.orderId = orderId
3890 
    args.isUsable = isUsable
3891 
    args.write(self._oprot)
3892 
    self._oprot.writeMessageEnd()
3893 
    self._oprot.trans.flush()
3894 
 
3895 
  def recv_validateReturnProduct(self, ):
3896 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3897 
    if mtype == TMessageType.EXCEPTION:
3898 
      x = TApplicationException()
3899 
      x.read(self._iprot)
3900 
      self._iprot.readMessageEnd()
3901 
      raise x
3902 
    result = validateReturnProduct_result()
3903 
    result.read(self._iprot)
3904 
    self._iprot.readMessageEnd()
3905 
    if result.success is not None:
3906 
      return result.success
3907 
    if result.ex is not None:
3908 
      raise result.ex
3909 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "validateReturnProduct failed: unknown result");
3910 
 
2616 chandransh 3911 
  def reshipOrder(self, orderId):
3912 
    """
4484 rajveer 3913 
    If the order is in RTO_RECEIVED_PRESTINE or DOA_CERT_INVALID state, it does the following:
2616 chandransh 3914 
    	1. Creates a new order for processing in the BILLED state. All billing information is saved.
4484 rajveer 3915 
    	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 3916 
 
3917 
    If the order is in DOA_CERT_VALID state, it does the following:
3918 
    	1. Creates a new order for processing in the SUBMITTED_FOR_PROCESSING state.
3919 
    	2. Creates a return order for the warehouse executive to return the DOA material.
4452 rajveer 3920 
    	3. Marks the current order as the final DOA_VALID_RESHIPPED state.
3431 rajveer 3921 
 
2616 chandransh 3922 
    Returns the id of the newly created order.
3431 rajveer 3923 
 
2616 chandransh 3924 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 3925 
 
2616 chandransh 3926 
    Parameters:
3927 
     - orderId
3928 
    """
3929 
    self.send_reshipOrder(orderId)
3930 
    return self.recv_reshipOrder()
2591 chandransh 3931 
 
2616 chandransh 3932 
  def send_reshipOrder(self, orderId):
3933 
    self._oprot.writeMessageBegin('reshipOrder', TMessageType.CALL, self._seqid)
3934 
    args = reshipOrder_args()
3935 
    args.orderId = orderId
3936 
    args.write(self._oprot)
3937 
    self._oprot.writeMessageEnd()
3938 
    self._oprot.trans.flush()
3939 
 
3940 
  def recv_reshipOrder(self, ):
3941 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3942 
    if mtype == TMessageType.EXCEPTION:
3943 
      x = TApplicationException()
3944 
      x.read(self._iprot)
3945 
      self._iprot.readMessageEnd()
3946 
      raise x
3947 
    result = reshipOrder_result()
3948 
    result.read(self._iprot)
3949 
    self._iprot.readMessageEnd()
3431 rajveer 3950 
    if result.success is not None:
2616 chandransh 3951 
      return result.success
3431 rajveer 3952 
    if result.ex is not None:
2616 chandransh 3953 
      raise result.ex
3954 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "reshipOrder failed: unknown result");
3955 
 
3226 chandransh 3956 
  def refundOrder(self, orderId, refundedBy, reason):
2616 chandransh 3957 
    """
4484 rajveer 3958 
    If the order is in RTO_RECEIVED_PRESTINE, DOA_CERT_VALID or DOA_CERT_INVALID state, it does the following:
2616 chandransh 3959 
    	1. Creates a refund request for batch processing.
3960 
    	2. Creates a return order for the warehouse executive to return the shipped material.
4484 rajveer 3961 
    	3. Marks the current order as RTO_REFUNDED, DOA_VALID_REFUNDED or DOA_INVALID_REFUNDED final states.
3431 rajveer 3962 
 
2616 chandransh 3963 
    If the order is in SUBMITTED_FOR_PROCESSING or INVENTORY_LOW state, it does the following:
3964 
    	1. Creates a refund request for batch processing.
3226 chandransh 3965 
    	2. Cancels the reservation of the item in the warehouse.
3966 
    	3. Marks the current order as the REFUNDED final state.
3431 rajveer 3967 
 
3226 chandransh 3968 
    For all COD orders, if the order is in INIT, SUBMITTED_FOR_PROCESSING or INVENTORY_LOW state, it does the following:
3969 
    	1. Cancels the reservation of the item in the warehouse.
3970 
    	2. Marks the current order as CANCELED.
3971 
 
3972 
    In all cases, it updates the reason for cancellation or refund and the person who performed the action.
3973 
 
2616 chandransh 3974 
    Returns True if it is successful, False otherwise.
3431 rajveer 3975 
 
2616 chandransh 3976 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 3977 
 
2616 chandransh 3978 
    Parameters:
3979 
     - orderId
3226 chandransh 3980 
     - refundedBy
3981 
     - reason
2616 chandransh 3982 
    """
3226 chandransh 3983 
    self.send_refundOrder(orderId, refundedBy, reason)
2616 chandransh 3984 
    return self.recv_refundOrder()
3985 
 
3226 chandransh 3986 
  def send_refundOrder(self, orderId, refundedBy, reason):
2616 chandransh 3987 
    self._oprot.writeMessageBegin('refundOrder', TMessageType.CALL, self._seqid)
3988 
    args = refundOrder_args()
3989 
    args.orderId = orderId
3226 chandransh 3990 
    args.refundedBy = refundedBy
3991 
    args.reason = reason
2616 chandransh 3992 
    args.write(self._oprot)
3993 
    self._oprot.writeMessageEnd()
3994 
    self._oprot.trans.flush()
3995 
 
3996 
  def recv_refundOrder(self, ):
3997 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3998 
    if mtype == TMessageType.EXCEPTION:
3999 
      x = TApplicationException()
4000 
      x.read(self._iprot)
4001 
      self._iprot.readMessageEnd()
4002 
      raise x
4003 
    result = refundOrder_result()
4004 
    result.read(self._iprot)
4005 
    self._iprot.readMessageEnd()
3431 rajveer 4006 
    if result.success is not None:
2616 chandransh 4007 
      return result.success
3431 rajveer 4008 
    if result.ex is not None:
2616 chandransh 4009 
      raise result.ex
4010 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "refundOrder failed: unknown result");
4011 
 
2690 chandransh 4012 
  def getReturnOrders(self, warehouseId, fromDate, toDate):
4013 
    """
4014 
    Get all return orders created between the from and to dates for the given warehouse.
4015 
    Ignores the warehouse if it is passed as -1.
3431 rajveer 4016 
 
2690 chandransh 4017 
    Parameters:
4018 
     - warehouseId
4019 
     - fromDate
4020 
     - toDate
4021 
    """
4022 
    self.send_getReturnOrders(warehouseId, fromDate, toDate)
4023 
    return self.recv_getReturnOrders()
2616 chandransh 4024 
 
2690 chandransh 4025 
  def send_getReturnOrders(self, warehouseId, fromDate, toDate):
4026 
    self._oprot.writeMessageBegin('getReturnOrders', TMessageType.CALL, self._seqid)
4027 
    args = getReturnOrders_args()
4028 
    args.warehouseId = warehouseId
4029 
    args.fromDate = fromDate
4030 
    args.toDate = toDate
4031 
    args.write(self._oprot)
4032 
    self._oprot.writeMessageEnd()
4033 
    self._oprot.trans.flush()
4034 
 
4035 
  def recv_getReturnOrders(self, ):
4036 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4037 
    if mtype == TMessageType.EXCEPTION:
4038 
      x = TApplicationException()
4039 
      x.read(self._iprot)
4040 
      self._iprot.readMessageEnd()
4041 
      raise x
4042 
    result = getReturnOrders_result()
4043 
    result.read(self._iprot)
4044 
    self._iprot.readMessageEnd()
3431 rajveer 4045 
    if result.success is not None:
2690 chandransh 4046 
      return result.success
4047 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReturnOrders failed: unknown result");
4048 
 
5481 phani.kuma 4049 
  def getAllReturnOrders(self, onlyNotProcessed, fromDate, toDate):
4050 
    """
4051 
    Get all return orders created between the from and to dates.
4052 
 
4053 
    Parameters:
4054 
     - onlyNotProcessed
4055 
     - fromDate
4056 
     - toDate
4057 
    """
4058 
    self.send_getAllReturnOrders(onlyNotProcessed, fromDate, toDate)
4059 
    return self.recv_getAllReturnOrders()
4060 
 
4061 
  def send_getAllReturnOrders(self, onlyNotProcessed, fromDate, toDate):
4062 
    self._oprot.writeMessageBegin('getAllReturnOrders', TMessageType.CALL, self._seqid)
4063 
    args = getAllReturnOrders_args()
4064 
    args.onlyNotProcessed = onlyNotProcessed
4065 
    args.fromDate = fromDate
4066 
    args.toDate = toDate
4067 
    args.write(self._oprot)
4068 
    self._oprot.writeMessageEnd()
4069 
    self._oprot.trans.flush()
4070 
 
4071 
  def recv_getAllReturnOrders(self, ):
4072 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4073 
    if mtype == TMessageType.EXCEPTION:
4074 
      x = TApplicationException()
4075 
      x.read(self._iprot)
4076 
      self._iprot.readMessageEnd()
4077 
      raise x
4078 
    result = getAllReturnOrders_result()
4079 
    result.read(self._iprot)
4080 
    self._iprot.readMessageEnd()
4081 
    if result.success is not None:
4082 
      return result.success
4083 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllReturnOrders failed: unknown result");
4084 
 
2700 chandransh 4085 
  def getReturnOrder(self, id):
4086 
    """
4087 
    Returns the ReturnOrder corresponding to the given id.
4088 
    Throws an exception if the return order with the given id couldn't be found.
3431 rajveer 4089 
 
2700 chandransh 4090 
    Parameters:
4091 
     - id
4092 
    """
4093 
    self.send_getReturnOrder(id)
4094 
    return self.recv_getReturnOrder()
4095 
 
4096 
  def send_getReturnOrder(self, id):
4097 
    self._oprot.writeMessageBegin('getReturnOrder', TMessageType.CALL, self._seqid)
4098 
    args = getReturnOrder_args()
4099 
    args.id = id
4100 
    args.write(self._oprot)
4101 
    self._oprot.writeMessageEnd()
4102 
    self._oprot.trans.flush()
4103 
 
4104 
  def recv_getReturnOrder(self, ):
4105 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4106 
    if mtype == TMessageType.EXCEPTION:
4107 
      x = TApplicationException()
4108 
      x.read(self._iprot)
4109 
      self._iprot.readMessageEnd()
4110 
      raise x
4111 
    result = getReturnOrder_result()
4112 
    result.read(self._iprot)
4113 
    self._iprot.readMessageEnd()
3431 rajveer 4114 
    if result.success is not None:
2700 chandransh 4115 
      return result.success
3431 rajveer 4116 
    if result.ex is not None:
2700 chandransh 4117 
      raise result.ex
4118 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReturnOrder failed: unknown result");
4119 
 
2690 chandransh 4120 
  def processReturn(self, returnOrderId):
4121 
    """
4122 
    Marks the return order with the given id as processed. Raises an exception if no such return order exists.
3431 rajveer 4123 
 
2690 chandransh 4124 
    Parameters:
4125 
     - returnOrderId
4126 
    """
4127 
    self.send_processReturn(returnOrderId)
4128 
    self.recv_processReturn()
4129 
 
4130 
  def send_processReturn(self, returnOrderId):
4131 
    self._oprot.writeMessageBegin('processReturn', TMessageType.CALL, self._seqid)
4132 
    args = processReturn_args()
4133 
    args.returnOrderId = returnOrderId
4134 
    args.write(self._oprot)
4135 
    self._oprot.writeMessageEnd()
4136 
    self._oprot.trans.flush()
4137 
 
4138 
  def recv_processReturn(self, ):
4139 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4140 
    if mtype == TMessageType.EXCEPTION:
4141 
      x = TApplicationException()
4142 
      x.read(self._iprot)
4143 
      self._iprot.readMessageEnd()
4144 
      raise x
4145 
    result = processReturn_result()
4146 
    result.read(self._iprot)
4147 
    self._iprot.readMessageEnd()
3431 rajveer 4148 
    if result.ex is not None:
2690 chandransh 4149 
      raise result.ex
4150 
    return
4151 
 
3451 chandransh 4152 
  def updateWeight(self, orderId, weight):
4153 
    """
4154 
    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 4155 
 
3451 chandransh 4156 
    Parameters:
4157 
     - orderId
4158 
     - weight
4159 
    """
4160 
    self.send_updateWeight(orderId, weight)
4161 
    return self.recv_updateWeight()
4162 
 
4163 
  def send_updateWeight(self, orderId, weight):
4164 
    self._oprot.writeMessageBegin('updateWeight', TMessageType.CALL, self._seqid)
4165 
    args = updateWeight_args()
4166 
    args.orderId = orderId
4167 
    args.weight = weight
4168 
    args.write(self._oprot)
4169 
    self._oprot.writeMessageEnd()
4170 
    self._oprot.trans.flush()
4171 
 
4172 
  def recv_updateWeight(self, ):
4173 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4174 
    if mtype == TMessageType.EXCEPTION:
4175 
      x = TApplicationException()
4176 
      x.read(self._iprot)
4177 
      self._iprot.readMessageEnd()
4178 
      raise x
4179 
    result = updateWeight_result()
4180 
    result.read(self._iprot)
4181 
    self._iprot.readMessageEnd()
4182 
    if result.success is not None:
4183 
      return result.success
4184 
    if result.ex is not None:
4185 
      raise result.ex
4186 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updateWeight failed: unknown result");
4187 
 
3469 chandransh 4188 
  def changeItem(self, orderId, itemId):
4189 
    """
4190 
    Change the item to be shipped for this order. Also adjusts the reservation in the inventory accordingly.
4191 
    Currently, it also ensures that only a different color of the given item is shipped.
3451 chandransh 4192 
 
3469 chandransh 4193 
    Parameters:
4194 
     - orderId
4195 
     - itemId
4196 
    """
4197 
    self.send_changeItem(orderId, itemId)
4198 
    return self.recv_changeItem()
4199 
 
4200 
  def send_changeItem(self, orderId, itemId):
4201 
    self._oprot.writeMessageBegin('changeItem', TMessageType.CALL, self._seqid)
4202 
    args = changeItem_args()
4203 
    args.orderId = orderId
4204 
    args.itemId = itemId
4205 
    args.write(self._oprot)
4206 
    self._oprot.writeMessageEnd()
4207 
    self._oprot.trans.flush()
4208 
 
4209 
  def recv_changeItem(self, ):
4210 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4211 
    if mtype == TMessageType.EXCEPTION:
4212 
      x = TApplicationException()
4213 
      x.read(self._iprot)
4214 
      self._iprot.readMessageEnd()
4215 
      raise x
4216 
    result = changeItem_result()
4217 
    result.read(self._iprot)
4218 
    self._iprot.readMessageEnd()
4219 
    if result.success is not None:
4220 
      return result.success
4221 
    if result.ex is not None:
4222 
      raise result.ex
4223 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "changeItem failed: unknown result");
4224 
 
4225 
  def shiftToWarehouse(self, orderId, warehouseId):
4226 
    """
4227 
    Moves the given order to the given warehouse. Also adjusts the inventory reservations accordingly.
4228 
 
4229 
    Parameters:
4230 
     - orderId
4231 
     - warehouseId
4232 
    """
4233 
    self.send_shiftToWarehouse(orderId, warehouseId)
4234 
    return self.recv_shiftToWarehouse()
4235 
 
4236 
  def send_shiftToWarehouse(self, orderId, warehouseId):
4237 
    self._oprot.writeMessageBegin('shiftToWarehouse', TMessageType.CALL, self._seqid)
4238 
    args = shiftToWarehouse_args()
4239 
    args.orderId = orderId
4240 
    args.warehouseId = warehouseId
4241 
    args.write(self._oprot)
4242 
    self._oprot.writeMessageEnd()
4243 
    self._oprot.trans.flush()
4244 
 
4245 
  def recv_shiftToWarehouse(self, ):
4246 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4247 
    if mtype == TMessageType.EXCEPTION:
4248 
      x = TApplicationException()
4249 
      x.read(self._iprot)
4250 
      self._iprot.readMessageEnd()
4251 
      raise x
4252 
    result = shiftToWarehouse_result()
4253 
    result.read(self._iprot)
4254 
    self._iprot.readMessageEnd()
4255 
    if result.success is not None:
4256 
      return result.success
4257 
    if result.ex is not None:
4258 
      raise result.ex
4259 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "shiftToWarehouse failed: unknown result");
4260 
 
4647 rajveer 4261 
  def addDelayReason(self, orderId, delayReason, furtherDelay, delayReasonText):
3553 chandransh 4262 
    """
4263 
    Adds the given delay reason to the given order.
3986 chandransh 4264 
    Increases the expected delivery time of the given order by the given no. of days.
3553 chandransh 4265 
    Raises an exception if no order with the given id can be found.
3469 chandransh 4266 
 
3553 chandransh 4267 
    Parameters:
4268 
     - orderId
4269 
     - delayReason
3986 chandransh 4270 
     - furtherDelay
4647 rajveer 4271 
     - delayReasonText
3553 chandransh 4272 
    """
4647 rajveer 4273 
    self.send_addDelayReason(orderId, delayReason, furtherDelay, delayReasonText)
3553 chandransh 4274 
    return self.recv_addDelayReason()
4275 
 
4647 rajveer 4276 
  def send_addDelayReason(self, orderId, delayReason, furtherDelay, delayReasonText):
3553 chandransh 4277 
    self._oprot.writeMessageBegin('addDelayReason', TMessageType.CALL, self._seqid)
4278 
    args = addDelayReason_args()
4279 
    args.orderId = orderId
4280 
    args.delayReason = delayReason
3986 chandransh 4281 
    args.furtherDelay = furtherDelay
4647 rajveer 4282 
    args.delayReasonText = delayReasonText
3553 chandransh 4283 
    args.write(self._oprot)
4284 
    self._oprot.writeMessageEnd()
4285 
    self._oprot.trans.flush()
4286 
 
4287 
  def recv_addDelayReason(self, ):
4288 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4289 
    if mtype == TMessageType.EXCEPTION:
4290 
      x = TApplicationException()
4291 
      x.read(self._iprot)
4292 
      self._iprot.readMessageEnd()
4293 
      raise x
4294 
    result = addDelayReason_result()
4295 
    result.read(self._iprot)
4296 
    self._iprot.readMessageEnd()
4297 
    if result.success is not None:
4298 
      return result.success
4299 
    if result.ex is not None:
4300 
      raise result.ex
4301 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addDelayReason failed: unknown result");
4302 
 
3956 chandransh 4303 
  def reconcileCodCollection(self, collectedAmountMap, xferBy, xferTxnId, xferDate):
4304 
    """
4305 
    Marks the COD orders with given AWB nos. as having been processed.
4306 
    Updates the captured amount for the corresponding payment.
3553 chandransh 4307 
 
3956 chandransh 4308 
    Returns a map of AWBs which were not processed and the associated reason. An AWB is not processed if:
4309 
    1. There is no order corresponding to an AWB number.
4310 
    2. The captured amount for a payment exceeds the total payment.
4311 
    3. The order corresponding to an AWB no. is in a state prior to DELIVERY_SUCCESS.
4312 
 
4313 
    Parameters:
4314 
     - collectedAmountMap
4315 
     - xferBy
4316 
     - xferTxnId
4317 
     - xferDate
4318 
    """
4319 
    self.send_reconcileCodCollection(collectedAmountMap, xferBy, xferTxnId, xferDate)
4320 
    return self.recv_reconcileCodCollection()
4321 
 
4322 
  def send_reconcileCodCollection(self, collectedAmountMap, xferBy, xferTxnId, xferDate):
4323 
    self._oprot.writeMessageBegin('reconcileCodCollection', TMessageType.CALL, self._seqid)
4324 
    args = reconcileCodCollection_args()
4325 
    args.collectedAmountMap = collectedAmountMap
4326 
    args.xferBy = xferBy
4327 
    args.xferTxnId = xferTxnId
4328 
    args.xferDate = xferDate
4329 
    args.write(self._oprot)
4330 
    self._oprot.writeMessageEnd()
4331 
    self._oprot.trans.flush()
4332 
 
4333 
  def recv_reconcileCodCollection(self, ):
4334 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4335 
    if mtype == TMessageType.EXCEPTION:
4336 
      x = TApplicationException()
4337 
      x.read(self._iprot)
4338 
      self._iprot.readMessageEnd()
4339 
      raise x
4340 
    result = reconcileCodCollection_result()
4341 
    result.read(self._iprot)
4342 
    self._iprot.readMessageEnd()
4343 
    if result.success is not None:
4344 
      return result.success
4345 
    if result.ex is not None:
4346 
      raise result.ex
4347 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "reconcileCodCollection failed: unknown result");
4348 
 
4008 mandeep.dh 4349 
  def getTransactionsRequiringExtraProcessing(self, category):
4350 
    """
4065 mandeep.dh 4351 
    Returns the list of transaction ids that require some extra processing and
4008 mandeep.dh 4352 
    which belong to a particular category. This is currently used by CRM
4065 mandeep.dh 4353 
    application. If no such transaction ids are present, it returns an empty list.
3956 chandransh 4354 
 
4008 mandeep.dh 4355 
    Parameters:
4356 
     - category
4357 
    """
4358 
    self.send_getTransactionsRequiringExtraProcessing(category)
4359 
    return self.recv_getTransactionsRequiringExtraProcessing()
4360 
 
4361 
  def send_getTransactionsRequiringExtraProcessing(self, category):
4362 
    self._oprot.writeMessageBegin('getTransactionsRequiringExtraProcessing', TMessageType.CALL, self._seqid)
4363 
    args = getTransactionsRequiringExtraProcessing_args()
4364 
    args.category = category
4365 
    args.write(self._oprot)
4366 
    self._oprot.writeMessageEnd()
4367 
    self._oprot.trans.flush()
4368 
 
4369 
  def recv_getTransactionsRequiringExtraProcessing(self, ):
4370 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4371 
    if mtype == TMessageType.EXCEPTION:
4372 
      x = TApplicationException()
4373 
      x.read(self._iprot)
4374 
      self._iprot.readMessageEnd()
4375 
      raise x
4376 
    result = getTransactionsRequiringExtraProcessing_result()
4377 
    result.read(self._iprot)
4378 
    self._iprot.readMessageEnd()
4379 
    if result.success is not None:
4380 
      return result.success
4381 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransactionsRequiringExtraProcessing failed: unknown result");
4382 
 
4383 
  def markTransactionAsProcessed(self, transactionId, category):
4384 
    """
4385 
    Marks a particular transaction as processed for a particular cateogory.
4065 mandeep.dh 4386 
    It essentially deletes the transaction id record for a particular
4387 
    processing type category (if present) from DB.
4388 
    This is currently used by CRM application.
4008 mandeep.dh 4389 
 
4390 
    Parameters:
4391 
     - transactionId
4392 
     - category
4393 
    """
4394 
    self.send_markTransactionAsProcessed(transactionId, category)
4395 
    self.recv_markTransactionAsProcessed()
4396 
 
4397 
  def send_markTransactionAsProcessed(self, transactionId, category):
4398 
    self._oprot.writeMessageBegin('markTransactionAsProcessed', TMessageType.CALL, self._seqid)
4399 
    args = markTransactionAsProcessed_args()
4400 
    args.transactionId = transactionId
4401 
    args.category = category
4402 
    args.write(self._oprot)
4403 
    self._oprot.writeMessageEnd()
4404 
    self._oprot.trans.flush()
4405 
 
4406 
  def recv_markTransactionAsProcessed(self, ):
4407 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4408 
    if mtype == TMessageType.EXCEPTION:
4409 
      x = TApplicationException()
4410 
      x.read(self._iprot)
4411 
      self._iprot.readMessageEnd()
4412 
      raise x
4413 
    result = markTransactionAsProcessed_result()
4414 
    result.read(self._iprot)
4415 
    self._iprot.readMessageEnd()
4416 
    return
4417 
 
4018 chandransh 4418 
  def getItemWiseRiskyOrdersCount(self, ):
4419 
    """
4420 
    Returns a map containing the number of risky orders keyed by item id. A risky order
4421 
    is defined as one whose shipping date is about to expire.
4422 
    """
4423 
    self.send_getItemWiseRiskyOrdersCount()
4424 
    return self.recv_getItemWiseRiskyOrdersCount()
4008 mandeep.dh 4425 
 
4018 chandransh 4426 
  def send_getItemWiseRiskyOrdersCount(self, ):
4427 
    self._oprot.writeMessageBegin('getItemWiseRiskyOrdersCount', TMessageType.CALL, self._seqid)
4428 
    args = getItemWiseRiskyOrdersCount_args()
4429 
    args.write(self._oprot)
4430 
    self._oprot.writeMessageEnd()
4431 
    self._oprot.trans.flush()
4432 
 
4433 
  def recv_getItemWiseRiskyOrdersCount(self, ):
4434 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4435 
    if mtype == TMessageType.EXCEPTION:
4436 
      x = TApplicationException()
4437 
      x.read(self._iprot)
4438 
      self._iprot.readMessageEnd()
4439 
      raise x
4440 
    result = getItemWiseRiskyOrdersCount_result()
4441 
    result.read(self._iprot)
4442 
    self._iprot.readMessageEnd()
4443 
    if result.success is not None:
4444 
      return result.success
4445 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItemWiseRiskyOrdersCount failed: unknown result");
4446 
 
4295 varun.gupt 4447 
  def getOrdersForItemIds(self, itemIds):
4448 
    """
4449 
    Returns a list of all orders which have items with given id
4450 
 
4451 
    Parameters:
4452 
     - itemIds
4453 
    """
4454 
    self.send_getOrdersForItemIds(itemIds)
4455 
    return self.recv_getOrdersForItemIds()
4456 
 
4457 
  def send_getOrdersForItemIds(self, itemIds):
4458 
    self._oprot.writeMessageBegin('getOrdersForItemIds', TMessageType.CALL, self._seqid)
4459 
    args = getOrdersForItemIds_args()
4460 
    args.itemIds = itemIds
4461 
    args.write(self._oprot)
4462 
    self._oprot.writeMessageEnd()
4463 
    self._oprot.trans.flush()
4464 
 
4465 
  def recv_getOrdersForItemIds(self, ):
4466 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4467 
    if mtype == TMessageType.EXCEPTION:
4468 
      x = TApplicationException()
4469 
      x.read(self._iprot)
4470 
      self._iprot.readMessageEnd()
4471 
      raise x
4472 
    result = getOrdersForItemIds_result()
4473 
    result.read(self._iprot)
4474 
    self._iprot.readMessageEnd()
4475 
    if result.success is not None:
4476 
      return result.success
4477 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersForItemIds failed: unknown result");
4478 
 
4247 rajveer 4479 
  def markOrderCancellationRequestReceived(self, orderId):
4480 
    """
4481 
    Mark order as cancellation request received. If customer sends request of cancellation of
4482 
    a particular order, this method will be called. It will just change status of the order
4483 
    depending on its current status. It also records the previous status, so that we can move
4484 
    back to that status if cancellation request is denied.
4018 chandransh 4485 
 
4247 rajveer 4486 
    Parameters:
4487 
     - orderId
4488 
    """
4489 
    self.send_markOrderCancellationRequestReceived(orderId)
4490 
    self.recv_markOrderCancellationRequestReceived()
4491 
 
4492 
  def send_markOrderCancellationRequestReceived(self, orderId):
4493 
    self._oprot.writeMessageBegin('markOrderCancellationRequestReceived', TMessageType.CALL, self._seqid)
4494 
    args = markOrderCancellationRequestReceived_args()
4495 
    args.orderId = orderId
4496 
    args.write(self._oprot)
4497 
    self._oprot.writeMessageEnd()
4498 
    self._oprot.trans.flush()
4499 
 
4500 
  def recv_markOrderCancellationRequestReceived(self, ):
4501 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4502 
    if mtype == TMessageType.EXCEPTION:
4503 
      x = TApplicationException()
4504 
      x.read(self._iprot)
4505 
      self._iprot.readMessageEnd()
4506 
      raise x
4507 
    result = markOrderCancellationRequestReceived_result()
4508 
    result.read(self._iprot)
4509 
    self._iprot.readMessageEnd()
4510 
    if result.ex is not None:
4511 
      raise result.ex
4512 
    return
4513 
 
4514 
  def markOrderCancellationRequestConfirmed(self, orderId):
4515 
    """
4516 
    If we decide to to cancel order, CRM will call this method to move the status of order to
4517 
    cancellation request confirmed. After this OM will be able to cancel the order.
4518 
 
4519 
    Parameters:
4520 
     - orderId
4521 
    """
4522 
    self.send_markOrderCancellationRequestConfirmed(orderId)
4523 
    self.recv_markOrderCancellationRequestConfirmed()
4524 
 
4525 
  def send_markOrderCancellationRequestConfirmed(self, orderId):
4526 
    self._oprot.writeMessageBegin('markOrderCancellationRequestConfirmed', TMessageType.CALL, self._seqid)
4527 
    args = markOrderCancellationRequestConfirmed_args()
4528 
    args.orderId = orderId
4529 
    args.write(self._oprot)
4530 
    self._oprot.writeMessageEnd()
4531 
    self._oprot.trans.flush()
4532 
 
4533 
  def recv_markOrderCancellationRequestConfirmed(self, ):
4534 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4535 
    if mtype == TMessageType.EXCEPTION:
4536 
      x = TApplicationException()
4537 
      x.read(self._iprot)
4538 
      self._iprot.readMessageEnd()
4539 
      raise x
4540 
    result = markOrderCancellationRequestConfirmed_result()
4541 
    result.read(self._iprot)
4542 
    self._iprot.readMessageEnd()
4543 
    if result.ex is not None:
4544 
      raise result.ex
4545 
    return
4546 
 
4547 
  def markOrderCancellationRequestDenied(self, orderId):
4548 
    """
4549 
    If we decide to not to cancel order, we will move the order ro previous status.
4550 
 
4551 
    Parameters:
4552 
     - orderId
4553 
    """
4554 
    self.send_markOrderCancellationRequestDenied(orderId)
4555 
    self.recv_markOrderCancellationRequestDenied()
4556 
 
4557 
  def send_markOrderCancellationRequestDenied(self, orderId):
4558 
    self._oprot.writeMessageBegin('markOrderCancellationRequestDenied', TMessageType.CALL, self._seqid)
4559 
    args = markOrderCancellationRequestDenied_args()
4560 
    args.orderId = orderId
4561 
    args.write(self._oprot)
4562 
    self._oprot.writeMessageEnd()
4563 
    self._oprot.trans.flush()
4564 
 
4565 
  def recv_markOrderCancellationRequestDenied(self, ):
4566 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4567 
    if mtype == TMessageType.EXCEPTION:
4568 
      x = TApplicationException()
4569 
      x.read(self._iprot)
4570 
      self._iprot.readMessageEnd()
4571 
      raise x
4572 
    result = markOrderCancellationRequestDenied_result()
4573 
    result.read(self._iprot)
4574 
    self._iprot.readMessageEnd()
4575 
    if result.ex is not None:
4576 
      raise result.ex
4577 
    return
4578 
 
4258 rajveer 4579 
  def markTransactionAsPaymentFlagRemoved(self, transactionId):
4247 rajveer 4580 
    """
4258 rajveer 4581 
    If we and/or payment gateway has decided to accept the payment, this method needs to be called.
4582 
    Changed transaction and all orders status to payment accepted.
4247 rajveer 4583 
 
4584 
    Parameters:
4258 rajveer 4585 
     - transactionId
4247 rajveer 4586 
    """
4258 rajveer 4587 
    self.send_markTransactionAsPaymentFlagRemoved(transactionId)
4588 
    self.recv_markTransactionAsPaymentFlagRemoved()
4247 rajveer 4589 
 
4258 rajveer 4590 
  def send_markTransactionAsPaymentFlagRemoved(self, transactionId):
4591 
    self._oprot.writeMessageBegin('markTransactionAsPaymentFlagRemoved', TMessageType.CALL, self._seqid)
4592 
    args = markTransactionAsPaymentFlagRemoved_args()
4593 
    args.transactionId = transactionId
4247 rajveer 4594 
    args.write(self._oprot)
4595 
    self._oprot.writeMessageEnd()
4596 
    self._oprot.trans.flush()
4597 
 
4258 rajveer 4598 
  def recv_markTransactionAsPaymentFlagRemoved(self, ):
4247 rajveer 4599 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4600 
    if mtype == TMessageType.EXCEPTION:
4601 
      x = TApplicationException()
4602 
      x.read(self._iprot)
4603 
      self._iprot.readMessageEnd()
4604 
      raise x
4258 rajveer 4605 
    result = markTransactionAsPaymentFlagRemoved_result()
4247 rajveer 4606 
    result.read(self._iprot)
4607 
    self._iprot.readMessageEnd()
4608 
    if result.ex is not None:
4609 
      raise result.ex
4610 
    return
4611 
 
4259 anupam.sin 4612 
  def refundTransaction(self, transactionId, refundedBy, reason):
4613 
    """
4614 
    This method is called when a flagged payment is deemed unserviceable and the corresponding orders
4615 
    need to be cancelled
4247 rajveer 4616 
 
4259 anupam.sin 4617 
    Parameters:
4618 
     - transactionId
4619 
     - refundedBy
4620 
     - reason
4621 
    """
4622 
    self.send_refundTransaction(transactionId, refundedBy, reason)
4623 
    self.recv_refundTransaction()
4624 
 
4625 
  def send_refundTransaction(self, transactionId, refundedBy, reason):
4626 
    self._oprot.writeMessageBegin('refundTransaction', TMessageType.CALL, self._seqid)
4627 
    args = refundTransaction_args()
4628 
    args.transactionId = transactionId
4629 
    args.refundedBy = refundedBy
4630 
    args.reason = reason
4631 
    args.write(self._oprot)
4632 
    self._oprot.writeMessageEnd()
4633 
    self._oprot.trans.flush()
4634 
 
4635 
  def recv_refundTransaction(self, ):
4636 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4637 
    if mtype == TMessageType.EXCEPTION:
4638 
      x = TApplicationException()
4639 
      x.read(self._iprot)
4640 
      self._iprot.readMessageEnd()
4641 
      raise x
4642 
    result = refundTransaction_result()
4643 
    result.read(self._iprot)
4644 
    self._iprot.readMessageEnd()
4645 
    if result.ex is not None:
4646 
      raise result.ex
4647 
    return
4648 
 
4324 mandeep.dh 4649 
  def updateShipmentAddress(self, orderId, addressId):
4650 
    """
4651 
    Updates shipment address of an order. Delivery and shipping date estimates
4652 
    etc. are also updated here.
4653 
 
4654 
    Throws TransactionServiceException in case address change is not
4655 
    possible due to certain reasons such as new pincode in address is
4656 
    not serviceable etc.
4657 
 
4658 
    Parameters:
4659 
     - orderId
4660 
     - addressId
4661 
    """
4662 
    self.send_updateShipmentAddress(orderId, addressId)
4663 
    self.recv_updateShipmentAddress()
4664 
 
4665 
  def send_updateShipmentAddress(self, orderId, addressId):
4666 
    self._oprot.writeMessageBegin('updateShipmentAddress', TMessageType.CALL, self._seqid)
4667 
    args = updateShipmentAddress_args()
4668 
    args.orderId = orderId
4669 
    args.addressId = addressId
4670 
    args.write(self._oprot)
4671 
    self._oprot.writeMessageEnd()
4672 
    self._oprot.trans.flush()
4673 
 
4674 
  def recv_updateShipmentAddress(self, ):
4675 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4676 
    if mtype == TMessageType.EXCEPTION:
4677 
      x = TApplicationException()
4678 
      x.read(self._iprot)
4679 
      self._iprot.readMessageEnd()
4680 
      raise x
4681 
    result = updateShipmentAddress_result()
4682 
    result.read(self._iprot)
4683 
    self._iprot.readMessageEnd()
4684 
    if result.ex is not None:
4685 
      raise result.ex
4686 
    return
4687 
 
4285 rajveer 4688 
  def acceptOrdersForItemId(self, itemId, inventory):
4689 
    """
4690 
    Marks the orders as ACCEPTED for the given itemId and inventory. It also updates the accepted timestamp. If the
4691 
    given order is not a COD order, it also captures the payment if the same has not been captured.
4259 anupam.sin 4692 
 
4285 rajveer 4693 
    Parameters:
4694 
     - itemId
4695 
     - inventory
4696 
    """
4697 
    self.send_acceptOrdersForItemId(itemId, inventory)
4698 
    return self.recv_acceptOrdersForItemId()
4699 
 
4700 
  def send_acceptOrdersForItemId(self, itemId, inventory):
4701 
    self._oprot.writeMessageBegin('acceptOrdersForItemId', TMessageType.CALL, self._seqid)
4702 
    args = acceptOrdersForItemId_args()
4703 
    args.itemId = itemId
4704 
    args.inventory = inventory
4705 
    args.write(self._oprot)
4706 
    self._oprot.writeMessageEnd()
4707 
    self._oprot.trans.flush()
4708 
 
4709 
  def recv_acceptOrdersForItemId(self, ):
4710 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4711 
    if mtype == TMessageType.EXCEPTION:
4712 
      x = TApplicationException()
4713 
      x.read(self._iprot)
4714 
      self._iprot.readMessageEnd()
4715 
      raise x
4716 
    result = acceptOrdersForItemId_result()
4717 
    result.read(self._iprot)
4718 
    self._iprot.readMessageEnd()
4719 
    if result.success is not None:
4720 
      return result.success
4721 
    if result.ex is not None:
4722 
      raise result.ex
4723 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "acceptOrdersForItemId failed: unknown result");
4724 
 
4369 rajveer 4725 
  def markOrdersAsPORaised(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 4726 
    """
4727 
    Parameters:
4728 
     - vendorId
4729 
     - itemId
4730 
     - quantity
4731 
     - estimate
4369 rajveer 4732 
     - isReminder
4303 rajveer 4733 
    """
4369 rajveer 4734 
    self.send_markOrdersAsPORaised(vendorId, itemId, quantity, estimate, isReminder)
4303 rajveer 4735 
    self.recv_markOrdersAsPORaised()
4285 rajveer 4736 
 
4369 rajveer 4737 
  def send_markOrdersAsPORaised(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 4738 
    self._oprot.writeMessageBegin('markOrdersAsPORaised', TMessageType.CALL, self._seqid)
4739 
    args = markOrdersAsPORaised_args()
4740 
    args.vendorId = vendorId
4741 
    args.itemId = itemId
4742 
    args.quantity = quantity
4743 
    args.estimate = estimate
4369 rajveer 4744 
    args.isReminder = isReminder
4303 rajveer 4745 
    args.write(self._oprot)
4746 
    self._oprot.writeMessageEnd()
4747 
    self._oprot.trans.flush()
4748 
 
4749 
  def recv_markOrdersAsPORaised(self, ):
4750 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4751 
    if mtype == TMessageType.EXCEPTION:
4752 
      x = TApplicationException()
4753 
      x.read(self._iprot)
4754 
      self._iprot.readMessageEnd()
4755 
      raise x
4756 
    result = markOrdersAsPORaised_result()
4757 
    result.read(self._iprot)
4758 
    self._iprot.readMessageEnd()
4759 
    if result.ex is not None:
4760 
      raise result.ex
4761 
    return
4762 
 
4369 rajveer 4763 
  def markOrdersAsReversalInitiated(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 4764 
    """
4765 
    Parameters:
4766 
     - vendorId
4767 
     - itemId
4768 
     - quantity
4769 
     - estimate
4369 rajveer 4770 
     - isReminder
4303 rajveer 4771 
    """
4369 rajveer 4772 
    self.send_markOrdersAsReversalInitiated(vendorId, itemId, quantity, estimate, isReminder)
4303 rajveer 4773 
    self.recv_markOrdersAsReversalInitiated()
4774 
 
4369 rajveer 4775 
  def send_markOrdersAsReversalInitiated(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 4776 
    self._oprot.writeMessageBegin('markOrdersAsReversalInitiated', TMessageType.CALL, self._seqid)
4777 
    args = markOrdersAsReversalInitiated_args()
4778 
    args.vendorId = vendorId
4779 
    args.itemId = itemId
4780 
    args.quantity = quantity
4781 
    args.estimate = estimate
4369 rajveer 4782 
    args.isReminder = isReminder
4303 rajveer 4783 
    args.write(self._oprot)
4784 
    self._oprot.writeMessageEnd()
4785 
    self._oprot.trans.flush()
4786 
 
4787 
  def recv_markOrdersAsReversalInitiated(self, ):
4788 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4789 
    if mtype == TMessageType.EXCEPTION:
4790 
      x = TApplicationException()
4791 
      x.read(self._iprot)
4792 
      self._iprot.readMessageEnd()
4793 
      raise x
4794 
    result = markOrdersAsReversalInitiated_result()
4795 
    result.read(self._iprot)
4796 
    self._iprot.readMessageEnd()
4797 
    if result.ex is not None:
4798 
      raise result.ex
4799 
    return
4800 
 
4369 rajveer 4801 
  def markOrdersAsNotAvailabke(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 4802 
    """
4803 
    Parameters:
4804 
     - vendorId
4805 
     - itemId
4806 
     - quantity
4807 
     - estimate
4369 rajveer 4808 
     - isReminder
4303 rajveer 4809 
    """
4369 rajveer 4810 
    self.send_markOrdersAsNotAvailabke(vendorId, itemId, quantity, estimate, isReminder)
4303 rajveer 4811 
    self.recv_markOrdersAsNotAvailabke()
4812 
 
4369 rajveer 4813 
  def send_markOrdersAsNotAvailabke(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 4814 
    self._oprot.writeMessageBegin('markOrdersAsNotAvailabke', TMessageType.CALL, self._seqid)
4815 
    args = markOrdersAsNotAvailabke_args()
4816 
    args.vendorId = vendorId
4817 
    args.itemId = itemId
4818 
    args.quantity = quantity
4819 
    args.estimate = estimate
4369 rajveer 4820 
    args.isReminder = isReminder
4303 rajveer 4821 
    args.write(self._oprot)
4822 
    self._oprot.writeMessageEnd()
4823 
    self._oprot.trans.flush()
4824 
 
4825 
  def recv_markOrdersAsNotAvailabke(self, ):
4826 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4827 
    if mtype == TMessageType.EXCEPTION:
4828 
      x = TApplicationException()
4829 
      x.read(self._iprot)
4830 
      self._iprot.readMessageEnd()
4831 
      raise x
4832 
    result = markOrdersAsNotAvailabke_result()
4833 
    result.read(self._iprot)
4834 
    self._iprot.readMessageEnd()
4835 
    if result.ex is not None:
4836 
      raise result.ex
4837 
    return
4838 
 
4369 rajveer 4839 
  def markOrdersAsTimeout(self, vendorId):
4840 
    """
4841 
    Parameters:
4842 
     - vendorId
4843 
    """
4844 
    self.send_markOrdersAsTimeout(vendorId)
4845 
    return self.recv_markOrdersAsTimeout()
4303 rajveer 4846 
 
4369 rajveer 4847 
  def send_markOrdersAsTimeout(self, vendorId):
4848 
    self._oprot.writeMessageBegin('markOrdersAsTimeout', TMessageType.CALL, self._seqid)
4849 
    args = markOrdersAsTimeout_args()
4850 
    args.vendorId = vendorId
4851 
    args.write(self._oprot)
4852 
    self._oprot.writeMessageEnd()
4853 
    self._oprot.trans.flush()
4854 
 
4855 
  def recv_markOrdersAsTimeout(self, ):
4856 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4857 
    if mtype == TMessageType.EXCEPTION:
4858 
      x = TApplicationException()
4859 
      x.read(self._iprot)
4860 
      self._iprot.readMessageEnd()
4861 
      raise x
4862 
    result = markOrdersAsTimeout_result()
4863 
    result.read(self._iprot)
4864 
    self._iprot.readMessageEnd()
4865 
    if result.success is not None:
4866 
      return result.success
4867 
    if result.ex is not None:
4868 
      raise result.ex
4869 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrdersAsTimeout failed: unknown result");
4870 
 
4662 rajveer 4871 
  def markOrderAsLostInTransit(self, orderId):
4872 
    """
4873 
    Mark order as LOST_IN_TRANSIT
4874 
 
4875 
    Parameters:
4876 
     - orderId
4877 
    """
4878 
    self.send_markOrderAsLostInTransit(orderId)
4879 
    return self.recv_markOrderAsLostInTransit()
4880 
 
4881 
  def send_markOrderAsLostInTransit(self, orderId):
4882 
    self._oprot.writeMessageBegin('markOrderAsLostInTransit', TMessageType.CALL, self._seqid)
4883 
    args = markOrderAsLostInTransit_args()
4884 
    args.orderId = orderId
4885 
    args.write(self._oprot)
4886 
    self._oprot.writeMessageEnd()
4887 
    self._oprot.trans.flush()
4888 
 
4889 
  def recv_markOrderAsLostInTransit(self, ):
4890 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4891 
    if mtype == TMessageType.EXCEPTION:
4892 
      x = TApplicationException()
4893 
      x.read(self._iprot)
4894 
      self._iprot.readMessageEnd()
4895 
      raise x
4896 
    result = markOrderAsLostInTransit_result()
4897 
    result.read(self._iprot)
4898 
    self._iprot.readMessageEnd()
4899 
    if result.success is not None:
4900 
      return result.success
4901 
    if result.ex is not None:
4902 
      raise result.ex
4903 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderAsLostInTransit failed: unknown result");
4904 
 
4386 anupam.sin 4905 
  def getOrderForAwb(self, awb):
4906 
    """
4907 
    Returns the order corresponding to an AWB number
4369 rajveer 4908 
 
4386 anupam.sin 4909 
    Parameters:
4910 
     - awb
4911 
    """
4912 
    self.send_getOrderForAwb(awb)
4913 
    return self.recv_getOrderForAwb()
4914 
 
4915 
  def send_getOrderForAwb(self, awb):
4916 
    self._oprot.writeMessageBegin('getOrderForAwb', TMessageType.CALL, self._seqid)
4917 
    args = getOrderForAwb_args()
4918 
    args.awb = awb
4919 
    args.write(self._oprot)
4920 
    self._oprot.writeMessageEnd()
4921 
    self._oprot.trans.flush()
4922 
 
4923 
  def recv_getOrderForAwb(self, ):
4924 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4925 
    if mtype == TMessageType.EXCEPTION:
4926 
      x = TApplicationException()
4927 
      x.read(self._iprot)
4928 
      self._iprot.readMessageEnd()
4929 
      raise x
4930 
    result = getOrderForAwb_result()
4931 
    result.read(self._iprot)
4932 
    self._iprot.readMessageEnd()
4933 
    if result.success is not None:
4934 
      return result.success
4935 
    if result.ex is not None:
4936 
      raise result.ex
4937 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderForAwb failed: unknown result");
4938 
 
4910 phani.kuma 4939 
  def getOrdersForProviderForStatus(self, logistics_provider_id, order_status_list):
4506 phani.kuma 4940 
    """
4910 phani.kuma 4941 
    Returns the order corresponding to a logistics provider id for a given list of order status
4386 anupam.sin 4942 
 
4506 phani.kuma 4943 
    Parameters:
4944 
     - logistics_provider_id
4910 phani.kuma 4945 
     - order_status_list
4506 phani.kuma 4946 
    """
4910 phani.kuma 4947 
    self.send_getOrdersForProviderForStatus(logistics_provider_id, order_status_list)
4506 phani.kuma 4948 
    return self.recv_getOrdersForProviderForStatus()
4949 
 
4910 phani.kuma 4950 
  def send_getOrdersForProviderForStatus(self, logistics_provider_id, order_status_list):
4506 phani.kuma 4951 
    self._oprot.writeMessageBegin('getOrdersForProviderForStatus', TMessageType.CALL, self._seqid)
4952 
    args = getOrdersForProviderForStatus_args()
4953 
    args.logistics_provider_id = logistics_provider_id
4910 phani.kuma 4954 
    args.order_status_list = order_status_list
4506 phani.kuma 4955 
    args.write(self._oprot)
4956 
    self._oprot.writeMessageEnd()
4957 
    self._oprot.trans.flush()
4958 
 
4959 
  def recv_getOrdersForProviderForStatus(self, ):
4960 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4961 
    if mtype == TMessageType.EXCEPTION:
4962 
      x = TApplicationException()
4963 
      x.read(self._iprot)
4964 
      self._iprot.readMessageEnd()
4965 
      raise x
4966 
    result = getOrdersForProviderForStatus_result()
4967 
    result.read(self._iprot)
4968 
    self._iprot.readMessageEnd()
4969 
    if result.success is not None:
4970 
      return result.success
4971 
    if result.ex is not None:
4972 
      raise result.ex
4973 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersForProviderForStatus failed: unknown result");
4974 
 
4600 varun.gupt 4975 
  def getBilledOrdersForVendor(self, vendorId, billingDateFrom, billingDateTo):
4976 
    """
4977 
    Returns list of orders fullfiled from a certain vendor and billed in a given date range
4506 phani.kuma 4978 
 
4600 varun.gupt 4979 
    Parameters:
4980 
     - vendorId
4981 
     - billingDateFrom
4982 
     - billingDateTo
4983 
    """
4984 
    self.send_getBilledOrdersForVendor(vendorId, billingDateFrom, billingDateTo)
4985 
    return self.recv_getBilledOrdersForVendor()
4986 
 
4987 
  def send_getBilledOrdersForVendor(self, vendorId, billingDateFrom, billingDateTo):
4988 
    self._oprot.writeMessageBegin('getBilledOrdersForVendor', TMessageType.CALL, self._seqid)
4989 
    args = getBilledOrdersForVendor_args()
4990 
    args.vendorId = vendorId
4991 
    args.billingDateFrom = billingDateFrom
4992 
    args.billingDateTo = billingDateTo
4993 
    args.write(self._oprot)
4994 
    self._oprot.writeMessageEnd()
4995 
    self._oprot.trans.flush()
4996 
 
4997 
  def recv_getBilledOrdersForVendor(self, ):
4998 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4999 
    if mtype == TMessageType.EXCEPTION:
5000 
      x = TApplicationException()
5001 
      x.read(self._iprot)
5002 
      self._iprot.readMessageEnd()
5003 
      raise x
5004 
    result = getBilledOrdersForVendor_result()
5005 
    result.read(self._iprot)
5006 
    self._iprot.readMessageEnd()
5007 
    if result.success is not None:
5008 
      return result.success
5009 
    if result.ex is not None:
5010 
      raise result.ex
5011 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBilledOrdersForVendor failed: unknown result");
5012 
 
4607 rajveer 5013 
  def getSlippedSippingDateOrders(self, ):
5014 
    self.send_getSlippedSippingDateOrders()
5015 
    return self.recv_getSlippedSippingDateOrders()
5016 
 
5017 
  def send_getSlippedSippingDateOrders(self, ):
5018 
    self._oprot.writeMessageBegin('getSlippedSippingDateOrders', TMessageType.CALL, self._seqid)
5019 
    args = getSlippedSippingDateOrders_args()
5020 
    args.write(self._oprot)
5021 
    self._oprot.writeMessageEnd()
5022 
    self._oprot.trans.flush()
5023 
 
5024 
  def recv_getSlippedSippingDateOrders(self, ):
5025 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5026 
    if mtype == TMessageType.EXCEPTION:
5027 
      x = TApplicationException()
5028 
      x.read(self._iprot)
5029 
      self._iprot.readMessageEnd()
5030 
      raise x
5031 
    result = getSlippedSippingDateOrders_result()
5032 
    result.read(self._iprot)
5033 
    self._iprot.readMessageEnd()
5034 
    if result.success is not None:
5035 
      return result.success
5036 
    if result.ex is not None:
5037 
      raise result.ex
5038 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getSlippedSippingDateOrders failed: unknown result");
5039 
 
4709 rajveer 5040 
  def getCancelledOrders(self, cancelDateFrom, cancelDateTo):
5041 
    """
5042 
    Parameters:
5043 
     - cancelDateFrom
5044 
     - cancelDateTo
5045 
    """
5046 
    self.send_getCancelledOrders(cancelDateFrom, cancelDateTo)
5047 
    return self.recv_getCancelledOrders()
5048 
 
5049 
  def send_getCancelledOrders(self, cancelDateFrom, cancelDateTo):
5050 
    self._oprot.writeMessageBegin('getCancelledOrders', TMessageType.CALL, self._seqid)
5051 
    args = getCancelledOrders_args()
5052 
    args.cancelDateFrom = cancelDateFrom
5053 
    args.cancelDateTo = cancelDateTo
5054 
    args.write(self._oprot)
5055 
    self._oprot.writeMessageEnd()
5056 
    self._oprot.trans.flush()
5057 
 
5058 
  def recv_getCancelledOrders(self, ):
5059 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5060 
    if mtype == TMessageType.EXCEPTION:
5061 
      x = TApplicationException()
5062 
      x.read(self._iprot)
5063 
      self._iprot.readMessageEnd()
5064 
      raise x
5065 
    result = getCancelledOrders_result()
5066 
    result.read(self._iprot)
5067 
    self._iprot.readMessageEnd()
5068 
    if result.success is not None:
5069 
      return result.success
5070 
    if result.ex is not None:
5071 
      raise result.ex
5072 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCancelledOrders failed: unknown result");
5073 
 
4600 varun.gupt 5074 
  def saveBluedartSettlements(self, mapAWBAndAmount):
5075 
    """
5076 
    Parameters:
5077 
     - mapAWBAndAmount
5078 
    """
5079 
    self.send_saveBluedartSettlements(mapAWBAndAmount)
5080 
    self.recv_saveBluedartSettlements()
5081 
 
5082 
  def send_saveBluedartSettlements(self, mapAWBAndAmount):
5083 
    self._oprot.writeMessageBegin('saveBluedartSettlements', TMessageType.CALL, self._seqid)
5084 
    args = saveBluedartSettlements_args()
5085 
    args.mapAWBAndAmount = mapAWBAndAmount
5086 
    args.write(self._oprot)
5087 
    self._oprot.writeMessageEnd()
5088 
    self._oprot.trans.flush()
5089 
 
5090 
  def recv_saveBluedartSettlements(self, ):
5091 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5092 
    if mtype == TMessageType.EXCEPTION:
5093 
      x = TApplicationException()
5094 
      x.read(self._iprot)
5095 
      self._iprot.readMessageEnd()
5096 
      raise x
5097 
    result = saveBluedartSettlements_result()
5098 
    result.read(self._iprot)
5099 
    self._iprot.readMessageEnd()
5100 
    if result.ex is not None:
5101 
      raise result.ex
5102 
    return
5103 
 
4905 varun.gupt 5104 
  def savePaymentSettlements(self, settlementDate, paymentGatewayId, referenceId, serviceTax, otherCharges, netCollection):
4600 varun.gupt 5105 
    """
5106 
    Parameters:
5107 
     - settlementDate
5108 
     - paymentGatewayId
4905 varun.gupt 5109 
     - referenceId
4600 varun.gupt 5110 
     - serviceTax
5111 
     - otherCharges
5112 
     - netCollection
5113 
    """
4905 varun.gupt 5114 
    self.send_savePaymentSettlements(settlementDate, paymentGatewayId, referenceId, serviceTax, otherCharges, netCollection)
4600 varun.gupt 5115 
    self.recv_savePaymentSettlements()
5116 
 
4905 varun.gupt 5117 
  def send_savePaymentSettlements(self, settlementDate, paymentGatewayId, referenceId, serviceTax, otherCharges, netCollection):
4600 varun.gupt 5118 
    self._oprot.writeMessageBegin('savePaymentSettlements', TMessageType.CALL, self._seqid)
5119 
    args = savePaymentSettlements_args()
5120 
    args.settlementDate = settlementDate
5121 
    args.paymentGatewayId = paymentGatewayId
4905 varun.gupt 5122 
    args.referenceId = referenceId
4600 varun.gupt 5123 
    args.serviceTax = serviceTax
5124 
    args.otherCharges = otherCharges
5125 
    args.netCollection = netCollection
5126 
    args.write(self._oprot)
5127 
    self._oprot.writeMessageEnd()
5128 
    self._oprot.trans.flush()
5129 
 
5130 
  def recv_savePaymentSettlements(self, ):
5131 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5132 
    if mtype == TMessageType.EXCEPTION:
5133 
      x = TApplicationException()
5134 
      x.read(self._iprot)
5135 
      self._iprot.readMessageEnd()
5136 
      raise x
5137 
    result = savePaymentSettlements_result()
5138 
    result.read(self._iprot)
5139 
    self._iprot.readMessageEnd()
5140 
    if result.ex is not None:
5141 
      raise result.ex
5142 
    return
5143 
 
5144 
  def saveEBSSettlementSummary(self, settlementId, settlementDate, transactionDateFrom, transactionDateTo, amount):
5145 
    """
5146 
    Parameters:
5147 
     - settlementId
5148 
     - settlementDate
5149 
     - transactionDateFrom
5150 
     - transactionDateTo
5151 
     - amount
5152 
    """
5153 
    self.send_saveEBSSettlementSummary(settlementId, settlementDate, transactionDateFrom, transactionDateTo, amount)
5154 
    self.recv_saveEBSSettlementSummary()
5155 
 
5156 
  def send_saveEBSSettlementSummary(self, settlementId, settlementDate, transactionDateFrom, transactionDateTo, amount):
5157 
    self._oprot.writeMessageBegin('saveEBSSettlementSummary', TMessageType.CALL, self._seqid)
5158 
    args = saveEBSSettlementSummary_args()
5159 
    args.settlementId = settlementId
5160 
    args.settlementDate = settlementDate
5161 
    args.transactionDateFrom = transactionDateFrom
5162 
    args.transactionDateTo = transactionDateTo
5163 
    args.amount = amount
5164 
    args.write(self._oprot)
5165 
    self._oprot.writeMessageEnd()
5166 
    self._oprot.trans.flush()
5167 
 
5168 
  def recv_saveEBSSettlementSummary(self, ):
5169 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5170 
    if mtype == TMessageType.EXCEPTION:
5171 
      x = TApplicationException()
5172 
      x.read(self._iprot)
5173 
      self._iprot.readMessageEnd()
5174 
      raise x
5175 
    result = saveEBSSettlementSummary_result()
5176 
    result.read(self._iprot)
5177 
    self._iprot.readMessageEnd()
5178 
    if result.ex is not None:
5179 
      raise result.ex
5180 
    return
5181 
 
5386 phani.kuma 5182 
  def getSettlementForPrepaid(self, referenceId, isRefund):
4600 varun.gupt 5183 
    """
5184 
    Parameters:
5189 varun.gupt 5185 
     - referenceId
5186 
     - isRefund
4600 varun.gupt 5187 
    """
5386 phani.kuma 5188 
    self.send_getSettlementForPrepaid(referenceId, isRefund)
5189 
    return self.recv_getSettlementForPrepaid()
4600 varun.gupt 5190 
 
5386 phani.kuma 5191 
  def send_getSettlementForPrepaid(self, referenceId, isRefund):
5192 
    self._oprot.writeMessageBegin('getSettlementForPrepaid', TMessageType.CALL, self._seqid)
5193 
    args = getSettlementForPrepaid_args()
5189 varun.gupt 5194 
    args.referenceId = referenceId
5195 
    args.isRefund = isRefund
4600 varun.gupt 5196 
    args.write(self._oprot)
5197 
    self._oprot.writeMessageEnd()
5198 
    self._oprot.trans.flush()
5199 
 
5386 phani.kuma 5200 
  def recv_getSettlementForPrepaid(self, ):
4600 varun.gupt 5201 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5202 
    if mtype == TMessageType.EXCEPTION:
5203 
      x = TApplicationException()
5204 
      x.read(self._iprot)
5205 
      self._iprot.readMessageEnd()
5206 
      raise x
5386 phani.kuma 5207 
    result = getSettlementForPrepaid_result()
4600 varun.gupt 5208 
    result.read(self._iprot)
5209 
    self._iprot.readMessageEnd()
5210 
    if result.success is not None:
5211 
      return result.success
5212 
    if result.ex is not None:
5213 
      raise result.ex
5386 phani.kuma 5214 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getSettlementForPrepaid failed: unknown result");
4600 varun.gupt 5215 
 
5386 phani.kuma 5216 
  def getSettlementForCod(self, orderId, isRefund):
5217 
    """
5218 
    Parameters:
5219 
     - orderId
5220 
     - isRefund
5221 
    """
5222 
    self.send_getSettlementForCod(orderId, isRefund)
5223 
    return self.recv_getSettlementForCod()
5224 
 
5225 
  def send_getSettlementForCod(self, orderId, isRefund):
5226 
    self._oprot.writeMessageBegin('getSettlementForCod', TMessageType.CALL, self._seqid)
5227 
    args = getSettlementForCod_args()
5228 
    args.orderId = orderId
5229 
    args.isRefund = isRefund
5230 
    args.write(self._oprot)
5231 
    self._oprot.writeMessageEnd()
5232 
    self._oprot.trans.flush()
5233 
 
5234 
  def recv_getSettlementForCod(self, ):
5235 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5236 
    if mtype == TMessageType.EXCEPTION:
5237 
      x = TApplicationException()
5238 
      x.read(self._iprot)
5239 
      self._iprot.readMessageEnd()
5240 
      raise x
5241 
    result = getSettlementForCod_result()
5242 
    result.read(self._iprot)
5243 
    self._iprot.readMessageEnd()
5244 
    if result.success is not None:
5245 
      return result.success
5246 
    if result.ex is not None:
5247 
      raise result.ex
5248 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getSettlementForCod failed: unknown result");
5249 
 
4600 varun.gupt 5250 
  def getEBSSettlementSummaries(self, ):
5251 
    self.send_getEBSSettlementSummaries()
5252 
    return self.recv_getEBSSettlementSummaries()
5253 
 
5254 
  def send_getEBSSettlementSummaries(self, ):
5255 
    self._oprot.writeMessageBegin('getEBSSettlementSummaries', TMessageType.CALL, self._seqid)
5256 
    args = getEBSSettlementSummaries_args()
5257 
    args.write(self._oprot)
5258 
    self._oprot.writeMessageEnd()
5259 
    self._oprot.trans.flush()
5260 
 
5261 
  def recv_getEBSSettlementSummaries(self, ):
5262 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5263 
    if mtype == TMessageType.EXCEPTION:
5264 
      x = TApplicationException()
5265 
      x.read(self._iprot)
5266 
      self._iprot.readMessageEnd()
5267 
      raise x
5268 
    result = getEBSSettlementSummaries_result()
5269 
    result.read(self._iprot)
5270 
    self._iprot.readMessageEnd()
5271 
    if result.success is not None:
5272 
      return result.success
5273 
    if result.ex is not None:
5274 
      raise result.ex
5275 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getEBSSettlementSummaries failed: unknown result");
5276 
 
5277 
  def markEBSSettlementUploaded(self, settlementId):
5278 
    """
5279 
    Parameters:
5280 
     - settlementId
5281 
    """
5282 
    self.send_markEBSSettlementUploaded(settlementId)
5283 
    self.recv_markEBSSettlementUploaded()
5284 
 
5285 
  def send_markEBSSettlementUploaded(self, settlementId):
5286 
    self._oprot.writeMessageBegin('markEBSSettlementUploaded', TMessageType.CALL, self._seqid)
5287 
    args = markEBSSettlementUploaded_args()
5288 
    args.settlementId = settlementId
5289 
    args.write(self._oprot)
5290 
    self._oprot.writeMessageEnd()
5291 
    self._oprot.trans.flush()
5292 
 
5293 
  def recv_markEBSSettlementUploaded(self, ):
5294 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5295 
    if mtype == TMessageType.EXCEPTION:
5296 
      x = TApplicationException()
5297 
      x.read(self._iprot)
5298 
      self._iprot.readMessageEnd()
5299 
      raise x
5300 
    result = markEBSSettlementUploaded_result()
5301 
    result.read(self._iprot)
5302 
    self._iprot.readMessageEnd()
5303 
    if result.ex is not None:
5304 
      raise result.ex
5305 
    return
5306 
 
5307 
  def getEBSSettlementDate(self, settlementId):
5308 
    """
5309 
    Parameters:
5310 
     - settlementId
5311 
    """
5312 
    self.send_getEBSSettlementDate(settlementId)
5313 
    return self.recv_getEBSSettlementDate()
5314 
 
5315 
  def send_getEBSSettlementDate(self, settlementId):
5316 
    self._oprot.writeMessageBegin('getEBSSettlementDate', TMessageType.CALL, self._seqid)
5317 
    args = getEBSSettlementDate_args()
5318 
    args.settlementId = settlementId
5319 
    args.write(self._oprot)
5320 
    self._oprot.writeMessageEnd()
5321 
    self._oprot.trans.flush()
5322 
 
5323 
  def recv_getEBSSettlementDate(self, ):
5324 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5325 
    if mtype == TMessageType.EXCEPTION:
5326 
      x = TApplicationException()
5327 
      x.read(self._iprot)
5328 
      self._iprot.readMessageEnd()
5329 
      raise x
5330 
    result = getEBSSettlementDate_result()
5331 
    result.read(self._iprot)
5332 
    self._iprot.readMessageEnd()
5333 
    if result.success is not None:
5334 
      return result.success
5335 
    if result.ex is not None:
5336 
      raise result.ex
5337 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getEBSSettlementDate failed: unknown result");
5338 
 
4715 varun.gupt 5339 
  def getSettlementsByDate(self, settlementDateFrom, settlementDateTo, isRefund):
5340 
    """
5341 
    Parameters:
5342 
     - settlementDateFrom
5343 
     - settlementDateTo
5344 
     - isRefund
5345 
    """
5346 
    self.send_getSettlementsByDate(settlementDateFrom, settlementDateTo, isRefund)
5347 
    return self.recv_getSettlementsByDate()
4600 varun.gupt 5348 
 
4715 varun.gupt 5349 
  def send_getSettlementsByDate(self, settlementDateFrom, settlementDateTo, isRefund):
5350 
    self._oprot.writeMessageBegin('getSettlementsByDate', TMessageType.CALL, self._seqid)
5351 
    args = getSettlementsByDate_args()
5352 
    args.settlementDateFrom = settlementDateFrom
5353 
    args.settlementDateTo = settlementDateTo
5354 
    args.isRefund = isRefund
5355 
    args.write(self._oprot)
5356 
    self._oprot.writeMessageEnd()
5357 
    self._oprot.trans.flush()
5358 
 
5359 
  def recv_getSettlementsByDate(self, ):
5360 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5361 
    if mtype == TMessageType.EXCEPTION:
5362 
      x = TApplicationException()
5363 
      x.read(self._iprot)
5364 
      self._iprot.readMessageEnd()
5365 
      raise x
5366 
    result = getSettlementsByDate_result()
5367 
    result.read(self._iprot)
5368 
    self._iprot.readMessageEnd()
5369 
    if result.success is not None:
5370 
      return result.success
5371 
    if result.ex is not None:
5372 
      raise result.ex
5373 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getSettlementsByDate failed: unknown result");
5374 
 
5375 
  def getReshippedOrderIds(self, orderIds):
5376 
    """
5377 
    Returns list of Order Ids, which belong to reshiped orders, shortlisted from a given list of Order Ids
5378 
 
5379 
    Parameters:
5380 
     - orderIds
5381 
    """
5382 
    self.send_getReshippedOrderIds(orderIds)
5383 
    return self.recv_getReshippedOrderIds()
5384 
 
5385 
  def send_getReshippedOrderIds(self, orderIds):
5386 
    self._oprot.writeMessageBegin('getReshippedOrderIds', TMessageType.CALL, self._seqid)
5387 
    args = getReshippedOrderIds_args()
5388 
    args.orderIds = orderIds
5389 
    args.write(self._oprot)
5390 
    self._oprot.writeMessageEnd()
5391 
    self._oprot.trans.flush()
5392 
 
5393 
  def recv_getReshippedOrderIds(self, ):
5394 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5395 
    if mtype == TMessageType.EXCEPTION:
5396 
      x = TApplicationException()
5397 
      x.read(self._iprot)
5398 
      self._iprot.readMessageEnd()
5399 
      raise x
5400 
    result = getReshippedOrderIds_result()
5401 
    result.read(self._iprot)
5402 
    self._iprot.readMessageEnd()
5403 
    if result.success is not None:
5404 
      return result.success
5405 
    if result.ex is not None:
5406 
      raise result.ex
5407 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReshippedOrderIds failed: unknown result");
5408 
 
5481 phani.kuma 5409 
  def getBilledOrders(self, vendorId, onlyVendorNotPaid, billingDateFrom, billingDateTo):
4875 varun.gupt 5410 
    """
5411 
    Parameters:
5412 
     - vendorId
5481 phani.kuma 5413 
     - onlyVendorNotPaid
5414 
     - billingDateFrom
5415 
     - billingDateTo
4875 varun.gupt 5416 
    """
5481 phani.kuma 5417 
    self.send_getBilledOrders(vendorId, onlyVendorNotPaid, billingDateFrom, billingDateTo)
5418 
    return self.recv_getBilledOrders()
4757 mandeep.dh 5419 
 
5481 phani.kuma 5420 
  def send_getBilledOrders(self, vendorId, onlyVendorNotPaid, billingDateFrom, billingDateTo):
5421 
    self._oprot.writeMessageBegin('getBilledOrders', TMessageType.CALL, self._seqid)
5422 
    args = getBilledOrders_args()
4875 varun.gupt 5423 
    args.vendorId = vendorId
5481 phani.kuma 5424 
    args.onlyVendorNotPaid = onlyVendorNotPaid
5425 
    args.billingDateFrom = billingDateFrom
5426 
    args.billingDateTo = billingDateTo
4875 varun.gupt 5427 
    args.write(self._oprot)
5428 
    self._oprot.writeMessageEnd()
5429 
    self._oprot.trans.flush()
5430 
 
5481 phani.kuma 5431 
  def recv_getBilledOrders(self, ):
4875 varun.gupt 5432 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5433 
    if mtype == TMessageType.EXCEPTION:
5434 
      x = TApplicationException()
5435 
      x.read(self._iprot)
5436 
      self._iprot.readMessageEnd()
5437 
      raise x
5481 phani.kuma 5438 
    result = getBilledOrders_result()
4875 varun.gupt 5439 
    result.read(self._iprot)
5440 
    self._iprot.readMessageEnd()
5441 
    if result.success is not None:
5442 
      return result.success
5443 
    if result.ex is not None:
5444 
      raise result.ex
5481 phani.kuma 5445 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBilledOrders failed: unknown result");
4875 varun.gupt 5446 
 
5031 varun.gupt 5447 
  def getStatusDistributionOfOrders(self, startDate, endDate):
5448 
    """
5449 
    Parameters:
5450 
     - startDate
5451 
     - endDate
5452 
    """
5453 
    self.send_getStatusDistributionOfOrders(startDate, endDate)
5454 
    return self.recv_getStatusDistributionOfOrders()
4875 varun.gupt 5455 
 
5031 varun.gupt 5456 
  def send_getStatusDistributionOfOrders(self, startDate, endDate):
5457 
    self._oprot.writeMessageBegin('getStatusDistributionOfOrders', TMessageType.CALL, self._seqid)
5458 
    args = getStatusDistributionOfOrders_args()
5459 
    args.startDate = startDate
5460 
    args.endDate = endDate
5461 
    args.write(self._oprot)
5462 
    self._oprot.writeMessageEnd()
5463 
    self._oprot.trans.flush()
5464 
 
5465 
  def recv_getStatusDistributionOfOrders(self, ):
5466 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5467 
    if mtype == TMessageType.EXCEPTION:
5468 
      x = TApplicationException()
5469 
      x.read(self._iprot)
5470 
      self._iprot.readMessageEnd()
5471 
      raise x
5472 
    result = getStatusDistributionOfOrders_result()
5473 
    result.read(self._iprot)
5474 
    self._iprot.readMessageEnd()
5475 
    if result.success is not None:
5476 
      return result.success
5477 
    if result.ex is not None:
5478 
      raise result.ex
5479 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getStatusDistributionOfOrders failed: unknown result");
5480 
 
5067 varun.gupt 5481 
  def getOrderIdsForStatus(self, status, startDatetime, endDatetime):
5482 
    """
5483 
    Parameters:
5484 
     - status
5485 
     - startDatetime
5486 
     - endDatetime
5487 
    """
5488 
    self.send_getOrderIdsForStatus(status, startDatetime, endDatetime)
5489 
    return self.recv_getOrderIdsForStatus()
5031 varun.gupt 5490 
 
5067 varun.gupt 5491 
  def send_getOrderIdsForStatus(self, status, startDatetime, endDatetime):
5492 
    self._oprot.writeMessageBegin('getOrderIdsForStatus', TMessageType.CALL, self._seqid)
5493 
    args = getOrderIdsForStatus_args()
5494 
    args.status = status
5495 
    args.startDatetime = startDatetime
5496 
    args.endDatetime = endDatetime
5497 
    args.write(self._oprot)
5498 
    self._oprot.writeMessageEnd()
5499 
    self._oprot.trans.flush()
5500 
 
5501 
  def recv_getOrderIdsForStatus(self, ):
5502 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5503 
    if mtype == TMessageType.EXCEPTION:
5504 
      x = TApplicationException()
5505 
      x.read(self._iprot)
5506 
      self._iprot.readMessageEnd()
5507 
      raise x
5508 
    result = getOrderIdsForStatus_result()
5509 
    result.read(self._iprot)
5510 
    self._iprot.readMessageEnd()
5511 
    if result.success is not None:
5512 
      return result.success
5513 
    if result.ex is not None:
5514 
      raise result.ex
5515 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderIdsForStatus failed: unknown result");
5516 
 
5348 anupam.sin 5517 
  def updateCODAgent(self, agent, orderId):
5518 
    """
5519 
    Updates the agent who handled the COD verification call
5520 
 
5521 
    Parameters:
5522 
     - agent
5523 
     - orderId
5524 
    """
5525 
    self.send_updateCODAgent(agent, orderId)
5526 
    self.recv_updateCODAgent()
5527 
 
5528 
  def send_updateCODAgent(self, agent, orderId):
5529 
    self._oprot.writeMessageBegin('updateCODAgent', TMessageType.CALL, self._seqid)
5530 
    args = updateCODAgent_args()
5531 
    args.agent = agent
5532 
    args.orderId = orderId
5533 
    args.write(self._oprot)
5534 
    self._oprot.writeMessageEnd()
5535 
    self._oprot.trans.flush()
5536 
 
5537 
  def recv_updateCODAgent(self, ):
5538 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5539 
    if mtype == TMessageType.EXCEPTION:
5540 
      x = TApplicationException()
5541 
      x.read(self._iprot)
5542 
      self._iprot.readMessageEnd()
5543 
      raise x
5544 
    result = updateCODAgent_result()
5545 
    result.read(self._iprot)
5546 
    self._iprot.readMessageEnd()
5547 
    if result.ex is not None:
5548 
      raise result.ex
5549 
    return
5550 
 
5099 varun.gupt 5551 
  def updateOrderAsPaidToVendor(self, orderId):
5552 
    """
5553 
    Parameters:
5554 
     - orderId
5555 
    """
5556 
    self.send_updateOrderAsPaidToVendor(orderId)
5557 
    self.recv_updateOrderAsPaidToVendor()
5067 varun.gupt 5558 
 
5099 varun.gupt 5559 
  def send_updateOrderAsPaidToVendor(self, orderId):
5560 
    self._oprot.writeMessageBegin('updateOrderAsPaidToVendor', TMessageType.CALL, self._seqid)
5561 
    args = updateOrderAsPaidToVendor_args()
5562 
    args.orderId = orderId
5563 
    args.write(self._oprot)
5564 
    self._oprot.writeMessageEnd()
5565 
    self._oprot.trans.flush()
5566 
 
5567 
  def recv_updateOrderAsPaidToVendor(self, ):
5568 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5569 
    if mtype == TMessageType.EXCEPTION:
5570 
      x = TApplicationException()
5571 
      x.read(self._iprot)
5572 
      self._iprot.readMessageEnd()
5573 
      raise x
5574 
    result = updateOrderAsPaidToVendor_result()
5575 
    result.read(self._iprot)
5576 
    self._iprot.readMessageEnd()
5577 
    if result.ex is not None:
5578 
      raise result.ex
5579 
    return
5580 
 
5386 phani.kuma 5581 
  def updateOrderOnlyAsPaidToVendor(self, orderId):
5582 
    """
5583 
    Parameters:
5584 
     - orderId
5585 
    """
5586 
    self.send_updateOrderOnlyAsPaidToVendor(orderId)
5587 
    self.recv_updateOrderOnlyAsPaidToVendor()
5588 
 
5589 
  def send_updateOrderOnlyAsPaidToVendor(self, orderId):
5590 
    self._oprot.writeMessageBegin('updateOrderOnlyAsPaidToVendor', TMessageType.CALL, self._seqid)
5591 
    args = updateOrderOnlyAsPaidToVendor_args()
5592 
    args.orderId = orderId
5593 
    args.write(self._oprot)
5594 
    self._oprot.writeMessageEnd()
5595 
    self._oprot.trans.flush()
5596 
 
5597 
  def recv_updateOrderOnlyAsPaidToVendor(self, ):
5598 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5599 
    if mtype == TMessageType.EXCEPTION:
5600 
      x = TApplicationException()
5601 
      x.read(self._iprot)
5602 
      self._iprot.readMessageEnd()
5603 
      raise x
5604 
    result = updateOrderOnlyAsPaidToVendor_result()
5605 
    result.read(self._iprot)
5606 
    self._iprot.readMessageEnd()
5607 
    if result.ex is not None:
5608 
      raise result.ex
5609 
    return
5610 
 
5208 varun.gupt 5611 
  def getRefundedOrdersMarkedPaid(self, ):
5612 
    self.send_getRefundedOrdersMarkedPaid()
5613 
    return self.recv_getRefundedOrdersMarkedPaid()
5099 varun.gupt 5614 
 
5208 varun.gupt 5615 
  def send_getRefundedOrdersMarkedPaid(self, ):
5616 
    self._oprot.writeMessageBegin('getRefundedOrdersMarkedPaid', TMessageType.CALL, self._seqid)
5617 
    args = getRefundedOrdersMarkedPaid_args()
5618 
    args.write(self._oprot)
5619 
    self._oprot.writeMessageEnd()
5620 
    self._oprot.trans.flush()
5621 
 
5622 
  def recv_getRefundedOrdersMarkedPaid(self, ):
5623 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5624 
    if mtype == TMessageType.EXCEPTION:
5625 
      x = TApplicationException()
5626 
      x.read(self._iprot)
5627 
      self._iprot.readMessageEnd()
5628 
      raise x
5629 
    result = getRefundedOrdersMarkedPaid_result()
5630 
    result.read(self._iprot)
5631 
    self._iprot.readMessageEnd()
5632 
    if result.success is not None:
5633 
      return result.success
5634 
    if result.ex is not None:
5635 
      raise result.ex
5636 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getRefundedOrdersMarkedPaid failed: unknown result");
5637 
 
5447 anupam.sin 5638 
  def getAllVerificationAgents(self, minOrderId, maxOrderId):
5639 
    """
5640 
    gets all COD Verification Agents for all orderIds from a minId to maxId
5208 varun.gupt 5641 
 
5447 anupam.sin 5642 
 
5643 
    Parameters:
5644 
     - minOrderId
5645 
     - maxOrderId
5646 
    """
5647 
    self.send_getAllVerificationAgents(minOrderId, maxOrderId)
5648 
    return self.recv_getAllVerificationAgents()
5649 
 
5650 
  def send_getAllVerificationAgents(self, minOrderId, maxOrderId):
5651 
    self._oprot.writeMessageBegin('getAllVerificationAgents', TMessageType.CALL, self._seqid)
5652 
    args = getAllVerificationAgents_args()
5653 
    args.minOrderId = minOrderId
5654 
    args.maxOrderId = maxOrderId
5655 
    args.write(self._oprot)
5656 
    self._oprot.writeMessageEnd()
5657 
    self._oprot.trans.flush()
5658 
 
5659 
  def recv_getAllVerificationAgents(self, ):
5660 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5661 
    if mtype == TMessageType.EXCEPTION:
5662 
      x = TApplicationException()
5663 
      x.read(self._iprot)
5664 
      self._iprot.readMessageEnd()
5665 
      raise x
5666 
    result = getAllVerificationAgents_result()
5667 
    result.read(self._iprot)
5668 
    self._iprot.readMessageEnd()
5669 
    if result.success is not None:
5670 
      return result.success
5671 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllVerificationAgents failed: unknown result");
5672 
 
5527 anupam.sin 5673 
  def getAllAttributesForOrderId(self, orderId):
5674 
    """
5675 
    gets all attributes for a given orderId
5447 anupam.sin 5676 
 
5527 anupam.sin 5677 
    Parameters:
5678 
     - orderId
5679 
    """
5680 
    self.send_getAllAttributesForOrderId(orderId)
5681 
    return self.recv_getAllAttributesForOrderId()
5682 
 
5683 
  def send_getAllAttributesForOrderId(self, orderId):
5684 
    self._oprot.writeMessageBegin('getAllAttributesForOrderId', TMessageType.CALL, self._seqid)
5685 
    args = getAllAttributesForOrderId_args()
5686 
    args.orderId = orderId
5687 
    args.write(self._oprot)
5688 
    self._oprot.writeMessageEnd()
5689 
    self._oprot.trans.flush()
5690 
 
5691 
  def recv_getAllAttributesForOrderId(self, ):
5692 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5693 
    if mtype == TMessageType.EXCEPTION:
5694 
      x = TApplicationException()
5695 
      x.read(self._iprot)
5696 
      self._iprot.readMessageEnd()
5697 
      raise x
5698 
    result = getAllAttributesForOrderId_result()
5699 
    result.read(self._iprot)
5700 
    self._iprot.readMessageEnd()
5701 
    if result.success is not None:
5702 
      return result.success
5703 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllAttributesForOrderId failed: unknown result");
5704 
 
5676 rajveer 5705 
  def setOrderAttributes(self, orderId, attributes):
5706 
    """
5707 
    sets attributes for an order
5708 
 
5709 
    Parameters:
5710 
     - orderId
5711 
     - attributes
5712 
    """
5713 
    self.send_setOrderAttributes(orderId, attributes)
5714 
    self.recv_setOrderAttributes()
5715 
 
5716 
  def send_setOrderAttributes(self, orderId, attributes):
5717 
    self._oprot.writeMessageBegin('setOrderAttributes', TMessageType.CALL, self._seqid)
5718 
    args = setOrderAttributes_args()
5719 
    args.orderId = orderId
5720 
    args.attributes = attributes
5721 
    args.write(self._oprot)
5722 
    self._oprot.writeMessageEnd()
5723 
    self._oprot.trans.flush()
5724 
 
5725 
  def recv_setOrderAttributes(self, ):
5726 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5727 
    if mtype == TMessageType.EXCEPTION:
5728 
      x = TApplicationException()
5729 
      x.read(self._iprot)
5730 
      self._iprot.readMessageEnd()
5731 
      raise x
5732 
    result = setOrderAttributes_result()
5733 
    result.read(self._iprot)
5734 
    self._iprot.readMessageEnd()
5735 
    return
5736 
 
5527 anupam.sin 5737 
  def setOrderAttributeForTransaction(self, transactionId, attribute):
5738 
    """
5739 
    sets attributes for all orders in a transaction
5740 
 
5741 
    Parameters:
5742 
     - transactionId
5743 
     - attribute
5744 
    """
5745 
    self.send_setOrderAttributeForTransaction(transactionId, attribute)
5746 
    self.recv_setOrderAttributeForTransaction()
5747 
 
5748 
  def send_setOrderAttributeForTransaction(self, transactionId, attribute):
5749 
    self._oprot.writeMessageBegin('setOrderAttributeForTransaction', TMessageType.CALL, self._seqid)
5750 
    args = setOrderAttributeForTransaction_args()
5751 
    args.transactionId = transactionId
5752 
    args.attribute = attribute
5753 
    args.write(self._oprot)
5754 
    self._oprot.writeMessageEnd()
5755 
    self._oprot.trans.flush()
5756 
 
5757 
  def recv_setOrderAttributeForTransaction(self, ):
5758 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5759 
    if mtype == TMessageType.EXCEPTION:
5760 
      x = TApplicationException()
5761 
      x.read(self._iprot)
5762 
      self._iprot.readMessageEnd()
5763 
      raise x
5764 
    result = setOrderAttributeForTransaction_result()
5765 
    result.read(self._iprot)
5766 
    self._iprot.readMessageEnd()
5767 
    return
5768 
 
5553 rajveer 5769 
  def getReceivePendingOrders(self, storeId):
5770 
    """
5771 
    Parameters:
5772 
     - storeId
5773 
    """
5774 
    self.send_getReceivePendingOrders(storeId)
5775 
    return self.recv_getReceivePendingOrders()
5527 anupam.sin 5776 
 
5553 rajveer 5777 
  def send_getReceivePendingOrders(self, storeId):
5778 
    self._oprot.writeMessageBegin('getReceivePendingOrders', TMessageType.CALL, self._seqid)
5779 
    args = getReceivePendingOrders_args()
5780 
    args.storeId = storeId
5781 
    args.write(self._oprot)
5782 
    self._oprot.writeMessageEnd()
5783 
    self._oprot.trans.flush()
5784 
 
5785 
  def recv_getReceivePendingOrders(self, ):
5786 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5787 
    if mtype == TMessageType.EXCEPTION:
5788 
      x = TApplicationException()
5789 
      x.read(self._iprot)
5790 
      self._iprot.readMessageEnd()
5791 
      raise x
5792 
    result = getReceivePendingOrders_result()
5793 
    result.read(self._iprot)
5794 
    self._iprot.readMessageEnd()
5795 
    if result.success is not None:
5796 
      return result.success
5797 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReceivePendingOrders failed: unknown result");
5798 
 
5799 
  def getReceivedAtStoreOrders(self, storeId):
5800 
    """
5801 
    Parameters:
5802 
     - storeId
5803 
    """
5804 
    self.send_getReceivedAtStoreOrders(storeId)
5805 
    return self.recv_getReceivedAtStoreOrders()
5806 
 
5807 
  def send_getReceivedAtStoreOrders(self, storeId):
5808 
    self._oprot.writeMessageBegin('getReceivedAtStoreOrders', TMessageType.CALL, self._seqid)
5809 
    args = getReceivedAtStoreOrders_args()
5810 
    args.storeId = storeId
5811 
    args.write(self._oprot)
5812 
    self._oprot.writeMessageEnd()
5813 
    self._oprot.trans.flush()
5814 
 
5815 
  def recv_getReceivedAtStoreOrders(self, ):
5816 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5817 
    if mtype == TMessageType.EXCEPTION:
5818 
      x = TApplicationException()
5819 
      x.read(self._iprot)
5820 
      self._iprot.readMessageEnd()
5821 
      raise x
5822 
    result = getReceivedAtStoreOrders_result()
5823 
    result.read(self._iprot)
5824 
    self._iprot.readMessageEnd()
5825 
    if result.success is not None:
5826 
      return result.success
5827 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReceivedAtStoreOrders failed: unknown result");
5828 
 
5713 rajveer 5829 
  def getOrdersCollectionAtStore(self, storeId, fromDate, toDate, onlyCod):
5830 
    """
5831 
    Parameters:
5832 
     - storeId
5833 
     - fromDate
5834 
     - toDate
5835 
     - onlyCod
5836 
    """
5837 
    self.send_getOrdersCollectionAtStore(storeId, fromDate, toDate, onlyCod)
5838 
    return self.recv_getOrdersCollectionAtStore()
5839 
 
5840 
  def send_getOrdersCollectionAtStore(self, storeId, fromDate, toDate, onlyCod):
5841 
    self._oprot.writeMessageBegin('getOrdersCollectionAtStore', TMessageType.CALL, self._seqid)
5842 
    args = getOrdersCollectionAtStore_args()
5843 
    args.storeId = storeId
5844 
    args.fromDate = fromDate
5845 
    args.toDate = toDate
5846 
    args.onlyCod = onlyCod
5847 
    args.write(self._oprot)
5848 
    self._oprot.writeMessageEnd()
5849 
    self._oprot.trans.flush()
5850 
 
5851 
  def recv_getOrdersCollectionAtStore(self, ):
5852 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5853 
    if mtype == TMessageType.EXCEPTION:
5854 
      x = TApplicationException()
5855 
      x.read(self._iprot)
5856 
      self._iprot.readMessageEnd()
5857 
      raise x
5858 
    result = getOrdersCollectionAtStore_result()
5859 
    result.read(self._iprot)
5860 
    self._iprot.readMessageEnd()
5861 
    if result.success is not None:
5862 
      return result.success
5863 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersCollectionAtStore failed: unknown result");
5864 
 
5833 rajveer 5865 
  def getOrderAttributeValue(self, orderId, attributeName):
5866 
    """
5867 
    Parameters:
5868 
     - orderId
5869 
     - attributeName
5870 
    """
5871 
    self.send_getOrderAttributeValue(orderId, attributeName)
5872 
    return self.recv_getOrderAttributeValue()
5873 
 
5874 
  def send_getOrderAttributeValue(self, orderId, attributeName):
5875 
    self._oprot.writeMessageBegin('getOrderAttributeValue', TMessageType.CALL, self._seqid)
5876 
    args = getOrderAttributeValue_args()
5877 
    args.orderId = orderId
5878 
    args.attributeName = attributeName
5879 
    args.write(self._oprot)
5880 
    self._oprot.writeMessageEnd()
5881 
    self._oprot.trans.flush()
5882 
 
5883 
  def recv_getOrderAttributeValue(self, ):
5884 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5885 
    if mtype == TMessageType.EXCEPTION:
5886 
      x = TApplicationException()
5887 
      x.read(self._iprot)
5888 
      self._iprot.readMessageEnd()
5889 
      raise x
5890 
    result = getOrderAttributeValue_result()
5891 
    result.read(self._iprot)
5892 
    self._iprot.readMessageEnd()
5893 
    if result.success is not None:
5894 
      return result.success
5895 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderAttributeValue failed: unknown result");
5896 
 
6019 rajveer 5897 
  def changeJacketNumber(self, orderId, jacketNumber):
5898 
    """
5899 
    Parameters:
5900 
     - orderId
5901 
     - jacketNumber
5902 
    """
5903 
    self.send_changeJacketNumber(orderId, jacketNumber)
5904 
    return self.recv_changeJacketNumber()
5905 
 
5906 
  def send_changeJacketNumber(self, orderId, jacketNumber):
5907 
    self._oprot.writeMessageBegin('changeJacketNumber', TMessageType.CALL, self._seqid)
5908 
    args = changeJacketNumber_args()
5909 
    args.orderId = orderId
5910 
    args.jacketNumber = jacketNumber
5911 
    args.write(self._oprot)
5912 
    self._oprot.writeMessageEnd()
5913 
    self._oprot.trans.flush()
5914 
 
5915 
  def recv_changeJacketNumber(self, ):
5916 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5917 
    if mtype == TMessageType.EXCEPTION:
5918 
      x = TApplicationException()
5919 
      x.read(self._iprot)
5920 
      self._iprot.readMessageEnd()
5921 
      raise x
5922 
    result = changeJacketNumber_result()
5923 
    result.read(self._iprot)
5924 
    self._iprot.readMessageEnd()
5925 
    if result.success is not None:
5926 
      return result.success
5927 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "changeJacketNumber failed: unknown result");
5928 
 
5929 
  def markOrderAsRtoInTransit(self, orderId):
5930 
    """
5931 
    Parameters:
5932 
     - orderId
5933 
    """
5934 
    self.send_markOrderAsRtoInTransit(orderId)
5935 
    return self.recv_markOrderAsRtoInTransit()
5936 
 
5937 
  def send_markOrderAsRtoInTransit(self, orderId):
5938 
    self._oprot.writeMessageBegin('markOrderAsRtoInTransit', TMessageType.CALL, self._seqid)
5939 
    args = markOrderAsRtoInTransit_args()
5940 
    args.orderId = orderId
5941 
    args.write(self._oprot)
5942 
    self._oprot.writeMessageEnd()
5943 
    self._oprot.trans.flush()
5944 
 
5945 
  def recv_markOrderAsRtoInTransit(self, ):
5946 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5947 
    if mtype == TMessageType.EXCEPTION:
5948 
      x = TApplicationException()
5949 
      x.read(self._iprot)
5950 
      self._iprot.readMessageEnd()
5951 
      raise x
5952 
    result = markOrderAsRtoInTransit_result()
5953 
    result.read(self._iprot)
5954 
    self._iprot.readMessageEnd()
5955 
    if result.success is not None:
5956 
      return result.success
5957 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderAsRtoInTransit failed: unknown result");
5958 
 
5593 mandeep.dh 5959 
  def acceptOrderForItem(self, itemId, quantity, fulfilmentWarehouseId, billingWarehouseId):
5960 
    """
5961 
    Accepts appropriate order for an item in a given billingWarehouse. Usually
5962 
    invoked while scanning IN of items.
5553 rajveer 5963 
 
5593 mandeep.dh 5964 
    Parameters:
5965 
     - itemId
5966 
     - quantity
5967 
     - fulfilmentWarehouseId
5968 
     - billingWarehouseId
5969 
    """
5970 
    self.send_acceptOrderForItem(itemId, quantity, fulfilmentWarehouseId, billingWarehouseId)
5971 
    self.recv_acceptOrderForItem()
5972 
 
5973 
  def send_acceptOrderForItem(self, itemId, quantity, fulfilmentWarehouseId, billingWarehouseId):
5974 
    self._oprot.writeMessageBegin('acceptOrderForItem', TMessageType.CALL, self._seqid)
5975 
    args = acceptOrderForItem_args()
5976 
    args.itemId = itemId
5977 
    args.quantity = quantity
5978 
    args.fulfilmentWarehouseId = fulfilmentWarehouseId
5979 
    args.billingWarehouseId = billingWarehouseId
5980 
    args.write(self._oprot)
5981 
    self._oprot.writeMessageEnd()
5982 
    self._oprot.trans.flush()
5983 
 
5984 
  def recv_acceptOrderForItem(self, ):
5985 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5986 
    if mtype == TMessageType.EXCEPTION:
5987 
      x = TApplicationException()
5988 
      x.read(self._iprot)
5989 
      self._iprot.readMessageEnd()
5990 
      raise x
5991 
    result = acceptOrderForItem_result()
5992 
    result.read(self._iprot)
5993 
    self._iprot.readMessageEnd()
5994 
    return
5995 
 
6000 mandeep.dh 5996 
  def createRechargeOrder(self, rechargeOrder):
5997 
    """
5998 
    Parameters:
5999 
     - rechargeOrder
6000 
    """
6001 
    self.send_createRechargeOrder(rechargeOrder)
6002 
    return self.recv_createRechargeOrder()
5593 mandeep.dh 6003 
 
6000 mandeep.dh 6004 
  def send_createRechargeOrder(self, rechargeOrder):
6005 
    self._oprot.writeMessageBegin('createRechargeOrder', TMessageType.CALL, self._seqid)
6006 
    args = createRechargeOrder_args()
6007 
    args.rechargeOrder = rechargeOrder
6008 
    args.write(self._oprot)
6009 
    self._oprot.writeMessageEnd()
6010 
    self._oprot.trans.flush()
6011 
 
6012 
  def recv_createRechargeOrder(self, ):
6013 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6014 
    if mtype == TMessageType.EXCEPTION:
6015 
      x = TApplicationException()
6016 
      x.read(self._iprot)
6017 
      self._iprot.readMessageEnd()
6018 
      raise x
6019 
    result = createRechargeOrder_result()
6020 
    result.read(self._iprot)
6021 
    self._iprot.readMessageEnd()
6022 
    if result.success is not None:
6023 
      return result.success
6024 
    if result.ex is not None:
6025 
      raise result.ex
6026 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createRechargeOrder failed: unknown result");
6027 
 
6031 rajveer 6028 
  def getRechargeOrder(self, rechargeRrderId):
6029 
    """
6030 
    Parameters:
6031 
     - rechargeRrderId
6032 
    """
6033 
    self.send_getRechargeOrder(rechargeRrderId)
6034 
    return self.recv_getRechargeOrder()
6035 
 
6036 
  def send_getRechargeOrder(self, rechargeRrderId):
6037 
    self._oprot.writeMessageBegin('getRechargeOrder', TMessageType.CALL, self._seqid)
6038 
    args = getRechargeOrder_args()
6039 
    args.rechargeRrderId = rechargeRrderId
6040 
    args.write(self._oprot)
6041 
    self._oprot.writeMessageEnd()
6042 
    self._oprot.trans.flush()
6043 
 
6044 
  def recv_getRechargeOrder(self, ):
6045 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6046 
    if mtype == TMessageType.EXCEPTION:
6047 
      x = TApplicationException()
6048 
      x.read(self._iprot)
6049 
      self._iprot.readMessageEnd()
6050 
      raise x
6051 
    result = getRechargeOrder_result()
6052 
    result.read(self._iprot)
6053 
    self._iprot.readMessageEnd()
6054 
    if result.success is not None:
6055 
      return result.success
6056 
    if result.ex is not None:
6057 
      raise result.ex
6058 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getRechargeOrder failed: unknown result");
6059 
 
6060 
  def getRechargeOrders(self, userId):
6061 
    """
6062 
    Parameters:
6063 
     - userId
6064 
    """
6065 
    self.send_getRechargeOrders(userId)
6066 
    return self.recv_getRechargeOrders()
6067 
 
6068 
  def send_getRechargeOrders(self, userId):
6069 
    self._oprot.writeMessageBegin('getRechargeOrders', TMessageType.CALL, self._seqid)
6070 
    args = getRechargeOrders_args()
6071 
    args.userId = userId
6072 
    args.write(self._oprot)
6073 
    self._oprot.writeMessageEnd()
6074 
    self._oprot.trans.flush()
6075 
 
6076 
  def recv_getRechargeOrders(self, ):
6077 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6078 
    if mtype == TMessageType.EXCEPTION:
6079 
      x = TApplicationException()
6080 
      x.read(self._iprot)
6081 
      self._iprot.readMessageEnd()
6082 
      raise x
6083 
    result = getRechargeOrders_result()
6084 
    result.read(self._iprot)
6085 
    self._iprot.readMessageEnd()
6086 
    if result.success is not None:
6087 
      return result.success
6088 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getRechargeOrders failed: unknown result");
6089 
 
6000 mandeep.dh 6090 
  def updateRechargeOrderStatus(self, rechargeOrderId, rechargeOrderStatus):
6091 
    """
6092 
    Parameters:
6093 
     - rechargeOrderId
6094 
     - rechargeOrderStatus
6095 
    """
6096 
    self.send_updateRechargeOrderStatus(rechargeOrderId, rechargeOrderStatus)
6031 rajveer 6097 
    return self.recv_updateRechargeOrderStatus()
6000 mandeep.dh 6098 
 
6099 
  def send_updateRechargeOrderStatus(self, rechargeOrderId, rechargeOrderStatus):
6100 
    self._oprot.writeMessageBegin('updateRechargeOrderStatus', TMessageType.CALL, self._seqid)
6101 
    args = updateRechargeOrderStatus_args()
6102 
    args.rechargeOrderId = rechargeOrderId
6103 
    args.rechargeOrderStatus = rechargeOrderStatus
6104 
    args.write(self._oprot)
6105 
    self._oprot.writeMessageEnd()
6106 
    self._oprot.trans.flush()
6107 
 
6108 
  def recv_updateRechargeOrderStatus(self, ):
6109 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6110 
    if mtype == TMessageType.EXCEPTION:
6111 
      x = TApplicationException()
6112 
      x.read(self._iprot)
6113 
      self._iprot.readMessageEnd()
6114 
      raise x
6115 
    result = updateRechargeOrderStatus_result()
6116 
    result.read(self._iprot)
6117 
    self._iprot.readMessageEnd()
6031 rajveer 6118 
    if result.success is not None:
6119 
      return result.success
6000 mandeep.dh 6120 
    if result.ex is not None:
6121 
      raise result.ex
6031 rajveer 6122 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updateRechargeOrderStatus failed: unknown result");
6000 mandeep.dh 6123 
 
6031 rajveer 6124 
  def activateRechargeTxn(self, rechargeOrderId):
6000 mandeep.dh 6125 
    """
6126 
    Parameters:
6031 rajveer 6127 
     - rechargeOrderId
6000 mandeep.dh 6128 
    """
6031 rajveer 6129 
    self.send_activateRechargeTxn(rechargeOrderId)
6000 mandeep.dh 6130 
    return self.recv_activateRechargeTxn()
6131 
 
6031 rajveer 6132 
  def send_activateRechargeTxn(self, rechargeOrderId):
6000 mandeep.dh 6133 
    self._oprot.writeMessageBegin('activateRechargeTxn', TMessageType.CALL, self._seqid)
6134 
    args = activateRechargeTxn_args()
6031 rajveer 6135 
    args.rechargeOrderId = rechargeOrderId
6000 mandeep.dh 6136 
    args.write(self._oprot)
6137 
    self._oprot.writeMessageEnd()
6138 
    self._oprot.trans.flush()
6139 
 
6140 
  def recv_activateRechargeTxn(self, ):
6141 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6142 
    if mtype == TMessageType.EXCEPTION:
6143 
      x = TApplicationException()
6144 
      x.read(self._iprot)
6145 
      self._iprot.readMessageEnd()
6146 
      raise x
6147 
    result = activateRechargeTxn_result()
6148 
    result.read(self._iprot)
6149 
    self._iprot.readMessageEnd()
6150 
    if result.success is not None:
6151 
      return result.success
6152 
    if result.ex is not None:
6153 
      raise result.ex
6154 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "activateRechargeTxn failed: unknown result");
6155 
 
6031 rajveer 6156 
  def getUserWallet(self, userId):
6000 mandeep.dh 6157 
    """
6158 
    Parameters:
6031 rajveer 6159 
     - userId
6000 mandeep.dh 6160 
    """
6031 rajveer 6161 
    self.send_getUserWallet(userId)
6162 
    return self.recv_getUserWallet()
6000 mandeep.dh 6163 
 
6031 rajveer 6164 
  def send_getUserWallet(self, userId):
6165 
    self._oprot.writeMessageBegin('getUserWallet', TMessageType.CALL, self._seqid)
6166 
    args = getUserWallet_args()
6167 
    args.userId = userId
6000 mandeep.dh 6168 
    args.write(self._oprot)
6169 
    self._oprot.writeMessageEnd()
6170 
    self._oprot.trans.flush()
6171 
 
6031 rajveer 6172 
  def recv_getUserWallet(self, ):
6000 mandeep.dh 6173 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6174 
    if mtype == TMessageType.EXCEPTION:
6175 
      x = TApplicationException()
6176 
      x.read(self._iprot)
6177 
      self._iprot.readMessageEnd()
6178 
      raise x
6031 rajveer 6179 
    result = getUserWallet_result()
6000 mandeep.dh 6180 
    result.read(self._iprot)
6181 
    self._iprot.readMessageEnd()
6182 
    if result.success is not None:
6183 
      return result.success
6031 rajveer 6184 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUserWallet failed: unknown result");
6000 mandeep.dh 6185 
 
6031 rajveer 6186 
  def getUserWalletHistory(self, userId):
6000 mandeep.dh 6187 
    """
6188 
    Parameters:
6031 rajveer 6189 
     - userId
6000 mandeep.dh 6190 
    """
6031 rajveer 6191 
    self.send_getUserWalletHistory(userId)
6192 
    return self.recv_getUserWalletHistory()
6000 mandeep.dh 6193 
 
6031 rajveer 6194 
  def send_getUserWalletHistory(self, userId):
6195 
    self._oprot.writeMessageBegin('getUserWalletHistory', TMessageType.CALL, self._seqid)
6196 
    args = getUserWalletHistory_args()
6197 
    args.userId = userId
6000 mandeep.dh 6198 
    args.write(self._oprot)
6199 
    self._oprot.writeMessageEnd()
6200 
    self._oprot.trans.flush()
6201 
 
6031 rajveer 6202 
  def recv_getUserWalletHistory(self, ):
6000 mandeep.dh 6203 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6204 
    if mtype == TMessageType.EXCEPTION:
6205 
      x = TApplicationException()
6206 
      x.read(self._iprot)
6207 
      self._iprot.readMessageEnd()
6208 
      raise x
6031 rajveer 6209 
    result = getUserWalletHistory_result()
6000 mandeep.dh 6210 
    result.read(self._iprot)
6211 
    self._iprot.readMessageEnd()
6212 
    if result.success is not None:
6213 
      return result.success
6031 rajveer 6214 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUserWalletHistory failed: unknown result");
6000 mandeep.dh 6215 
 
6050 anupam.sin 6216 
  def getRechargeOrdersForTransaction(self, txnId):
6217 
    """
6218 
    Returns a recharge order for a given transactionId
6219 
 
6220 
    Parameters:
6221 
     - txnId
6222 
    """
6223 
    self.send_getRechargeOrdersForTransaction(txnId)
6224 
    return self.recv_getRechargeOrdersForTransaction()
6225 
 
6226 
  def send_getRechargeOrdersForTransaction(self, txnId):
6227 
    self._oprot.writeMessageBegin('getRechargeOrdersForTransaction', TMessageType.CALL, self._seqid)
6228 
    args = getRechargeOrdersForTransaction_args()
6229 
    args.txnId = txnId
6230 
    args.write(self._oprot)
6231 
    self._oprot.writeMessageEnd()
6232 
    self._oprot.trans.flush()
6233 
 
6234 
  def recv_getRechargeOrdersForTransaction(self, ):
6235 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6236 
    if mtype == TMessageType.EXCEPTION:
6237 
      x = TApplicationException()
6238 
      x.read(self._iprot)
6239 
      self._iprot.readMessageEnd()
6240 
      raise x
6241 
    result = getRechargeOrdersForTransaction_result()
6242 
    result.read(self._iprot)
6243 
    self._iprot.readMessageEnd()
6244 
    if result.success is not None:
6245 
      return result.success
6246 
    if result.ex is not None:
6247 
      raise result.ex
6248 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getRechargeOrdersForTransaction failed: unknown result");
6249 
 
6206 rajveer 6250 
  def getServiceProviders(self, rechargeType, onlyActive):
6048 rajveer 6251 
    """
6252 
    Parameters:
6253 
     - rechargeType
6206 rajveer 6254 
     - onlyActive
6048 rajveer 6255 
    """
6206 rajveer 6256 
    self.send_getServiceProviders(rechargeType, onlyActive)
6048 rajveer 6257 
    return self.recv_getServiceProviders()
6000 mandeep.dh 6258 
 
6206 rajveer 6259 
  def send_getServiceProviders(self, rechargeType, onlyActive):
6048 rajveer 6260 
    self._oprot.writeMessageBegin('getServiceProviders', TMessageType.CALL, self._seqid)
6261 
    args = getServiceProviders_args()
6262 
    args.rechargeType = rechargeType
6206 rajveer 6263 
    args.onlyActive = onlyActive
6048 rajveer 6264 
    args.write(self._oprot)
6265 
    self._oprot.writeMessageEnd()
6266 
    self._oprot.trans.flush()
6267 
 
6268 
  def recv_getServiceProviders(self, ):
6269 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6270 
    if mtype == TMessageType.EXCEPTION:
6271 
      x = TApplicationException()
6272 
      x.read(self._iprot)
6273 
      self._iprot.readMessageEnd()
6274 
      raise x
6275 
    result = getServiceProviders_result()
6276 
    result.read(self._iprot)
6277 
    self._iprot.readMessageEnd()
6278 
    if result.success is not None:
6279 
      return result.success
6280 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getServiceProviders failed: unknown result");
6281 
 
6049 rajveer 6282 
  def getServiceProviderForDevice(self, rechargeType, deviceNumber):
6048 rajveer 6283 
    """
6284 
    Parameters:
6049 rajveer 6285 
     - rechargeType
6048 rajveer 6286 
     - deviceNumber
6287 
    """
6049 rajveer 6288 
    self.send_getServiceProviderForDevice(rechargeType, deviceNumber)
6048 rajveer 6289 
    return self.recv_getServiceProviderForDevice()
6290 
 
6049 rajveer 6291 
  def send_getServiceProviderForDevice(self, rechargeType, deviceNumber):
6048 rajveer 6292 
    self._oprot.writeMessageBegin('getServiceProviderForDevice', TMessageType.CALL, self._seqid)
6293 
    args = getServiceProviderForDevice_args()
6049 rajveer 6294 
    args.rechargeType = rechargeType
6048 rajveer 6295 
    args.deviceNumber = deviceNumber
6296 
    args.write(self._oprot)
6297 
    self._oprot.writeMessageEnd()
6298 
    self._oprot.trans.flush()
6299 
 
6300 
  def recv_getServiceProviderForDevice(self, ):
6301 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6302 
    if mtype == TMessageType.EXCEPTION:
6303 
      x = TApplicationException()
6304 
      x.read(self._iprot)
6305 
      self._iprot.readMessageEnd()
6306 
      raise x
6307 
    result = getServiceProviderForDevice_result()
6308 
    result.read(self._iprot)
6309 
    self._iprot.readMessageEnd()
6310 
    if result.success is not None:
6311 
      return result.success
6312 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getServiceProviderForDevice failed: unknown result");
6313 
 
6591 anupam.sin 6314 
  def validateRecharge(self, rechargeType, deviceNumber, userSelectedProviderId, clientAddress):
6269 rajveer 6315 
    """
6316 
    Parameters:
6317 
     - rechargeType
6318 
     - deviceNumber
6307 anupam.sin 6319 
     - userSelectedProviderId
6591 anupam.sin 6320 
     - clientAddress
6269 rajveer 6321 
    """
6591 anupam.sin 6322 
    self.send_validateRecharge(rechargeType, deviceNumber, userSelectedProviderId, clientAddress)
6269 rajveer 6323 
    return self.recv_validateRecharge()
6324 
 
6591 anupam.sin 6325 
  def send_validateRecharge(self, rechargeType, deviceNumber, userSelectedProviderId, clientAddress):
6269 rajveer 6326 
    self._oprot.writeMessageBegin('validateRecharge', TMessageType.CALL, self._seqid)
6327 
    args = validateRecharge_args()
6328 
    args.rechargeType = rechargeType
6329 
    args.deviceNumber = deviceNumber
6307 anupam.sin 6330 
    args.userSelectedProviderId = userSelectedProviderId
6591 anupam.sin 6331 
    args.clientAddress = clientAddress
6269 rajveer 6332 
    args.write(self._oprot)
6333 
    self._oprot.writeMessageEnd()
6334 
    self._oprot.trans.flush()
6335 
 
6336 
  def recv_validateRecharge(self, ):
6337 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6338 
    if mtype == TMessageType.EXCEPTION:
6339 
      x = TApplicationException()
6340 
      x.read(self._iprot)
6341 
      self._iprot.readMessageEnd()
6342 
      raise x
6343 
    result = validateRecharge_result()
6344 
    result.read(self._iprot)
6345 
    self._iprot.readMessageEnd()
6346 
    if result.success is not None:
6347 
      return result.success
6348 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "validateRecharge failed: unknown result");
6349 
 
6094 rajveer 6350 
  def getRechargeOrdersForDevice(self, deviceNumber):
6351 
    """
6352 
    Parameters:
6353 
     - deviceNumber
6354 
    """
6355 
    self.send_getRechargeOrdersForDevice(deviceNumber)
6356 
    return self.recv_getRechargeOrdersForDevice()
6048 rajveer 6357 
 
6094 rajveer 6358 
  def send_getRechargeOrdersForDevice(self, deviceNumber):
6359 
    self._oprot.writeMessageBegin('getRechargeOrdersForDevice', TMessageType.CALL, self._seqid)
6360 
    args = getRechargeOrdersForDevice_args()
6361 
    args.deviceNumber = deviceNumber
6362 
    args.write(self._oprot)
6363 
    self._oprot.writeMessageEnd()
6364 
    self._oprot.trans.flush()
6365 
 
6366 
  def recv_getRechargeOrdersForDevice(self, ):
6367 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6368 
    if mtype == TMessageType.EXCEPTION:
6369 
      x = TApplicationException()
6370 
      x.read(self._iprot)
6371 
      self._iprot.readMessageEnd()
6372 
      raise x
6373 
    result = getRechargeOrdersForDevice_result()
6374 
    result.read(self._iprot)
6375 
    self._iprot.readMessageEnd()
6376 
    if result.success is not None:
6377 
      return result.success
6378 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getRechargeOrdersForDevice failed: unknown result");
6379 
 
6380 
  def addAmountToWallet(self, userId, orderId, amount):
6381 
    """
6382 
    Parameters:
6383 
     - userId
6384 
     - orderId
6385 
     - amount
6386 
    """
6387 
    self.send_addAmountToWallet(userId, orderId, amount)
6388 
    self.recv_addAmountToWallet()
6389 
 
6390 
  def send_addAmountToWallet(self, userId, orderId, amount):
6391 
    self._oprot.writeMessageBegin('addAmountToWallet', TMessageType.CALL, self._seqid)
6392 
    args = addAmountToWallet_args()
6393 
    args.userId = userId
6394 
    args.orderId = orderId
6395 
    args.amount = amount
6396 
    args.write(self._oprot)
6397 
    self._oprot.writeMessageEnd()
6398 
    self._oprot.trans.flush()
6399 
 
6400 
  def recv_addAmountToWallet(self, ):
6401 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6402 
    if mtype == TMessageType.EXCEPTION:
6403 
      x = TApplicationException()
6404 
      x.read(self._iprot)
6405 
      self._iprot.readMessageEnd()
6406 
      raise x
6407 
    result = addAmountToWallet_result()
6408 
    result.read(self._iprot)
6409 
    self._iprot.readMessageEnd()
6410 
    return
6411 
 
6188 rajveer 6412 
  def getRechargeStatistics(self, ):
6413 
    self.send_getRechargeStatistics()
6414 
    return self.recv_getRechargeStatistics()
6415 
 
6416 
  def send_getRechargeStatistics(self, ):
6417 
    self._oprot.writeMessageBegin('getRechargeStatistics', TMessageType.CALL, self._seqid)
6418 
    args = getRechargeStatistics_args()
6419 
    args.write(self._oprot)
6420 
    self._oprot.writeMessageEnd()
6421 
    self._oprot.trans.flush()
6422 
 
6423 
  def recv_getRechargeStatistics(self, ):
6424 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6425 
    if mtype == TMessageType.EXCEPTION:
6426 
      x = TApplicationException()
6427 
      x.read(self._iprot)
6428 
      self._iprot.readMessageEnd()
6429 
      raise x
6430 
    result = getRechargeStatistics_result()
6431 
    result.read(self._iprot)
6432 
    self._iprot.readMessageEnd()
6433 
    if result.success is not None:
6434 
      return result.success
6435 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getRechargeStatistics failed: unknown result");
6436 
 
6154 rajveer 6437 
  def getRechargeOrdersForStatus(self, status):
6438 
    """
6439 
    Parameters:
6440 
     - status
6441 
    """
6442 
    self.send_getRechargeOrdersForStatus(status)
6443 
    return self.recv_getRechargeOrdersForStatus()
6094 rajveer 6444 
 
6154 rajveer 6445 
  def send_getRechargeOrdersForStatus(self, status):
6446 
    self._oprot.writeMessageBegin('getRechargeOrdersForStatus', TMessageType.CALL, self._seqid)
6447 
    args = getRechargeOrdersForStatus_args()
6448 
    args.status = status
6449 
    args.write(self._oprot)
6450 
    self._oprot.writeMessageEnd()
6451 
    self._oprot.trans.flush()
6452 
 
6453 
  def recv_getRechargeOrdersForStatus(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 = getRechargeOrdersForStatus_result()
6461 
    result.read(self._iprot)
6462 
    self._iprot.readMessageEnd()
6463 
    if result.success is not None:
6464 
      return result.success
6465 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getRechargeOrdersForStatus failed: unknown result");
6466 
 
6159 rajveer 6467 
  def getPlansForOperator(self, operatorId):
6468 
    """
6469 
    Parameters:
6470 
     - operatorId
6471 
    """
6472 
    self.send_getPlansForOperator(operatorId)
6473 
    return self.recv_getPlansForOperator()
6154 rajveer 6474 
 
6159 rajveer 6475 
  def send_getPlansForOperator(self, operatorId):
6476 
    self._oprot.writeMessageBegin('getPlansForOperator', TMessageType.CALL, self._seqid)
6477 
    args = getPlansForOperator_args()
6478 
    args.operatorId = operatorId
6479 
    args.write(self._oprot)
6480 
    self._oprot.writeMessageEnd()
6481 
    self._oprot.trans.flush()
6482 
 
6483 
  def recv_getPlansForOperator(self, ):
6484 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6485 
    if mtype == TMessageType.EXCEPTION:
6486 
      x = TApplicationException()
6487 
      x.read(self._iprot)
6488 
      self._iprot.readMessageEnd()
6489 
      raise x
6490 
    result = getPlansForOperator_result()
6491 
    result.read(self._iprot)
6492 
    self._iprot.readMessageEnd()
6493 
    if result.success is not None:
6494 
      return result.success
6495 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getPlansForOperator failed: unknown result");
6496 
 
6307 anupam.sin 6497 
  def getRechargeDenominations(self, operatorId, circleCode, denominationType):
6289 anupam.sin 6498 
    """
6499 
    Returns denominations for a given operator and circle
6159 rajveer 6500 
 
6289 anupam.sin 6501 
    Parameters:
6502 
     - operatorId
6307 anupam.sin 6503 
     - circleCode
6289 anupam.sin 6504 
     - denominationType
6505 
    """
6307 anupam.sin 6506 
    self.send_getRechargeDenominations(operatorId, circleCode, denominationType)
6289 anupam.sin 6507 
    return self.recv_getRechargeDenominations()
6508 
 
6307 anupam.sin 6509 
  def send_getRechargeDenominations(self, operatorId, circleCode, denominationType):
6289 anupam.sin 6510 
    self._oprot.writeMessageBegin('getRechargeDenominations', TMessageType.CALL, self._seqid)
6511 
    args = getRechargeDenominations_args()
6512 
    args.operatorId = operatorId
6307 anupam.sin 6513 
    args.circleCode = circleCode
6289 anupam.sin 6514 
    args.denominationType = denominationType
6515 
    args.write(self._oprot)
6516 
    self._oprot.writeMessageEnd()
6517 
    self._oprot.trans.flush()
6518 
 
6519 
  def recv_getRechargeDenominations(self, ):
6520 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6521 
    if mtype == TMessageType.EXCEPTION:
6522 
      x = TApplicationException()
6523 
      x.read(self._iprot)
6524 
      self._iprot.readMessageEnd()
6525 
      raise x
6526 
    result = getRechargeDenominations_result()
6527 
    result.read(self._iprot)
6528 
    self._iprot.readMessageEnd()
6529 
    if result.success is not None:
6530 
      return result.success
6531 
    if result.ex is not None:
6532 
      raise result.ex
6533 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getRechargeDenominations failed: unknown result");
6534 
 
6371 rajveer 6535 
  def updateAvailabilityStatus(self, operatorId, circleId, isAvailable):
6536 
    """
6537 
    Parameters:
6538 
     - operatorId
6539 
     - circleId
6540 
     - isAvailable
6541 
    """
6542 
    self.send_updateAvailabilityStatus(operatorId, circleId, isAvailable)
6543 
    self.recv_updateAvailabilityStatus()
6289 anupam.sin 6544 
 
6371 rajveer 6545 
  def send_updateAvailabilityStatus(self, operatorId, circleId, isAvailable):
6546 
    self._oprot.writeMessageBegin('updateAvailabilityStatus', TMessageType.CALL, self._seqid)
6547 
    args = updateAvailabilityStatus_args()
6548 
    args.operatorId = operatorId
6549 
    args.circleId = circleId
6550 
    args.isAvailable = isAvailable
6551 
    args.write(self._oprot)
6552 
    self._oprot.writeMessageEnd()
6553 
    self._oprot.trans.flush()
6554 
 
6555 
  def recv_updateAvailabilityStatus(self, ):
6556 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6557 
    if mtype == TMessageType.EXCEPTION:
6558 
      x = TApplicationException()
6559 
      x.read(self._iprot)
6560 
      self._iprot.readMessageEnd()
6561 
      raise x
6562 
    result = updateAvailabilityStatus_result()
6563 
    result.read(self._iprot)
6564 
    self._iprot.readMessageEnd()
6565 
    return
6566 
 
6389 rajveer 6567 
  def getAvailableEmiSchemes(self, ):
6568 
    self.send_getAvailableEmiSchemes()
6569 
    return self.recv_getAvailableEmiSchemes()
6371 rajveer 6570 
 
6389 rajveer 6571 
  def send_getAvailableEmiSchemes(self, ):
6572 
    self._oprot.writeMessageBegin('getAvailableEmiSchemes', TMessageType.CALL, self._seqid)
6573 
    args = getAvailableEmiSchemes_args()
6574 
    args.write(self._oprot)
6575 
    self._oprot.writeMessageEnd()
6576 
    self._oprot.trans.flush()
6577 
 
6578 
  def recv_getAvailableEmiSchemes(self, ):
6579 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6580 
    if mtype == TMessageType.EXCEPTION:
6581 
      x = TApplicationException()
6582 
      x.read(self._iprot)
6583 
      self._iprot.readMessageEnd()
6584 
      raise x
6585 
    result = getAvailableEmiSchemes_result()
6586 
    result.read(self._iprot)
6587 
    self._iprot.readMessageEnd()
6588 
    if result.success is not None:
6589 
      return result.success
6590 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAvailableEmiSchemes failed: unknown result");
6591 
 
6592 
  def getMiscCharges(self, transactionId):
6593 
    """
6594 
    Parameters:
6595 
     - transactionId
6596 
    """
6597 
    self.send_getMiscCharges(transactionId)
6598 
    return self.recv_getMiscCharges()
6599 
 
6600 
  def send_getMiscCharges(self, transactionId):
6601 
    self._oprot.writeMessageBegin('getMiscCharges', TMessageType.CALL, self._seqid)
6602 
    args = getMiscCharges_args()
6603 
    args.transactionId = transactionId
6604 
    args.write(self._oprot)
6605 
    self._oprot.writeMessageEnd()
6606 
    self._oprot.trans.flush()
6607 
 
6608 
  def recv_getMiscCharges(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 = getMiscCharges_result()
6616 
    result.read(self._iprot)
6617 
    self._iprot.readMessageEnd()
6618 
    if result.success is not None:
6619 
      return result.success
6620 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getMiscCharges failed: unknown result");
6621 
 
6507 anupam.sin 6622 
  def refundRechargeOrder(self, rechargeOrderId):
6623 
    """
6624 
    Parameters:
6625 
     - rechargeOrderId
6626 
    """
6627 
    self.send_refundRechargeOrder(rechargeOrderId)
6628 
    return self.recv_refundRechargeOrder()
6389 rajveer 6629 
 
6507 anupam.sin 6630 
  def send_refundRechargeOrder(self, rechargeOrderId):
6631 
    self._oprot.writeMessageBegin('refundRechargeOrder', TMessageType.CALL, self._seqid)
6632 
    args = refundRechargeOrder_args()
6633 
    args.rechargeOrderId = rechargeOrderId
6634 
    args.write(self._oprot)
6635 
    self._oprot.writeMessageEnd()
6636 
    self._oprot.trans.flush()
6637 
 
6638 
  def recv_refundRechargeOrder(self, ):
6639 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6640 
    if mtype == TMessageType.EXCEPTION:
6641 
      x = TApplicationException()
6642 
      x.read(self._iprot)
6643 
      self._iprot.readMessageEnd()
6644 
      raise x
6645 
    result = refundRechargeOrder_result()
6646 
    result.read(self._iprot)
6647 
    self._iprot.readMessageEnd()
6648 
    if result.success is not None:
6649 
      return result.success
6650 
    if result.ex is not None:
6651 
      raise result.ex
6652 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "refundRechargeOrder failed: unknown result");
6653 
 
6821 amar.kumar 6654 
  def getPhysicalOrders(self, fromDate, toDate):
6655 
    """
6656 
    Parameters:
6657 
     - fromDate
6658 
     - toDate
6659 
    """
6660 
    self.send_getPhysicalOrders(fromDate, toDate)
6661 
    return self.recv_getPhysicalOrders()
6507 anupam.sin 6662 
 
6821 amar.kumar 6663 
  def send_getPhysicalOrders(self, fromDate, toDate):
6664 
    self._oprot.writeMessageBegin('getPhysicalOrders', TMessageType.CALL, self._seqid)
6665 
    args = getPhysicalOrders_args()
6666 
    args.fromDate = fromDate
6667 
    args.toDate = toDate
6668 
    args.write(self._oprot)
6669 
    self._oprot.writeMessageEnd()
6670 
    self._oprot.trans.flush()
6671 
 
6672 
  def recv_getPhysicalOrders(self, ):
6673 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6674 
    if mtype == TMessageType.EXCEPTION:
6675 
      x = TApplicationException()
6676 
      x.read(self._iprot)
6677 
      self._iprot.readMessageEnd()
6678 
      raise x
6679 
    result = getPhysicalOrders_result()
6680 
    result.read(self._iprot)
6681 
    self._iprot.readMessageEnd()
6682 
    if result.success is not None:
6683 
      return result.success
6684 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getPhysicalOrders failed: unknown result");
6685 
 
6906 rajveer 6686 
  def getDocument(self, docType, docSource):
6687 
    """
6688 
    Parameters:
6689 
     - docType
6690 
     - docSource
6691 
    """
6692 
    self.send_getDocument(docType, docSource)
6693 
    return self.recv_getDocument()
6821 amar.kumar 6694 
 
6906 rajveer 6695 
  def send_getDocument(self, docType, docSource):
6696 
    self._oprot.writeMessageBegin('getDocument', TMessageType.CALL, self._seqid)
6697 
    args = getDocument_args()
6698 
    args.docType = docType
6699 
    args.docSource = docSource
6700 
    args.write(self._oprot)
6701 
    self._oprot.writeMessageEnd()
6702 
    self._oprot.trans.flush()
6703 
 
6704 
  def recv_getDocument(self, ):
6705 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6706 
    if mtype == TMessageType.EXCEPTION:
6707 
      x = TApplicationException()
6708 
      x.read(self._iprot)
6709 
      self._iprot.readMessageEnd()
6710 
      raise x
6711 
    result = getDocument_result()
6712 
    result.read(self._iprot)
6713 
    self._iprot.readMessageEnd()
6714 
    if result.success is not None:
6715 
      return result.success
6716 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getDocument failed: unknown result");
6717 
 
6985 anupam.sin 6718 
  def changeShippingAddress(self, orderId, line1, line2, city, state, pin):
6719 
    """
6720 
    Parameters:
6721 
     - orderId
6722 
     - line1
6723 
     - line2
6724 
     - city
6725 
     - state
6726 
     - pin
6727 
    """
6728 
    self.send_changeShippingAddress(orderId, line1, line2, city, state, pin)
6729 
    return self.recv_changeShippingAddress()
6906 rajveer 6730 
 
6985 anupam.sin 6731 
  def send_changeShippingAddress(self, orderId, line1, line2, city, state, pin):
6732 
    self._oprot.writeMessageBegin('changeShippingAddress', TMessageType.CALL, self._seqid)
6733 
    args = changeShippingAddress_args()
6734 
    args.orderId = orderId
6735 
    args.line1 = line1
6736 
    args.line2 = line2
6737 
    args.city = city
6738 
    args.state = state
6739 
    args.pin = pin
6740 
    args.write(self._oprot)
6741 
    self._oprot.writeMessageEnd()
6742 
    self._oprot.trans.flush()
6743 
 
6744 
  def recv_changeShippingAddress(self, ):
6745 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6746 
    if mtype == TMessageType.EXCEPTION:
6747 
      x = TApplicationException()
6748 
      x.read(self._iprot)
6749 
      self._iprot.readMessageEnd()
6750 
      raise x
6751 
    result = changeShippingAddress_result()
6752 
    result.read(self._iprot)
6753 
    self._iprot.readMessageEnd()
6754 
    if result.success is not None:
6755 
      return result.success
6756 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "changeShippingAddress failed: unknown result");
6757 
 
7075 rajveer 6758 
  def retrieveInvoice(self, orderId, userId):
6988 rajveer 6759 
    """
6760 
    Parameters:
6761 
     - orderId
7075 rajveer 6762 
     - userId
6988 rajveer 6763 
    """
7075 rajveer 6764 
    self.send_retrieveInvoice(orderId, userId)
6988 rajveer 6765 
    return self.recv_retrieveInvoice()
6985 anupam.sin 6766 
 
7075 rajveer 6767 
  def send_retrieveInvoice(self, orderId, userId):
6988 rajveer 6768 
    self._oprot.writeMessageBegin('retrieveInvoice', TMessageType.CALL, self._seqid)
6769 
    args = retrieveInvoice_args()
6770 
    args.orderId = orderId
7075 rajveer 6771 
    args.userId = userId
6988 rajveer 6772 
    args.write(self._oprot)
6773 
    self._oprot.writeMessageEnd()
6774 
    self._oprot.trans.flush()
6775 
 
6776 
  def recv_retrieveInvoice(self, ):
6777 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6778 
    if mtype == TMessageType.EXCEPTION:
6779 
      x = TApplicationException()
6780 
      x.read(self._iprot)
6781 
      self._iprot.readMessageEnd()
6782 
      raise x
6783 
    result = retrieveInvoice_result()
6784 
    result.read(self._iprot)
6785 
    self._iprot.readMessageEnd()
6786 
    if result.success is not None:
6787 
      return result.success
6788 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "retrieveInvoice failed: unknown result");
6789 
 
7026 rajveer 6790 
  def receiveUpdatesForRedExpress(self, awbNumber):
6791 
    """
6792 
    Parameters:
6793 
     - awbNumber
6794 
    """
6795 
    self.send_receiveUpdatesForRedExpress(awbNumber)
6796 
    return self.recv_receiveUpdatesForRedExpress()
6988 rajveer 6797 
 
7026 rajveer 6798 
  def send_receiveUpdatesForRedExpress(self, awbNumber):
6799 
    self._oprot.writeMessageBegin('receiveUpdatesForRedExpress', TMessageType.CALL, self._seqid)
6800 
    args = receiveUpdatesForRedExpress_args()
6801 
    args.awbNumber = awbNumber
6802 
    args.write(self._oprot)
6803 
    self._oprot.writeMessageEnd()
6804 
    self._oprot.trans.flush()
6805 
 
6806 
  def recv_receiveUpdatesForRedExpress(self, ):
6807 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6808 
    if mtype == TMessageType.EXCEPTION:
6809 
      x = TApplicationException()
6810 
      x.read(self._iprot)
6811 
      self._iprot.readMessageEnd()
6812 
      raise x
6813 
    result = receiveUpdatesForRedExpress_result()
6814 
    result.read(self._iprot)
6815 
    self._iprot.readMessageEnd()
6816 
    if result.success is not None:
6817 
      return result.success
6818 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "receiveUpdatesForRedExpress failed: unknown result");
6819 
 
7073 anupam.sin 6820 
  def createRechargeTransaction(self, thriftRechargeTransaction):
6821 
    """
6822 
    Parameters:
6823 
     - thriftRechargeTransaction
6824 
    """
6825 
    self.send_createRechargeTransaction(thriftRechargeTransaction)
6826 
    return self.recv_createRechargeTransaction()
7026 rajveer 6827 
 
7073 anupam.sin 6828 
  def send_createRechargeTransaction(self, thriftRechargeTransaction):
6829 
    self._oprot.writeMessageBegin('createRechargeTransaction', TMessageType.CALL, self._seqid)
6830 
    args = createRechargeTransaction_args()
6831 
    args.thriftRechargeTransaction = thriftRechargeTransaction
6832 
    args.write(self._oprot)
6833 
    self._oprot.writeMessageEnd()
6834 
    self._oprot.trans.flush()
6835 
 
6836 
  def recv_createRechargeTransaction(self, ):
6837 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6838 
    if mtype == TMessageType.EXCEPTION:
6839 
      x = TApplicationException()
6840 
      x.read(self._iprot)
6841 
      self._iprot.readMessageEnd()
6842 
      raise x
6843 
    result = createRechargeTransaction_result()
6844 
    result.read(self._iprot)
6845 
    self._iprot.readMessageEnd()
6846 
    if result.success is not None:
6847 
      return result.success
6848 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createRechargeTransaction failed: unknown result");
6849 
 
7085 rajveer 6850 
  def getRechargeTransactions(self, storeId):
6851 
    """
6852 
    Parameters:
6853 
     - storeId
6854 
    """
6855 
    self.send_getRechargeTransactions(storeId)
6856 
    return self.recv_getRechargeTransactions()
6857 
 
6858 
  def send_getRechargeTransactions(self, storeId):
6859 
    self._oprot.writeMessageBegin('getRechargeTransactions', TMessageType.CALL, self._seqid)
6860 
    args = getRechargeTransactions_args()
6861 
    args.storeId = storeId
6862 
    args.write(self._oprot)
6863 
    self._oprot.writeMessageEnd()
6864 
    self._oprot.trans.flush()
6865 
 
6866 
  def recv_getRechargeTransactions(self, ):
6867 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6868 
    if mtype == TMessageType.EXCEPTION:
6869 
      x = TApplicationException()
6870 
      x.read(self._iprot)
6871 
      self._iprot.readMessageEnd()
6872 
      raise x
6873 
    result = getRechargeTransactions_result()
6874 
    result.read(self._iprot)
6875 
    self._iprot.readMessageEnd()
6876 
    if result.success is not None:
6877 
      return result.success
6878 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getRechargeTransactions failed: unknown result");
6879 
 
7151 amit.gupta 6880 
  def getRechargeTrans(self, storeId, startDate, endDate, status):
6881 
    """
6882 
    Parameters:
6883 
     - storeId
6884 
     - startDate
6885 
     - endDate
6886 
     - status
6887 
    """
6888 
    self.send_getRechargeTrans(storeId, startDate, endDate, status)
6889 
    return self.recv_getRechargeTrans()
6890 
 
6891 
  def send_getRechargeTrans(self, storeId, startDate, endDate, status):
6892 
    self._oprot.writeMessageBegin('getRechargeTrans', TMessageType.CALL, self._seqid)
6893 
    args = getRechargeTrans_args()
6894 
    args.storeId = storeId
6895 
    args.startDate = startDate
6896 
    args.endDate = endDate
6897 
    args.status = status
6898 
    args.write(self._oprot)
6899 
    self._oprot.writeMessageEnd()
6900 
    self._oprot.trans.flush()
6901 
 
6902 
  def recv_getRechargeTrans(self, ):
6903 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6904 
    if mtype == TMessageType.EXCEPTION:
6905 
      x = TApplicationException()
6906 
      x.read(self._iprot)
6907 
      self._iprot.readMessageEnd()
6908 
      raise x
6909 
    result = getRechargeTrans_result()
6910 
    result.read(self._iprot)
6911 
    self._iprot.readMessageEnd()
6912 
    if result.success is not None:
6913 
      return result.success
6914 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getRechargeTrans failed: unknown result");
6915 
 
7080 anupam.sin 6916 
  def getRechargeTransaction(self, rechargeId):
6917 
    """
6918 
    Parameters:
6919 
     - rechargeId
6920 
    """
6921 
    self.send_getRechargeTransaction(rechargeId)
6922 
    return self.recv_getRechargeTransaction()
7073 anupam.sin 6923 
 
7080 anupam.sin 6924 
  def send_getRechargeTransaction(self, rechargeId):
6925 
    self._oprot.writeMessageBegin('getRechargeTransaction', TMessageType.CALL, self._seqid)
6926 
    args = getRechargeTransaction_args()
6927 
    args.rechargeId = rechargeId
6928 
    args.write(self._oprot)
6929 
    self._oprot.writeMessageEnd()
6930 
    self._oprot.trans.flush()
6931 
 
6932 
  def recv_getRechargeTransaction(self, ):
6933 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6934 
    if mtype == TMessageType.EXCEPTION:
6935 
      x = TApplicationException()
6936 
      x.read(self._iprot)
6937 
      self._iprot.readMessageEnd()
6938 
      raise x
6939 
    result = getRechargeTransaction_result()
6940 
    result.read(self._iprot)
6941 
    self._iprot.readMessageEnd()
6942 
    if result.success is not None:
6943 
      return result.success
6944 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getRechargeTransaction failed: unknown result");
6945 
 
6946 
  def getFRCs(self, circleId, operatorId):
6947 
    """
6948 
    Parameters:
6949 
     - circleId
6950 
     - operatorId
6951 
    """
6952 
    self.send_getFRCs(circleId, operatorId)
6953 
    return self.recv_getFRCs()
6954 
 
6955 
  def send_getFRCs(self, circleId, operatorId):
6956 
    self._oprot.writeMessageBegin('getFRCs', TMessageType.CALL, self._seqid)
6957 
    args = getFRCs_args()
6958 
    args.circleId = circleId
6959 
    args.operatorId = operatorId
6960 
    args.write(self._oprot)
6961 
    self._oprot.writeMessageEnd()
6962 
    self._oprot.trans.flush()
6963 
 
6964 
  def recv_getFRCs(self, ):
6965 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6966 
    if mtype == TMessageType.EXCEPTION:
6967 
      x = TApplicationException()
6968 
      x.read(self._iprot)
6969 
      self._iprot.readMessageEnd()
6970 
      raise x
6971 
    result = getFRCs_result()
6972 
    result.read(self._iprot)
6973 
    self._iprot.readMessageEnd()
6974 
    if result.success is not None:
6975 
      return result.success
6976 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getFRCs failed: unknown result");
6977 
 
7096 anupam.sin 6978 
  def getHotspotStore(self, id, hotspotid):
6979 
    """
6980 
    Parameters:
6981 
     - id
6982 
     - hotspotid
6983 
    """
6984 
    self.send_getHotspotStore(id, hotspotid)
6985 
    return self.recv_getHotspotStore()
7080 anupam.sin 6986 
 
7096 anupam.sin 6987 
  def send_getHotspotStore(self, id, hotspotid):
6988 
    self._oprot.writeMessageBegin('getHotspotStore', TMessageType.CALL, self._seqid)
6989 
    args = getHotspotStore_args()
6990 
    args.id = id
6991 
    args.hotspotid = hotspotid
6992 
    args.write(self._oprot)
6993 
    self._oprot.writeMessageEnd()
6994 
    self._oprot.trans.flush()
6995 
 
6996 
  def recv_getHotspotStore(self, ):
6997 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6998 
    if mtype == TMessageType.EXCEPTION:
6999 
      x = TApplicationException()
7000 
      x.read(self._iprot)
7001 
      self._iprot.readMessageEnd()
7002 
      raise x
7003 
    result = getHotspotStore_result()
7004 
    result.read(self._iprot)
7005 
    self._iprot.readMessageEnd()
7006 
    if result.success is not None:
7007 
      return result.success
7008 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getHotspotStore failed: unknown result");
7009 
 
7010 
  def getTelecomCircle(self, id, code):
7011 
    """
7012 
    Parameters:
7013 
     - id
7014 
     - code
7015 
    """
7016 
    self.send_getTelecomCircle(id, code)
7017 
    return self.recv_getTelecomCircle()
7018 
 
7019 
  def send_getTelecomCircle(self, id, code):
7020 
    self._oprot.writeMessageBegin('getTelecomCircle', TMessageType.CALL, self._seqid)
7021 
    args = getTelecomCircle_args()
7022 
    args.id = id
7023 
    args.code = code
7024 
    args.write(self._oprot)
7025 
    self._oprot.writeMessageEnd()
7026 
    self._oprot.trans.flush()
7027 
 
7028 
  def recv_getTelecomCircle(self, ):
7029 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
7030 
    if mtype == TMessageType.EXCEPTION:
7031 
      x = TApplicationException()
7032 
      x.read(self._iprot)
7033 
      self._iprot.readMessageEnd()
7034 
      raise x
7035 
    result = getTelecomCircle_result()
7036 
    result.read(self._iprot)
7037 
    self._iprot.readMessageEnd()
7038 
    if result.success is not None:
7039 
      return result.success
7040 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTelecomCircle failed: unknown result");
7041 
 
7109 anupam.sin 7042 
  def retrieveHotspotRechargeInvoice(self, rechargeId):
7043 
    """
7044 
    Parameters:
7045 
     - rechargeId
7046 
    """
7047 
    self.send_retrieveHotspotRechargeInvoice(rechargeId)
7048 
    return self.recv_retrieveHotspotRechargeInvoice()
7096 anupam.sin 7049 
 
7109 anupam.sin 7050 
  def send_retrieveHotspotRechargeInvoice(self, rechargeId):
7051 
    self._oprot.writeMessageBegin('retrieveHotspotRechargeInvoice', TMessageType.CALL, self._seqid)
7052 
    args = retrieveHotspotRechargeInvoice_args()
7053 
    args.rechargeId = rechargeId
7054 
    args.write(self._oprot)
7055 
    self._oprot.writeMessageEnd()
7056 
    self._oprot.trans.flush()
7057 
 
7058 
  def recv_retrieveHotspotRechargeInvoice(self, ):
7059 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
7060 
    if mtype == TMessageType.EXCEPTION:
7061 
      x = TApplicationException()
7062 
      x.read(self._iprot)
7063 
      self._iprot.readMessageEnd()
7064 
      raise x
7065 
    result = retrieveHotspotRechargeInvoice_result()
7066 
    result.read(self._iprot)
7067 
    self._iprot.readMessageEnd()
7068 
    if result.success is not None:
7069 
      return result.success
7070 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "retrieveHotspotRechargeInvoice failed: unknown result");
7071 
 
7072 
 
3376 rajveer 7073 
class Processor(shop2020.thriftpy.generic.GenericService.Processor, Iface, TProcessor):
94 ashish 7074 
  def __init__(self, handler):
3376 rajveer 7075 
    shop2020.thriftpy.generic.GenericService.Processor.__init__(self, handler)
94 ashish 7076 
    self._processMap["createTransaction"] = Processor.process_createTransaction
7077 
    self._processMap["getTransaction"] = Processor.process_getTransaction
7078 
    self._processMap["getTransactionsForCustomer"] = Processor.process_getTransactionsForCustomer
132 ashish 7079 
    self._processMap["getTransactionsForShoppingCartId"] = Processor.process_getTransactionsForShoppingCartId
94 ashish 7080 
    self._processMap["getTransactionStatus"] = Processor.process_getTransactionStatus
7081 
    self._processMap["changeTransactionStatus"] = Processor.process_changeTransactionStatus
1398 varun.gupt 7082 
    self._processMap["enqueueTransactionInfoEmail"] = Processor.process_enqueueTransactionInfoEmail
483 rajveer 7083 
    self._processMap["getAllOrders"] = Processor.process_getAllOrders
4133 chandransh 7084 
    self._processMap["getOrdersInBatch"] = Processor.process_getOrdersInBatch
7085 
    self._processMap["getOrderCount"] = Processor.process_getOrderCount
999 varun.gupt 7086 
    self._processMap["getOrdersByBillingDate"] = Processor.process_getOrdersByBillingDate
3427 chandransh 7087 
    self._processMap["getOrdersByShippingDate"] = Processor.process_getOrdersByShippingDate
1382 varun.gupt 7088 
    self._processMap["getReturnableOrdersForCustomer"] = Processor.process_getReturnableOrdersForCustomer
7089 
    self._processMap["getCancellableOrdersForCustomer"] = Processor.process_getCancellableOrdersForCustomer
483 rajveer 7090 
    self._processMap["changeOrderStatus"] = Processor.process_changeOrderStatus
7091 
    self._processMap["getOrdersForTransaction"] = Processor.process_getOrdersForTransaction
7092 
    self._processMap["getOrdersForCustomer"] = Processor.process_getOrdersForCustomer
7093 
    self._processMap["createOrder"] = Processor.process_createOrder
7094 
    self._processMap["getOrder"] = Processor.process_getOrder
7095 
    self._processMap["getLineItemsForOrder"] = Processor.process_getLineItemsForOrder
4999 phani.kuma 7096 
    self._processMap["getOrderList"] = Processor.process_getOrderList
5386 phani.kuma 7097 
    self._processMap["getOrderListForVendor"] = Processor.process_getOrderListForVendor
1528 ankur.sing 7098 
    self._processMap["getOrderForCustomer"] = Processor.process_getOrderForCustomer
3064 chandransh 7099 
    self._processMap["getAlerts"] = Processor.process_getAlerts
4394 rajveer 7100 
    self._processMap["addAlert"] = Processor.process_addAlert
4444 rajveer 7101 
    self._processMap["markAlertsAsSeen"] = Processor.process_markAlertsAsSeen
3064 chandransh 7102 
    self._processMap["getValidOrderCount"] = Processor.process_getValidOrderCount
7103 
    self._processMap["getNoOfCustomersWithSuccessfulTransaction"] = Processor.process_getNoOfCustomersWithSuccessfulTransaction
7104 
    self._processMap["getValidOrdersAmountRange"] = Processor.process_getValidOrdersAmountRange
7105 
    self._processMap["getValidOrders"] = Processor.process_getValidOrders
1220 chandransh 7106 
    self._processMap["batchOrders"] = Processor.process_batchOrders
1208 chandransh 7107 
    self._processMap["markOrderAsOutOfStock"] = Processor.process_markOrderAsOutOfStock
3064 chandransh 7108 
    self._processMap["verifyOrder"] = Processor.process_verifyOrder
7109 
    self._processMap["acceptOrder"] = Processor.process_acceptOrder
7110 
    self._processMap["addBillingDetails"] = Processor.process_addBillingDetails
4579 rajveer 7111 
    self._processMap["addInvoiceNumber"] = Processor.process_addInvoiceNumber
4410 rajveer 7112 
    self._processMap["markOrdersAsShippedFromWarehouse"] = Processor.process_markOrdersAsShippedFromWarehouse
5676 rajveer 7113 
    self._processMap["markOrdersAsReturnedFromStore"] = Processor.process_markOrdersAsReturnedFromStore
1113 chandransh 7114 
    self._processMap["markOrdersAsPickedUp"] = Processor.process_markOrdersAsPickedUp
4910 phani.kuma 7115 
    self._processMap["getOrdersNotPickedUp"] = Processor.process_getOrdersNotPickedUp
1132 chandransh 7116 
    self._processMap["markOrdersAsDelivered"] = Processor.process_markOrdersAsDelivered
4910 phani.kuma 7117 
    self._processMap["markAsRTOrders"] = Processor.process_markAsRTOrders
7118 
    self._processMap["getRTOrders"] = Processor.process_getRTOrders
1246 chandransh 7119 
    self._processMap["updateNonDeliveryReason"] = Processor.process_updateNonDeliveryReason
4910 phani.kuma 7120 
    self._processMap["getNonDeliveredOrdersbyCourier"] = Processor.process_getNonDeliveredOrdersbyCourier
7121 
    self._processMap["markOrdersAsLocalConnected"] = Processor.process_markOrdersAsLocalConnected
7122 
    self._processMap["getOrdersNotLocalConnected"] = Processor.process_getOrdersNotLocalConnected
7123 
    self._processMap["markOrdersAsDestinationCityReached"] = Processor.process_markOrdersAsDestinationCityReached
7124 
    self._processMap["markOrdersAsFirstDeliveryAttempted"] = Processor.process_markOrdersAsFirstDeliveryAttempted
1408 ankur.sing 7125 
    self._processMap["getUndeliveredOrders"] = Processor.process_getUndeliveredOrders
4783 phani.kuma 7126 
    self._processMap["getUndeliveredOrdersExpectedDeliveryDateNotMet"] = Processor.process_getUndeliveredOrdersExpectedDeliveryDateNotMet
2536 chandransh 7127 
    self._processMap["toggleDOAFlag"] = Processor.process_toggleDOAFlag
4712 rajveer 7128 
    self._processMap["markOrderAsDelivered"] = Processor.process_markOrderAsDelivered
5553 rajveer 7129 
    self._processMap["markOrderAsReceivedAtStore"] = Processor.process_markOrderAsReceivedAtStore
4454 rajveer 7130 
    self._processMap["markOrderDoaRequestReceived"] = Processor.process_markOrderDoaRequestReceived
7131 
    self._processMap["markOrderDoaRequestAuthorized"] = Processor.process_markOrderDoaRequestAuthorized
4488 rajveer 7132 
    self._processMap["markOrderReturnRequestReceived"] = Processor.process_markOrderReturnRequestReceived
7133 
    self._processMap["markOrderReturnRequestAuthorized"] = Processor.process_markOrderReturnRequestAuthorized
2536 chandransh 7134 
    self._processMap["requestPickupNumber"] = Processor.process_requestPickupNumber
7135 
    self._processMap["authorizePickup"] = Processor.process_authorizePickup
2764 chandransh 7136 
    self._processMap["markDoasAsPickedUp"] = Processor.process_markDoasAsPickedUp
4910 phani.kuma 7137 
    self._processMap["getDoasNotPickedUp"] = Processor.process_getDoasNotPickedUp
4741 phani.kuma 7138 
    self._processMap["markReturnOrdersAsPickedUp"] = Processor.process_markReturnOrdersAsPickedUp
4910 phani.kuma 7139 
    self._processMap["getReturnOrdersNotPickedUp"] = Processor.process_getReturnOrdersNotPickedUp
2616 chandransh 7140 
    self._processMap["receiveReturn"] = Processor.process_receiveReturn
2591 chandransh 7141 
    self._processMap["validateDoa"] = Processor.process_validateDoa
4495 rajveer 7142 
    self._processMap["validateReturnProduct"] = Processor.process_validateReturnProduct
2616 chandransh 7143 
    self._processMap["reshipOrder"] = Processor.process_reshipOrder
7144 
    self._processMap["refundOrder"] = Processor.process_refundOrder
2690 chandransh 7145 
    self._processMap["getReturnOrders"] = Processor.process_getReturnOrders
5481 phani.kuma 7146 
    self._processMap["getAllReturnOrders"] = Processor.process_getAllReturnOrders
2700 chandransh 7147 
    self._processMap["getReturnOrder"] = Processor.process_getReturnOrder
2690 chandransh 7148 
    self._processMap["processReturn"] = Processor.process_processReturn
3451 chandransh 7149 
    self._processMap["updateWeight"] = Processor.process_updateWeight
3469 chandransh 7150 
    self._processMap["changeItem"] = Processor.process_changeItem
7151 
    self._processMap["shiftToWarehouse"] = Processor.process_shiftToWarehouse
3553 chandransh 7152 
    self._processMap["addDelayReason"] = Processor.process_addDelayReason
3956 chandransh 7153 
    self._processMap["reconcileCodCollection"] = Processor.process_reconcileCodCollection
4008 mandeep.dh 7154 
    self._processMap["getTransactionsRequiringExtraProcessing"] = Processor.process_getTransactionsRequiringExtraProcessing
7155 
    self._processMap["markTransactionAsProcessed"] = Processor.process_markTransactionAsProcessed
4018 chandransh 7156 
    self._processMap["getItemWiseRiskyOrdersCount"] = Processor.process_getItemWiseRiskyOrdersCount
4295 varun.gupt 7157 
    self._processMap["getOrdersForItemIds"] = Processor.process_getOrdersForItemIds
4247 rajveer 7158 
    self._processMap["markOrderCancellationRequestReceived"] = Processor.process_markOrderCancellationRequestReceived
7159 
    self._processMap["markOrderCancellationRequestConfirmed"] = Processor.process_markOrderCancellationRequestConfirmed
7160 
    self._processMap["markOrderCancellationRequestDenied"] = Processor.process_markOrderCancellationRequestDenied
4258 rajveer 7161 
    self._processMap["markTransactionAsPaymentFlagRemoved"] = Processor.process_markTransactionAsPaymentFlagRemoved
4259 anupam.sin 7162 
    self._processMap["refundTransaction"] = Processor.process_refundTransaction
4324 mandeep.dh 7163 
    self._processMap["updateShipmentAddress"] = Processor.process_updateShipmentAddress
4285 rajveer 7164 
    self._processMap["acceptOrdersForItemId"] = Processor.process_acceptOrdersForItemId
4303 rajveer 7165 
    self._processMap["markOrdersAsPORaised"] = Processor.process_markOrdersAsPORaised
7166 
    self._processMap["markOrdersAsReversalInitiated"] = Processor.process_markOrdersAsReversalInitiated
7167 
    self._processMap["markOrdersAsNotAvailabke"] = Processor.process_markOrdersAsNotAvailabke
4369 rajveer 7168 
    self._processMap["markOrdersAsTimeout"] = Processor.process_markOrdersAsTimeout
4662 rajveer 7169 
    self._processMap["markOrderAsLostInTransit"] = Processor.process_markOrderAsLostInTransit
4386 anupam.sin 7170 
    self._processMap["getOrderForAwb"] = Processor.process_getOrderForAwb
4506 phani.kuma 7171 
    self._processMap["getOrdersForProviderForStatus"] = Processor.process_getOrdersForProviderForStatus
4600 varun.gupt 7172 
    self._processMap["getBilledOrdersForVendor"] = Processor.process_getBilledOrdersForVendor
4607 rajveer 7173 
    self._processMap["getSlippedSippingDateOrders"] = Processor.process_getSlippedSippingDateOrders
4709 rajveer 7174 
    self._processMap["getCancelledOrders"] = Processor.process_getCancelledOrders
4600 varun.gupt 7175 
    self._processMap["saveBluedartSettlements"] = Processor.process_saveBluedartSettlements
7176 
    self._processMap["savePaymentSettlements"] = Processor.process_savePaymentSettlements
7177 
    self._processMap["saveEBSSettlementSummary"] = Processor.process_saveEBSSettlementSummary
5386 phani.kuma 7178 
    self._processMap["getSettlementForPrepaid"] = Processor.process_getSettlementForPrepaid
7179 
    self._processMap["getSettlementForCod"] = Processor.process_getSettlementForCod
4600 varun.gupt 7180 
    self._processMap["getEBSSettlementSummaries"] = Processor.process_getEBSSettlementSummaries
7181 
    self._processMap["markEBSSettlementUploaded"] = Processor.process_markEBSSettlementUploaded
7182 
    self._processMap["getEBSSettlementDate"] = Processor.process_getEBSSettlementDate
4715 varun.gupt 7183 
    self._processMap["getSettlementsByDate"] = Processor.process_getSettlementsByDate
7184 
    self._processMap["getReshippedOrderIds"] = Processor.process_getReshippedOrderIds
5481 phani.kuma 7185 
    self._processMap["getBilledOrders"] = Processor.process_getBilledOrders
5031 varun.gupt 7186 
    self._processMap["getStatusDistributionOfOrders"] = Processor.process_getStatusDistributionOfOrders
5067 varun.gupt 7187 
    self._processMap["getOrderIdsForStatus"] = Processor.process_getOrderIdsForStatus
5348 anupam.sin 7188 
    self._processMap["updateCODAgent"] = Processor.process_updateCODAgent
5099 varun.gupt 7189 
    self._processMap["updateOrderAsPaidToVendor"] = Processor.process_updateOrderAsPaidToVendor
5386 phani.kuma 7190 
    self._processMap["updateOrderOnlyAsPaidToVendor"] = Processor.process_updateOrderOnlyAsPaidToVendor
5208 varun.gupt 7191 
    self._processMap["getRefundedOrdersMarkedPaid"] = Processor.process_getRefundedOrdersMarkedPaid
5447 anupam.sin 7192 
    self._processMap["getAllVerificationAgents"] = Processor.process_getAllVerificationAgents
5527 anupam.sin 7193 
    self._processMap["getAllAttributesForOrderId"] = Processor.process_getAllAttributesForOrderId
5676 rajveer 7194 
    self._processMap["setOrderAttributes"] = Processor.process_setOrderAttributes
5527 anupam.sin 7195 
    self._processMap["setOrderAttributeForTransaction"] = Processor.process_setOrderAttributeForTransaction
5553 rajveer 7196 
    self._processMap["getReceivePendingOrders"] = Processor.process_getReceivePendingOrders
7197 
    self._processMap["getReceivedAtStoreOrders"] = Processor.process_getReceivedAtStoreOrders
5713 rajveer 7198 
    self._processMap["getOrdersCollectionAtStore"] = Processor.process_getOrdersCollectionAtStore
5833 rajveer 7199 
    self._processMap["getOrderAttributeValue"] = Processor.process_getOrderAttributeValue
6019 rajveer 7200 
    self._processMap["changeJacketNumber"] = Processor.process_changeJacketNumber
7201 
    self._processMap["markOrderAsRtoInTransit"] = Processor.process_markOrderAsRtoInTransit
5593 mandeep.dh 7202 
    self._processMap["acceptOrderForItem"] = Processor.process_acceptOrderForItem
6000 mandeep.dh 7203 
    self._processMap["createRechargeOrder"] = Processor.process_createRechargeOrder
6031 rajveer 7204 
    self._processMap["getRechargeOrder"] = Processor.process_getRechargeOrder
7205 
    self._processMap["getRechargeOrders"] = Processor.process_getRechargeOrders
6000 mandeep.dh 7206 
    self._processMap["updateRechargeOrderStatus"] = Processor.process_updateRechargeOrderStatus
7207 
    self._processMap["activateRechargeTxn"] = Processor.process_activateRechargeTxn
6031 rajveer 7208 
    self._processMap["getUserWallet"] = Processor.process_getUserWallet
7209 
    self._processMap["getUserWalletHistory"] = Processor.process_getUserWalletHistory
6050 anupam.sin 7210 
    self._processMap["getRechargeOrdersForTransaction"] = Processor.process_getRechargeOrdersForTransaction
6048 rajveer 7211 
    self._processMap["getServiceProviders"] = Processor.process_getServiceProviders
7212 
    self._processMap["getServiceProviderForDevice"] = Processor.process_getServiceProviderForDevice
6269 rajveer 7213 
    self._processMap["validateRecharge"] = Processor.process_validateRecharge
6094 rajveer 7214 
    self._processMap["getRechargeOrdersForDevice"] = Processor.process_getRechargeOrdersForDevice
7215 
    self._processMap["addAmountToWallet"] = Processor.process_addAmountToWallet
6188 rajveer 7216 
    self._processMap["getRechargeStatistics"] = Processor.process_getRechargeStatistics
6154 rajveer 7217 
    self._processMap["getRechargeOrdersForStatus"] = Processor.process_getRechargeOrdersForStatus
6159 rajveer 7218 
    self._processMap["getPlansForOperator"] = Processor.process_getPlansForOperator
6289 anupam.sin 7219 
    self._processMap["getRechargeDenominations"] = Processor.process_getRechargeDenominations
6371 rajveer 7220 
    self._processMap["updateAvailabilityStatus"] = Processor.process_updateAvailabilityStatus
6389 rajveer 7221 
    self._processMap["getAvailableEmiSchemes"] = Processor.process_getAvailableEmiSchemes
7222 
    self._processMap["getMiscCharges"] = Processor.process_getMiscCharges
6507 anupam.sin 7223 
    self._processMap["refundRechargeOrder"] = Processor.process_refundRechargeOrder
6821 amar.kumar 7224 
    self._processMap["getPhysicalOrders"] = Processor.process_getPhysicalOrders
6906 rajveer 7225 
    self._processMap["getDocument"] = Processor.process_getDocument
6985 anupam.sin 7226 
    self._processMap["changeShippingAddress"] = Processor.process_changeShippingAddress
6988 rajveer 7227 
    self._processMap["retrieveInvoice"] = Processor.process_retrieveInvoice
7026 rajveer 7228 
    self._processMap["receiveUpdatesForRedExpress"] = Processor.process_receiveUpdatesForRedExpress
7073 anupam.sin 7229 
    self._processMap["createRechargeTransaction"] = Processor.process_createRechargeTransaction
7085 rajveer 7230 
    self._processMap["getRechargeTransactions"] = Processor.process_getRechargeTransactions
7151 amit.gupta 7231 
    self._processMap["getRechargeTrans"] = Processor.process_getRechargeTrans
7080 anupam.sin 7232 
    self._processMap["getRechargeTransaction"] = Processor.process_getRechargeTransaction
7233 
    self._processMap["getFRCs"] = Processor.process_getFRCs
7096 anupam.sin 7234 
    self._processMap["getHotspotStore"] = Processor.process_getHotspotStore
7235 
    self._processMap["getTelecomCircle"] = Processor.process_getTelecomCircle
7109 anupam.sin 7236 
    self._processMap["retrieveHotspotRechargeInvoice"] = Processor.process_retrieveHotspotRechargeInvoice
94 ashish 7237 
 
7238 
  def process(self, iprot, oprot):
7239 
    (name, type, seqid) = iprot.readMessageBegin()
7240 
    if name not in self._processMap:
7241 
      iprot.skip(TType.STRUCT)
7242 
      iprot.readMessageEnd()
7243 
      x = TApplicationException(TApplicationException.UNKNOWN_METHOD, 'Unknown function %s' % (name))
7244 
      oprot.writeMessageBegin(name, TMessageType.EXCEPTION, seqid)
7245 
      x.write(oprot)
7246 
      oprot.writeMessageEnd()
7247 
      oprot.trans.flush()
7248 
      return
7249 
    else:
7250 
      self._processMap[name](self, seqid, iprot, oprot)
7251 
    return True
7252 
 
7253 
  def process_createTransaction(self, seqid, iprot, oprot):
7254 
    args = createTransaction_args()
7255 
    args.read(iprot)
7256 
    iprot.readMessageEnd()
7257 
    result = createTransaction_result()
7258 
    try:
132 ashish 7259 
      result.success = self._handler.createTransaction(args.transaction)
94 ashish 7260 
    except TransactionServiceException, ex:
7261 
      result.ex = ex
7262 
    oprot.writeMessageBegin("createTransaction", TMessageType.REPLY, seqid)
7263 
    result.write(oprot)
7264 
    oprot.writeMessageEnd()
7265 
    oprot.trans.flush()
7266 
 
7267 
  def process_getTransaction(self, seqid, iprot, oprot):
7268 
    args = getTransaction_args()
7269 
    args.read(iprot)
7270 
    iprot.readMessageEnd()
7271 
    result = getTransaction_result()
7272 
    try:
7273 
      result.success = self._handler.getTransaction(args.id)
7274 
    except TransactionServiceException, ex:
7275 
      result.ex = ex
7276 
    oprot.writeMessageBegin("getTransaction", TMessageType.REPLY, seqid)
7277 
    result.write(oprot)
7278 
    oprot.writeMessageEnd()
7279 
    oprot.trans.flush()
7280 
 
7281 
  def process_getTransactionsForCustomer(self, seqid, iprot, oprot):
7282 
    args = getTransactionsForCustomer_args()
7283 
    args.read(iprot)
7284 
    iprot.readMessageEnd()
7285 
    result = getTransactionsForCustomer_result()
7286 
    try:
7287 
      result.success = self._handler.getTransactionsForCustomer(args.customerId, args.from_date, args.to_date, args.status)
7288 
    except TransactionServiceException, ex:
7289 
      result.ex = ex
7290 
    oprot.writeMessageBegin("getTransactionsForCustomer", TMessageType.REPLY, seqid)
7291 
    result.write(oprot)
7292 
    oprot.writeMessageEnd()
7293 
    oprot.trans.flush()
7294 
 
132 ashish 7295 
  def process_getTransactionsForShoppingCartId(self, seqid, iprot, oprot):
7296 
    args = getTransactionsForShoppingCartId_args()
7297 
    args.read(iprot)
7298 
    iprot.readMessageEnd()
7299 
    result = getTransactionsForShoppingCartId_result()
7300 
    try:
7301 
      result.success = self._handler.getTransactionsForShoppingCartId(args.shoppingCartId)
7302 
    except TransactionServiceException, ex:
7303 
      result.ex = ex
7304 
    oprot.writeMessageBegin("getTransactionsForShoppingCartId", TMessageType.REPLY, seqid)
7305 
    result.write(oprot)
7306 
    oprot.writeMessageEnd()
7307 
    oprot.trans.flush()
7308 
 
94 ashish 7309 
  def process_getTransactionStatus(self, seqid, iprot, oprot):
7310 
    args = getTransactionStatus_args()
7311 
    args.read(iprot)
7312 
    iprot.readMessageEnd()
7313 
    result = getTransactionStatus_result()
7314 
    try:
7315 
      result.success = self._handler.getTransactionStatus(args.transactionId)
7316 
    except TransactionServiceException, ex:
7317 
      result.ex = ex
7318 
    oprot.writeMessageBegin("getTransactionStatus", TMessageType.REPLY, seqid)
7319 
    result.write(oprot)
7320 
    oprot.writeMessageEnd()
7321 
    oprot.trans.flush()
7322 
 
7323 
  def process_changeTransactionStatus(self, seqid, iprot, oprot):
7324 
    args = changeTransactionStatus_args()
7325 
    args.read(iprot)
7326 
    iprot.readMessageEnd()
7327 
    result = changeTransactionStatus_result()
7328 
    try:
5527 anupam.sin 7329 
      result.success = self._handler.changeTransactionStatus(args.transactionId, args.status, args.description, args.pickUp, args.orderType)
94 ashish 7330 
    except TransactionServiceException, ex:
7331 
      result.ex = ex
7332 
    oprot.writeMessageBegin("changeTransactionStatus", TMessageType.REPLY, seqid)
7333 
    result.write(oprot)
7334 
    oprot.writeMessageEnd()
7335 
    oprot.trans.flush()
7336 
 
1398 varun.gupt 7337 
  def process_enqueueTransactionInfoEmail(self, seqid, iprot, oprot):
7338 
    args = enqueueTransactionInfoEmail_args()
1382 varun.gupt 7339 
    args.read(iprot)
7340 
    iprot.readMessageEnd()
1398 varun.gupt 7341 
    result = enqueueTransactionInfoEmail_result()
1382 varun.gupt 7342 
    try:
1398 varun.gupt 7343 
      result.success = self._handler.enqueueTransactionInfoEmail(args.transactionId)
1382 varun.gupt 7344 
    except TransactionServiceException, ex:
7345 
      result.ex = ex
1398 varun.gupt 7346 
    oprot.writeMessageBegin("enqueueTransactionInfoEmail", TMessageType.REPLY, seqid)
1382 varun.gupt 7347 
    result.write(oprot)
7348 
    oprot.writeMessageEnd()
7349 
    oprot.trans.flush()
7350 
 
483 rajveer 7351 
  def process_getAllOrders(self, seqid, iprot, oprot):
7352 
    args = getAllOrders_args()
94 ashish 7353 
    args.read(iprot)
7354 
    iprot.readMessageEnd()
483 rajveer 7355 
    result = getAllOrders_result()
94 ashish 7356 
    try:
4801 anupam.sin 7357 
      result.success = self._handler.getAllOrders(args.statuses, args.from_date, args.to_date, args.warehouse_id)
94 ashish 7358 
    except TransactionServiceException, ex:
7359 
      result.ex = ex
483 rajveer 7360 
    oprot.writeMessageBegin("getAllOrders", TMessageType.REPLY, seqid)
94 ashish 7361 
    result.write(oprot)
7362 
    oprot.writeMessageEnd()
7363 
    oprot.trans.flush()
7364 
 
4133 chandransh 7365 
  def process_getOrdersInBatch(self, seqid, iprot, oprot):
7366 
    args = getOrdersInBatch_args()
7367 
    args.read(iprot)
7368 
    iprot.readMessageEnd()
7369 
    result = getOrdersInBatch_result()
7370 
    try:
7371 
      result.success = self._handler.getOrdersInBatch(args.statuses, args.offset, args.limit, args.warehouse_id)
7372 
    except TransactionServiceException, ex:
7373 
      result.ex = ex
7374 
    oprot.writeMessageBegin("getOrdersInBatch", TMessageType.REPLY, seqid)
7375 
    result.write(oprot)
7376 
    oprot.writeMessageEnd()
7377 
    oprot.trans.flush()
7378 
 
7379 
  def process_getOrderCount(self, seqid, iprot, oprot):
7380 
    args = getOrderCount_args()
7381 
    args.read(iprot)
7382 
    iprot.readMessageEnd()
7383 
    result = getOrderCount_result()
7384 
    try:
7385 
      result.success = self._handler.getOrderCount(args.statuses, args.warehouseId)
7386 
    except TransactionServiceException, ex:
7387 
      result.ex = ex
7388 
    oprot.writeMessageBegin("getOrderCount", TMessageType.REPLY, seqid)
7389 
    result.write(oprot)
7390 
    oprot.writeMessageEnd()
7391 
    oprot.trans.flush()
7392 
 
999 varun.gupt 7393 
  def process_getOrdersByBillingDate(self, seqid, iprot, oprot):
7394 
    args = getOrdersByBillingDate_args()
7395 
    args.read(iprot)
7396 
    iprot.readMessageEnd()
7397 
    result = getOrdersByBillingDate_result()
7398 
    try:
7399 
      result.success = self._handler.getOrdersByBillingDate(args.status, args.start_billing_date, args.end_billing_date, args.warehouse_id)
7400 
    except TransactionServiceException, ex:
7401 
      result.ex = ex
7402 
    oprot.writeMessageBegin("getOrdersByBillingDate", TMessageType.REPLY, seqid)
7403 
    result.write(oprot)
7404 
    oprot.writeMessageEnd()
7405 
    oprot.trans.flush()
7406 
 
3427 chandransh 7407 
  def process_getOrdersByShippingDate(self, seqid, iprot, oprot):
7408 
    args = getOrdersByShippingDate_args()
7409 
    args.read(iprot)
7410 
    iprot.readMessageEnd()
7411 
    result = getOrdersByShippingDate_result()
7412 
    try:
3451 chandransh 7413 
      result.success = self._handler.getOrdersByShippingDate(args.fromShippingDate, args.toShippingDate, args.providerId, args.warehouseId, args.cod)
3427 chandransh 7414 
    except TransactionServiceException, ex:
7415 
      result.ex = ex
7416 
    oprot.writeMessageBegin("getOrdersByShippingDate", TMessageType.REPLY, seqid)
7417 
    result.write(oprot)
7418 
    oprot.writeMessageEnd()
7419 
    oprot.trans.flush()
7420 
 
1382 varun.gupt 7421 
  def process_getReturnableOrdersForCustomer(self, seqid, iprot, oprot):
7422 
    args = getReturnableOrdersForCustomer_args()
7423 
    args.read(iprot)
7424 
    iprot.readMessageEnd()
7425 
    result = getReturnableOrdersForCustomer_result()
7426 
    try:
7427 
      result.success = self._handler.getReturnableOrdersForCustomer(args.customer_id, args.limit)
7428 
    except TransactionServiceException, ex:
7429 
      result.ex = ex
7430 
    oprot.writeMessageBegin("getReturnableOrdersForCustomer", TMessageType.REPLY, seqid)
7431 
    result.write(oprot)
7432 
    oprot.writeMessageEnd()
7433 
    oprot.trans.flush()
7434 
 
7435 
  def process_getCancellableOrdersForCustomer(self, seqid, iprot, oprot):
7436 
    args = getCancellableOrdersForCustomer_args()
7437 
    args.read(iprot)
7438 
    iprot.readMessageEnd()
7439 
    result = getCancellableOrdersForCustomer_result()
7440 
    try:
7441 
      result.success = self._handler.getCancellableOrdersForCustomer(args.customer_id, args.limit)
7442 
    except TransactionServiceException, ex:
7443 
      result.ex = ex
7444 
    oprot.writeMessageBegin("getCancellableOrdersForCustomer", TMessageType.REPLY, seqid)
7445 
    result.write(oprot)
7446 
    oprot.writeMessageEnd()
7447 
    oprot.trans.flush()
7448 
 
483 rajveer 7449 
  def process_changeOrderStatus(self, seqid, iprot, oprot):
7450 
    args = changeOrderStatus_args()
94 ashish 7451 
    args.read(iprot)
7452 
    iprot.readMessageEnd()
483 rajveer 7453 
    result = changeOrderStatus_result()
94 ashish 7454 
    try:
483 rajveer 7455 
      result.success = self._handler.changeOrderStatus(args.orderId, args.status, args.description)
94 ashish 7456 
    except TransactionServiceException, ex:
7457 
      result.ex = ex
483 rajveer 7458 
    oprot.writeMessageBegin("changeOrderStatus", TMessageType.REPLY, seqid)
94 ashish 7459 
    result.write(oprot)
7460 
    oprot.writeMessageEnd()
7461 
    oprot.trans.flush()
7462 
 
483 rajveer 7463 
  def process_getOrdersForTransaction(self, seqid, iprot, oprot):
7464 
    args = getOrdersForTransaction_args()
94 ashish 7465 
    args.read(iprot)
7466 
    iprot.readMessageEnd()
483 rajveer 7467 
    result = getOrdersForTransaction_result()
94 ashish 7468 
    try:
1528 ankur.sing 7469 
      result.success = self._handler.getOrdersForTransaction(args.transactionId, args.customerId)
94 ashish 7470 
    except TransactionServiceException, ex:
7471 
      result.ex = ex
483 rajveer 7472 
    oprot.writeMessageBegin("getOrdersForTransaction", TMessageType.REPLY, seqid)
94 ashish 7473 
    result.write(oprot)
7474 
    oprot.writeMessageEnd()
7475 
    oprot.trans.flush()
7476 
 
483 rajveer 7477 
  def process_getOrdersForCustomer(self, seqid, iprot, oprot):
7478 
    args = getOrdersForCustomer_args()
94 ashish 7479 
    args.read(iprot)
7480 
    iprot.readMessageEnd()
483 rajveer 7481 
    result = getOrdersForCustomer_result()
94 ashish 7482 
    try:
3014 chandransh 7483 
      result.success = self._handler.getOrdersForCustomer(args.customerId, args.from_date, args.to_date, args.statuses)
94 ashish 7484 
    except TransactionServiceException, ex:
7485 
      result.ex = ex
483 rajveer 7486 
    oprot.writeMessageBegin("getOrdersForCustomer", TMessageType.REPLY, seqid)
94 ashish 7487 
    result.write(oprot)
7488 
    oprot.writeMessageEnd()
7489 
    oprot.trans.flush()
7490 
 
483 rajveer 7491 
  def process_createOrder(self, seqid, iprot, oprot):
7492 
    args = createOrder_args()
94 ashish 7493 
    args.read(iprot)
7494 
    iprot.readMessageEnd()
483 rajveer 7495 
    result = createOrder_result()
94 ashish 7496 
    try:
483 rajveer 7497 
      result.success = self._handler.createOrder(args.order)
94 ashish 7498 
    except TransactionServiceException, ex:
7499 
      result.ex = ex
483 rajveer 7500 
    oprot.writeMessageBegin("createOrder", TMessageType.REPLY, seqid)
94 ashish 7501 
    result.write(oprot)
7502 
    oprot.writeMessageEnd()
7503 
    oprot.trans.flush()
7504 
 
483 rajveer 7505 
  def process_getOrder(self, seqid, iprot, oprot):
7506 
    args = getOrder_args()
94 ashish 7507 
    args.read(iprot)
7508 
    iprot.readMessageEnd()
483 rajveer 7509 
    result = getOrder_result()
94 ashish 7510 
    try:
483 rajveer 7511 
      result.success = self._handler.getOrder(args.id)
94 ashish 7512 
    except TransactionServiceException, ex:
7513 
      result.ex = ex
483 rajveer 7514 
    oprot.writeMessageBegin("getOrder", TMessageType.REPLY, seqid)
94 ashish 7515 
    result.write(oprot)
7516 
    oprot.writeMessageEnd()
7517 
    oprot.trans.flush()
7518 
 
483 rajveer 7519 
  def process_getLineItemsForOrder(self, seqid, iprot, oprot):
7520 
    args = getLineItemsForOrder_args()
94 ashish 7521 
    args.read(iprot)
7522 
    iprot.readMessageEnd()
483 rajveer 7523 
    result = getLineItemsForOrder_result()
94 ashish 7524 
    try:
483 rajveer 7525 
      result.success = self._handler.getLineItemsForOrder(args.orderId)
94 ashish 7526 
    except TransactionServiceException, ex:
7527 
      result.ex = ex
483 rajveer 7528 
    oprot.writeMessageBegin("getLineItemsForOrder", TMessageType.REPLY, seqid)
94 ashish 7529 
    result.write(oprot)
7530 
    oprot.writeMessageEnd()
7531 
    oprot.trans.flush()
7532 
 
4999 phani.kuma 7533 
  def process_getOrderList(self, seqid, iprot, oprot):
7534 
    args = getOrderList_args()
7535 
    args.read(iprot)
7536 
    iprot.readMessageEnd()
7537 
    result = getOrderList_result()
7538 
    result.success = self._handler.getOrderList(args.order_ids)
7539 
    oprot.writeMessageBegin("getOrderList", TMessageType.REPLY, seqid)
7540 
    result.write(oprot)
7541 
    oprot.writeMessageEnd()
7542 
    oprot.trans.flush()
7543 
 
5386 phani.kuma 7544 
  def process_getOrderListForVendor(self, seqid, iprot, oprot):
7545 
    args = getOrderListForVendor_args()
7546 
    args.read(iprot)
7547 
    iprot.readMessageEnd()
7548 
    result = getOrderListForVendor_result()
7549 
    result.success = self._handler.getOrderListForVendor(args.order_ids, args.vendorId)
7550 
    oprot.writeMessageBegin("getOrderListForVendor", TMessageType.REPLY, seqid)
7551 
    result.write(oprot)
7552 
    oprot.writeMessageEnd()
7553 
    oprot.trans.flush()
7554 
 
1528 ankur.sing 7555 
  def process_getOrderForCustomer(self, seqid, iprot, oprot):
7556 
    args = getOrderForCustomer_args()
7557 
    args.read(iprot)
7558 
    iprot.readMessageEnd()
7559 
    result = getOrderForCustomer_result()
7560 
    try:
7561 
      result.success = self._handler.getOrderForCustomer(args.orderId, args.customerId)
7562 
    except TransactionServiceException, ex:
7563 
      result.ex = ex
7564 
    oprot.writeMessageBegin("getOrderForCustomer", TMessageType.REPLY, seqid)
7565 
    result.write(oprot)
7566 
    oprot.writeMessageEnd()
7567 
    oprot.trans.flush()
7568 
 
3064 chandransh 7569 
  def process_getAlerts(self, seqid, iprot, oprot):
7570 
    args = getAlerts_args()
7571 
    args.read(iprot)
7572 
    iprot.readMessageEnd()
7573 
    result = getAlerts_result()
4444 rajveer 7574 
    result.success = self._handler.getAlerts(args.type, args.warehouseId, args.status, args.timestamp)
3064 chandransh 7575 
    oprot.writeMessageBegin("getAlerts", TMessageType.REPLY, seqid)
7576 
    result.write(oprot)
7577 
    oprot.writeMessageEnd()
7578 
    oprot.trans.flush()
7579 
 
4394 rajveer 7580 
  def process_addAlert(self, seqid, iprot, oprot):
7581 
    args = addAlert_args()
3064 chandransh 7582 
    args.read(iprot)
7583 
    iprot.readMessageEnd()
4394 rajveer 7584 
    result = addAlert_result()
4444 rajveer 7585 
    self._handler.addAlert(args.type, args.warehouseId, args.description)
4394 rajveer 7586 
    oprot.writeMessageBegin("addAlert", TMessageType.REPLY, seqid)
3064 chandransh 7587 
    result.write(oprot)
7588 
    oprot.writeMessageEnd()
7589 
    oprot.trans.flush()
7590 
 
4444 rajveer 7591 
  def process_markAlertsAsSeen(self, seqid, iprot, oprot):
7592 
    args = markAlertsAsSeen_args()
7593 
    args.read(iprot)
7594 
    iprot.readMessageEnd()
7595 
    result = markAlertsAsSeen_result()
7596 
    self._handler.markAlertsAsSeen(args.warehouseId)
7597 
    oprot.writeMessageBegin("markAlertsAsSeen", TMessageType.REPLY, seqid)
7598 
    result.write(oprot)
7599 
    oprot.writeMessageEnd()
7600 
    oprot.trans.flush()
7601 
 
3064 chandransh 7602 
  def process_getValidOrderCount(self, seqid, iprot, oprot):
7603 
    args = getValidOrderCount_args()
7604 
    args.read(iprot)
7605 
    iprot.readMessageEnd()
7606 
    result = getValidOrderCount_result()
7607 
    result.success = self._handler.getValidOrderCount()
7608 
    oprot.writeMessageBegin("getValidOrderCount", TMessageType.REPLY, seqid)
7609 
    result.write(oprot)
7610 
    oprot.writeMessageEnd()
7611 
    oprot.trans.flush()
7612 
 
7613 
  def process_getNoOfCustomersWithSuccessfulTransaction(self, seqid, iprot, oprot):
7614 
    args = getNoOfCustomersWithSuccessfulTransaction_args()
7615 
    args.read(iprot)
7616 
    iprot.readMessageEnd()
7617 
    result = getNoOfCustomersWithSuccessfulTransaction_result()
7618 
    result.success = self._handler.getNoOfCustomersWithSuccessfulTransaction()
7619 
    oprot.writeMessageBegin("getNoOfCustomersWithSuccessfulTransaction", TMessageType.REPLY, seqid)
7620 
    result.write(oprot)
7621 
    oprot.writeMessageEnd()
7622 
    oprot.trans.flush()
7623 
 
7624 
  def process_getValidOrdersAmountRange(self, seqid, iprot, oprot):
7625 
    args = getValidOrdersAmountRange_args()
7626 
    args.read(iprot)
7627 
    iprot.readMessageEnd()
7628 
    result = getValidOrdersAmountRange_result()
7629 
    result.success = self._handler.getValidOrdersAmountRange()
7630 
    oprot.writeMessageBegin("getValidOrdersAmountRange", TMessageType.REPLY, seqid)
7631 
    result.write(oprot)
7632 
    oprot.writeMessageEnd()
7633 
    oprot.trans.flush()
7634 
 
7635 
  def process_getValidOrders(self, seqid, iprot, oprot):
7636 
    args = getValidOrders_args()
7637 
    args.read(iprot)
7638 
    iprot.readMessageEnd()
7639 
    result = getValidOrders_result()
5874 rajveer 7640 
    result.success = self._handler.getValidOrders(args.limit, args.onlyStore)
3064 chandransh 7641 
    oprot.writeMessageBegin("getValidOrders", TMessageType.REPLY, seqid)
7642 
    result.write(oprot)
7643 
    oprot.writeMessageEnd()
7644 
    oprot.trans.flush()
7645 
 
1220 chandransh 7646 
  def process_batchOrders(self, seqid, iprot, oprot):
7647 
    args = batchOrders_args()
7648 
    args.read(iprot)
7649 
    iprot.readMessageEnd()
7650 
    result = batchOrders_result()
7651 
    try:
7652 
      result.success = self._handler.batchOrders(args.warehouseId)
7653 
    except TransactionServiceException, ex:
7654 
      result.ex = ex
7655 
    oprot.writeMessageBegin("batchOrders", TMessageType.REPLY, seqid)
7656 
    result.write(oprot)
7657 
    oprot.writeMessageEnd()
7658 
    oprot.trans.flush()
7659 
 
1208 chandransh 7660 
  def process_markOrderAsOutOfStock(self, seqid, iprot, oprot):
7661 
    args = markOrderAsOutOfStock_args()
7662 
    args.read(iprot)
7663 
    iprot.readMessageEnd()
7664 
    result = markOrderAsOutOfStock_result()
7665 
    try:
7666 
      result.success = self._handler.markOrderAsOutOfStock(args.orderId)
7667 
    except TransactionServiceException, ex:
7668 
      result.ex = ex
7669 
    oprot.writeMessageBegin("markOrderAsOutOfStock", TMessageType.REPLY, seqid)
7670 
    result.write(oprot)
7671 
    oprot.writeMessageEnd()
7672 
    oprot.trans.flush()
7673 
 
3064 chandransh 7674 
  def process_verifyOrder(self, seqid, iprot, oprot):
7675 
    args = verifyOrder_args()
759 chandransh 7676 
    args.read(iprot)
7677 
    iprot.readMessageEnd()
3064 chandransh 7678 
    result = verifyOrder_result()
759 chandransh 7679 
    try:
3064 chandransh 7680 
      result.success = self._handler.verifyOrder(args.orderId)
759 chandransh 7681 
    except TransactionServiceException, ex:
7682 
      result.ex = ex
3064 chandransh 7683 
    oprot.writeMessageBegin("verifyOrder", TMessageType.REPLY, seqid)
759 chandransh 7684 
    result.write(oprot)
7685 
    oprot.writeMessageEnd()
7686 
    oprot.trans.flush()
7687 
 
3064 chandransh 7688 
  def process_acceptOrder(self, seqid, iprot, oprot):
7689 
    args = acceptOrder_args()
1113 chandransh 7690 
    args.read(iprot)
7691 
    iprot.readMessageEnd()
3064 chandransh 7692 
    result = acceptOrder_result()
1113 chandransh 7693 
    try:
3064 chandransh 7694 
      result.success = self._handler.acceptOrder(args.orderId)
1113 chandransh 7695 
    except TransactionServiceException, ex:
7696 
      result.ex = ex
3064 chandransh 7697 
    oprot.writeMessageBegin("acceptOrder", TMessageType.REPLY, seqid)
1113 chandransh 7698 
    result.write(oprot)
7699 
    oprot.writeMessageEnd()
7700 
    oprot.trans.flush()
7701 
 
3064 chandransh 7702 
  def process_addBillingDetails(self, seqid, iprot, oprot):
7703 
    args = addBillingDetails_args()
1135 chandransh 7704 
    args.read(iprot)
7705 
    iprot.readMessageEnd()
3064 chandransh 7706 
    result = addBillingDetails_result()
1135 chandransh 7707 
    try:
5110 mandeep.dh 7708 
      result.success = self._handler.addBillingDetails(args.orderId, args.invoice_number, args.serialNumber, args.itemNumber, args.billed_by, args.jacketNumber, args.billingType, args.fulfilmentWarehouseId, args.authorize)
1135 chandransh 7709 
    except TransactionServiceException, ex:
7710 
      result.ex = ex
3064 chandransh 7711 
    oprot.writeMessageBegin("addBillingDetails", TMessageType.REPLY, seqid)
1135 chandransh 7712 
    result.write(oprot)
7713 
    oprot.writeMessageEnd()
7714 
    oprot.trans.flush()
7715 
 
4579 rajveer 7716 
  def process_addInvoiceNumber(self, seqid, iprot, oprot):
7717 
    args = addInvoiceNumber_args()
7718 
    args.read(iprot)
7719 
    iprot.readMessageEnd()
7720 
    result = addInvoiceNumber_result()
7721 
    try:
6756 amar.kumar 7722 
      self._handler.addInvoiceNumber(args.orderId, args.invoiceNumber, args.color, args.serialNumber, args.itemNumber)
4579 rajveer 7723 
    except TransactionServiceException, ex:
7724 
      result.ex = ex
7725 
    oprot.writeMessageBegin("addInvoiceNumber", TMessageType.REPLY, seqid)
7726 
    result.write(oprot)
7727 
    oprot.writeMessageEnd()
7728 
    oprot.trans.flush()
7729 
 
4410 rajveer 7730 
  def process_markOrdersAsShippedFromWarehouse(self, seqid, iprot, oprot):
7731 
    args = markOrdersAsShippedFromWarehouse_args()
7732 
    args.read(iprot)
7733 
    iprot.readMessageEnd()
7734 
    result = markOrdersAsShippedFromWarehouse_result()
7735 
    try:
4789 rajveer 7736 
      result.success = self._handler.markOrdersAsShippedFromWarehouse(args.warehouseId, args.providerId, args.cod, args.orderIds)
4410 rajveer 7737 
    except TransactionServiceException, ex:
7738 
      result.ex = ex
7739 
    oprot.writeMessageBegin("markOrdersAsShippedFromWarehouse", TMessageType.REPLY, seqid)
7740 
    result.write(oprot)
7741 
    oprot.writeMessageEnd()
7742 
    oprot.trans.flush()
7743 
 
5676 rajveer 7744 
  def process_markOrdersAsReturnedFromStore(self, seqid, iprot, oprot):
7745 
    args = markOrdersAsReturnedFromStore_args()
7746 
    args.read(iprot)
7747 
    iprot.readMessageEnd()
7748 
    result = markOrdersAsReturnedFromStore_result()
7749 
    try:
5713 rajveer 7750 
      result.success = self._handler.markOrdersAsReturnedFromStore(args.providerId, args.orderIds, args.awbs)
5676 rajveer 7751 
    except TransactionServiceException, ex:
7752 
      result.ex = ex
7753 
    oprot.writeMessageBegin("markOrdersAsReturnedFromStore", TMessageType.REPLY, seqid)
7754 
    result.write(oprot)
7755 
    oprot.writeMessageEnd()
7756 
    oprot.trans.flush()
7757 
 
3064 chandransh 7758 
  def process_markOrdersAsPickedUp(self, seqid, iprot, oprot):
7759 
    args = markOrdersAsPickedUp_args()
304 ashish 7760 
    args.read(iprot)
7761 
    iprot.readMessageEnd()
3064 chandransh 7762 
    result = markOrdersAsPickedUp_result()
7763 
    try:
4910 phani.kuma 7764 
      self._handler.markOrdersAsPickedUp(args.providerId, args.pickupDetails)
3064 chandransh 7765 
    except TransactionServiceException, ex:
7766 
      result.ex = ex
7767 
    oprot.writeMessageBegin("markOrdersAsPickedUp", TMessageType.REPLY, seqid)
304 ashish 7768 
    result.write(oprot)
7769 
    oprot.writeMessageEnd()
7770 
    oprot.trans.flush()
94 ashish 7771 
 
4910 phani.kuma 7772 
  def process_getOrdersNotPickedUp(self, seqid, iprot, oprot):
7773 
    args = getOrdersNotPickedUp_args()
7774 
    args.read(iprot)
7775 
    iprot.readMessageEnd()
7776 
    result = getOrdersNotPickedUp_result()
7777 
    result.success = self._handler.getOrdersNotPickedUp(args.providerId)
7778 
    oprot.writeMessageBegin("getOrdersNotPickedUp", TMessageType.REPLY, seqid)
7779 
    result.write(oprot)
7780 
    oprot.writeMessageEnd()
7781 
    oprot.trans.flush()
7782 
 
3064 chandransh 7783 
  def process_markOrdersAsDelivered(self, seqid, iprot, oprot):
7784 
    args = markOrdersAsDelivered_args()
304 ashish 7785 
    args.read(iprot)
7786 
    iprot.readMessageEnd()
3064 chandransh 7787 
    result = markOrdersAsDelivered_result()
7788 
    try:
7789 
      self._handler.markOrdersAsDelivered(args.providerId, args.deliveredOrders)
7790 
    except TransactionServiceException, ex:
7791 
      result.ex = ex
7792 
    oprot.writeMessageBegin("markOrdersAsDelivered", TMessageType.REPLY, seqid)
304 ashish 7793 
    result.write(oprot)
7794 
    oprot.writeMessageEnd()
7795 
    oprot.trans.flush()
7796 
 
4910 phani.kuma 7797 
  def process_markAsRTOrders(self, seqid, iprot, oprot):
7798 
    args = markAsRTOrders_args()
1596 ankur.sing 7799 
    args.read(iprot)
7800 
    iprot.readMessageEnd()
4910 phani.kuma 7801 
    result = markAsRTOrders_result()
3064 chandransh 7802 
    try:
4910 phani.kuma 7803 
      self._handler.markAsRTOrders(args.providerId, args.returnedOrders)
3064 chandransh 7804 
    except TransactionServiceException, ex:
7805 
      result.ex = ex
4910 phani.kuma 7806 
    oprot.writeMessageBegin("markAsRTOrders", TMessageType.REPLY, seqid)
1596 ankur.sing 7807 
    result.write(oprot)
7808 
    oprot.writeMessageEnd()
7809 
    oprot.trans.flush()
304 ashish 7810 
 
4910 phani.kuma 7811 
  def process_getRTOrders(self, seqid, iprot, oprot):
7812 
    args = getRTOrders_args()
7813 
    args.read(iprot)
7814 
    iprot.readMessageEnd()
7815 
    result = getRTOrders_result()
7816 
    result.success = self._handler.getRTOrders(args.providerId)
7817 
    oprot.writeMessageBegin("getRTOrders", TMessageType.REPLY, seqid)
7818 
    result.write(oprot)
7819 
    oprot.writeMessageEnd()
7820 
    oprot.trans.flush()
7821 
 
3064 chandransh 7822 
  def process_updateNonDeliveryReason(self, seqid, iprot, oprot):
7823 
    args = updateNonDeliveryReason_args()
1627 ankur.sing 7824 
    args.read(iprot)
7825 
    iprot.readMessageEnd()
3064 chandransh 7826 
    result = updateNonDeliveryReason_result()
7827 
    try:
4910 phani.kuma 7828 
      self._handler.updateNonDeliveryReason(args.providerId, args.undeliveredOrders)
3064 chandransh 7829 
    except TransactionServiceException, ex:
7830 
      result.ex = ex
7831 
    oprot.writeMessageBegin("updateNonDeliveryReason", TMessageType.REPLY, seqid)
1627 ankur.sing 7832 
    result.write(oprot)
7833 
    oprot.writeMessageEnd()
7834 
    oprot.trans.flush()
1596 ankur.sing 7835 
 
4910 phani.kuma 7836 
  def process_getNonDeliveredOrdersbyCourier(self, seqid, iprot, oprot):
7837 
    args = getNonDeliveredOrdersbyCourier_args()
7838 
    args.read(iprot)
7839 
    iprot.readMessageEnd()
7840 
    result = getNonDeliveredOrdersbyCourier_result()
7841 
    result.success = self._handler.getNonDeliveredOrdersbyCourier(args.providerId)
7842 
    oprot.writeMessageBegin("getNonDeliveredOrdersbyCourier", TMessageType.REPLY, seqid)
7843 
    result.write(oprot)
7844 
    oprot.writeMessageEnd()
7845 
    oprot.trans.flush()
7846 
 
7847 
  def process_markOrdersAsLocalConnected(self, seqid, iprot, oprot):
7848 
    args = markOrdersAsLocalConnected_args()
7849 
    args.read(iprot)
7850 
    iprot.readMessageEnd()
7851 
    result = markOrdersAsLocalConnected_result()
7852 
    try:
7853 
      self._handler.markOrdersAsLocalConnected(args.providerId, args.local_connected_orders)
7854 
    except TransactionServiceException, ex:
7855 
      result.ex = ex
7856 
    oprot.writeMessageBegin("markOrdersAsLocalConnected", TMessageType.REPLY, seqid)
7857 
    result.write(oprot)
7858 
    oprot.writeMessageEnd()
7859 
    oprot.trans.flush()
7860 
 
7861 
  def process_getOrdersNotLocalConnected(self, seqid, iprot, oprot):
7862 
    args = getOrdersNotLocalConnected_args()
7863 
    args.read(iprot)
7864 
    iprot.readMessageEnd()
7865 
    result = getOrdersNotLocalConnected_result()
7866 
    result.success = self._handler.getOrdersNotLocalConnected(args.providerId)
7867 
    oprot.writeMessageBegin("getOrdersNotLocalConnected", TMessageType.REPLY, seqid)
7868 
    result.write(oprot)
7869 
    oprot.writeMessageEnd()
7870 
    oprot.trans.flush()
7871 
 
7872 
  def process_markOrdersAsDestinationCityReached(self, seqid, iprot, oprot):
7873 
    args = markOrdersAsDestinationCityReached_args()
7874 
    args.read(iprot)
7875 
    iprot.readMessageEnd()
7876 
    result = markOrdersAsDestinationCityReached_result()
7877 
    try:
7878 
      self._handler.markOrdersAsDestinationCityReached(args.providerId, args.destination_city_reached_orders)
7879 
    except TransactionServiceException, ex:
7880 
      result.ex = ex
7881 
    oprot.writeMessageBegin("markOrdersAsDestinationCityReached", TMessageType.REPLY, seqid)
7882 
    result.write(oprot)
7883 
    oprot.writeMessageEnd()
7884 
    oprot.trans.flush()
7885 
 
7886 
  def process_markOrdersAsFirstDeliveryAttempted(self, seqid, iprot, oprot):
7887 
    args = markOrdersAsFirstDeliveryAttempted_args()
7888 
    args.read(iprot)
7889 
    iprot.readMessageEnd()
7890 
    result = markOrdersAsFirstDeliveryAttempted_result()
7891 
    try:
7892 
      self._handler.markOrdersAsFirstDeliveryAttempted(args.providerId, args.first_atdl_orders)
7893 
    except TransactionServiceException, ex:
7894 
      result.ex = ex
7895 
    oprot.writeMessageBegin("markOrdersAsFirstDeliveryAttempted", TMessageType.REPLY, seqid)
7896 
    result.write(oprot)
7897 
    oprot.writeMessageEnd()
7898 
    oprot.trans.flush()
7899 
 
3064 chandransh 7900 
  def process_getUndeliveredOrders(self, seqid, iprot, oprot):
7901 
    args = getUndeliveredOrders_args()
1627 ankur.sing 7902 
    args.read(iprot)
7903 
    iprot.readMessageEnd()
3064 chandransh 7904 
    result = getUndeliveredOrders_result()
7905 
    result.success = self._handler.getUndeliveredOrders(args.providerId, args.warehouseId)
7906 
    oprot.writeMessageBegin("getUndeliveredOrders", TMessageType.REPLY, seqid)
1627 ankur.sing 7907 
    result.write(oprot)
7908 
    oprot.writeMessageEnd()
7909 
    oprot.trans.flush()
7910 
 
4783 phani.kuma 7911 
  def process_getUndeliveredOrdersExpectedDeliveryDateNotMet(self, seqid, iprot, oprot):
7912 
    args = getUndeliveredOrdersExpectedDeliveryDateNotMet_args()
7913 
    args.read(iprot)
7914 
    iprot.readMessageEnd()
7915 
    result = getUndeliveredOrdersExpectedDeliveryDateNotMet_result()
7916 
    result.success = self._handler.getUndeliveredOrdersExpectedDeliveryDateNotMet()
7917 
    oprot.writeMessageBegin("getUndeliveredOrdersExpectedDeliveryDateNotMet", TMessageType.REPLY, seqid)
7918 
    result.write(oprot)
7919 
    oprot.writeMessageEnd()
7920 
    oprot.trans.flush()
7921 
 
2536 chandransh 7922 
  def process_toggleDOAFlag(self, seqid, iprot, oprot):
7923 
    args = toggleDOAFlag_args()
7924 
    args.read(iprot)
7925 
    iprot.readMessageEnd()
7926 
    result = toggleDOAFlag_result()
7927 
    try:
7928 
      result.success = self._handler.toggleDOAFlag(args.orderId)
7929 
    except TransactionServiceException, ex:
7930 
      result.ex = ex
7931 
    oprot.writeMessageBegin("toggleDOAFlag", TMessageType.REPLY, seqid)
7932 
    result.write(oprot)
7933 
    oprot.writeMessageEnd()
7934 
    oprot.trans.flush()
1886 ankur.sing 7935 
 
4712 rajveer 7936 
  def process_markOrderAsDelivered(self, seqid, iprot, oprot):
7937 
    args = markOrderAsDelivered_args()
7938 
    args.read(iprot)
7939 
    iprot.readMessageEnd()
7940 
    result = markOrderAsDelivered_result()
7941 
    try:
7942 
      self._handler.markOrderAsDelivered(args.orderId, args.deliveryTimestamp, args.receiver)
7943 
    except TransactionServiceException, ex:
7944 
      result.ex = ex
7945 
    oprot.writeMessageBegin("markOrderAsDelivered", TMessageType.REPLY, seqid)
7946 
    result.write(oprot)
7947 
    oprot.writeMessageEnd()
7948 
    oprot.trans.flush()
7949 
 
5553 rajveer 7950 
  def process_markOrderAsReceivedAtStore(self, seqid, iprot, oprot):
7951 
    args = markOrderAsReceivedAtStore_args()
7952 
    args.read(iprot)
7953 
    iprot.readMessageEnd()
7954 
    result = markOrderAsReceivedAtStore_result()
7955 
    try:
7956 
      self._handler.markOrderAsReceivedAtStore(args.orderId, args.deliveryTimestamp)
7957 
    except TransactionServiceException, ex:
7958 
      result.ex = ex
7959 
    oprot.writeMessageBegin("markOrderAsReceivedAtStore", TMessageType.REPLY, seqid)
7960 
    result.write(oprot)
7961 
    oprot.writeMessageEnd()
7962 
    oprot.trans.flush()
7963 
 
4454 rajveer 7964 
  def process_markOrderDoaRequestReceived(self, seqid, iprot, oprot):
7965 
    args = markOrderDoaRequestReceived_args()
7966 
    args.read(iprot)
7967 
    iprot.readMessageEnd()
7968 
    result = markOrderDoaRequestReceived_result()
7969 
    try:
7970 
      result.success = self._handler.markOrderDoaRequestReceived(args.orderId)
7971 
    except TransactionServiceException, ex:
7972 
      result.ex = ex
7973 
    oprot.writeMessageBegin("markOrderDoaRequestReceived", TMessageType.REPLY, seqid)
7974 
    result.write(oprot)
7975 
    oprot.writeMessageEnd()
7976 
    oprot.trans.flush()
7977 
 
7978 
  def process_markOrderDoaRequestAuthorized(self, seqid, iprot, oprot):
7979 
    args = markOrderDoaRequestAuthorized_args()
7980 
    args.read(iprot)
7981 
    iprot.readMessageEnd()
7982 
    result = markOrderDoaRequestAuthorized_result()
7983 
    try:
7984 
      result.success = self._handler.markOrderDoaRequestAuthorized(args.orderId, args.isAuthorized)
7985 
    except TransactionServiceException, ex:
7986 
      result.ex = ex
7987 
    oprot.writeMessageBegin("markOrderDoaRequestAuthorized", TMessageType.REPLY, seqid)
7988 
    result.write(oprot)
7989 
    oprot.writeMessageEnd()
7990 
    oprot.trans.flush()
7991 
 
4488 rajveer 7992 
  def process_markOrderReturnRequestReceived(self, seqid, iprot, oprot):
7993 
    args = markOrderReturnRequestReceived_args()
7994 
    args.read(iprot)
7995 
    iprot.readMessageEnd()
7996 
    result = markOrderReturnRequestReceived_result()
7997 
    try:
7998 
      result.success = self._handler.markOrderReturnRequestReceived(args.orderId)
7999 
    except TransactionServiceException, ex:
8000 
      result.ex = ex
8001 
    oprot.writeMessageBegin("markOrderReturnRequestReceived", TMessageType.REPLY, seqid)
8002 
    result.write(oprot)
8003 
    oprot.writeMessageEnd()
8004 
    oprot.trans.flush()
8005 
 
8006 
  def process_markOrderReturnRequestAuthorized(self, seqid, iprot, oprot):
8007 
    args = markOrderReturnRequestAuthorized_args()
8008 
    args.read(iprot)
8009 
    iprot.readMessageEnd()
8010 
    result = markOrderReturnRequestAuthorized_result()
8011 
    try:
8012 
      result.success = self._handler.markOrderReturnRequestAuthorized(args.orderId, args.isAuthorized)
8013 
    except TransactionServiceException, ex:
8014 
      result.ex = ex
8015 
    oprot.writeMessageBegin("markOrderReturnRequestAuthorized", TMessageType.REPLY, seqid)
8016 
    result.write(oprot)
8017 
    oprot.writeMessageEnd()
8018 
    oprot.trans.flush()
8019 
 
2536 chandransh 8020 
  def process_requestPickupNumber(self, seqid, iprot, oprot):
8021 
    args = requestPickupNumber_args()
8022 
    args.read(iprot)
8023 
    iprot.readMessageEnd()
8024 
    result = requestPickupNumber_result()
8025 
    try:
4579 rajveer 8026 
      result.success = self._handler.requestPickupNumber(args.orderId, args.providerId)
2536 chandransh 8027 
    except TransactionServiceException, ex:
8028 
      result.ex = ex
8029 
    oprot.writeMessageBegin("requestPickupNumber", TMessageType.REPLY, seqid)
8030 
    result.write(oprot)
8031 
    oprot.writeMessageEnd()
8032 
    oprot.trans.flush()
8033 
 
8034 
  def process_authorizePickup(self, seqid, iprot, oprot):
8035 
    args = authorizePickup_args()
8036 
    args.read(iprot)
8037 
    iprot.readMessageEnd()
8038 
    result = authorizePickup_result()
8039 
    try:
4602 rajveer 8040 
      result.success = self._handler.authorizePickup(args.orderId, args.pickupNumber, args.providerId)
2536 chandransh 8041 
    except TransactionServiceException, ex:
8042 
      result.ex = ex
8043 
    oprot.writeMessageBegin("authorizePickup", TMessageType.REPLY, seqid)
8044 
    result.write(oprot)
8045 
    oprot.writeMessageEnd()
8046 
    oprot.trans.flush()
8047 
 
2764 chandransh 8048 
  def process_markDoasAsPickedUp(self, seqid, iprot, oprot):
8049 
    args = markDoasAsPickedUp_args()
8050 
    args.read(iprot)
8051 
    iprot.readMessageEnd()
8052 
    result = markDoasAsPickedUp_result()
4910 phani.kuma 8053 
    self._handler.markDoasAsPickedUp(args.providerId, args.pickupDetails)
2764 chandransh 8054 
    oprot.writeMessageBegin("markDoasAsPickedUp", TMessageType.REPLY, seqid)
8055 
    result.write(oprot)
8056 
    oprot.writeMessageEnd()
8057 
    oprot.trans.flush()
8058 
 
4910 phani.kuma 8059 
  def process_getDoasNotPickedUp(self, seqid, iprot, oprot):
8060 
    args = getDoasNotPickedUp_args()
8061 
    args.read(iprot)
8062 
    iprot.readMessageEnd()
8063 
    result = getDoasNotPickedUp_result()
8064 
    result.success = self._handler.getDoasNotPickedUp(args.providerId)
8065 
    oprot.writeMessageBegin("getDoasNotPickedUp", TMessageType.REPLY, seqid)
8066 
    result.write(oprot)
8067 
    oprot.writeMessageEnd()
8068 
    oprot.trans.flush()
8069 
 
4741 phani.kuma 8070 
  def process_markReturnOrdersAsPickedUp(self, seqid, iprot, oprot):
8071 
    args = markReturnOrdersAsPickedUp_args()
8072 
    args.read(iprot)
8073 
    iprot.readMessageEnd()
8074 
    result = markReturnOrdersAsPickedUp_result()
4910 phani.kuma 8075 
    self._handler.markReturnOrdersAsPickedUp(args.providerId, args.pickupDetails)
4741 phani.kuma 8076 
    oprot.writeMessageBegin("markReturnOrdersAsPickedUp", TMessageType.REPLY, seqid)
8077 
    result.write(oprot)
8078 
    oprot.writeMessageEnd()
8079 
    oprot.trans.flush()
8080 
 
4910 phani.kuma 8081 
  def process_getReturnOrdersNotPickedUp(self, seqid, iprot, oprot):
8082 
    args = getReturnOrdersNotPickedUp_args()
8083 
    args.read(iprot)
8084 
    iprot.readMessageEnd()
8085 
    result = getReturnOrdersNotPickedUp_result()
8086 
    result.success = self._handler.getReturnOrdersNotPickedUp(args.providerId)
8087 
    oprot.writeMessageBegin("getReturnOrdersNotPickedUp", TMessageType.REPLY, seqid)
8088 
    result.write(oprot)
8089 
    oprot.writeMessageEnd()
8090 
    oprot.trans.flush()
8091 
 
2616 chandransh 8092 
  def process_receiveReturn(self, seqid, iprot, oprot):
8093 
    args = receiveReturn_args()
2591 chandransh 8094 
    args.read(iprot)
8095 
    iprot.readMessageEnd()
2616 chandransh 8096 
    result = receiveReturn_result()
2591 chandransh 8097 
    try:
4479 rajveer 8098 
      result.success = self._handler.receiveReturn(args.orderId, args.receiveCondition)
2591 chandransh 8099 
    except TransactionServiceException, ex:
8100 
      result.ex = ex
2616 chandransh 8101 
    oprot.writeMessageBegin("receiveReturn", TMessageType.REPLY, seqid)
2591 chandransh 8102 
    result.write(oprot)
8103 
    oprot.writeMessageEnd()
8104 
    oprot.trans.flush()
2536 chandransh 8105 
 
2591 chandransh 8106 
  def process_validateDoa(self, seqid, iprot, oprot):
8107 
    args = validateDoa_args()
8108 
    args.read(iprot)
8109 
    iprot.readMessageEnd()
8110 
    result = validateDoa_result()
8111 
    try:
8112 
      result.success = self._handler.validateDoa(args.orderId, args.isValid)
8113 
    except TransactionServiceException, ex:
8114 
      result.ex = ex
8115 
    oprot.writeMessageBegin("validateDoa", TMessageType.REPLY, seqid)
8116 
    result.write(oprot)
8117 
    oprot.writeMessageEnd()
8118 
    oprot.trans.flush()
8119 
 
4495 rajveer 8120 
  def process_validateReturnProduct(self, seqid, iprot, oprot):
8121 
    args = validateReturnProduct_args()
8122 
    args.read(iprot)
8123 
    iprot.readMessageEnd()
8124 
    result = validateReturnProduct_result()
8125 
    try:
8126 
      result.success = self._handler.validateReturnProduct(args.orderId, args.isUsable)
8127 
    except TransactionServiceException, ex:
8128 
      result.ex = ex
8129 
    oprot.writeMessageBegin("validateReturnProduct", TMessageType.REPLY, seqid)
8130 
    result.write(oprot)
8131 
    oprot.writeMessageEnd()
8132 
    oprot.trans.flush()
8133 
 
2616 chandransh 8134 
  def process_reshipOrder(self, seqid, iprot, oprot):
8135 
    args = reshipOrder_args()
8136 
    args.read(iprot)
8137 
    iprot.readMessageEnd()
8138 
    result = reshipOrder_result()
8139 
    try:
8140 
      result.success = self._handler.reshipOrder(args.orderId)
8141 
    except TransactionServiceException, ex:
8142 
      result.ex = ex
8143 
    oprot.writeMessageBegin("reshipOrder", TMessageType.REPLY, seqid)
8144 
    result.write(oprot)
8145 
    oprot.writeMessageEnd()
8146 
    oprot.trans.flush()
2591 chandransh 8147 
 
2616 chandransh 8148 
  def process_refundOrder(self, seqid, iprot, oprot):
8149 
    args = refundOrder_args()
8150 
    args.read(iprot)
8151 
    iprot.readMessageEnd()
8152 
    result = refundOrder_result()
8153 
    try:
3226 chandransh 8154 
      result.success = self._handler.refundOrder(args.orderId, args.refundedBy, args.reason)
2616 chandransh 8155 
    except TransactionServiceException, ex:
8156 
      result.ex = ex
8157 
    oprot.writeMessageBegin("refundOrder", TMessageType.REPLY, seqid)
8158 
    result.write(oprot)
8159 
    oprot.writeMessageEnd()
8160 
    oprot.trans.flush()
8161 
 
2690 chandransh 8162 
  def process_getReturnOrders(self, seqid, iprot, oprot):
8163 
    args = getReturnOrders_args()
8164 
    args.read(iprot)
8165 
    iprot.readMessageEnd()
8166 
    result = getReturnOrders_result()
8167 
    result.success = self._handler.getReturnOrders(args.warehouseId, args.fromDate, args.toDate)
8168 
    oprot.writeMessageBegin("getReturnOrders", TMessageType.REPLY, seqid)
8169 
    result.write(oprot)
8170 
    oprot.writeMessageEnd()
8171 
    oprot.trans.flush()
2616 chandransh 8172 
 
5481 phani.kuma 8173 
  def process_getAllReturnOrders(self, seqid, iprot, oprot):
8174 
    args = getAllReturnOrders_args()
8175 
    args.read(iprot)
8176 
    iprot.readMessageEnd()
8177 
    result = getAllReturnOrders_result()
8178 
    result.success = self._handler.getAllReturnOrders(args.onlyNotProcessed, args.fromDate, args.toDate)
8179 
    oprot.writeMessageBegin("getAllReturnOrders", TMessageType.REPLY, seqid)
8180 
    result.write(oprot)
8181 
    oprot.writeMessageEnd()
8182 
    oprot.trans.flush()
8183 
 
2700 chandransh 8184 
  def process_getReturnOrder(self, seqid, iprot, oprot):
8185 
    args = getReturnOrder_args()
8186 
    args.read(iprot)
8187 
    iprot.readMessageEnd()
8188 
    result = getReturnOrder_result()
8189 
    try:
8190 
      result.success = self._handler.getReturnOrder(args.id)
8191 
    except TransactionServiceException, ex:
8192 
      result.ex = ex
8193 
    oprot.writeMessageBegin("getReturnOrder", TMessageType.REPLY, seqid)
8194 
    result.write(oprot)
8195 
    oprot.writeMessageEnd()
8196 
    oprot.trans.flush()
8197 
 
2690 chandransh 8198 
  def process_processReturn(self, seqid, iprot, oprot):
8199 
    args = processReturn_args()
8200 
    args.read(iprot)
8201 
    iprot.readMessageEnd()
8202 
    result = processReturn_result()
8203 
    try:
8204 
      self._handler.processReturn(args.returnOrderId)
8205 
    except TransactionServiceException, ex:
8206 
      result.ex = ex
8207 
    oprot.writeMessageBegin("processReturn", TMessageType.REPLY, seqid)
8208 
    result.write(oprot)
8209 
    oprot.writeMessageEnd()
8210 
    oprot.trans.flush()
8211 
 
3451 chandransh 8212 
  def process_updateWeight(self, seqid, iprot, oprot):
8213 
    args = updateWeight_args()
8214 
    args.read(iprot)
8215 
    iprot.readMessageEnd()
8216 
    result = updateWeight_result()
8217 
    try:
8218 
      result.success = self._handler.updateWeight(args.orderId, args.weight)
8219 
    except TransactionServiceException, ex:
8220 
      result.ex = ex
8221 
    oprot.writeMessageBegin("updateWeight", TMessageType.REPLY, seqid)
8222 
    result.write(oprot)
8223 
    oprot.writeMessageEnd()
8224 
    oprot.trans.flush()
2819 chandransh 8225 
 
3469 chandransh 8226 
  def process_changeItem(self, seqid, iprot, oprot):
8227 
    args = changeItem_args()
8228 
    args.read(iprot)
8229 
    iprot.readMessageEnd()
8230 
    result = changeItem_result()
8231 
    try:
8232 
      result.success = self._handler.changeItem(args.orderId, args.itemId)
8233 
    except TransactionServiceException, ex:
8234 
      result.ex = ex
8235 
    oprot.writeMessageBegin("changeItem", TMessageType.REPLY, seqid)
8236 
    result.write(oprot)
8237 
    oprot.writeMessageEnd()
8238 
    oprot.trans.flush()
3451 chandransh 8239 
 
3469 chandransh 8240 
  def process_shiftToWarehouse(self, seqid, iprot, oprot):
8241 
    args = shiftToWarehouse_args()
8242 
    args.read(iprot)
8243 
    iprot.readMessageEnd()
8244 
    result = shiftToWarehouse_result()
8245 
    try:
8246 
      result.success = self._handler.shiftToWarehouse(args.orderId, args.warehouseId)
8247 
    except TransactionServiceException, ex:
8248 
      result.ex = ex
8249 
    oprot.writeMessageBegin("shiftToWarehouse", TMessageType.REPLY, seqid)
8250 
    result.write(oprot)
8251 
    oprot.writeMessageEnd()
8252 
    oprot.trans.flush()
8253 
 
3553 chandransh 8254 
  def process_addDelayReason(self, seqid, iprot, oprot):
8255 
    args = addDelayReason_args()
8256 
    args.read(iprot)
8257 
    iprot.readMessageEnd()
8258 
    result = addDelayReason_result()
8259 
    try:
4647 rajveer 8260 
      result.success = self._handler.addDelayReason(args.orderId, args.delayReason, args.furtherDelay, args.delayReasonText)
3553 chandransh 8261 
    except TransactionServiceException, ex:
8262 
      result.ex = ex
8263 
    oprot.writeMessageBegin("addDelayReason", TMessageType.REPLY, seqid)
8264 
    result.write(oprot)
8265 
    oprot.writeMessageEnd()
8266 
    oprot.trans.flush()
3469 chandransh 8267 
 
3956 chandransh 8268 
  def process_reconcileCodCollection(self, seqid, iprot, oprot):
8269 
    args = reconcileCodCollection_args()
8270 
    args.read(iprot)
8271 
    iprot.readMessageEnd()
8272 
    result = reconcileCodCollection_result()
8273 
    try:
8274 
      result.success = self._handler.reconcileCodCollection(args.collectedAmountMap, args.xferBy, args.xferTxnId, args.xferDate)
8275 
    except TransactionServiceException, ex:
8276 
      result.ex = ex
8277 
    oprot.writeMessageBegin("reconcileCodCollection", TMessageType.REPLY, seqid)
8278 
    result.write(oprot)
8279 
    oprot.writeMessageEnd()
8280 
    oprot.trans.flush()
3553 chandransh 8281 
 
4008 mandeep.dh 8282 
  def process_getTransactionsRequiringExtraProcessing(self, seqid, iprot, oprot):
8283 
    args = getTransactionsRequiringExtraProcessing_args()
8284 
    args.read(iprot)
8285 
    iprot.readMessageEnd()
8286 
    result = getTransactionsRequiringExtraProcessing_result()
8287 
    result.success = self._handler.getTransactionsRequiringExtraProcessing(args.category)
8288 
    oprot.writeMessageBegin("getTransactionsRequiringExtraProcessing", TMessageType.REPLY, seqid)
8289 
    result.write(oprot)
8290 
    oprot.writeMessageEnd()
8291 
    oprot.trans.flush()
3956 chandransh 8292 
 
4008 mandeep.dh 8293 
  def process_markTransactionAsProcessed(self, seqid, iprot, oprot):
8294 
    args = markTransactionAsProcessed_args()
8295 
    args.read(iprot)
8296 
    iprot.readMessageEnd()
8297 
    result = markTransactionAsProcessed_result()
8298 
    self._handler.markTransactionAsProcessed(args.transactionId, args.category)
8299 
    oprot.writeMessageBegin("markTransactionAsProcessed", TMessageType.REPLY, seqid)
8300 
    result.write(oprot)
8301 
    oprot.writeMessageEnd()
8302 
    oprot.trans.flush()
8303 
 
4018 chandransh 8304 
  def process_getItemWiseRiskyOrdersCount(self, seqid, iprot, oprot):
8305 
    args = getItemWiseRiskyOrdersCount_args()
8306 
    args.read(iprot)
8307 
    iprot.readMessageEnd()
8308 
    result = getItemWiseRiskyOrdersCount_result()
8309 
    result.success = self._handler.getItemWiseRiskyOrdersCount()
8310 
    oprot.writeMessageBegin("getItemWiseRiskyOrdersCount", TMessageType.REPLY, seqid)
8311 
    result.write(oprot)
8312 
    oprot.writeMessageEnd()
8313 
    oprot.trans.flush()
4008 mandeep.dh 8314 
 
4295 varun.gupt 8315 
  def process_getOrdersForItemIds(self, seqid, iprot, oprot):
8316 
    args = getOrdersForItemIds_args()
8317 
    args.read(iprot)
8318 
    iprot.readMessageEnd()
8319 
    result = getOrdersForItemIds_result()
8320 
    result.success = self._handler.getOrdersForItemIds(args.itemIds)
8321 
    oprot.writeMessageBegin("getOrdersForItemIds", TMessageType.REPLY, seqid)
8322 
    result.write(oprot)
8323 
    oprot.writeMessageEnd()
8324 
    oprot.trans.flush()
8325 
 
4247 rajveer 8326 
  def process_markOrderCancellationRequestReceived(self, seqid, iprot, oprot):
8327 
    args = markOrderCancellationRequestReceived_args()
8328 
    args.read(iprot)
8329 
    iprot.readMessageEnd()
8330 
    result = markOrderCancellationRequestReceived_result()
8331 
    try:
8332 
      self._handler.markOrderCancellationRequestReceived(args.orderId)
8333 
    except TransactionServiceException, ex:
8334 
      result.ex = ex
8335 
    oprot.writeMessageBegin("markOrderCancellationRequestReceived", TMessageType.REPLY, seqid)
8336 
    result.write(oprot)
8337 
    oprot.writeMessageEnd()
8338 
    oprot.trans.flush()
4018 chandransh 8339 
 
4247 rajveer 8340 
  def process_markOrderCancellationRequestConfirmed(self, seqid, iprot, oprot):
8341 
    args = markOrderCancellationRequestConfirmed_args()
8342 
    args.read(iprot)
8343 
    iprot.readMessageEnd()
8344 
    result = markOrderCancellationRequestConfirmed_result()
8345 
    try:
8346 
      self._handler.markOrderCancellationRequestConfirmed(args.orderId)
8347 
    except TransactionServiceException, ex:
8348 
      result.ex = ex
8349 
    oprot.writeMessageBegin("markOrderCancellationRequestConfirmed", TMessageType.REPLY, seqid)
8350 
    result.write(oprot)
8351 
    oprot.writeMessageEnd()
8352 
    oprot.trans.flush()
8353 
 
8354 
  def process_markOrderCancellationRequestDenied(self, seqid, iprot, oprot):
8355 
    args = markOrderCancellationRequestDenied_args()
8356 
    args.read(iprot)
8357 
    iprot.readMessageEnd()
8358 
    result = markOrderCancellationRequestDenied_result()
8359 
    try:
8360 
      self._handler.markOrderCancellationRequestDenied(args.orderId)
8361 
    except TransactionServiceException, ex:
8362 
      result.ex = ex
8363 
    oprot.writeMessageBegin("markOrderCancellationRequestDenied", TMessageType.REPLY, seqid)
8364 
    result.write(oprot)
8365 
    oprot.writeMessageEnd()
8366 
    oprot.trans.flush()
8367 
 
4258 rajveer 8368 
  def process_markTransactionAsPaymentFlagRemoved(self, seqid, iprot, oprot):
8369 
    args = markTransactionAsPaymentFlagRemoved_args()
4247 rajveer 8370 
    args.read(iprot)
8371 
    iprot.readMessageEnd()
4258 rajveer 8372 
    result = markTransactionAsPaymentFlagRemoved_result()
4247 rajveer 8373 
    try:
4258 rajveer 8374 
      self._handler.markTransactionAsPaymentFlagRemoved(args.transactionId)
4247 rajveer 8375 
    except TransactionServiceException, ex:
8376 
      result.ex = ex
4258 rajveer 8377 
    oprot.writeMessageBegin("markTransactionAsPaymentFlagRemoved", TMessageType.REPLY, seqid)
4247 rajveer 8378 
    result.write(oprot)
8379 
    oprot.writeMessageEnd()
8380 
    oprot.trans.flush()
8381 
 
4259 anupam.sin 8382 
  def process_refundTransaction(self, seqid, iprot, oprot):
8383 
    args = refundTransaction_args()
8384 
    args.read(iprot)
8385 
    iprot.readMessageEnd()
8386 
    result = refundTransaction_result()
8387 
    try:
8388 
      self._handler.refundTransaction(args.transactionId, args.refundedBy, args.reason)
8389 
    except TransactionServiceException, ex:
8390 
      result.ex = ex
8391 
    oprot.writeMessageBegin("refundTransaction", TMessageType.REPLY, seqid)
8392 
    result.write(oprot)
8393 
    oprot.writeMessageEnd()
8394 
    oprot.trans.flush()
4247 rajveer 8395 
 
4324 mandeep.dh 8396 
  def process_updateShipmentAddress(self, seqid, iprot, oprot):
8397 
    args = updateShipmentAddress_args()
8398 
    args.read(iprot)
8399 
    iprot.readMessageEnd()
8400 
    result = updateShipmentAddress_result()
8401 
    try:
8402 
      self._handler.updateShipmentAddress(args.orderId, args.addressId)
8403 
    except TransactionServiceException, ex:
8404 
      result.ex = ex
8405 
    oprot.writeMessageBegin("updateShipmentAddress", TMessageType.REPLY, seqid)
8406 
    result.write(oprot)
8407 
    oprot.writeMessageEnd()
8408 
    oprot.trans.flush()
8409 
 
4285 rajveer 8410 
  def process_acceptOrdersForItemId(self, seqid, iprot, oprot):
8411 
    args = acceptOrdersForItemId_args()
8412 
    args.read(iprot)
8413 
    iprot.readMessageEnd()
8414 
    result = acceptOrdersForItemId_result()
8415 
    try:
8416 
      result.success = self._handler.acceptOrdersForItemId(args.itemId, args.inventory)
8417 
    except TransactionServiceException, ex:
8418 
      result.ex = ex
8419 
    oprot.writeMessageBegin("acceptOrdersForItemId", TMessageType.REPLY, seqid)
8420 
    result.write(oprot)
8421 
    oprot.writeMessageEnd()
8422 
    oprot.trans.flush()
4259 anupam.sin 8423 
 
4303 rajveer 8424 
  def process_markOrdersAsPORaised(self, seqid, iprot, oprot):
8425 
    args = markOrdersAsPORaised_args()
8426 
    args.read(iprot)
8427 
    iprot.readMessageEnd()
8428 
    result = markOrdersAsPORaised_result()
8429 
    try:
4369 rajveer 8430 
      self._handler.markOrdersAsPORaised(args.vendorId, args.itemId, args.quantity, args.estimate, args.isReminder)
4303 rajveer 8431 
    except TransactionServiceException, ex:
8432 
      result.ex = ex
8433 
    oprot.writeMessageBegin("markOrdersAsPORaised", TMessageType.REPLY, seqid)
8434 
    result.write(oprot)
8435 
    oprot.writeMessageEnd()
8436 
    oprot.trans.flush()
4285 rajveer 8437 
 
4303 rajveer 8438 
  def process_markOrdersAsReversalInitiated(self, seqid, iprot, oprot):
8439 
    args = markOrdersAsReversalInitiated_args()
8440 
    args.read(iprot)
8441 
    iprot.readMessageEnd()
8442 
    result = markOrdersAsReversalInitiated_result()
8443 
    try:
4369 rajveer 8444 
      self._handler.markOrdersAsReversalInitiated(args.vendorId, args.itemId, args.quantity, args.estimate, args.isReminder)
4303 rajveer 8445 
    except TransactionServiceException, ex:
8446 
      result.ex = ex
8447 
    oprot.writeMessageBegin("markOrdersAsReversalInitiated", TMessageType.REPLY, seqid)
8448 
    result.write(oprot)
8449 
    oprot.writeMessageEnd()
8450 
    oprot.trans.flush()
8451 
 
8452 
  def process_markOrdersAsNotAvailabke(self, seqid, iprot, oprot):
8453 
    args = markOrdersAsNotAvailabke_args()
8454 
    args.read(iprot)
8455 
    iprot.readMessageEnd()
8456 
    result = markOrdersAsNotAvailabke_result()
8457 
    try:
4369 rajveer 8458 
      self._handler.markOrdersAsNotAvailabke(args.vendorId, args.itemId, args.quantity, args.estimate, args.isReminder)
4303 rajveer 8459 
    except TransactionServiceException, ex:
8460 
      result.ex = ex
8461 
    oprot.writeMessageBegin("markOrdersAsNotAvailabke", TMessageType.REPLY, seqid)
8462 
    result.write(oprot)
8463 
    oprot.writeMessageEnd()
8464 
    oprot.trans.flush()
8465 
 
4369 rajveer 8466 
  def process_markOrdersAsTimeout(self, seqid, iprot, oprot):
8467 
    args = markOrdersAsTimeout_args()
8468 
    args.read(iprot)
8469 
    iprot.readMessageEnd()
8470 
    result = markOrdersAsTimeout_result()
8471 
    try:
8472 
      result.success = self._handler.markOrdersAsTimeout(args.vendorId)
8473 
    except TransactionServiceException, ex:
8474 
      result.ex = ex
8475 
    oprot.writeMessageBegin("markOrdersAsTimeout", TMessageType.REPLY, seqid)
8476 
    result.write(oprot)
8477 
    oprot.writeMessageEnd()
8478 
    oprot.trans.flush()
4303 rajveer 8479 
 
4662 rajveer 8480 
  def process_markOrderAsLostInTransit(self, seqid, iprot, oprot):
8481 
    args = markOrderAsLostInTransit_args()
8482 
    args.read(iprot)
8483 
    iprot.readMessageEnd()
8484 
    result = markOrderAsLostInTransit_result()
8485 
    try:
8486 
      result.success = self._handler.markOrderAsLostInTransit(args.orderId)
8487 
    except TransactionServiceException, ex:
8488 
      result.ex = ex
8489 
    oprot.writeMessageBegin("markOrderAsLostInTransit", TMessageType.REPLY, seqid)
8490 
    result.write(oprot)
8491 
    oprot.writeMessageEnd()
8492 
    oprot.trans.flush()
8493 
 
4386 anupam.sin 8494 
  def process_getOrderForAwb(self, seqid, iprot, oprot):
8495 
    args = getOrderForAwb_args()
8496 
    args.read(iprot)
8497 
    iprot.readMessageEnd()
8498 
    result = getOrderForAwb_result()
8499 
    try:
8500 
      result.success = self._handler.getOrderForAwb(args.awb)
8501 
    except TransactionServiceException, ex:
8502 
      result.ex = ex
8503 
    oprot.writeMessageBegin("getOrderForAwb", TMessageType.REPLY, seqid)
8504 
    result.write(oprot)
8505 
    oprot.writeMessageEnd()
8506 
    oprot.trans.flush()
4369 rajveer 8507 
 
4506 phani.kuma 8508 
  def process_getOrdersForProviderForStatus(self, seqid, iprot, oprot):
8509 
    args = getOrdersForProviderForStatus_args()
8510 
    args.read(iprot)
8511 
    iprot.readMessageEnd()
8512 
    result = getOrdersForProviderForStatus_result()
8513 
    try:
4910 phani.kuma 8514 
      result.success = self._handler.getOrdersForProviderForStatus(args.logistics_provider_id, args.order_status_list)
4506 phani.kuma 8515 
    except TransactionServiceException, ex:
8516 
      result.ex = ex
8517 
    oprot.writeMessageBegin("getOrdersForProviderForStatus", TMessageType.REPLY, seqid)
8518 
    result.write(oprot)
8519 
    oprot.writeMessageEnd()
8520 
    oprot.trans.flush()
4386 anupam.sin 8521 
 
4600 varun.gupt 8522 
  def process_getBilledOrdersForVendor(self, seqid, iprot, oprot):
8523 
    args = getBilledOrdersForVendor_args()
8524 
    args.read(iprot)
8525 
    iprot.readMessageEnd()
8526 
    result = getBilledOrdersForVendor_result()
8527 
    try:
8528 
      result.success = self._handler.getBilledOrdersForVendor(args.vendorId, args.billingDateFrom, args.billingDateTo)
8529 
    except TransactionServiceException, ex:
8530 
      result.ex = ex
8531 
    oprot.writeMessageBegin("getBilledOrdersForVendor", TMessageType.REPLY, seqid)
8532 
    result.write(oprot)
8533 
    oprot.writeMessageEnd()
8534 
    oprot.trans.flush()
4506 phani.kuma 8535 
 
4607 rajveer 8536 
  def process_getSlippedSippingDateOrders(self, seqid, iprot, oprot):
8537 
    args = getSlippedSippingDateOrders_args()
8538 
    args.read(iprot)
8539 
    iprot.readMessageEnd()
8540 
    result = getSlippedSippingDateOrders_result()
8541 
    try:
8542 
      result.success = self._handler.getSlippedSippingDateOrders()
8543 
    except TransactionServiceException, ex:
8544 
      result.ex = ex
8545 
    oprot.writeMessageBegin("getSlippedSippingDateOrders", TMessageType.REPLY, seqid)
8546 
    result.write(oprot)
8547 
    oprot.writeMessageEnd()
8548 
    oprot.trans.flush()
8549 
 
4709 rajveer 8550 
  def process_getCancelledOrders(self, seqid, iprot, oprot):
8551 
    args = getCancelledOrders_args()
8552 
    args.read(iprot)
8553 
    iprot.readMessageEnd()
8554 
    result = getCancelledOrders_result()
8555 
    try:
8556 
      result.success = self._handler.getCancelledOrders(args.cancelDateFrom, args.cancelDateTo)
8557 
    except TransactionServiceException, ex:
8558 
      result.ex = ex
8559 
    oprot.writeMessageBegin("getCancelledOrders", TMessageType.REPLY, seqid)
8560 
    result.write(oprot)
8561 
    oprot.writeMessageEnd()
8562 
    oprot.trans.flush()
8563 
 
4600 varun.gupt 8564 
  def process_saveBluedartSettlements(self, seqid, iprot, oprot):
8565 
    args = saveBluedartSettlements_args()
8566 
    args.read(iprot)
8567 
    iprot.readMessageEnd()
8568 
    result = saveBluedartSettlements_result()
8569 
    try:
8570 
      self._handler.saveBluedartSettlements(args.mapAWBAndAmount)
8571 
    except TransactionServiceException, ex:
8572 
      result.ex = ex
8573 
    oprot.writeMessageBegin("saveBluedartSettlements", TMessageType.REPLY, seqid)
8574 
    result.write(oprot)
8575 
    oprot.writeMessageEnd()
8576 
    oprot.trans.flush()
8577 
 
8578 
  def process_savePaymentSettlements(self, seqid, iprot, oprot):
8579 
    args = savePaymentSettlements_args()
8580 
    args.read(iprot)
8581 
    iprot.readMessageEnd()
8582 
    result = savePaymentSettlements_result()
8583 
    try:
4905 varun.gupt 8584 
      self._handler.savePaymentSettlements(args.settlementDate, args.paymentGatewayId, args.referenceId, args.serviceTax, args.otherCharges, args.netCollection)
4600 varun.gupt 8585 
    except TransactionServiceException, ex:
8586 
      result.ex = ex
8587 
    oprot.writeMessageBegin("savePaymentSettlements", TMessageType.REPLY, seqid)
8588 
    result.write(oprot)
8589 
    oprot.writeMessageEnd()
8590 
    oprot.trans.flush()
8591 
 
8592 
  def process_saveEBSSettlementSummary(self, seqid, iprot, oprot):
8593 
    args = saveEBSSettlementSummary_args()
8594 
    args.read(iprot)
8595 
    iprot.readMessageEnd()
8596 
    result = saveEBSSettlementSummary_result()
8597 
    try:
8598 
      self._handler.saveEBSSettlementSummary(args.settlementId, args.settlementDate, args.transactionDateFrom, args.transactionDateTo, args.amount)
8599 
    except TransactionServiceException, ex:
8600 
      result.ex = ex
8601 
    oprot.writeMessageBegin("saveEBSSettlementSummary", TMessageType.REPLY, seqid)
8602 
    result.write(oprot)
8603 
    oprot.writeMessageEnd()
8604 
    oprot.trans.flush()
8605 
 
5386 phani.kuma 8606 
  def process_getSettlementForPrepaid(self, seqid, iprot, oprot):
8607 
    args = getSettlementForPrepaid_args()
4600 varun.gupt 8608 
    args.read(iprot)
8609 
    iprot.readMessageEnd()
5386 phani.kuma 8610 
    result = getSettlementForPrepaid_result()
4600 varun.gupt 8611 
    try:
5386 phani.kuma 8612 
      result.success = self._handler.getSettlementForPrepaid(args.referenceId, args.isRefund)
4600 varun.gupt 8613 
    except TransactionServiceException, ex:
8614 
      result.ex = ex
5386 phani.kuma 8615 
    oprot.writeMessageBegin("getSettlementForPrepaid", TMessageType.REPLY, seqid)
4600 varun.gupt 8616 
    result.write(oprot)
8617 
    oprot.writeMessageEnd()
8618 
    oprot.trans.flush()
8619 
 
5386 phani.kuma 8620 
  def process_getSettlementForCod(self, seqid, iprot, oprot):
8621 
    args = getSettlementForCod_args()
8622 
    args.read(iprot)
8623 
    iprot.readMessageEnd()
8624 
    result = getSettlementForCod_result()
8625 
    try:
8626 
      result.success = self._handler.getSettlementForCod(args.orderId, args.isRefund)
8627 
    except TransactionServiceException, ex:
8628 
      result.ex = ex
8629 
    oprot.writeMessageBegin("getSettlementForCod", TMessageType.REPLY, seqid)
8630 
    result.write(oprot)
8631 
    oprot.writeMessageEnd()
8632 
    oprot.trans.flush()
8633 
 
4600 varun.gupt 8634 
  def process_getEBSSettlementSummaries(self, seqid, iprot, oprot):
8635 
    args = getEBSSettlementSummaries_args()
8636 
    args.read(iprot)
8637 
    iprot.readMessageEnd()
8638 
    result = getEBSSettlementSummaries_result()
8639 
    try:
8640 
      result.success = self._handler.getEBSSettlementSummaries()
8641 
    except TransactionServiceException, ex:
8642 
      result.ex = ex
8643 
    oprot.writeMessageBegin("getEBSSettlementSummaries", TMessageType.REPLY, seqid)
8644 
    result.write(oprot)
8645 
    oprot.writeMessageEnd()
8646 
    oprot.trans.flush()
8647 
 
8648 
  def process_markEBSSettlementUploaded(self, seqid, iprot, oprot):
8649 
    args = markEBSSettlementUploaded_args()
8650 
    args.read(iprot)
8651 
    iprot.readMessageEnd()
8652 
    result = markEBSSettlementUploaded_result()
8653 
    try:
8654 
      self._handler.markEBSSettlementUploaded(args.settlementId)
8655 
    except TransactionServiceException, ex:
8656 
      result.ex = ex
8657 
    oprot.writeMessageBegin("markEBSSettlementUploaded", TMessageType.REPLY, seqid)
8658 
    result.write(oprot)
8659 
    oprot.writeMessageEnd()
8660 
    oprot.trans.flush()
8661 
 
8662 
  def process_getEBSSettlementDate(self, seqid, iprot, oprot):
8663 
    args = getEBSSettlementDate_args()
8664 
    args.read(iprot)
8665 
    iprot.readMessageEnd()
8666 
    result = getEBSSettlementDate_result()
8667 
    try:
8668 
      result.success = self._handler.getEBSSettlementDate(args.settlementId)
8669 
    except TransactionServiceException, ex:
8670 
      result.ex = ex
8671 
    oprot.writeMessageBegin("getEBSSettlementDate", TMessageType.REPLY, seqid)
8672 
    result.write(oprot)
8673 
    oprot.writeMessageEnd()
8674 
    oprot.trans.flush()
8675 
 
4715 varun.gupt 8676 
  def process_getSettlementsByDate(self, seqid, iprot, oprot):
8677 
    args = getSettlementsByDate_args()
8678 
    args.read(iprot)
8679 
    iprot.readMessageEnd()
8680 
    result = getSettlementsByDate_result()
8681 
    try:
8682 
      result.success = self._handler.getSettlementsByDate(args.settlementDateFrom, args.settlementDateTo, args.isRefund)
8683 
    except TransactionServiceException, ex:
8684 
      result.ex = ex
8685 
    oprot.writeMessageBegin("getSettlementsByDate", TMessageType.REPLY, seqid)
8686 
    result.write(oprot)
8687 
    oprot.writeMessageEnd()
8688 
    oprot.trans.flush()
4600 varun.gupt 8689 
 
4715 varun.gupt 8690 
  def process_getReshippedOrderIds(self, seqid, iprot, oprot):
8691 
    args = getReshippedOrderIds_args()
8692 
    args.read(iprot)
8693 
    iprot.readMessageEnd()
8694 
    result = getReshippedOrderIds_result()
8695 
    try:
8696 
      result.success = self._handler.getReshippedOrderIds(args.orderIds)
8697 
    except TransactionServiceException, ex:
8698 
      result.ex = ex
8699 
    oprot.writeMessageBegin("getReshippedOrderIds", TMessageType.REPLY, seqid)
8700 
    result.write(oprot)
8701 
    oprot.writeMessageEnd()
8702 
    oprot.trans.flush()
8703 
 
5481 phani.kuma 8704 
  def process_getBilledOrders(self, seqid, iprot, oprot):
8705 
    args = getBilledOrders_args()
4875 varun.gupt 8706 
    args.read(iprot)
8707 
    iprot.readMessageEnd()
5481 phani.kuma 8708 
    result = getBilledOrders_result()
4875 varun.gupt 8709 
    try:
5481 phani.kuma 8710 
      result.success = self._handler.getBilledOrders(args.vendorId, args.onlyVendorNotPaid, args.billingDateFrom, args.billingDateTo)
4875 varun.gupt 8711 
    except TransactionServiceException, ex:
8712 
      result.ex = ex
5481 phani.kuma 8713 
    oprot.writeMessageBegin("getBilledOrders", TMessageType.REPLY, seqid)
4875 varun.gupt 8714 
    result.write(oprot)
8715 
    oprot.writeMessageEnd()
8716 
    oprot.trans.flush()
4757 mandeep.dh 8717 
 
5031 varun.gupt 8718 
  def process_getStatusDistributionOfOrders(self, seqid, iprot, oprot):
8719 
    args = getStatusDistributionOfOrders_args()
8720 
    args.read(iprot)
8721 
    iprot.readMessageEnd()
8722 
    result = getStatusDistributionOfOrders_result()
8723 
    try:
8724 
      result.success = self._handler.getStatusDistributionOfOrders(args.startDate, args.endDate)
8725 
    except TransactionServiceException, ex:
8726 
      result.ex = ex
8727 
    oprot.writeMessageBegin("getStatusDistributionOfOrders", TMessageType.REPLY, seqid)
8728 
    result.write(oprot)
8729 
    oprot.writeMessageEnd()
8730 
    oprot.trans.flush()
4875 varun.gupt 8731 
 
5067 varun.gupt 8732 
  def process_getOrderIdsForStatus(self, seqid, iprot, oprot):
8733 
    args = getOrderIdsForStatus_args()
8734 
    args.read(iprot)
8735 
    iprot.readMessageEnd()
8736 
    result = getOrderIdsForStatus_result()
8737 
    try:
8738 
      result.success = self._handler.getOrderIdsForStatus(args.status, args.startDatetime, args.endDatetime)
8739 
    except TransactionServiceException, ex:
8740 
      result.ex = ex
8741 
    oprot.writeMessageBegin("getOrderIdsForStatus", TMessageType.REPLY, seqid)
8742 
    result.write(oprot)
8743 
    oprot.writeMessageEnd()
8744 
    oprot.trans.flush()
5031 varun.gupt 8745 
 
5348 anupam.sin 8746 
  def process_updateCODAgent(self, seqid, iprot, oprot):
8747 
    args = updateCODAgent_args()
8748 
    args.read(iprot)
8749 
    iprot.readMessageEnd()
8750 
    result = updateCODAgent_result()
8751 
    try:
8752 
      self._handler.updateCODAgent(args.agent, args.orderId)
8753 
    except TransactionServiceException, ex:
8754 
      result.ex = ex
8755 
    oprot.writeMessageBegin("updateCODAgent", TMessageType.REPLY, seqid)
8756 
    result.write(oprot)
8757 
    oprot.writeMessageEnd()
8758 
    oprot.trans.flush()
8759 
 
5099 varun.gupt 8760 
  def process_updateOrderAsPaidToVendor(self, seqid, iprot, oprot):
8761 
    args = updateOrderAsPaidToVendor_args()
8762 
    args.read(iprot)
8763 
    iprot.readMessageEnd()
8764 
    result = updateOrderAsPaidToVendor_result()
8765 
    try:
8766 
      self._handler.updateOrderAsPaidToVendor(args.orderId)
8767 
    except TransactionServiceException, ex:
8768 
      result.ex = ex
8769 
    oprot.writeMessageBegin("updateOrderAsPaidToVendor", TMessageType.REPLY, seqid)
8770 
    result.write(oprot)
8771 
    oprot.writeMessageEnd()
8772 
    oprot.trans.flush()
5067 varun.gupt 8773 
 
5386 phani.kuma 8774 
  def process_updateOrderOnlyAsPaidToVendor(self, seqid, iprot, oprot):
8775 
    args = updateOrderOnlyAsPaidToVendor_args()
8776 
    args.read(iprot)
8777 
    iprot.readMessageEnd()
8778 
    result = updateOrderOnlyAsPaidToVendor_result()
8779 
    try:
8780 
      self._handler.updateOrderOnlyAsPaidToVendor(args.orderId)
8781 
    except TransactionServiceException, ex:
8782 
      result.ex = ex
8783 
    oprot.writeMessageBegin("updateOrderOnlyAsPaidToVendor", TMessageType.REPLY, seqid)
8784 
    result.write(oprot)
8785 
    oprot.writeMessageEnd()
8786 
    oprot.trans.flush()
8787 
 
5208 varun.gupt 8788 
  def process_getRefundedOrdersMarkedPaid(self, seqid, iprot, oprot):
8789 
    args = getRefundedOrdersMarkedPaid_args()
8790 
    args.read(iprot)
8791 
    iprot.readMessageEnd()
8792 
    result = getRefundedOrdersMarkedPaid_result()
8793 
    try:
8794 
      result.success = self._handler.getRefundedOrdersMarkedPaid()
8795 
    except TransactionServiceException, ex:
8796 
      result.ex = ex
8797 
    oprot.writeMessageBegin("getRefundedOrdersMarkedPaid", TMessageType.REPLY, seqid)
8798 
    result.write(oprot)
8799 
    oprot.writeMessageEnd()
8800 
    oprot.trans.flush()
5099 varun.gupt 8801 
 
5447 anupam.sin 8802 
  def process_getAllVerificationAgents(self, seqid, iprot, oprot):
8803 
    args = getAllVerificationAgents_args()
8804 
    args.read(iprot)
8805 
    iprot.readMessageEnd()
8806 
    result = getAllVerificationAgents_result()
8807 
    result.success = self._handler.getAllVerificationAgents(args.minOrderId, args.maxOrderId)
8808 
    oprot.writeMessageBegin("getAllVerificationAgents", TMessageType.REPLY, seqid)
8809 
    result.write(oprot)
8810 
    oprot.writeMessageEnd()
8811 
    oprot.trans.flush()
5208 varun.gupt 8812 
 
5527 anupam.sin 8813 
  def process_getAllAttributesForOrderId(self, seqid, iprot, oprot):
8814 
    args = getAllAttributesForOrderId_args()
8815 
    args.read(iprot)
8816 
    iprot.readMessageEnd()
8817 
    result = getAllAttributesForOrderId_result()
8818 
    result.success = self._handler.getAllAttributesForOrderId(args.orderId)
8819 
    oprot.writeMessageBegin("getAllAttributesForOrderId", TMessageType.REPLY, seqid)
8820 
    result.write(oprot)
8821 
    oprot.writeMessageEnd()
8822 
    oprot.trans.flush()
5447 anupam.sin 8823 
 
5676 rajveer 8824 
  def process_setOrderAttributes(self, seqid, iprot, oprot):
8825 
    args = setOrderAttributes_args()
8826 
    args.read(iprot)
8827 
    iprot.readMessageEnd()
8828 
    result = setOrderAttributes_result()
8829 
    self._handler.setOrderAttributes(args.orderId, args.attributes)
8830 
    oprot.writeMessageBegin("setOrderAttributes", TMessageType.REPLY, seqid)
8831 
    result.write(oprot)
8832 
    oprot.writeMessageEnd()
8833 
    oprot.trans.flush()
8834 
 
5527 anupam.sin 8835 
  def process_setOrderAttributeForTransaction(self, seqid, iprot, oprot):
8836 
    args = setOrderAttributeForTransaction_args()
8837 
    args.read(iprot)
8838 
    iprot.readMessageEnd()
8839 
    result = setOrderAttributeForTransaction_result()
8840 
    self._handler.setOrderAttributeForTransaction(args.transactionId, args.attribute)
8841 
    oprot.writeMessageBegin("setOrderAttributeForTransaction", TMessageType.REPLY, seqid)
8842 
    result.write(oprot)
8843 
    oprot.writeMessageEnd()
8844 
    oprot.trans.flush()
8845 
 
5553 rajveer 8846 
  def process_getReceivePendingOrders(self, seqid, iprot, oprot):
8847 
    args = getReceivePendingOrders_args()
8848 
    args.read(iprot)
8849 
    iprot.readMessageEnd()
8850 
    result = getReceivePendingOrders_result()
8851 
    result.success = self._handler.getReceivePendingOrders(args.storeId)
8852 
    oprot.writeMessageBegin("getReceivePendingOrders", TMessageType.REPLY, seqid)
8853 
    result.write(oprot)
8854 
    oprot.writeMessageEnd()
8855 
    oprot.trans.flush()
5527 anupam.sin 8856 
 
5553 rajveer 8857 
  def process_getReceivedAtStoreOrders(self, seqid, iprot, oprot):
8858 
    args = getReceivedAtStoreOrders_args()
8859 
    args.read(iprot)
8860 
    iprot.readMessageEnd()
8861 
    result = getReceivedAtStoreOrders_result()
8862 
    result.success = self._handler.getReceivedAtStoreOrders(args.storeId)
8863 
    oprot.writeMessageBegin("getReceivedAtStoreOrders", TMessageType.REPLY, seqid)
8864 
    result.write(oprot)
8865 
    oprot.writeMessageEnd()
8866 
    oprot.trans.flush()
8867 
 
5713 rajveer 8868 
  def process_getOrdersCollectionAtStore(self, seqid, iprot, oprot):
8869 
    args = getOrdersCollectionAtStore_args()
8870 
    args.read(iprot)
8871 
    iprot.readMessageEnd()
8872 
    result = getOrdersCollectionAtStore_result()
8873 
    result.success = self._handler.getOrdersCollectionAtStore(args.storeId, args.fromDate, args.toDate, args.onlyCod)
8874 
    oprot.writeMessageBegin("getOrdersCollectionAtStore", TMessageType.REPLY, seqid)
8875 
    result.write(oprot)
8876 
    oprot.writeMessageEnd()
8877 
    oprot.trans.flush()
8878 
 
5833 rajveer 8879 
  def process_getOrderAttributeValue(self, seqid, iprot, oprot):
8880 
    args = getOrderAttributeValue_args()
8881 
    args.read(iprot)
8882 
    iprot.readMessageEnd()
8883 
    result = getOrderAttributeValue_result()
8884 
    result.success = self._handler.getOrderAttributeValue(args.orderId, args.attributeName)
8885 
    oprot.writeMessageBegin("getOrderAttributeValue", TMessageType.REPLY, seqid)
8886 
    result.write(oprot)
8887 
    oprot.writeMessageEnd()
8888 
    oprot.trans.flush()
8889 
 
6019 rajveer 8890 
  def process_changeJacketNumber(self, seqid, iprot, oprot):
8891 
    args = changeJacketNumber_args()
8892 
    args.read(iprot)
8893 
    iprot.readMessageEnd()
8894 
    result = changeJacketNumber_result()
8895 
    result.success = self._handler.changeJacketNumber(args.orderId, args.jacketNumber)
8896 
    oprot.writeMessageBegin("changeJacketNumber", TMessageType.REPLY, seqid)
8897 
    result.write(oprot)
8898 
    oprot.writeMessageEnd()
8899 
    oprot.trans.flush()
8900 
 
8901 
  def process_markOrderAsRtoInTransit(self, seqid, iprot, oprot):
8902 
    args = markOrderAsRtoInTransit_args()
8903 
    args.read(iprot)
8904 
    iprot.readMessageEnd()
8905 
    result = markOrderAsRtoInTransit_result()
8906 
    result.success = self._handler.markOrderAsRtoInTransit(args.orderId)
8907 
    oprot.writeMessageBegin("markOrderAsRtoInTransit", TMessageType.REPLY, seqid)
8908 
    result.write(oprot)
8909 
    oprot.writeMessageEnd()
8910 
    oprot.trans.flush()
8911 
 
5593 mandeep.dh 8912 
  def process_acceptOrderForItem(self, seqid, iprot, oprot):
8913 
    args = acceptOrderForItem_args()
8914 
    args.read(iprot)
8915 
    iprot.readMessageEnd()
8916 
    result = acceptOrderForItem_result()
8917 
    self._handler.acceptOrderForItem(args.itemId, args.quantity, args.fulfilmentWarehouseId, args.billingWarehouseId)
8918 
    oprot.writeMessageBegin("acceptOrderForItem", TMessageType.REPLY, seqid)
8919 
    result.write(oprot)
8920 
    oprot.writeMessageEnd()
8921 
    oprot.trans.flush()
5553 rajveer 8922 
 
6000 mandeep.dh 8923 
  def process_createRechargeOrder(self, seqid, iprot, oprot):
8924 
    args = createRechargeOrder_args()
8925 
    args.read(iprot)
8926 
    iprot.readMessageEnd()
8927 
    result = createRechargeOrder_result()
8928 
    try:
8929 
      result.success = self._handler.createRechargeOrder(args.rechargeOrder)
8930 
    except TransactionServiceException, ex:
8931 
      result.ex = ex
8932 
    oprot.writeMessageBegin("createRechargeOrder", TMessageType.REPLY, seqid)
8933 
    result.write(oprot)
8934 
    oprot.writeMessageEnd()
8935 
    oprot.trans.flush()
5593 mandeep.dh 8936 
 
6031 rajveer 8937 
  def process_getRechargeOrder(self, seqid, iprot, oprot):
8938 
    args = getRechargeOrder_args()
8939 
    args.read(iprot)
8940 
    iprot.readMessageEnd()
8941 
    result = getRechargeOrder_result()
8942 
    try:
8943 
      result.success = self._handler.getRechargeOrder(args.rechargeRrderId)
8944 
    except TransactionServiceException, ex:
8945 
      result.ex = ex
8946 
    oprot.writeMessageBegin("getRechargeOrder", TMessageType.REPLY, seqid)
8947 
    result.write(oprot)
8948 
    oprot.writeMessageEnd()
8949 
    oprot.trans.flush()
8950 
 
8951 
  def process_getRechargeOrders(self, seqid, iprot, oprot):
8952 
    args = getRechargeOrders_args()
8953 
    args.read(iprot)
8954 
    iprot.readMessageEnd()
8955 
    result = getRechargeOrders_result()
8956 
    result.success = self._handler.getRechargeOrders(args.userId)
8957 
    oprot.writeMessageBegin("getRechargeOrders", TMessageType.REPLY, seqid)
8958 
    result.write(oprot)
8959 
    oprot.writeMessageEnd()
8960 
    oprot.trans.flush()
8961 
 
6000 mandeep.dh 8962 
  def process_updateRechargeOrderStatus(self, seqid, iprot, oprot):
8963 
    args = updateRechargeOrderStatus_args()
8964 
    args.read(iprot)
8965 
    iprot.readMessageEnd()
8966 
    result = updateRechargeOrderStatus_result()
8967 
    try:
6031 rajveer 8968 
      result.success = self._handler.updateRechargeOrderStatus(args.rechargeOrderId, args.rechargeOrderStatus)
6000 mandeep.dh 8969 
    except TransactionServiceException, ex:
8970 
      result.ex = ex
8971 
    oprot.writeMessageBegin("updateRechargeOrderStatus", TMessageType.REPLY, seqid)
8972 
    result.write(oprot)
8973 
    oprot.writeMessageEnd()
8974 
    oprot.trans.flush()
8975 
 
8976 
  def process_activateRechargeTxn(self, seqid, iprot, oprot):
8977 
    args = activateRechargeTxn_args()
8978 
    args.read(iprot)
8979 
    iprot.readMessageEnd()
8980 
    result = activateRechargeTxn_result()
8981 
    try:
6031 rajveer 8982 
      result.success = self._handler.activateRechargeTxn(args.rechargeOrderId)
6000 mandeep.dh 8983 
    except TransactionServiceException, ex:
8984 
      result.ex = ex
8985 
    oprot.writeMessageBegin("activateRechargeTxn", TMessageType.REPLY, seqid)
8986 
    result.write(oprot)
8987 
    oprot.writeMessageEnd()
8988 
    oprot.trans.flush()
8989 
 
6031 rajveer 8990 
  def process_getUserWallet(self, seqid, iprot, oprot):
8991 
    args = getUserWallet_args()
6000 mandeep.dh 8992 
    args.read(iprot)
8993 
    iprot.readMessageEnd()
6031 rajveer 8994 
    result = getUserWallet_result()
8995 
    result.success = self._handler.getUserWallet(args.userId)
8996 
    oprot.writeMessageBegin("getUserWallet", TMessageType.REPLY, seqid)
6000 mandeep.dh 8997 
    result.write(oprot)
8998 
    oprot.writeMessageEnd()
8999 
    oprot.trans.flush()
9000 
 
6031 rajveer 9001 
  def process_getUserWalletHistory(self, seqid, iprot, oprot):
9002 
    args = getUserWalletHistory_args()
6000 mandeep.dh 9003 
    args.read(iprot)
9004 
    iprot.readMessageEnd()
6031 rajveer 9005 
    result = getUserWalletHistory_result()
9006 
    result.success = self._handler.getUserWalletHistory(args.userId)
9007 
    oprot.writeMessageBegin("getUserWalletHistory", TMessageType.REPLY, seqid)
6000 mandeep.dh 9008 
    result.write(oprot)
9009 
    oprot.writeMessageEnd()
9010 
    oprot.trans.flush()
9011 
 
6050 anupam.sin 9012 
  def process_getRechargeOrdersForTransaction(self, seqid, iprot, oprot):
9013 
    args = getRechargeOrdersForTransaction_args()
9014 
    args.read(iprot)
9015 
    iprot.readMessageEnd()
9016 
    result = getRechargeOrdersForTransaction_result()
9017 
    try:
9018 
      result.success = self._handler.getRechargeOrdersForTransaction(args.txnId)
9019 
    except TransactionServiceException, ex:
9020 
      result.ex = ex
9021 
    oprot.writeMessageBegin("getRechargeOrdersForTransaction", TMessageType.REPLY, seqid)
9022 
    result.write(oprot)
9023 
    oprot.writeMessageEnd()
9024 
    oprot.trans.flush()
9025 
 
6048 rajveer 9026 
  def process_getServiceProviders(self, seqid, iprot, oprot):
9027 
    args = getServiceProviders_args()
9028 
    args.read(iprot)
9029 
    iprot.readMessageEnd()
9030 
    result = getServiceProviders_result()
6206 rajveer 9031 
    result.success = self._handler.getServiceProviders(args.rechargeType, args.onlyActive)
6048 rajveer 9032 
    oprot.writeMessageBegin("getServiceProviders", TMessageType.REPLY, seqid)
9033 
    result.write(oprot)
9034 
    oprot.writeMessageEnd()
9035 
    oprot.trans.flush()
6000 mandeep.dh 9036 
 
6048 rajveer 9037 
  def process_getServiceProviderForDevice(self, seqid, iprot, oprot):
9038 
    args = getServiceProviderForDevice_args()
9039 
    args.read(iprot)
9040 
    iprot.readMessageEnd()
9041 
    result = getServiceProviderForDevice_result()
6049 rajveer 9042 
    result.success = self._handler.getServiceProviderForDevice(args.rechargeType, args.deviceNumber)
6048 rajveer 9043 
    oprot.writeMessageBegin("getServiceProviderForDevice", TMessageType.REPLY, seqid)
9044 
    result.write(oprot)
9045 
    oprot.writeMessageEnd()
9046 
    oprot.trans.flush()
9047 
 
6269 rajveer 9048 
  def process_validateRecharge(self, seqid, iprot, oprot):
9049 
    args = validateRecharge_args()
9050 
    args.read(iprot)
9051 
    iprot.readMessageEnd()
9052 
    result = validateRecharge_result()
6591 anupam.sin 9053 
    result.success = self._handler.validateRecharge(args.rechargeType, args.deviceNumber, args.userSelectedProviderId, args.clientAddress)
6269 rajveer 9054 
    oprot.writeMessageBegin("validateRecharge", TMessageType.REPLY, seqid)
9055 
    result.write(oprot)
9056 
    oprot.writeMessageEnd()
9057 
    oprot.trans.flush()
9058 
 
6094 rajveer 9059 
  def process_getRechargeOrdersForDevice(self, seqid, iprot, oprot):
9060 
    args = getRechargeOrdersForDevice_args()
9061 
    args.read(iprot)
9062 
    iprot.readMessageEnd()
9063 
    result = getRechargeOrdersForDevice_result()
9064 
    result.success = self._handler.getRechargeOrdersForDevice(args.deviceNumber)
9065 
    oprot.writeMessageBegin("getRechargeOrdersForDevice", TMessageType.REPLY, seqid)
9066 
    result.write(oprot)
9067 
    oprot.writeMessageEnd()
9068 
    oprot.trans.flush()
6048 rajveer 9069 
 
6094 rajveer 9070 
  def process_addAmountToWallet(self, seqid, iprot, oprot):
9071 
    args = addAmountToWallet_args()
9072 
    args.read(iprot)
9073 
    iprot.readMessageEnd()
9074 
    result = addAmountToWallet_result()
9075 
    self._handler.addAmountToWallet(args.userId, args.orderId, args.amount)
9076 
    oprot.writeMessageBegin("addAmountToWallet", TMessageType.REPLY, seqid)
9077 
    result.write(oprot)
9078 
    oprot.writeMessageEnd()
9079 
    oprot.trans.flush()
9080 
 
6188 rajveer 9081 
  def process_getRechargeStatistics(self, seqid, iprot, oprot):
9082 
    args = getRechargeStatistics_args()
9083 
    args.read(iprot)
9084 
    iprot.readMessageEnd()
9085 
    result = getRechargeStatistics_result()
9086 
    result.success = self._handler.getRechargeStatistics()
9087 
    oprot.writeMessageBegin("getRechargeStatistics", TMessageType.REPLY, seqid)
9088 
    result.write(oprot)
9089 
    oprot.writeMessageEnd()
9090 
    oprot.trans.flush()
9091 
 
6154 rajveer 9092 
  def process_getRechargeOrdersForStatus(self, seqid, iprot, oprot):
9093 
    args = getRechargeOrdersForStatus_args()
9094 
    args.read(iprot)
9095 
    iprot.readMessageEnd()
9096 
    result = getRechargeOrdersForStatus_result()
9097 
    result.success = self._handler.getRechargeOrdersForStatus(args.status)
9098 
    oprot.writeMessageBegin("getRechargeOrdersForStatus", TMessageType.REPLY, seqid)
9099 
    result.write(oprot)
9100 
    oprot.writeMessageEnd()
9101 
    oprot.trans.flush()
6094 rajveer 9102 
 
6159 rajveer 9103 
  def process_getPlansForOperator(self, seqid, iprot, oprot):
9104 
    args = getPlansForOperator_args()
9105 
    args.read(iprot)
9106 
    iprot.readMessageEnd()
9107 
    result = getPlansForOperator_result()
9108 
    result.success = self._handler.getPlansForOperator(args.operatorId)
9109 
    oprot.writeMessageBegin("getPlansForOperator", TMessageType.REPLY, seqid)
9110 
    result.write(oprot)
9111 
    oprot.writeMessageEnd()
9112 
    oprot.trans.flush()
6154 rajveer 9113 
 
6289 anupam.sin 9114 
  def process_getRechargeDenominations(self, seqid, iprot, oprot):
9115 
    args = getRechargeDenominations_args()
9116 
    args.read(iprot)
9117 
    iprot.readMessageEnd()
9118 
    result = getRechargeDenominations_result()
9119 
    try:
6307 anupam.sin 9120 
      result.success = self._handler.getRechargeDenominations(args.operatorId, args.circleCode, args.denominationType)
6289 anupam.sin 9121 
    except TransactionServiceException, ex:
9122 
      result.ex = ex
9123 
    oprot.writeMessageBegin("getRechargeDenominations", TMessageType.REPLY, seqid)
9124 
    result.write(oprot)
9125 
    oprot.writeMessageEnd()
9126 
    oprot.trans.flush()
6159 rajveer 9127 
 
6371 rajveer 9128 
  def process_updateAvailabilityStatus(self, seqid, iprot, oprot):
9129 
    args = updateAvailabilityStatus_args()
9130 
    args.read(iprot)
9131 
    iprot.readMessageEnd()
9132 
    result = updateAvailabilityStatus_result()
9133 
    self._handler.updateAvailabilityStatus(args.operatorId, args.circleId, args.isAvailable)
9134 
    oprot.writeMessageBegin("updateAvailabilityStatus", TMessageType.REPLY, seqid)
9135 
    result.write(oprot)
9136 
    oprot.writeMessageEnd()
9137 
    oprot.trans.flush()
6289 anupam.sin 9138 
 
6389 rajveer 9139 
  def process_getAvailableEmiSchemes(self, seqid, iprot, oprot):
9140 
    args = getAvailableEmiSchemes_args()
9141 
    args.read(iprot)
9142 
    iprot.readMessageEnd()
9143 
    result = getAvailableEmiSchemes_result()
9144 
    result.success = self._handler.getAvailableEmiSchemes()
9145 
    oprot.writeMessageBegin("getAvailableEmiSchemes", TMessageType.REPLY, seqid)
9146 
    result.write(oprot)
9147 
    oprot.writeMessageEnd()
9148 
    oprot.trans.flush()
6371 rajveer 9149 
 
6389 rajveer 9150 
  def process_getMiscCharges(self, seqid, iprot, oprot):
9151 
    args = getMiscCharges_args()
9152 
    args.read(iprot)
9153 
    iprot.readMessageEnd()
9154 
    result = getMiscCharges_result()
9155 
    result.success = self._handler.getMiscCharges(args.transactionId)
9156 
    oprot.writeMessageBegin("getMiscCharges", TMessageType.REPLY, seqid)
9157 
    result.write(oprot)
9158 
    oprot.writeMessageEnd()
9159 
    oprot.trans.flush()
9160 
 
6507 anupam.sin 9161 
  def process_refundRechargeOrder(self, seqid, iprot, oprot):
9162 
    args = refundRechargeOrder_args()
9163 
    args.read(iprot)
9164 
    iprot.readMessageEnd()
9165 
    result = refundRechargeOrder_result()
9166 
    try:
9167 
      result.success = self._handler.refundRechargeOrder(args.rechargeOrderId)
9168 
    except TransactionServiceException, ex:
9169 
      result.ex = ex
9170 
    oprot.writeMessageBegin("refundRechargeOrder", TMessageType.REPLY, seqid)
9171 
    result.write(oprot)
9172 
    oprot.writeMessageEnd()
9173 
    oprot.trans.flush()
6389 rajveer 9174 
 
6821 amar.kumar 9175 
  def process_getPhysicalOrders(self, seqid, iprot, oprot):
9176 
    args = getPhysicalOrders_args()
9177 
    args.read(iprot)
9178 
    iprot.readMessageEnd()
9179 
    result = getPhysicalOrders_result()
9180 
    result.success = self._handler.getPhysicalOrders(args.fromDate, args.toDate)
9181 
    oprot.writeMessageBegin("getPhysicalOrders", TMessageType.REPLY, seqid)
9182 
    result.write(oprot)
9183 
    oprot.writeMessageEnd()
9184 
    oprot.trans.flush()
6507 anupam.sin 9185 
 
6906 rajveer 9186 
  def process_getDocument(self, seqid, iprot, oprot):
9187 
    args = getDocument_args()
9188 
    args.read(iprot)
9189 
    iprot.readMessageEnd()
9190 
    result = getDocument_result()
9191 
    result.success = self._handler.getDocument(args.docType, args.docSource)
9192 
    oprot.writeMessageBegin("getDocument", TMessageType.REPLY, seqid)
9193 
    result.write(oprot)
9194 
    oprot.writeMessageEnd()
9195 
    oprot.trans.flush()
6821 amar.kumar 9196 
 
6985 anupam.sin 9197 
  def process_changeShippingAddress(self, seqid, iprot, oprot):
9198 
    args = changeShippingAddress_args()
9199 
    args.read(iprot)
9200 
    iprot.readMessageEnd()
9201 
    result = changeShippingAddress_result()
9202 
    result.success = self._handler.changeShippingAddress(args.orderId, args.line1, args.line2, args.city, args.state, args.pin)
9203 
    oprot.writeMessageBegin("changeShippingAddress", TMessageType.REPLY, seqid)
9204 
    result.write(oprot)
9205 
    oprot.writeMessageEnd()
9206 
    oprot.trans.flush()
6906 rajveer 9207 
 
6988 rajveer 9208 
  def process_retrieveInvoice(self, seqid, iprot, oprot):
9209 
    args = retrieveInvoice_args()
9210 
    args.read(iprot)
9211 
    iprot.readMessageEnd()
9212 
    result = retrieveInvoice_result()
7075 rajveer 9213 
    result.success = self._handler.retrieveInvoice(args.orderId, args.userId)
6988 rajveer 9214 
    oprot.writeMessageBegin("retrieveInvoice", TMessageType.REPLY, seqid)
9215 
    result.write(oprot)
9216 
    oprot.writeMessageEnd()
9217 
    oprot.trans.flush()
6985 anupam.sin 9218 
 
7026 rajveer 9219 
  def process_receiveUpdatesForRedExpress(self, seqid, iprot, oprot):
9220 
    args = receiveUpdatesForRedExpress_args()
9221 
    args.read(iprot)
9222 
    iprot.readMessageEnd()
9223 
    result = receiveUpdatesForRedExpress_result()
9224 
    result.success = self._handler.receiveUpdatesForRedExpress(args.awbNumber)
9225 
    oprot.writeMessageBegin("receiveUpdatesForRedExpress", TMessageType.REPLY, seqid)
9226 
    result.write(oprot)
9227 
    oprot.writeMessageEnd()
9228 
    oprot.trans.flush()
6988 rajveer 9229 
 
7073 anupam.sin 9230 
  def process_createRechargeTransaction(self, seqid, iprot, oprot):
9231 
    args = createRechargeTransaction_args()
9232 
    args.read(iprot)
9233 
    iprot.readMessageEnd()
9234 
    result = createRechargeTransaction_result()
9235 
    result.success = self._handler.createRechargeTransaction(args.thriftRechargeTransaction)
9236 
    oprot.writeMessageBegin("createRechargeTransaction", TMessageType.REPLY, seqid)
9237 
    result.write(oprot)
9238 
    oprot.writeMessageEnd()
9239 
    oprot.trans.flush()
7026 rajveer 9240 
 
7085 rajveer 9241 
  def process_getRechargeTransactions(self, seqid, iprot, oprot):
9242 
    args = getRechargeTransactions_args()
9243 
    args.read(iprot)
9244 
    iprot.readMessageEnd()
9245 
    result = getRechargeTransactions_result()
9246 
    result.success = self._handler.getRechargeTransactions(args.storeId)
9247 
    oprot.writeMessageBegin("getRechargeTransactions", TMessageType.REPLY, seqid)
9248 
    result.write(oprot)
9249 
    oprot.writeMessageEnd()
9250 
    oprot.trans.flush()
9251 
 
7151 amit.gupta 9252 
  def process_getRechargeTrans(self, seqid, iprot, oprot):
9253 
    args = getRechargeTrans_args()
9254 
    args.read(iprot)
9255 
    iprot.readMessageEnd()
9256 
    result = getRechargeTrans_result()
9257 
    result.success = self._handler.getRechargeTrans(args.storeId, args.startDate, args.endDate, args.status)
9258 
    oprot.writeMessageBegin("getRechargeTrans", TMessageType.REPLY, seqid)
9259 
    result.write(oprot)
9260 
    oprot.writeMessageEnd()
9261 
    oprot.trans.flush()
9262 
 
7080 anupam.sin 9263 
  def process_getRechargeTransaction(self, seqid, iprot, oprot):
9264 
    args = getRechargeTransaction_args()
9265 
    args.read(iprot)
9266 
    iprot.readMessageEnd()
9267 
    result = getRechargeTransaction_result()
9268 
    result.success = self._handler.getRechargeTransaction(args.rechargeId)
9269 
    oprot.writeMessageBegin("getRechargeTransaction", TMessageType.REPLY, seqid)
9270 
    result.write(oprot)
9271 
    oprot.writeMessageEnd()
9272 
    oprot.trans.flush()
7073 anupam.sin 9273 
 
7080 anupam.sin 9274 
  def process_getFRCs(self, seqid, iprot, oprot):
9275 
    args = getFRCs_args()
9276 
    args.read(iprot)
9277 
    iprot.readMessageEnd()
9278 
    result = getFRCs_result()
9279 
    result.success = self._handler.getFRCs(args.circleId, args.operatorId)
9280 
    oprot.writeMessageBegin("getFRCs", TMessageType.REPLY, seqid)
9281 
    result.write(oprot)
9282 
    oprot.writeMessageEnd()
9283 
    oprot.trans.flush()
9284 
 
7096 anupam.sin 9285 
  def process_getHotspotStore(self, seqid, iprot, oprot):
9286 
    args = getHotspotStore_args()
9287 
    args.read(iprot)
9288 
    iprot.readMessageEnd()
9289 
    result = getHotspotStore_result()
9290 
    result.success = self._handler.getHotspotStore(args.id, args.hotspotid)
9291 
    oprot.writeMessageBegin("getHotspotStore", TMessageType.REPLY, seqid)
9292 
    result.write(oprot)
9293 
    oprot.writeMessageEnd()
9294 
    oprot.trans.flush()
7080 anupam.sin 9295 
 
7096 anupam.sin 9296 
  def process_getTelecomCircle(self, seqid, iprot, oprot):
9297 
    args = getTelecomCircle_args()
9298 
    args.read(iprot)
9299 
    iprot.readMessageEnd()
9300 
    result = getTelecomCircle_result()
9301 
    result.success = self._handler.getTelecomCircle(args.id, args.code)
9302 
    oprot.writeMessageBegin("getTelecomCircle", TMessageType.REPLY, seqid)
9303 
    result.write(oprot)
9304 
    oprot.writeMessageEnd()
9305 
    oprot.trans.flush()
9306 
 
7109 anupam.sin 9307 
  def process_retrieveHotspotRechargeInvoice(self, seqid, iprot, oprot):
9308 
    args = retrieveHotspotRechargeInvoice_args()
9309 
    args.read(iprot)
9310 
    iprot.readMessageEnd()
9311 
    result = retrieveHotspotRechargeInvoice_result()
9312 
    result.success = self._handler.retrieveHotspotRechargeInvoice(args.rechargeId)
9313 
    oprot.writeMessageBegin("retrieveHotspotRechargeInvoice", TMessageType.REPLY, seqid)
9314 
    result.write(oprot)
9315 
    oprot.writeMessageEnd()
9316 
    oprot.trans.flush()
7096 anupam.sin 9317 
 
7109 anupam.sin 9318 
 
94 ashish 9319 
# HELPER FUNCTIONS AND STRUCTURES
9320 
 
9321 
class createTransaction_args:
9322 
  """
9323 
  Attributes:
9324 
   - transaction
9325 
  """
9326 
 
9327 
  thrift_spec = (
9328 
    None, # 0
9329 
    (1, TType.STRUCT, 'transaction', (Transaction, Transaction.thrift_spec), None, ), # 1
9330 
  )
9331 
 
9332 
  def __init__(self, transaction=None,):
9333 
    self.transaction = transaction
9334 
 
9335 
  def read(self, iprot):
9336 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9337 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9338 
      return
9339 
    iprot.readStructBegin()
9340 
    while True:
9341 
      (fname, ftype, fid) = iprot.readFieldBegin()
9342 
      if ftype == TType.STOP:
9343 
        break
9344 
      if fid == 1:
9345 
        if ftype == TType.STRUCT:
9346 
          self.transaction = Transaction()
9347 
          self.transaction.read(iprot)
9348 
        else:
9349 
          iprot.skip(ftype)
9350 
      else:
9351 
        iprot.skip(ftype)
9352 
      iprot.readFieldEnd()
9353 
    iprot.readStructEnd()
9354 
 
9355 
  def write(self, oprot):
9356 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9357 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9358 
      return
9359 
    oprot.writeStructBegin('createTransaction_args')
3431 rajveer 9360 
    if self.transaction is not None:
94 ashish 9361 
      oprot.writeFieldBegin('transaction', TType.STRUCT, 1)
9362 
      self.transaction.write(oprot)
9363 
      oprot.writeFieldEnd()
9364 
    oprot.writeFieldStop()
9365 
    oprot.writeStructEnd()
9366 
 
3431 rajveer 9367 
  def validate(self):
9368 
    return
9369 
 
9370 
 
94 ashish 9371 
  def __repr__(self):
9372 
    L = ['%s=%r' % (key, value)
9373 
      for key, value in self.__dict__.iteritems()]
9374 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9375 
 
9376 
  def __eq__(self, other):
9377 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9378 
 
9379 
  def __ne__(self, other):
9380 
    return not (self == other)
9381 
 
9382 
class createTransaction_result:
9383 
  """
9384 
  Attributes:
132 ashish 9385 
   - success
94 ashish 9386 
   - ex
9387 
  """
9388 
 
9389 
  thrift_spec = (
132 ashish 9390 
    (0, TType.I64, 'success', None, None, ), # 0
94 ashish 9391 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
9392 
  )
9393 
 
132 ashish 9394 
  def __init__(self, success=None, ex=None,):
9395 
    self.success = success
94 ashish 9396 
    self.ex = ex
9397 
 
9398 
  def read(self, iprot):
9399 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9400 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9401 
      return
9402 
    iprot.readStructBegin()
9403 
    while True:
9404 
      (fname, ftype, fid) = iprot.readFieldBegin()
9405 
      if ftype == TType.STOP:
9406 
        break
132 ashish 9407 
      if fid == 0:
9408 
        if ftype == TType.I64:
9409 
          self.success = iprot.readI64();
9410 
        else:
9411 
          iprot.skip(ftype)
9412 
      elif fid == 1:
94 ashish 9413 
        if ftype == TType.STRUCT:
9414 
          self.ex = TransactionServiceException()
9415 
          self.ex.read(iprot)
9416 
        else:
9417 
          iprot.skip(ftype)
9418 
      else:
9419 
        iprot.skip(ftype)
9420 
      iprot.readFieldEnd()
9421 
    iprot.readStructEnd()
9422 
 
9423 
  def write(self, oprot):
9424 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9425 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9426 
      return
9427 
    oprot.writeStructBegin('createTransaction_result')
3431 rajveer 9428 
    if self.success is not None:
132 ashish 9429 
      oprot.writeFieldBegin('success', TType.I64, 0)
9430 
      oprot.writeI64(self.success)
9431 
      oprot.writeFieldEnd()
3431 rajveer 9432 
    if self.ex is not None:
94 ashish 9433 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9434 
      self.ex.write(oprot)
9435 
      oprot.writeFieldEnd()
9436 
    oprot.writeFieldStop()
9437 
    oprot.writeStructEnd()
9438 
 
3431 rajveer 9439 
  def validate(self):
9440 
    return
9441 
 
9442 
 
94 ashish 9443 
  def __repr__(self):
9444 
    L = ['%s=%r' % (key, value)
9445 
      for key, value in self.__dict__.iteritems()]
9446 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9447 
 
9448 
  def __eq__(self, other):
9449 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9450 
 
9451 
  def __ne__(self, other):
9452 
    return not (self == other)
9453 
 
9454 
class getTransaction_args:
9455 
  """
9456 
  Attributes:
9457 
   - id
9458 
  """
9459 
 
9460 
  thrift_spec = (
9461 
    None, # 0
9462 
    (1, TType.I64, 'id', None, None, ), # 1
9463 
  )
9464 
 
9465 
  def __init__(self, id=None,):
9466 
    self.id = id
9467 
 
9468 
  def read(self, iprot):
9469 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9470 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9471 
      return
9472 
    iprot.readStructBegin()
9473 
    while True:
9474 
      (fname, ftype, fid) = iprot.readFieldBegin()
9475 
      if ftype == TType.STOP:
9476 
        break
9477 
      if fid == 1:
9478 
        if ftype == TType.I64:
9479 
          self.id = iprot.readI64();
9480 
        else:
9481 
          iprot.skip(ftype)
9482 
      else:
9483 
        iprot.skip(ftype)
9484 
      iprot.readFieldEnd()
9485 
    iprot.readStructEnd()
9486 
 
9487 
  def write(self, oprot):
9488 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9489 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9490 
      return
9491 
    oprot.writeStructBegin('getTransaction_args')
3431 rajveer 9492 
    if self.id is not None:
94 ashish 9493 
      oprot.writeFieldBegin('id', TType.I64, 1)
9494 
      oprot.writeI64(self.id)
9495 
      oprot.writeFieldEnd()
9496 
    oprot.writeFieldStop()
9497 
    oprot.writeStructEnd()
9498 
 
3431 rajveer 9499 
  def validate(self):
9500 
    return
9501 
 
9502 
 
94 ashish 9503 
  def __repr__(self):
9504 
    L = ['%s=%r' % (key, value)
9505 
      for key, value in self.__dict__.iteritems()]
9506 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9507 
 
9508 
  def __eq__(self, other):
9509 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9510 
 
9511 
  def __ne__(self, other):
9512 
    return not (self == other)
9513 
 
9514 
class getTransaction_result:
9515 
  """
9516 
  Attributes:
9517 
   - success
9518 
   - ex
9519 
  """
9520 
 
9521 
  thrift_spec = (
9522 
    (0, TType.STRUCT, 'success', (Transaction, Transaction.thrift_spec), None, ), # 0
9523 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
9524 
  )
9525 
 
9526 
  def __init__(self, success=None, ex=None,):
9527 
    self.success = success
9528 
    self.ex = ex
9529 
 
9530 
  def read(self, iprot):
9531 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9532 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9533 
      return
9534 
    iprot.readStructBegin()
9535 
    while True:
9536 
      (fname, ftype, fid) = iprot.readFieldBegin()
9537 
      if ftype == TType.STOP:
9538 
        break
9539 
      if fid == 0:
9540 
        if ftype == TType.STRUCT:
9541 
          self.success = Transaction()
9542 
          self.success.read(iprot)
9543 
        else:
9544 
          iprot.skip(ftype)
9545 
      elif fid == 1:
9546 
        if ftype == TType.STRUCT:
9547 
          self.ex = TransactionServiceException()
9548 
          self.ex.read(iprot)
9549 
        else:
9550 
          iprot.skip(ftype)
9551 
      else:
9552 
        iprot.skip(ftype)
9553 
      iprot.readFieldEnd()
9554 
    iprot.readStructEnd()
9555 
 
9556 
  def write(self, oprot):
9557 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9558 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9559 
      return
9560 
    oprot.writeStructBegin('getTransaction_result')
3431 rajveer 9561 
    if self.success is not None:
94 ashish 9562 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
9563 
      self.success.write(oprot)
9564 
      oprot.writeFieldEnd()
3431 rajveer 9565 
    if self.ex is not None:
94 ashish 9566 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9567 
      self.ex.write(oprot)
9568 
      oprot.writeFieldEnd()
9569 
    oprot.writeFieldStop()
9570 
    oprot.writeStructEnd()
9571 
 
3431 rajveer 9572 
  def validate(self):
9573 
    return
9574 
 
9575 
 
94 ashish 9576 
  def __repr__(self):
9577 
    L = ['%s=%r' % (key, value)
9578 
      for key, value in self.__dict__.iteritems()]
9579 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9580 
 
9581 
  def __eq__(self, other):
9582 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9583 
 
9584 
  def __ne__(self, other):
9585 
    return not (self == other)
9586 
 
9587 
class getTransactionsForCustomer_args:
9588 
  """
9589 
  Attributes:
9590 
   - customerId
9591 
   - from_date
9592 
   - to_date
9593 
   - status
9594 
  """
9595 
 
9596 
  thrift_spec = (
9597 
    None, # 0
9598 
    (1, TType.I64, 'customerId', None, None, ), # 1
9599 
    (2, TType.I64, 'from_date', None, None, ), # 2
9600 
    (3, TType.I64, 'to_date', None, None, ), # 3
9601 
    (4, TType.I32, 'status', None, None, ), # 4
9602 
  )
9603 
 
9604 
  def __init__(self, customerId=None, from_date=None, to_date=None, status=None,):
9605 
    self.customerId = customerId
9606 
    self.from_date = from_date
9607 
    self.to_date = to_date
9608 
    self.status = status
9609 
 
9610 
  def read(self, iprot):
9611 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9612 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9613 
      return
9614 
    iprot.readStructBegin()
9615 
    while True:
9616 
      (fname, ftype, fid) = iprot.readFieldBegin()
9617 
      if ftype == TType.STOP:
9618 
        break
9619 
      if fid == 1:
9620 
        if ftype == TType.I64:
9621 
          self.customerId = iprot.readI64();
9622 
        else:
9623 
          iprot.skip(ftype)
9624 
      elif fid == 2:
9625 
        if ftype == TType.I64:
9626 
          self.from_date = iprot.readI64();
9627 
        else:
9628 
          iprot.skip(ftype)
9629 
      elif fid == 3:
9630 
        if ftype == TType.I64:
9631 
          self.to_date = iprot.readI64();
9632 
        else:
9633 
          iprot.skip(ftype)
9634 
      elif fid == 4:
9635 
        if ftype == TType.I32:
9636 
          self.status = iprot.readI32();
9637 
        else:
9638 
          iprot.skip(ftype)
9639 
      else:
9640 
        iprot.skip(ftype)
9641 
      iprot.readFieldEnd()
9642 
    iprot.readStructEnd()
9643 
 
9644 
  def write(self, oprot):
9645 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9646 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9647 
      return
9648 
    oprot.writeStructBegin('getTransactionsForCustomer_args')
3431 rajveer 9649 
    if self.customerId is not None:
94 ashish 9650 
      oprot.writeFieldBegin('customerId', TType.I64, 1)
9651 
      oprot.writeI64(self.customerId)
9652 
      oprot.writeFieldEnd()
3431 rajveer 9653 
    if self.from_date is not None:
94 ashish 9654 
      oprot.writeFieldBegin('from_date', TType.I64, 2)
9655 
      oprot.writeI64(self.from_date)
9656 
      oprot.writeFieldEnd()
3431 rajveer 9657 
    if self.to_date is not None:
94 ashish 9658 
      oprot.writeFieldBegin('to_date', TType.I64, 3)
9659 
      oprot.writeI64(self.to_date)
9660 
      oprot.writeFieldEnd()
3431 rajveer 9661 
    if self.status is not None:
94 ashish 9662 
      oprot.writeFieldBegin('status', TType.I32, 4)
9663 
      oprot.writeI32(self.status)
9664 
      oprot.writeFieldEnd()
9665 
    oprot.writeFieldStop()
9666 
    oprot.writeStructEnd()
9667 
 
3431 rajveer 9668 
  def validate(self):
9669 
    return
9670 
 
9671 
 
94 ashish 9672 
  def __repr__(self):
9673 
    L = ['%s=%r' % (key, value)
9674 
      for key, value in self.__dict__.iteritems()]
9675 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9676 
 
9677 
  def __eq__(self, other):
9678 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9679 
 
9680 
  def __ne__(self, other):
9681 
    return not (self == other)
9682 
 
9683 
class getTransactionsForCustomer_result:
9684 
  """
9685 
  Attributes:
9686 
   - success
9687 
   - ex
9688 
  """
9689 
 
9690 
  thrift_spec = (
9691 
    (0, TType.LIST, 'success', (TType.STRUCT,(Transaction, Transaction.thrift_spec)), None, ), # 0
9692 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
9693 
  )
9694 
 
9695 
  def __init__(self, success=None, ex=None,):
9696 
    self.success = success
9697 
    self.ex = ex
9698 
 
9699 
  def read(self, iprot):
9700 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9701 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9702 
      return
9703 
    iprot.readStructBegin()
9704 
    while True:
9705 
      (fname, ftype, fid) = iprot.readFieldBegin()
9706 
      if ftype == TType.STOP:
9707 
        break
9708 
      if fid == 0:
9709 
        if ftype == TType.LIST:
9710 
          self.success = []
6188 rajveer 9711 
          (_etype109, _size106) = iprot.readListBegin()
9712 
          for _i110 in xrange(_size106):
9713 
            _elem111 = Transaction()
9714 
            _elem111.read(iprot)
9715 
            self.success.append(_elem111)
94 ashish 9716 
          iprot.readListEnd()
9717 
        else:
9718 
          iprot.skip(ftype)
9719 
      elif fid == 1:
9720 
        if ftype == TType.STRUCT:
9721 
          self.ex = TransactionServiceException()
9722 
          self.ex.read(iprot)
9723 
        else:
9724 
          iprot.skip(ftype)
9725 
      else:
9726 
        iprot.skip(ftype)
9727 
      iprot.readFieldEnd()
9728 
    iprot.readStructEnd()
9729 
 
9730 
  def write(self, oprot):
9731 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9732 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9733 
      return
9734 
    oprot.writeStructBegin('getTransactionsForCustomer_result')
3431 rajveer 9735 
    if self.success is not None:
94 ashish 9736 
      oprot.writeFieldBegin('success', TType.LIST, 0)
9737 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 9738 
      for iter112 in self.success:
9739 
        iter112.write(oprot)
94 ashish 9740 
      oprot.writeListEnd()
9741 
      oprot.writeFieldEnd()
3431 rajveer 9742 
    if self.ex is not None:
94 ashish 9743 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9744 
      self.ex.write(oprot)
9745 
      oprot.writeFieldEnd()
9746 
    oprot.writeFieldStop()
9747 
    oprot.writeStructEnd()
9748 
 
3431 rajveer 9749 
  def validate(self):
9750 
    return
9751 
 
9752 
 
94 ashish 9753 
  def __repr__(self):
9754 
    L = ['%s=%r' % (key, value)
9755 
      for key, value in self.__dict__.iteritems()]
9756 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9757 
 
9758 
  def __eq__(self, other):
9759 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9760 
 
9761 
  def __ne__(self, other):
9762 
    return not (self == other)
9763 
 
132 ashish 9764 
class getTransactionsForShoppingCartId_args:
9765 
  """
9766 
  Attributes:
9767 
   - shoppingCartId
9768 
  """
9769 
 
9770 
  thrift_spec = (
9771 
    None, # 0
9772 
    (1, TType.I64, 'shoppingCartId', None, None, ), # 1
9773 
  )
9774 
 
9775 
  def __init__(self, shoppingCartId=None,):
9776 
    self.shoppingCartId = shoppingCartId
9777 
 
9778 
  def read(self, iprot):
9779 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9780 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9781 
      return
9782 
    iprot.readStructBegin()
9783 
    while True:
9784 
      (fname, ftype, fid) = iprot.readFieldBegin()
9785 
      if ftype == TType.STOP:
9786 
        break
9787 
      if fid == 1:
9788 
        if ftype == TType.I64:
9789 
          self.shoppingCartId = iprot.readI64();
9790 
        else:
9791 
          iprot.skip(ftype)
9792 
      else:
9793 
        iprot.skip(ftype)
9794 
      iprot.readFieldEnd()
9795 
    iprot.readStructEnd()
9796 
 
9797 
  def write(self, oprot):
9798 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9799 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9800 
      return
9801 
    oprot.writeStructBegin('getTransactionsForShoppingCartId_args')
3431 rajveer 9802 
    if self.shoppingCartId is not None:
132 ashish 9803 
      oprot.writeFieldBegin('shoppingCartId', TType.I64, 1)
9804 
      oprot.writeI64(self.shoppingCartId)
9805 
      oprot.writeFieldEnd()
9806 
    oprot.writeFieldStop()
9807 
    oprot.writeStructEnd()
9808 
 
3431 rajveer 9809 
  def validate(self):
9810 
    return
9811 
 
9812 
 
132 ashish 9813 
  def __repr__(self):
9814 
    L = ['%s=%r' % (key, value)
9815 
      for key, value in self.__dict__.iteritems()]
9816 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9817 
 
9818 
  def __eq__(self, other):
9819 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9820 
 
9821 
  def __ne__(self, other):
9822 
    return not (self == other)
9823 
 
9824 
class getTransactionsForShoppingCartId_result:
9825 
  """
9826 
  Attributes:
9827 
   - success
9828 
   - ex
9829 
  """
9830 
 
9831 
  thrift_spec = (
9832 
    (0, TType.LIST, 'success', (TType.STRUCT,(Transaction, Transaction.thrift_spec)), None, ), # 0
9833 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
9834 
  )
9835 
 
9836 
  def __init__(self, success=None, ex=None,):
9837 
    self.success = success
9838 
    self.ex = ex
9839 
 
9840 
  def read(self, iprot):
9841 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9842 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9843 
      return
9844 
    iprot.readStructBegin()
9845 
    while True:
9846 
      (fname, ftype, fid) = iprot.readFieldBegin()
9847 
      if ftype == TType.STOP:
9848 
        break
9849 
      if fid == 0:
9850 
        if ftype == TType.LIST:
9851 
          self.success = []
6188 rajveer 9852 
          (_etype116, _size113) = iprot.readListBegin()
9853 
          for _i117 in xrange(_size113):
9854 
            _elem118 = Transaction()
9855 
            _elem118.read(iprot)
9856 
            self.success.append(_elem118)
132 ashish 9857 
          iprot.readListEnd()
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('getTransactionsForShoppingCartId_result')
3431 rajveer 9876 
    if self.success is not None:
132 ashish 9877 
      oprot.writeFieldBegin('success', TType.LIST, 0)
9878 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 9879 
      for iter119 in self.success:
9880 
        iter119.write(oprot)
132 ashish 9881 
      oprot.writeListEnd()
9882 
      oprot.writeFieldEnd()
3431 rajveer 9883 
    if self.ex is not None:
132 ashish 9884 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9885 
      self.ex.write(oprot)
9886 
      oprot.writeFieldEnd()
9887 
    oprot.writeFieldStop()
9888 
    oprot.writeStructEnd()
9889 
 
3431 rajveer 9890 
  def validate(self):
9891 
    return
9892 
 
9893 
 
132 ashish 9894 
  def __repr__(self):
9895 
    L = ['%s=%r' % (key, value)
9896 
      for key, value in self.__dict__.iteritems()]
9897 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9898 
 
9899 
  def __eq__(self, other):
9900 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9901 
 
9902 
  def __ne__(self, other):
9903 
    return not (self == other)
9904 
 
94 ashish 9905 
class getTransactionStatus_args:
9906 
  """
9907 
  Attributes:
9908 
   - transactionId
9909 
  """
9910 
 
9911 
  thrift_spec = (
9912 
    None, # 0
9913 
    (1, TType.I64, 'transactionId', None, None, ), # 1
9914 
  )
9915 
 
9916 
  def __init__(self, transactionId=None,):
9917 
    self.transactionId = transactionId
9918 
 
9919 
  def read(self, iprot):
9920 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9921 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9922 
      return
9923 
    iprot.readStructBegin()
9924 
    while True:
9925 
      (fname, ftype, fid) = iprot.readFieldBegin()
9926 
      if ftype == TType.STOP:
9927 
        break
9928 
      if fid == 1:
9929 
        if ftype == TType.I64:
9930 
          self.transactionId = iprot.readI64();
9931 
        else:
9932 
          iprot.skip(ftype)
9933 
      else:
9934 
        iprot.skip(ftype)
9935 
      iprot.readFieldEnd()
9936 
    iprot.readStructEnd()
9937 
 
9938 
  def write(self, oprot):
9939 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9940 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9941 
      return
9942 
    oprot.writeStructBegin('getTransactionStatus_args')
3431 rajveer 9943 
    if self.transactionId is not None:
94 ashish 9944 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
9945 
      oprot.writeI64(self.transactionId)
9946 
      oprot.writeFieldEnd()
9947 
    oprot.writeFieldStop()
9948 
    oprot.writeStructEnd()
9949 
 
3431 rajveer 9950 
  def validate(self):
9951 
    return
9952 
 
9953 
 
94 ashish 9954 
  def __repr__(self):
9955 
    L = ['%s=%r' % (key, value)
9956 
      for key, value in self.__dict__.iteritems()]
9957 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9958 
 
9959 
  def __eq__(self, other):
9960 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9961 
 
9962 
  def __ne__(self, other):
9963 
    return not (self == other)
9964 
 
9965 
class getTransactionStatus_result:
9966 
  """
9967 
  Attributes:
9968 
   - success
9969 
   - ex
9970 
  """
9971 
 
9972 
  thrift_spec = (
9973 
    (0, TType.I32, 'success', None, None, ), # 0
9974 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
9975 
  )
9976 
 
9977 
  def __init__(self, success=None, ex=None,):
9978 
    self.success = success
9979 
    self.ex = ex
9980 
 
9981 
  def read(self, iprot):
9982 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9983 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9984 
      return
9985 
    iprot.readStructBegin()
9986 
    while True:
9987 
      (fname, ftype, fid) = iprot.readFieldBegin()
9988 
      if ftype == TType.STOP:
9989 
        break
9990 
      if fid == 0:
9991 
        if ftype == TType.I32:
9992 
          self.success = iprot.readI32();
9993 
        else:
9994 
          iprot.skip(ftype)
9995 
      elif fid == 1:
9996 
        if ftype == TType.STRUCT:
9997 
          self.ex = TransactionServiceException()
9998 
          self.ex.read(iprot)
9999 
        else:
10000 
          iprot.skip(ftype)
10001 
      else:
10002 
        iprot.skip(ftype)
10003 
      iprot.readFieldEnd()
10004 
    iprot.readStructEnd()
10005 
 
10006 
  def write(self, oprot):
10007 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10008 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10009 
      return
10010 
    oprot.writeStructBegin('getTransactionStatus_result')
3431 rajveer 10011 
    if self.success is not None:
94 ashish 10012 
      oprot.writeFieldBegin('success', TType.I32, 0)
10013 
      oprot.writeI32(self.success)
10014 
      oprot.writeFieldEnd()
3431 rajveer 10015 
    if self.ex is not None:
94 ashish 10016 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10017 
      self.ex.write(oprot)
10018 
      oprot.writeFieldEnd()
10019 
    oprot.writeFieldStop()
10020 
    oprot.writeStructEnd()
10021 
 
3431 rajveer 10022 
  def validate(self):
10023 
    return
10024 
 
10025 
 
94 ashish 10026 
  def __repr__(self):
10027 
    L = ['%s=%r' % (key, value)
10028 
      for key, value in self.__dict__.iteritems()]
10029 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10030 
 
10031 
  def __eq__(self, other):
10032 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10033 
 
10034 
  def __ne__(self, other):
10035 
    return not (self == other)
10036 
 
10037 
class changeTransactionStatus_args:
10038 
  """
10039 
  Attributes:
10040 
   - transactionId
10041 
   - status
10042 
   - description
5527 anupam.sin 10043 
   - pickUp
10044 
   - orderType
94 ashish 10045 
  """
10046 
 
10047 
  thrift_spec = (
10048 
    None, # 0
10049 
    (1, TType.I64, 'transactionId', None, None, ), # 1
10050 
    (2, TType.I32, 'status', None, None, ), # 2
10051 
    (3, TType.STRING, 'description', None, None, ), # 3
5527 anupam.sin 10052 
    (4, TType.I64, 'pickUp', None, None, ), # 4
10053 
    (5, TType.I32, 'orderType', None, None, ), # 5
94 ashish 10054 
  )
10055 
 
5527 anupam.sin 10056 
  def __init__(self, transactionId=None, status=None, description=None, pickUp=None, orderType=None,):
94 ashish 10057 
    self.transactionId = transactionId
10058 
    self.status = status
10059 
    self.description = description
5527 anupam.sin 10060 
    self.pickUp = pickUp
10061 
    self.orderType = orderType
94 ashish 10062 
 
10063 
  def read(self, iprot):
10064 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10065 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10066 
      return
10067 
    iprot.readStructBegin()
10068 
    while True:
10069 
      (fname, ftype, fid) = iprot.readFieldBegin()
10070 
      if ftype == TType.STOP:
10071 
        break
10072 
      if fid == 1:
10073 
        if ftype == TType.I64:
10074 
          self.transactionId = iprot.readI64();
10075 
        else:
10076 
          iprot.skip(ftype)
10077 
      elif fid == 2:
10078 
        if ftype == TType.I32:
10079 
          self.status = iprot.readI32();
10080 
        else:
10081 
          iprot.skip(ftype)
10082 
      elif fid == 3:
10083 
        if ftype == TType.STRING:
10084 
          self.description = iprot.readString();
10085 
        else:
10086 
          iprot.skip(ftype)
5387 rajveer 10087 
      elif fid == 4:
5527 anupam.sin 10088 
        if ftype == TType.I64:
10089 
          self.pickUp = iprot.readI64();
5387 rajveer 10090 
        else:
10091 
          iprot.skip(ftype)
5527 anupam.sin 10092 
      elif fid == 5:
10093 
        if ftype == TType.I32:
10094 
          self.orderType = iprot.readI32();
10095 
        else:
10096 
          iprot.skip(ftype)
94 ashish 10097 
      else:
10098 
        iprot.skip(ftype)
10099 
      iprot.readFieldEnd()
10100 
    iprot.readStructEnd()
10101 
 
10102 
  def write(self, oprot):
10103 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10104 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10105 
      return
10106 
    oprot.writeStructBegin('changeTransactionStatus_args')
3431 rajveer 10107 
    if self.transactionId is not None:
94 ashish 10108 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
10109 
      oprot.writeI64(self.transactionId)
10110 
      oprot.writeFieldEnd()
3431 rajveer 10111 
    if self.status is not None:
94 ashish 10112 
      oprot.writeFieldBegin('status', TType.I32, 2)
10113 
      oprot.writeI32(self.status)
10114 
      oprot.writeFieldEnd()
3431 rajveer 10115 
    if self.description is not None:
94 ashish 10116 
      oprot.writeFieldBegin('description', TType.STRING, 3)
10117 
      oprot.writeString(self.description)
10118 
      oprot.writeFieldEnd()
5527 anupam.sin 10119 
    if self.pickUp is not None:
10120 
      oprot.writeFieldBegin('pickUp', TType.I64, 4)
10121 
      oprot.writeI64(self.pickUp)
5387 rajveer 10122 
      oprot.writeFieldEnd()
5527 anupam.sin 10123 
    if self.orderType is not None:
10124 
      oprot.writeFieldBegin('orderType', TType.I32, 5)
10125 
      oprot.writeI32(self.orderType)
10126 
      oprot.writeFieldEnd()
94 ashish 10127 
    oprot.writeFieldStop()
10128 
    oprot.writeStructEnd()
10129 
 
3431 rajveer 10130 
  def validate(self):
10131 
    return
10132 
 
10133 
 
94 ashish 10134 
  def __repr__(self):
10135 
    L = ['%s=%r' % (key, value)
10136 
      for key, value in self.__dict__.iteritems()]
10137 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10138 
 
10139 
  def __eq__(self, other):
10140 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10141 
 
10142 
  def __ne__(self, other):
10143 
    return not (self == other)
10144 
 
10145 
class changeTransactionStatus_result:
10146 
  """
10147 
  Attributes:
10148 
   - success
10149 
   - ex
10150 
  """
10151 
 
10152 
  thrift_spec = (
10153 
    (0, TType.BOOL, 'success', None, None, ), # 0
10154 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
10155 
  )
10156 
 
10157 
  def __init__(self, success=None, ex=None,):
10158 
    self.success = success
10159 
    self.ex = ex
10160 
 
10161 
  def read(self, iprot):
10162 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10163 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10164 
      return
10165 
    iprot.readStructBegin()
10166 
    while True:
10167 
      (fname, ftype, fid) = iprot.readFieldBegin()
10168 
      if ftype == TType.STOP:
10169 
        break
10170 
      if fid == 0:
10171 
        if ftype == TType.BOOL:
10172 
          self.success = iprot.readBool();
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('changeTransactionStatus_result')
3431 rajveer 10191 
    if self.success is not None:
94 ashish 10192 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
10193 
      oprot.writeBool(self.success)
10194 
      oprot.writeFieldEnd()
3431 rajveer 10195 
    if self.ex is not None:
94 ashish 10196 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10197 
      self.ex.write(oprot)
10198 
      oprot.writeFieldEnd()
10199 
    oprot.writeFieldStop()
10200 
    oprot.writeStructEnd()
10201 
 
3431 rajveer 10202 
  def validate(self):
10203 
    return
10204 
 
10205 
 
94 ashish 10206 
  def __repr__(self):
10207 
    L = ['%s=%r' % (key, value)
10208 
      for key, value in self.__dict__.iteritems()]
10209 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10210 
 
10211 
  def __eq__(self, other):
10212 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10213 
 
10214 
  def __ne__(self, other):
10215 
    return not (self == other)
10216 
 
1398 varun.gupt 10217 
class enqueueTransactionInfoEmail_args:
1382 varun.gupt 10218 
  """
10219 
  Attributes:
10220 
   - transactionId
10221 
  """
10222 
 
10223 
  thrift_spec = (
10224 
    None, # 0
10225 
    (1, TType.I64, 'transactionId', None, None, ), # 1
10226 
  )
10227 
 
10228 
  def __init__(self, transactionId=None,):
10229 
    self.transactionId = transactionId
10230 
 
10231 
  def read(self, iprot):
10232 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10233 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10234 
      return
10235 
    iprot.readStructBegin()
10236 
    while True:
10237 
      (fname, ftype, fid) = iprot.readFieldBegin()
10238 
      if ftype == TType.STOP:
10239 
        break
10240 
      if fid == 1:
10241 
        if ftype == TType.I64:
10242 
          self.transactionId = iprot.readI64();
10243 
        else:
10244 
          iprot.skip(ftype)
10245 
      else:
10246 
        iprot.skip(ftype)
10247 
      iprot.readFieldEnd()
10248 
    iprot.readStructEnd()
10249 
 
10250 
  def write(self, oprot):
10251 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10252 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10253 
      return
1398 varun.gupt 10254 
    oprot.writeStructBegin('enqueueTransactionInfoEmail_args')
3431 rajveer 10255 
    if self.transactionId is not None:
1382 varun.gupt 10256 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
10257 
      oprot.writeI64(self.transactionId)
10258 
      oprot.writeFieldEnd()
10259 
    oprot.writeFieldStop()
10260 
    oprot.writeStructEnd()
10261 
 
3431 rajveer 10262 
  def validate(self):
10263 
    return
10264 
 
10265 
 
1382 varun.gupt 10266 
  def __repr__(self):
10267 
    L = ['%s=%r' % (key, value)
10268 
      for key, value in self.__dict__.iteritems()]
10269 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10270 
 
10271 
  def __eq__(self, other):
10272 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10273 
 
10274 
  def __ne__(self, other):
10275 
    return not (self == other)
10276 
 
1398 varun.gupt 10277 
class enqueueTransactionInfoEmail_result:
1382 varun.gupt 10278 
  """
10279 
  Attributes:
10280 
   - success
10281 
   - ex
10282 
  """
10283 
 
10284 
  thrift_spec = (
10285 
    (0, TType.BOOL, 'success', None, None, ), # 0
10286 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
10287 
  )
10288 
 
10289 
  def __init__(self, success=None, ex=None,):
10290 
    self.success = success
10291 
    self.ex = ex
10292 
 
10293 
  def read(self, iprot):
10294 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10295 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10296 
      return
10297 
    iprot.readStructBegin()
10298 
    while True:
10299 
      (fname, ftype, fid) = iprot.readFieldBegin()
10300 
      if ftype == TType.STOP:
10301 
        break
10302 
      if fid == 0:
10303 
        if ftype == TType.BOOL:
10304 
          self.success = iprot.readBool();
10305 
        else:
10306 
          iprot.skip(ftype)
10307 
      elif fid == 1:
10308 
        if ftype == TType.STRUCT:
10309 
          self.ex = TransactionServiceException()
10310 
          self.ex.read(iprot)
10311 
        else:
10312 
          iprot.skip(ftype)
10313 
      else:
10314 
        iprot.skip(ftype)
10315 
      iprot.readFieldEnd()
10316 
    iprot.readStructEnd()
10317 
 
10318 
  def write(self, oprot):
10319 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10320 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10321 
      return
1398 varun.gupt 10322 
    oprot.writeStructBegin('enqueueTransactionInfoEmail_result')
3431 rajveer 10323 
    if self.success is not None:
1382 varun.gupt 10324 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
10325 
      oprot.writeBool(self.success)
10326 
      oprot.writeFieldEnd()
3431 rajveer 10327 
    if self.ex is not None:
1382 varun.gupt 10328 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10329 
      self.ex.write(oprot)
10330 
      oprot.writeFieldEnd()
10331 
    oprot.writeFieldStop()
10332 
    oprot.writeStructEnd()
10333 
 
3431 rajveer 10334 
  def validate(self):
10335 
    return
10336 
 
10337 
 
1382 varun.gupt 10338 
  def __repr__(self):
10339 
    L = ['%s=%r' % (key, value)
10340 
      for key, value in self.__dict__.iteritems()]
10341 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10342 
 
10343 
  def __eq__(self, other):
10344 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10345 
 
10346 
  def __ne__(self, other):
10347 
    return not (self == other)
10348 
 
483 rajveer 10349 
class getAllOrders_args:
94 ashish 10350 
  """
10351 
  Attributes:
4801 anupam.sin 10352 
   - statuses
483 rajveer 10353 
   - from_date
10354 
   - to_date
10355 
   - warehouse_id
94 ashish 10356 
  """
10357 
 
10358 
  thrift_spec = (
10359 
    None, # 0
4801 anupam.sin 10360 
    (1, TType.LIST, 'statuses', (TType.I32,None), None, ), # 1
483 rajveer 10361 
    (2, TType.I64, 'from_date', None, None, ), # 2
10362 
    (3, TType.I64, 'to_date', None, None, ), # 3
10363 
    (4, TType.I64, 'warehouse_id', None, None, ), # 4
94 ashish 10364 
  )
10365 
 
4801 anupam.sin 10366 
  def __init__(self, statuses=None, from_date=None, to_date=None, warehouse_id=None,):
10367 
    self.statuses = statuses
483 rajveer 10368 
    self.from_date = from_date
10369 
    self.to_date = to_date
10370 
    self.warehouse_id = warehouse_id
94 ashish 10371 
 
10372 
  def read(self, iprot):
10373 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10374 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10375 
      return
10376 
    iprot.readStructBegin()
10377 
    while True:
10378 
      (fname, ftype, fid) = iprot.readFieldBegin()
10379 
      if ftype == TType.STOP:
10380 
        break
10381 
      if fid == 1:
4801 anupam.sin 10382 
        if ftype == TType.LIST:
10383 
          self.statuses = []
6188 rajveer 10384 
          (_etype123, _size120) = iprot.readListBegin()
10385 
          for _i124 in xrange(_size120):
10386 
            _elem125 = iprot.readI32();
10387 
            self.statuses.append(_elem125)
4801 anupam.sin 10388 
          iprot.readListEnd()
94 ashish 10389 
        else:
10390 
          iprot.skip(ftype)
483 rajveer 10391 
      elif fid == 2:
10392 
        if ftype == TType.I64:
10393 
          self.from_date = iprot.readI64();
94 ashish 10394 
        else:
10395 
          iprot.skip(ftype)
483 rajveer 10396 
      elif fid == 3:
10397 
        if ftype == TType.I64:
10398 
          self.to_date = iprot.readI64();
94 ashish 10399 
        else:
10400 
          iprot.skip(ftype)
483 rajveer 10401 
      elif fid == 4:
94 ashish 10402 
        if ftype == TType.I64:
483 rajveer 10403 
          self.warehouse_id = iprot.readI64();
94 ashish 10404 
        else:
10405 
          iprot.skip(ftype)
10406 
      else:
10407 
        iprot.skip(ftype)
10408 
      iprot.readFieldEnd()
10409 
    iprot.readStructEnd()
10410 
 
10411 
  def write(self, oprot):
10412 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10413 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10414 
      return
483 rajveer 10415 
    oprot.writeStructBegin('getAllOrders_args')
4801 anupam.sin 10416 
    if self.statuses is not None:
10417 
      oprot.writeFieldBegin('statuses', TType.LIST, 1)
10418 
      oprot.writeListBegin(TType.I32, len(self.statuses))
6188 rajveer 10419 
      for iter126 in self.statuses:
10420 
        oprot.writeI32(iter126)
4801 anupam.sin 10421 
      oprot.writeListEnd()
94 ashish 10422 
      oprot.writeFieldEnd()
3431 rajveer 10423 
    if self.from_date is not None:
483 rajveer 10424 
      oprot.writeFieldBegin('from_date', TType.I64, 2)
10425 
      oprot.writeI64(self.from_date)
94 ashish 10426 
      oprot.writeFieldEnd()
3431 rajveer 10427 
    if self.to_date is not None:
483 rajveer 10428 
      oprot.writeFieldBegin('to_date', TType.I64, 3)
10429 
      oprot.writeI64(self.to_date)
94 ashish 10430 
      oprot.writeFieldEnd()
3431 rajveer 10431 
    if self.warehouse_id is not None:
483 rajveer 10432 
      oprot.writeFieldBegin('warehouse_id', TType.I64, 4)
10433 
      oprot.writeI64(self.warehouse_id)
94 ashish 10434 
      oprot.writeFieldEnd()
10435 
    oprot.writeFieldStop()
10436 
    oprot.writeStructEnd()
10437 
 
3431 rajveer 10438 
  def validate(self):
10439 
    return
10440 
 
10441 
 
94 ashish 10442 
  def __repr__(self):
10443 
    L = ['%s=%r' % (key, value)
10444 
      for key, value in self.__dict__.iteritems()]
10445 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10446 
 
10447 
  def __eq__(self, other):
10448 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10449 
 
10450 
  def __ne__(self, other):
10451 
    return not (self == other)
10452 
 
483 rajveer 10453 
class getAllOrders_result:
94 ashish 10454 
  """
10455 
  Attributes:
10456 
   - success
10457 
   - ex
10458 
  """
10459 
 
10460 
  thrift_spec = (
483 rajveer 10461 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
94 ashish 10462 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
10463 
  )
10464 
 
10465 
  def __init__(self, success=None, ex=None,):
10466 
    self.success = success
10467 
    self.ex = ex
10468 
 
10469 
  def read(self, iprot):
10470 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10471 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10472 
      return
10473 
    iprot.readStructBegin()
10474 
    while True:
10475 
      (fname, ftype, fid) = iprot.readFieldBegin()
10476 
      if ftype == TType.STOP:
10477 
        break
10478 
      if fid == 0:
483 rajveer 10479 
        if ftype == TType.LIST:
10480 
          self.success = []
6188 rajveer 10481 
          (_etype130, _size127) = iprot.readListBegin()
10482 
          for _i131 in xrange(_size127):
10483 
            _elem132 = Order()
10484 
            _elem132.read(iprot)
10485 
            self.success.append(_elem132)
483 rajveer 10486 
          iprot.readListEnd()
94 ashish 10487 
        else:
10488 
          iprot.skip(ftype)
10489 
      elif fid == 1:
10490 
        if ftype == TType.STRUCT:
10491 
          self.ex = TransactionServiceException()
10492 
          self.ex.read(iprot)
10493 
        else:
10494 
          iprot.skip(ftype)
10495 
      else:
10496 
        iprot.skip(ftype)
10497 
      iprot.readFieldEnd()
10498 
    iprot.readStructEnd()
10499 
 
10500 
  def write(self, oprot):
10501 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10502 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10503 
      return
483 rajveer 10504 
    oprot.writeStructBegin('getAllOrders_result')
3431 rajveer 10505 
    if self.success is not None:
483 rajveer 10506 
      oprot.writeFieldBegin('success', TType.LIST, 0)
10507 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 10508 
      for iter133 in self.success:
10509 
        iter133.write(oprot)
483 rajveer 10510 
      oprot.writeListEnd()
94 ashish 10511 
      oprot.writeFieldEnd()
3431 rajveer 10512 
    if self.ex is not None:
94 ashish 10513 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10514 
      self.ex.write(oprot)
10515 
      oprot.writeFieldEnd()
10516 
    oprot.writeFieldStop()
10517 
    oprot.writeStructEnd()
10518 
 
3431 rajveer 10519 
  def validate(self):
10520 
    return
10521 
 
10522 
 
94 ashish 10523 
  def __repr__(self):
10524 
    L = ['%s=%r' % (key, value)
10525 
      for key, value in self.__dict__.iteritems()]
10526 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10527 
 
10528 
  def __eq__(self, other):
10529 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10530 
 
10531 
  def __ne__(self, other):
10532 
    return not (self == other)
10533 
 
4133 chandransh 10534 
class getOrdersInBatch_args:
10535 
  """
10536 
  Attributes:
10537 
   - statuses
10538 
   - offset
10539 
   - limit
10540 
   - warehouse_id
10541 
  """
10542 
 
10543 
  thrift_spec = (
10544 
    None, # 0
10545 
    (1, TType.LIST, 'statuses', (TType.I32,None), None, ), # 1
10546 
    (2, TType.I64, 'offset', None, None, ), # 2
10547 
    (3, TType.I64, 'limit', None, None, ), # 3
10548 
    (4, TType.I64, 'warehouse_id', None, None, ), # 4
10549 
  )
10550 
 
10551 
  def __init__(self, statuses=None, offset=None, limit=None, warehouse_id=None,):
10552 
    self.statuses = statuses
10553 
    self.offset = offset
10554 
    self.limit = limit
10555 
    self.warehouse_id = warehouse_id
10556 
 
10557 
  def read(self, iprot):
10558 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10559 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10560 
      return
10561 
    iprot.readStructBegin()
10562 
    while True:
10563 
      (fname, ftype, fid) = iprot.readFieldBegin()
10564 
      if ftype == TType.STOP:
10565 
        break
10566 
      if fid == 1:
10567 
        if ftype == TType.LIST:
10568 
          self.statuses = []
6188 rajveer 10569 
          (_etype137, _size134) = iprot.readListBegin()
10570 
          for _i138 in xrange(_size134):
10571 
            _elem139 = iprot.readI32();
10572 
            self.statuses.append(_elem139)
4133 chandransh 10573 
          iprot.readListEnd()
10574 
        else:
10575 
          iprot.skip(ftype)
10576 
      elif fid == 2:
10577 
        if ftype == TType.I64:
10578 
          self.offset = iprot.readI64();
10579 
        else:
10580 
          iprot.skip(ftype)
10581 
      elif fid == 3:
10582 
        if ftype == TType.I64:
10583 
          self.limit = iprot.readI64();
10584 
        else:
10585 
          iprot.skip(ftype)
10586 
      elif fid == 4:
10587 
        if ftype == TType.I64:
10588 
          self.warehouse_id = iprot.readI64();
10589 
        else:
10590 
          iprot.skip(ftype)
10591 
      else:
10592 
        iprot.skip(ftype)
10593 
      iprot.readFieldEnd()
10594 
    iprot.readStructEnd()
10595 
 
10596 
  def write(self, oprot):
10597 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10598 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10599 
      return
10600 
    oprot.writeStructBegin('getOrdersInBatch_args')
10601 
    if self.statuses is not None:
10602 
      oprot.writeFieldBegin('statuses', TType.LIST, 1)
10603 
      oprot.writeListBegin(TType.I32, len(self.statuses))
6188 rajveer 10604 
      for iter140 in self.statuses:
10605 
        oprot.writeI32(iter140)
4133 chandransh 10606 
      oprot.writeListEnd()
10607 
      oprot.writeFieldEnd()
10608 
    if self.offset is not None:
10609 
      oprot.writeFieldBegin('offset', TType.I64, 2)
10610 
      oprot.writeI64(self.offset)
10611 
      oprot.writeFieldEnd()
10612 
    if self.limit is not None:
10613 
      oprot.writeFieldBegin('limit', TType.I64, 3)
10614 
      oprot.writeI64(self.limit)
10615 
      oprot.writeFieldEnd()
10616 
    if self.warehouse_id is not None:
10617 
      oprot.writeFieldBegin('warehouse_id', TType.I64, 4)
10618 
      oprot.writeI64(self.warehouse_id)
10619 
      oprot.writeFieldEnd()
10620 
    oprot.writeFieldStop()
10621 
    oprot.writeStructEnd()
10622 
 
10623 
  def validate(self):
10624 
    return
10625 
 
10626 
 
10627 
  def __repr__(self):
10628 
    L = ['%s=%r' % (key, value)
10629 
      for key, value in self.__dict__.iteritems()]
10630 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10631 
 
10632 
  def __eq__(self, other):
10633 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10634 
 
10635 
  def __ne__(self, other):
10636 
    return not (self == other)
10637 
 
10638 
class getOrdersInBatch_result:
10639 
  """
10640 
  Attributes:
10641 
   - success
10642 
   - ex
10643 
  """
10644 
 
10645 
  thrift_spec = (
10646 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
10647 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
10648 
  )
10649 
 
10650 
  def __init__(self, success=None, ex=None,):
10651 
    self.success = success
10652 
    self.ex = ex
10653 
 
10654 
  def read(self, iprot):
10655 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10656 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10657 
      return
10658 
    iprot.readStructBegin()
10659 
    while True:
10660 
      (fname, ftype, fid) = iprot.readFieldBegin()
10661 
      if ftype == TType.STOP:
10662 
        break
10663 
      if fid == 0:
10664 
        if ftype == TType.LIST:
10665 
          self.success = []
6188 rajveer 10666 
          (_etype144, _size141) = iprot.readListBegin()
10667 
          for _i145 in xrange(_size141):
10668 
            _elem146 = Order()
10669 
            _elem146.read(iprot)
10670 
            self.success.append(_elem146)
4133 chandransh 10671 
          iprot.readListEnd()
10672 
        else:
10673 
          iprot.skip(ftype)
10674 
      elif fid == 1:
10675 
        if ftype == TType.STRUCT:
10676 
          self.ex = TransactionServiceException()
10677 
          self.ex.read(iprot)
10678 
        else:
10679 
          iprot.skip(ftype)
10680 
      else:
10681 
        iprot.skip(ftype)
10682 
      iprot.readFieldEnd()
10683 
    iprot.readStructEnd()
10684 
 
10685 
  def write(self, oprot):
10686 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10687 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10688 
      return
10689 
    oprot.writeStructBegin('getOrdersInBatch_result')
10690 
    if self.success is not None:
10691 
      oprot.writeFieldBegin('success', TType.LIST, 0)
10692 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 10693 
      for iter147 in self.success:
10694 
        iter147.write(oprot)
4133 chandransh 10695 
      oprot.writeListEnd()
10696 
      oprot.writeFieldEnd()
10697 
    if self.ex is not None:
10698 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10699 
      self.ex.write(oprot)
10700 
      oprot.writeFieldEnd()
10701 
    oprot.writeFieldStop()
10702 
    oprot.writeStructEnd()
10703 
 
10704 
  def validate(self):
10705 
    return
10706 
 
10707 
 
10708 
  def __repr__(self):
10709 
    L = ['%s=%r' % (key, value)
10710 
      for key, value in self.__dict__.iteritems()]
10711 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10712 
 
10713 
  def __eq__(self, other):
10714 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10715 
 
10716 
  def __ne__(self, other):
10717 
    return not (self == other)
10718 
 
10719 
class getOrderCount_args:
10720 
  """
10721 
  Attributes:
10722 
   - statuses
10723 
   - warehouseId
10724 
  """
10725 
 
10726 
  thrift_spec = (
10727 
    None, # 0
10728 
    (1, TType.LIST, 'statuses', (TType.I32,None), None, ), # 1
10729 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
10730 
  )
10731 
 
10732 
  def __init__(self, statuses=None, warehouseId=None,):
10733 
    self.statuses = statuses
10734 
    self.warehouseId = warehouseId
10735 
 
10736 
  def read(self, iprot):
10737 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10738 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10739 
      return
10740 
    iprot.readStructBegin()
10741 
    while True:
10742 
      (fname, ftype, fid) = iprot.readFieldBegin()
10743 
      if ftype == TType.STOP:
10744 
        break
10745 
      if fid == 1:
10746 
        if ftype == TType.LIST:
10747 
          self.statuses = []
6188 rajveer 10748 
          (_etype151, _size148) = iprot.readListBegin()
10749 
          for _i152 in xrange(_size148):
10750 
            _elem153 = iprot.readI32();
10751 
            self.statuses.append(_elem153)
4133 chandransh 10752 
          iprot.readListEnd()
10753 
        else:
10754 
          iprot.skip(ftype)
10755 
      elif fid == 2:
10756 
        if ftype == TType.I64:
10757 
          self.warehouseId = iprot.readI64();
10758 
        else:
10759 
          iprot.skip(ftype)
10760 
      else:
10761 
        iprot.skip(ftype)
10762 
      iprot.readFieldEnd()
10763 
    iprot.readStructEnd()
10764 
 
10765 
  def write(self, oprot):
10766 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10767 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10768 
      return
10769 
    oprot.writeStructBegin('getOrderCount_args')
10770 
    if self.statuses is not None:
10771 
      oprot.writeFieldBegin('statuses', TType.LIST, 1)
10772 
      oprot.writeListBegin(TType.I32, len(self.statuses))
6188 rajveer 10773 
      for iter154 in self.statuses:
10774 
        oprot.writeI32(iter154)
4133 chandransh 10775 
      oprot.writeListEnd()
10776 
      oprot.writeFieldEnd()
10777 
    if self.warehouseId is not None:
10778 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
10779 
      oprot.writeI64(self.warehouseId)
10780 
      oprot.writeFieldEnd()
10781 
    oprot.writeFieldStop()
10782 
    oprot.writeStructEnd()
10783 
 
10784 
  def validate(self):
10785 
    return
10786 
 
10787 
 
10788 
  def __repr__(self):
10789 
    L = ['%s=%r' % (key, value)
10790 
      for key, value in self.__dict__.iteritems()]
10791 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10792 
 
10793 
  def __eq__(self, other):
10794 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10795 
 
10796 
  def __ne__(self, other):
10797 
    return not (self == other)
10798 
 
10799 
class getOrderCount_result:
10800 
  """
10801 
  Attributes:
10802 
   - success
10803 
   - ex
10804 
  """
10805 
 
10806 
  thrift_spec = (
10807 
    (0, TType.I32, 'success', None, None, ), # 0
10808 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
10809 
  )
10810 
 
10811 
  def __init__(self, success=None, ex=None,):
10812 
    self.success = success
10813 
    self.ex = ex
10814 
 
10815 
  def read(self, iprot):
10816 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10817 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10818 
      return
10819 
    iprot.readStructBegin()
10820 
    while True:
10821 
      (fname, ftype, fid) = iprot.readFieldBegin()
10822 
      if ftype == TType.STOP:
10823 
        break
10824 
      if fid == 0:
10825 
        if ftype == TType.I32:
10826 
          self.success = iprot.readI32();
10827 
        else:
10828 
          iprot.skip(ftype)
10829 
      elif fid == 1:
10830 
        if ftype == TType.STRUCT:
10831 
          self.ex = TransactionServiceException()
10832 
          self.ex.read(iprot)
10833 
        else:
10834 
          iprot.skip(ftype)
10835 
      else:
10836 
        iprot.skip(ftype)
10837 
      iprot.readFieldEnd()
10838 
    iprot.readStructEnd()
10839 
 
10840 
  def write(self, oprot):
10841 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10842 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10843 
      return
10844 
    oprot.writeStructBegin('getOrderCount_result')
10845 
    if self.success is not None:
10846 
      oprot.writeFieldBegin('success', TType.I32, 0)
10847 
      oprot.writeI32(self.success)
10848 
      oprot.writeFieldEnd()
10849 
    if self.ex is not None:
10850 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10851 
      self.ex.write(oprot)
10852 
      oprot.writeFieldEnd()
10853 
    oprot.writeFieldStop()
10854 
    oprot.writeStructEnd()
10855 
 
10856 
  def validate(self):
10857 
    return
10858 
 
10859 
 
10860 
  def __repr__(self):
10861 
    L = ['%s=%r' % (key, value)
10862 
      for key, value in self.__dict__.iteritems()]
10863 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10864 
 
10865 
  def __eq__(self, other):
10866 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10867 
 
10868 
  def __ne__(self, other):
10869 
    return not (self == other)
10870 
 
999 varun.gupt 10871 
class getOrdersByBillingDate_args:
10872 
  """
10873 
  Attributes:
10874 
   - status
10875 
   - start_billing_date
10876 
   - end_billing_date
10877 
   - warehouse_id
10878 
  """
10879 
 
10880 
  thrift_spec = (
10881 
    None, # 0
10882 
    (1, TType.I32, 'status', None, None, ), # 1
10883 
    (2, TType.I64, 'start_billing_date', None, None, ), # 2
10884 
    (3, TType.I64, 'end_billing_date', None, None, ), # 3
10885 
    (4, TType.I64, 'warehouse_id', None, None, ), # 4
10886 
  )
10887 
 
10888 
  def __init__(self, status=None, start_billing_date=None, end_billing_date=None, warehouse_id=None,):
10889 
    self.status = status
10890 
    self.start_billing_date = start_billing_date
10891 
    self.end_billing_date = end_billing_date
10892 
    self.warehouse_id = warehouse_id
10893 
 
10894 
  def read(self, iprot):
10895 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10896 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10897 
      return
10898 
    iprot.readStructBegin()
10899 
    while True:
10900 
      (fname, ftype, fid) = iprot.readFieldBegin()
10901 
      if ftype == TType.STOP:
10902 
        break
10903 
      if fid == 1:
10904 
        if ftype == TType.I32:
10905 
          self.status = iprot.readI32();
10906 
        else:
10907 
          iprot.skip(ftype)
10908 
      elif fid == 2:
10909 
        if ftype == TType.I64:
10910 
          self.start_billing_date = iprot.readI64();
10911 
        else:
10912 
          iprot.skip(ftype)
10913 
      elif fid == 3:
10914 
        if ftype == TType.I64:
10915 
          self.end_billing_date = iprot.readI64();
10916 
        else:
10917 
          iprot.skip(ftype)
10918 
      elif fid == 4:
10919 
        if ftype == TType.I64:
10920 
          self.warehouse_id = iprot.readI64();
10921 
        else:
10922 
          iprot.skip(ftype)
10923 
      else:
10924 
        iprot.skip(ftype)
10925 
      iprot.readFieldEnd()
10926 
    iprot.readStructEnd()
10927 
 
10928 
  def write(self, oprot):
10929 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10930 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10931 
      return
10932 
    oprot.writeStructBegin('getOrdersByBillingDate_args')
3431 rajveer 10933 
    if self.status is not None:
999 varun.gupt 10934 
      oprot.writeFieldBegin('status', TType.I32, 1)
10935 
      oprot.writeI32(self.status)
10936 
      oprot.writeFieldEnd()
3431 rajveer 10937 
    if self.start_billing_date is not None:
999 varun.gupt 10938 
      oprot.writeFieldBegin('start_billing_date', TType.I64, 2)
10939 
      oprot.writeI64(self.start_billing_date)
10940 
      oprot.writeFieldEnd()
3431 rajveer 10941 
    if self.end_billing_date is not None:
999 varun.gupt 10942 
      oprot.writeFieldBegin('end_billing_date', TType.I64, 3)
10943 
      oprot.writeI64(self.end_billing_date)
10944 
      oprot.writeFieldEnd()
3431 rajveer 10945 
    if self.warehouse_id is not None:
999 varun.gupt 10946 
      oprot.writeFieldBegin('warehouse_id', TType.I64, 4)
10947 
      oprot.writeI64(self.warehouse_id)
10948 
      oprot.writeFieldEnd()
10949 
    oprot.writeFieldStop()
10950 
    oprot.writeStructEnd()
10951 
 
3431 rajveer 10952 
  def validate(self):
10953 
    return
10954 
 
10955 
 
999 varun.gupt 10956 
  def __repr__(self):
10957 
    L = ['%s=%r' % (key, value)
10958 
      for key, value in self.__dict__.iteritems()]
10959 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10960 
 
10961 
  def __eq__(self, other):
10962 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10963 
 
10964 
  def __ne__(self, other):
10965 
    return not (self == other)
10966 
 
10967 
class getOrdersByBillingDate_result:
10968 
  """
10969 
  Attributes:
10970 
   - success
10971 
   - ex
10972 
  """
10973 
 
10974 
  thrift_spec = (
10975 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
10976 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
10977 
  )
10978 
 
10979 
  def __init__(self, success=None, ex=None,):
10980 
    self.success = success
10981 
    self.ex = ex
10982 
 
10983 
  def read(self, iprot):
10984 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10985 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10986 
      return
10987 
    iprot.readStructBegin()
10988 
    while True:
10989 
      (fname, ftype, fid) = iprot.readFieldBegin()
10990 
      if ftype == TType.STOP:
10991 
        break
10992 
      if fid == 0:
10993 
        if ftype == TType.LIST:
10994 
          self.success = []
6188 rajveer 10995 
          (_etype158, _size155) = iprot.readListBegin()
10996 
          for _i159 in xrange(_size155):
10997 
            _elem160 = Order()
10998 
            _elem160.read(iprot)
10999 
            self.success.append(_elem160)
999 varun.gupt 11000 
          iprot.readListEnd()
11001 
        else:
11002 
          iprot.skip(ftype)
11003 
      elif fid == 1:
11004 
        if ftype == TType.STRUCT:
11005 
          self.ex = TransactionServiceException()
11006 
          self.ex.read(iprot)
11007 
        else:
11008 
          iprot.skip(ftype)
11009 
      else:
11010 
        iprot.skip(ftype)
11011 
      iprot.readFieldEnd()
11012 
    iprot.readStructEnd()
11013 
 
11014 
  def write(self, oprot):
11015 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11016 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11017 
      return
11018 
    oprot.writeStructBegin('getOrdersByBillingDate_result')
3431 rajveer 11019 
    if self.success is not None:
999 varun.gupt 11020 
      oprot.writeFieldBegin('success', TType.LIST, 0)
11021 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 11022 
      for iter161 in self.success:
11023 
        iter161.write(oprot)
999 varun.gupt 11024 
      oprot.writeListEnd()
11025 
      oprot.writeFieldEnd()
3431 rajveer 11026 
    if self.ex is not None:
999 varun.gupt 11027 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11028 
      self.ex.write(oprot)
11029 
      oprot.writeFieldEnd()
11030 
    oprot.writeFieldStop()
11031 
    oprot.writeStructEnd()
11032 
 
3431 rajveer 11033 
  def validate(self):
11034 
    return
11035 
 
11036 
 
999 varun.gupt 11037 
  def __repr__(self):
11038 
    L = ['%s=%r' % (key, value)
11039 
      for key, value in self.__dict__.iteritems()]
11040 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11041 
 
11042 
  def __eq__(self, other):
11043 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11044 
 
11045 
  def __ne__(self, other):
11046 
    return not (self == other)
11047 
 
3427 chandransh 11048 
class getOrdersByShippingDate_args:
11049 
  """
11050 
  Attributes:
11051 
   - fromShippingDate
11052 
   - toShippingDate
11053 
   - providerId
11054 
   - warehouseId
3451 chandransh 11055 
   - cod
3427 chandransh 11056 
  """
11057 
 
11058 
  thrift_spec = (
11059 
    None, # 0
11060 
    (1, TType.I64, 'fromShippingDate', None, None, ), # 1
11061 
    (2, TType.I64, 'toShippingDate', None, None, ), # 2
11062 
    (3, TType.I64, 'providerId', None, None, ), # 3
11063 
    (4, TType.I64, 'warehouseId', None, None, ), # 4
3451 chandransh 11064 
    (5, TType.BOOL, 'cod', None, None, ), # 5
3427 chandransh 11065 
  )
11066 
 
3451 chandransh 11067 
  def __init__(self, fromShippingDate=None, toShippingDate=None, providerId=None, warehouseId=None, cod=None,):
3427 chandransh 11068 
    self.fromShippingDate = fromShippingDate
11069 
    self.toShippingDate = toShippingDate
11070 
    self.providerId = providerId
11071 
    self.warehouseId = warehouseId
3451 chandransh 11072 
    self.cod = cod
3427 chandransh 11073 
 
11074 
  def read(self, iprot):
11075 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11076 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11077 
      return
11078 
    iprot.readStructBegin()
11079 
    while True:
11080 
      (fname, ftype, fid) = iprot.readFieldBegin()
11081 
      if ftype == TType.STOP:
11082 
        break
11083 
      if fid == 1:
11084 
        if ftype == TType.I64:
11085 
          self.fromShippingDate = iprot.readI64();
11086 
        else:
11087 
          iprot.skip(ftype)
11088 
      elif fid == 2:
11089 
        if ftype == TType.I64:
11090 
          self.toShippingDate = iprot.readI64();
11091 
        else:
11092 
          iprot.skip(ftype)
11093 
      elif fid == 3:
11094 
        if ftype == TType.I64:
11095 
          self.providerId = iprot.readI64();
11096 
        else:
11097 
          iprot.skip(ftype)
11098 
      elif fid == 4:
11099 
        if ftype == TType.I64:
11100 
          self.warehouseId = iprot.readI64();
11101 
        else:
11102 
          iprot.skip(ftype)
3451 chandransh 11103 
      elif fid == 5:
11104 
        if ftype == TType.BOOL:
11105 
          self.cod = iprot.readBool();
11106 
        else:
11107 
          iprot.skip(ftype)
3427 chandransh 11108 
      else:
11109 
        iprot.skip(ftype)
11110 
      iprot.readFieldEnd()
11111 
    iprot.readStructEnd()
11112 
 
11113 
  def write(self, oprot):
11114 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11115 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11116 
      return
11117 
    oprot.writeStructBegin('getOrdersByShippingDate_args')
3431 rajveer 11118 
    if self.fromShippingDate is not None:
3427 chandransh 11119 
      oprot.writeFieldBegin('fromShippingDate', TType.I64, 1)
11120 
      oprot.writeI64(self.fromShippingDate)
11121 
      oprot.writeFieldEnd()
3431 rajveer 11122 
    if self.toShippingDate is not None:
3427 chandransh 11123 
      oprot.writeFieldBegin('toShippingDate', TType.I64, 2)
11124 
      oprot.writeI64(self.toShippingDate)
11125 
      oprot.writeFieldEnd()
3431 rajveer 11126 
    if self.providerId is not None:
3427 chandransh 11127 
      oprot.writeFieldBegin('providerId', TType.I64, 3)
11128 
      oprot.writeI64(self.providerId)
11129 
      oprot.writeFieldEnd()
3431 rajveer 11130 
    if self.warehouseId is not None:
3427 chandransh 11131 
      oprot.writeFieldBegin('warehouseId', TType.I64, 4)
11132 
      oprot.writeI64(self.warehouseId)
11133 
      oprot.writeFieldEnd()
3451 chandransh 11134 
    if self.cod is not None:
11135 
      oprot.writeFieldBegin('cod', TType.BOOL, 5)
11136 
      oprot.writeBool(self.cod)
11137 
      oprot.writeFieldEnd()
3427 chandransh 11138 
    oprot.writeFieldStop()
11139 
    oprot.writeStructEnd()
11140 
 
3431 rajveer 11141 
  def validate(self):
11142 
    return
11143 
 
11144 
 
3427 chandransh 11145 
  def __repr__(self):
11146 
    L = ['%s=%r' % (key, value)
11147 
      for key, value in self.__dict__.iteritems()]
11148 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11149 
 
11150 
  def __eq__(self, other):
11151 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11152 
 
11153 
  def __ne__(self, other):
11154 
    return not (self == other)
11155 
 
11156 
class getOrdersByShippingDate_result:
11157 
  """
11158 
  Attributes:
11159 
   - success
11160 
   - ex
11161 
  """
11162 
 
11163 
  thrift_spec = (
11164 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
11165 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
11166 
  )
11167 
 
11168 
  def __init__(self, success=None, ex=None,):
11169 
    self.success = success
11170 
    self.ex = ex
11171 
 
11172 
  def read(self, iprot):
11173 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11174 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11175 
      return
11176 
    iprot.readStructBegin()
11177 
    while True:
11178 
      (fname, ftype, fid) = iprot.readFieldBegin()
11179 
      if ftype == TType.STOP:
11180 
        break
11181 
      if fid == 0:
11182 
        if ftype == TType.LIST:
11183 
          self.success = []
6188 rajveer 11184 
          (_etype165, _size162) = iprot.readListBegin()
11185 
          for _i166 in xrange(_size162):
11186 
            _elem167 = Order()
11187 
            _elem167.read(iprot)
11188 
            self.success.append(_elem167)
3427 chandransh 11189 
          iprot.readListEnd()
11190 
        else:
11191 
          iprot.skip(ftype)
11192 
      elif fid == 1:
11193 
        if ftype == TType.STRUCT:
11194 
          self.ex = TransactionServiceException()
11195 
          self.ex.read(iprot)
11196 
        else:
11197 
          iprot.skip(ftype)
11198 
      else:
11199 
        iprot.skip(ftype)
11200 
      iprot.readFieldEnd()
11201 
    iprot.readStructEnd()
11202 
 
11203 
  def write(self, oprot):
11204 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11205 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11206 
      return
11207 
    oprot.writeStructBegin('getOrdersByShippingDate_result')
3431 rajveer 11208 
    if self.success is not None:
3427 chandransh 11209 
      oprot.writeFieldBegin('success', TType.LIST, 0)
11210 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 11211 
      for iter168 in self.success:
11212 
        iter168.write(oprot)
3427 chandransh 11213 
      oprot.writeListEnd()
11214 
      oprot.writeFieldEnd()
3431 rajveer 11215 
    if self.ex is not None:
3427 chandransh 11216 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11217 
      self.ex.write(oprot)
11218 
      oprot.writeFieldEnd()
11219 
    oprot.writeFieldStop()
11220 
    oprot.writeStructEnd()
11221 
 
3431 rajveer 11222 
  def validate(self):
11223 
    return
11224 
 
11225 
 
3427 chandransh 11226 
  def __repr__(self):
11227 
    L = ['%s=%r' % (key, value)
11228 
      for key, value in self.__dict__.iteritems()]
11229 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11230 
 
11231 
  def __eq__(self, other):
11232 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11233 
 
11234 
  def __ne__(self, other):
11235 
    return not (self == other)
11236 
 
1382 varun.gupt 11237 
class getReturnableOrdersForCustomer_args:
11238 
  """
11239 
  Attributes:
11240 
   - customer_id
11241 
   - limit
11242 
  """
11243 
 
11244 
  thrift_spec = (
11245 
    None, # 0
11246 
    (1, TType.I64, 'customer_id', None, None, ), # 1
11247 
    (2, TType.I64, 'limit', None, None, ), # 2
11248 
  )
11249 
 
11250 
  def __init__(self, customer_id=None, limit=None,):
11251 
    self.customer_id = customer_id
11252 
    self.limit = limit
11253 
 
11254 
  def read(self, iprot):
11255 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11256 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11257 
      return
11258 
    iprot.readStructBegin()
11259 
    while True:
11260 
      (fname, ftype, fid) = iprot.readFieldBegin()
11261 
      if ftype == TType.STOP:
11262 
        break
11263 
      if fid == 1:
11264 
        if ftype == TType.I64:
11265 
          self.customer_id = iprot.readI64();
11266 
        else:
11267 
          iprot.skip(ftype)
11268 
      elif fid == 2:
11269 
        if ftype == TType.I64:
11270 
          self.limit = iprot.readI64();
11271 
        else:
11272 
          iprot.skip(ftype)
11273 
      else:
11274 
        iprot.skip(ftype)
11275 
      iprot.readFieldEnd()
11276 
    iprot.readStructEnd()
11277 
 
11278 
  def write(self, oprot):
11279 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11280 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11281 
      return
11282 
    oprot.writeStructBegin('getReturnableOrdersForCustomer_args')
3431 rajveer 11283 
    if self.customer_id is not None:
1382 varun.gupt 11284 
      oprot.writeFieldBegin('customer_id', TType.I64, 1)
11285 
      oprot.writeI64(self.customer_id)
11286 
      oprot.writeFieldEnd()
3431 rajveer 11287 
    if self.limit is not None:
1382 varun.gupt 11288 
      oprot.writeFieldBegin('limit', TType.I64, 2)
11289 
      oprot.writeI64(self.limit)
11290 
      oprot.writeFieldEnd()
11291 
    oprot.writeFieldStop()
11292 
    oprot.writeStructEnd()
11293 
 
3431 rajveer 11294 
  def validate(self):
11295 
    return
11296 
 
11297 
 
1382 varun.gupt 11298 
  def __repr__(self):
11299 
    L = ['%s=%r' % (key, value)
11300 
      for key, value in self.__dict__.iteritems()]
11301 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11302 
 
11303 
  def __eq__(self, other):
11304 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11305 
 
11306 
  def __ne__(self, other):
11307 
    return not (self == other)
11308 
 
11309 
class getReturnableOrdersForCustomer_result:
11310 
  """
11311 
  Attributes:
11312 
   - success
11313 
   - ex
11314 
  """
11315 
 
11316 
  thrift_spec = (
11317 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
11318 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
11319 
  )
11320 
 
11321 
  def __init__(self, success=None, ex=None,):
11322 
    self.success = success
11323 
    self.ex = ex
11324 
 
11325 
  def read(self, iprot):
11326 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11327 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11328 
      return
11329 
    iprot.readStructBegin()
11330 
    while True:
11331 
      (fname, ftype, fid) = iprot.readFieldBegin()
11332 
      if ftype == TType.STOP:
11333 
        break
11334 
      if fid == 0:
11335 
        if ftype == TType.LIST:
11336 
          self.success = []
6188 rajveer 11337 
          (_etype172, _size169) = iprot.readListBegin()
11338 
          for _i173 in xrange(_size169):
11339 
            _elem174 = iprot.readI64();
11340 
            self.success.append(_elem174)
1382 varun.gupt 11341 
          iprot.readListEnd()
11342 
        else:
11343 
          iprot.skip(ftype)
11344 
      elif fid == 1:
11345 
        if ftype == TType.STRUCT:
11346 
          self.ex = TransactionServiceException()
11347 
          self.ex.read(iprot)
11348 
        else:
11349 
          iprot.skip(ftype)
11350 
      else:
11351 
        iprot.skip(ftype)
11352 
      iprot.readFieldEnd()
11353 
    iprot.readStructEnd()
11354 
 
11355 
  def write(self, oprot):
11356 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11357 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11358 
      return
11359 
    oprot.writeStructBegin('getReturnableOrdersForCustomer_result')
3431 rajveer 11360 
    if self.success is not None:
1382 varun.gupt 11361 
      oprot.writeFieldBegin('success', TType.LIST, 0)
11362 
      oprot.writeListBegin(TType.I64, len(self.success))
6188 rajveer 11363 
      for iter175 in self.success:
11364 
        oprot.writeI64(iter175)
1382 varun.gupt 11365 
      oprot.writeListEnd()
11366 
      oprot.writeFieldEnd()
3431 rajveer 11367 
    if self.ex is not None:
1382 varun.gupt 11368 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11369 
      self.ex.write(oprot)
11370 
      oprot.writeFieldEnd()
11371 
    oprot.writeFieldStop()
11372 
    oprot.writeStructEnd()
11373 
 
3431 rajveer 11374 
  def validate(self):
11375 
    return
11376 
 
11377 
 
1382 varun.gupt 11378 
  def __repr__(self):
11379 
    L = ['%s=%r' % (key, value)
11380 
      for key, value in self.__dict__.iteritems()]
11381 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11382 
 
11383 
  def __eq__(self, other):
11384 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11385 
 
11386 
  def __ne__(self, other):
11387 
    return not (self == other)
11388 
 
11389 
class getCancellableOrdersForCustomer_args:
11390 
  """
11391 
  Attributes:
11392 
   - customer_id
11393 
   - limit
11394 
  """
11395 
 
11396 
  thrift_spec = (
11397 
    None, # 0
11398 
    (1, TType.I64, 'customer_id', None, None, ), # 1
11399 
    (2, TType.I64, 'limit', None, None, ), # 2
11400 
  )
11401 
 
11402 
  def __init__(self, customer_id=None, limit=None,):
11403 
    self.customer_id = customer_id
11404 
    self.limit = limit
11405 
 
11406 
  def read(self, iprot):
11407 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11408 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11409 
      return
11410 
    iprot.readStructBegin()
11411 
    while True:
11412 
      (fname, ftype, fid) = iprot.readFieldBegin()
11413 
      if ftype == TType.STOP:
11414 
        break
11415 
      if fid == 1:
11416 
        if ftype == TType.I64:
11417 
          self.customer_id = iprot.readI64();
11418 
        else:
11419 
          iprot.skip(ftype)
11420 
      elif fid == 2:
11421 
        if ftype == TType.I64:
11422 
          self.limit = iprot.readI64();
11423 
        else:
11424 
          iprot.skip(ftype)
11425 
      else:
11426 
        iprot.skip(ftype)
11427 
      iprot.readFieldEnd()
11428 
    iprot.readStructEnd()
11429 
 
11430 
  def write(self, oprot):
11431 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11432 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11433 
      return
11434 
    oprot.writeStructBegin('getCancellableOrdersForCustomer_args')
3431 rajveer 11435 
    if self.customer_id is not None:
1382 varun.gupt 11436 
      oprot.writeFieldBegin('customer_id', TType.I64, 1)
11437 
      oprot.writeI64(self.customer_id)
11438 
      oprot.writeFieldEnd()
3431 rajveer 11439 
    if self.limit is not None:
1382 varun.gupt 11440 
      oprot.writeFieldBegin('limit', TType.I64, 2)
11441 
      oprot.writeI64(self.limit)
11442 
      oprot.writeFieldEnd()
11443 
    oprot.writeFieldStop()
11444 
    oprot.writeStructEnd()
11445 
 
3431 rajveer 11446 
  def validate(self):
11447 
    return
11448 
 
11449 
 
1382 varun.gupt 11450 
  def __repr__(self):
11451 
    L = ['%s=%r' % (key, value)
11452 
      for key, value in self.__dict__.iteritems()]
11453 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11454 
 
11455 
  def __eq__(self, other):
11456 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11457 
 
11458 
  def __ne__(self, other):
11459 
    return not (self == other)
11460 
 
11461 
class getCancellableOrdersForCustomer_result:
11462 
  """
11463 
  Attributes:
11464 
   - success
11465 
   - ex
11466 
  """
11467 
 
11468 
  thrift_spec = (
11469 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
11470 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
11471 
  )
11472 
 
11473 
  def __init__(self, success=None, ex=None,):
11474 
    self.success = success
11475 
    self.ex = ex
11476 
 
11477 
  def read(self, iprot):
11478 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11479 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11480 
      return
11481 
    iprot.readStructBegin()
11482 
    while True:
11483 
      (fname, ftype, fid) = iprot.readFieldBegin()
11484 
      if ftype == TType.STOP:
11485 
        break
11486 
      if fid == 0:
11487 
        if ftype == TType.LIST:
11488 
          self.success = []
6188 rajveer 11489 
          (_etype179, _size176) = iprot.readListBegin()
11490 
          for _i180 in xrange(_size176):
11491 
            _elem181 = iprot.readI64();
11492 
            self.success.append(_elem181)
1382 varun.gupt 11493 
          iprot.readListEnd()
11494 
        else:
11495 
          iprot.skip(ftype)
11496 
      elif fid == 1:
11497 
        if ftype == TType.STRUCT:
11498 
          self.ex = TransactionServiceException()
11499 
          self.ex.read(iprot)
11500 
        else:
11501 
          iprot.skip(ftype)
11502 
      else:
11503 
        iprot.skip(ftype)
11504 
      iprot.readFieldEnd()
11505 
    iprot.readStructEnd()
11506 
 
11507 
  def write(self, oprot):
11508 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11509 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11510 
      return
11511 
    oprot.writeStructBegin('getCancellableOrdersForCustomer_result')
3431 rajveer 11512 
    if self.success is not None:
1382 varun.gupt 11513 
      oprot.writeFieldBegin('success', TType.LIST, 0)
11514 
      oprot.writeListBegin(TType.I64, len(self.success))
6188 rajveer 11515 
      for iter182 in self.success:
11516 
        oprot.writeI64(iter182)
1382 varun.gupt 11517 
      oprot.writeListEnd()
11518 
      oprot.writeFieldEnd()
3431 rajveer 11519 
    if self.ex is not None:
1382 varun.gupt 11520 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11521 
      self.ex.write(oprot)
11522 
      oprot.writeFieldEnd()
11523 
    oprot.writeFieldStop()
11524 
    oprot.writeStructEnd()
11525 
 
3431 rajveer 11526 
  def validate(self):
11527 
    return
11528 
 
11529 
 
1382 varun.gupt 11530 
  def __repr__(self):
11531 
    L = ['%s=%r' % (key, value)
11532 
      for key, value in self.__dict__.iteritems()]
11533 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11534 
 
11535 
  def __eq__(self, other):
11536 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11537 
 
11538 
  def __ne__(self, other):
11539 
    return not (self == other)
11540 
 
483 rajveer 11541 
class changeOrderStatus_args:
94 ashish 11542 
  """
11543 
  Attributes:
483 rajveer 11544 
   - orderId
11545 
   - status
11546 
   - description
94 ashish 11547 
  """
11548 
 
11549 
  thrift_spec = (
11550 
    None, # 0
483 rajveer 11551 
    (1, TType.I64, 'orderId', None, None, ), # 1
11552 
    (2, TType.I32, 'status', None, None, ), # 2
11553 
    (3, TType.STRING, 'description', None, None, ), # 3
94 ashish 11554 
  )
11555 
 
483 rajveer 11556 
  def __init__(self, orderId=None, status=None, description=None,):
11557 
    self.orderId = orderId
11558 
    self.status = status
11559 
    self.description = description
94 ashish 11560 
 
11561 
  def read(self, iprot):
11562 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11563 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11564 
      return
11565 
    iprot.readStructBegin()
11566 
    while True:
11567 
      (fname, ftype, fid) = iprot.readFieldBegin()
11568 
      if ftype == TType.STOP:
11569 
        break
11570 
      if fid == 1:
11571 
        if ftype == TType.I64:
483 rajveer 11572 
          self.orderId = iprot.readI64();
94 ashish 11573 
        else:
11574 
          iprot.skip(ftype)
11575 
      elif fid == 2:
483 rajveer 11576 
        if ftype == TType.I32:
11577 
          self.status = iprot.readI32();
94 ashish 11578 
        else:
11579 
          iprot.skip(ftype)
483 rajveer 11580 
      elif fid == 3:
11581 
        if ftype == TType.STRING:
11582 
          self.description = iprot.readString();
11583 
        else:
11584 
          iprot.skip(ftype)
94 ashish 11585 
      else:
11586 
        iprot.skip(ftype)
11587 
      iprot.readFieldEnd()
11588 
    iprot.readStructEnd()
11589 
 
11590 
  def write(self, oprot):
11591 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11592 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11593 
      return
483 rajveer 11594 
    oprot.writeStructBegin('changeOrderStatus_args')
3431 rajveer 11595 
    if self.orderId is not None:
483 rajveer 11596 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
11597 
      oprot.writeI64(self.orderId)
94 ashish 11598 
      oprot.writeFieldEnd()
3431 rajveer 11599 
    if self.status is not None:
483 rajveer 11600 
      oprot.writeFieldBegin('status', TType.I32, 2)
11601 
      oprot.writeI32(self.status)
94 ashish 11602 
      oprot.writeFieldEnd()
3431 rajveer 11603 
    if self.description is not None:
483 rajveer 11604 
      oprot.writeFieldBegin('description', TType.STRING, 3)
11605 
      oprot.writeString(self.description)
11606 
      oprot.writeFieldEnd()
94 ashish 11607 
    oprot.writeFieldStop()
11608 
    oprot.writeStructEnd()
11609 
 
3431 rajveer 11610 
  def validate(self):
11611 
    return
11612 
 
11613 
 
94 ashish 11614 
  def __repr__(self):
11615 
    L = ['%s=%r' % (key, value)
11616 
      for key, value in self.__dict__.iteritems()]
11617 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11618 
 
11619 
  def __eq__(self, other):
11620 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11621 
 
11622 
  def __ne__(self, other):
11623 
    return not (self == other)
11624 
 
483 rajveer 11625 
class changeOrderStatus_result:
94 ashish 11626 
  """
11627 
  Attributes:
11628 
   - success
11629 
   - ex
11630 
  """
11631 
 
11632 
  thrift_spec = (
11633 
    (0, TType.BOOL, 'success', None, None, ), # 0
11634 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
11635 
  )
11636 
 
11637 
  def __init__(self, success=None, ex=None,):
11638 
    self.success = success
11639 
    self.ex = ex
11640 
 
11641 
  def read(self, iprot):
11642 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11643 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11644 
      return
11645 
    iprot.readStructBegin()
11646 
    while True:
11647 
      (fname, ftype, fid) = iprot.readFieldBegin()
11648 
      if ftype == TType.STOP:
11649 
        break
11650 
      if fid == 0:
11651 
        if ftype == TType.BOOL:
11652 
          self.success = iprot.readBool();
11653 
        else:
11654 
          iprot.skip(ftype)
11655 
      elif fid == 1:
11656 
        if ftype == TType.STRUCT:
11657 
          self.ex = TransactionServiceException()
11658 
          self.ex.read(iprot)
11659 
        else:
11660 
          iprot.skip(ftype)
11661 
      else:
11662 
        iprot.skip(ftype)
11663 
      iprot.readFieldEnd()
11664 
    iprot.readStructEnd()
11665 
 
11666 
  def write(self, oprot):
11667 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11668 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11669 
      return
483 rajveer 11670 
    oprot.writeStructBegin('changeOrderStatus_result')
3431 rajveer 11671 
    if self.success is not None:
94 ashish 11672 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
11673 
      oprot.writeBool(self.success)
11674 
      oprot.writeFieldEnd()
3431 rajveer 11675 
    if self.ex is not None:
94 ashish 11676 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11677 
      self.ex.write(oprot)
11678 
      oprot.writeFieldEnd()
11679 
    oprot.writeFieldStop()
11680 
    oprot.writeStructEnd()
11681 
 
3431 rajveer 11682 
  def validate(self):
11683 
    return
11684 
 
11685 
 
94 ashish 11686 
  def __repr__(self):
11687 
    L = ['%s=%r' % (key, value)
11688 
      for key, value in self.__dict__.iteritems()]
11689 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11690 
 
11691 
  def __eq__(self, other):
11692 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11693 
 
11694 
  def __ne__(self, other):
11695 
    return not (self == other)
11696 
 
3064 chandransh 11697 
class getOrdersForTransaction_args:
494 rajveer 11698 
  """
11699 
  Attributes:
3064 chandransh 11700 
   - transactionId
11701 
   - customerId
494 rajveer 11702 
  """
11703 
 
11704 
  thrift_spec = (
11705 
    None, # 0
3064 chandransh 11706 
    (1, TType.I64, 'transactionId', None, None, ), # 1
11707 
    (2, TType.I64, 'customerId', None, None, ), # 2
494 rajveer 11708 
  )
11709 
 
3064 chandransh 11710 
  def __init__(self, transactionId=None, customerId=None,):
11711 
    self.transactionId = transactionId
11712 
    self.customerId = customerId
494 rajveer 11713 
 
11714 
  def read(self, iprot):
11715 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11716 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11717 
      return
11718 
    iprot.readStructBegin()
11719 
    while True:
11720 
      (fname, ftype, fid) = iprot.readFieldBegin()
11721 
      if ftype == TType.STOP:
11722 
        break
11723 
      if fid == 1:
11724 
        if ftype == TType.I64:
3064 chandransh 11725 
          self.transactionId = iprot.readI64();
494 rajveer 11726 
        else:
11727 
          iprot.skip(ftype)
11728 
      elif fid == 2:
3064 chandransh 11729 
        if ftype == TType.I64:
11730 
          self.customerId = iprot.readI64();
494 rajveer 11731 
        else:
11732 
          iprot.skip(ftype)
11733 
      else:
11734 
        iprot.skip(ftype)
11735 
      iprot.readFieldEnd()
11736 
    iprot.readStructEnd()
11737 
 
11738 
  def write(self, oprot):
11739 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11740 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11741 
      return
3064 chandransh 11742 
    oprot.writeStructBegin('getOrdersForTransaction_args')
3431 rajveer 11743 
    if self.transactionId is not None:
3064 chandransh 11744 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
11745 
      oprot.writeI64(self.transactionId)
494 rajveer 11746 
      oprot.writeFieldEnd()
3431 rajveer 11747 
    if self.customerId is not None:
3064 chandransh 11748 
      oprot.writeFieldBegin('customerId', TType.I64, 2)
11749 
      oprot.writeI64(self.customerId)
494 rajveer 11750 
      oprot.writeFieldEnd()
11751 
    oprot.writeFieldStop()
11752 
    oprot.writeStructEnd()
11753 
 
3431 rajveer 11754 
  def validate(self):
11755 
    return
11756 
 
11757 
 
494 rajveer 11758 
  def __repr__(self):
11759 
    L = ['%s=%r' % (key, value)
11760 
      for key, value in self.__dict__.iteritems()]
11761 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11762 
 
11763 
  def __eq__(self, other):
11764 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11765 
 
11766 
  def __ne__(self, other):
11767 
    return not (self == other)
11768 
 
3064 chandransh 11769 
class getOrdersForTransaction_result:
494 rajveer 11770 
  """
11771 
  Attributes:
11772 
   - success
11773 
   - ex
11774 
  """
11775 
 
11776 
  thrift_spec = (
3064 chandransh 11777 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
494 rajveer 11778 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
11779 
  )
11780 
 
11781 
  def __init__(self, success=None, ex=None,):
11782 
    self.success = success
11783 
    self.ex = ex
11784 
 
11785 
  def read(self, iprot):
11786 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11787 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11788 
      return
11789 
    iprot.readStructBegin()
11790 
    while True:
11791 
      (fname, ftype, fid) = iprot.readFieldBegin()
11792 
      if ftype == TType.STOP:
11793 
        break
11794 
      if fid == 0:
3064 chandransh 11795 
        if ftype == TType.LIST:
11796 
          self.success = []
6188 rajveer 11797 
          (_etype186, _size183) = iprot.readListBegin()
11798 
          for _i187 in xrange(_size183):
11799 
            _elem188 = Order()
11800 
            _elem188.read(iprot)
11801 
            self.success.append(_elem188)
3064 chandransh 11802 
          iprot.readListEnd()
494 rajveer 11803 
        else:
11804 
          iprot.skip(ftype)
11805 
      elif fid == 1:
11806 
        if ftype == TType.STRUCT:
11807 
          self.ex = TransactionServiceException()
11808 
          self.ex.read(iprot)
11809 
        else:
11810 
          iprot.skip(ftype)
11811 
      else:
11812 
        iprot.skip(ftype)
11813 
      iprot.readFieldEnd()
11814 
    iprot.readStructEnd()
11815 
 
11816 
  def write(self, oprot):
11817 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11818 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11819 
      return
3064 chandransh 11820 
    oprot.writeStructBegin('getOrdersForTransaction_result')
3431 rajveer 11821 
    if self.success is not None:
3064 chandransh 11822 
      oprot.writeFieldBegin('success', TType.LIST, 0)
11823 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 11824 
      for iter189 in self.success:
11825 
        iter189.write(oprot)
3064 chandransh 11826 
      oprot.writeListEnd()
494 rajveer 11827 
      oprot.writeFieldEnd()
3431 rajveer 11828 
    if self.ex is not None:
494 rajveer 11829 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11830 
      self.ex.write(oprot)
11831 
      oprot.writeFieldEnd()
11832 
    oprot.writeFieldStop()
11833 
    oprot.writeStructEnd()
11834 
 
3431 rajveer 11835 
  def validate(self):
11836 
    return
11837 
 
11838 
 
494 rajveer 11839 
  def __repr__(self):
11840 
    L = ['%s=%r' % (key, value)
11841 
      for key, value in self.__dict__.iteritems()]
11842 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11843 
 
11844 
  def __eq__(self, other):
11845 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11846 
 
11847 
  def __ne__(self, other):
11848 
    return not (self == other)
11849 
 
3064 chandransh 11850 
class getOrdersForCustomer_args:
1149 chandransh 11851 
  """
11852 
  Attributes:
3064 chandransh 11853 
   - customerId
11854 
   - from_date
11855 
   - to_date
11856 
   - statuses
1149 chandransh 11857 
  """
11858 
 
11859 
  thrift_spec = (
11860 
    None, # 0
3064 chandransh 11861 
    (1, TType.I64, 'customerId', None, None, ), # 1
11862 
    (2, TType.I64, 'from_date', None, None, ), # 2
11863 
    (3, TType.I64, 'to_date', None, None, ), # 3
11864 
    (4, TType.LIST, 'statuses', (TType.I32,None), None, ), # 4
1149 chandransh 11865 
  )
11866 
 
3064 chandransh 11867 
  def __init__(self, customerId=None, from_date=None, to_date=None, statuses=None,):
11868 
    self.customerId = customerId
11869 
    self.from_date = from_date
11870 
    self.to_date = to_date
11871 
    self.statuses = statuses
1149 chandransh 11872 
 
11873 
  def read(self, iprot):
11874 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11875 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11876 
      return
11877 
    iprot.readStructBegin()
11878 
    while True:
11879 
      (fname, ftype, fid) = iprot.readFieldBegin()
11880 
      if ftype == TType.STOP:
11881 
        break
11882 
      if fid == 1:
11883 
        if ftype == TType.I64:
3064 chandransh 11884 
          self.customerId = iprot.readI64();
1149 chandransh 11885 
        else:
11886 
          iprot.skip(ftype)
11887 
      elif fid == 2:
11888 
        if ftype == TType.I64:
3064 chandransh 11889 
          self.from_date = iprot.readI64();
1149 chandransh 11890 
        else:
11891 
          iprot.skip(ftype)
2783 chandransh 11892 
      elif fid == 3:
11893 
        if ftype == TType.I64:
3064 chandransh 11894 
          self.to_date = iprot.readI64();
2783 chandransh 11895 
        else:
11896 
          iprot.skip(ftype)
11897 
      elif fid == 4:
3064 chandransh 11898 
        if ftype == TType.LIST:
11899 
          self.statuses = []
6188 rajveer 11900 
          (_etype193, _size190) = iprot.readListBegin()
11901 
          for _i194 in xrange(_size190):
11902 
            _elem195 = iprot.readI32();
11903 
            self.statuses.append(_elem195)
3064 chandransh 11904 
          iprot.readListEnd()
2783 chandransh 11905 
        else:
11906 
          iprot.skip(ftype)
1149 chandransh 11907 
      else:
11908 
        iprot.skip(ftype)
11909 
      iprot.readFieldEnd()
11910 
    iprot.readStructEnd()
11911 
 
11912 
  def write(self, oprot):
11913 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11914 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11915 
      return
3064 chandransh 11916 
    oprot.writeStructBegin('getOrdersForCustomer_args')
3431 rajveer 11917 
    if self.customerId is not None:
3064 chandransh 11918 
      oprot.writeFieldBegin('customerId', TType.I64, 1)
11919 
      oprot.writeI64(self.customerId)
1149 chandransh 11920 
      oprot.writeFieldEnd()
3431 rajveer 11921 
    if self.from_date is not None:
3064 chandransh 11922 
      oprot.writeFieldBegin('from_date', TType.I64, 2)
11923 
      oprot.writeI64(self.from_date)
1149 chandransh 11924 
      oprot.writeFieldEnd()
3431 rajveer 11925 
    if self.to_date is not None:
3064 chandransh 11926 
      oprot.writeFieldBegin('to_date', TType.I64, 3)
11927 
      oprot.writeI64(self.to_date)
2783 chandransh 11928 
      oprot.writeFieldEnd()
3431 rajveer 11929 
    if self.statuses is not None:
3064 chandransh 11930 
      oprot.writeFieldBegin('statuses', TType.LIST, 4)
11931 
      oprot.writeListBegin(TType.I32, len(self.statuses))
6188 rajveer 11932 
      for iter196 in self.statuses:
11933 
        oprot.writeI32(iter196)
3064 chandransh 11934 
      oprot.writeListEnd()
2783 chandransh 11935 
      oprot.writeFieldEnd()
1149 chandransh 11936 
    oprot.writeFieldStop()
11937 
    oprot.writeStructEnd()
11938 
 
3431 rajveer 11939 
  def validate(self):
11940 
    return
11941 
 
11942 
 
1149 chandransh 11943 
  def __repr__(self):
11944 
    L = ['%s=%r' % (key, value)
11945 
      for key, value in self.__dict__.iteritems()]
11946 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11947 
 
11948 
  def __eq__(self, other):
11949 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11950 
 
11951 
  def __ne__(self, other):
11952 
    return not (self == other)
11953 
 
3064 chandransh 11954 
class getOrdersForCustomer_result:
1149 chandransh 11955 
  """
11956 
  Attributes:
11957 
   - success
11958 
   - ex
11959 
  """
11960 
 
11961 
  thrift_spec = (
3064 chandransh 11962 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
1149 chandransh 11963 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
11964 
  )
11965 
 
11966 
  def __init__(self, success=None, ex=None,):
11967 
    self.success = success
11968 
    self.ex = ex
11969 
 
11970 
  def read(self, iprot):
11971 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11972 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11973 
      return
11974 
    iprot.readStructBegin()
11975 
    while True:
11976 
      (fname, ftype, fid) = iprot.readFieldBegin()
11977 
      if ftype == TType.STOP:
11978 
        break
11979 
      if fid == 0:
3064 chandransh 11980 
        if ftype == TType.LIST:
11981 
          self.success = []
6188 rajveer 11982 
          (_etype200, _size197) = iprot.readListBegin()
11983 
          for _i201 in xrange(_size197):
11984 
            _elem202 = Order()
11985 
            _elem202.read(iprot)
11986 
            self.success.append(_elem202)
3064 chandransh 11987 
          iprot.readListEnd()
1149 chandransh 11988 
        else:
11989 
          iprot.skip(ftype)
11990 
      elif fid == 1:
11991 
        if ftype == TType.STRUCT:
11992 
          self.ex = TransactionServiceException()
11993 
          self.ex.read(iprot)
11994 
        else:
11995 
          iprot.skip(ftype)
11996 
      else:
11997 
        iprot.skip(ftype)
11998 
      iprot.readFieldEnd()
11999 
    iprot.readStructEnd()
12000 
 
12001 
  def write(self, oprot):
12002 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12003 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12004 
      return
3064 chandransh 12005 
    oprot.writeStructBegin('getOrdersForCustomer_result')
3431 rajveer 12006 
    if self.success is not None:
3064 chandransh 12007 
      oprot.writeFieldBegin('success', TType.LIST, 0)
12008 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 12009 
      for iter203 in self.success:
12010 
        iter203.write(oprot)
3064 chandransh 12011 
      oprot.writeListEnd()
1149 chandransh 12012 
      oprot.writeFieldEnd()
3431 rajveer 12013 
    if self.ex is not None:
1149 chandransh 12014 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
12015 
      self.ex.write(oprot)
12016 
      oprot.writeFieldEnd()
12017 
    oprot.writeFieldStop()
12018 
    oprot.writeStructEnd()
12019 
 
3431 rajveer 12020 
  def validate(self):
12021 
    return
12022 
 
12023 
 
1149 chandransh 12024 
  def __repr__(self):
12025 
    L = ['%s=%r' % (key, value)
12026 
      for key, value in self.__dict__.iteritems()]
12027 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12028 
 
12029 
  def __eq__(self, other):
12030 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12031 
 
12032 
  def __ne__(self, other):
12033 
    return not (self == other)
12034 
 
3064 chandransh 12035 
class createOrder_args:
921 rajveer 12036 
  """
12037 
  Attributes:
3064 chandransh 12038 
   - order
921 rajveer 12039 
  """
12040 
 
12041 
  thrift_spec = (
12042 
    None, # 0
3064 chandransh 12043 
    (1, TType.STRUCT, 'order', (Order, Order.thrift_spec), None, ), # 1
921 rajveer 12044 
  )
12045 
 
3064 chandransh 12046 
  def __init__(self, order=None,):
12047 
    self.order = order
921 rajveer 12048 
 
12049 
  def read(self, iprot):
12050 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12051 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12052 
      return
12053 
    iprot.readStructBegin()
12054 
    while True:
12055 
      (fname, ftype, fid) = iprot.readFieldBegin()
12056 
      if ftype == TType.STOP:
12057 
        break
12058 
      if fid == 1:
3064 chandransh 12059 
        if ftype == TType.STRUCT:
12060 
          self.order = Order()
12061 
          self.order.read(iprot)
921 rajveer 12062 
        else:
12063 
          iprot.skip(ftype)
12064 
      else:
12065 
        iprot.skip(ftype)
12066 
      iprot.readFieldEnd()
12067 
    iprot.readStructEnd()
12068 
 
12069 
  def write(self, oprot):
12070 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12071 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12072 
      return
3064 chandransh 12073 
    oprot.writeStructBegin('createOrder_args')
3431 rajveer 12074 
    if self.order is not None:
3064 chandransh 12075 
      oprot.writeFieldBegin('order', TType.STRUCT, 1)
12076 
      self.order.write(oprot)
921 rajveer 12077 
      oprot.writeFieldEnd()
12078 
    oprot.writeFieldStop()
12079 
    oprot.writeStructEnd()
12080 
 
3431 rajveer 12081 
  def validate(self):
12082 
    return
12083 
 
12084 
 
921 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 createOrder_result:
921 rajveer 12097 
  """
12098 
  Attributes:
12099 
   - success
12100 
   - ex
12101 
  """
12102 
 
12103 
  thrift_spec = (
3064 chandransh 12104 
    (0, TType.I64, 'success', None, None, ), # 0
921 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.I64:
12123 
          self.success = iprot.readI64();
921 rajveer 12124 
        else:
12125 
          iprot.skip(ftype)
12126 
      elif fid == 1:
12127 
        if ftype == TType.STRUCT:
12128 
          self.ex = TransactionServiceException()
12129 
          self.ex.read(iprot)
12130 
        else:
12131 
          iprot.skip(ftype)
12132 
      else:
12133 
        iprot.skip(ftype)
12134 
      iprot.readFieldEnd()
12135 
    iprot.readStructEnd()
12136 
 
12137 
  def write(self, oprot):
12138 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12139 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12140 
      return
3064 chandransh 12141 
    oprot.writeStructBegin('createOrder_result')
3431 rajveer 12142 
    if self.success is not None:
3064 chandransh 12143 
      oprot.writeFieldBegin('success', TType.I64, 0)
12144 
      oprot.writeI64(self.success)
921 rajveer 12145 
      oprot.writeFieldEnd()
3431 rajveer 12146 
    if self.ex is not None:
921 rajveer 12147 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
12148 
      self.ex.write(oprot)
12149 
      oprot.writeFieldEnd()
12150 
    oprot.writeFieldStop()
12151 
    oprot.writeStructEnd()
12152 
 
3431 rajveer 12153 
  def validate(self):
12154 
    return
12155 
 
12156 
 
921 rajveer 12157 
  def __repr__(self):
12158 
    L = ['%s=%r' % (key, value)
12159 
      for key, value in self.__dict__.iteritems()]
12160 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12161 
 
12162 
  def __eq__(self, other):
12163 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12164 
 
12165 
  def __ne__(self, other):
12166 
    return not (self == other)
12167 
 
3064 chandransh 12168 
class getOrder_args:
921 rajveer 12169 
  """
12170 
  Attributes:
3064 chandransh 12171 
   - id
921 rajveer 12172 
  """
12173 
 
12174 
  thrift_spec = (
12175 
    None, # 0
3064 chandransh 12176 
    (1, TType.I64, 'id', None, None, ), # 1
921 rajveer 12177 
  )
12178 
 
3064 chandransh 12179 
  def __init__(self, id=None,):
12180 
    self.id = id
921 rajveer 12181 
 
12182 
  def read(self, iprot):
12183 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12184 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12185 
      return
12186 
    iprot.readStructBegin()
12187 
    while True:
12188 
      (fname, ftype, fid) = iprot.readFieldBegin()
12189 
      if ftype == TType.STOP:
12190 
        break
12191 
      if fid == 1:
12192 
        if ftype == TType.I64:
3064 chandransh 12193 
          self.id = iprot.readI64();
921 rajveer 12194 
        else:
12195 
          iprot.skip(ftype)
12196 
      else:
12197 
        iprot.skip(ftype)
12198 
      iprot.readFieldEnd()
12199 
    iprot.readStructEnd()
12200 
 
12201 
  def write(self, oprot):
12202 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12203 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12204 
      return
3064 chandransh 12205 
    oprot.writeStructBegin('getOrder_args')
3431 rajveer 12206 
    if self.id is not None:
3064 chandransh 12207 
      oprot.writeFieldBegin('id', TType.I64, 1)
12208 
      oprot.writeI64(self.id)
921 rajveer 12209 
      oprot.writeFieldEnd()
12210 
    oprot.writeFieldStop()
12211 
    oprot.writeStructEnd()
12212 
 
3431 rajveer 12213 
  def validate(self):
12214 
    return
12215 
 
12216 
 
921 rajveer 12217 
  def __repr__(self):
12218 
    L = ['%s=%r' % (key, value)
12219 
      for key, value in self.__dict__.iteritems()]
12220 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12221 
 
12222 
  def __eq__(self, other):
12223 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12224 
 
12225 
  def __ne__(self, other):
12226 
    return not (self == other)
12227 
 
3064 chandransh 12228 
class getOrder_result:
921 rajveer 12229 
  """
12230 
  Attributes:
12231 
   - success
12232 
   - ex
12233 
  """
12234 
 
12235 
  thrift_spec = (
3064 chandransh 12236 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
921 rajveer 12237 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
12238 
  )
12239 
 
12240 
  def __init__(self, success=None, ex=None,):
12241 
    self.success = success
12242 
    self.ex = ex
12243 
 
12244 
  def read(self, iprot):
12245 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12246 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12247 
      return
12248 
    iprot.readStructBegin()
12249 
    while True:
12250 
      (fname, ftype, fid) = iprot.readFieldBegin()
12251 
      if ftype == TType.STOP:
12252 
        break
12253 
      if fid == 0:
3064 chandransh 12254 
        if ftype == TType.STRUCT:
12255 
          self.success = Order()
12256 
          self.success.read(iprot)
921 rajveer 12257 
        else:
12258 
          iprot.skip(ftype)
12259 
      elif fid == 1:
12260 
        if ftype == TType.STRUCT:
12261 
          self.ex = TransactionServiceException()
12262 
          self.ex.read(iprot)
12263 
        else:
12264 
          iprot.skip(ftype)
12265 
      else:
12266 
        iprot.skip(ftype)
12267 
      iprot.readFieldEnd()
12268 
    iprot.readStructEnd()
12269 
 
12270 
  def write(self, oprot):
12271 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12272 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12273 
      return
3064 chandransh 12274 
    oprot.writeStructBegin('getOrder_result')
3431 rajveer 12275 
    if self.success is not None:
3064 chandransh 12276 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
12277 
      self.success.write(oprot)
921 rajveer 12278 
      oprot.writeFieldEnd()
3431 rajveer 12279 
    if self.ex is not None:
921 rajveer 12280 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
12281 
      self.ex.write(oprot)
12282 
      oprot.writeFieldEnd()
12283 
    oprot.writeFieldStop()
12284 
    oprot.writeStructEnd()
12285 
 
3431 rajveer 12286 
  def validate(self):
12287 
    return
12288 
 
12289 
 
921 rajveer 12290 
  def __repr__(self):
12291 
    L = ['%s=%r' % (key, value)
12292 
      for key, value in self.__dict__.iteritems()]
12293 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12294 
 
12295 
  def __eq__(self, other):
12296 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12297 
 
12298 
  def __ne__(self, other):
12299 
    return not (self == other)
12300 
 
3064 chandransh 12301 
class getLineItemsForOrder_args:
94 ashish 12302 
  """
12303 
  Attributes:
3064 chandransh 12304 
   - orderId
94 ashish 12305 
  """
12306 
 
12307 
  thrift_spec = (
12308 
    None, # 0
3064 chandransh 12309 
    (1, TType.I64, 'orderId', None, None, ), # 1
94 ashish 12310 
  )
12311 
 
3064 chandransh 12312 
  def __init__(self, orderId=None,):
12313 
    self.orderId = orderId
94 ashish 12314 
 
12315 
  def read(self, iprot):
12316 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12317 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12318 
      return
12319 
    iprot.readStructBegin()
12320 
    while True:
12321 
      (fname, ftype, fid) = iprot.readFieldBegin()
12322 
      if ftype == TType.STOP:
12323 
        break
12324 
      if fid == 1:
12325 
        if ftype == TType.I64:
3064 chandransh 12326 
          self.orderId = iprot.readI64();
94 ashish 12327 
        else:
12328 
          iprot.skip(ftype)
12329 
      else:
12330 
        iprot.skip(ftype)
12331 
      iprot.readFieldEnd()
12332 
    iprot.readStructEnd()
12333 
 
12334 
  def write(self, oprot):
12335 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12336 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12337 
      return
3064 chandransh 12338 
    oprot.writeStructBegin('getLineItemsForOrder_args')
3431 rajveer 12339 
    if self.orderId is not None:
3064 chandransh 12340 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
12341 
      oprot.writeI64(self.orderId)
94 ashish 12342 
      oprot.writeFieldEnd()
12343 
    oprot.writeFieldStop()
12344 
    oprot.writeStructEnd()
12345 
 
3431 rajveer 12346 
  def validate(self):
12347 
    return
12348 
 
12349 
 
94 ashish 12350 
  def __repr__(self):
12351 
    L = ['%s=%r' % (key, value)
12352 
      for key, value in self.__dict__.iteritems()]
12353 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12354 
 
12355 
  def __eq__(self, other):
12356 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12357 
 
12358 
  def __ne__(self, other):
12359 
    return not (self == other)
12360 
 
3064 chandransh 12361 
class getLineItemsForOrder_result:
94 ashish 12362 
  """
12363 
  Attributes:
12364 
   - success
12365 
   - ex
12366 
  """
12367 
 
12368 
  thrift_spec = (
3064 chandransh 12369 
    (0, TType.LIST, 'success', (TType.STRUCT,(LineItem, LineItem.thrift_spec)), None, ), # 0
94 ashish 12370 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
12371 
  )
12372 
 
12373 
  def __init__(self, success=None, ex=None,):
12374 
    self.success = success
12375 
    self.ex = ex
12376 
 
12377 
  def read(self, iprot):
12378 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12379 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12380 
      return
12381 
    iprot.readStructBegin()
12382 
    while True:
12383 
      (fname, ftype, fid) = iprot.readFieldBegin()
12384 
      if ftype == TType.STOP:
12385 
        break
12386 
      if fid == 0:
483 rajveer 12387 
        if ftype == TType.LIST:
12388 
          self.success = []
6188 rajveer 12389 
          (_etype207, _size204) = iprot.readListBegin()
12390 
          for _i208 in xrange(_size204):
12391 
            _elem209 = LineItem()
12392 
            _elem209.read(iprot)
12393 
            self.success.append(_elem209)
483 rajveer 12394 
          iprot.readListEnd()
94 ashish 12395 
        else:
12396 
          iprot.skip(ftype)
12397 
      elif fid == 1:
12398 
        if ftype == TType.STRUCT:
12399 
          self.ex = TransactionServiceException()
12400 
          self.ex.read(iprot)
12401 
        else:
12402 
          iprot.skip(ftype)
12403 
      else:
12404 
        iprot.skip(ftype)
12405 
      iprot.readFieldEnd()
12406 
    iprot.readStructEnd()
12407 
 
12408 
  def write(self, oprot):
12409 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12410 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12411 
      return
3064 chandransh 12412 
    oprot.writeStructBegin('getLineItemsForOrder_result')
3431 rajveer 12413 
    if self.success is not None:
483 rajveer 12414 
      oprot.writeFieldBegin('success', TType.LIST, 0)
12415 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 12416 
      for iter210 in self.success:
12417 
        iter210.write(oprot)
483 rajveer 12418 
      oprot.writeListEnd()
94 ashish 12419 
      oprot.writeFieldEnd()
3431 rajveer 12420 
    if self.ex is not None:
94 ashish 12421 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
12422 
      self.ex.write(oprot)
12423 
      oprot.writeFieldEnd()
12424 
    oprot.writeFieldStop()
12425 
    oprot.writeStructEnd()
12426 
 
3431 rajveer 12427 
  def validate(self):
12428 
    return
12429 
 
12430 
 
94 ashish 12431 
  def __repr__(self):
12432 
    L = ['%s=%r' % (key, value)
12433 
      for key, value in self.__dict__.iteritems()]
12434 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12435 
 
12436 
  def __eq__(self, other):
12437 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12438 
 
12439 
  def __ne__(self, other):
12440 
    return not (self == other)
12441 
 
4999 phani.kuma 12442 
class getOrderList_args:
12443 
  """
12444 
  Attributes:
12445 
   - order_ids
12446 
  """
12447 
 
12448 
  thrift_spec = (
12449 
    None, # 0
12450 
    (1, TType.LIST, 'order_ids', (TType.I64,None), None, ), # 1
12451 
  )
12452 
 
12453 
  def __init__(self, order_ids=None,):
12454 
    self.order_ids = order_ids
12455 
 
12456 
  def read(self, iprot):
12457 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12458 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12459 
      return
12460 
    iprot.readStructBegin()
12461 
    while True:
12462 
      (fname, ftype, fid) = iprot.readFieldBegin()
12463 
      if ftype == TType.STOP:
12464 
        break
12465 
      if fid == 1:
12466 
        if ftype == TType.LIST:
12467 
          self.order_ids = []
6188 rajveer 12468 
          (_etype214, _size211) = iprot.readListBegin()
12469 
          for _i215 in xrange(_size211):
12470 
            _elem216 = iprot.readI64();
12471 
            self.order_ids.append(_elem216)
4999 phani.kuma 12472 
          iprot.readListEnd()
12473 
        else:
12474 
          iprot.skip(ftype)
12475 
      else:
12476 
        iprot.skip(ftype)
12477 
      iprot.readFieldEnd()
12478 
    iprot.readStructEnd()
12479 
 
12480 
  def write(self, oprot):
12481 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12482 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12483 
      return
12484 
    oprot.writeStructBegin('getOrderList_args')
12485 
    if self.order_ids is not None:
12486 
      oprot.writeFieldBegin('order_ids', TType.LIST, 1)
12487 
      oprot.writeListBegin(TType.I64, len(self.order_ids))
6188 rajveer 12488 
      for iter217 in self.order_ids:
12489 
        oprot.writeI64(iter217)
4999 phani.kuma 12490 
      oprot.writeListEnd()
12491 
      oprot.writeFieldEnd()
12492 
    oprot.writeFieldStop()
12493 
    oprot.writeStructEnd()
12494 
 
12495 
  def validate(self):
12496 
    return
12497 
 
12498 
 
12499 
  def __repr__(self):
12500 
    L = ['%s=%r' % (key, value)
12501 
      for key, value in self.__dict__.iteritems()]
12502 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12503 
 
12504 
  def __eq__(self, other):
12505 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12506 
 
12507 
  def __ne__(self, other):
12508 
    return not (self == other)
12509 
 
12510 
class getOrderList_result:
12511 
  """
12512 
  Attributes:
12513 
   - success
12514 
  """
12515 
 
12516 
  thrift_spec = (
12517 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
12518 
  )
12519 
 
12520 
  def __init__(self, success=None,):
12521 
    self.success = success
12522 
 
12523 
  def read(self, iprot):
12524 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12525 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12526 
      return
12527 
    iprot.readStructBegin()
12528 
    while True:
12529 
      (fname, ftype, fid) = iprot.readFieldBegin()
12530 
      if ftype == TType.STOP:
12531 
        break
12532 
      if fid == 0:
12533 
        if ftype == TType.LIST:
12534 
          self.success = []
6188 rajveer 12535 
          (_etype221, _size218) = iprot.readListBegin()
12536 
          for _i222 in xrange(_size218):
12537 
            _elem223 = Order()
12538 
            _elem223.read(iprot)
12539 
            self.success.append(_elem223)
4999 phani.kuma 12540 
          iprot.readListEnd()
12541 
        else:
12542 
          iprot.skip(ftype)
12543 
      else:
12544 
        iprot.skip(ftype)
12545 
      iprot.readFieldEnd()
12546 
    iprot.readStructEnd()
12547 
 
12548 
  def write(self, oprot):
12549 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12550 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12551 
      return
12552 
    oprot.writeStructBegin('getOrderList_result')
12553 
    if self.success is not None:
12554 
      oprot.writeFieldBegin('success', TType.LIST, 0)
12555 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 12556 
      for iter224 in self.success:
12557 
        iter224.write(oprot)
4999 phani.kuma 12558 
      oprot.writeListEnd()
12559 
      oprot.writeFieldEnd()
12560 
    oprot.writeFieldStop()
12561 
    oprot.writeStructEnd()
12562 
 
12563 
  def validate(self):
12564 
    return
12565 
 
12566 
 
12567 
  def __repr__(self):
12568 
    L = ['%s=%r' % (key, value)
12569 
      for key, value in self.__dict__.iteritems()]
12570 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12571 
 
12572 
  def __eq__(self, other):
12573 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12574 
 
12575 
  def __ne__(self, other):
12576 
    return not (self == other)
12577 
 
5386 phani.kuma 12578 
class getOrderListForVendor_args:
12579 
  """
12580 
  Attributes:
12581 
   - order_ids
12582 
   - vendorId
12583 
  """
12584 
 
12585 
  thrift_spec = (
12586 
    None, # 0
12587 
    (1, TType.LIST, 'order_ids', (TType.I64,None), None, ), # 1
12588 
    (2, TType.I64, 'vendorId', None, None, ), # 2
12589 
  )
12590 
 
12591 
  def __init__(self, order_ids=None, vendorId=None,):
12592 
    self.order_ids = order_ids
12593 
    self.vendorId = vendorId
12594 
 
12595 
  def read(self, iprot):
12596 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12597 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12598 
      return
12599 
    iprot.readStructBegin()
12600 
    while True:
12601 
      (fname, ftype, fid) = iprot.readFieldBegin()
12602 
      if ftype == TType.STOP:
12603 
        break
12604 
      if fid == 1:
12605 
        if ftype == TType.LIST:
12606 
          self.order_ids = []
6188 rajveer 12607 
          (_etype228, _size225) = iprot.readListBegin()
12608 
          for _i229 in xrange(_size225):
12609 
            _elem230 = iprot.readI64();
12610 
            self.order_ids.append(_elem230)
5386 phani.kuma 12611 
          iprot.readListEnd()
12612 
        else:
12613 
          iprot.skip(ftype)
12614 
      elif fid == 2:
12615 
        if ftype == TType.I64:
12616 
          self.vendorId = iprot.readI64();
12617 
        else:
12618 
          iprot.skip(ftype)
12619 
      else:
12620 
        iprot.skip(ftype)
12621 
      iprot.readFieldEnd()
12622 
    iprot.readStructEnd()
12623 
 
12624 
  def write(self, oprot):
12625 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12626 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12627 
      return
12628 
    oprot.writeStructBegin('getOrderListForVendor_args')
12629 
    if self.order_ids is not None:
12630 
      oprot.writeFieldBegin('order_ids', TType.LIST, 1)
12631 
      oprot.writeListBegin(TType.I64, len(self.order_ids))
6188 rajveer 12632 
      for iter231 in self.order_ids:
12633 
        oprot.writeI64(iter231)
5386 phani.kuma 12634 
      oprot.writeListEnd()
12635 
      oprot.writeFieldEnd()
12636 
    if self.vendorId is not None:
12637 
      oprot.writeFieldBegin('vendorId', TType.I64, 2)
12638 
      oprot.writeI64(self.vendorId)
12639 
      oprot.writeFieldEnd()
12640 
    oprot.writeFieldStop()
12641 
    oprot.writeStructEnd()
12642 
 
12643 
  def validate(self):
12644 
    return
12645 
 
12646 
 
12647 
  def __repr__(self):
12648 
    L = ['%s=%r' % (key, value)
12649 
      for key, value in self.__dict__.iteritems()]
12650 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12651 
 
12652 
  def __eq__(self, other):
12653 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12654 
 
12655 
  def __ne__(self, other):
12656 
    return not (self == other)
12657 
 
12658 
class getOrderListForVendor_result:
12659 
  """
12660 
  Attributes:
12661 
   - success
12662 
  """
12663 
 
12664 
  thrift_spec = (
12665 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
12666 
  )
12667 
 
12668 
  def __init__(self, success=None,):
12669 
    self.success = success
12670 
 
12671 
  def read(self, iprot):
12672 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12673 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12674 
      return
12675 
    iprot.readStructBegin()
12676 
    while True:
12677 
      (fname, ftype, fid) = iprot.readFieldBegin()
12678 
      if ftype == TType.STOP:
12679 
        break
12680 
      if fid == 0:
12681 
        if ftype == TType.LIST:
12682 
          self.success = []
6188 rajveer 12683 
          (_etype235, _size232) = iprot.readListBegin()
12684 
          for _i236 in xrange(_size232):
12685 
            _elem237 = Order()
12686 
            _elem237.read(iprot)
12687 
            self.success.append(_elem237)
5386 phani.kuma 12688 
          iprot.readListEnd()
12689 
        else:
12690 
          iprot.skip(ftype)
12691 
      else:
12692 
        iprot.skip(ftype)
12693 
      iprot.readFieldEnd()
12694 
    iprot.readStructEnd()
12695 
 
12696 
  def write(self, oprot):
12697 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12698 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12699 
      return
12700 
    oprot.writeStructBegin('getOrderListForVendor_result')
12701 
    if self.success is not None:
12702 
      oprot.writeFieldBegin('success', TType.LIST, 0)
12703 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 12704 
      for iter238 in self.success:
12705 
        iter238.write(oprot)
5386 phani.kuma 12706 
      oprot.writeListEnd()
12707 
      oprot.writeFieldEnd()
12708 
    oprot.writeFieldStop()
12709 
    oprot.writeStructEnd()
12710 
 
12711 
  def validate(self):
12712 
    return
12713 
 
12714 
 
12715 
  def __repr__(self):
12716 
    L = ['%s=%r' % (key, value)
12717 
      for key, value in self.__dict__.iteritems()]
12718 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12719 
 
12720 
  def __eq__(self, other):
12721 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12722 
 
12723 
  def __ne__(self, other):
12724 
    return not (self == other)
12725 
 
3064 chandransh 12726 
class getOrderForCustomer_args:
94 ashish 12727 
  """
12728 
  Attributes:
3064 chandransh 12729 
   - orderId
483 rajveer 12730 
   - customerId
94 ashish 12731 
  """
12732 
 
12733 
  thrift_spec = (
12734 
    None, # 0
3064 chandransh 12735 
    (1, TType.I64, 'orderId', None, None, ), # 1
12736 
    (2, TType.I64, 'customerId', None, None, ), # 2
94 ashish 12737 
  )
12738 
 
3064 chandransh 12739 
  def __init__(self, orderId=None, customerId=None,):
12740 
    self.orderId = orderId
483 rajveer 12741 
    self.customerId = customerId
94 ashish 12742 
 
12743 
  def read(self, iprot):
12744 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12745 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12746 
      return
12747 
    iprot.readStructBegin()
12748 
    while True:
12749 
      (fname, ftype, fid) = iprot.readFieldBegin()
12750 
      if ftype == TType.STOP:
12751 
        break
12752 
      if fid == 1:
12753 
        if ftype == TType.I64:
3064 chandransh 12754 
          self.orderId = iprot.readI64();
94 ashish 12755 
        else:
12756 
          iprot.skip(ftype)
12757 
      elif fid == 2:
12758 
        if ftype == TType.I64:
3064 chandransh 12759 
          self.customerId = iprot.readI64();
94 ashish 12760 
        else:
12761 
          iprot.skip(ftype)
12762 
      else:
12763 
        iprot.skip(ftype)
12764 
      iprot.readFieldEnd()
12765 
    iprot.readStructEnd()
12766 
 
12767 
  def write(self, oprot):
12768 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12769 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12770 
      return
3064 chandransh 12771 
    oprot.writeStructBegin('getOrderForCustomer_args')
3431 rajveer 12772 
    if self.orderId is not None:
3064 chandransh 12773 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
12774 
      oprot.writeI64(self.orderId)
12775 
      oprot.writeFieldEnd()
3431 rajveer 12776 
    if self.customerId is not None:
3064 chandransh 12777 
      oprot.writeFieldBegin('customerId', TType.I64, 2)
483 rajveer 12778 
      oprot.writeI64(self.customerId)
94 ashish 12779 
      oprot.writeFieldEnd()
12780 
    oprot.writeFieldStop()
12781 
    oprot.writeStructEnd()
12782 
 
3431 rajveer 12783 
  def validate(self):
12784 
    return
12785 
 
12786 
 
94 ashish 12787 
  def __repr__(self):
12788 
    L = ['%s=%r' % (key, value)
12789 
      for key, value in self.__dict__.iteritems()]
12790 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12791 
 
12792 
  def __eq__(self, other):
12793 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12794 
 
12795 
  def __ne__(self, other):
12796 
    return not (self == other)
12797 
 
3064 chandransh 12798 
class getOrderForCustomer_result:
94 ashish 12799 
  """
12800 
  Attributes:
12801 
   - success
12802 
   - ex
12803 
  """
12804 
 
12805 
  thrift_spec = (
3064 chandransh 12806 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
94 ashish 12807 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
12808 
  )
12809 
 
12810 
  def __init__(self, success=None, ex=None,):
12811 
    self.success = success
12812 
    self.ex = ex
12813 
 
12814 
  def read(self, iprot):
12815 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12816 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12817 
      return
12818 
    iprot.readStructBegin()
12819 
    while True:
12820 
      (fname, ftype, fid) = iprot.readFieldBegin()
12821 
      if ftype == TType.STOP:
12822 
        break
12823 
      if fid == 0:
3064 chandransh 12824 
        if ftype == TType.STRUCT:
12825 
          self.success = Order()
12826 
          self.success.read(iprot)
94 ashish 12827 
        else:
12828 
          iprot.skip(ftype)
12829 
      elif fid == 1:
12830 
        if ftype == TType.STRUCT:
12831 
          self.ex = TransactionServiceException()
12832 
          self.ex.read(iprot)
12833 
        else:
12834 
          iprot.skip(ftype)
12835 
      else:
12836 
        iprot.skip(ftype)
12837 
      iprot.readFieldEnd()
12838 
    iprot.readStructEnd()
12839 
 
12840 
  def write(self, oprot):
12841 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12842 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12843 
      return
3064 chandransh 12844 
    oprot.writeStructBegin('getOrderForCustomer_result')
3431 rajveer 12845 
    if self.success is not None:
3064 chandransh 12846 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
12847 
      self.success.write(oprot)
94 ashish 12848 
      oprot.writeFieldEnd()
3431 rajveer 12849 
    if self.ex is not None:
94 ashish 12850 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
12851 
      self.ex.write(oprot)
12852 
      oprot.writeFieldEnd()
12853 
    oprot.writeFieldStop()
12854 
    oprot.writeStructEnd()
12855 
 
3431 rajveer 12856 
  def validate(self):
12857 
    return
12858 
 
12859 
 
94 ashish 12860 
  def __repr__(self):
12861 
    L = ['%s=%r' % (key, value)
12862 
      for key, value in self.__dict__.iteritems()]
12863 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12864 
 
12865 
  def __eq__(self, other):
12866 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12867 
 
12868 
  def __ne__(self, other):
12869 
    return not (self == other)
12870 
 
3064 chandransh 12871 
class getAlerts_args:
94 ashish 12872 
  """
12873 
  Attributes:
4394 rajveer 12874 
   - type
4444 rajveer 12875 
   - warehouseId
4394 rajveer 12876 
   - status
12877 
   - timestamp
94 ashish 12878 
  """
12879 
 
12880 
  thrift_spec = (
12881 
    None, # 0
4394 rajveer 12882 
    (1, TType.I64, 'type', None, None, ), # 1
4444 rajveer 12883 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
12884 
    (3, TType.I64, 'status', None, None, ), # 3
12885 
    (4, TType.I64, 'timestamp', None, None, ), # 4
94 ashish 12886 
  )
12887 
 
4444 rajveer 12888 
  def __init__(self, type=None, warehouseId=None, status=None, timestamp=None,):
4394 rajveer 12889 
    self.type = type
4444 rajveer 12890 
    self.warehouseId = warehouseId
4394 rajveer 12891 
    self.status = status
12892 
    self.timestamp = timestamp
94 ashish 12893 
 
12894 
  def read(self, iprot):
12895 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12896 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12897 
      return
12898 
    iprot.readStructBegin()
12899 
    while True:
12900 
      (fname, ftype, fid) = iprot.readFieldBegin()
12901 
      if ftype == TType.STOP:
12902 
        break
12903 
      if fid == 1:
3064 chandransh 12904 
        if ftype == TType.I64:
4394 rajveer 12905 
          self.type = iprot.readI64();
94 ashish 12906 
        else:
12907 
          iprot.skip(ftype)
3064 chandransh 12908 
      elif fid == 2:
4394 rajveer 12909 
        if ftype == TType.I64:
4444 rajveer 12910 
          self.warehouseId = iprot.readI64();
3064 chandransh 12911 
        else:
12912 
          iprot.skip(ftype)
4394 rajveer 12913 
      elif fid == 3:
12914 
        if ftype == TType.I64:
4444 rajveer 12915 
          self.status = iprot.readI64();
12916 
        else:
12917 
          iprot.skip(ftype)
12918 
      elif fid == 4:
12919 
        if ftype == TType.I64:
4394 rajveer 12920 
          self.timestamp = iprot.readI64();
12921 
        else:
12922 
          iprot.skip(ftype)
94 ashish 12923 
      else:
12924 
        iprot.skip(ftype)
12925 
      iprot.readFieldEnd()
12926 
    iprot.readStructEnd()
12927 
 
12928 
  def write(self, oprot):
12929 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12930 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12931 
      return
3064 chandransh 12932 
    oprot.writeStructBegin('getAlerts_args')
4394 rajveer 12933 
    if self.type is not None:
12934 
      oprot.writeFieldBegin('type', TType.I64, 1)
12935 
      oprot.writeI64(self.type)
94 ashish 12936 
      oprot.writeFieldEnd()
4444 rajveer 12937 
    if self.warehouseId is not None:
12938 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
12939 
      oprot.writeI64(self.warehouseId)
12940 
      oprot.writeFieldEnd()
4394 rajveer 12941 
    if self.status is not None:
4444 rajveer 12942 
      oprot.writeFieldBegin('status', TType.I64, 3)
4394 rajveer 12943 
      oprot.writeI64(self.status)
3064 chandransh 12944 
      oprot.writeFieldEnd()
4394 rajveer 12945 
    if self.timestamp is not None:
4444 rajveer 12946 
      oprot.writeFieldBegin('timestamp', TType.I64, 4)
4394 rajveer 12947 
      oprot.writeI64(self.timestamp)
12948 
      oprot.writeFieldEnd()
94 ashish 12949 
    oprot.writeFieldStop()
12950 
    oprot.writeStructEnd()
12951 
 
3431 rajveer 12952 
  def validate(self):
12953 
    return
12954 
 
12955 
 
94 ashish 12956 
  def __repr__(self):
12957 
    L = ['%s=%r' % (key, value)
12958 
      for key, value in self.__dict__.iteritems()]
12959 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12960 
 
12961 
  def __eq__(self, other):
12962 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12963 
 
12964 
  def __ne__(self, other):
12965 
    return not (self == other)
12966 
 
3064 chandransh 12967 
class getAlerts_result:
94 ashish 12968 
  """
12969 
  Attributes:
12970 
   - success
12971 
  """
12972 
 
12973 
  thrift_spec = (
3064 chandransh 12974 
    (0, TType.LIST, 'success', (TType.STRUCT,(Alert, Alert.thrift_spec)), None, ), # 0
94 ashish 12975 
  )
12976 
 
3064 chandransh 12977 
  def __init__(self, success=None,):
94 ashish 12978 
    self.success = success
12979 
 
12980 
  def read(self, iprot):
12981 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12982 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12983 
      return
12984 
    iprot.readStructBegin()
12985 
    while True:
12986 
      (fname, ftype, fid) = iprot.readFieldBegin()
12987 
      if ftype == TType.STOP:
12988 
        break
12989 
      if fid == 0:
3064 chandransh 12990 
        if ftype == TType.LIST:
12991 
          self.success = []
6188 rajveer 12992 
          (_etype242, _size239) = iprot.readListBegin()
12993 
          for _i243 in xrange(_size239):
12994 
            _elem244 = Alert()
12995 
            _elem244.read(iprot)
12996 
            self.success.append(_elem244)
3064 chandransh 12997 
          iprot.readListEnd()
94 ashish 12998 
        else:
12999 
          iprot.skip(ftype)
13000 
      else:
13001 
        iprot.skip(ftype)
13002 
      iprot.readFieldEnd()
13003 
    iprot.readStructEnd()
13004 
 
13005 
  def write(self, oprot):
13006 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13007 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13008 
      return
3064 chandransh 13009 
    oprot.writeStructBegin('getAlerts_result')
3431 rajveer 13010 
    if self.success is not None:
3064 chandransh 13011 
      oprot.writeFieldBegin('success', TType.LIST, 0)
13012 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 13013 
      for iter245 in self.success:
13014 
        iter245.write(oprot)
3064 chandransh 13015 
      oprot.writeListEnd()
94 ashish 13016 
      oprot.writeFieldEnd()
13017 
    oprot.writeFieldStop()
13018 
    oprot.writeStructEnd()
13019 
 
3431 rajveer 13020 
  def validate(self):
13021 
    return
13022 
 
13023 
 
94 ashish 13024 
  def __repr__(self):
13025 
    L = ['%s=%r' % (key, value)
13026 
      for key, value in self.__dict__.iteritems()]
13027 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13028 
 
13029 
  def __eq__(self, other):
13030 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13031 
 
13032 
  def __ne__(self, other):
13033 
    return not (self == other)
13034 
 
4394 rajveer 13035 
class addAlert_args:
94 ashish 13036 
  """
13037 
  Attributes:
3064 chandransh 13038 
   - type
4444 rajveer 13039 
   - warehouseId
4394 rajveer 13040 
   - description
94 ashish 13041 
  """
13042 
 
13043 
  thrift_spec = (
13044 
    None, # 0
4394 rajveer 13045 
    (1, TType.I64, 'type', None, None, ), # 1
4444 rajveer 13046 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
13047 
    (3, TType.STRING, 'description', None, None, ), # 3
94 ashish 13048 
  )
13049 
 
4444 rajveer 13050 
  def __init__(self, type=None, warehouseId=None, description=None,):
3064 chandransh 13051 
    self.type = type
4444 rajveer 13052 
    self.warehouseId = warehouseId
4394 rajveer 13053 
    self.description = description
94 ashish 13054 
 
13055 
  def read(self, iprot):
13056 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13057 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13058 
      return
13059 
    iprot.readStructBegin()
13060 
    while True:
13061 
      (fname, ftype, fid) = iprot.readFieldBegin()
13062 
      if ftype == TType.STOP:
13063 
        break
13064 
      if fid == 1:
13065 
        if ftype == TType.I64:
4394 rajveer 13066 
          self.type = iprot.readI64();
94 ashish 13067 
        else:
13068 
          iprot.skip(ftype)
3064 chandransh 13069 
      elif fid == 2:
4444 rajveer 13070 
        if ftype == TType.I64:
13071 
          self.warehouseId = iprot.readI64();
13072 
        else:
13073 
          iprot.skip(ftype)
13074 
      elif fid == 3:
3064 chandransh 13075 
        if ftype == TType.STRING:
4394 rajveer 13076 
          self.description = iprot.readString();
3064 chandransh 13077 
        else:
13078 
          iprot.skip(ftype)
94 ashish 13079 
      else:
13080 
        iprot.skip(ftype)
13081 
      iprot.readFieldEnd()
13082 
    iprot.readStructEnd()
13083 
 
13084 
  def write(self, oprot):
13085 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13086 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13087 
      return
4394 rajveer 13088 
    oprot.writeStructBegin('addAlert_args')
3431 rajveer 13089 
    if self.type is not None:
4394 rajveer 13090 
      oprot.writeFieldBegin('type', TType.I64, 1)
3064 chandransh 13091 
      oprot.writeI64(self.type)
13092 
      oprot.writeFieldEnd()
4444 rajveer 13093 
    if self.warehouseId is not None:
13094 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
13095 
      oprot.writeI64(self.warehouseId)
13096 
      oprot.writeFieldEnd()
4394 rajveer 13097 
    if self.description is not None:
4444 rajveer 13098 
      oprot.writeFieldBegin('description', TType.STRING, 3)
4394 rajveer 13099 
      oprot.writeString(self.description)
3064 chandransh 13100 
      oprot.writeFieldEnd()
94 ashish 13101 
    oprot.writeFieldStop()
13102 
    oprot.writeStructEnd()
13103 
 
3431 rajveer 13104 
  def validate(self):
13105 
    return
13106 
 
13107 
 
94 ashish 13108 
  def __repr__(self):
13109 
    L = ['%s=%r' % (key, value)
13110 
      for key, value in self.__dict__.iteritems()]
13111 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13112 
 
13113 
  def __eq__(self, other):
13114 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13115 
 
13116 
  def __ne__(self, other):
13117 
    return not (self == other)
13118 
 
4394 rajveer 13119 
class addAlert_result:
3064 chandransh 13120 
 
13121 
  thrift_spec = (
13122 
  )
13123 
 
13124 
  def read(self, iprot):
13125 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13126 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13127 
      return
13128 
    iprot.readStructBegin()
13129 
    while True:
13130 
      (fname, ftype, fid) = iprot.readFieldBegin()
13131 
      if ftype == TType.STOP:
13132 
        break
13133 
      else:
13134 
        iprot.skip(ftype)
13135 
      iprot.readFieldEnd()
13136 
    iprot.readStructEnd()
13137 
 
13138 
  def write(self, oprot):
13139 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13140 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13141 
      return
4394 rajveer 13142 
    oprot.writeStructBegin('addAlert_result')
3064 chandransh 13143 
    oprot.writeFieldStop()
13144 
    oprot.writeStructEnd()
13145 
 
3431 rajveer 13146 
  def validate(self):
13147 
    return
13148 
 
13149 
 
3064 chandransh 13150 
  def __repr__(self):
13151 
    L = ['%s=%r' % (key, value)
13152 
      for key, value in self.__dict__.iteritems()]
13153 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13154 
 
13155 
  def __eq__(self, other):
13156 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13157 
 
13158 
  def __ne__(self, other):
13159 
    return not (self == other)
13160 
 
4444 rajveer 13161 
class markAlertsAsSeen_args:
13162 
  """
13163 
  Attributes:
13164 
   - warehouseId
13165 
  """
13166 
 
13167 
  thrift_spec = (
13168 
    None, # 0
13169 
    (1, TType.I64, 'warehouseId', None, None, ), # 1
13170 
  )
13171 
 
13172 
  def __init__(self, warehouseId=None,):
13173 
    self.warehouseId = warehouseId
13174 
 
13175 
  def read(self, iprot):
13176 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13177 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13178 
      return
13179 
    iprot.readStructBegin()
13180 
    while True:
13181 
      (fname, ftype, fid) = iprot.readFieldBegin()
13182 
      if ftype == TType.STOP:
13183 
        break
13184 
      if fid == 1:
13185 
        if ftype == TType.I64:
13186 
          self.warehouseId = iprot.readI64();
13187 
        else:
13188 
          iprot.skip(ftype)
13189 
      else:
13190 
        iprot.skip(ftype)
13191 
      iprot.readFieldEnd()
13192 
    iprot.readStructEnd()
13193 
 
13194 
  def write(self, oprot):
13195 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13196 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13197 
      return
13198 
    oprot.writeStructBegin('markAlertsAsSeen_args')
13199 
    if self.warehouseId is not None:
13200 
      oprot.writeFieldBegin('warehouseId', TType.I64, 1)
13201 
      oprot.writeI64(self.warehouseId)
13202 
      oprot.writeFieldEnd()
13203 
    oprot.writeFieldStop()
13204 
    oprot.writeStructEnd()
13205 
 
13206 
  def validate(self):
13207 
    return
13208 
 
13209 
 
13210 
  def __repr__(self):
13211 
    L = ['%s=%r' % (key, value)
13212 
      for key, value in self.__dict__.iteritems()]
13213 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13214 
 
13215 
  def __eq__(self, other):
13216 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13217 
 
13218 
  def __ne__(self, other):
13219 
    return not (self == other)
13220 
 
13221 
class markAlertsAsSeen_result:
13222 
 
13223 
  thrift_spec = (
13224 
  )
13225 
 
13226 
  def read(self, iprot):
13227 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13228 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13229 
      return
13230 
    iprot.readStructBegin()
13231 
    while True:
13232 
      (fname, ftype, fid) = iprot.readFieldBegin()
13233 
      if ftype == TType.STOP:
13234 
        break
13235 
      else:
13236 
        iprot.skip(ftype)
13237 
      iprot.readFieldEnd()
13238 
    iprot.readStructEnd()
13239 
 
13240 
  def write(self, oprot):
13241 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13242 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13243 
      return
13244 
    oprot.writeStructBegin('markAlertsAsSeen_result')
13245 
    oprot.writeFieldStop()
13246 
    oprot.writeStructEnd()
13247 
 
13248 
  def validate(self):
13249 
    return
13250 
 
13251 
 
13252 
  def __repr__(self):
13253 
    L = ['%s=%r' % (key, value)
13254 
      for key, value in self.__dict__.iteritems()]
13255 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13256 
 
13257 
  def __eq__(self, other):
13258 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13259 
 
13260 
  def __ne__(self, other):
13261 
    return not (self == other)
13262 
 
3064 chandransh 13263 
class getValidOrderCount_args:
13264 
 
13265 
  thrift_spec = (
13266 
  )
13267 
 
13268 
  def read(self, iprot):
13269 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13270 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13271 
      return
13272 
    iprot.readStructBegin()
13273 
    while True:
13274 
      (fname, ftype, fid) = iprot.readFieldBegin()
13275 
      if ftype == TType.STOP:
13276 
        break
13277 
      else:
13278 
        iprot.skip(ftype)
13279 
      iprot.readFieldEnd()
13280 
    iprot.readStructEnd()
13281 
 
13282 
  def write(self, oprot):
13283 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13284 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13285 
      return
13286 
    oprot.writeStructBegin('getValidOrderCount_args')
13287 
    oprot.writeFieldStop()
13288 
    oprot.writeStructEnd()
13289 
 
3431 rajveer 13290 
  def validate(self):
13291 
    return
13292 
 
13293 
 
3064 chandransh 13294 
  def __repr__(self):
13295 
    L = ['%s=%r' % (key, value)
13296 
      for key, value in self.__dict__.iteritems()]
13297 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13298 
 
13299 
  def __eq__(self, other):
13300 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13301 
 
13302 
  def __ne__(self, other):
13303 
    return not (self == other)
13304 
 
13305 
class getValidOrderCount_result:
94 ashish 13306 
  """
13307 
  Attributes:
13308 
   - success
13309 
  """
13310 
 
13311 
  thrift_spec = (
3064 chandransh 13312 
    (0, TType.I64, 'success', None, None, ), # 0
94 ashish 13313 
  )
13314 
 
3064 chandransh 13315 
  def __init__(self, success=None,):
94 ashish 13316 
    self.success = success
13317 
 
13318 
  def read(self, iprot):
13319 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13320 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13321 
      return
13322 
    iprot.readStructBegin()
13323 
    while True:
13324 
      (fname, ftype, fid) = iprot.readFieldBegin()
13325 
      if ftype == TType.STOP:
13326 
        break
13327 
      if fid == 0:
3064 chandransh 13328 
        if ftype == TType.I64:
13329 
          self.success = iprot.readI64();
94 ashish 13330 
        else:
13331 
          iprot.skip(ftype)
13332 
      else:
13333 
        iprot.skip(ftype)
13334 
      iprot.readFieldEnd()
13335 
    iprot.readStructEnd()
13336 
 
13337 
  def write(self, oprot):
13338 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13339 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13340 
      return
3064 chandransh 13341 
    oprot.writeStructBegin('getValidOrderCount_result')
3431 rajveer 13342 
    if self.success is not None:
3064 chandransh 13343 
      oprot.writeFieldBegin('success', TType.I64, 0)
13344 
      oprot.writeI64(self.success)
94 ashish 13345 
      oprot.writeFieldEnd()
13346 
    oprot.writeFieldStop()
13347 
    oprot.writeStructEnd()
13348 
 
3431 rajveer 13349 
  def validate(self):
13350 
    return
13351 
 
13352 
 
94 ashish 13353 
  def __repr__(self):
13354 
    L = ['%s=%r' % (key, value)
13355 
      for key, value in self.__dict__.iteritems()]
13356 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13357 
 
13358 
  def __eq__(self, other):
13359 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13360 
 
13361 
  def __ne__(self, other):
13362 
    return not (self == other)
13363 
 
3064 chandransh 13364 
class getNoOfCustomersWithSuccessfulTransaction_args:
13365 
 
13366 
  thrift_spec = (
13367 
  )
13368 
 
13369 
  def read(self, iprot):
13370 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13371 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13372 
      return
13373 
    iprot.readStructBegin()
13374 
    while True:
13375 
      (fname, ftype, fid) = iprot.readFieldBegin()
13376 
      if ftype == TType.STOP:
13377 
        break
13378 
      else:
13379 
        iprot.skip(ftype)
13380 
      iprot.readFieldEnd()
13381 
    iprot.readStructEnd()
13382 
 
13383 
  def write(self, oprot):
13384 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13385 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13386 
      return
13387 
    oprot.writeStructBegin('getNoOfCustomersWithSuccessfulTransaction_args')
13388 
    oprot.writeFieldStop()
13389 
    oprot.writeStructEnd()
13390 
 
3431 rajveer 13391 
  def validate(self):
13392 
    return
13393 
 
13394 
 
3064 chandransh 13395 
  def __repr__(self):
13396 
    L = ['%s=%r' % (key, value)
13397 
      for key, value in self.__dict__.iteritems()]
13398 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13399 
 
13400 
  def __eq__(self, other):
13401 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13402 
 
13403 
  def __ne__(self, other):
13404 
    return not (self == other)
13405 
 
13406 
class getNoOfCustomersWithSuccessfulTransaction_result:
94 ashish 13407 
  """
13408 
  Attributes:
3064 chandransh 13409 
   - success
94 ashish 13410 
  """
13411 
 
13412 
  thrift_spec = (
3064 chandransh 13413 
    (0, TType.I64, 'success', None, None, ), # 0
94 ashish 13414 
  )
13415 
 
3064 chandransh 13416 
  def __init__(self, success=None,):
13417 
    self.success = success
94 ashish 13418 
 
13419 
  def read(self, iprot):
13420 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13421 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13422 
      return
13423 
    iprot.readStructBegin()
13424 
    while True:
13425 
      (fname, ftype, fid) = iprot.readFieldBegin()
13426 
      if ftype == TType.STOP:
13427 
        break
3064 chandransh 13428 
      if fid == 0:
94 ashish 13429 
        if ftype == TType.I64:
3064 chandransh 13430 
          self.success = iprot.readI64();
94 ashish 13431 
        else:
13432 
          iprot.skip(ftype)
13433 
      else:
13434 
        iprot.skip(ftype)
13435 
      iprot.readFieldEnd()
13436 
    iprot.readStructEnd()
13437 
 
13438 
  def write(self, oprot):
13439 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13440 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13441 
      return
3064 chandransh 13442 
    oprot.writeStructBegin('getNoOfCustomersWithSuccessfulTransaction_result')
3431 rajveer 13443 
    if self.success is not None:
3064 chandransh 13444 
      oprot.writeFieldBegin('success', TType.I64, 0)
13445 
      oprot.writeI64(self.success)
94 ashish 13446 
      oprot.writeFieldEnd()
13447 
    oprot.writeFieldStop()
13448 
    oprot.writeStructEnd()
13449 
 
3431 rajveer 13450 
  def validate(self):
13451 
    return
13452 
 
13453 
 
94 ashish 13454 
  def __repr__(self):
13455 
    L = ['%s=%r' % (key, value)
13456 
      for key, value in self.__dict__.iteritems()]
13457 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13458 
 
13459 
  def __eq__(self, other):
13460 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13461 
 
13462 
  def __ne__(self, other):
13463 
    return not (self == other)
13464 
 
3064 chandransh 13465 
class getValidOrdersAmountRange_args:
13466 
 
13467 
  thrift_spec = (
13468 
  )
13469 
 
13470 
  def read(self, iprot):
13471 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13472 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13473 
      return
13474 
    iprot.readStructBegin()
13475 
    while True:
13476 
      (fname, ftype, fid) = iprot.readFieldBegin()
13477 
      if ftype == TType.STOP:
13478 
        break
13479 
      else:
13480 
        iprot.skip(ftype)
13481 
      iprot.readFieldEnd()
13482 
    iprot.readStructEnd()
13483 
 
13484 
  def write(self, oprot):
13485 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13486 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13487 
      return
13488 
    oprot.writeStructBegin('getValidOrdersAmountRange_args')
13489 
    oprot.writeFieldStop()
13490 
    oprot.writeStructEnd()
13491 
 
3431 rajveer 13492 
  def validate(self):
13493 
    return
13494 
 
13495 
 
3064 chandransh 13496 
  def __repr__(self):
13497 
    L = ['%s=%r' % (key, value)
13498 
      for key, value in self.__dict__.iteritems()]
13499 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13500 
 
13501 
  def __eq__(self, other):
13502 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13503 
 
13504 
  def __ne__(self, other):
13505 
    return not (self == other)
13506 
 
13507 
class getValidOrdersAmountRange_result:
94 ashish 13508 
  """
13509 
  Attributes:
13510 
   - success
13511 
  """
13512 
 
13513 
  thrift_spec = (
3064 chandransh 13514 
    (0, TType.LIST, 'success', (TType.DOUBLE,None), None, ), # 0
94 ashish 13515 
  )
13516 
 
3064 chandransh 13517 
  def __init__(self, success=None,):
94 ashish 13518 
    self.success = success
13519 
 
13520 
  def read(self, iprot):
13521 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13522 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13523 
      return
13524 
    iprot.readStructBegin()
13525 
    while True:
13526 
      (fname, ftype, fid) = iprot.readFieldBegin()
13527 
      if ftype == TType.STOP:
13528 
        break
13529 
      if fid == 0:
483 rajveer 13530 
        if ftype == TType.LIST:
13531 
          self.success = []
6188 rajveer 13532 
          (_etype249, _size246) = iprot.readListBegin()
13533 
          for _i250 in xrange(_size246):
13534 
            _elem251 = iprot.readDouble();
13535 
            self.success.append(_elem251)
483 rajveer 13536 
          iprot.readListEnd()
94 ashish 13537 
        else:
13538 
          iprot.skip(ftype)
13539 
      else:
13540 
        iprot.skip(ftype)
13541 
      iprot.readFieldEnd()
13542 
    iprot.readStructEnd()
13543 
 
13544 
  def write(self, oprot):
13545 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13546 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13547 
      return
3064 chandransh 13548 
    oprot.writeStructBegin('getValidOrdersAmountRange_result')
3431 rajveer 13549 
    if self.success is not None:
483 rajveer 13550 
      oprot.writeFieldBegin('success', TType.LIST, 0)
3064 chandransh 13551 
      oprot.writeListBegin(TType.DOUBLE, len(self.success))
6188 rajveer 13552 
      for iter252 in self.success:
13553 
        oprot.writeDouble(iter252)
483 rajveer 13554 
      oprot.writeListEnd()
94 ashish 13555 
      oprot.writeFieldEnd()
13556 
    oprot.writeFieldStop()
13557 
    oprot.writeStructEnd()
13558 
 
3431 rajveer 13559 
  def validate(self):
13560 
    return
13561 
 
13562 
 
94 ashish 13563 
  def __repr__(self):
13564 
    L = ['%s=%r' % (key, value)
13565 
      for key, value in self.__dict__.iteritems()]
13566 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13567 
 
13568 
  def __eq__(self, other):
13569 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13570 
 
13571 
  def __ne__(self, other):
13572 
    return not (self == other)
13573 
 
3064 chandransh 13574 
class getValidOrders_args:
1528 ankur.sing 13575 
  """
13576 
  Attributes:
3064 chandransh 13577 
   - limit
5874 rajveer 13578 
   - onlyStore
1528 ankur.sing 13579 
  """
13580 
 
13581 
  thrift_spec = (
13582 
    None, # 0
3064 chandransh 13583 
    (1, TType.I64, 'limit', None, None, ), # 1
5874 rajveer 13584 
    (2, TType.BOOL, 'onlyStore', None, None, ), # 2
1528 ankur.sing 13585 
  )
13586 
 
5874 rajveer 13587 
  def __init__(self, limit=None, onlyStore=None,):
3064 chandransh 13588 
    self.limit = limit
5874 rajveer 13589 
    self.onlyStore = onlyStore
1528 ankur.sing 13590 
 
13591 
  def read(self, iprot):
13592 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13593 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13594 
      return
13595 
    iprot.readStructBegin()
13596 
    while True:
13597 
      (fname, ftype, fid) = iprot.readFieldBegin()
13598 
      if ftype == TType.STOP:
13599 
        break
13600 
      if fid == 1:
13601 
        if ftype == TType.I64:
3064 chandransh 13602 
          self.limit = iprot.readI64();
1528 ankur.sing 13603 
        else:
13604 
          iprot.skip(ftype)
5874 rajveer 13605 
      elif fid == 2:
13606 
        if ftype == TType.BOOL:
13607 
          self.onlyStore = iprot.readBool();
13608 
        else:
13609 
          iprot.skip(ftype)
1528 ankur.sing 13610 
      else:
13611 
        iprot.skip(ftype)
13612 
      iprot.readFieldEnd()
13613 
    iprot.readStructEnd()
13614 
 
13615 
  def write(self, oprot):
13616 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13617 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13618 
      return
3064 chandransh 13619 
    oprot.writeStructBegin('getValidOrders_args')
3431 rajveer 13620 
    if self.limit is not None:
3064 chandransh 13621 
      oprot.writeFieldBegin('limit', TType.I64, 1)
13622 
      oprot.writeI64(self.limit)
1528 ankur.sing 13623 
      oprot.writeFieldEnd()
5874 rajveer 13624 
    if self.onlyStore is not None:
13625 
      oprot.writeFieldBegin('onlyStore', TType.BOOL, 2)
13626 
      oprot.writeBool(self.onlyStore)
13627 
      oprot.writeFieldEnd()
1528 ankur.sing 13628 
    oprot.writeFieldStop()
13629 
    oprot.writeStructEnd()
13630 
 
3431 rajveer 13631 
  def validate(self):
13632 
    return
13633 
 
13634 
 
1528 ankur.sing 13635 
  def __repr__(self):
13636 
    L = ['%s=%r' % (key, value)
13637 
      for key, value in self.__dict__.iteritems()]
13638 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13639 
 
13640 
  def __eq__(self, other):
13641 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13642 
 
13643 
  def __ne__(self, other):
13644 
    return not (self == other)
13645 
 
3064 chandransh 13646 
class getValidOrders_result:
1528 ankur.sing 13647 
  """
13648 
  Attributes:
13649 
   - success
13650 
  """
13651 
 
13652 
  thrift_spec = (
3064 chandransh 13653 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
1528 ankur.sing 13654 
  )
13655 
 
3064 chandransh 13656 
  def __init__(self, success=None,):
1528 ankur.sing 13657 
    self.success = success
13658 
 
13659 
  def read(self, iprot):
13660 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13661 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13662 
      return
13663 
    iprot.readStructBegin()
13664 
    while True:
13665 
      (fname, ftype, fid) = iprot.readFieldBegin()
13666 
      if ftype == TType.STOP:
13667 
        break
13668 
      if fid == 0:
3064 chandransh 13669 
        if ftype == TType.LIST:
13670 
          self.success = []
6188 rajveer 13671 
          (_etype256, _size253) = iprot.readListBegin()
13672 
          for _i257 in xrange(_size253):
13673 
            _elem258 = Order()
13674 
            _elem258.read(iprot)
13675 
            self.success.append(_elem258)
3064 chandransh 13676 
          iprot.readListEnd()
1528 ankur.sing 13677 
        else:
13678 
          iprot.skip(ftype)
13679 
      else:
13680 
        iprot.skip(ftype)
13681 
      iprot.readFieldEnd()
13682 
    iprot.readStructEnd()
13683 
 
13684 
  def write(self, oprot):
13685 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13686 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13687 
      return
3064 chandransh 13688 
    oprot.writeStructBegin('getValidOrders_result')
3431 rajveer 13689 
    if self.success is not None:
3064 chandransh 13690 
      oprot.writeFieldBegin('success', TType.LIST, 0)
13691 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 13692 
      for iter259 in self.success:
13693 
        iter259.write(oprot)
3064 chandransh 13694 
      oprot.writeListEnd()
1528 ankur.sing 13695 
      oprot.writeFieldEnd()
13696 
    oprot.writeFieldStop()
13697 
    oprot.writeStructEnd()
13698 
 
3431 rajveer 13699 
  def validate(self):
13700 
    return
13701 
 
13702 
 
1528 ankur.sing 13703 
  def __repr__(self):
13704 
    L = ['%s=%r' % (key, value)
13705 
      for key, value in self.__dict__.iteritems()]
13706 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13707 
 
13708 
  def __eq__(self, other):
13709 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13710 
 
13711 
  def __ne__(self, other):
13712 
    return not (self == other)
13713 
 
1220 chandransh 13714 
class batchOrders_args:
13715 
  """
13716 
  Attributes:
13717 
   - warehouseId
13718 
  """
13719 
 
13720 
  thrift_spec = (
13721 
    None, # 0
13722 
    (1, TType.I64, 'warehouseId', None, None, ), # 1
13723 
  )
13724 
 
13725 
  def __init__(self, warehouseId=None,):
13726 
    self.warehouseId = warehouseId
13727 
 
13728 
  def read(self, iprot):
13729 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13730 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13731 
      return
13732 
    iprot.readStructBegin()
13733 
    while True:
13734 
      (fname, ftype, fid) = iprot.readFieldBegin()
13735 
      if ftype == TType.STOP:
13736 
        break
13737 
      if fid == 1:
13738 
        if ftype == TType.I64:
13739 
          self.warehouseId = iprot.readI64();
13740 
        else:
13741 
          iprot.skip(ftype)
13742 
      else:
13743 
        iprot.skip(ftype)
13744 
      iprot.readFieldEnd()
13745 
    iprot.readStructEnd()
13746 
 
13747 
  def write(self, oprot):
13748 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13749 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13750 
      return
13751 
    oprot.writeStructBegin('batchOrders_args')
3431 rajveer 13752 
    if self.warehouseId is not None:
1220 chandransh 13753 
      oprot.writeFieldBegin('warehouseId', TType.I64, 1)
13754 
      oprot.writeI64(self.warehouseId)
13755 
      oprot.writeFieldEnd()
13756 
    oprot.writeFieldStop()
13757 
    oprot.writeStructEnd()
13758 
 
3431 rajveer 13759 
  def validate(self):
13760 
    return
13761 
 
13762 
 
1220 chandransh 13763 
  def __repr__(self):
13764 
    L = ['%s=%r' % (key, value)
13765 
      for key, value in self.__dict__.iteritems()]
13766 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13767 
 
13768 
  def __eq__(self, other):
13769 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13770 
 
13771 
  def __ne__(self, other):
13772 
    return not (self == other)
13773 
 
13774 
class batchOrders_result:
13775 
  """
13776 
  Attributes:
13777 
   - success
13778 
   - ex
13779 
  """
13780 
 
13781 
  thrift_spec = (
13782 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
13783 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
13784 
  )
13785 
 
13786 
  def __init__(self, success=None, ex=None,):
13787 
    self.success = success
13788 
    self.ex = ex
13789 
 
13790 
  def read(self, iprot):
13791 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13792 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13793 
      return
13794 
    iprot.readStructBegin()
13795 
    while True:
13796 
      (fname, ftype, fid) = iprot.readFieldBegin()
13797 
      if ftype == TType.STOP:
13798 
        break
13799 
      if fid == 0:
13800 
        if ftype == TType.LIST:
13801 
          self.success = []
6188 rajveer 13802 
          (_etype263, _size260) = iprot.readListBegin()
13803 
          for _i264 in xrange(_size260):
13804 
            _elem265 = Order()
13805 
            _elem265.read(iprot)
13806 
            self.success.append(_elem265)
1220 chandransh 13807 
          iprot.readListEnd()
13808 
        else:
13809 
          iprot.skip(ftype)
13810 
      elif fid == 1:
13811 
        if ftype == TType.STRUCT:
13812 
          self.ex = TransactionServiceException()
13813 
          self.ex.read(iprot)
13814 
        else:
13815 
          iprot.skip(ftype)
13816 
      else:
13817 
        iprot.skip(ftype)
13818 
      iprot.readFieldEnd()
13819 
    iprot.readStructEnd()
13820 
 
13821 
  def write(self, oprot):
13822 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13823 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13824 
      return
13825 
    oprot.writeStructBegin('batchOrders_result')
3431 rajveer 13826 
    if self.success is not None:
1220 chandransh 13827 
      oprot.writeFieldBegin('success', TType.LIST, 0)
13828 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 13829 
      for iter266 in self.success:
13830 
        iter266.write(oprot)
1220 chandransh 13831 
      oprot.writeListEnd()
13832 
      oprot.writeFieldEnd()
3431 rajveer 13833 
    if self.ex is not None:
1220 chandransh 13834 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
13835 
      self.ex.write(oprot)
13836 
      oprot.writeFieldEnd()
13837 
    oprot.writeFieldStop()
13838 
    oprot.writeStructEnd()
13839 
 
3431 rajveer 13840 
  def validate(self):
13841 
    return
13842 
 
13843 
 
1220 chandransh 13844 
  def __repr__(self):
13845 
    L = ['%s=%r' % (key, value)
13846 
      for key, value in self.__dict__.iteritems()]
13847 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13848 
 
13849 
  def __eq__(self, other):
13850 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13851 
 
13852 
  def __ne__(self, other):
13853 
    return not (self == other)
13854 
 
1208 chandransh 13855 
class markOrderAsOutOfStock_args:
13856 
  """
13857 
  Attributes:
13858 
   - orderId
13859 
  """
13860 
 
13861 
  thrift_spec = (
13862 
    None, # 0
13863 
    (1, TType.I64, 'orderId', None, None, ), # 1
13864 
  )
13865 
 
13866 
  def __init__(self, orderId=None,):
13867 
    self.orderId = orderId
13868 
 
13869 
  def read(self, iprot):
13870 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13871 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13872 
      return
13873 
    iprot.readStructBegin()
13874 
    while True:
13875 
      (fname, ftype, fid) = iprot.readFieldBegin()
13876 
      if ftype == TType.STOP:
13877 
        break
13878 
      if fid == 1:
13879 
        if ftype == TType.I64:
13880 
          self.orderId = iprot.readI64();
13881 
        else:
13882 
          iprot.skip(ftype)
13883 
      else:
13884 
        iprot.skip(ftype)
13885 
      iprot.readFieldEnd()
13886 
    iprot.readStructEnd()
13887 
 
13888 
  def write(self, oprot):
13889 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13890 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13891 
      return
13892 
    oprot.writeStructBegin('markOrderAsOutOfStock_args')
3431 rajveer 13893 
    if self.orderId is not None:
1208 chandransh 13894 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
13895 
      oprot.writeI64(self.orderId)
13896 
      oprot.writeFieldEnd()
13897 
    oprot.writeFieldStop()
13898 
    oprot.writeStructEnd()
13899 
 
3431 rajveer 13900 
  def validate(self):
13901 
    return
13902 
 
13903 
 
1208 chandransh 13904 
  def __repr__(self):
13905 
    L = ['%s=%r' % (key, value)
13906 
      for key, value in self.__dict__.iteritems()]
13907 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13908 
 
13909 
  def __eq__(self, other):
13910 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13911 
 
13912 
  def __ne__(self, other):
13913 
    return not (self == other)
13914 
 
13915 
class markOrderAsOutOfStock_result:
13916 
  """
13917 
  Attributes:
13918 
   - success
13919 
   - ex
13920 
  """
13921 
 
13922 
  thrift_spec = (
13923 
    (0, TType.BOOL, 'success', None, None, ), # 0
13924 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
13925 
  )
13926 
 
13927 
  def __init__(self, success=None, ex=None,):
13928 
    self.success = success
13929 
    self.ex = ex
13930 
 
13931 
  def read(self, iprot):
13932 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13933 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13934 
      return
13935 
    iprot.readStructBegin()
13936 
    while True:
13937 
      (fname, ftype, fid) = iprot.readFieldBegin()
13938 
      if ftype == TType.STOP:
13939 
        break
13940 
      if fid == 0:
13941 
        if ftype == TType.BOOL:
13942 
          self.success = iprot.readBool();
13943 
        else:
13944 
          iprot.skip(ftype)
13945 
      elif fid == 1:
13946 
        if ftype == TType.STRUCT:
13947 
          self.ex = TransactionServiceException()
13948 
          self.ex.read(iprot)
13949 
        else:
13950 
          iprot.skip(ftype)
13951 
      else:
13952 
        iprot.skip(ftype)
13953 
      iprot.readFieldEnd()
13954 
    iprot.readStructEnd()
13955 
 
13956 
  def write(self, oprot):
13957 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13958 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13959 
      return
13960 
    oprot.writeStructBegin('markOrderAsOutOfStock_result')
3431 rajveer 13961 
    if self.success is not None:
1208 chandransh 13962 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
13963 
      oprot.writeBool(self.success)
13964 
      oprot.writeFieldEnd()
3431 rajveer 13965 
    if self.ex is not None:
1208 chandransh 13966 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
13967 
      self.ex.write(oprot)
13968 
      oprot.writeFieldEnd()
13969 
    oprot.writeFieldStop()
13970 
    oprot.writeStructEnd()
13971 
 
3431 rajveer 13972 
  def validate(self):
13973 
    return
13974 
 
13975 
 
1208 chandransh 13976 
  def __repr__(self):
13977 
    L = ['%s=%r' % (key, value)
13978 
      for key, value in self.__dict__.iteritems()]
13979 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13980 
 
13981 
  def __eq__(self, other):
13982 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13983 
 
13984 
  def __ne__(self, other):
13985 
    return not (self == other)
13986 
 
3064 chandransh 13987 
class verifyOrder_args:
759 chandransh 13988 
  """
13989 
  Attributes:
3064 chandransh 13990 
   - orderId
759 chandransh 13991 
  """
13992 
 
13993 
  thrift_spec = (
13994 
    None, # 0
3064 chandransh 13995 
    (1, TType.I64, 'orderId', None, None, ), # 1
759 chandransh 13996 
  )
13997 
 
3064 chandransh 13998 
  def __init__(self, orderId=None,):
13999 
    self.orderId = orderId
759 chandransh 14000 
 
14001 
  def read(self, iprot):
14002 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14003 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14004 
      return
14005 
    iprot.readStructBegin()
14006 
    while True:
14007 
      (fname, ftype, fid) = iprot.readFieldBegin()
14008 
      if ftype == TType.STOP:
14009 
        break
14010 
      if fid == 1:
14011 
        if ftype == TType.I64:
3064 chandransh 14012 
          self.orderId = iprot.readI64();
759 chandransh 14013 
        else:
14014 
          iprot.skip(ftype)
14015 
      else:
14016 
        iprot.skip(ftype)
14017 
      iprot.readFieldEnd()
14018 
    iprot.readStructEnd()
14019 
 
14020 
  def write(self, oprot):
14021 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14022 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14023 
      return
3064 chandransh 14024 
    oprot.writeStructBegin('verifyOrder_args')
3431 rajveer 14025 
    if self.orderId is not None:
3064 chandransh 14026 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
14027 
      oprot.writeI64(self.orderId)
759 chandransh 14028 
      oprot.writeFieldEnd()
14029 
    oprot.writeFieldStop()
14030 
    oprot.writeStructEnd()
14031 
 
3431 rajveer 14032 
  def validate(self):
14033 
    return
14034 
 
14035 
 
759 chandransh 14036 
  def __repr__(self):
14037 
    L = ['%s=%r' % (key, value)
14038 
      for key, value in self.__dict__.iteritems()]
14039 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14040 
 
14041 
  def __eq__(self, other):
14042 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14043 
 
14044 
  def __ne__(self, other):
14045 
    return not (self == other)
14046 
 
3064 chandransh 14047 
class verifyOrder_result:
759 chandransh 14048 
  """
14049 
  Attributes:
14050 
   - success
14051 
   - ex
14052 
  """
14053 
 
14054 
  thrift_spec = (
14055 
    (0, TType.BOOL, 'success', None, None, ), # 0
14056 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
14057 
  )
14058 
 
14059 
  def __init__(self, success=None, ex=None,):
14060 
    self.success = success
14061 
    self.ex = ex
14062 
 
14063 
  def read(self, iprot):
14064 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14065 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14066 
      return
14067 
    iprot.readStructBegin()
14068 
    while True:
14069 
      (fname, ftype, fid) = iprot.readFieldBegin()
14070 
      if ftype == TType.STOP:
14071 
        break
14072 
      if fid == 0:
14073 
        if ftype == TType.BOOL:
14074 
          self.success = iprot.readBool();
14075 
        else:
14076 
          iprot.skip(ftype)
14077 
      elif fid == 1:
14078 
        if ftype == TType.STRUCT:
14079 
          self.ex = TransactionServiceException()
14080 
          self.ex.read(iprot)
14081 
        else:
14082 
          iprot.skip(ftype)
14083 
      else:
14084 
        iprot.skip(ftype)
14085 
      iprot.readFieldEnd()
14086 
    iprot.readStructEnd()
14087 
 
14088 
  def write(self, oprot):
14089 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14090 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14091 
      return
3064 chandransh 14092 
    oprot.writeStructBegin('verifyOrder_result')
3431 rajveer 14093 
    if self.success is not None:
759 chandransh 14094 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
14095 
      oprot.writeBool(self.success)
14096 
      oprot.writeFieldEnd()
3431 rajveer 14097 
    if self.ex is not None:
759 chandransh 14098 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
14099 
      self.ex.write(oprot)
14100 
      oprot.writeFieldEnd()
14101 
    oprot.writeFieldStop()
14102 
    oprot.writeStructEnd()
14103 
 
3431 rajveer 14104 
  def validate(self):
14105 
    return
14106 
 
14107 
 
759 chandransh 14108 
  def __repr__(self):
14109 
    L = ['%s=%r' % (key, value)
14110 
      for key, value in self.__dict__.iteritems()]
14111 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14112 
 
14113 
  def __eq__(self, other):
14114 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14115 
 
14116 
  def __ne__(self, other):
14117 
    return not (self == other)
14118 
 
3064 chandransh 14119 
class acceptOrder_args:
1113 chandransh 14120 
  """
14121 
  Attributes:
3064 chandransh 14122 
   - orderId
1113 chandransh 14123 
  """
14124 
 
14125 
  thrift_spec = (
14126 
    None, # 0
3064 chandransh 14127 
    (1, TType.I64, 'orderId', None, None, ), # 1
1113 chandransh 14128 
  )
14129 
 
3064 chandransh 14130 
  def __init__(self, orderId=None,):
14131 
    self.orderId = orderId
1113 chandransh 14132 
 
14133 
  def read(self, iprot):
14134 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14135 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14136 
      return
14137 
    iprot.readStructBegin()
14138 
    while True:
14139 
      (fname, ftype, fid) = iprot.readFieldBegin()
14140 
      if ftype == TType.STOP:
14141 
        break
14142 
      if fid == 1:
14143 
        if ftype == TType.I64:
3064 chandransh 14144 
          self.orderId = iprot.readI64();
1113 chandransh 14145 
        else:
14146 
          iprot.skip(ftype)
14147 
      else:
14148 
        iprot.skip(ftype)
14149 
      iprot.readFieldEnd()
14150 
    iprot.readStructEnd()
14151 
 
14152 
  def write(self, oprot):
14153 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14154 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14155 
      return
3064 chandransh 14156 
    oprot.writeStructBegin('acceptOrder_args')
3431 rajveer 14157 
    if self.orderId is not None:
3064 chandransh 14158 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
14159 
      oprot.writeI64(self.orderId)
1113 chandransh 14160 
      oprot.writeFieldEnd()
14161 
    oprot.writeFieldStop()
14162 
    oprot.writeStructEnd()
14163 
 
3431 rajveer 14164 
  def validate(self):
14165 
    return
14166 
 
14167 
 
1113 chandransh 14168 
  def __repr__(self):
14169 
    L = ['%s=%r' % (key, value)
14170 
      for key, value in self.__dict__.iteritems()]
14171 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14172 
 
14173 
  def __eq__(self, other):
14174 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14175 
 
14176 
  def __ne__(self, other):
14177 
    return not (self == other)
14178 
 
3064 chandransh 14179 
class acceptOrder_result:
1113 chandransh 14180 
  """
14181 
  Attributes:
14182 
   - success
14183 
   - ex
14184 
  """
14185 
 
14186 
  thrift_spec = (
3064 chandransh 14187 
    (0, TType.BOOL, 'success', None, None, ), # 0
1113 chandransh 14188 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
14189 
  )
14190 
 
14191 
  def __init__(self, success=None, ex=None,):
14192 
    self.success = success
14193 
    self.ex = ex
14194 
 
14195 
  def read(self, iprot):
14196 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14197 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14198 
      return
14199 
    iprot.readStructBegin()
14200 
    while True:
14201 
      (fname, ftype, fid) = iprot.readFieldBegin()
14202 
      if ftype == TType.STOP:
14203 
        break
14204 
      if fid == 0:
3064 chandransh 14205 
        if ftype == TType.BOOL:
14206 
          self.success = iprot.readBool();
1113 chandransh 14207 
        else:
14208 
          iprot.skip(ftype)
14209 
      elif fid == 1:
14210 
        if ftype == TType.STRUCT:
14211 
          self.ex = TransactionServiceException()
14212 
          self.ex.read(iprot)
14213 
        else:
14214 
          iprot.skip(ftype)
14215 
      else:
14216 
        iprot.skip(ftype)
14217 
      iprot.readFieldEnd()
14218 
    iprot.readStructEnd()
14219 
 
14220 
  def write(self, oprot):
14221 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14222 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14223 
      return
3064 chandransh 14224 
    oprot.writeStructBegin('acceptOrder_result')
3431 rajveer 14225 
    if self.success is not None:
3064 chandransh 14226 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
14227 
      oprot.writeBool(self.success)
1113 chandransh 14228 
      oprot.writeFieldEnd()
3431 rajveer 14229 
    if self.ex is not None:
1113 chandransh 14230 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
14231 
      self.ex.write(oprot)
14232 
      oprot.writeFieldEnd()
14233 
    oprot.writeFieldStop()
14234 
    oprot.writeStructEnd()
14235 
 
3431 rajveer 14236 
  def validate(self):
14237 
    return
14238 
 
14239 
 
1113 chandransh 14240 
  def __repr__(self):
14241 
    L = ['%s=%r' % (key, value)
14242 
      for key, value in self.__dict__.iteritems()]
14243 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14244 
 
14245 
  def __eq__(self, other):
14246 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14247 
 
14248 
  def __ne__(self, other):
14249 
    return not (self == other)
14250 
 
3064 chandransh 14251 
class addBillingDetails_args:
1135 chandransh 14252 
  """
14253 
  Attributes:
3064 chandransh 14254 
   - orderId
14255 
   - invoice_number
4658 mandeep.dh 14256 
   - serialNumber
4283 anupam.sin 14257 
   - itemNumber
3064 chandransh 14258 
   - billed_by
4264 rajveer 14259 
   - jacketNumber
4283 anupam.sin 14260 
   - billingType
5110 mandeep.dh 14261 
   - fulfilmentWarehouseId
4763 rajveer 14262 
   - authorize
1135 chandransh 14263 
  """
14264 
 
14265 
  thrift_spec = (
14266 
    None, # 0
3064 chandransh 14267 
    (1, TType.I64, 'orderId', None, None, ), # 1
14268 
    (2, TType.STRING, 'invoice_number', None, None, ), # 2
5411 rajveer 14269 
    (3, TType.LIST, 'serialNumber', (TType.STRING,None), None, ), # 3
14270 
    (4, TType.LIST, 'itemNumber', (TType.STRING,None), None, ), # 4
4283 anupam.sin 14271 
    (5, TType.STRING, 'billed_by', None, None, ), # 5
14272 
    (6, TType.I64, 'jacketNumber', None, None, ), # 6
14273 
    (7, TType.I64, 'billingType', None, None, ), # 7
5110 mandeep.dh 14274 
    (8, TType.I64, 'fulfilmentWarehouseId', None, None, ), # 8
4763 rajveer 14275 
    (9, TType.BOOL, 'authorize', None, None, ), # 9
1135 chandransh 14276 
  )
14277 
 
5110 mandeep.dh 14278 
  def __init__(self, orderId=None, invoice_number=None, serialNumber=None, itemNumber=None, billed_by=None, jacketNumber=None, billingType=None, fulfilmentWarehouseId=None, authorize=None,):
3064 chandransh 14279 
    self.orderId = orderId
14280 
    self.invoice_number = invoice_number
4658 mandeep.dh 14281 
    self.serialNumber = serialNumber
4283 anupam.sin 14282 
    self.itemNumber = itemNumber
3064 chandransh 14283 
    self.billed_by = billed_by
4264 rajveer 14284 
    self.jacketNumber = jacketNumber
4283 anupam.sin 14285 
    self.billingType = billingType
5110 mandeep.dh 14286 
    self.fulfilmentWarehouseId = fulfilmentWarehouseId
4763 rajveer 14287 
    self.authorize = authorize
1135 chandransh 14288 
 
14289 
  def read(self, iprot):
14290 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14291 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14292 
      return
14293 
    iprot.readStructBegin()
14294 
    while True:
14295 
      (fname, ftype, fid) = iprot.readFieldBegin()
14296 
      if ftype == TType.STOP:
14297 
        break
14298 
      if fid == 1:
14299 
        if ftype == TType.I64:
3064 chandransh 14300 
          self.orderId = iprot.readI64();
1135 chandransh 14301 
        else:
14302 
          iprot.skip(ftype)
14303 
      elif fid == 2:
3064 chandransh 14304 
        if ftype == TType.STRING:
14305 
          self.invoice_number = iprot.readString();
1135 chandransh 14306 
        else:
14307 
          iprot.skip(ftype)
3064 chandransh 14308 
      elif fid == 3:
5411 rajveer 14309 
        if ftype == TType.LIST:
14310 
          self.serialNumber = []
6188 rajveer 14311 
          (_etype270, _size267) = iprot.readListBegin()
14312 
          for _i271 in xrange(_size267):
14313 
            _elem272 = iprot.readString();
14314 
            self.serialNumber.append(_elem272)
5411 rajveer 14315 
          iprot.readListEnd()
3064 chandransh 14316 
        else:
14317 
          iprot.skip(ftype)
14318 
      elif fid == 4:
5411 rajveer 14319 
        if ftype == TType.LIST:
14320 
          self.itemNumber = []
6188 rajveer 14321 
          (_etype276, _size273) = iprot.readListBegin()
14322 
          for _i277 in xrange(_size273):
14323 
            _elem278 = iprot.readString();
14324 
            self.itemNumber.append(_elem278)
5411 rajveer 14325 
          iprot.readListEnd()
3064 chandransh 14326 
        else:
14327 
          iprot.skip(ftype)
14328 
      elif fid == 5:
14329 
        if ftype == TType.STRING:
4283 anupam.sin 14330 
          self.billed_by = iprot.readString();
3064 chandransh 14331 
        else:
14332 
          iprot.skip(ftype)
14333 
      elif fid == 6:
14334 
        if ftype == TType.I64:
4283 anupam.sin 14335 
          self.jacketNumber = iprot.readI64();
14336 
        else:
14337 
          iprot.skip(ftype)
14338 
      elif fid == 7:
14339 
        if ftype == TType.I64:
3064 chandransh 14340 
          self.billingType = iprot.readI64();
14341 
        else:
14342 
          iprot.skip(ftype)
4283 anupam.sin 14343 
      elif fid == 8:
14344 
        if ftype == TType.I64:
5110 mandeep.dh 14345 
          self.fulfilmentWarehouseId = iprot.readI64();
4283 anupam.sin 14346 
        else:
14347 
          iprot.skip(ftype)
4763 rajveer 14348 
      elif fid == 9:
14349 
        if ftype == TType.BOOL:
14350 
          self.authorize = iprot.readBool();
14351 
        else:
14352 
          iprot.skip(ftype)
1246 chandransh 14353 
      else:
14354 
        iprot.skip(ftype)
14355 
      iprot.readFieldEnd()
14356 
    iprot.readStructEnd()
14357 
 
14358 
  def write(self, oprot):
14359 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14360 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14361 
      return
4283 anupam.sin 14362 
    oprot.writeStructBegin('addBillingDetails_args')
3431 rajveer 14363 
    if self.orderId is not None:
3064 chandransh 14364 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
14365 
      oprot.writeI64(self.orderId)
1246 chandransh 14366 
      oprot.writeFieldEnd()
4283 anupam.sin 14367 
    if self.invoice_number is not None:
14368 
      oprot.writeFieldBegin('invoice_number', TType.STRING, 2)
14369 
      oprot.writeString(self.invoice_number)
1246 chandransh 14370 
      oprot.writeFieldEnd()
4658 mandeep.dh 14371 
    if self.serialNumber is not None:
5411 rajveer 14372 
      oprot.writeFieldBegin('serialNumber', TType.LIST, 3)
14373 
      oprot.writeListBegin(TType.STRING, len(self.serialNumber))
6188 rajveer 14374 
      for iter279 in self.serialNumber:
14375 
        oprot.writeString(iter279)
5411 rajveer 14376 
      oprot.writeListEnd()
3064 chandransh 14377 
      oprot.writeFieldEnd()
3431 rajveer 14378 
    if self.itemNumber is not None:
5411 rajveer 14379 
      oprot.writeFieldBegin('itemNumber', TType.LIST, 4)
14380 
      oprot.writeListBegin(TType.STRING, len(self.itemNumber))
6188 rajveer 14381 
      for iter280 in self.itemNumber:
14382 
        oprot.writeString(iter280)
5411 rajveer 14383 
      oprot.writeListEnd()
3064 chandransh 14384 
      oprot.writeFieldEnd()
4283 anupam.sin 14385 
    if self.billed_by is not None:
14386 
      oprot.writeFieldBegin('billed_by', TType.STRING, 5)
14387 
      oprot.writeString(self.billed_by)
3064 chandransh 14388 
      oprot.writeFieldEnd()
4283 anupam.sin 14389 
    if self.jacketNumber is not None:
14390 
      oprot.writeFieldBegin('jacketNumber', TType.I64, 6)
14391 
      oprot.writeI64(self.jacketNumber)
14392 
      oprot.writeFieldEnd()
3431 rajveer 14393 
    if self.billingType is not None:
4283 anupam.sin 14394 
      oprot.writeFieldBegin('billingType', TType.I64, 7)
3064 chandransh 14395 
      oprot.writeI64(self.billingType)
14396 
      oprot.writeFieldEnd()
5110 mandeep.dh 14397 
    if self.fulfilmentWarehouseId is not None:
14398 
      oprot.writeFieldBegin('fulfilmentWarehouseId', TType.I64, 8)
14399 
      oprot.writeI64(self.fulfilmentWarehouseId)
4283 anupam.sin 14400 
      oprot.writeFieldEnd()
4763 rajveer 14401 
    if self.authorize is not None:
14402 
      oprot.writeFieldBegin('authorize', TType.BOOL, 9)
14403 
      oprot.writeBool(self.authorize)
14404 
      oprot.writeFieldEnd()
1246 chandransh 14405 
    oprot.writeFieldStop()
14406 
    oprot.writeStructEnd()
14407 
 
3431 rajveer 14408 
  def validate(self):
14409 
    return
14410 
 
14411 
 
1246 chandransh 14412 
  def __repr__(self):
14413 
    L = ['%s=%r' % (key, value)
14414 
      for key, value in self.__dict__.iteritems()]
14415 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14416 
 
14417 
  def __eq__(self, other):
14418 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14419 
 
14420 
  def __ne__(self, other):
14421 
    return not (self == other)
14422 
 
4283 anupam.sin 14423 
class addBillingDetails_result:
1246 chandransh 14424 
  """
14425 
  Attributes:
3064 chandransh 14426 
   - success
1246 chandransh 14427 
   - ex
14428 
  """
14429 
 
14430 
  thrift_spec = (
3064 chandransh 14431 
    (0, TType.BOOL, 'success', None, None, ), # 0
1246 chandransh 14432 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
14433 
  )
14434 
 
3064 chandransh 14435 
  def __init__(self, success=None, ex=None,):
14436 
    self.success = success
1246 chandransh 14437 
    self.ex = ex
14438 
 
14439 
  def read(self, iprot):
14440 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14441 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14442 
      return
14443 
    iprot.readStructBegin()
14444 
    while True:
14445 
      (fname, ftype, fid) = iprot.readFieldBegin()
14446 
      if ftype == TType.STOP:
14447 
        break
3064 chandransh 14448 
      if fid == 0:
14449 
        if ftype == TType.BOOL:
14450 
          self.success = iprot.readBool();
14451 
        else:
14452 
          iprot.skip(ftype)
14453 
      elif fid == 1:
1246 chandransh 14454 
        if ftype == TType.STRUCT:
14455 
          self.ex = TransactionServiceException()
14456 
          self.ex.read(iprot)
14457 
        else:
14458 
          iprot.skip(ftype)
14459 
      else:
14460 
        iprot.skip(ftype)
14461 
      iprot.readFieldEnd()
14462 
    iprot.readStructEnd()
14463 
 
14464 
  def write(self, oprot):
14465 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14466 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14467 
      return
4283 anupam.sin 14468 
    oprot.writeStructBegin('addBillingDetails_result')
3431 rajveer 14469 
    if self.success is not None:
3064 chandransh 14470 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
14471 
      oprot.writeBool(self.success)
14472 
      oprot.writeFieldEnd()
3431 rajveer 14473 
    if self.ex is not None:
1246 chandransh 14474 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
14475 
      self.ex.write(oprot)
14476 
      oprot.writeFieldEnd()
14477 
    oprot.writeFieldStop()
14478 
    oprot.writeStructEnd()
14479 
 
3431 rajveer 14480 
  def validate(self):
14481 
    return
14482 
 
14483 
 
1246 chandransh 14484 
  def __repr__(self):
14485 
    L = ['%s=%r' % (key, value)
14486 
      for key, value in self.__dict__.iteritems()]
14487 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14488 
 
14489 
  def __eq__(self, other):
14490 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14491 
 
14492 
  def __ne__(self, other):
14493 
    return not (self == other)
14494 
 
4579 rajveer 14495 
class addInvoiceNumber_args:
14496 
  """
14497 
  Attributes:
14498 
   - orderId
14499 
   - invoiceNumber
4763 rajveer 14500 
   - color
6756 amar.kumar 14501 
   - serialNumber
14502 
   - itemNumber
4579 rajveer 14503 
  """
14504 
 
14505 
  thrift_spec = (
14506 
    None, # 0
14507 
    (1, TType.I64, 'orderId', None, None, ), # 1
14508 
    (2, TType.STRING, 'invoiceNumber', None, None, ), # 2
4763 rajveer 14509 
    (3, TType.STRING, 'color', None, None, ), # 3
6756 amar.kumar 14510 
    (4, TType.STRING, 'serialNumber', None, None, ), # 4
14511 
    (5, TType.STRING, 'itemNumber', None, None, ), # 5
4579 rajveer 14512 
  )
14513 
 
6756 amar.kumar 14514 
  def __init__(self, orderId=None, invoiceNumber=None, color=None, serialNumber=None, itemNumber=None,):
4579 rajveer 14515 
    self.orderId = orderId
14516 
    self.invoiceNumber = invoiceNumber
4763 rajveer 14517 
    self.color = color
6756 amar.kumar 14518 
    self.serialNumber = serialNumber
14519 
    self.itemNumber = itemNumber
4579 rajveer 14520 
 
14521 
  def read(self, iprot):
14522 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14523 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14524 
      return
14525 
    iprot.readStructBegin()
14526 
    while True:
14527 
      (fname, ftype, fid) = iprot.readFieldBegin()
14528 
      if ftype == TType.STOP:
14529 
        break
14530 
      if fid == 1:
14531 
        if ftype == TType.I64:
14532 
          self.orderId = iprot.readI64();
14533 
        else:
14534 
          iprot.skip(ftype)
14535 
      elif fid == 2:
14536 
        if ftype == TType.STRING:
14537 
          self.invoiceNumber = iprot.readString();
14538 
        else:
14539 
          iprot.skip(ftype)
4763 rajveer 14540 
      elif fid == 3:
14541 
        if ftype == TType.STRING:
14542 
          self.color = iprot.readString();
14543 
        else:
14544 
          iprot.skip(ftype)
6756 amar.kumar 14545 
      elif fid == 4:
14546 
        if ftype == TType.STRING:
14547 
          self.serialNumber = iprot.readString();
14548 
        else:
14549 
          iprot.skip(ftype)
14550 
      elif fid == 5:
14551 
        if ftype == TType.STRING:
14552 
          self.itemNumber = iprot.readString();
14553 
        else:
14554 
          iprot.skip(ftype)
4579 rajveer 14555 
      else:
14556 
        iprot.skip(ftype)
14557 
      iprot.readFieldEnd()
14558 
    iprot.readStructEnd()
14559 
 
14560 
  def write(self, oprot):
14561 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14562 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14563 
      return
14564 
    oprot.writeStructBegin('addInvoiceNumber_args')
14565 
    if self.orderId is not None:
14566 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
14567 
      oprot.writeI64(self.orderId)
14568 
      oprot.writeFieldEnd()
14569 
    if self.invoiceNumber is not None:
14570 
      oprot.writeFieldBegin('invoiceNumber', TType.STRING, 2)
14571 
      oprot.writeString(self.invoiceNumber)
14572 
      oprot.writeFieldEnd()
4763 rajveer 14573 
    if self.color is not None:
14574 
      oprot.writeFieldBegin('color', TType.STRING, 3)
14575 
      oprot.writeString(self.color)
14576 
      oprot.writeFieldEnd()
6756 amar.kumar 14577 
    if self.serialNumber is not None:
14578 
      oprot.writeFieldBegin('serialNumber', TType.STRING, 4)
14579 
      oprot.writeString(self.serialNumber)
14580 
      oprot.writeFieldEnd()
14581 
    if self.itemNumber is not None:
14582 
      oprot.writeFieldBegin('itemNumber', TType.STRING, 5)
14583 
      oprot.writeString(self.itemNumber)
14584 
      oprot.writeFieldEnd()
4579 rajveer 14585 
    oprot.writeFieldStop()
14586 
    oprot.writeStructEnd()
14587 
 
14588 
  def validate(self):
14589 
    return
14590 
 
14591 
 
14592 
  def __repr__(self):
14593 
    L = ['%s=%r' % (key, value)
14594 
      for key, value in self.__dict__.iteritems()]
14595 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14596 
 
14597 
  def __eq__(self, other):
14598 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14599 
 
14600 
  def __ne__(self, other):
14601 
    return not (self == other)
14602 
 
14603 
class addInvoiceNumber_result:
14604 
  """
14605 
  Attributes:
14606 
   - ex
14607 
  """
14608 
 
14609 
  thrift_spec = (
14610 
    None, # 0
14611 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
14612 
  )
14613 
 
14614 
  def __init__(self, ex=None,):
14615 
    self.ex = ex
14616 
 
14617 
  def read(self, iprot):
14618 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14619 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14620 
      return
14621 
    iprot.readStructBegin()
14622 
    while True:
14623 
      (fname, ftype, fid) = iprot.readFieldBegin()
14624 
      if ftype == TType.STOP:
14625 
        break
14626 
      if fid == 1:
14627 
        if ftype == TType.STRUCT:
14628 
          self.ex = TransactionServiceException()
14629 
          self.ex.read(iprot)
14630 
        else:
14631 
          iprot.skip(ftype)
14632 
      else:
14633 
        iprot.skip(ftype)
14634 
      iprot.readFieldEnd()
14635 
    iprot.readStructEnd()
14636 
 
14637 
  def write(self, oprot):
14638 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14639 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14640 
      return
14641 
    oprot.writeStructBegin('addInvoiceNumber_result')
14642 
    if self.ex is not None:
14643 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
14644 
      self.ex.write(oprot)
14645 
      oprot.writeFieldEnd()
14646 
    oprot.writeFieldStop()
14647 
    oprot.writeStructEnd()
14648 
 
14649 
  def validate(self):
14650 
    return
14651 
 
14652 
 
14653 
  def __repr__(self):
14654 
    L = ['%s=%r' % (key, value)
14655 
      for key, value in self.__dict__.iteritems()]
14656 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14657 
 
14658 
  def __eq__(self, other):
14659 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14660 
 
14661 
  def __ne__(self, other):
14662 
    return not (self == other)
14663 
 
4910 phani.kuma 14664 
class markOrdersAsShippedFromWarehouse_args:
1408 ankur.sing 14665 
  """
14666 
  Attributes:
3064 chandransh 14667 
   - warehouseId
1408 ankur.sing 14668 
   - providerId
3064 chandransh 14669 
   - cod
4910 phani.kuma 14670 
   - orderIds
1408 ankur.sing 14671 
  """
14672 
 
14673 
  thrift_spec = (
14674 
    None, # 0
3064 chandransh 14675 
    (1, TType.I64, 'warehouseId', None, None, ), # 1
14676 
    (2, TType.I64, 'providerId', None, None, ), # 2
14677 
    (3, TType.BOOL, 'cod', None, None, ), # 3
4910 phani.kuma 14678 
    (4, TType.LIST, 'orderIds', (TType.I64,None), None, ), # 4
1408 ankur.sing 14679 
  )
14680 
 
4910 phani.kuma 14681 
  def __init__(self, warehouseId=None, providerId=None, cod=None, orderIds=None,):
3064 chandransh 14682 
    self.warehouseId = warehouseId
1408 ankur.sing 14683 
    self.providerId = providerId
3064 chandransh 14684 
    self.cod = cod
4910 phani.kuma 14685 
    self.orderIds = orderIds
1408 ankur.sing 14686 
 
14687 
  def read(self, iprot):
14688 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14689 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14690 
      return
14691 
    iprot.readStructBegin()
14692 
    while True:
14693 
      (fname, ftype, fid) = iprot.readFieldBegin()
14694 
      if ftype == TType.STOP:
14695 
        break
14696 
      if fid == 1:
14697 
        if ftype == TType.I64:
3064 chandransh 14698 
          self.warehouseId = iprot.readI64();
1408 ankur.sing 14699 
        else:
14700 
          iprot.skip(ftype)
14701 
      elif fid == 2:
14702 
        if ftype == TType.I64:
3064 chandransh 14703 
          self.providerId = iprot.readI64();
1408 ankur.sing 14704 
        else:
14705 
          iprot.skip(ftype)
3064 chandransh 14706 
      elif fid == 3:
14707 
        if ftype == TType.BOOL:
14708 
          self.cod = iprot.readBool();
14709 
        else:
14710 
          iprot.skip(ftype)
4910 phani.kuma 14711 
      elif fid == 4:
14712 
        if ftype == TType.LIST:
14713 
          self.orderIds = []
6188 rajveer 14714 
          (_etype284, _size281) = iprot.readListBegin()
14715 
          for _i285 in xrange(_size281):
14716 
            _elem286 = iprot.readI64();
14717 
            self.orderIds.append(_elem286)
4910 phani.kuma 14718 
          iprot.readListEnd()
14719 
        else:
14720 
          iprot.skip(ftype)
1408 ankur.sing 14721 
      else:
14722 
        iprot.skip(ftype)
14723 
      iprot.readFieldEnd()
14724 
    iprot.readStructEnd()
14725 
 
14726 
  def write(self, oprot):
14727 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14728 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14729 
      return
4910 phani.kuma 14730 
    oprot.writeStructBegin('markOrdersAsShippedFromWarehouse_args')
3431 rajveer 14731 
    if self.warehouseId is not None:
3064 chandransh 14732 
      oprot.writeFieldBegin('warehouseId', TType.I64, 1)
14733 
      oprot.writeI64(self.warehouseId)
14734 
      oprot.writeFieldEnd()
3431 rajveer 14735 
    if self.providerId is not None:
3064 chandransh 14736 
      oprot.writeFieldBegin('providerId', TType.I64, 2)
1408 ankur.sing 14737 
      oprot.writeI64(self.providerId)
14738 
      oprot.writeFieldEnd()
3431 rajveer 14739 
    if self.cod is not None:
3064 chandransh 14740 
      oprot.writeFieldBegin('cod', TType.BOOL, 3)
14741 
      oprot.writeBool(self.cod)
1408 ankur.sing 14742 
      oprot.writeFieldEnd()
4910 phani.kuma 14743 
    if self.orderIds is not None:
14744 
      oprot.writeFieldBegin('orderIds', TType.LIST, 4)
14745 
      oprot.writeListBegin(TType.I64, len(self.orderIds))
6188 rajveer 14746 
      for iter287 in self.orderIds:
14747 
        oprot.writeI64(iter287)
4910 phani.kuma 14748 
      oprot.writeListEnd()
14749 
      oprot.writeFieldEnd()
1408 ankur.sing 14750 
    oprot.writeFieldStop()
14751 
    oprot.writeStructEnd()
14752 
 
3431 rajveer 14753 
  def validate(self):
14754 
    return
14755 
 
14756 
 
1408 ankur.sing 14757 
  def __repr__(self):
14758 
    L = ['%s=%r' % (key, value)
14759 
      for key, value in self.__dict__.iteritems()]
14760 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14761 
 
14762 
  def __eq__(self, other):
14763 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14764 
 
14765 
  def __ne__(self, other):
14766 
    return not (self == other)
14767 
 
4910 phani.kuma 14768 
class markOrdersAsShippedFromWarehouse_result:
1408 ankur.sing 14769 
  """
14770 
  Attributes:
14771 
   - success
3064 chandransh 14772 
   - ex
1408 ankur.sing 14773 
  """
14774 
 
14775 
  thrift_spec = (
3064 chandransh 14776 
    (0, TType.BOOL, 'success', None, None, ), # 0
14777 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
1408 ankur.sing 14778 
  )
14779 
 
3064 chandransh 14780 
  def __init__(self, success=None, ex=None,):
1408 ankur.sing 14781 
    self.success = success
3064 chandransh 14782 
    self.ex = ex
1408 ankur.sing 14783 
 
14784 
  def read(self, iprot):
14785 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14786 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14787 
      return
14788 
    iprot.readStructBegin()
14789 
    while True:
14790 
      (fname, ftype, fid) = iprot.readFieldBegin()
14791 
      if ftype == TType.STOP:
14792 
        break
14793 
      if fid == 0:
3064 chandransh 14794 
        if ftype == TType.BOOL:
14795 
          self.success = iprot.readBool();
1408 ankur.sing 14796 
        else:
14797 
          iprot.skip(ftype)
3064 chandransh 14798 
      elif fid == 1:
14799 
        if ftype == TType.STRUCT:
14800 
          self.ex = TransactionServiceException()
14801 
          self.ex.read(iprot)
14802 
        else:
14803 
          iprot.skip(ftype)
1408 ankur.sing 14804 
      else:
14805 
        iprot.skip(ftype)
14806 
      iprot.readFieldEnd()
14807 
    iprot.readStructEnd()
14808 
 
14809 
  def write(self, oprot):
14810 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14811 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14812 
      return
4910 phani.kuma 14813 
    oprot.writeStructBegin('markOrdersAsShippedFromWarehouse_result')
3431 rajveer 14814 
    if self.success is not None:
3064 chandransh 14815 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
14816 
      oprot.writeBool(self.success)
1408 ankur.sing 14817 
      oprot.writeFieldEnd()
3431 rajveer 14818 
    if self.ex is not None:
3064 chandransh 14819 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
14820 
      self.ex.write(oprot)
14821 
      oprot.writeFieldEnd()
1408 ankur.sing 14822 
    oprot.writeFieldStop()
14823 
    oprot.writeStructEnd()
14824 
 
3431 rajveer 14825 
  def validate(self):
14826 
    return
14827 
 
14828 
 
1408 ankur.sing 14829 
  def __repr__(self):
14830 
    L = ['%s=%r' % (key, value)
14831 
      for key, value in self.__dict__.iteritems()]
14832 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14833 
 
14834 
  def __eq__(self, other):
14835 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14836 
 
14837 
  def __ne__(self, other):
14838 
    return not (self == other)
14839 
 
5676 rajveer 14840 
class markOrdersAsReturnedFromStore_args:
14841 
  """
14842 
  Attributes:
14843 
   - providerId
14844 
   - orderIds
5713 rajveer 14845 
   - awbs
5676 rajveer 14846 
  """
14847 
 
14848 
  thrift_spec = (
14849 
    None, # 0
14850 
    (1, TType.I64, 'providerId', None, None, ), # 1
14851 
    (2, TType.LIST, 'orderIds', (TType.I64,None), None, ), # 2
5713 rajveer 14852 
    (3, TType.LIST, 'awbs', (TType.STRING,None), None, ), # 3
5676 rajveer 14853 
  )
14854 
 
5713 rajveer 14855 
  def __init__(self, providerId=None, orderIds=None, awbs=None,):
5676 rajveer 14856 
    self.providerId = providerId
14857 
    self.orderIds = orderIds
5713 rajveer 14858 
    self.awbs = awbs
5676 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.providerId = iprot.readI64();
14872 
        else:
14873 
          iprot.skip(ftype)
14874 
      elif fid == 2:
14875 
        if ftype == TType.LIST:
14876 
          self.orderIds = []
6188 rajveer 14877 
          (_etype291, _size288) = iprot.readListBegin()
14878 
          for _i292 in xrange(_size288):
14879 
            _elem293 = iprot.readI64();
14880 
            self.orderIds.append(_elem293)
5676 rajveer 14881 
          iprot.readListEnd()
14882 
        else:
14883 
          iprot.skip(ftype)
5713 rajveer 14884 
      elif fid == 3:
14885 
        if ftype == TType.LIST:
14886 
          self.awbs = []
6188 rajveer 14887 
          (_etype297, _size294) = iprot.readListBegin()
14888 
          for _i298 in xrange(_size294):
14889 
            _elem299 = iprot.readString();
14890 
            self.awbs.append(_elem299)
5713 rajveer 14891 
          iprot.readListEnd()
14892 
        else:
14893 
          iprot.skip(ftype)
5676 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('markOrdersAsReturnedFromStore_args')
14904 
    if self.providerId is not None:
14905 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
14906 
      oprot.writeI64(self.providerId)
14907 
      oprot.writeFieldEnd()
14908 
    if self.orderIds is not None:
14909 
      oprot.writeFieldBegin('orderIds', TType.LIST, 2)
14910 
      oprot.writeListBegin(TType.I64, len(self.orderIds))
6188 rajveer 14911 
      for iter300 in self.orderIds:
14912 
        oprot.writeI64(iter300)
5676 rajveer 14913 
      oprot.writeListEnd()
14914 
      oprot.writeFieldEnd()
5713 rajveer 14915 
    if self.awbs is not None:
14916 
      oprot.writeFieldBegin('awbs', TType.LIST, 3)
14917 
      oprot.writeListBegin(TType.STRING, len(self.awbs))
6188 rajveer 14918 
      for iter301 in self.awbs:
14919 
        oprot.writeString(iter301)
5713 rajveer 14920 
      oprot.writeListEnd()
14921 
      oprot.writeFieldEnd()
5676 rajveer 14922 
    oprot.writeFieldStop()
14923 
    oprot.writeStructEnd()
14924 
 
14925 
  def validate(self):
14926 
    return
14927 
 
14928 
 
14929 
  def __repr__(self):
14930 
    L = ['%s=%r' % (key, value)
14931 
      for key, value in self.__dict__.iteritems()]
14932 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14933 
 
14934 
  def __eq__(self, other):
14935 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14936 
 
14937 
  def __ne__(self, other):
14938 
    return not (self == other)
14939 
 
14940 
class markOrdersAsReturnedFromStore_result:
14941 
  """
14942 
  Attributes:
14943 
   - success
14944 
   - ex
14945 
  """
14946 
 
14947 
  thrift_spec = (
14948 
    (0, TType.BOOL, 'success', None, None, ), # 0
14949 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
14950 
  )
14951 
 
14952 
  def __init__(self, success=None, ex=None,):
14953 
    self.success = success
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 == 0:
14966 
        if ftype == TType.BOOL:
14967 
          self.success = iprot.readBool();
14968 
        else:
14969 
          iprot.skip(ftype)
14970 
      elif fid == 1:
14971 
        if ftype == TType.STRUCT:
14972 
          self.ex = TransactionServiceException()
14973 
          self.ex.read(iprot)
14974 
        else:
14975 
          iprot.skip(ftype)
14976 
      else:
14977 
        iprot.skip(ftype)
14978 
      iprot.readFieldEnd()
14979 
    iprot.readStructEnd()
14980 
 
14981 
  def write(self, oprot):
14982 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14983 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14984 
      return
14985 
    oprot.writeStructBegin('markOrdersAsReturnedFromStore_result')
14986 
    if self.success is not None:
14987 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
14988 
      oprot.writeBool(self.success)
14989 
      oprot.writeFieldEnd()
14990 
    if self.ex is not None:
14991 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
14992 
      self.ex.write(oprot)
14993 
      oprot.writeFieldEnd()
14994 
    oprot.writeFieldStop()
14995 
    oprot.writeStructEnd()
14996 
 
14997 
  def validate(self):
14998 
    return
14999 
 
15000 
 
15001 
  def __repr__(self):
15002 
    L = ['%s=%r' % (key, value)
15003 
      for key, value in self.__dict__.iteritems()]
15004 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15005 
 
15006 
  def __eq__(self, other):
15007 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15008 
 
15009 
  def __ne__(self, other):
15010 
    return not (self == other)
15011 
 
4910 phani.kuma 15012 
class markOrdersAsPickedUp_args:
4410 rajveer 15013 
  """
15014 
  Attributes:
15015 
   - providerId
4910 phani.kuma 15016 
   - pickupDetails
4410 rajveer 15017 
  """
15018 
 
15019 
  thrift_spec = (
15020 
    None, # 0
4910 phani.kuma 15021 
    (1, TType.I64, 'providerId', None, None, ), # 1
15022 
    (2, TType.MAP, 'pickupDetails', (TType.STRING,None,TType.STRING,None), None, ), # 2
4410 rajveer 15023 
  )
15024 
 
4910 phani.kuma 15025 
  def __init__(self, providerId=None, pickupDetails=None,):
4410 rajveer 15026 
    self.providerId = providerId
4910 phani.kuma 15027 
    self.pickupDetails = pickupDetails
4410 rajveer 15028 
 
15029 
  def read(self, iprot):
15030 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15031 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15032 
      return
15033 
    iprot.readStructBegin()
15034 
    while True:
15035 
      (fname, ftype, fid) = iprot.readFieldBegin()
15036 
      if ftype == TType.STOP:
15037 
        break
15038 
      if fid == 1:
15039 
        if ftype == TType.I64:
4910 phani.kuma 15040 
          self.providerId = iprot.readI64();
4410 rajveer 15041 
        else:
15042 
          iprot.skip(ftype)
15043 
      elif fid == 2:
4910 phani.kuma 15044 
        if ftype == TType.MAP:
15045 
          self.pickupDetails = {}
6188 rajveer 15046 
          (_ktype303, _vtype304, _size302 ) = iprot.readMapBegin()
15047 
          for _i306 in xrange(_size302):
15048 
            _key307 = iprot.readString();
15049 
            _val308 = iprot.readString();
15050 
            self.pickupDetails[_key307] = _val308
4910 phani.kuma 15051 
          iprot.readMapEnd()
4410 rajveer 15052 
        else:
15053 
          iprot.skip(ftype)
15054 
      else:
15055 
        iprot.skip(ftype)
15056 
      iprot.readFieldEnd()
15057 
    iprot.readStructEnd()
15058 
 
15059 
  def write(self, oprot):
15060 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15061 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15062 
      return
4910 phani.kuma 15063 
    oprot.writeStructBegin('markOrdersAsPickedUp_args')
4410 rajveer 15064 
    if self.providerId is not None:
4910 phani.kuma 15065 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
4410 rajveer 15066 
      oprot.writeI64(self.providerId)
15067 
      oprot.writeFieldEnd()
4910 phani.kuma 15068 
    if self.pickupDetails is not None:
15069 
      oprot.writeFieldBegin('pickupDetails', TType.MAP, 2)
15070 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.pickupDetails))
6188 rajveer 15071 
      for kiter309,viter310 in self.pickupDetails.items():
15072 
        oprot.writeString(kiter309)
15073 
        oprot.writeString(viter310)
4910 phani.kuma 15074 
      oprot.writeMapEnd()
4410 rajveer 15075 
      oprot.writeFieldEnd()
15076 
    oprot.writeFieldStop()
15077 
    oprot.writeStructEnd()
15078 
 
15079 
  def validate(self):
15080 
    return
15081 
 
15082 
 
15083 
  def __repr__(self):
15084 
    L = ['%s=%r' % (key, value)
15085 
      for key, value in self.__dict__.iteritems()]
15086 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15087 
 
15088 
  def __eq__(self, other):
15089 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15090 
 
15091 
  def __ne__(self, other):
15092 
    return not (self == other)
15093 
 
4910 phani.kuma 15094 
class markOrdersAsPickedUp_result:
4410 rajveer 15095 
  """
15096 
  Attributes:
15097 
   - ex
15098 
  """
15099 
 
15100 
  thrift_spec = (
4910 phani.kuma 15101 
    None, # 0
4410 rajveer 15102 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
15103 
  )
15104 
 
4910 phani.kuma 15105 
  def __init__(self, ex=None,):
4410 rajveer 15106 
    self.ex = ex
15107 
 
15108 
  def read(self, iprot):
15109 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15110 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15111 
      return
15112 
    iprot.readStructBegin()
15113 
    while True:
15114 
      (fname, ftype, fid) = iprot.readFieldBegin()
15115 
      if ftype == TType.STOP:
15116 
        break
4910 phani.kuma 15117 
      if fid == 1:
4410 rajveer 15118 
        if ftype == TType.STRUCT:
15119 
          self.ex = TransactionServiceException()
15120 
          self.ex.read(iprot)
15121 
        else:
15122 
          iprot.skip(ftype)
15123 
      else:
15124 
        iprot.skip(ftype)
15125 
      iprot.readFieldEnd()
15126 
    iprot.readStructEnd()
15127 
 
15128 
  def write(self, oprot):
15129 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15130 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15131 
      return
4910 phani.kuma 15132 
    oprot.writeStructBegin('markOrdersAsPickedUp_result')
4410 rajveer 15133 
    if self.ex is not None:
15134 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
15135 
      self.ex.write(oprot)
15136 
      oprot.writeFieldEnd()
15137 
    oprot.writeFieldStop()
15138 
    oprot.writeStructEnd()
15139 
 
15140 
  def validate(self):
15141 
    return
15142 
 
15143 
 
15144 
  def __repr__(self):
15145 
    L = ['%s=%r' % (key, value)
15146 
      for key, value in self.__dict__.iteritems()]
15147 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15148 
 
15149 
  def __eq__(self, other):
15150 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15151 
 
15152 
  def __ne__(self, other):
15153 
    return not (self == other)
15154 
 
4910 phani.kuma 15155 
class getOrdersNotPickedUp_args:
304 ashish 15156 
  """
15157 
  Attributes:
3064 chandransh 15158 
   - providerId
304 ashish 15159 
  """
94 ashish 15160 
 
304 ashish 15161 
  thrift_spec = (
15162 
    None, # 0
3064 chandransh 15163 
    (1, TType.I64, 'providerId', None, None, ), # 1
304 ashish 15164 
  )
15165 
 
4910 phani.kuma 15166 
  def __init__(self, providerId=None,):
3064 chandransh 15167 
    self.providerId = providerId
304 ashish 15168 
 
15169 
  def read(self, iprot):
15170 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15171 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15172 
      return
15173 
    iprot.readStructBegin()
15174 
    while True:
15175 
      (fname, ftype, fid) = iprot.readFieldBegin()
15176 
      if ftype == TType.STOP:
15177 
        break
15178 
      if fid == 1:
15179 
        if ftype == TType.I64:
3064 chandransh 15180 
          self.providerId = iprot.readI64();
304 ashish 15181 
        else:
15182 
          iprot.skip(ftype)
15183 
      else:
15184 
        iprot.skip(ftype)
15185 
      iprot.readFieldEnd()
15186 
    iprot.readStructEnd()
15187 
 
15188 
  def write(self, oprot):
15189 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15190 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15191 
      return
4910 phani.kuma 15192 
    oprot.writeStructBegin('getOrdersNotPickedUp_args')
3431 rajveer 15193 
    if self.providerId is not None:
3064 chandransh 15194 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
15195 
      oprot.writeI64(self.providerId)
304 ashish 15196 
      oprot.writeFieldEnd()
15197 
    oprot.writeFieldStop()
15198 
    oprot.writeStructEnd()
15199 
 
3431 rajveer 15200 
  def validate(self):
15201 
    return
15202 
 
15203 
 
304 ashish 15204 
  def __repr__(self):
15205 
    L = ['%s=%r' % (key, value)
15206 
      for key, value in self.__dict__.iteritems()]
15207 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15208 
 
15209 
  def __eq__(self, other):
15210 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15211 
 
15212 
  def __ne__(self, other):
15213 
    return not (self == other)
15214 
 
4910 phani.kuma 15215 
class getOrdersNotPickedUp_result:
304 ashish 15216 
  """
15217 
  Attributes:
15218 
   - success
15219 
  """
15220 
 
15221 
  thrift_spec = (
3064 chandransh 15222 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
304 ashish 15223 
  )
15224 
 
4910 phani.kuma 15225 
  def __init__(self, success=None,):
304 ashish 15226 
    self.success = success
15227 
 
15228 
  def read(self, iprot):
15229 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15230 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15231 
      return
15232 
    iprot.readStructBegin()
15233 
    while True:
15234 
      (fname, ftype, fid) = iprot.readFieldBegin()
15235 
      if ftype == TType.STOP:
15236 
        break
15237 
      if fid == 0:
15238 
        if ftype == TType.LIST:
15239 
          self.success = []
6188 rajveer 15240 
          (_etype314, _size311) = iprot.readListBegin()
15241 
          for _i315 in xrange(_size311):
15242 
            _elem316 = Order()
15243 
            _elem316.read(iprot)
15244 
            self.success.append(_elem316)
304 ashish 15245 
          iprot.readListEnd()
15246 
        else:
15247 
          iprot.skip(ftype)
15248 
      else:
15249 
        iprot.skip(ftype)
15250 
      iprot.readFieldEnd()
15251 
    iprot.readStructEnd()
15252 
 
15253 
  def write(self, oprot):
15254 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15255 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15256 
      return
4910 phani.kuma 15257 
    oprot.writeStructBegin('getOrdersNotPickedUp_result')
3431 rajveer 15258 
    if self.success is not None:
304 ashish 15259 
      oprot.writeFieldBegin('success', TType.LIST, 0)
15260 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 15261 
      for iter317 in self.success:
15262 
        iter317.write(oprot)
304 ashish 15263 
      oprot.writeListEnd()
15264 
      oprot.writeFieldEnd()
15265 
    oprot.writeFieldStop()
15266 
    oprot.writeStructEnd()
15267 
 
3431 rajveer 15268 
  def validate(self):
15269 
    return
15270 
 
15271 
 
304 ashish 15272 
  def __repr__(self):
15273 
    L = ['%s=%r' % (key, value)
15274 
      for key, value in self.__dict__.iteritems()]
15275 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15276 
 
15277 
  def __eq__(self, other):
15278 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15279 
 
15280 
  def __ne__(self, other):
15281 
    return not (self == other)
15282 
 
3064 chandransh 15283 
class markOrdersAsDelivered_args:
304 ashish 15284 
  """
15285 
  Attributes:
3064 chandransh 15286 
   - providerId
15287 
   - deliveredOrders
304 ashish 15288 
  """
15289 
 
15290 
  thrift_spec = (
15291 
    None, # 0
3064 chandransh 15292 
    (1, TType.I64, 'providerId', None, None, ), # 1
15293 
    (2, TType.MAP, 'deliveredOrders', (TType.STRING,None,TType.STRING,None), None, ), # 2
304 ashish 15294 
  )
15295 
 
3064 chandransh 15296 
  def __init__(self, providerId=None, deliveredOrders=None,):
15297 
    self.providerId = providerId
15298 
    self.deliveredOrders = deliveredOrders
304 ashish 15299 
 
15300 
  def read(self, iprot):
15301 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15302 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15303 
      return
15304 
    iprot.readStructBegin()
15305 
    while True:
15306 
      (fname, ftype, fid) = iprot.readFieldBegin()
15307 
      if ftype == TType.STOP:
15308 
        break
15309 
      if fid == 1:
15310 
        if ftype == TType.I64:
3064 chandransh 15311 
          self.providerId = iprot.readI64();
304 ashish 15312 
        else:
15313 
          iprot.skip(ftype)
15314 
      elif fid == 2:
3064 chandransh 15315 
        if ftype == TType.MAP:
15316 
          self.deliveredOrders = {}
6188 rajveer 15317 
          (_ktype319, _vtype320, _size318 ) = iprot.readMapBegin()
15318 
          for _i322 in xrange(_size318):
15319 
            _key323 = iprot.readString();
15320 
            _val324 = iprot.readString();
15321 
            self.deliveredOrders[_key323] = _val324
3064 chandransh 15322 
          iprot.readMapEnd()
304 ashish 15323 
        else:
15324 
          iprot.skip(ftype)
15325 
      else:
15326 
        iprot.skip(ftype)
15327 
      iprot.readFieldEnd()
15328 
    iprot.readStructEnd()
15329 
 
15330 
  def write(self, oprot):
15331 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15332 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15333 
      return
3064 chandransh 15334 
    oprot.writeStructBegin('markOrdersAsDelivered_args')
3431 rajveer 15335 
    if self.providerId is not None:
3064 chandransh 15336 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
15337 
      oprot.writeI64(self.providerId)
304 ashish 15338 
      oprot.writeFieldEnd()
3431 rajveer 15339 
    if self.deliveredOrders is not None:
3064 chandransh 15340 
      oprot.writeFieldBegin('deliveredOrders', TType.MAP, 2)
15341 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.deliveredOrders))
6188 rajveer 15342 
      for kiter325,viter326 in self.deliveredOrders.items():
15343 
        oprot.writeString(kiter325)
15344 
        oprot.writeString(viter326)
3064 chandransh 15345 
      oprot.writeMapEnd()
304 ashish 15346 
      oprot.writeFieldEnd()
15347 
    oprot.writeFieldStop()
15348 
    oprot.writeStructEnd()
15349 
 
3431 rajveer 15350 
  def validate(self):
15351 
    return
15352 
 
15353 
 
304 ashish 15354 
  def __repr__(self):
15355 
    L = ['%s=%r' % (key, value)
15356 
      for key, value in self.__dict__.iteritems()]
15357 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15358 
 
15359 
  def __eq__(self, other):
15360 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15361 
 
15362 
  def __ne__(self, other):
15363 
    return not (self == other)
15364 
 
3064 chandransh 15365 
class markOrdersAsDelivered_result:
15366 
  """
15367 
  Attributes:
15368 
   - ex
15369 
  """
304 ashish 15370 
 
15371 
  thrift_spec = (
3064 chandransh 15372 
    None, # 0
15373 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
304 ashish 15374 
  )
15375 
 
3064 chandransh 15376 
  def __init__(self, ex=None,):
15377 
    self.ex = ex
304 ashish 15378 
 
1596 ankur.sing 15379 
  def read(self, iprot):
15380 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15381 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15382 
      return
15383 
    iprot.readStructBegin()
15384 
    while True:
15385 
      (fname, ftype, fid) = iprot.readFieldBegin()
15386 
      if ftype == TType.STOP:
15387 
        break
3064 chandransh 15388 
      if fid == 1:
15389 
        if ftype == TType.STRUCT:
15390 
          self.ex = TransactionServiceException()
15391 
          self.ex.read(iprot)
15392 
        else:
15393 
          iprot.skip(ftype)
1596 ankur.sing 15394 
      else:
15395 
        iprot.skip(ftype)
15396 
      iprot.readFieldEnd()
15397 
    iprot.readStructEnd()
15398 
 
15399 
  def write(self, oprot):
15400 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15401 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15402 
      return
3064 chandransh 15403 
    oprot.writeStructBegin('markOrdersAsDelivered_result')
3431 rajveer 15404 
    if self.ex is not None:
3064 chandransh 15405 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
15406 
      self.ex.write(oprot)
15407 
      oprot.writeFieldEnd()
1596 ankur.sing 15408 
    oprot.writeFieldStop()
15409 
    oprot.writeStructEnd()
15410 
 
3431 rajveer 15411 
  def validate(self):
15412 
    return
15413 
 
15414 
 
1596 ankur.sing 15415 
  def __repr__(self):
15416 
    L = ['%s=%r' % (key, value)
15417 
      for key, value in self.__dict__.iteritems()]
15418 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15419 
 
15420 
  def __eq__(self, other):
15421 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15422 
 
15423 
  def __ne__(self, other):
15424 
    return not (self == other)
15425 
 
4910 phani.kuma 15426 
class markAsRTOrders_args:
1596 ankur.sing 15427 
  """
15428 
  Attributes:
3064 chandransh 15429 
   - providerId
15430 
   - returnedOrders
1596 ankur.sing 15431 
  """
15432 
 
15433 
  thrift_spec = (
3064 chandransh 15434 
    None, # 0
15435 
    (1, TType.I64, 'providerId', None, None, ), # 1
15436 
    (2, TType.MAP, 'returnedOrders', (TType.STRING,None,TType.STRING,None), None, ), # 2
1596 ankur.sing 15437 
  )
15438 
 
3064 chandransh 15439 
  def __init__(self, providerId=None, returnedOrders=None,):
15440 
    self.providerId = providerId
15441 
    self.returnedOrders = returnedOrders
1596 ankur.sing 15442 
 
15443 
  def read(self, iprot):
15444 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15445 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15446 
      return
15447 
    iprot.readStructBegin()
15448 
    while True:
15449 
      (fname, ftype, fid) = iprot.readFieldBegin()
15450 
      if ftype == TType.STOP:
15451 
        break
3064 chandransh 15452 
      if fid == 1:
1596 ankur.sing 15453 
        if ftype == TType.I64:
3064 chandransh 15454 
          self.providerId = iprot.readI64();
1596 ankur.sing 15455 
        else:
15456 
          iprot.skip(ftype)
3064 chandransh 15457 
      elif fid == 2:
15458 
        if ftype == TType.MAP:
15459 
          self.returnedOrders = {}
6188 rajveer 15460 
          (_ktype328, _vtype329, _size327 ) = iprot.readMapBegin()
15461 
          for _i331 in xrange(_size327):
15462 
            _key332 = iprot.readString();
15463 
            _val333 = iprot.readString();
15464 
            self.returnedOrders[_key332] = _val333
3064 chandransh 15465 
          iprot.readMapEnd()
15466 
        else:
15467 
          iprot.skip(ftype)
1596 ankur.sing 15468 
      else:
15469 
        iprot.skip(ftype)
15470 
      iprot.readFieldEnd()
15471 
    iprot.readStructEnd()
15472 
 
15473 
  def write(self, oprot):
15474 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15475 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15476 
      return
4910 phani.kuma 15477 
    oprot.writeStructBegin('markAsRTOrders_args')
3431 rajveer 15478 
    if self.providerId is not None:
3064 chandransh 15479 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
15480 
      oprot.writeI64(self.providerId)
1596 ankur.sing 15481 
      oprot.writeFieldEnd()
3431 rajveer 15482 
    if self.returnedOrders is not None:
3064 chandransh 15483 
      oprot.writeFieldBegin('returnedOrders', TType.MAP, 2)
15484 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.returnedOrders))
6188 rajveer 15485 
      for kiter334,viter335 in self.returnedOrders.items():
15486 
        oprot.writeString(kiter334)
15487 
        oprot.writeString(viter335)
3064 chandransh 15488 
      oprot.writeMapEnd()
15489 
      oprot.writeFieldEnd()
1596 ankur.sing 15490 
    oprot.writeFieldStop()
15491 
    oprot.writeStructEnd()
15492 
 
3431 rajveer 15493 
  def validate(self):
15494 
    return
15495 
 
15496 
 
1596 ankur.sing 15497 
  def __repr__(self):
15498 
    L = ['%s=%r' % (key, value)
15499 
      for key, value in self.__dict__.iteritems()]
15500 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15501 
 
15502 
  def __eq__(self, other):
15503 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15504 
 
15505 
  def __ne__(self, other):
15506 
    return not (self == other)
15507 
 
4910 phani.kuma 15508 
class markAsRTOrders_result:
3064 chandransh 15509 
  """
15510 
  Attributes:
15511 
   - ex
15512 
  """
1596 ankur.sing 15513 
 
1627 ankur.sing 15514 
  thrift_spec = (
3064 chandransh 15515 
    None, # 0
15516 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
1627 ankur.sing 15517 
  )
15518 
 
3064 chandransh 15519 
  def __init__(self, ex=None,):
15520 
    self.ex = ex
15521 
 
1627 ankur.sing 15522 
  def read(self, iprot):
15523 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15524 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15525 
      return
15526 
    iprot.readStructBegin()
15527 
    while True:
15528 
      (fname, ftype, fid) = iprot.readFieldBegin()
15529 
      if ftype == TType.STOP:
15530 
        break
3064 chandransh 15531 
      if fid == 1:
15532 
        if ftype == TType.STRUCT:
15533 
          self.ex = TransactionServiceException()
15534 
          self.ex.read(iprot)
15535 
        else:
15536 
          iprot.skip(ftype)
1627 ankur.sing 15537 
      else:
15538 
        iprot.skip(ftype)
15539 
      iprot.readFieldEnd()
15540 
    iprot.readStructEnd()
15541 
 
15542 
  def write(self, oprot):
15543 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15544 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15545 
      return
4910 phani.kuma 15546 
    oprot.writeStructBegin('markAsRTOrders_result')
3431 rajveer 15547 
    if self.ex is not None:
3064 chandransh 15548 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
15549 
      self.ex.write(oprot)
15550 
      oprot.writeFieldEnd()
1627 ankur.sing 15551 
    oprot.writeFieldStop()
15552 
    oprot.writeStructEnd()
15553 
 
3431 rajveer 15554 
  def validate(self):
15555 
    return
15556 
 
15557 
 
1627 ankur.sing 15558 
  def __repr__(self):
15559 
    L = ['%s=%r' % (key, value)
15560 
      for key, value in self.__dict__.iteritems()]
15561 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15562 
 
15563 
  def __eq__(self, other):
15564 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15565 
 
15566 
  def __ne__(self, other):
15567 
    return not (self == other)
15568 
 
4910 phani.kuma 15569 
class getRTOrders_args:
15570 
  """
15571 
  Attributes:
15572 
   - providerId
15573 
  """
15574 
 
15575 
  thrift_spec = (
15576 
    None, # 0
15577 
    (1, TType.I64, 'providerId', None, None, ), # 1
15578 
  )
15579 
 
15580 
  def __init__(self, providerId=None,):
15581 
    self.providerId = providerId
15582 
 
15583 
  def read(self, iprot):
15584 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15585 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15586 
      return
15587 
    iprot.readStructBegin()
15588 
    while True:
15589 
      (fname, ftype, fid) = iprot.readFieldBegin()
15590 
      if ftype == TType.STOP:
15591 
        break
15592 
      if fid == 1:
15593 
        if ftype == TType.I64:
15594 
          self.providerId = iprot.readI64();
15595 
        else:
15596 
          iprot.skip(ftype)
15597 
      else:
15598 
        iprot.skip(ftype)
15599 
      iprot.readFieldEnd()
15600 
    iprot.readStructEnd()
15601 
 
15602 
  def write(self, oprot):
15603 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15604 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15605 
      return
15606 
    oprot.writeStructBegin('getRTOrders_args')
15607 
    if self.providerId is not None:
15608 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
15609 
      oprot.writeI64(self.providerId)
15610 
      oprot.writeFieldEnd()
15611 
    oprot.writeFieldStop()
15612 
    oprot.writeStructEnd()
15613 
 
15614 
  def validate(self):
15615 
    return
15616 
 
15617 
 
15618 
  def __repr__(self):
15619 
    L = ['%s=%r' % (key, value)
15620 
      for key, value in self.__dict__.iteritems()]
15621 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15622 
 
15623 
  def __eq__(self, other):
15624 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15625 
 
15626 
  def __ne__(self, other):
15627 
    return not (self == other)
15628 
 
15629 
class getRTOrders_result:
15630 
  """
15631 
  Attributes:
15632 
   - success
15633 
  """
15634 
 
15635 
  thrift_spec = (
15636 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
15637 
  )
15638 
 
15639 
  def __init__(self, success=None,):
15640 
    self.success = success
15641 
 
15642 
  def read(self, iprot):
15643 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15644 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15645 
      return
15646 
    iprot.readStructBegin()
15647 
    while True:
15648 
      (fname, ftype, fid) = iprot.readFieldBegin()
15649 
      if ftype == TType.STOP:
15650 
        break
15651 
      if fid == 0:
15652 
        if ftype == TType.LIST:
15653 
          self.success = []
6188 rajveer 15654 
          (_etype339, _size336) = iprot.readListBegin()
15655 
          for _i340 in xrange(_size336):
15656 
            _elem341 = Order()
15657 
            _elem341.read(iprot)
15658 
            self.success.append(_elem341)
4910 phani.kuma 15659 
          iprot.readListEnd()
15660 
        else:
15661 
          iprot.skip(ftype)
15662 
      else:
15663 
        iprot.skip(ftype)
15664 
      iprot.readFieldEnd()
15665 
    iprot.readStructEnd()
15666 
 
15667 
  def write(self, oprot):
15668 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15669 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15670 
      return
15671 
    oprot.writeStructBegin('getRTOrders_result')
15672 
    if self.success is not None:
15673 
      oprot.writeFieldBegin('success', TType.LIST, 0)
15674 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 15675 
      for iter342 in self.success:
15676 
        iter342.write(oprot)
4910 phani.kuma 15677 
      oprot.writeListEnd()
15678 
      oprot.writeFieldEnd()
15679 
    oprot.writeFieldStop()
15680 
    oprot.writeStructEnd()
15681 
 
15682 
  def validate(self):
15683 
    return
15684 
 
15685 
 
15686 
  def __repr__(self):
15687 
    L = ['%s=%r' % (key, value)
15688 
      for key, value in self.__dict__.iteritems()]
15689 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15690 
 
15691 
  def __eq__(self, other):
15692 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15693 
 
15694 
  def __ne__(self, other):
15695 
    return not (self == other)
15696 
 
3064 chandransh 15697 
class updateNonDeliveryReason_args:
1627 ankur.sing 15698 
  """
15699 
  Attributes:
3064 chandransh 15700 
   - providerId
15701 
   - undeliveredOrders
1627 ankur.sing 15702 
  """
15703 
 
15704 
  thrift_spec = (
3064 chandransh 15705 
    None, # 0
15706 
    (1, TType.I64, 'providerId', None, None, ), # 1
15707 
    (2, TType.MAP, 'undeliveredOrders', (TType.STRING,None,TType.STRING,None), None, ), # 2
1627 ankur.sing 15708 
  )
15709 
 
3064 chandransh 15710 
  def __init__(self, providerId=None, undeliveredOrders=None,):
15711 
    self.providerId = providerId
15712 
    self.undeliveredOrders = undeliveredOrders
1627 ankur.sing 15713 
 
15714 
  def read(self, iprot):
15715 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15716 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15717 
      return
15718 
    iprot.readStructBegin()
15719 
    while True:
15720 
      (fname, ftype, fid) = iprot.readFieldBegin()
15721 
      if ftype == TType.STOP:
15722 
        break
3064 chandransh 15723 
      if fid == 1:
1627 ankur.sing 15724 
        if ftype == TType.I64:
3064 chandransh 15725 
          self.providerId = iprot.readI64();
1627 ankur.sing 15726 
        else:
15727 
          iprot.skip(ftype)
3064 chandransh 15728 
      elif fid == 2:
15729 
        if ftype == TType.MAP:
15730 
          self.undeliveredOrders = {}
6188 rajveer 15731 
          (_ktype344, _vtype345, _size343 ) = iprot.readMapBegin()
15732 
          for _i347 in xrange(_size343):
15733 
            _key348 = iprot.readString();
15734 
            _val349 = iprot.readString();
15735 
            self.undeliveredOrders[_key348] = _val349
3064 chandransh 15736 
          iprot.readMapEnd()
15737 
        else:
15738 
          iprot.skip(ftype)
1627 ankur.sing 15739 
      else:
15740 
        iprot.skip(ftype)
15741 
      iprot.readFieldEnd()
15742 
    iprot.readStructEnd()
15743 
 
15744 
  def write(self, oprot):
15745 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15746 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15747 
      return
3064 chandransh 15748 
    oprot.writeStructBegin('updateNonDeliveryReason_args')
3431 rajveer 15749 
    if self.providerId is not None:
3064 chandransh 15750 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
15751 
      oprot.writeI64(self.providerId)
1627 ankur.sing 15752 
      oprot.writeFieldEnd()
3431 rajveer 15753 
    if self.undeliveredOrders is not None:
3064 chandransh 15754 
      oprot.writeFieldBegin('undeliveredOrders', TType.MAP, 2)
15755 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.undeliveredOrders))
6188 rajveer 15756 
      for kiter350,viter351 in self.undeliveredOrders.items():
15757 
        oprot.writeString(kiter350)
15758 
        oprot.writeString(viter351)
3064 chandransh 15759 
      oprot.writeMapEnd()
15760 
      oprot.writeFieldEnd()
1627 ankur.sing 15761 
    oprot.writeFieldStop()
15762 
    oprot.writeStructEnd()
15763 
 
3431 rajveer 15764 
  def validate(self):
15765 
    return
15766 
 
15767 
 
1627 ankur.sing 15768 
  def __repr__(self):
15769 
    L = ['%s=%r' % (key, value)
15770 
      for key, value in self.__dict__.iteritems()]
15771 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15772 
 
15773 
  def __eq__(self, other):
15774 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15775 
 
15776 
  def __ne__(self, other):
15777 
    return not (self == other)
15778 
 
3064 chandransh 15779 
class updateNonDeliveryReason_result:
1627 ankur.sing 15780 
  """
15781 
  Attributes:
3064 chandransh 15782 
   - ex
1627 ankur.sing 15783 
  """
15784 
 
15785 
  thrift_spec = (
4910 phani.kuma 15786 
    None, # 0
3064 chandransh 15787 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
1627 ankur.sing 15788 
  )
15789 
 
4910 phani.kuma 15790 
  def __init__(self, ex=None,):
3064 chandransh 15791 
    self.ex = ex
1627 ankur.sing 15792 
 
15793 
  def read(self, iprot):
15794 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15795 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15796 
      return
15797 
    iprot.readStructBegin()
15798 
    while True:
15799 
      (fname, ftype, fid) = iprot.readFieldBegin()
15800 
      if ftype == TType.STOP:
15801 
        break
4910 phani.kuma 15802 
      if fid == 1:
15803 
        if ftype == TType.STRUCT:
15804 
          self.ex = TransactionServiceException()
15805 
          self.ex.read(iprot)
15806 
        else:
15807 
          iprot.skip(ftype)
15808 
      else:
15809 
        iprot.skip(ftype)
15810 
      iprot.readFieldEnd()
15811 
    iprot.readStructEnd()
15812 
 
15813 
  def write(self, oprot):
15814 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15815 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15816 
      return
15817 
    oprot.writeStructBegin('updateNonDeliveryReason_result')
15818 
    if self.ex is not None:
15819 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
15820 
      self.ex.write(oprot)
15821 
      oprot.writeFieldEnd()
15822 
    oprot.writeFieldStop()
15823 
    oprot.writeStructEnd()
15824 
 
15825 
  def validate(self):
15826 
    return
15827 
 
15828 
 
15829 
  def __repr__(self):
15830 
    L = ['%s=%r' % (key, value)
15831 
      for key, value in self.__dict__.iteritems()]
15832 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15833 
 
15834 
  def __eq__(self, other):
15835 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15836 
 
15837 
  def __ne__(self, other):
15838 
    return not (self == other)
15839 
 
15840 
class getNonDeliveredOrdersbyCourier_args:
15841 
  """
15842 
  Attributes:
15843 
   - providerId
15844 
  """
15845 
 
15846 
  thrift_spec = (
15847 
    None, # 0
15848 
    (1, TType.I64, 'providerId', None, None, ), # 1
15849 
  )
15850 
 
15851 
  def __init__(self, providerId=None,):
15852 
    self.providerId = providerId
15853 
 
15854 
  def read(self, iprot):
15855 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15856 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15857 
      return
15858 
    iprot.readStructBegin()
15859 
    while True:
15860 
      (fname, ftype, fid) = iprot.readFieldBegin()
15861 
      if ftype == TType.STOP:
15862 
        break
15863 
      if fid == 1:
15864 
        if ftype == TType.I64:
15865 
          self.providerId = iprot.readI64();
15866 
        else:
15867 
          iprot.skip(ftype)
15868 
      else:
15869 
        iprot.skip(ftype)
15870 
      iprot.readFieldEnd()
15871 
    iprot.readStructEnd()
15872 
 
15873 
  def write(self, oprot):
15874 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15875 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15876 
      return
15877 
    oprot.writeStructBegin('getNonDeliveredOrdersbyCourier_args')
15878 
    if self.providerId is not None:
15879 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
15880 
      oprot.writeI64(self.providerId)
15881 
      oprot.writeFieldEnd()
15882 
    oprot.writeFieldStop()
15883 
    oprot.writeStructEnd()
15884 
 
15885 
  def validate(self):
15886 
    return
15887 
 
15888 
 
15889 
  def __repr__(self):
15890 
    L = ['%s=%r' % (key, value)
15891 
      for key, value in self.__dict__.iteritems()]
15892 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15893 
 
15894 
  def __eq__(self, other):
15895 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15896 
 
15897 
  def __ne__(self, other):
15898 
    return not (self == other)
15899 
 
15900 
class getNonDeliveredOrdersbyCourier_result:
15901 
  """
15902 
  Attributes:
15903 
   - success
15904 
  """
15905 
 
15906 
  thrift_spec = (
15907 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
15908 
  )
15909 
 
15910 
  def __init__(self, success=None,):
15911 
    self.success = success
15912 
 
15913 
  def read(self, iprot):
15914 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15915 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15916 
      return
15917 
    iprot.readStructBegin()
15918 
    while True:
15919 
      (fname, ftype, fid) = iprot.readFieldBegin()
15920 
      if ftype == TType.STOP:
15921 
        break
4581 phani.kuma 15922 
      if fid == 0:
15923 
        if ftype == TType.LIST:
15924 
          self.success = []
6188 rajveer 15925 
          (_etype355, _size352) = iprot.readListBegin()
15926 
          for _i356 in xrange(_size352):
15927 
            _elem357 = Order()
15928 
            _elem357.read(iprot)
15929 
            self.success.append(_elem357)
4581 phani.kuma 15930 
          iprot.readListEnd()
15931 
        else:
15932 
          iprot.skip(ftype)
4910 phani.kuma 15933 
      else:
15934 
        iprot.skip(ftype)
15935 
      iprot.readFieldEnd()
15936 
    iprot.readStructEnd()
15937 
 
15938 
  def write(self, oprot):
15939 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15940 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15941 
      return
15942 
    oprot.writeStructBegin('getNonDeliveredOrdersbyCourier_result')
15943 
    if self.success is not None:
15944 
      oprot.writeFieldBegin('success', TType.LIST, 0)
15945 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 15946 
      for iter358 in self.success:
15947 
        iter358.write(oprot)
4910 phani.kuma 15948 
      oprot.writeListEnd()
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 markOrdersAsLocalConnected_args:
15969 
  """
15970 
  Attributes:
15971 
   - providerId
15972 
   - local_connected_orders
15973 
  """
15974 
 
15975 
  thrift_spec = (
15976 
    None, # 0
15977 
    (1, TType.I64, 'providerId', None, None, ), # 1
15978 
    (2, TType.MAP, 'local_connected_orders', (TType.STRING,None,TType.STRING,None), None, ), # 2
15979 
  )
15980 
 
15981 
  def __init__(self, providerId=None, local_connected_orders=None,):
15982 
    self.providerId = providerId
15983 
    self.local_connected_orders = local_connected_orders
15984 
 
15985 
  def read(self, iprot):
15986 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15987 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15988 
      return
15989 
    iprot.readStructBegin()
15990 
    while True:
15991 
      (fname, ftype, fid) = iprot.readFieldBegin()
15992 
      if ftype == TType.STOP:
15993 
        break
15994 
      if fid == 1:
15995 
        if ftype == TType.I64:
15996 
          self.providerId = iprot.readI64();
15997 
        else:
15998 
          iprot.skip(ftype)
15999 
      elif fid == 2:
16000 
        if ftype == TType.MAP:
16001 
          self.local_connected_orders = {}
6188 rajveer 16002 
          (_ktype360, _vtype361, _size359 ) = iprot.readMapBegin()
16003 
          for _i363 in xrange(_size359):
16004 
            _key364 = iprot.readString();
16005 
            _val365 = iprot.readString();
16006 
            self.local_connected_orders[_key364] = _val365
4910 phani.kuma 16007 
          iprot.readMapEnd()
16008 
        else:
16009 
          iprot.skip(ftype)
16010 
      else:
16011 
        iprot.skip(ftype)
16012 
      iprot.readFieldEnd()
16013 
    iprot.readStructEnd()
16014 
 
16015 
  def write(self, oprot):
16016 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16017 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16018 
      return
16019 
    oprot.writeStructBegin('markOrdersAsLocalConnected_args')
16020 
    if self.providerId is not None:
16021 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
16022 
      oprot.writeI64(self.providerId)
16023 
      oprot.writeFieldEnd()
16024 
    if self.local_connected_orders is not None:
16025 
      oprot.writeFieldBegin('local_connected_orders', TType.MAP, 2)
16026 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.local_connected_orders))
6188 rajveer 16027 
      for kiter366,viter367 in self.local_connected_orders.items():
16028 
        oprot.writeString(kiter366)
16029 
        oprot.writeString(viter367)
4910 phani.kuma 16030 
      oprot.writeMapEnd()
16031 
      oprot.writeFieldEnd()
16032 
    oprot.writeFieldStop()
16033 
    oprot.writeStructEnd()
16034 
 
16035 
  def validate(self):
16036 
    return
16037 
 
16038 
 
16039 
  def __repr__(self):
16040 
    L = ['%s=%r' % (key, value)
16041 
      for key, value in self.__dict__.iteritems()]
16042 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16043 
 
16044 
  def __eq__(self, other):
16045 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16046 
 
16047 
  def __ne__(self, other):
16048 
    return not (self == other)
16049 
 
16050 
class markOrdersAsLocalConnected_result:
16051 
  """
16052 
  Attributes:
16053 
   - ex
16054 
  """
16055 
 
16056 
  thrift_spec = (
16057 
    None, # 0
16058 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
16059 
  )
16060 
 
16061 
  def __init__(self, ex=None,):
16062 
    self.ex = ex
16063 
 
16064 
  def read(self, iprot):
16065 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16066 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16067 
      return
16068 
    iprot.readStructBegin()
16069 
    while True:
16070 
      (fname, ftype, fid) = iprot.readFieldBegin()
16071 
      if ftype == TType.STOP:
16072 
        break
16073 
      if fid == 1:
3064 chandransh 16074 
        if ftype == TType.STRUCT:
16075 
          self.ex = TransactionServiceException()
16076 
          self.ex.read(iprot)
1627 ankur.sing 16077 
        else:
16078 
          iprot.skip(ftype)
16079 
      else:
16080 
        iprot.skip(ftype)
16081 
      iprot.readFieldEnd()
16082 
    iprot.readStructEnd()
16083 
 
16084 
  def write(self, oprot):
16085 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16086 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16087 
      return
4910 phani.kuma 16088 
    oprot.writeStructBegin('markOrdersAsLocalConnected_result')
16089 
    if self.ex is not None:
16090 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
16091 
      self.ex.write(oprot)
16092 
      oprot.writeFieldEnd()
16093 
    oprot.writeFieldStop()
16094 
    oprot.writeStructEnd()
16095 
 
16096 
  def validate(self):
16097 
    return
16098 
 
16099 
 
16100 
  def __repr__(self):
16101 
    L = ['%s=%r' % (key, value)
16102 
      for key, value in self.__dict__.iteritems()]
16103 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16104 
 
16105 
  def __eq__(self, other):
16106 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16107 
 
16108 
  def __ne__(self, other):
16109 
    return not (self == other)
16110 
 
16111 
class getOrdersNotLocalConnected_args:
16112 
  """
16113 
  Attributes:
16114 
   - providerId
16115 
  """
16116 
 
16117 
  thrift_spec = (
16118 
    None, # 0
16119 
    (1, TType.I64, 'providerId', None, None, ), # 1
16120 
  )
16121 
 
16122 
  def __init__(self, providerId=None,):
16123 
    self.providerId = providerId
16124 
 
16125 
  def read(self, iprot):
16126 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16127 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16128 
      return
16129 
    iprot.readStructBegin()
16130 
    while True:
16131 
      (fname, ftype, fid) = iprot.readFieldBegin()
16132 
      if ftype == TType.STOP:
16133 
        break
16134 
      if fid == 1:
16135 
        if ftype == TType.I64:
16136 
          self.providerId = iprot.readI64();
16137 
        else:
16138 
          iprot.skip(ftype)
16139 
      else:
16140 
        iprot.skip(ftype)
16141 
      iprot.readFieldEnd()
16142 
    iprot.readStructEnd()
16143 
 
16144 
  def write(self, oprot):
16145 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16146 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16147 
      return
16148 
    oprot.writeStructBegin('getOrdersNotLocalConnected_args')
16149 
    if self.providerId is not None:
16150 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
16151 
      oprot.writeI64(self.providerId)
16152 
      oprot.writeFieldEnd()
16153 
    oprot.writeFieldStop()
16154 
    oprot.writeStructEnd()
16155 
 
16156 
  def validate(self):
16157 
    return
16158 
 
16159 
 
16160 
  def __repr__(self):
16161 
    L = ['%s=%r' % (key, value)
16162 
      for key, value in self.__dict__.iteritems()]
16163 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16164 
 
16165 
  def __eq__(self, other):
16166 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16167 
 
16168 
  def __ne__(self, other):
16169 
    return not (self == other)
16170 
 
16171 
class getOrdersNotLocalConnected_result:
16172 
  """
16173 
  Attributes:
16174 
   - success
16175 
  """
16176 
 
16177 
  thrift_spec = (
16178 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
16179 
  )
16180 
 
16181 
  def __init__(self, success=None,):
16182 
    self.success = success
16183 
 
16184 
  def read(self, iprot):
16185 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16186 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16187 
      return
16188 
    iprot.readStructBegin()
16189 
    while True:
16190 
      (fname, ftype, fid) = iprot.readFieldBegin()
16191 
      if ftype == TType.STOP:
16192 
        break
16193 
      if fid == 0:
16194 
        if ftype == TType.LIST:
16195 
          self.success = []
6188 rajveer 16196 
          (_etype371, _size368) = iprot.readListBegin()
16197 
          for _i372 in xrange(_size368):
16198 
            _elem373 = Order()
16199 
            _elem373.read(iprot)
16200 
            self.success.append(_elem373)
4910 phani.kuma 16201 
          iprot.readListEnd()
16202 
        else:
16203 
          iprot.skip(ftype)
16204 
      else:
16205 
        iprot.skip(ftype)
16206 
      iprot.readFieldEnd()
16207 
    iprot.readStructEnd()
16208 
 
16209 
  def write(self, oprot):
16210 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16211 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16212 
      return
16213 
    oprot.writeStructBegin('getOrdersNotLocalConnected_result')
4581 phani.kuma 16214 
    if self.success is not None:
16215 
      oprot.writeFieldBegin('success', TType.LIST, 0)
16216 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 16217 
      for iter374 in self.success:
16218 
        iter374.write(oprot)
4581 phani.kuma 16219 
      oprot.writeListEnd()
16220 
      oprot.writeFieldEnd()
4910 phani.kuma 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 markOrdersAsDestinationCityReached_args:
16240 
  """
16241 
  Attributes:
16242 
   - providerId
16243 
   - destination_city_reached_orders
16244 
  """
16245 
 
16246 
  thrift_spec = (
16247 
    None, # 0
16248 
    (1, TType.I64, 'providerId', None, None, ), # 1
16249 
    (2, TType.MAP, 'destination_city_reached_orders', (TType.STRING,None,TType.STRING,None), None, ), # 2
16250 
  )
16251 
 
16252 
  def __init__(self, providerId=None, destination_city_reached_orders=None,):
16253 
    self.providerId = providerId
16254 
    self.destination_city_reached_orders = destination_city_reached_orders
16255 
 
16256 
  def read(self, iprot):
16257 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16258 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16259 
      return
16260 
    iprot.readStructBegin()
16261 
    while True:
16262 
      (fname, ftype, fid) = iprot.readFieldBegin()
16263 
      if ftype == TType.STOP:
16264 
        break
16265 
      if fid == 1:
16266 
        if ftype == TType.I64:
16267 
          self.providerId = iprot.readI64();
16268 
        else:
16269 
          iprot.skip(ftype)
16270 
      elif fid == 2:
16271 
        if ftype == TType.MAP:
16272 
          self.destination_city_reached_orders = {}
6188 rajveer 16273 
          (_ktype376, _vtype377, _size375 ) = iprot.readMapBegin()
16274 
          for _i379 in xrange(_size375):
16275 
            _key380 = iprot.readString();
16276 
            _val381 = iprot.readString();
16277 
            self.destination_city_reached_orders[_key380] = _val381
4910 phani.kuma 16278 
          iprot.readMapEnd()
16279 
        else:
16280 
          iprot.skip(ftype)
16281 
      else:
16282 
        iprot.skip(ftype)
16283 
      iprot.readFieldEnd()
16284 
    iprot.readStructEnd()
16285 
 
16286 
  def write(self, oprot):
16287 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16288 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16289 
      return
16290 
    oprot.writeStructBegin('markOrdersAsDestinationCityReached_args')
16291 
    if self.providerId is not None:
16292 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
16293 
      oprot.writeI64(self.providerId)
16294 
      oprot.writeFieldEnd()
16295 
    if self.destination_city_reached_orders is not None:
16296 
      oprot.writeFieldBegin('destination_city_reached_orders', TType.MAP, 2)
16297 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.destination_city_reached_orders))
6188 rajveer 16298 
      for kiter382,viter383 in self.destination_city_reached_orders.items():
16299 
        oprot.writeString(kiter382)
16300 
        oprot.writeString(viter383)
4910 phani.kuma 16301 
      oprot.writeMapEnd()
16302 
      oprot.writeFieldEnd()
16303 
    oprot.writeFieldStop()
16304 
    oprot.writeStructEnd()
16305 
 
16306 
  def validate(self):
16307 
    return
16308 
 
16309 
 
16310 
  def __repr__(self):
16311 
    L = ['%s=%r' % (key, value)
16312 
      for key, value in self.__dict__.iteritems()]
16313 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16314 
 
16315 
  def __eq__(self, other):
16316 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16317 
 
16318 
  def __ne__(self, other):
16319 
    return not (self == other)
16320 
 
16321 
class markOrdersAsDestinationCityReached_result:
16322 
  """
16323 
  Attributes:
16324 
   - ex
16325 
  """
16326 
 
16327 
  thrift_spec = (
16328 
    None, # 0
16329 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
16330 
  )
16331 
 
16332 
  def __init__(self, ex=None,):
16333 
    self.ex = ex
16334 
 
16335 
  def read(self, iprot):
16336 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16337 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16338 
      return
16339 
    iprot.readStructBegin()
16340 
    while True:
16341 
      (fname, ftype, fid) = iprot.readFieldBegin()
16342 
      if ftype == TType.STOP:
16343 
        break
16344 
      if fid == 1:
16345 
        if ftype == TType.STRUCT:
16346 
          self.ex = TransactionServiceException()
16347 
          self.ex.read(iprot)
16348 
        else:
16349 
          iprot.skip(ftype)
16350 
      else:
16351 
        iprot.skip(ftype)
16352 
      iprot.readFieldEnd()
16353 
    iprot.readStructEnd()
16354 
 
16355 
  def write(self, oprot):
16356 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16357 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16358 
      return
16359 
    oprot.writeStructBegin('markOrdersAsDestinationCityReached_result')
3431 rajveer 16360 
    if self.ex is not None:
3064 chandransh 16361 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
16362 
      self.ex.write(oprot)
1627 ankur.sing 16363 
      oprot.writeFieldEnd()
16364 
    oprot.writeFieldStop()
16365 
    oprot.writeStructEnd()
16366 
 
3431 rajveer 16367 
  def validate(self):
16368 
    return
16369 
 
16370 
 
1627 ankur.sing 16371 
  def __repr__(self):
16372 
    L = ['%s=%r' % (key, value)
16373 
      for key, value in self.__dict__.iteritems()]
16374 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16375 
 
16376 
  def __eq__(self, other):
16377 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16378 
 
16379 
  def __ne__(self, other):
16380 
    return not (self == other)
16381 
 
4910 phani.kuma 16382 
class markOrdersAsFirstDeliveryAttempted_args:
16383 
  """
16384 
  Attributes:
16385 
   - providerId
16386 
   - first_atdl_orders
16387 
  """
16388 
 
16389 
  thrift_spec = (
16390 
    None, # 0
16391 
    (1, TType.I64, 'providerId', None, None, ), # 1
16392 
    (2, TType.MAP, 'first_atdl_orders', (TType.STRING,None,TType.STRING,None), None, ), # 2
16393 
  )
16394 
 
16395 
  def __init__(self, providerId=None, first_atdl_orders=None,):
16396 
    self.providerId = providerId
16397 
    self.first_atdl_orders = first_atdl_orders
16398 
 
16399 
  def read(self, iprot):
16400 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16401 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16402 
      return
16403 
    iprot.readStructBegin()
16404 
    while True:
16405 
      (fname, ftype, fid) = iprot.readFieldBegin()
16406 
      if ftype == TType.STOP:
16407 
        break
16408 
      if fid == 1:
16409 
        if ftype == TType.I64:
16410 
          self.providerId = iprot.readI64();
16411 
        else:
16412 
          iprot.skip(ftype)
16413 
      elif fid == 2:
16414 
        if ftype == TType.MAP:
16415 
          self.first_atdl_orders = {}
6188 rajveer 16416 
          (_ktype385, _vtype386, _size384 ) = iprot.readMapBegin()
16417 
          for _i388 in xrange(_size384):
16418 
            _key389 = iprot.readString();
16419 
            _val390 = iprot.readString();
16420 
            self.first_atdl_orders[_key389] = _val390
4910 phani.kuma 16421 
          iprot.readMapEnd()
16422 
        else:
16423 
          iprot.skip(ftype)
16424 
      else:
16425 
        iprot.skip(ftype)
16426 
      iprot.readFieldEnd()
16427 
    iprot.readStructEnd()
16428 
 
16429 
  def write(self, oprot):
16430 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16431 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16432 
      return
16433 
    oprot.writeStructBegin('markOrdersAsFirstDeliveryAttempted_args')
16434 
    if self.providerId is not None:
16435 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
16436 
      oprot.writeI64(self.providerId)
16437 
      oprot.writeFieldEnd()
16438 
    if self.first_atdl_orders is not None:
16439 
      oprot.writeFieldBegin('first_atdl_orders', TType.MAP, 2)
16440 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.first_atdl_orders))
6188 rajveer 16441 
      for kiter391,viter392 in self.first_atdl_orders.items():
16442 
        oprot.writeString(kiter391)
16443 
        oprot.writeString(viter392)
4910 phani.kuma 16444 
      oprot.writeMapEnd()
16445 
      oprot.writeFieldEnd()
16446 
    oprot.writeFieldStop()
16447 
    oprot.writeStructEnd()
16448 
 
16449 
  def validate(self):
16450 
    return
16451 
 
16452 
 
16453 
  def __repr__(self):
16454 
    L = ['%s=%r' % (key, value)
16455 
      for key, value in self.__dict__.iteritems()]
16456 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16457 
 
16458 
  def __eq__(self, other):
16459 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16460 
 
16461 
  def __ne__(self, other):
16462 
    return not (self == other)
16463 
 
16464 
class markOrdersAsFirstDeliveryAttempted_result:
16465 
  """
16466 
  Attributes:
16467 
   - ex
16468 
  """
16469 
 
16470 
  thrift_spec = (
16471 
    None, # 0
16472 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
16473 
  )
16474 
 
16475 
  def __init__(self, ex=None,):
16476 
    self.ex = ex
16477 
 
16478 
  def read(self, iprot):
16479 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16480 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16481 
      return
16482 
    iprot.readStructBegin()
16483 
    while True:
16484 
      (fname, ftype, fid) = iprot.readFieldBegin()
16485 
      if ftype == TType.STOP:
16486 
        break
16487 
      if fid == 1:
16488 
        if ftype == TType.STRUCT:
16489 
          self.ex = TransactionServiceException()
16490 
          self.ex.read(iprot)
16491 
        else:
16492 
          iprot.skip(ftype)
16493 
      else:
16494 
        iprot.skip(ftype)
16495 
      iprot.readFieldEnd()
16496 
    iprot.readStructEnd()
16497 
 
16498 
  def write(self, oprot):
16499 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16500 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16501 
      return
16502 
    oprot.writeStructBegin('markOrdersAsFirstDeliveryAttempted_result')
16503 
    if self.ex is not None:
16504 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
16505 
      self.ex.write(oprot)
16506 
      oprot.writeFieldEnd()
16507 
    oprot.writeFieldStop()
16508 
    oprot.writeStructEnd()
16509 
 
16510 
  def validate(self):
16511 
    return
16512 
 
16513 
 
16514 
  def __repr__(self):
16515 
    L = ['%s=%r' % (key, value)
16516 
      for key, value in self.__dict__.iteritems()]
16517 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16518 
 
16519 
  def __eq__(self, other):
16520 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16521 
 
16522 
  def __ne__(self, other):
16523 
    return not (self == other)
16524 
 
3064 chandransh 16525 
class getUndeliveredOrders_args:
1886 ankur.sing 16526 
  """
16527 
  Attributes:
3064 chandransh 16528 
   - providerId
16529 
   - warehouseId
1886 ankur.sing 16530 
  """
1627 ankur.sing 16531 
 
1886 ankur.sing 16532 
  thrift_spec = (
16533 
    None, # 0
3064 chandransh 16534 
    (1, TType.I64, 'providerId', None, None, ), # 1
16535 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
1886 ankur.sing 16536 
  )
16537 
 
3064 chandransh 16538 
  def __init__(self, providerId=None, warehouseId=None,):
16539 
    self.providerId = providerId
16540 
    self.warehouseId = warehouseId
1886 ankur.sing 16541 
 
16542 
  def read(self, iprot):
16543 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16544 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16545 
      return
16546 
    iprot.readStructBegin()
16547 
    while True:
16548 
      (fname, ftype, fid) = iprot.readFieldBegin()
16549 
      if ftype == TType.STOP:
16550 
        break
16551 
      if fid == 1:
16552 
        if ftype == TType.I64:
3064 chandransh 16553 
          self.providerId = iprot.readI64();
1886 ankur.sing 16554 
        else:
16555 
          iprot.skip(ftype)
3064 chandransh 16556 
      elif fid == 2:
16557 
        if ftype == TType.I64:
16558 
          self.warehouseId = iprot.readI64();
16559 
        else:
16560 
          iprot.skip(ftype)
1886 ankur.sing 16561 
      else:
16562 
        iprot.skip(ftype)
16563 
      iprot.readFieldEnd()
16564 
    iprot.readStructEnd()
16565 
 
16566 
  def write(self, oprot):
16567 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16568 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16569 
      return
3064 chandransh 16570 
    oprot.writeStructBegin('getUndeliveredOrders_args')
3431 rajveer 16571 
    if self.providerId is not None:
3064 chandransh 16572 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
16573 
      oprot.writeI64(self.providerId)
1886 ankur.sing 16574 
      oprot.writeFieldEnd()
3431 rajveer 16575 
    if self.warehouseId is not None:
3064 chandransh 16576 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
16577 
      oprot.writeI64(self.warehouseId)
16578 
      oprot.writeFieldEnd()
1886 ankur.sing 16579 
    oprot.writeFieldStop()
16580 
    oprot.writeStructEnd()
16581 
 
3431 rajveer 16582 
  def validate(self):
16583 
    return
16584 
 
16585 
 
1886 ankur.sing 16586 
  def __repr__(self):
16587 
    L = ['%s=%r' % (key, value)
16588 
      for key, value in self.__dict__.iteritems()]
16589 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16590 
 
16591 
  def __eq__(self, other):
16592 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16593 
 
16594 
  def __ne__(self, other):
16595 
    return not (self == other)
16596 
 
3064 chandransh 16597 
class getUndeliveredOrders_result:
1886 ankur.sing 16598 
  """
16599 
  Attributes:
16600 
   - success
16601 
  """
16602 
 
16603 
  thrift_spec = (
16604 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
16605 
  )
16606 
 
16607 
  def __init__(self, success=None,):
16608 
    self.success = success
16609 
 
16610 
  def read(self, iprot):
16611 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16612 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16613 
      return
16614 
    iprot.readStructBegin()
16615 
    while True:
16616 
      (fname, ftype, fid) = iprot.readFieldBegin()
16617 
      if ftype == TType.STOP:
16618 
        break
16619 
      if fid == 0:
16620 
        if ftype == TType.LIST:
16621 
          self.success = []
6188 rajveer 16622 
          (_etype396, _size393) = iprot.readListBegin()
16623 
          for _i397 in xrange(_size393):
16624 
            _elem398 = Order()
16625 
            _elem398.read(iprot)
16626 
            self.success.append(_elem398)
1886 ankur.sing 16627 
          iprot.readListEnd()
16628 
        else:
16629 
          iprot.skip(ftype)
16630 
      else:
16631 
        iprot.skip(ftype)
16632 
      iprot.readFieldEnd()
16633 
    iprot.readStructEnd()
16634 
 
16635 
  def write(self, oprot):
16636 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16637 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16638 
      return
3064 chandransh 16639 
    oprot.writeStructBegin('getUndeliveredOrders_result')
3431 rajveer 16640 
    if self.success is not None:
1886 ankur.sing 16641 
      oprot.writeFieldBegin('success', TType.LIST, 0)
16642 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 16643 
      for iter399 in self.success:
16644 
        iter399.write(oprot)
1886 ankur.sing 16645 
      oprot.writeListEnd()
16646 
      oprot.writeFieldEnd()
16647 
    oprot.writeFieldStop()
16648 
    oprot.writeStructEnd()
16649 
 
3431 rajveer 16650 
  def validate(self):
16651 
    return
16652 
 
16653 
 
1886 ankur.sing 16654 
  def __repr__(self):
16655 
    L = ['%s=%r' % (key, value)
16656 
      for key, value in self.__dict__.iteritems()]
16657 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16658 
 
16659 
  def __eq__(self, other):
16660 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16661 
 
16662 
  def __ne__(self, other):
16663 
    return not (self == other)
16664 
 
4783 phani.kuma 16665 
class getUndeliveredOrdersExpectedDeliveryDateNotMet_args:
16666 
 
16667 
  thrift_spec = (
16668 
  )
16669 
 
16670 
  def read(self, iprot):
16671 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16672 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16673 
      return
16674 
    iprot.readStructBegin()
16675 
    while True:
16676 
      (fname, ftype, fid) = iprot.readFieldBegin()
16677 
      if ftype == TType.STOP:
16678 
        break
16679 
      else:
16680 
        iprot.skip(ftype)
16681 
      iprot.readFieldEnd()
16682 
    iprot.readStructEnd()
16683 
 
16684 
  def write(self, oprot):
16685 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16686 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16687 
      return
16688 
    oprot.writeStructBegin('getUndeliveredOrdersExpectedDeliveryDateNotMet_args')
16689 
    oprot.writeFieldStop()
16690 
    oprot.writeStructEnd()
16691 
 
16692 
  def validate(self):
16693 
    return
16694 
 
16695 
 
16696 
  def __repr__(self):
16697 
    L = ['%s=%r' % (key, value)
16698 
      for key, value in self.__dict__.iteritems()]
16699 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16700 
 
16701 
  def __eq__(self, other):
16702 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16703 
 
16704 
  def __ne__(self, other):
16705 
    return not (self == other)
16706 
 
16707 
class getUndeliveredOrdersExpectedDeliveryDateNotMet_result:
16708 
  """
16709 
  Attributes:
16710 
   - success
16711 
  """
16712 
 
16713 
  thrift_spec = (
16714 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
16715 
  )
16716 
 
16717 
  def __init__(self, success=None,):
16718 
    self.success = success
16719 
 
16720 
  def read(self, iprot):
16721 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16722 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16723 
      return
16724 
    iprot.readStructBegin()
16725 
    while True:
16726 
      (fname, ftype, fid) = iprot.readFieldBegin()
16727 
      if ftype == TType.STOP:
16728 
        break
16729 
      if fid == 0:
16730 
        if ftype == TType.LIST:
16731 
          self.success = []
6188 rajveer 16732 
          (_etype403, _size400) = iprot.readListBegin()
16733 
          for _i404 in xrange(_size400):
16734 
            _elem405 = Order()
16735 
            _elem405.read(iprot)
16736 
            self.success.append(_elem405)
4783 phani.kuma 16737 
          iprot.readListEnd()
16738 
        else:
16739 
          iprot.skip(ftype)
16740 
      else:
16741 
        iprot.skip(ftype)
16742 
      iprot.readFieldEnd()
16743 
    iprot.readStructEnd()
16744 
 
16745 
  def write(self, oprot):
16746 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16747 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16748 
      return
16749 
    oprot.writeStructBegin('getUndeliveredOrdersExpectedDeliveryDateNotMet_result')
16750 
    if self.success is not None:
16751 
      oprot.writeFieldBegin('success', TType.LIST, 0)
16752 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 16753 
      for iter406 in self.success:
16754 
        iter406.write(oprot)
4783 phani.kuma 16755 
      oprot.writeListEnd()
16756 
      oprot.writeFieldEnd()
16757 
    oprot.writeFieldStop()
16758 
    oprot.writeStructEnd()
16759 
 
16760 
  def validate(self):
16761 
    return
16762 
 
16763 
 
16764 
  def __repr__(self):
16765 
    L = ['%s=%r' % (key, value)
16766 
      for key, value in self.__dict__.iteritems()]
16767 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16768 
 
16769 
  def __eq__(self, other):
16770 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16771 
 
16772 
  def __ne__(self, other):
16773 
    return not (self == other)
16774 
 
2536 chandransh 16775 
class toggleDOAFlag_args:
16776 
  """
16777 
  Attributes:
16778 
   - orderId
16779 
  """
1886 ankur.sing 16780 
 
2536 chandransh 16781 
  thrift_spec = (
16782 
    None, # 0
16783 
    (1, TType.I64, 'orderId', None, None, ), # 1
16784 
  )
16785 
 
16786 
  def __init__(self, orderId=None,):
16787 
    self.orderId = orderId
16788 
 
16789 
  def read(self, iprot):
16790 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16791 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16792 
      return
16793 
    iprot.readStructBegin()
16794 
    while True:
16795 
      (fname, ftype, fid) = iprot.readFieldBegin()
16796 
      if ftype == TType.STOP:
16797 
        break
16798 
      if fid == 1:
16799 
        if ftype == TType.I64:
16800 
          self.orderId = iprot.readI64();
16801 
        else:
16802 
          iprot.skip(ftype)
16803 
      else:
16804 
        iprot.skip(ftype)
16805 
      iprot.readFieldEnd()
16806 
    iprot.readStructEnd()
16807 
 
16808 
  def write(self, oprot):
16809 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16810 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16811 
      return
16812 
    oprot.writeStructBegin('toggleDOAFlag_args')
3431 rajveer 16813 
    if self.orderId is not None:
2536 chandransh 16814 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
16815 
      oprot.writeI64(self.orderId)
16816 
      oprot.writeFieldEnd()
16817 
    oprot.writeFieldStop()
16818 
    oprot.writeStructEnd()
16819 
 
3431 rajveer 16820 
  def validate(self):
16821 
    return
16822 
 
16823 
 
2536 chandransh 16824 
  def __repr__(self):
16825 
    L = ['%s=%r' % (key, value)
16826 
      for key, value in self.__dict__.iteritems()]
16827 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16828 
 
16829 
  def __eq__(self, other):
16830 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16831 
 
16832 
  def __ne__(self, other):
16833 
    return not (self == other)
16834 
 
16835 
class toggleDOAFlag_result:
16836 
  """
16837 
  Attributes:
16838 
   - success
16839 
   - ex
16840 
  """
16841 
 
16842 
  thrift_spec = (
16843 
    (0, TType.BOOL, 'success', None, None, ), # 0
16844 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
16845 
  )
16846 
 
16847 
  def __init__(self, success=None, ex=None,):
16848 
    self.success = success
16849 
    self.ex = ex
16850 
 
16851 
  def read(self, iprot):
16852 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16853 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16854 
      return
16855 
    iprot.readStructBegin()
16856 
    while True:
16857 
      (fname, ftype, fid) = iprot.readFieldBegin()
16858 
      if ftype == TType.STOP:
16859 
        break
16860 
      if fid == 0:
16861 
        if ftype == TType.BOOL:
16862 
          self.success = iprot.readBool();
16863 
        else:
16864 
          iprot.skip(ftype)
16865 
      elif fid == 1:
16866 
        if ftype == TType.STRUCT:
16867 
          self.ex = TransactionServiceException()
16868 
          self.ex.read(iprot)
16869 
        else:
16870 
          iprot.skip(ftype)
16871 
      else:
16872 
        iprot.skip(ftype)
16873 
      iprot.readFieldEnd()
16874 
    iprot.readStructEnd()
16875 
 
16876 
  def write(self, oprot):
16877 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16878 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16879 
      return
16880 
    oprot.writeStructBegin('toggleDOAFlag_result')
3431 rajveer 16881 
    if self.success is not None:
2536 chandransh 16882 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
16883 
      oprot.writeBool(self.success)
16884 
      oprot.writeFieldEnd()
3431 rajveer 16885 
    if self.ex is not None:
2536 chandransh 16886 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
16887 
      self.ex.write(oprot)
16888 
      oprot.writeFieldEnd()
16889 
    oprot.writeFieldStop()
16890 
    oprot.writeStructEnd()
16891 
 
3431 rajveer 16892 
  def validate(self):
16893 
    return
16894 
 
16895 
 
2536 chandransh 16896 
  def __repr__(self):
16897 
    L = ['%s=%r' % (key, value)
16898 
      for key, value in self.__dict__.iteritems()]
16899 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16900 
 
16901 
  def __eq__(self, other):
16902 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16903 
 
16904 
  def __ne__(self, other):
16905 
    return not (self == other)
16906 
 
4712 rajveer 16907 
class markOrderAsDelivered_args:
16908 
  """
16909 
  Attributes:
16910 
   - orderId
16911 
   - deliveryTimestamp
16912 
   - receiver
16913 
  """
16914 
 
16915 
  thrift_spec = None
16916 
  def __init__(self, orderId=None, deliveryTimestamp=None, receiver=None,):
16917 
    self.orderId = orderId
16918 
    self.deliveryTimestamp = deliveryTimestamp
16919 
    self.receiver = receiver
16920 
 
16921 
  def read(self, iprot):
16922 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16923 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16924 
      return
16925 
    iprot.readStructBegin()
16926 
    while True:
16927 
      (fname, ftype, fid) = iprot.readFieldBegin()
16928 
      if ftype == TType.STOP:
16929 
        break
16930 
      if fid == 1:
16931 
        if ftype == TType.I64:
16932 
          self.orderId = iprot.readI64();
16933 
        else:
16934 
          iprot.skip(ftype)
16935 
      elif fid == 2:
16936 
        if ftype == TType.I64:
16937 
          self.deliveryTimestamp = iprot.readI64();
16938 
        else:
16939 
          iprot.skip(ftype)
16940 
      elif fid == -1:
16941 
        if ftype == TType.STRING:
16942 
          self.receiver = iprot.readString();
16943 
        else:
16944 
          iprot.skip(ftype)
16945 
      else:
16946 
        iprot.skip(ftype)
16947 
      iprot.readFieldEnd()
16948 
    iprot.readStructEnd()
16949 
 
16950 
  def write(self, oprot):
16951 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16952 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16953 
      return
16954 
    oprot.writeStructBegin('markOrderAsDelivered_args')
16955 
    if self.receiver is not None:
16956 
      oprot.writeFieldBegin('receiver', TType.STRING, -1)
16957 
      oprot.writeString(self.receiver)
16958 
      oprot.writeFieldEnd()
16959 
    if self.orderId is not None:
16960 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
16961 
      oprot.writeI64(self.orderId)
16962 
      oprot.writeFieldEnd()
16963 
    if self.deliveryTimestamp is not None:
16964 
      oprot.writeFieldBegin('deliveryTimestamp', TType.I64, 2)
16965 
      oprot.writeI64(self.deliveryTimestamp)
16966 
      oprot.writeFieldEnd()
16967 
    oprot.writeFieldStop()
16968 
    oprot.writeStructEnd()
16969 
 
16970 
  def validate(self):
16971 
    return
16972 
 
16973 
 
16974 
  def __repr__(self):
16975 
    L = ['%s=%r' % (key, value)
16976 
      for key, value in self.__dict__.iteritems()]
16977 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16978 
 
16979 
  def __eq__(self, other):
16980 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16981 
 
16982 
  def __ne__(self, other):
16983 
    return not (self == other)
16984 
 
16985 
class markOrderAsDelivered_result:
16986 
  """
16987 
  Attributes:
16988 
   - ex
16989 
  """
16990 
 
16991 
  thrift_spec = (
16992 
    None, # 0
16993 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
16994 
  )
16995 
 
16996 
  def __init__(self, ex=None,):
16997 
    self.ex = ex
16998 
 
16999 
  def read(self, iprot):
17000 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17001 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17002 
      return
17003 
    iprot.readStructBegin()
17004 
    while True:
17005 
      (fname, ftype, fid) = iprot.readFieldBegin()
17006 
      if ftype == TType.STOP:
17007 
        break
17008 
      if fid == 1:
17009 
        if ftype == TType.STRUCT:
17010 
          self.ex = TransactionServiceException()
17011 
          self.ex.read(iprot)
17012 
        else:
17013 
          iprot.skip(ftype)
17014 
      else:
17015 
        iprot.skip(ftype)
17016 
      iprot.readFieldEnd()
17017 
    iprot.readStructEnd()
17018 
 
17019 
  def write(self, oprot):
17020 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17021 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17022 
      return
17023 
    oprot.writeStructBegin('markOrderAsDelivered_result')
17024 
    if self.ex is not None:
17025 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
17026 
      self.ex.write(oprot)
17027 
      oprot.writeFieldEnd()
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 
 
5553 rajveer 17046 
class markOrderAsReceivedAtStore_args:
17047 
  """
17048 
  Attributes:
17049 
   - orderId
17050 
   - deliveryTimestamp
17051 
  """
17052 
 
17053 
  thrift_spec = (
17054 
    None, # 0
17055 
    (1, TType.I64, 'orderId', None, None, ), # 1
17056 
    (2, TType.I64, 'deliveryTimestamp', None, None, ), # 2
17057 
  )
17058 
 
17059 
  def __init__(self, orderId=None, deliveryTimestamp=None,):
17060 
    self.orderId = orderId
17061 
    self.deliveryTimestamp = deliveryTimestamp
17062 
 
17063 
  def read(self, iprot):
17064 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17065 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17066 
      return
17067 
    iprot.readStructBegin()
17068 
    while True:
17069 
      (fname, ftype, fid) = iprot.readFieldBegin()
17070 
      if ftype == TType.STOP:
17071 
        break
17072 
      if fid == 1:
17073 
        if ftype == TType.I64:
17074 
          self.orderId = iprot.readI64();
17075 
        else:
17076 
          iprot.skip(ftype)
17077 
      elif fid == 2:
17078 
        if ftype == TType.I64:
17079 
          self.deliveryTimestamp = iprot.readI64();
17080 
        else:
17081 
          iprot.skip(ftype)
17082 
      else:
17083 
        iprot.skip(ftype)
17084 
      iprot.readFieldEnd()
17085 
    iprot.readStructEnd()
17086 
 
17087 
  def write(self, oprot):
17088 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17089 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17090 
      return
17091 
    oprot.writeStructBegin('markOrderAsReceivedAtStore_args')
17092 
    if self.orderId is not None:
17093 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
17094 
      oprot.writeI64(self.orderId)
17095 
      oprot.writeFieldEnd()
17096 
    if self.deliveryTimestamp is not None:
17097 
      oprot.writeFieldBegin('deliveryTimestamp', TType.I64, 2)
17098 
      oprot.writeI64(self.deliveryTimestamp)
17099 
      oprot.writeFieldEnd()
17100 
    oprot.writeFieldStop()
17101 
    oprot.writeStructEnd()
17102 
 
17103 
  def validate(self):
17104 
    return
17105 
 
17106 
 
17107 
  def __repr__(self):
17108 
    L = ['%s=%r' % (key, value)
17109 
      for key, value in self.__dict__.iteritems()]
17110 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17111 
 
17112 
  def __eq__(self, other):
17113 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17114 
 
17115 
  def __ne__(self, other):
17116 
    return not (self == other)
17117 
 
17118 
class markOrderAsReceivedAtStore_result:
17119 
  """
17120 
  Attributes:
17121 
   - ex
17122 
  """
17123 
 
17124 
  thrift_spec = (
17125 
    None, # 0
17126 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
17127 
  )
17128 
 
17129 
  def __init__(self, ex=None,):
17130 
    self.ex = ex
17131 
 
17132 
  def read(self, iprot):
17133 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17134 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17135 
      return
17136 
    iprot.readStructBegin()
17137 
    while True:
17138 
      (fname, ftype, fid) = iprot.readFieldBegin()
17139 
      if ftype == TType.STOP:
17140 
        break
17141 
      if fid == 1:
17142 
        if ftype == TType.STRUCT:
17143 
          self.ex = TransactionServiceException()
17144 
          self.ex.read(iprot)
17145 
        else:
17146 
          iprot.skip(ftype)
17147 
      else:
17148 
        iprot.skip(ftype)
17149 
      iprot.readFieldEnd()
17150 
    iprot.readStructEnd()
17151 
 
17152 
  def write(self, oprot):
17153 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17154 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17155 
      return
17156 
    oprot.writeStructBegin('markOrderAsReceivedAtStore_result')
17157 
    if self.ex is not None:
17158 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
17159 
      self.ex.write(oprot)
17160 
      oprot.writeFieldEnd()
17161 
    oprot.writeFieldStop()
17162 
    oprot.writeStructEnd()
17163 
 
17164 
  def validate(self):
17165 
    return
17166 
 
17167 
 
17168 
  def __repr__(self):
17169 
    L = ['%s=%r' % (key, value)
17170 
      for key, value in self.__dict__.iteritems()]
17171 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17172 
 
17173 
  def __eq__(self, other):
17174 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17175 
 
17176 
  def __ne__(self, other):
17177 
    return not (self == other)
17178 
 
4454 rajveer 17179 
class markOrderDoaRequestReceived_args:
17180 
  """
17181 
  Attributes:
17182 
   - orderId
17183 
  """
17184 
 
17185 
  thrift_spec = (
17186 
    None, # 0
17187 
    (1, TType.I64, 'orderId', None, None, ), # 1
17188 
  )
17189 
 
17190 
  def __init__(self, orderId=None,):
17191 
    self.orderId = orderId
17192 
 
17193 
  def read(self, iprot):
17194 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17195 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17196 
      return
17197 
    iprot.readStructBegin()
17198 
    while True:
17199 
      (fname, ftype, fid) = iprot.readFieldBegin()
17200 
      if ftype == TType.STOP:
17201 
        break
17202 
      if fid == 1:
17203 
        if ftype == TType.I64:
17204 
          self.orderId = iprot.readI64();
17205 
        else:
17206 
          iprot.skip(ftype)
17207 
      else:
17208 
        iprot.skip(ftype)
17209 
      iprot.readFieldEnd()
17210 
    iprot.readStructEnd()
17211 
 
17212 
  def write(self, oprot):
17213 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17214 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17215 
      return
17216 
    oprot.writeStructBegin('markOrderDoaRequestReceived_args')
17217 
    if self.orderId is not None:
17218 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
17219 
      oprot.writeI64(self.orderId)
17220 
      oprot.writeFieldEnd()
17221 
    oprot.writeFieldStop()
17222 
    oprot.writeStructEnd()
17223 
 
17224 
  def validate(self):
17225 
    return
17226 
 
17227 
 
17228 
  def __repr__(self):
17229 
    L = ['%s=%r' % (key, value)
17230 
      for key, value in self.__dict__.iteritems()]
17231 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17232 
 
17233 
  def __eq__(self, other):
17234 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17235 
 
17236 
  def __ne__(self, other):
17237 
    return not (self == other)
17238 
 
17239 
class markOrderDoaRequestReceived_result:
17240 
  """
17241 
  Attributes:
17242 
   - success
17243 
   - ex
17244 
  """
17245 
 
17246 
  thrift_spec = (
17247 
    (0, TType.BOOL, 'success', None, None, ), # 0
17248 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
17249 
  )
17250 
 
17251 
  def __init__(self, success=None, ex=None,):
17252 
    self.success = success
17253 
    self.ex = ex
17254 
 
17255 
  def read(self, iprot):
17256 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17257 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17258 
      return
17259 
    iprot.readStructBegin()
17260 
    while True:
17261 
      (fname, ftype, fid) = iprot.readFieldBegin()
17262 
      if ftype == TType.STOP:
17263 
        break
17264 
      if fid == 0:
17265 
        if ftype == TType.BOOL:
17266 
          self.success = iprot.readBool();
17267 
        else:
17268 
          iprot.skip(ftype)
17269 
      elif fid == 1:
17270 
        if ftype == TType.STRUCT:
17271 
          self.ex = TransactionServiceException()
17272 
          self.ex.read(iprot)
17273 
        else:
17274 
          iprot.skip(ftype)
17275 
      else:
17276 
        iprot.skip(ftype)
17277 
      iprot.readFieldEnd()
17278 
    iprot.readStructEnd()
17279 
 
17280 
  def write(self, oprot):
17281 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17282 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17283 
      return
17284 
    oprot.writeStructBegin('markOrderDoaRequestReceived_result')
17285 
    if self.success is not None:
17286 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
17287 
      oprot.writeBool(self.success)
17288 
      oprot.writeFieldEnd()
17289 
    if self.ex is not None:
17290 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
17291 
      self.ex.write(oprot)
17292 
      oprot.writeFieldEnd()
17293 
    oprot.writeFieldStop()
17294 
    oprot.writeStructEnd()
17295 
 
17296 
  def validate(self):
17297 
    return
17298 
 
17299 
 
17300 
  def __repr__(self):
17301 
    L = ['%s=%r' % (key, value)
17302 
      for key, value in self.__dict__.iteritems()]
17303 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17304 
 
17305 
  def __eq__(self, other):
17306 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17307 
 
17308 
  def __ne__(self, other):
17309 
    return not (self == other)
17310 
 
17311 
class markOrderDoaRequestAuthorized_args:
17312 
  """
17313 
  Attributes:
17314 
   - orderId
17315 
   - isAuthorized
17316 
  """
17317 
 
17318 
  thrift_spec = (
17319 
    None, # 0
17320 
    (1, TType.I64, 'orderId', None, None, ), # 1
17321 
    (2, TType.BOOL, 'isAuthorized', None, None, ), # 2
17322 
  )
17323 
 
17324 
  def __init__(self, orderId=None, isAuthorized=None,):
17325 
    self.orderId = orderId
17326 
    self.isAuthorized = isAuthorized
17327 
 
17328 
  def read(self, iprot):
17329 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17330 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17331 
      return
17332 
    iprot.readStructBegin()
17333 
    while True:
17334 
      (fname, ftype, fid) = iprot.readFieldBegin()
17335 
      if ftype == TType.STOP:
17336 
        break
17337 
      if fid == 1:
17338 
        if ftype == TType.I64:
17339 
          self.orderId = iprot.readI64();
17340 
        else:
17341 
          iprot.skip(ftype)
17342 
      elif fid == 2:
17343 
        if ftype == TType.BOOL:
17344 
          self.isAuthorized = iprot.readBool();
17345 
        else:
17346 
          iprot.skip(ftype)
17347 
      else:
17348 
        iprot.skip(ftype)
17349 
      iprot.readFieldEnd()
17350 
    iprot.readStructEnd()
17351 
 
17352 
  def write(self, oprot):
17353 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17354 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17355 
      return
17356 
    oprot.writeStructBegin('markOrderDoaRequestAuthorized_args')
17357 
    if self.orderId is not None:
17358 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
17359 
      oprot.writeI64(self.orderId)
17360 
      oprot.writeFieldEnd()
17361 
    if self.isAuthorized is not None:
17362 
      oprot.writeFieldBegin('isAuthorized', TType.BOOL, 2)
17363 
      oprot.writeBool(self.isAuthorized)
17364 
      oprot.writeFieldEnd()
17365 
    oprot.writeFieldStop()
17366 
    oprot.writeStructEnd()
17367 
 
17368 
  def validate(self):
17369 
    return
17370 
 
17371 
 
17372 
  def __repr__(self):
17373 
    L = ['%s=%r' % (key, value)
17374 
      for key, value in self.__dict__.iteritems()]
17375 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17376 
 
17377 
  def __eq__(self, other):
17378 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17379 
 
17380 
  def __ne__(self, other):
17381 
    return not (self == other)
17382 
 
17383 
class markOrderDoaRequestAuthorized_result:
17384 
  """
17385 
  Attributes:
17386 
   - success
17387 
   - ex
17388 
  """
17389 
 
17390 
  thrift_spec = (
17391 
    (0, TType.BOOL, 'success', None, None, ), # 0
17392 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
17393 
  )
17394 
 
17395 
  def __init__(self, success=None, ex=None,):
17396 
    self.success = success
17397 
    self.ex = ex
17398 
 
17399 
  def read(self, iprot):
17400 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17401 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17402 
      return
17403 
    iprot.readStructBegin()
17404 
    while True:
17405 
      (fname, ftype, fid) = iprot.readFieldBegin()
17406 
      if ftype == TType.STOP:
17407 
        break
17408 
      if fid == 0:
17409 
        if ftype == TType.BOOL:
17410 
          self.success = iprot.readBool();
17411 
        else:
17412 
          iprot.skip(ftype)
17413 
      elif fid == 1:
17414 
        if ftype == TType.STRUCT:
17415 
          self.ex = TransactionServiceException()
17416 
          self.ex.read(iprot)
17417 
        else:
17418 
          iprot.skip(ftype)
17419 
      else:
17420 
        iprot.skip(ftype)
17421 
      iprot.readFieldEnd()
17422 
    iprot.readStructEnd()
17423 
 
17424 
  def write(self, oprot):
17425 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17426 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17427 
      return
17428 
    oprot.writeStructBegin('markOrderDoaRequestAuthorized_result')
17429 
    if self.success is not None:
17430 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
17431 
      oprot.writeBool(self.success)
17432 
      oprot.writeFieldEnd()
17433 
    if self.ex is not None:
17434 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
17435 
      self.ex.write(oprot)
17436 
      oprot.writeFieldEnd()
17437 
    oprot.writeFieldStop()
17438 
    oprot.writeStructEnd()
17439 
 
17440 
  def validate(self):
17441 
    return
17442 
 
17443 
 
17444 
  def __repr__(self):
17445 
    L = ['%s=%r' % (key, value)
17446 
      for key, value in self.__dict__.iteritems()]
17447 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17448 
 
17449 
  def __eq__(self, other):
17450 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17451 
 
17452 
  def __ne__(self, other):
17453 
    return not (self == other)
17454 
 
4488 rajveer 17455 
class markOrderReturnRequestReceived_args:
17456 
  """
17457 
  Attributes:
17458 
   - orderId
17459 
  """
17460 
 
17461 
  thrift_spec = (
17462 
    None, # 0
17463 
    (1, TType.I64, 'orderId', None, None, ), # 1
17464 
  )
17465 
 
17466 
  def __init__(self, orderId=None,):
17467 
    self.orderId = orderId
17468 
 
17469 
  def read(self, iprot):
17470 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17471 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17472 
      return
17473 
    iprot.readStructBegin()
17474 
    while True:
17475 
      (fname, ftype, fid) = iprot.readFieldBegin()
17476 
      if ftype == TType.STOP:
17477 
        break
17478 
      if fid == 1:
17479 
        if ftype == TType.I64:
17480 
          self.orderId = iprot.readI64();
17481 
        else:
17482 
          iprot.skip(ftype)
17483 
      else:
17484 
        iprot.skip(ftype)
17485 
      iprot.readFieldEnd()
17486 
    iprot.readStructEnd()
17487 
 
17488 
  def write(self, oprot):
17489 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17490 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17491 
      return
17492 
    oprot.writeStructBegin('markOrderReturnRequestReceived_args')
17493 
    if self.orderId is not None:
17494 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
17495 
      oprot.writeI64(self.orderId)
17496 
      oprot.writeFieldEnd()
17497 
    oprot.writeFieldStop()
17498 
    oprot.writeStructEnd()
17499 
 
17500 
  def validate(self):
17501 
    return
17502 
 
17503 
 
17504 
  def __repr__(self):
17505 
    L = ['%s=%r' % (key, value)
17506 
      for key, value in self.__dict__.iteritems()]
17507 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17508 
 
17509 
  def __eq__(self, other):
17510 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17511 
 
17512 
  def __ne__(self, other):
17513 
    return not (self == other)
17514 
 
17515 
class markOrderReturnRequestReceived_result:
17516 
  """
17517 
  Attributes:
17518 
   - success
17519 
   - ex
17520 
  """
17521 
 
17522 
  thrift_spec = (
17523 
    (0, TType.BOOL, 'success', None, None, ), # 0
17524 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
17525 
  )
17526 
 
17527 
  def __init__(self, success=None, ex=None,):
17528 
    self.success = success
17529 
    self.ex = ex
17530 
 
17531 
  def read(self, iprot):
17532 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17533 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17534 
      return
17535 
    iprot.readStructBegin()
17536 
    while True:
17537 
      (fname, ftype, fid) = iprot.readFieldBegin()
17538 
      if ftype == TType.STOP:
17539 
        break
17540 
      if fid == 0:
17541 
        if ftype == TType.BOOL:
17542 
          self.success = iprot.readBool();
17543 
        else:
17544 
          iprot.skip(ftype)
17545 
      elif fid == 1:
17546 
        if ftype == TType.STRUCT:
17547 
          self.ex = TransactionServiceException()
17548 
          self.ex.read(iprot)
17549 
        else:
17550 
          iprot.skip(ftype)
17551 
      else:
17552 
        iprot.skip(ftype)
17553 
      iprot.readFieldEnd()
17554 
    iprot.readStructEnd()
17555 
 
17556 
  def write(self, oprot):
17557 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17558 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17559 
      return
17560 
    oprot.writeStructBegin('markOrderReturnRequestReceived_result')
17561 
    if self.success is not None:
17562 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
17563 
      oprot.writeBool(self.success)
17564 
      oprot.writeFieldEnd()
17565 
    if self.ex is not None:
17566 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
17567 
      self.ex.write(oprot)
17568 
      oprot.writeFieldEnd()
17569 
    oprot.writeFieldStop()
17570 
    oprot.writeStructEnd()
17571 
 
17572 
  def validate(self):
17573 
    return
17574 
 
17575 
 
17576 
  def __repr__(self):
17577 
    L = ['%s=%r' % (key, value)
17578 
      for key, value in self.__dict__.iteritems()]
17579 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17580 
 
17581 
  def __eq__(self, other):
17582 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17583 
 
17584 
  def __ne__(self, other):
17585 
    return not (self == other)
17586 
 
17587 
class markOrderReturnRequestAuthorized_args:
17588 
  """
17589 
  Attributes:
17590 
   - orderId
17591 
   - isAuthorized
17592 
  """
17593 
 
17594 
  thrift_spec = (
17595 
    None, # 0
17596 
    (1, TType.I64, 'orderId', None, None, ), # 1
17597 
    (2, TType.BOOL, 'isAuthorized', None, None, ), # 2
17598 
  )
17599 
 
17600 
  def __init__(self, orderId=None, isAuthorized=None,):
17601 
    self.orderId = orderId
17602 
    self.isAuthorized = isAuthorized
17603 
 
17604 
  def read(self, iprot):
17605 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17606 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17607 
      return
17608 
    iprot.readStructBegin()
17609 
    while True:
17610 
      (fname, ftype, fid) = iprot.readFieldBegin()
17611 
      if ftype == TType.STOP:
17612 
        break
17613 
      if fid == 1:
17614 
        if ftype == TType.I64:
17615 
          self.orderId = iprot.readI64();
17616 
        else:
17617 
          iprot.skip(ftype)
17618 
      elif fid == 2:
17619 
        if ftype == TType.BOOL:
17620 
          self.isAuthorized = iprot.readBool();
17621 
        else:
17622 
          iprot.skip(ftype)
17623 
      else:
17624 
        iprot.skip(ftype)
17625 
      iprot.readFieldEnd()
17626 
    iprot.readStructEnd()
17627 
 
17628 
  def write(self, oprot):
17629 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17630 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17631 
      return
17632 
    oprot.writeStructBegin('markOrderReturnRequestAuthorized_args')
17633 
    if self.orderId is not None:
17634 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
17635 
      oprot.writeI64(self.orderId)
17636 
      oprot.writeFieldEnd()
17637 
    if self.isAuthorized is not None:
17638 
      oprot.writeFieldBegin('isAuthorized', TType.BOOL, 2)
17639 
      oprot.writeBool(self.isAuthorized)
17640 
      oprot.writeFieldEnd()
17641 
    oprot.writeFieldStop()
17642 
    oprot.writeStructEnd()
17643 
 
17644 
  def validate(self):
17645 
    return
17646 
 
17647 
 
17648 
  def __repr__(self):
17649 
    L = ['%s=%r' % (key, value)
17650 
      for key, value in self.__dict__.iteritems()]
17651 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17652 
 
17653 
  def __eq__(self, other):
17654 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17655 
 
17656 
  def __ne__(self, other):
17657 
    return not (self == other)
17658 
 
17659 
class markOrderReturnRequestAuthorized_result:
17660 
  """
17661 
  Attributes:
17662 
   - success
17663 
   - ex
17664 
  """
17665 
 
17666 
  thrift_spec = (
17667 
    (0, TType.BOOL, 'success', None, None, ), # 0
17668 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
17669 
  )
17670 
 
17671 
  def __init__(self, success=None, ex=None,):
17672 
    self.success = success
17673 
    self.ex = ex
17674 
 
17675 
  def read(self, iprot):
17676 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17677 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17678 
      return
17679 
    iprot.readStructBegin()
17680 
    while True:
17681 
      (fname, ftype, fid) = iprot.readFieldBegin()
17682 
      if ftype == TType.STOP:
17683 
        break
17684 
      if fid == 0:
17685 
        if ftype == TType.BOOL:
17686 
          self.success = iprot.readBool();
17687 
        else:
17688 
          iprot.skip(ftype)
17689 
      elif fid == 1:
17690 
        if ftype == TType.STRUCT:
17691 
          self.ex = TransactionServiceException()
17692 
          self.ex.read(iprot)
17693 
        else:
17694 
          iprot.skip(ftype)
17695 
      else:
17696 
        iprot.skip(ftype)
17697 
      iprot.readFieldEnd()
17698 
    iprot.readStructEnd()
17699 
 
17700 
  def write(self, oprot):
17701 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17702 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17703 
      return
17704 
    oprot.writeStructBegin('markOrderReturnRequestAuthorized_result')
17705 
    if self.success is not None:
17706 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
17707 
      oprot.writeBool(self.success)
17708 
      oprot.writeFieldEnd()
17709 
    if self.ex is not None:
17710 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
17711 
      self.ex.write(oprot)
17712 
      oprot.writeFieldEnd()
17713 
    oprot.writeFieldStop()
17714 
    oprot.writeStructEnd()
17715 
 
17716 
  def validate(self):
17717 
    return
17718 
 
17719 
 
17720 
  def __repr__(self):
17721 
    L = ['%s=%r' % (key, value)
17722 
      for key, value in self.__dict__.iteritems()]
17723 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17724 
 
17725 
  def __eq__(self, other):
17726 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17727 
 
17728 
  def __ne__(self, other):
17729 
    return not (self == other)
17730 
 
2536 chandransh 17731 
class requestPickupNumber_args:
17732 
  """
17733 
  Attributes:
17734 
   - orderId
4579 rajveer 17735 
   - providerId
2536 chandransh 17736 
  """
17737 
 
17738 
  thrift_spec = (
17739 
    None, # 0
17740 
    (1, TType.I64, 'orderId', None, None, ), # 1
4579 rajveer 17741 
    (2, TType.I64, 'providerId', None, None, ), # 2
2536 chandransh 17742 
  )
17743 
 
4579 rajveer 17744 
  def __init__(self, orderId=None, providerId=None,):
2536 chandransh 17745 
    self.orderId = orderId
4579 rajveer 17746 
    self.providerId = providerId
2536 chandransh 17747 
 
17748 
  def read(self, iprot):
17749 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17750 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17751 
      return
17752 
    iprot.readStructBegin()
17753 
    while True:
17754 
      (fname, ftype, fid) = iprot.readFieldBegin()
17755 
      if ftype == TType.STOP:
17756 
        break
17757 
      if fid == 1:
17758 
        if ftype == TType.I64:
17759 
          self.orderId = iprot.readI64();
17760 
        else:
17761 
          iprot.skip(ftype)
4579 rajveer 17762 
      elif fid == 2:
17763 
        if ftype == TType.I64:
17764 
          self.providerId = iprot.readI64();
17765 
        else:
17766 
          iprot.skip(ftype)
2536 chandransh 17767 
      else:
17768 
        iprot.skip(ftype)
17769 
      iprot.readFieldEnd()
17770 
    iprot.readStructEnd()
17771 
 
17772 
  def write(self, oprot):
17773 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17774 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17775 
      return
17776 
    oprot.writeStructBegin('requestPickupNumber_args')
3431 rajveer 17777 
    if self.orderId is not None:
2536 chandransh 17778 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
17779 
      oprot.writeI64(self.orderId)
17780 
      oprot.writeFieldEnd()
4579 rajveer 17781 
    if self.providerId is not None:
17782 
      oprot.writeFieldBegin('providerId', TType.I64, 2)
17783 
      oprot.writeI64(self.providerId)
17784 
      oprot.writeFieldEnd()
2536 chandransh 17785 
    oprot.writeFieldStop()
17786 
    oprot.writeStructEnd()
17787 
 
3431 rajveer 17788 
  def validate(self):
17789 
    return
17790 
 
17791 
 
2536 chandransh 17792 
  def __repr__(self):
17793 
    L = ['%s=%r' % (key, value)
17794 
      for key, value in self.__dict__.iteritems()]
17795 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17796 
 
17797 
  def __eq__(self, other):
17798 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17799 
 
17800 
  def __ne__(self, other):
17801 
    return not (self == other)
17802 
 
17803 
class requestPickupNumber_result:
17804 
  """
17805 
  Attributes:
17806 
   - success
17807 
   - ex
17808 
  """
17809 
 
17810 
  thrift_spec = (
17811 
    (0, TType.BOOL, 'success', None, None, ), # 0
17812 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
17813 
  )
17814 
 
17815 
  def __init__(self, success=None, ex=None,):
17816 
    self.success = success
17817 
    self.ex = ex
17818 
 
17819 
  def read(self, iprot):
17820 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17821 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17822 
      return
17823 
    iprot.readStructBegin()
17824 
    while True:
17825 
      (fname, ftype, fid) = iprot.readFieldBegin()
17826 
      if ftype == TType.STOP:
17827 
        break
17828 
      if fid == 0:
17829 
        if ftype == TType.BOOL:
17830 
          self.success = iprot.readBool();
17831 
        else:
17832 
          iprot.skip(ftype)
17833 
      elif fid == 1:
17834 
        if ftype == TType.STRUCT:
17835 
          self.ex = TransactionServiceException()
17836 
          self.ex.read(iprot)
17837 
        else:
17838 
          iprot.skip(ftype)
17839 
      else:
17840 
        iprot.skip(ftype)
17841 
      iprot.readFieldEnd()
17842 
    iprot.readStructEnd()
17843 
 
17844 
  def write(self, oprot):
17845 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17846 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17847 
      return
17848 
    oprot.writeStructBegin('requestPickupNumber_result')
3431 rajveer 17849 
    if self.success is not None:
2536 chandransh 17850 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
17851 
      oprot.writeBool(self.success)
17852 
      oprot.writeFieldEnd()
3431 rajveer 17853 
    if self.ex is not None:
2536 chandransh 17854 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
17855 
      self.ex.write(oprot)
17856 
      oprot.writeFieldEnd()
17857 
    oprot.writeFieldStop()
17858 
    oprot.writeStructEnd()
17859 
 
3431 rajveer 17860 
  def validate(self):
17861 
    return
17862 
 
17863 
 
2536 chandransh 17864 
  def __repr__(self):
17865 
    L = ['%s=%r' % (key, value)
17866 
      for key, value in self.__dict__.iteritems()]
17867 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17868 
 
17869 
  def __eq__(self, other):
17870 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17871 
 
17872 
  def __ne__(self, other):
17873 
    return not (self == other)
17874 
 
17875 
class authorizePickup_args:
17876 
  """
17877 
  Attributes:
17878 
   - orderId
17879 
   - pickupNumber
4602 rajveer 17880 
   - providerId
2536 chandransh 17881 
  """
17882 
 
17883 
  thrift_spec = (
17884 
    None, # 0
17885 
    (1, TType.I64, 'orderId', None, None, ), # 1
17886 
    (2, TType.STRING, 'pickupNumber', None, None, ), # 2
4602 rajveer 17887 
    (3, TType.I64, 'providerId', None, None, ), # 3
2536 chandransh 17888 
  )
17889 
 
4602 rajveer 17890 
  def __init__(self, orderId=None, pickupNumber=None, providerId=None,):
2536 chandransh 17891 
    self.orderId = orderId
17892 
    self.pickupNumber = pickupNumber
4602 rajveer 17893 
    self.providerId = providerId
2536 chandransh 17894 
 
17895 
  def read(self, iprot):
17896 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17897 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17898 
      return
17899 
    iprot.readStructBegin()
17900 
    while True:
17901 
      (fname, ftype, fid) = iprot.readFieldBegin()
17902 
      if ftype == TType.STOP:
17903 
        break
17904 
      if fid == 1:
17905 
        if ftype == TType.I64:
17906 
          self.orderId = iprot.readI64();
17907 
        else:
17908 
          iprot.skip(ftype)
17909 
      elif fid == 2:
17910 
        if ftype == TType.STRING:
17911 
          self.pickupNumber = iprot.readString();
17912 
        else:
17913 
          iprot.skip(ftype)
4602 rajveer 17914 
      elif fid == 3:
17915 
        if ftype == TType.I64:
17916 
          self.providerId = iprot.readI64();
17917 
        else:
17918 
          iprot.skip(ftype)
2536 chandransh 17919 
      else:
17920 
        iprot.skip(ftype)
17921 
      iprot.readFieldEnd()
17922 
    iprot.readStructEnd()
17923 
 
17924 
  def write(self, oprot):
17925 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17926 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17927 
      return
17928 
    oprot.writeStructBegin('authorizePickup_args')
3431 rajveer 17929 
    if self.orderId is not None:
2536 chandransh 17930 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
17931 
      oprot.writeI64(self.orderId)
17932 
      oprot.writeFieldEnd()
3431 rajveer 17933 
    if self.pickupNumber is not None:
2536 chandransh 17934 
      oprot.writeFieldBegin('pickupNumber', TType.STRING, 2)
17935 
      oprot.writeString(self.pickupNumber)
17936 
      oprot.writeFieldEnd()
4602 rajveer 17937 
    if self.providerId is not None:
17938 
      oprot.writeFieldBegin('providerId', TType.I64, 3)
17939 
      oprot.writeI64(self.providerId)
17940 
      oprot.writeFieldEnd()
2536 chandransh 17941 
    oprot.writeFieldStop()
17942 
    oprot.writeStructEnd()
17943 
 
3431 rajveer 17944 
  def validate(self):
17945 
    return
17946 
 
17947 
 
2536 chandransh 17948 
  def __repr__(self):
17949 
    L = ['%s=%r' % (key, value)
17950 
      for key, value in self.__dict__.iteritems()]
17951 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17952 
 
17953 
  def __eq__(self, other):
17954 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17955 
 
17956 
  def __ne__(self, other):
17957 
    return not (self == other)
17958 
 
17959 
class authorizePickup_result:
17960 
  """
17961 
  Attributes:
17962 
   - success
17963 
   - ex
17964 
  """
17965 
 
17966 
  thrift_spec = (
17967 
    (0, TType.BOOL, 'success', None, None, ), # 0
17968 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
17969 
  )
17970 
 
17971 
  def __init__(self, success=None, ex=None,):
17972 
    self.success = success
17973 
    self.ex = ex
17974 
 
17975 
  def read(self, iprot):
17976 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17977 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17978 
      return
17979 
    iprot.readStructBegin()
17980 
    while True:
17981 
      (fname, ftype, fid) = iprot.readFieldBegin()
17982 
      if ftype == TType.STOP:
17983 
        break
17984 
      if fid == 0:
17985 
        if ftype == TType.BOOL:
17986 
          self.success = iprot.readBool();
17987 
        else:
17988 
          iprot.skip(ftype)
17989 
      elif fid == 1:
17990 
        if ftype == TType.STRUCT:
17991 
          self.ex = TransactionServiceException()
17992 
          self.ex.read(iprot)
17993 
        else:
17994 
          iprot.skip(ftype)
17995 
      else:
17996 
        iprot.skip(ftype)
17997 
      iprot.readFieldEnd()
17998 
    iprot.readStructEnd()
17999 
 
18000 
  def write(self, oprot):
18001 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18002 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18003 
      return
18004 
    oprot.writeStructBegin('authorizePickup_result')
3431 rajveer 18005 
    if self.success is not None:
2536 chandransh 18006 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
18007 
      oprot.writeBool(self.success)
18008 
      oprot.writeFieldEnd()
3431 rajveer 18009 
    if self.ex is not None:
2536 chandransh 18010 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
18011 
      self.ex.write(oprot)
18012 
      oprot.writeFieldEnd()
18013 
    oprot.writeFieldStop()
18014 
    oprot.writeStructEnd()
18015 
 
3431 rajveer 18016 
  def validate(self):
18017 
    return
18018 
 
18019 
 
2536 chandransh 18020 
  def __repr__(self):
18021 
    L = ['%s=%r' % (key, value)
18022 
      for key, value in self.__dict__.iteritems()]
18023 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18024 
 
18025 
  def __eq__(self, other):
18026 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18027 
 
18028 
  def __ne__(self, other):
18029 
    return not (self == other)
18030 
 
2764 chandransh 18031 
class markDoasAsPickedUp_args:
18032 
  """
18033 
  Attributes:
18034 
   - providerId
18035 
   - pickupDetails
18036 
  """
18037 
 
18038 
  thrift_spec = (
18039 
    None, # 0
18040 
    (1, TType.I64, 'providerId', None, None, ), # 1
18041 
    (2, TType.MAP, 'pickupDetails', (TType.STRING,None,TType.STRING,None), None, ), # 2
18042 
  )
18043 
 
18044 
  def __init__(self, providerId=None, pickupDetails=None,):
18045 
    self.providerId = providerId
18046 
    self.pickupDetails = pickupDetails
18047 
 
18048 
  def read(self, iprot):
18049 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18050 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18051 
      return
18052 
    iprot.readStructBegin()
18053 
    while True:
18054 
      (fname, ftype, fid) = iprot.readFieldBegin()
18055 
      if ftype == TType.STOP:
18056 
        break
18057 
      if fid == 1:
18058 
        if ftype == TType.I64:
18059 
          self.providerId = iprot.readI64();
18060 
        else:
18061 
          iprot.skip(ftype)
18062 
      elif fid == 2:
18063 
        if ftype == TType.MAP:
18064 
          self.pickupDetails = {}
6188 rajveer 18065 
          (_ktype408, _vtype409, _size407 ) = iprot.readMapBegin()
18066 
          for _i411 in xrange(_size407):
18067 
            _key412 = iprot.readString();
18068 
            _val413 = iprot.readString();
18069 
            self.pickupDetails[_key412] = _val413
2764 chandransh 18070 
          iprot.readMapEnd()
18071 
        else:
18072 
          iprot.skip(ftype)
18073 
      else:
18074 
        iprot.skip(ftype)
18075 
      iprot.readFieldEnd()
18076 
    iprot.readStructEnd()
18077 
 
18078 
  def write(self, oprot):
18079 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18080 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18081 
      return
18082 
    oprot.writeStructBegin('markDoasAsPickedUp_args')
3431 rajveer 18083 
    if self.providerId is not None:
2764 chandransh 18084 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
18085 
      oprot.writeI64(self.providerId)
18086 
      oprot.writeFieldEnd()
3431 rajveer 18087 
    if self.pickupDetails is not None:
2764 chandransh 18088 
      oprot.writeFieldBegin('pickupDetails', TType.MAP, 2)
18089 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.pickupDetails))
6188 rajveer 18090 
      for kiter414,viter415 in self.pickupDetails.items():
18091 
        oprot.writeString(kiter414)
18092 
        oprot.writeString(viter415)
2764 chandransh 18093 
      oprot.writeMapEnd()
18094 
      oprot.writeFieldEnd()
18095 
    oprot.writeFieldStop()
18096 
    oprot.writeStructEnd()
18097 
 
3431 rajveer 18098 
  def validate(self):
18099 
    return
18100 
 
18101 
 
2764 chandransh 18102 
  def __repr__(self):
18103 
    L = ['%s=%r' % (key, value)
18104 
      for key, value in self.__dict__.iteritems()]
18105 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18106 
 
18107 
  def __eq__(self, other):
18108 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18109 
 
18110 
  def __ne__(self, other):
18111 
    return not (self == other)
18112 
 
18113 
class markDoasAsPickedUp_result:
4910 phani.kuma 18114 
 
18115 
  thrift_spec = (
18116 
  )
18117 
 
18118 
  def read(self, iprot):
18119 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18120 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18121 
      return
18122 
    iprot.readStructBegin()
18123 
    while True:
18124 
      (fname, ftype, fid) = iprot.readFieldBegin()
18125 
      if ftype == TType.STOP:
18126 
        break
18127 
      else:
18128 
        iprot.skip(ftype)
18129 
      iprot.readFieldEnd()
18130 
    iprot.readStructEnd()
18131 
 
18132 
  def write(self, oprot):
18133 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18134 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18135 
      return
18136 
    oprot.writeStructBegin('markDoasAsPickedUp_result')
18137 
    oprot.writeFieldStop()
18138 
    oprot.writeStructEnd()
18139 
 
18140 
  def validate(self):
18141 
    return
18142 
 
18143 
 
18144 
  def __repr__(self):
18145 
    L = ['%s=%r' % (key, value)
18146 
      for key, value in self.__dict__.iteritems()]
18147 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18148 
 
18149 
  def __eq__(self, other):
18150 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18151 
 
18152 
  def __ne__(self, other):
18153 
    return not (self == other)
18154 
 
18155 
class getDoasNotPickedUp_args:
2764 chandransh 18156 
  """
18157 
  Attributes:
4910 phani.kuma 18158 
   - providerId
18159 
  """
18160 
 
18161 
  thrift_spec = (
18162 
    None, # 0
18163 
    (1, TType.I64, 'providerId', None, None, ), # 1
18164 
  )
18165 
 
18166 
  def __init__(self, providerId=None,):
18167 
    self.providerId = providerId
18168 
 
18169 
  def read(self, iprot):
18170 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18171 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18172 
      return
18173 
    iprot.readStructBegin()
18174 
    while True:
18175 
      (fname, ftype, fid) = iprot.readFieldBegin()
18176 
      if ftype == TType.STOP:
18177 
        break
18178 
      if fid == 1:
18179 
        if ftype == TType.I64:
18180 
          self.providerId = iprot.readI64();
18181 
        else:
18182 
          iprot.skip(ftype)
18183 
      else:
18184 
        iprot.skip(ftype)
18185 
      iprot.readFieldEnd()
18186 
    iprot.readStructEnd()
18187 
 
18188 
  def write(self, oprot):
18189 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18190 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18191 
      return
18192 
    oprot.writeStructBegin('getDoasNotPickedUp_args')
18193 
    if self.providerId is not None:
18194 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
18195 
      oprot.writeI64(self.providerId)
18196 
      oprot.writeFieldEnd()
18197 
    oprot.writeFieldStop()
18198 
    oprot.writeStructEnd()
18199 
 
18200 
  def validate(self):
18201 
    return
18202 
 
18203 
 
18204 
  def __repr__(self):
18205 
    L = ['%s=%r' % (key, value)
18206 
      for key, value in self.__dict__.iteritems()]
18207 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18208 
 
18209 
  def __eq__(self, other):
18210 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18211 
 
18212 
  def __ne__(self, other):
18213 
    return not (self == other)
18214 
 
18215 
class getDoasNotPickedUp_result:
18216 
  """
18217 
  Attributes:
2764 chandransh 18218 
   - success
18219 
  """
18220 
 
18221 
  thrift_spec = (
18222 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
18223 
  )
18224 
 
18225 
  def __init__(self, success=None,):
18226 
    self.success = success
18227 
 
18228 
  def read(self, iprot):
18229 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18230 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18231 
      return
18232 
    iprot.readStructBegin()
18233 
    while True:
18234 
      (fname, ftype, fid) = iprot.readFieldBegin()
18235 
      if ftype == TType.STOP:
18236 
        break
18237 
      if fid == 0:
18238 
        if ftype == TType.LIST:
18239 
          self.success = []
6188 rajveer 18240 
          (_etype419, _size416) = iprot.readListBegin()
18241 
          for _i420 in xrange(_size416):
18242 
            _elem421 = Order()
18243 
            _elem421.read(iprot)
18244 
            self.success.append(_elem421)
2764 chandransh 18245 
          iprot.readListEnd()
18246 
        else:
18247 
          iprot.skip(ftype)
18248 
      else:
18249 
        iprot.skip(ftype)
18250 
      iprot.readFieldEnd()
18251 
    iprot.readStructEnd()
18252 
 
18253 
  def write(self, oprot):
18254 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18255 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18256 
      return
4910 phani.kuma 18257 
    oprot.writeStructBegin('getDoasNotPickedUp_result')
3431 rajveer 18258 
    if self.success is not None:
2764 chandransh 18259 
      oprot.writeFieldBegin('success', TType.LIST, 0)
18260 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 18261 
      for iter422 in self.success:
18262 
        iter422.write(oprot)
2764 chandransh 18263 
      oprot.writeListEnd()
18264 
      oprot.writeFieldEnd()
18265 
    oprot.writeFieldStop()
18266 
    oprot.writeStructEnd()
18267 
 
3431 rajveer 18268 
  def validate(self):
18269 
    return
18270 
 
18271 
 
2764 chandransh 18272 
  def __repr__(self):
18273 
    L = ['%s=%r' % (key, value)
18274 
      for key, value in self.__dict__.iteritems()]
18275 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18276 
 
18277 
  def __eq__(self, other):
18278 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18279 
 
18280 
  def __ne__(self, other):
18281 
    return not (self == other)
18282 
 
4741 phani.kuma 18283 
class markReturnOrdersAsPickedUp_args:
18284 
  """
18285 
  Attributes:
18286 
   - providerId
18287 
   - pickupDetails
18288 
  """
18289 
 
18290 
  thrift_spec = (
18291 
    None, # 0
18292 
    (1, TType.I64, 'providerId', None, None, ), # 1
18293 
    (2, TType.MAP, 'pickupDetails', (TType.STRING,None,TType.STRING,None), None, ), # 2
18294 
  )
18295 
 
18296 
  def __init__(self, providerId=None, pickupDetails=None,):
18297 
    self.providerId = providerId
18298 
    self.pickupDetails = pickupDetails
18299 
 
18300 
  def read(self, iprot):
18301 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18302 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18303 
      return
18304 
    iprot.readStructBegin()
18305 
    while True:
18306 
      (fname, ftype, fid) = iprot.readFieldBegin()
18307 
      if ftype == TType.STOP:
18308 
        break
18309 
      if fid == 1:
18310 
        if ftype == TType.I64:
18311 
          self.providerId = iprot.readI64();
18312 
        else:
18313 
          iprot.skip(ftype)
18314 
      elif fid == 2:
18315 
        if ftype == TType.MAP:
18316 
          self.pickupDetails = {}
6188 rajveer 18317 
          (_ktype424, _vtype425, _size423 ) = iprot.readMapBegin()
18318 
          for _i427 in xrange(_size423):
18319 
            _key428 = iprot.readString();
18320 
            _val429 = iprot.readString();
18321 
            self.pickupDetails[_key428] = _val429
4741 phani.kuma 18322 
          iprot.readMapEnd()
18323 
        else:
18324 
          iprot.skip(ftype)
18325 
      else:
18326 
        iprot.skip(ftype)
18327 
      iprot.readFieldEnd()
18328 
    iprot.readStructEnd()
18329 
 
18330 
  def write(self, oprot):
18331 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18332 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18333 
      return
18334 
    oprot.writeStructBegin('markReturnOrdersAsPickedUp_args')
18335 
    if self.providerId is not None:
18336 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
18337 
      oprot.writeI64(self.providerId)
18338 
      oprot.writeFieldEnd()
18339 
    if self.pickupDetails is not None:
18340 
      oprot.writeFieldBegin('pickupDetails', TType.MAP, 2)
18341 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.pickupDetails))
6188 rajveer 18342 
      for kiter430,viter431 in self.pickupDetails.items():
18343 
        oprot.writeString(kiter430)
18344 
        oprot.writeString(viter431)
4741 phani.kuma 18345 
      oprot.writeMapEnd()
18346 
      oprot.writeFieldEnd()
18347 
    oprot.writeFieldStop()
18348 
    oprot.writeStructEnd()
18349 
 
18350 
  def validate(self):
18351 
    return
18352 
 
18353 
 
18354 
  def __repr__(self):
18355 
    L = ['%s=%r' % (key, value)
18356 
      for key, value in self.__dict__.iteritems()]
18357 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18358 
 
18359 
  def __eq__(self, other):
18360 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18361 
 
18362 
  def __ne__(self, other):
18363 
    return not (self == other)
18364 
 
18365 
class markReturnOrdersAsPickedUp_result:
4910 phani.kuma 18366 
 
18367 
  thrift_spec = (
18368 
  )
18369 
 
18370 
  def read(self, iprot):
18371 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18372 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18373 
      return
18374 
    iprot.readStructBegin()
18375 
    while True:
18376 
      (fname, ftype, fid) = iprot.readFieldBegin()
18377 
      if ftype == TType.STOP:
18378 
        break
18379 
      else:
18380 
        iprot.skip(ftype)
18381 
      iprot.readFieldEnd()
18382 
    iprot.readStructEnd()
18383 
 
18384 
  def write(self, oprot):
18385 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18386 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18387 
      return
18388 
    oprot.writeStructBegin('markReturnOrdersAsPickedUp_result')
18389 
    oprot.writeFieldStop()
18390 
    oprot.writeStructEnd()
18391 
 
18392 
  def validate(self):
18393 
    return
18394 
 
18395 
 
18396 
  def __repr__(self):
18397 
    L = ['%s=%r' % (key, value)
18398 
      for key, value in self.__dict__.iteritems()]
18399 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18400 
 
18401 
  def __eq__(self, other):
18402 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18403 
 
18404 
  def __ne__(self, other):
18405 
    return not (self == other)
18406 
 
18407 
class getReturnOrdersNotPickedUp_args:
4741 phani.kuma 18408 
  """
18409 
  Attributes:
4910 phani.kuma 18410 
   - providerId
18411 
  """
18412 
 
18413 
  thrift_spec = (
18414 
    None, # 0
18415 
    (1, TType.I64, 'providerId', None, None, ), # 1
18416 
  )
18417 
 
18418 
  def __init__(self, providerId=None,):
18419 
    self.providerId = providerId
18420 
 
18421 
  def read(self, iprot):
18422 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18423 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18424 
      return
18425 
    iprot.readStructBegin()
18426 
    while True:
18427 
      (fname, ftype, fid) = iprot.readFieldBegin()
18428 
      if ftype == TType.STOP:
18429 
        break
18430 
      if fid == 1:
18431 
        if ftype == TType.I64:
18432 
          self.providerId = iprot.readI64();
18433 
        else:
18434 
          iprot.skip(ftype)
18435 
      else:
18436 
        iprot.skip(ftype)
18437 
      iprot.readFieldEnd()
18438 
    iprot.readStructEnd()
18439 
 
18440 
  def write(self, oprot):
18441 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18442 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18443 
      return
18444 
    oprot.writeStructBegin('getReturnOrdersNotPickedUp_args')
18445 
    if self.providerId is not None:
18446 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
18447 
      oprot.writeI64(self.providerId)
18448 
      oprot.writeFieldEnd()
18449 
    oprot.writeFieldStop()
18450 
    oprot.writeStructEnd()
18451 
 
18452 
  def validate(self):
18453 
    return
18454 
 
18455 
 
18456 
  def __repr__(self):
18457 
    L = ['%s=%r' % (key, value)
18458 
      for key, value in self.__dict__.iteritems()]
18459 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18460 
 
18461 
  def __eq__(self, other):
18462 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18463 
 
18464 
  def __ne__(self, other):
18465 
    return not (self == other)
18466 
 
18467 
class getReturnOrdersNotPickedUp_result:
18468 
  """
18469 
  Attributes:
4741 phani.kuma 18470 
   - success
18471 
  """
18472 
 
18473 
  thrift_spec = (
18474 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
18475 
  )
18476 
 
18477 
  def __init__(self, success=None,):
18478 
    self.success = success
18479 
 
18480 
  def read(self, iprot):
18481 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18482 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18483 
      return
18484 
    iprot.readStructBegin()
18485 
    while True:
18486 
      (fname, ftype, fid) = iprot.readFieldBegin()
18487 
      if ftype == TType.STOP:
18488 
        break
18489 
      if fid == 0:
18490 
        if ftype == TType.LIST:
18491 
          self.success = []
6188 rajveer 18492 
          (_etype435, _size432) = iprot.readListBegin()
18493 
          for _i436 in xrange(_size432):
18494 
            _elem437 = Order()
18495 
            _elem437.read(iprot)
18496 
            self.success.append(_elem437)
4741 phani.kuma 18497 
          iprot.readListEnd()
18498 
        else:
18499 
          iprot.skip(ftype)
18500 
      else:
18501 
        iprot.skip(ftype)
18502 
      iprot.readFieldEnd()
18503 
    iprot.readStructEnd()
18504 
 
18505 
  def write(self, oprot):
18506 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18507 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18508 
      return
4910 phani.kuma 18509 
    oprot.writeStructBegin('getReturnOrdersNotPickedUp_result')
4741 phani.kuma 18510 
    if self.success is not None:
18511 
      oprot.writeFieldBegin('success', TType.LIST, 0)
18512 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 18513 
      for iter438 in self.success:
18514 
        iter438.write(oprot)
4741 phani.kuma 18515 
      oprot.writeListEnd()
18516 
      oprot.writeFieldEnd()
18517 
    oprot.writeFieldStop()
18518 
    oprot.writeStructEnd()
18519 
 
18520 
  def validate(self):
18521 
    return
18522 
 
18523 
 
18524 
  def __repr__(self):
18525 
    L = ['%s=%r' % (key, value)
18526 
      for key, value in self.__dict__.iteritems()]
18527 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18528 
 
18529 
  def __eq__(self, other):
18530 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18531 
 
18532 
  def __ne__(self, other):
18533 
    return not (self == other)
18534 
 
2616 chandransh 18535 
class receiveReturn_args:
2591 chandransh 18536 
  """
18537 
  Attributes:
18538 
   - orderId
4479 rajveer 18539 
   - receiveCondition
2591 chandransh 18540 
  """
2536 chandransh 18541 
 
2591 chandransh 18542 
  thrift_spec = (
18543 
    None, # 0
18544 
    (1, TType.I64, 'orderId', None, None, ), # 1
4479 rajveer 18545 
    (2, TType.I64, 'receiveCondition', None, None, ), # 2
2591 chandransh 18546 
  )
18547 
 
4479 rajveer 18548 
  def __init__(self, orderId=None, receiveCondition=None,):
2591 chandransh 18549 
    self.orderId = orderId
4479 rajveer 18550 
    self.receiveCondition = receiveCondition
2591 chandransh 18551 
 
18552 
  def read(self, iprot):
18553 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18554 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18555 
      return
18556 
    iprot.readStructBegin()
18557 
    while True:
18558 
      (fname, ftype, fid) = iprot.readFieldBegin()
18559 
      if ftype == TType.STOP:
18560 
        break
18561 
      if fid == 1:
18562 
        if ftype == TType.I64:
18563 
          self.orderId = iprot.readI64();
18564 
        else:
18565 
          iprot.skip(ftype)
4479 rajveer 18566 
      elif fid == 2:
18567 
        if ftype == TType.I64:
18568 
          self.receiveCondition = iprot.readI64();
18569 
        else:
18570 
          iprot.skip(ftype)
2591 chandransh 18571 
      else:
18572 
        iprot.skip(ftype)
18573 
      iprot.readFieldEnd()
18574 
    iprot.readStructEnd()
18575 
 
18576 
  def write(self, oprot):
18577 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18578 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18579 
      return
2616 chandransh 18580 
    oprot.writeStructBegin('receiveReturn_args')
3431 rajveer 18581 
    if self.orderId is not None:
2591 chandransh 18582 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
18583 
      oprot.writeI64(self.orderId)
18584 
      oprot.writeFieldEnd()
4479 rajveer 18585 
    if self.receiveCondition is not None:
18586 
      oprot.writeFieldBegin('receiveCondition', TType.I64, 2)
18587 
      oprot.writeI64(self.receiveCondition)
18588 
      oprot.writeFieldEnd()
2591 chandransh 18589 
    oprot.writeFieldStop()
18590 
    oprot.writeStructEnd()
18591 
 
3431 rajveer 18592 
  def validate(self):
18593 
    return
18594 
 
18595 
 
2591 chandransh 18596 
  def __repr__(self):
18597 
    L = ['%s=%r' % (key, value)
18598 
      for key, value in self.__dict__.iteritems()]
18599 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18600 
 
18601 
  def __eq__(self, other):
18602 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18603 
 
18604 
  def __ne__(self, other):
18605 
    return not (self == other)
18606 
 
2616 chandransh 18607 
class receiveReturn_result:
2591 chandransh 18608 
  """
18609 
  Attributes:
18610 
   - success
18611 
   - ex
18612 
  """
18613 
 
18614 
  thrift_spec = (
18615 
    (0, TType.BOOL, 'success', None, None, ), # 0
18616 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
18617 
  )
18618 
 
18619 
  def __init__(self, success=None, ex=None,):
18620 
    self.success = success
18621 
    self.ex = ex
18622 
 
18623 
  def read(self, iprot):
18624 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18625 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18626 
      return
18627 
    iprot.readStructBegin()
18628 
    while True:
18629 
      (fname, ftype, fid) = iprot.readFieldBegin()
18630 
      if ftype == TType.STOP:
18631 
        break
18632 
      if fid == 0:
18633 
        if ftype == TType.BOOL:
18634 
          self.success = iprot.readBool();
18635 
        else:
18636 
          iprot.skip(ftype)
18637 
      elif fid == 1:
18638 
        if ftype == TType.STRUCT:
18639 
          self.ex = TransactionServiceException()
18640 
          self.ex.read(iprot)
18641 
        else:
18642 
          iprot.skip(ftype)
18643 
      else:
18644 
        iprot.skip(ftype)
18645 
      iprot.readFieldEnd()
18646 
    iprot.readStructEnd()
18647 
 
18648 
  def write(self, oprot):
18649 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18650 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18651 
      return
2616 chandransh 18652 
    oprot.writeStructBegin('receiveReturn_result')
3431 rajveer 18653 
    if self.success is not None:
2591 chandransh 18654 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
18655 
      oprot.writeBool(self.success)
18656 
      oprot.writeFieldEnd()
3431 rajveer 18657 
    if self.ex is not None:
2591 chandransh 18658 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
18659 
      self.ex.write(oprot)
18660 
      oprot.writeFieldEnd()
18661 
    oprot.writeFieldStop()
18662 
    oprot.writeStructEnd()
18663 
 
3431 rajveer 18664 
  def validate(self):
18665 
    return
18666 
 
18667 
 
2591 chandransh 18668 
  def __repr__(self):
18669 
    L = ['%s=%r' % (key, value)
18670 
      for key, value in self.__dict__.iteritems()]
18671 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18672 
 
18673 
  def __eq__(self, other):
18674 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18675 
 
18676 
  def __ne__(self, other):
18677 
    return not (self == other)
18678 
 
18679 
class validateDoa_args:
18680 
  """
18681 
  Attributes:
18682 
   - orderId
18683 
   - isValid
18684 
  """
18685 
 
18686 
  thrift_spec = (
18687 
    None, # 0
18688 
    (1, TType.I64, 'orderId', None, None, ), # 1
18689 
    (2, TType.BOOL, 'isValid', None, None, ), # 2
18690 
  )
18691 
 
18692 
  def __init__(self, orderId=None, isValid=None,):
18693 
    self.orderId = orderId
18694 
    self.isValid = isValid
18695 
 
18696 
  def read(self, iprot):
18697 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18698 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18699 
      return
18700 
    iprot.readStructBegin()
18701 
    while True:
18702 
      (fname, ftype, fid) = iprot.readFieldBegin()
18703 
      if ftype == TType.STOP:
18704 
        break
18705 
      if fid == 1:
18706 
        if ftype == TType.I64:
18707 
          self.orderId = iprot.readI64();
18708 
        else:
18709 
          iprot.skip(ftype)
18710 
      elif fid == 2:
18711 
        if ftype == TType.BOOL:
18712 
          self.isValid = iprot.readBool();
18713 
        else:
18714 
          iprot.skip(ftype)
18715 
      else:
18716 
        iprot.skip(ftype)
18717 
      iprot.readFieldEnd()
18718 
    iprot.readStructEnd()
18719 
 
18720 
  def write(self, oprot):
18721 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18722 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18723 
      return
18724 
    oprot.writeStructBegin('validateDoa_args')
3431 rajveer 18725 
    if self.orderId is not None:
2591 chandransh 18726 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
18727 
      oprot.writeI64(self.orderId)
18728 
      oprot.writeFieldEnd()
3431 rajveer 18729 
    if self.isValid is not None:
2591 chandransh 18730 
      oprot.writeFieldBegin('isValid', TType.BOOL, 2)
18731 
      oprot.writeBool(self.isValid)
18732 
      oprot.writeFieldEnd()
18733 
    oprot.writeFieldStop()
18734 
    oprot.writeStructEnd()
18735 
 
3431 rajveer 18736 
  def validate(self):
18737 
    return
18738 
 
18739 
 
2591 chandransh 18740 
  def __repr__(self):
18741 
    L = ['%s=%r' % (key, value)
18742 
      for key, value in self.__dict__.iteritems()]
18743 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18744 
 
18745 
  def __eq__(self, other):
18746 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18747 
 
18748 
  def __ne__(self, other):
18749 
    return not (self == other)
18750 
 
18751 
class validateDoa_result:
18752 
  """
18753 
  Attributes:
18754 
   - success
18755 
   - ex
18756 
  """
18757 
 
18758 
  thrift_spec = (
18759 
    (0, TType.BOOL, 'success', None, None, ), # 0
18760 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
18761 
  )
18762 
 
18763 
  def __init__(self, success=None, ex=None,):
18764 
    self.success = success
18765 
    self.ex = ex
18766 
 
18767 
  def read(self, iprot):
18768 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18769 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18770 
      return
18771 
    iprot.readStructBegin()
18772 
    while True:
18773 
      (fname, ftype, fid) = iprot.readFieldBegin()
18774 
      if ftype == TType.STOP:
18775 
        break
18776 
      if fid == 0:
18777 
        if ftype == TType.BOOL:
18778 
          self.success = iprot.readBool();
18779 
        else:
18780 
          iprot.skip(ftype)
18781 
      elif fid == 1:
18782 
        if ftype == TType.STRUCT:
18783 
          self.ex = TransactionServiceException()
18784 
          self.ex.read(iprot)
18785 
        else:
18786 
          iprot.skip(ftype)
18787 
      else:
18788 
        iprot.skip(ftype)
18789 
      iprot.readFieldEnd()
18790 
    iprot.readStructEnd()
18791 
 
18792 
  def write(self, oprot):
18793 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18794 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18795 
      return
18796 
    oprot.writeStructBegin('validateDoa_result')
3431 rajveer 18797 
    if self.success is not None:
2591 chandransh 18798 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
18799 
      oprot.writeBool(self.success)
18800 
      oprot.writeFieldEnd()
3431 rajveer 18801 
    if self.ex is not None:
2591 chandransh 18802 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
18803 
      self.ex.write(oprot)
18804 
      oprot.writeFieldEnd()
18805 
    oprot.writeFieldStop()
18806 
    oprot.writeStructEnd()
18807 
 
3431 rajveer 18808 
  def validate(self):
18809 
    return
18810 
 
18811 
 
2591 chandransh 18812 
  def __repr__(self):
18813 
    L = ['%s=%r' % (key, value)
18814 
      for key, value in self.__dict__.iteritems()]
18815 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18816 
 
18817 
  def __eq__(self, other):
18818 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18819 
 
18820 
  def __ne__(self, other):
18821 
    return not (self == other)
18822 
 
4495 rajveer 18823 
class validateReturnProduct_args:
18824 
  """
18825 
  Attributes:
18826 
   - orderId
18827 
   - isUsable
18828 
  """
18829 
 
18830 
  thrift_spec = (
18831 
    None, # 0
18832 
    (1, TType.I64, 'orderId', None, None, ), # 1
18833 
    (2, TType.BOOL, 'isUsable', None, None, ), # 2
18834 
  )
18835 
 
18836 
  def __init__(self, orderId=None, isUsable=None,):
18837 
    self.orderId = orderId
18838 
    self.isUsable = isUsable
18839 
 
18840 
  def read(self, iprot):
18841 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18842 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18843 
      return
18844 
    iprot.readStructBegin()
18845 
    while True:
18846 
      (fname, ftype, fid) = iprot.readFieldBegin()
18847 
      if ftype == TType.STOP:
18848 
        break
18849 
      if fid == 1:
18850 
        if ftype == TType.I64:
18851 
          self.orderId = iprot.readI64();
18852 
        else:
18853 
          iprot.skip(ftype)
18854 
      elif fid == 2:
18855 
        if ftype == TType.BOOL:
18856 
          self.isUsable = iprot.readBool();
18857 
        else:
18858 
          iprot.skip(ftype)
18859 
      else:
18860 
        iprot.skip(ftype)
18861 
      iprot.readFieldEnd()
18862 
    iprot.readStructEnd()
18863 
 
18864 
  def write(self, oprot):
18865 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18866 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18867 
      return
18868 
    oprot.writeStructBegin('validateReturnProduct_args')
18869 
    if self.orderId is not None:
18870 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
18871 
      oprot.writeI64(self.orderId)
18872 
      oprot.writeFieldEnd()
18873 
    if self.isUsable is not None:
18874 
      oprot.writeFieldBegin('isUsable', TType.BOOL, 2)
18875 
      oprot.writeBool(self.isUsable)
18876 
      oprot.writeFieldEnd()
18877 
    oprot.writeFieldStop()
18878 
    oprot.writeStructEnd()
18879 
 
18880 
  def validate(self):
18881 
    return
18882 
 
18883 
 
18884 
  def __repr__(self):
18885 
    L = ['%s=%r' % (key, value)
18886 
      for key, value in self.__dict__.iteritems()]
18887 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18888 
 
18889 
  def __eq__(self, other):
18890 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18891 
 
18892 
  def __ne__(self, other):
18893 
    return not (self == other)
18894 
 
18895 
class validateReturnProduct_result:
18896 
  """
18897 
  Attributes:
18898 
   - success
18899 
   - ex
18900 
  """
18901 
 
18902 
  thrift_spec = (
18903 
    (0, TType.BOOL, 'success', None, None, ), # 0
18904 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
18905 
  )
18906 
 
18907 
  def __init__(self, success=None, ex=None,):
18908 
    self.success = success
18909 
    self.ex = ex
18910 
 
18911 
  def read(self, iprot):
18912 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18913 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18914 
      return
18915 
    iprot.readStructBegin()
18916 
    while True:
18917 
      (fname, ftype, fid) = iprot.readFieldBegin()
18918 
      if ftype == TType.STOP:
18919 
        break
18920 
      if fid == 0:
18921 
        if ftype == TType.BOOL:
18922 
          self.success = iprot.readBool();
18923 
        else:
18924 
          iprot.skip(ftype)
18925 
      elif fid == 1:
18926 
        if ftype == TType.STRUCT:
18927 
          self.ex = TransactionServiceException()
18928 
          self.ex.read(iprot)
18929 
        else:
18930 
          iprot.skip(ftype)
18931 
      else:
18932 
        iprot.skip(ftype)
18933 
      iprot.readFieldEnd()
18934 
    iprot.readStructEnd()
18935 
 
18936 
  def write(self, oprot):
18937 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18938 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18939 
      return
18940 
    oprot.writeStructBegin('validateReturnProduct_result')
18941 
    if self.success is not None:
18942 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
18943 
      oprot.writeBool(self.success)
18944 
      oprot.writeFieldEnd()
18945 
    if self.ex is not None:
18946 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
18947 
      self.ex.write(oprot)
18948 
      oprot.writeFieldEnd()
18949 
    oprot.writeFieldStop()
18950 
    oprot.writeStructEnd()
18951 
 
18952 
  def validate(self):
18953 
    return
18954 
 
18955 
 
18956 
  def __repr__(self):
18957 
    L = ['%s=%r' % (key, value)
18958 
      for key, value in self.__dict__.iteritems()]
18959 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18960 
 
18961 
  def __eq__(self, other):
18962 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18963 
 
18964 
  def __ne__(self, other):
18965 
    return not (self == other)
18966 
 
2616 chandransh 18967 
class reshipOrder_args:
18968 
  """
18969 
  Attributes:
18970 
   - orderId
18971 
  """
2591 chandransh 18972 
 
2616 chandransh 18973 
  thrift_spec = (
18974 
    None, # 0
18975 
    (1, TType.I64, 'orderId', None, None, ), # 1
18976 
  )
18977 
 
18978 
  def __init__(self, orderId=None,):
18979 
    self.orderId = orderId
18980 
 
18981 
  def read(self, iprot):
18982 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18983 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18984 
      return
18985 
    iprot.readStructBegin()
18986 
    while True:
18987 
      (fname, ftype, fid) = iprot.readFieldBegin()
18988 
      if ftype == TType.STOP:
18989 
        break
18990 
      if fid == 1:
18991 
        if ftype == TType.I64:
18992 
          self.orderId = iprot.readI64();
18993 
        else:
18994 
          iprot.skip(ftype)
18995 
      else:
18996 
        iprot.skip(ftype)
18997 
      iprot.readFieldEnd()
18998 
    iprot.readStructEnd()
18999 
 
19000 
  def write(self, oprot):
19001 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19002 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19003 
      return
19004 
    oprot.writeStructBegin('reshipOrder_args')
3431 rajveer 19005 
    if self.orderId is not None:
2616 chandransh 19006 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
19007 
      oprot.writeI64(self.orderId)
19008 
      oprot.writeFieldEnd()
19009 
    oprot.writeFieldStop()
19010 
    oprot.writeStructEnd()
19011 
 
3431 rajveer 19012 
  def validate(self):
19013 
    return
19014 
 
19015 
 
2616 chandransh 19016 
  def __repr__(self):
19017 
    L = ['%s=%r' % (key, value)
19018 
      for key, value in self.__dict__.iteritems()]
19019 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19020 
 
19021 
  def __eq__(self, other):
19022 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19023 
 
19024 
  def __ne__(self, other):
19025 
    return not (self == other)
19026 
 
19027 
class reshipOrder_result:
19028 
  """
19029 
  Attributes:
19030 
   - success
19031 
   - ex
19032 
  """
19033 
 
19034 
  thrift_spec = (
19035 
    (0, TType.I64, 'success', None, None, ), # 0
19036 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
19037 
  )
19038 
 
19039 
  def __init__(self, success=None, ex=None,):
19040 
    self.success = success
19041 
    self.ex = ex
19042 
 
19043 
  def read(self, iprot):
19044 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19045 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19046 
      return
19047 
    iprot.readStructBegin()
19048 
    while True:
19049 
      (fname, ftype, fid) = iprot.readFieldBegin()
19050 
      if ftype == TType.STOP:
19051 
        break
19052 
      if fid == 0:
19053 
        if ftype == TType.I64:
19054 
          self.success = iprot.readI64();
19055 
        else:
19056 
          iprot.skip(ftype)
19057 
      elif fid == 1:
19058 
        if ftype == TType.STRUCT:
19059 
          self.ex = TransactionServiceException()
19060 
          self.ex.read(iprot)
19061 
        else:
19062 
          iprot.skip(ftype)
19063 
      else:
19064 
        iprot.skip(ftype)
19065 
      iprot.readFieldEnd()
19066 
    iprot.readStructEnd()
19067 
 
19068 
  def write(self, oprot):
19069 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19070 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19071 
      return
19072 
    oprot.writeStructBegin('reshipOrder_result')
3431 rajveer 19073 
    if self.success is not None:
2616 chandransh 19074 
      oprot.writeFieldBegin('success', TType.I64, 0)
19075 
      oprot.writeI64(self.success)
19076 
      oprot.writeFieldEnd()
3431 rajveer 19077 
    if self.ex is not None:
2616 chandransh 19078 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
19079 
      self.ex.write(oprot)
19080 
      oprot.writeFieldEnd()
19081 
    oprot.writeFieldStop()
19082 
    oprot.writeStructEnd()
19083 
 
3431 rajveer 19084 
  def validate(self):
19085 
    return
19086 
 
19087 
 
2616 chandransh 19088 
  def __repr__(self):
19089 
    L = ['%s=%r' % (key, value)
19090 
      for key, value in self.__dict__.iteritems()]
19091 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19092 
 
19093 
  def __eq__(self, other):
19094 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19095 
 
19096 
  def __ne__(self, other):
19097 
    return not (self == other)
19098 
 
19099 
class refundOrder_args:
19100 
  """
19101 
  Attributes:
19102 
   - orderId
3226 chandransh 19103 
   - refundedBy
19104 
   - reason
2616 chandransh 19105 
  """
19106 
 
19107 
  thrift_spec = (
19108 
    None, # 0
19109 
    (1, TType.I64, 'orderId', None, None, ), # 1
3226 chandransh 19110 
    (2, TType.STRING, 'refundedBy', None, None, ), # 2
19111 
    (3, TType.STRING, 'reason', None, None, ), # 3
2616 chandransh 19112 
  )
19113 
 
3226 chandransh 19114 
  def __init__(self, orderId=None, refundedBy=None, reason=None,):
2616 chandransh 19115 
    self.orderId = orderId
3226 chandransh 19116 
    self.refundedBy = refundedBy
19117 
    self.reason = reason
2616 chandransh 19118 
 
19119 
  def read(self, iprot):
19120 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19121 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19122 
      return
19123 
    iprot.readStructBegin()
19124 
    while True:
19125 
      (fname, ftype, fid) = iprot.readFieldBegin()
19126 
      if ftype == TType.STOP:
19127 
        break
19128 
      if fid == 1:
19129 
        if ftype == TType.I64:
19130 
          self.orderId = iprot.readI64();
19131 
        else:
19132 
          iprot.skip(ftype)
3226 chandransh 19133 
      elif fid == 2:
19134 
        if ftype == TType.STRING:
19135 
          self.refundedBy = iprot.readString();
19136 
        else:
19137 
          iprot.skip(ftype)
19138 
      elif fid == 3:
19139 
        if ftype == TType.STRING:
19140 
          self.reason = iprot.readString();
19141 
        else:
19142 
          iprot.skip(ftype)
2616 chandransh 19143 
      else:
19144 
        iprot.skip(ftype)
19145 
      iprot.readFieldEnd()
19146 
    iprot.readStructEnd()
19147 
 
19148 
  def write(self, oprot):
19149 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19150 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19151 
      return
19152 
    oprot.writeStructBegin('refundOrder_args')
3431 rajveer 19153 
    if self.orderId is not None:
2616 chandransh 19154 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
19155 
      oprot.writeI64(self.orderId)
19156 
      oprot.writeFieldEnd()
3431 rajveer 19157 
    if self.refundedBy is not None:
3226 chandransh 19158 
      oprot.writeFieldBegin('refundedBy', TType.STRING, 2)
19159 
      oprot.writeString(self.refundedBy)
19160 
      oprot.writeFieldEnd()
3431 rajveer 19161 
    if self.reason is not None:
3226 chandransh 19162 
      oprot.writeFieldBegin('reason', TType.STRING, 3)
19163 
      oprot.writeString(self.reason)
19164 
      oprot.writeFieldEnd()
2616 chandransh 19165 
    oprot.writeFieldStop()
19166 
    oprot.writeStructEnd()
19167 
 
3431 rajveer 19168 
  def validate(self):
19169 
    return
19170 
 
19171 
 
2616 chandransh 19172 
  def __repr__(self):
19173 
    L = ['%s=%r' % (key, value)
19174 
      for key, value in self.__dict__.iteritems()]
19175 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19176 
 
19177 
  def __eq__(self, other):
19178 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19179 
 
19180 
  def __ne__(self, other):
19181 
    return not (self == other)
19182 
 
19183 
class refundOrder_result:
19184 
  """
19185 
  Attributes:
19186 
   - success
19187 
   - ex
19188 
  """
19189 
 
19190 
  thrift_spec = (
19191 
    (0, TType.BOOL, 'success', None, None, ), # 0
19192 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
19193 
  )
19194 
 
19195 
  def __init__(self, success=None, ex=None,):
19196 
    self.success = success
19197 
    self.ex = ex
19198 
 
19199 
  def read(self, iprot):
19200 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19201 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19202 
      return
19203 
    iprot.readStructBegin()
19204 
    while True:
19205 
      (fname, ftype, fid) = iprot.readFieldBegin()
19206 
      if ftype == TType.STOP:
19207 
        break
19208 
      if fid == 0:
19209 
        if ftype == TType.BOOL:
19210 
          self.success = iprot.readBool();
19211 
        else:
19212 
          iprot.skip(ftype)
19213 
      elif fid == 1:
19214 
        if ftype == TType.STRUCT:
19215 
          self.ex = TransactionServiceException()
19216 
          self.ex.read(iprot)
19217 
        else:
19218 
          iprot.skip(ftype)
19219 
      else:
19220 
        iprot.skip(ftype)
19221 
      iprot.readFieldEnd()
19222 
    iprot.readStructEnd()
19223 
 
19224 
  def write(self, oprot):
19225 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19226 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19227 
      return
19228 
    oprot.writeStructBegin('refundOrder_result')
3431 rajveer 19229 
    if self.success is not None:
2616 chandransh 19230 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
19231 
      oprot.writeBool(self.success)
19232 
      oprot.writeFieldEnd()
3431 rajveer 19233 
    if self.ex is not None:
2616 chandransh 19234 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
19235 
      self.ex.write(oprot)
19236 
      oprot.writeFieldEnd()
19237 
    oprot.writeFieldStop()
19238 
    oprot.writeStructEnd()
19239 
 
3431 rajveer 19240 
  def validate(self):
19241 
    return
19242 
 
19243 
 
2616 chandransh 19244 
  def __repr__(self):
19245 
    L = ['%s=%r' % (key, value)
19246 
      for key, value in self.__dict__.iteritems()]
19247 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19248 
 
19249 
  def __eq__(self, other):
19250 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19251 
 
19252 
  def __ne__(self, other):
19253 
    return not (self == other)
19254 
 
2690 chandransh 19255 
class getReturnOrders_args:
19256 
  """
19257 
  Attributes:
19258 
   - warehouseId
19259 
   - fromDate
19260 
   - toDate
19261 
  """
2616 chandransh 19262 
 
2690 chandransh 19263 
  thrift_spec = (
19264 
    None, # 0
19265 
    (1, TType.I64, 'warehouseId', None, None, ), # 1
19266 
    (2, TType.I64, 'fromDate', None, None, ), # 2
19267 
    (3, TType.I64, 'toDate', None, None, ), # 3
19268 
  )
19269 
 
19270 
  def __init__(self, warehouseId=None, fromDate=None, toDate=None,):
19271 
    self.warehouseId = warehouseId
19272 
    self.fromDate = fromDate
19273 
    self.toDate = toDate
19274 
 
19275 
  def read(self, iprot):
19276 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19277 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19278 
      return
19279 
    iprot.readStructBegin()
19280 
    while True:
19281 
      (fname, ftype, fid) = iprot.readFieldBegin()
19282 
      if ftype == TType.STOP:
19283 
        break
19284 
      if fid == 1:
19285 
        if ftype == TType.I64:
19286 
          self.warehouseId = iprot.readI64();
19287 
        else:
19288 
          iprot.skip(ftype)
19289 
      elif fid == 2:
19290 
        if ftype == TType.I64:
19291 
          self.fromDate = iprot.readI64();
19292 
        else:
19293 
          iprot.skip(ftype)
19294 
      elif fid == 3:
19295 
        if ftype == TType.I64:
19296 
          self.toDate = iprot.readI64();
19297 
        else:
19298 
          iprot.skip(ftype)
19299 
      else:
19300 
        iprot.skip(ftype)
19301 
      iprot.readFieldEnd()
19302 
    iprot.readStructEnd()
19303 
 
19304 
  def write(self, oprot):
19305 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19306 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19307 
      return
19308 
    oprot.writeStructBegin('getReturnOrders_args')
3431 rajveer 19309 
    if self.warehouseId is not None:
2690 chandransh 19310 
      oprot.writeFieldBegin('warehouseId', TType.I64, 1)
19311 
      oprot.writeI64(self.warehouseId)
19312 
      oprot.writeFieldEnd()
3431 rajveer 19313 
    if self.fromDate is not None:
2690 chandransh 19314 
      oprot.writeFieldBegin('fromDate', TType.I64, 2)
19315 
      oprot.writeI64(self.fromDate)
19316 
      oprot.writeFieldEnd()
3431 rajveer 19317 
    if self.toDate is not None:
2690 chandransh 19318 
      oprot.writeFieldBegin('toDate', TType.I64, 3)
19319 
      oprot.writeI64(self.toDate)
19320 
      oprot.writeFieldEnd()
19321 
    oprot.writeFieldStop()
19322 
    oprot.writeStructEnd()
19323 
 
3431 rajveer 19324 
  def validate(self):
19325 
    return
19326 
 
19327 
 
2690 chandransh 19328 
  def __repr__(self):
19329 
    L = ['%s=%r' % (key, value)
19330 
      for key, value in self.__dict__.iteritems()]
19331 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19332 
 
19333 
  def __eq__(self, other):
19334 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19335 
 
19336 
  def __ne__(self, other):
19337 
    return not (self == other)
19338 
 
19339 
class getReturnOrders_result:
19340 
  """
19341 
  Attributes:
19342 
   - success
19343 
  """
19344 
 
19345 
  thrift_spec = (
19346 
    (0, TType.LIST, 'success', (TType.STRUCT,(ReturnOrder, ReturnOrder.thrift_spec)), None, ), # 0
19347 
  )
19348 
 
19349 
  def __init__(self, success=None,):
19350 
    self.success = success
19351 
 
19352 
  def read(self, iprot):
19353 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19354 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19355 
      return
19356 
    iprot.readStructBegin()
19357 
    while True:
19358 
      (fname, ftype, fid) = iprot.readFieldBegin()
19359 
      if ftype == TType.STOP:
19360 
        break
19361 
      if fid == 0:
19362 
        if ftype == TType.LIST:
19363 
          self.success = []
6188 rajveer 19364 
          (_etype442, _size439) = iprot.readListBegin()
19365 
          for _i443 in xrange(_size439):
19366 
            _elem444 = ReturnOrder()
19367 
            _elem444.read(iprot)
19368 
            self.success.append(_elem444)
2690 chandransh 19369 
          iprot.readListEnd()
19370 
        else:
19371 
          iprot.skip(ftype)
19372 
      else:
19373 
        iprot.skip(ftype)
19374 
      iprot.readFieldEnd()
19375 
    iprot.readStructEnd()
19376 
 
19377 
  def write(self, oprot):
19378 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19379 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19380 
      return
19381 
    oprot.writeStructBegin('getReturnOrders_result')
3431 rajveer 19382 
    if self.success is not None:
2690 chandransh 19383 
      oprot.writeFieldBegin('success', TType.LIST, 0)
19384 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 19385 
      for iter445 in self.success:
19386 
        iter445.write(oprot)
2690 chandransh 19387 
      oprot.writeListEnd()
19388 
      oprot.writeFieldEnd()
19389 
    oprot.writeFieldStop()
19390 
    oprot.writeStructEnd()
19391 
 
3431 rajveer 19392 
  def validate(self):
19393 
    return
19394 
 
19395 
 
2690 chandransh 19396 
  def __repr__(self):
19397 
    L = ['%s=%r' % (key, value)
19398 
      for key, value in self.__dict__.iteritems()]
19399 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19400 
 
19401 
  def __eq__(self, other):
19402 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19403 
 
19404 
  def __ne__(self, other):
19405 
    return not (self == other)
19406 
 
5481 phani.kuma 19407 
class getAllReturnOrders_args:
19408 
  """
19409 
  Attributes:
19410 
   - onlyNotProcessed
19411 
   - fromDate
19412 
   - toDate
19413 
  """
19414 
 
19415 
  thrift_spec = (
19416 
    None, # 0
19417 
    (1, TType.BOOL, 'onlyNotProcessed', None, None, ), # 1
19418 
    (2, TType.I64, 'fromDate', None, None, ), # 2
19419 
    (3, TType.I64, 'toDate', None, None, ), # 3
19420 
  )
19421 
 
19422 
  def __init__(self, onlyNotProcessed=None, fromDate=None, toDate=None,):
19423 
    self.onlyNotProcessed = onlyNotProcessed
19424 
    self.fromDate = fromDate
19425 
    self.toDate = toDate
19426 
 
19427 
  def read(self, iprot):
19428 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19429 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19430 
      return
19431 
    iprot.readStructBegin()
19432 
    while True:
19433 
      (fname, ftype, fid) = iprot.readFieldBegin()
19434 
      if ftype == TType.STOP:
19435 
        break
19436 
      if fid == 1:
19437 
        if ftype == TType.BOOL:
19438 
          self.onlyNotProcessed = iprot.readBool();
19439 
        else:
19440 
          iprot.skip(ftype)
19441 
      elif fid == 2:
19442 
        if ftype == TType.I64:
19443 
          self.fromDate = iprot.readI64();
19444 
        else:
19445 
          iprot.skip(ftype)
19446 
      elif fid == 3:
19447 
        if ftype == TType.I64:
19448 
          self.toDate = iprot.readI64();
19449 
        else:
19450 
          iprot.skip(ftype)
19451 
      else:
19452 
        iprot.skip(ftype)
19453 
      iprot.readFieldEnd()
19454 
    iprot.readStructEnd()
19455 
 
19456 
  def write(self, oprot):
19457 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19458 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19459 
      return
19460 
    oprot.writeStructBegin('getAllReturnOrders_args')
19461 
    if self.onlyNotProcessed is not None:
19462 
      oprot.writeFieldBegin('onlyNotProcessed', TType.BOOL, 1)
19463 
      oprot.writeBool(self.onlyNotProcessed)
19464 
      oprot.writeFieldEnd()
19465 
    if self.fromDate is not None:
19466 
      oprot.writeFieldBegin('fromDate', TType.I64, 2)
19467 
      oprot.writeI64(self.fromDate)
19468 
      oprot.writeFieldEnd()
19469 
    if self.toDate is not None:
19470 
      oprot.writeFieldBegin('toDate', TType.I64, 3)
19471 
      oprot.writeI64(self.toDate)
19472 
      oprot.writeFieldEnd()
19473 
    oprot.writeFieldStop()
19474 
    oprot.writeStructEnd()
19475 
 
19476 
  def validate(self):
19477 
    return
19478 
 
19479 
 
19480 
  def __repr__(self):
19481 
    L = ['%s=%r' % (key, value)
19482 
      for key, value in self.__dict__.iteritems()]
19483 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19484 
 
19485 
  def __eq__(self, other):
19486 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19487 
 
19488 
  def __ne__(self, other):
19489 
    return not (self == other)
19490 
 
19491 
class getAllReturnOrders_result:
19492 
  """
19493 
  Attributes:
19494 
   - success
19495 
  """
19496 
 
19497 
  thrift_spec = (
19498 
    (0, TType.LIST, 'success', (TType.STRUCT,(ReturnOrder, ReturnOrder.thrift_spec)), None, ), # 0
19499 
  )
19500 
 
19501 
  def __init__(self, success=None,):
19502 
    self.success = success
19503 
 
19504 
  def read(self, iprot):
19505 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19506 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19507 
      return
19508 
    iprot.readStructBegin()
19509 
    while True:
19510 
      (fname, ftype, fid) = iprot.readFieldBegin()
19511 
      if ftype == TType.STOP:
19512 
        break
19513 
      if fid == 0:
19514 
        if ftype == TType.LIST:
19515 
          self.success = []
6188 rajveer 19516 
          (_etype449, _size446) = iprot.readListBegin()
19517 
          for _i450 in xrange(_size446):
19518 
            _elem451 = ReturnOrder()
19519 
            _elem451.read(iprot)
19520 
            self.success.append(_elem451)
5481 phani.kuma 19521 
          iprot.readListEnd()
19522 
        else:
19523 
          iprot.skip(ftype)
19524 
      else:
19525 
        iprot.skip(ftype)
19526 
      iprot.readFieldEnd()
19527 
    iprot.readStructEnd()
19528 
 
19529 
  def write(self, oprot):
19530 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19531 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19532 
      return
19533 
    oprot.writeStructBegin('getAllReturnOrders_result')
19534 
    if self.success is not None:
19535 
      oprot.writeFieldBegin('success', TType.LIST, 0)
19536 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 19537 
      for iter452 in self.success:
19538 
        iter452.write(oprot)
5481 phani.kuma 19539 
      oprot.writeListEnd()
19540 
      oprot.writeFieldEnd()
19541 
    oprot.writeFieldStop()
19542 
    oprot.writeStructEnd()
19543 
 
19544 
  def validate(self):
19545 
    return
19546 
 
19547 
 
19548 
  def __repr__(self):
19549 
    L = ['%s=%r' % (key, value)
19550 
      for key, value in self.__dict__.iteritems()]
19551 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19552 
 
19553 
  def __eq__(self, other):
19554 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19555 
 
19556 
  def __ne__(self, other):
19557 
    return not (self == other)
19558 
 
2700 chandransh 19559 
class getReturnOrder_args:
19560 
  """
19561 
  Attributes:
19562 
   - id
19563 
  """
19564 
 
19565 
  thrift_spec = (
19566 
    None, # 0
19567 
    (1, TType.I64, 'id', None, None, ), # 1
19568 
  )
19569 
 
19570 
  def __init__(self, id=None,):
19571 
    self.id = id
19572 
 
19573 
  def read(self, iprot):
19574 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19575 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19576 
      return
19577 
    iprot.readStructBegin()
19578 
    while True:
19579 
      (fname, ftype, fid) = iprot.readFieldBegin()
19580 
      if ftype == TType.STOP:
19581 
        break
19582 
      if fid == 1:
19583 
        if ftype == TType.I64:
19584 
          self.id = iprot.readI64();
19585 
        else:
19586 
          iprot.skip(ftype)
19587 
      else:
19588 
        iprot.skip(ftype)
19589 
      iprot.readFieldEnd()
19590 
    iprot.readStructEnd()
19591 
 
19592 
  def write(self, oprot):
19593 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19594 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19595 
      return
19596 
    oprot.writeStructBegin('getReturnOrder_args')
3431 rajveer 19597 
    if self.id is not None:
2700 chandransh 19598 
      oprot.writeFieldBegin('id', TType.I64, 1)
19599 
      oprot.writeI64(self.id)
19600 
      oprot.writeFieldEnd()
19601 
    oprot.writeFieldStop()
19602 
    oprot.writeStructEnd()
19603 
 
3431 rajveer 19604 
  def validate(self):
19605 
    return
19606 
 
19607 
 
2700 chandransh 19608 
  def __repr__(self):
19609 
    L = ['%s=%r' % (key, value)
19610 
      for key, value in self.__dict__.iteritems()]
19611 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19612 
 
19613 
  def __eq__(self, other):
19614 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19615 
 
19616 
  def __ne__(self, other):
19617 
    return not (self == other)
19618 
 
19619 
class getReturnOrder_result:
19620 
  """
19621 
  Attributes:
19622 
   - success
19623 
   - ex
19624 
  """
19625 
 
19626 
  thrift_spec = (
19627 
    (0, TType.STRUCT, 'success', (ReturnOrder, ReturnOrder.thrift_spec), None, ), # 0
19628 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
19629 
  )
19630 
 
19631 
  def __init__(self, success=None, ex=None,):
19632 
    self.success = success
19633 
    self.ex = ex
19634 
 
19635 
  def read(self, iprot):
19636 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19637 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19638 
      return
19639 
    iprot.readStructBegin()
19640 
    while True:
19641 
      (fname, ftype, fid) = iprot.readFieldBegin()
19642 
      if ftype == TType.STOP:
19643 
        break
19644 
      if fid == 0:
19645 
        if ftype == TType.STRUCT:
19646 
          self.success = ReturnOrder()
19647 
          self.success.read(iprot)
19648 
        else:
19649 
          iprot.skip(ftype)
19650 
      elif fid == 1:
19651 
        if ftype == TType.STRUCT:
19652 
          self.ex = TransactionServiceException()
19653 
          self.ex.read(iprot)
19654 
        else:
19655 
          iprot.skip(ftype)
19656 
      else:
19657 
        iprot.skip(ftype)
19658 
      iprot.readFieldEnd()
19659 
    iprot.readStructEnd()
19660 
 
19661 
  def write(self, oprot):
19662 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19663 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19664 
      return
19665 
    oprot.writeStructBegin('getReturnOrder_result')
3431 rajveer 19666 
    if self.success is not None:
2700 chandransh 19667 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
19668 
      self.success.write(oprot)
19669 
      oprot.writeFieldEnd()
3431 rajveer 19670 
    if self.ex is not None:
2700 chandransh 19671 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
19672 
      self.ex.write(oprot)
19673 
      oprot.writeFieldEnd()
19674 
    oprot.writeFieldStop()
19675 
    oprot.writeStructEnd()
19676 
 
3431 rajveer 19677 
  def validate(self):
19678 
    return
19679 
 
19680 
 
2700 chandransh 19681 
  def __repr__(self):
19682 
    L = ['%s=%r' % (key, value)
19683 
      for key, value in self.__dict__.iteritems()]
19684 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19685 
 
19686 
  def __eq__(self, other):
19687 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19688 
 
19689 
  def __ne__(self, other):
19690 
    return not (self == other)
19691 
 
2690 chandransh 19692 
class processReturn_args:
19693 
  """
19694 
  Attributes:
19695 
   - returnOrderId
19696 
  """
19697 
 
19698 
  thrift_spec = (
19699 
    None, # 0
19700 
    (1, TType.I64, 'returnOrderId', None, None, ), # 1
19701 
  )
19702 
 
19703 
  def __init__(self, returnOrderId=None,):
19704 
    self.returnOrderId = returnOrderId
19705 
 
19706 
  def read(self, iprot):
19707 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19708 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19709 
      return
19710 
    iprot.readStructBegin()
19711 
    while True:
19712 
      (fname, ftype, fid) = iprot.readFieldBegin()
19713 
      if ftype == TType.STOP:
19714 
        break
19715 
      if fid == 1:
19716 
        if ftype == TType.I64:
19717 
          self.returnOrderId = iprot.readI64();
19718 
        else:
19719 
          iprot.skip(ftype)
19720 
      else:
19721 
        iprot.skip(ftype)
19722 
      iprot.readFieldEnd()
19723 
    iprot.readStructEnd()
19724 
 
19725 
  def write(self, oprot):
19726 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19727 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19728 
      return
19729 
    oprot.writeStructBegin('processReturn_args')
3431 rajveer 19730 
    if self.returnOrderId is not None:
2690 chandransh 19731 
      oprot.writeFieldBegin('returnOrderId', TType.I64, 1)
19732 
      oprot.writeI64(self.returnOrderId)
19733 
      oprot.writeFieldEnd()
19734 
    oprot.writeFieldStop()
19735 
    oprot.writeStructEnd()
19736 
 
3431 rajveer 19737 
  def validate(self):
19738 
    return
19739 
 
19740 
 
2690 chandransh 19741 
  def __repr__(self):
19742 
    L = ['%s=%r' % (key, value)
19743 
      for key, value in self.__dict__.iteritems()]
19744 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19745 
 
19746 
  def __eq__(self, other):
19747 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19748 
 
19749 
  def __ne__(self, other):
19750 
    return not (self == other)
19751 
 
19752 
class processReturn_result:
19753 
  """
19754 
  Attributes:
19755 
   - ex
19756 
  """
19757 
 
19758 
  thrift_spec = (
19759 
    None, # 0
19760 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
19761 
  )
19762 
 
19763 
  def __init__(self, ex=None,):
19764 
    self.ex = ex
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.STRUCT:
19777 
          self.ex = TransactionServiceException()
19778 
          self.ex.read(iprot)
19779 
        else:
19780 
          iprot.skip(ftype)
19781 
      else:
19782 
        iprot.skip(ftype)
19783 
      iprot.readFieldEnd()
19784 
    iprot.readStructEnd()
19785 
 
19786 
  def write(self, oprot):
19787 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19788 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19789 
      return
19790 
    oprot.writeStructBegin('processReturn_result')
3431 rajveer 19791 
    if self.ex is not None:
2690 chandransh 19792 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
19793 
      self.ex.write(oprot)
19794 
      oprot.writeFieldEnd()
19795 
    oprot.writeFieldStop()
19796 
    oprot.writeStructEnd()
19797 
 
3431 rajveer 19798 
  def validate(self):
19799 
    return
19800 
 
19801 
 
2690 chandransh 19802 
  def __repr__(self):
19803 
    L = ['%s=%r' % (key, value)
19804 
      for key, value in self.__dict__.iteritems()]
19805 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19806 
 
19807 
  def __eq__(self, other):
19808 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19809 
 
19810 
  def __ne__(self, other):
19811 
    return not (self == other)
19812 
 
3451 chandransh 19813 
class updateWeight_args:
19814 
  """
19815 
  Attributes:
19816 
   - orderId
19817 
   - weight
19818 
  """
19819 
 
19820 
  thrift_spec = (
19821 
    None, # 0
19822 
    (1, TType.I64, 'orderId', None, None, ), # 1
19823 
    (2, TType.DOUBLE, 'weight', None, None, ), # 2
19824 
  )
19825 
 
19826 
  def __init__(self, orderId=None, weight=None,):
19827 
    self.orderId = orderId
19828 
    self.weight = weight
19829 
 
19830 
  def read(self, iprot):
19831 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19832 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19833 
      return
19834 
    iprot.readStructBegin()
19835 
    while True:
19836 
      (fname, ftype, fid) = iprot.readFieldBegin()
19837 
      if ftype == TType.STOP:
19838 
        break
19839 
      if fid == 1:
19840 
        if ftype == TType.I64:
19841 
          self.orderId = iprot.readI64();
19842 
        else:
19843 
          iprot.skip(ftype)
19844 
      elif fid == 2:
19845 
        if ftype == TType.DOUBLE:
19846 
          self.weight = iprot.readDouble();
19847 
        else:
19848 
          iprot.skip(ftype)
19849 
      else:
19850 
        iprot.skip(ftype)
19851 
      iprot.readFieldEnd()
19852 
    iprot.readStructEnd()
19853 
 
19854 
  def write(self, oprot):
19855 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19856 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19857 
      return
19858 
    oprot.writeStructBegin('updateWeight_args')
19859 
    if self.orderId is not None:
19860 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
19861 
      oprot.writeI64(self.orderId)
19862 
      oprot.writeFieldEnd()
19863 
    if self.weight is not None:
19864 
      oprot.writeFieldBegin('weight', TType.DOUBLE, 2)
19865 
      oprot.writeDouble(self.weight)
19866 
      oprot.writeFieldEnd()
19867 
    oprot.writeFieldStop()
19868 
    oprot.writeStructEnd()
19869 
 
19870 
  def validate(self):
19871 
    return
19872 
 
19873 
 
19874 
  def __repr__(self):
19875 
    L = ['%s=%r' % (key, value)
19876 
      for key, value in self.__dict__.iteritems()]
19877 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19878 
 
19879 
  def __eq__(self, other):
19880 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19881 
 
19882 
  def __ne__(self, other):
19883 
    return not (self == other)
19884 
 
19885 
class updateWeight_result:
19886 
  """
19887 
  Attributes:
19888 
   - success
19889 
   - ex
19890 
  """
19891 
 
19892 
  thrift_spec = (
19893 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
19894 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
19895 
  )
19896 
 
19897 
  def __init__(self, success=None, ex=None,):
19898 
    self.success = success
19899 
    self.ex = ex
19900 
 
19901 
  def read(self, iprot):
19902 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19903 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19904 
      return
19905 
    iprot.readStructBegin()
19906 
    while True:
19907 
      (fname, ftype, fid) = iprot.readFieldBegin()
19908 
      if ftype == TType.STOP:
19909 
        break
19910 
      if fid == 0:
19911 
        if ftype == TType.STRUCT:
19912 
          self.success = Order()
19913 
          self.success.read(iprot)
19914 
        else:
19915 
          iprot.skip(ftype)
19916 
      elif fid == 1:
19917 
        if ftype == TType.STRUCT:
19918 
          self.ex = TransactionServiceException()
19919 
          self.ex.read(iprot)
19920 
        else:
19921 
          iprot.skip(ftype)
19922 
      else:
19923 
        iprot.skip(ftype)
19924 
      iprot.readFieldEnd()
19925 
    iprot.readStructEnd()
19926 
 
19927 
  def write(self, oprot):
19928 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19929 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19930 
      return
19931 
    oprot.writeStructBegin('updateWeight_result')
19932 
    if self.success is not None:
19933 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
19934 
      self.success.write(oprot)
19935 
      oprot.writeFieldEnd()
19936 
    if self.ex is not None:
19937 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
19938 
      self.ex.write(oprot)
19939 
      oprot.writeFieldEnd()
19940 
    oprot.writeFieldStop()
19941 
    oprot.writeStructEnd()
19942 
 
19943 
  def validate(self):
19944 
    return
19945 
 
19946 
 
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)
3469 chandransh 19957 
 
19958 
class changeItem_args:
19959 
  """
19960 
  Attributes:
19961 
   - orderId
19962 
   - itemId
19963 
  """
19964 
 
19965 
  thrift_spec = (
19966 
    None, # 0
19967 
    (1, TType.I64, 'orderId', None, None, ), # 1
19968 
    (2, TType.I64, 'itemId', None, None, ), # 2
19969 
  )
19970 
 
19971 
  def __init__(self, orderId=None, itemId=None,):
19972 
    self.orderId = orderId
19973 
    self.itemId = itemId
19974 
 
19975 
  def read(self, iprot):
19976 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19977 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19978 
      return
19979 
    iprot.readStructBegin()
19980 
    while True:
19981 
      (fname, ftype, fid) = iprot.readFieldBegin()
19982 
      if ftype == TType.STOP:
19983 
        break
19984 
      if fid == 1:
19985 
        if ftype == TType.I64:
19986 
          self.orderId = iprot.readI64();
19987 
        else:
19988 
          iprot.skip(ftype)
19989 
      elif fid == 2:
19990 
        if ftype == TType.I64:
19991 
          self.itemId = iprot.readI64();
19992 
        else:
19993 
          iprot.skip(ftype)
19994 
      else:
19995 
        iprot.skip(ftype)
19996 
      iprot.readFieldEnd()
19997 
    iprot.readStructEnd()
19998 
 
19999 
  def write(self, oprot):
20000 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20001 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20002 
      return
20003 
    oprot.writeStructBegin('changeItem_args')
20004 
    if self.orderId is not None:
20005 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
20006 
      oprot.writeI64(self.orderId)
20007 
      oprot.writeFieldEnd()
20008 
    if self.itemId is not None:
20009 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
20010 
      oprot.writeI64(self.itemId)
20011 
      oprot.writeFieldEnd()
20012 
    oprot.writeFieldStop()
20013 
    oprot.writeStructEnd()
20014 
 
20015 
  def validate(self):
20016 
    return
20017 
 
20018 
 
20019 
  def __repr__(self):
20020 
    L = ['%s=%r' % (key, value)
20021 
      for key, value in self.__dict__.iteritems()]
20022 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20023 
 
20024 
  def __eq__(self, other):
20025 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20026 
 
20027 
  def __ne__(self, other):
20028 
    return not (self == other)
20029 
 
20030 
class changeItem_result:
20031 
  """
20032 
  Attributes:
20033 
   - success
20034 
   - ex
20035 
  """
20036 
 
20037 
  thrift_spec = (
20038 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
20039 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
20040 
  )
20041 
 
20042 
  def __init__(self, success=None, ex=None,):
20043 
    self.success = success
20044 
    self.ex = ex
20045 
 
20046 
  def read(self, iprot):
20047 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20048 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20049 
      return
20050 
    iprot.readStructBegin()
20051 
    while True:
20052 
      (fname, ftype, fid) = iprot.readFieldBegin()
20053 
      if ftype == TType.STOP:
20054 
        break
20055 
      if fid == 0:
20056 
        if ftype == TType.STRUCT:
20057 
          self.success = Order()
20058 
          self.success.read(iprot)
20059 
        else:
20060 
          iprot.skip(ftype)
20061 
      elif fid == 1:
20062 
        if ftype == TType.STRUCT:
20063 
          self.ex = TransactionServiceException()
20064 
          self.ex.read(iprot)
20065 
        else:
20066 
          iprot.skip(ftype)
20067 
      else:
20068 
        iprot.skip(ftype)
20069 
      iprot.readFieldEnd()
20070 
    iprot.readStructEnd()
20071 
 
20072 
  def write(self, oprot):
20073 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20074 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20075 
      return
20076 
    oprot.writeStructBegin('changeItem_result')
20077 
    if self.success is not None:
20078 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
20079 
      self.success.write(oprot)
20080 
      oprot.writeFieldEnd()
20081 
    if self.ex is not None:
20082 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
20083 
      self.ex.write(oprot)
20084 
      oprot.writeFieldEnd()
20085 
    oprot.writeFieldStop()
20086 
    oprot.writeStructEnd()
20087 
 
20088 
  def validate(self):
20089 
    return
20090 
 
20091 
 
20092 
  def __repr__(self):
20093 
    L = ['%s=%r' % (key, value)
20094 
      for key, value in self.__dict__.iteritems()]
20095 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20096 
 
20097 
  def __eq__(self, other):
20098 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20099 
 
20100 
  def __ne__(self, other):
20101 
    return not (self == other)
20102 
 
20103 
class shiftToWarehouse_args:
20104 
  """
20105 
  Attributes:
20106 
   - orderId
20107 
   - warehouseId
20108 
  """
20109 
 
20110 
  thrift_spec = (
20111 
    None, # 0
20112 
    (1, TType.I64, 'orderId', None, None, ), # 1
20113 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
20114 
  )
20115 
 
20116 
  def __init__(self, orderId=None, warehouseId=None,):
20117 
    self.orderId = orderId
20118 
    self.warehouseId = warehouseId
20119 
 
20120 
  def read(self, iprot):
20121 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20122 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20123 
      return
20124 
    iprot.readStructBegin()
20125 
    while True:
20126 
      (fname, ftype, fid) = iprot.readFieldBegin()
20127 
      if ftype == TType.STOP:
20128 
        break
20129 
      if fid == 1:
20130 
        if ftype == TType.I64:
20131 
          self.orderId = iprot.readI64();
20132 
        else:
20133 
          iprot.skip(ftype)
20134 
      elif fid == 2:
20135 
        if ftype == TType.I64:
20136 
          self.warehouseId = iprot.readI64();
20137 
        else:
20138 
          iprot.skip(ftype)
20139 
      else:
20140 
        iprot.skip(ftype)
20141 
      iprot.readFieldEnd()
20142 
    iprot.readStructEnd()
20143 
 
20144 
  def write(self, oprot):
20145 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20146 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20147 
      return
20148 
    oprot.writeStructBegin('shiftToWarehouse_args')
20149 
    if self.orderId is not None:
20150 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
20151 
      oprot.writeI64(self.orderId)
20152 
      oprot.writeFieldEnd()
20153 
    if self.warehouseId is not None:
20154 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
20155 
      oprot.writeI64(self.warehouseId)
20156 
      oprot.writeFieldEnd()
20157 
    oprot.writeFieldStop()
20158 
    oprot.writeStructEnd()
20159 
 
20160 
  def validate(self):
20161 
    return
20162 
 
20163 
 
20164 
  def __repr__(self):
20165 
    L = ['%s=%r' % (key, value)
20166 
      for key, value in self.__dict__.iteritems()]
20167 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20168 
 
20169 
  def __eq__(self, other):
20170 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20171 
 
20172 
  def __ne__(self, other):
20173 
    return not (self == other)
20174 
 
20175 
class shiftToWarehouse_result:
20176 
  """
20177 
  Attributes:
20178 
   - success
20179 
   - ex
20180 
  """
20181 
 
20182 
  thrift_spec = (
20183 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
20184 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
20185 
  )
20186 
 
20187 
  def __init__(self, success=None, ex=None,):
20188 
    self.success = success
20189 
    self.ex = ex
20190 
 
20191 
  def read(self, iprot):
20192 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20193 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20194 
      return
20195 
    iprot.readStructBegin()
20196 
    while True:
20197 
      (fname, ftype, fid) = iprot.readFieldBegin()
20198 
      if ftype == TType.STOP:
20199 
        break
20200 
      if fid == 0:
20201 
        if ftype == TType.STRUCT:
20202 
          self.success = Order()
20203 
          self.success.read(iprot)
20204 
        else:
20205 
          iprot.skip(ftype)
20206 
      elif fid == 1:
20207 
        if ftype == TType.STRUCT:
20208 
          self.ex = TransactionServiceException()
20209 
          self.ex.read(iprot)
20210 
        else:
20211 
          iprot.skip(ftype)
20212 
      else:
20213 
        iprot.skip(ftype)
20214 
      iprot.readFieldEnd()
20215 
    iprot.readStructEnd()
20216 
 
20217 
  def write(self, oprot):
20218 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20219 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20220 
      return
20221 
    oprot.writeStructBegin('shiftToWarehouse_result')
20222 
    if self.success is not None:
20223 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
20224 
      self.success.write(oprot)
20225 
      oprot.writeFieldEnd()
20226 
    if self.ex is not None:
20227 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
20228 
      self.ex.write(oprot)
20229 
      oprot.writeFieldEnd()
20230 
    oprot.writeFieldStop()
20231 
    oprot.writeStructEnd()
20232 
 
20233 
  def validate(self):
20234 
    return
20235 
 
20236 
 
20237 
  def __repr__(self):
20238 
    L = ['%s=%r' % (key, value)
20239 
      for key, value in self.__dict__.iteritems()]
20240 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20241 
 
20242 
  def __eq__(self, other):
20243 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20244 
 
20245 
  def __ne__(self, other):
20246 
    return not (self == other)
3553 chandransh 20247 
 
20248 
class addDelayReason_args:
20249 
  """
20250 
  Attributes:
20251 
   - orderId
20252 
   - delayReason
3986 chandransh 20253 
   - furtherDelay
4647 rajveer 20254 
   - delayReasonText
3553 chandransh 20255 
  """
20256 
 
20257 
  thrift_spec = (
20258 
    None, # 0
20259 
    (1, TType.I64, 'orderId', None, None, ), # 1
20260 
    (2, TType.I32, 'delayReason', None, None, ), # 2
3986 chandransh 20261 
    (3, TType.I64, 'furtherDelay', None, None, ), # 3
4647 rajveer 20262 
    (4, TType.STRING, 'delayReasonText', None, None, ), # 4
3553 chandransh 20263 
  )
20264 
 
4647 rajveer 20265 
  def __init__(self, orderId=None, delayReason=None, furtherDelay=None, delayReasonText=None,):
3553 chandransh 20266 
    self.orderId = orderId
20267 
    self.delayReason = delayReason
3986 chandransh 20268 
    self.furtherDelay = furtherDelay
4647 rajveer 20269 
    self.delayReasonText = delayReasonText
3553 chandransh 20270 
 
20271 
  def read(self, iprot):
20272 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20273 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20274 
      return
20275 
    iprot.readStructBegin()
20276 
    while True:
20277 
      (fname, ftype, fid) = iprot.readFieldBegin()
20278 
      if ftype == TType.STOP:
20279 
        break
20280 
      if fid == 1:
20281 
        if ftype == TType.I64:
20282 
          self.orderId = iprot.readI64();
20283 
        else:
20284 
          iprot.skip(ftype)
20285 
      elif fid == 2:
20286 
        if ftype == TType.I32:
20287 
          self.delayReason = iprot.readI32();
20288 
        else:
20289 
          iprot.skip(ftype)
3986 chandransh 20290 
      elif fid == 3:
20291 
        if ftype == TType.I64:
20292 
          self.furtherDelay = iprot.readI64();
20293 
        else:
20294 
          iprot.skip(ftype)
4647 rajveer 20295 
      elif fid == 4:
20296 
        if ftype == TType.STRING:
20297 
          self.delayReasonText = iprot.readString();
20298 
        else:
20299 
          iprot.skip(ftype)
3553 chandransh 20300 
      else:
20301 
        iprot.skip(ftype)
20302 
      iprot.readFieldEnd()
20303 
    iprot.readStructEnd()
20304 
 
20305 
  def write(self, oprot):
20306 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20307 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20308 
      return
20309 
    oprot.writeStructBegin('addDelayReason_args')
20310 
    if self.orderId is not None:
20311 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
20312 
      oprot.writeI64(self.orderId)
20313 
      oprot.writeFieldEnd()
20314 
    if self.delayReason is not None:
20315 
      oprot.writeFieldBegin('delayReason', TType.I32, 2)
20316 
      oprot.writeI32(self.delayReason)
20317 
      oprot.writeFieldEnd()
3986 chandransh 20318 
    if self.furtherDelay is not None:
20319 
      oprot.writeFieldBegin('furtherDelay', TType.I64, 3)
20320 
      oprot.writeI64(self.furtherDelay)
20321 
      oprot.writeFieldEnd()
4647 rajveer 20322 
    if self.delayReasonText is not None:
20323 
      oprot.writeFieldBegin('delayReasonText', TType.STRING, 4)
20324 
      oprot.writeString(self.delayReasonText)
20325 
      oprot.writeFieldEnd()
3553 chandransh 20326 
    oprot.writeFieldStop()
20327 
    oprot.writeStructEnd()
20328 
 
20329 
  def validate(self):
20330 
    return
20331 
 
20332 
 
20333 
  def __repr__(self):
20334 
    L = ['%s=%r' % (key, value)
20335 
      for key, value in self.__dict__.iteritems()]
20336 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20337 
 
20338 
  def __eq__(self, other):
20339 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20340 
 
20341 
  def __ne__(self, other):
20342 
    return not (self == other)
20343 
 
20344 
class addDelayReason_result:
20345 
  """
20346 
  Attributes:
20347 
   - success
20348 
   - ex
20349 
  """
20350 
 
20351 
  thrift_spec = (
20352 
    (0, TType.BOOL, 'success', None, None, ), # 0
20353 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
20354 
  )
20355 
 
20356 
  def __init__(self, success=None, ex=None,):
20357 
    self.success = success
20358 
    self.ex = ex
20359 
 
20360 
  def read(self, iprot):
20361 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20362 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20363 
      return
20364 
    iprot.readStructBegin()
20365 
    while True:
20366 
      (fname, ftype, fid) = iprot.readFieldBegin()
20367 
      if ftype == TType.STOP:
20368 
        break
20369 
      if fid == 0:
20370 
        if ftype == TType.BOOL:
20371 
          self.success = iprot.readBool();
20372 
        else:
20373 
          iprot.skip(ftype)
20374 
      elif fid == 1:
20375 
        if ftype == TType.STRUCT:
20376 
          self.ex = TransactionServiceException()
20377 
          self.ex.read(iprot)
20378 
        else:
20379 
          iprot.skip(ftype)
20380 
      else:
20381 
        iprot.skip(ftype)
20382 
      iprot.readFieldEnd()
20383 
    iprot.readStructEnd()
20384 
 
20385 
  def write(self, oprot):
20386 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20387 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20388 
      return
20389 
    oprot.writeStructBegin('addDelayReason_result')
20390 
    if self.success is not None:
20391 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
20392 
      oprot.writeBool(self.success)
20393 
      oprot.writeFieldEnd()
20394 
    if self.ex is not None:
20395 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
20396 
      self.ex.write(oprot)
20397 
      oprot.writeFieldEnd()
20398 
    oprot.writeFieldStop()
20399 
    oprot.writeStructEnd()
20400 
 
20401 
  def validate(self):
20402 
    return
20403 
 
20404 
 
20405 
  def __repr__(self):
20406 
    L = ['%s=%r' % (key, value)
20407 
      for key, value in self.__dict__.iteritems()]
20408 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20409 
 
20410 
  def __eq__(self, other):
20411 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20412 
 
20413 
  def __ne__(self, other):
20414 
    return not (self == other)
3956 chandransh 20415 
 
20416 
class reconcileCodCollection_args:
20417 
  """
20418 
  Attributes:
20419 
   - collectedAmountMap
20420 
   - xferBy
20421 
   - xferTxnId
20422 
   - xferDate
20423 
  """
20424 
 
20425 
  thrift_spec = (
20426 
    None, # 0
20427 
    (1, TType.MAP, 'collectedAmountMap', (TType.STRING,None,TType.DOUBLE,None), None, ), # 1
20428 
    (2, TType.STRING, 'xferBy', None, None, ), # 2
20429 
    (3, TType.STRING, 'xferTxnId', None, None, ), # 3
20430 
    (4, TType.I64, 'xferDate', None, None, ), # 4
20431 
  )
20432 
 
20433 
  def __init__(self, collectedAmountMap=None, xferBy=None, xferTxnId=None, xferDate=None,):
20434 
    self.collectedAmountMap = collectedAmountMap
20435 
    self.xferBy = xferBy
20436 
    self.xferTxnId = xferTxnId
20437 
    self.xferDate = xferDate
20438 
 
20439 
  def read(self, iprot):
20440 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20441 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20442 
      return
20443 
    iprot.readStructBegin()
20444 
    while True:
20445 
      (fname, ftype, fid) = iprot.readFieldBegin()
20446 
      if ftype == TType.STOP:
20447 
        break
20448 
      if fid == 1:
20449 
        if ftype == TType.MAP:
20450 
          self.collectedAmountMap = {}
6188 rajveer 20451 
          (_ktype454, _vtype455, _size453 ) = iprot.readMapBegin()
20452 
          for _i457 in xrange(_size453):
20453 
            _key458 = iprot.readString();
20454 
            _val459 = iprot.readDouble();
20455 
            self.collectedAmountMap[_key458] = _val459
3956 chandransh 20456 
          iprot.readMapEnd()
20457 
        else:
20458 
          iprot.skip(ftype)
20459 
      elif fid == 2:
20460 
        if ftype == TType.STRING:
20461 
          self.xferBy = iprot.readString();
20462 
        else:
20463 
          iprot.skip(ftype)
20464 
      elif fid == 3:
20465 
        if ftype == TType.STRING:
20466 
          self.xferTxnId = iprot.readString();
20467 
        else:
20468 
          iprot.skip(ftype)
20469 
      elif fid == 4:
20470 
        if ftype == TType.I64:
20471 
          self.xferDate = iprot.readI64();
20472 
        else:
20473 
          iprot.skip(ftype)
20474 
      else:
20475 
        iprot.skip(ftype)
20476 
      iprot.readFieldEnd()
20477 
    iprot.readStructEnd()
20478 
 
20479 
  def write(self, oprot):
20480 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20481 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20482 
      return
20483 
    oprot.writeStructBegin('reconcileCodCollection_args')
20484 
    if self.collectedAmountMap is not None:
20485 
      oprot.writeFieldBegin('collectedAmountMap', TType.MAP, 1)
20486 
      oprot.writeMapBegin(TType.STRING, TType.DOUBLE, len(self.collectedAmountMap))
6188 rajveer 20487 
      for kiter460,viter461 in self.collectedAmountMap.items():
20488 
        oprot.writeString(kiter460)
20489 
        oprot.writeDouble(viter461)
3956 chandransh 20490 
      oprot.writeMapEnd()
20491 
      oprot.writeFieldEnd()
20492 
    if self.xferBy is not None:
20493 
      oprot.writeFieldBegin('xferBy', TType.STRING, 2)
20494 
      oprot.writeString(self.xferBy)
20495 
      oprot.writeFieldEnd()
20496 
    if self.xferTxnId is not None:
20497 
      oprot.writeFieldBegin('xferTxnId', TType.STRING, 3)
20498 
      oprot.writeString(self.xferTxnId)
20499 
      oprot.writeFieldEnd()
20500 
    if self.xferDate is not None:
20501 
      oprot.writeFieldBegin('xferDate', TType.I64, 4)
20502 
      oprot.writeI64(self.xferDate)
20503 
      oprot.writeFieldEnd()
20504 
    oprot.writeFieldStop()
20505 
    oprot.writeStructEnd()
20506 
 
20507 
  def validate(self):
20508 
    return
20509 
 
20510 
 
20511 
  def __repr__(self):
20512 
    L = ['%s=%r' % (key, value)
20513 
      for key, value in self.__dict__.iteritems()]
20514 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20515 
 
20516 
  def __eq__(self, other):
20517 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20518 
 
20519 
  def __ne__(self, other):
20520 
    return not (self == other)
20521 
 
20522 
class reconcileCodCollection_result:
20523 
  """
20524 
  Attributes:
20525 
   - success
20526 
   - ex
20527 
  """
20528 
 
20529 
  thrift_spec = (
20530 
    (0, TType.MAP, 'success', (TType.STRING,None,TType.STRING,None), None, ), # 0
20531 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
20532 
  )
20533 
 
20534 
  def __init__(self, success=None, ex=None,):
20535 
    self.success = success
20536 
    self.ex = ex
20537 
 
20538 
  def read(self, iprot):
20539 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20540 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20541 
      return
20542 
    iprot.readStructBegin()
20543 
    while True:
20544 
      (fname, ftype, fid) = iprot.readFieldBegin()
20545 
      if ftype == TType.STOP:
20546 
        break
20547 
      if fid == 0:
20548 
        if ftype == TType.MAP:
20549 
          self.success = {}
6188 rajveer 20550 
          (_ktype463, _vtype464, _size462 ) = iprot.readMapBegin()
20551 
          for _i466 in xrange(_size462):
20552 
            _key467 = iprot.readString();
20553 
            _val468 = iprot.readString();
20554 
            self.success[_key467] = _val468
3956 chandransh 20555 
          iprot.readMapEnd()
20556 
        else:
20557 
          iprot.skip(ftype)
20558 
      elif fid == 1:
20559 
        if ftype == TType.STRUCT:
20560 
          self.ex = TransactionServiceException()
20561 
          self.ex.read(iprot)
20562 
        else:
20563 
          iprot.skip(ftype)
20564 
      else:
20565 
        iprot.skip(ftype)
20566 
      iprot.readFieldEnd()
20567 
    iprot.readStructEnd()
20568 
 
20569 
  def write(self, oprot):
20570 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20571 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20572 
      return
20573 
    oprot.writeStructBegin('reconcileCodCollection_result')
20574 
    if self.success is not None:
20575 
      oprot.writeFieldBegin('success', TType.MAP, 0)
20576 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.success))
6188 rajveer 20577 
      for kiter469,viter470 in self.success.items():
20578 
        oprot.writeString(kiter469)
20579 
        oprot.writeString(viter470)
3956 chandransh 20580 
      oprot.writeMapEnd()
20581 
      oprot.writeFieldEnd()
20582 
    if self.ex is not None:
20583 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
20584 
      self.ex.write(oprot)
20585 
      oprot.writeFieldEnd()
20586 
    oprot.writeFieldStop()
20587 
    oprot.writeStructEnd()
20588 
 
20589 
  def validate(self):
20590 
    return
20591 
 
20592 
 
20593 
  def __repr__(self):
20594 
    L = ['%s=%r' % (key, value)
20595 
      for key, value in self.__dict__.iteritems()]
20596 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20597 
 
20598 
  def __eq__(self, other):
20599 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20600 
 
20601 
  def __ne__(self, other):
20602 
    return not (self == other)
4008 mandeep.dh 20603 
 
20604 
class getTransactionsRequiringExtraProcessing_args:
20605 
  """
20606 
  Attributes:
20607 
   - category
20608 
  """
20609 
 
20610 
  thrift_spec = (
20611 
    None, # 0
20612 
    (1, TType.I32, 'category', None, None, ), # 1
20613 
  )
20614 
 
20615 
  def __init__(self, category=None,):
20616 
    self.category = category
20617 
 
20618 
  def read(self, iprot):
20619 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20620 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20621 
      return
20622 
    iprot.readStructBegin()
20623 
    while True:
20624 
      (fname, ftype, fid) = iprot.readFieldBegin()
20625 
      if ftype == TType.STOP:
20626 
        break
20627 
      if fid == 1:
20628 
        if ftype == TType.I32:
20629 
          self.category = iprot.readI32();
20630 
        else:
20631 
          iprot.skip(ftype)
20632 
      else:
20633 
        iprot.skip(ftype)
20634 
      iprot.readFieldEnd()
20635 
    iprot.readStructEnd()
20636 
 
20637 
  def write(self, oprot):
20638 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20639 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20640 
      return
20641 
    oprot.writeStructBegin('getTransactionsRequiringExtraProcessing_args')
20642 
    if self.category is not None:
20643 
      oprot.writeFieldBegin('category', TType.I32, 1)
20644 
      oprot.writeI32(self.category)
20645 
      oprot.writeFieldEnd()
20646 
    oprot.writeFieldStop()
20647 
    oprot.writeStructEnd()
20648 
 
20649 
  def validate(self):
20650 
    return
20651 
 
20652 
 
20653 
  def __repr__(self):
20654 
    L = ['%s=%r' % (key, value)
20655 
      for key, value in self.__dict__.iteritems()]
20656 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20657 
 
20658 
  def __eq__(self, other):
20659 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20660 
 
20661 
  def __ne__(self, other):
20662 
    return not (self == other)
20663 
 
20664 
class getTransactionsRequiringExtraProcessing_result:
20665 
  """
20666 
  Attributes:
20667 
   - success
20668 
  """
20669 
 
20670 
  thrift_spec = (
20671 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
20672 
  )
20673 
 
20674 
  def __init__(self, success=None,):
20675 
    self.success = success
20676 
 
20677 
  def read(self, iprot):
20678 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20679 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20680 
      return
20681 
    iprot.readStructBegin()
20682 
    while True:
20683 
      (fname, ftype, fid) = iprot.readFieldBegin()
20684 
      if ftype == TType.STOP:
20685 
        break
20686 
      if fid == 0:
20687 
        if ftype == TType.LIST:
20688 
          self.success = []
6188 rajveer 20689 
          (_etype474, _size471) = iprot.readListBegin()
20690 
          for _i475 in xrange(_size471):
20691 
            _elem476 = iprot.readI64();
20692 
            self.success.append(_elem476)
4008 mandeep.dh 20693 
          iprot.readListEnd()
20694 
        else:
20695 
          iprot.skip(ftype)
20696 
      else:
20697 
        iprot.skip(ftype)
20698 
      iprot.readFieldEnd()
20699 
    iprot.readStructEnd()
20700 
 
20701 
  def write(self, oprot):
20702 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20703 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20704 
      return
20705 
    oprot.writeStructBegin('getTransactionsRequiringExtraProcessing_result')
20706 
    if self.success is not None:
20707 
      oprot.writeFieldBegin('success', TType.LIST, 0)
20708 
      oprot.writeListBegin(TType.I64, len(self.success))
6188 rajveer 20709 
      for iter477 in self.success:
20710 
        oprot.writeI64(iter477)
4008 mandeep.dh 20711 
      oprot.writeListEnd()
20712 
      oprot.writeFieldEnd()
20713 
    oprot.writeFieldStop()
20714 
    oprot.writeStructEnd()
20715 
 
20716 
  def validate(self):
20717 
    return
20718 
 
20719 
 
20720 
  def __repr__(self):
20721 
    L = ['%s=%r' % (key, value)
20722 
      for key, value in self.__dict__.iteritems()]
20723 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20724 
 
20725 
  def __eq__(self, other):
20726 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20727 
 
20728 
  def __ne__(self, other):
20729 
    return not (self == other)
20730 
 
20731 
class markTransactionAsProcessed_args:
20732 
  """
20733 
  Attributes:
20734 
   - transactionId
20735 
   - category
20736 
  """
20737 
 
20738 
  thrift_spec = (
20739 
    None, # 0
20740 
    (1, TType.I64, 'transactionId', None, None, ), # 1
20741 
    (2, TType.I32, 'category', None, None, ), # 2
20742 
  )
20743 
 
20744 
  def __init__(self, transactionId=None, category=None,):
20745 
    self.transactionId = transactionId
20746 
    self.category = category
20747 
 
20748 
  def read(self, iprot):
20749 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20750 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20751 
      return
20752 
    iprot.readStructBegin()
20753 
    while True:
20754 
      (fname, ftype, fid) = iprot.readFieldBegin()
20755 
      if ftype == TType.STOP:
20756 
        break
20757 
      if fid == 1:
20758 
        if ftype == TType.I64:
20759 
          self.transactionId = iprot.readI64();
20760 
        else:
20761 
          iprot.skip(ftype)
20762 
      elif fid == 2:
20763 
        if ftype == TType.I32:
20764 
          self.category = iprot.readI32();
20765 
        else:
20766 
          iprot.skip(ftype)
20767 
      else:
20768 
        iprot.skip(ftype)
20769 
      iprot.readFieldEnd()
20770 
    iprot.readStructEnd()
20771 
 
20772 
  def write(self, oprot):
20773 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20774 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20775 
      return
20776 
    oprot.writeStructBegin('markTransactionAsProcessed_args')
20777 
    if self.transactionId is not None:
20778 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
20779 
      oprot.writeI64(self.transactionId)
20780 
      oprot.writeFieldEnd()
20781 
    if self.category is not None:
20782 
      oprot.writeFieldBegin('category', TType.I32, 2)
20783 
      oprot.writeI32(self.category)
20784 
      oprot.writeFieldEnd()
20785 
    oprot.writeFieldStop()
20786 
    oprot.writeStructEnd()
20787 
 
20788 
  def validate(self):
20789 
    return
20790 
 
20791 
 
20792 
  def __repr__(self):
20793 
    L = ['%s=%r' % (key, value)
20794 
      for key, value in self.__dict__.iteritems()]
20795 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20796 
 
20797 
  def __eq__(self, other):
20798 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20799 
 
20800 
  def __ne__(self, other):
20801 
    return not (self == other)
20802 
 
20803 
class markTransactionAsProcessed_result:
20804 
 
20805 
  thrift_spec = (
20806 
  )
20807 
 
20808 
  def read(self, iprot):
20809 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20810 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20811 
      return
20812 
    iprot.readStructBegin()
20813 
    while True:
20814 
      (fname, ftype, fid) = iprot.readFieldBegin()
20815 
      if ftype == TType.STOP:
20816 
        break
20817 
      else:
20818 
        iprot.skip(ftype)
20819 
      iprot.readFieldEnd()
20820 
    iprot.readStructEnd()
20821 
 
20822 
  def write(self, oprot):
20823 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20824 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20825 
      return
20826 
    oprot.writeStructBegin('markTransactionAsProcessed_result')
20827 
    oprot.writeFieldStop()
20828 
    oprot.writeStructEnd()
20829 
 
20830 
  def validate(self):
20831 
    return
20832 
 
20833 
 
20834 
  def __repr__(self):
20835 
    L = ['%s=%r' % (key, value)
20836 
      for key, value in self.__dict__.iteritems()]
20837 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20838 
 
20839 
  def __eq__(self, other):
20840 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20841 
 
20842 
  def __ne__(self, other):
20843 
    return not (self == other)
4018 chandransh 20844 
 
20845 
class getItemWiseRiskyOrdersCount_args:
20846 
 
20847 
  thrift_spec = (
20848 
  )
20849 
 
20850 
  def read(self, iprot):
20851 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20852 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20853 
      return
20854 
    iprot.readStructBegin()
20855 
    while True:
20856 
      (fname, ftype, fid) = iprot.readFieldBegin()
20857 
      if ftype == TType.STOP:
20858 
        break
20859 
      else:
20860 
        iprot.skip(ftype)
20861 
      iprot.readFieldEnd()
20862 
    iprot.readStructEnd()
20863 
 
20864 
  def write(self, oprot):
20865 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20866 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20867 
      return
20868 
    oprot.writeStructBegin('getItemWiseRiskyOrdersCount_args')
20869 
    oprot.writeFieldStop()
20870 
    oprot.writeStructEnd()
20871 
 
20872 
  def validate(self):
20873 
    return
20874 
 
20875 
 
20876 
  def __repr__(self):
20877 
    L = ['%s=%r' % (key, value)
20878 
      for key, value in self.__dict__.iteritems()]
20879 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20880 
 
20881 
  def __eq__(self, other):
20882 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20883 
 
20884 
  def __ne__(self, other):
20885 
    return not (self == other)
20886 
 
20887 
class getItemWiseRiskyOrdersCount_result:
20888 
  """
20889 
  Attributes:
20890 
   - success
20891 
  """
20892 
 
20893 
  thrift_spec = (
20894 
    (0, TType.MAP, 'success', (TType.I64,None,TType.I64,None), None, ), # 0
20895 
  )
20896 
 
20897 
  def __init__(self, success=None,):
20898 
    self.success = success
20899 
 
20900 
  def read(self, iprot):
20901 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20902 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20903 
      return
20904 
    iprot.readStructBegin()
20905 
    while True:
20906 
      (fname, ftype, fid) = iprot.readFieldBegin()
20907 
      if ftype == TType.STOP:
20908 
        break
20909 
      if fid == 0:
20910 
        if ftype == TType.MAP:
20911 
          self.success = {}
6188 rajveer 20912 
          (_ktype479, _vtype480, _size478 ) = iprot.readMapBegin()
20913 
          for _i482 in xrange(_size478):
20914 
            _key483 = iprot.readI64();
20915 
            _val484 = iprot.readI64();
20916 
            self.success[_key483] = _val484
4018 chandransh 20917 
          iprot.readMapEnd()
20918 
        else:
20919 
          iprot.skip(ftype)
20920 
      else:
20921 
        iprot.skip(ftype)
20922 
      iprot.readFieldEnd()
20923 
    iprot.readStructEnd()
20924 
 
20925 
  def write(self, oprot):
20926 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20927 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20928 
      return
20929 
    oprot.writeStructBegin('getItemWiseRiskyOrdersCount_result')
20930 
    if self.success is not None:
20931 
      oprot.writeFieldBegin('success', TType.MAP, 0)
20932 
      oprot.writeMapBegin(TType.I64, TType.I64, len(self.success))
6188 rajveer 20933 
      for kiter485,viter486 in self.success.items():
20934 
        oprot.writeI64(kiter485)
20935 
        oprot.writeI64(viter486)
4018 chandransh 20936 
      oprot.writeMapEnd()
20937 
      oprot.writeFieldEnd()
20938 
    oprot.writeFieldStop()
20939 
    oprot.writeStructEnd()
20940 
 
20941 
  def validate(self):
20942 
    return
20943 
 
20944 
 
20945 
  def __repr__(self):
20946 
    L = ['%s=%r' % (key, value)
20947 
      for key, value in self.__dict__.iteritems()]
20948 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20949 
 
20950 
  def __eq__(self, other):
20951 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20952 
 
20953 
  def __ne__(self, other):
20954 
    return not (self == other)
4247 rajveer 20955 
 
4295 varun.gupt 20956 
class getOrdersForItemIds_args:
20957 
  """
20958 
  Attributes:
20959 
   - itemIds
20960 
  """
20961 
 
20962 
  thrift_spec = (
20963 
    None, # 0
20964 
    (1, TType.LIST, 'itemIds', (TType.I64,None), None, ), # 1
20965 
  )
20966 
 
20967 
  def __init__(self, itemIds=None,):
20968 
    self.itemIds = itemIds
20969 
 
20970 
  def read(self, iprot):
20971 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20972 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20973 
      return
20974 
    iprot.readStructBegin()
20975 
    while True:
20976 
      (fname, ftype, fid) = iprot.readFieldBegin()
20977 
      if ftype == TType.STOP:
20978 
        break
20979 
      if fid == 1:
20980 
        if ftype == TType.LIST:
20981 
          self.itemIds = []
6188 rajveer 20982 
          (_etype490, _size487) = iprot.readListBegin()
20983 
          for _i491 in xrange(_size487):
20984 
            _elem492 = iprot.readI64();
20985 
            self.itemIds.append(_elem492)
4295 varun.gupt 20986 
          iprot.readListEnd()
20987 
        else:
20988 
          iprot.skip(ftype)
20989 
      else:
20990 
        iprot.skip(ftype)
20991 
      iprot.readFieldEnd()
20992 
    iprot.readStructEnd()
20993 
 
20994 
  def write(self, oprot):
20995 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20996 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20997 
      return
20998 
    oprot.writeStructBegin('getOrdersForItemIds_args')
20999 
    if self.itemIds is not None:
21000 
      oprot.writeFieldBegin('itemIds', TType.LIST, 1)
21001 
      oprot.writeListBegin(TType.I64, len(self.itemIds))
6188 rajveer 21002 
      for iter493 in self.itemIds:
21003 
        oprot.writeI64(iter493)
4295 varun.gupt 21004 
      oprot.writeListEnd()
21005 
      oprot.writeFieldEnd()
21006 
    oprot.writeFieldStop()
21007 
    oprot.writeStructEnd()
21008 
 
21009 
  def validate(self):
21010 
    return
21011 
 
21012 
 
21013 
  def __repr__(self):
21014 
    L = ['%s=%r' % (key, value)
21015 
      for key, value in self.__dict__.iteritems()]
21016 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21017 
 
21018 
  def __eq__(self, other):
21019 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21020 
 
21021 
  def __ne__(self, other):
21022 
    return not (self == other)
21023 
 
21024 
class getOrdersForItemIds_result:
21025 
  """
21026 
  Attributes:
21027 
   - success
21028 
  """
21029 
 
21030 
  thrift_spec = (
21031 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
21032 
  )
21033 
 
21034 
  def __init__(self, success=None,):
21035 
    self.success = success
21036 
 
21037 
  def read(self, iprot):
21038 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21039 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21040 
      return
21041 
    iprot.readStructBegin()
21042 
    while True:
21043 
      (fname, ftype, fid) = iprot.readFieldBegin()
21044 
      if ftype == TType.STOP:
21045 
        break
21046 
      if fid == 0:
21047 
        if ftype == TType.LIST:
21048 
          self.success = []
6188 rajveer 21049 
          (_etype497, _size494) = iprot.readListBegin()
21050 
          for _i498 in xrange(_size494):
21051 
            _elem499 = Order()
21052 
            _elem499.read(iprot)
21053 
            self.success.append(_elem499)
4295 varun.gupt 21054 
          iprot.readListEnd()
21055 
        else:
21056 
          iprot.skip(ftype)
21057 
      else:
21058 
        iprot.skip(ftype)
21059 
      iprot.readFieldEnd()
21060 
    iprot.readStructEnd()
21061 
 
21062 
  def write(self, oprot):
21063 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21064 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21065 
      return
21066 
    oprot.writeStructBegin('getOrdersForItemIds_result')
21067 
    if self.success is not None:
21068 
      oprot.writeFieldBegin('success', TType.LIST, 0)
21069 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 21070 
      for iter500 in self.success:
21071 
        iter500.write(oprot)
4295 varun.gupt 21072 
      oprot.writeListEnd()
21073 
      oprot.writeFieldEnd()
21074 
    oprot.writeFieldStop()
21075 
    oprot.writeStructEnd()
21076 
 
21077 
  def validate(self):
21078 
    return
21079 
 
21080 
 
21081 
  def __repr__(self):
21082 
    L = ['%s=%r' % (key, value)
21083 
      for key, value in self.__dict__.iteritems()]
21084 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21085 
 
21086 
  def __eq__(self, other):
21087 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21088 
 
21089 
  def __ne__(self, other):
21090 
    return not (self == other)
21091 
 
4247 rajveer 21092 
class markOrderCancellationRequestReceived_args:
21093 
  """
21094 
  Attributes:
21095 
   - orderId
21096 
  """
21097 
 
21098 
  thrift_spec = (
21099 
    None, # 0
21100 
    (1, TType.I64, 'orderId', None, None, ), # 1
21101 
  )
21102 
 
21103 
  def __init__(self, orderId=None,):
21104 
    self.orderId = orderId
21105 
 
21106 
  def read(self, iprot):
21107 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21108 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21109 
      return
21110 
    iprot.readStructBegin()
21111 
    while True:
21112 
      (fname, ftype, fid) = iprot.readFieldBegin()
21113 
      if ftype == TType.STOP:
21114 
        break
21115 
      if fid == 1:
21116 
        if ftype == TType.I64:
21117 
          self.orderId = iprot.readI64();
21118 
        else:
21119 
          iprot.skip(ftype)
21120 
      else:
21121 
        iprot.skip(ftype)
21122 
      iprot.readFieldEnd()
21123 
    iprot.readStructEnd()
21124 
 
21125 
  def write(self, oprot):
21126 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21127 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21128 
      return
21129 
    oprot.writeStructBegin('markOrderCancellationRequestReceived_args')
21130 
    if self.orderId is not None:
21131 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
21132 
      oprot.writeI64(self.orderId)
21133 
      oprot.writeFieldEnd()
21134 
    oprot.writeFieldStop()
21135 
    oprot.writeStructEnd()
21136 
 
21137 
  def validate(self):
21138 
    return
21139 
 
21140 
 
21141 
  def __repr__(self):
21142 
    L = ['%s=%r' % (key, value)
21143 
      for key, value in self.__dict__.iteritems()]
21144 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21145 
 
21146 
  def __eq__(self, other):
21147 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21148 
 
21149 
  def __ne__(self, other):
21150 
    return not (self == other)
21151 
 
21152 
class markOrderCancellationRequestReceived_result:
21153 
  """
21154 
  Attributes:
21155 
   - ex
21156 
  """
21157 
 
21158 
  thrift_spec = (
21159 
    None, # 0
21160 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
21161 
  )
21162 
 
21163 
  def __init__(self, ex=None,):
21164 
    self.ex = ex
21165 
 
21166 
  def read(self, iprot):
21167 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21168 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21169 
      return
21170 
    iprot.readStructBegin()
21171 
    while True:
21172 
      (fname, ftype, fid) = iprot.readFieldBegin()
21173 
      if ftype == TType.STOP:
21174 
        break
21175 
      if fid == 1:
21176 
        if ftype == TType.STRUCT:
21177 
          self.ex = TransactionServiceException()
21178 
          self.ex.read(iprot)
21179 
        else:
21180 
          iprot.skip(ftype)
21181 
      else:
21182 
        iprot.skip(ftype)
21183 
      iprot.readFieldEnd()
21184 
    iprot.readStructEnd()
21185 
 
21186 
  def write(self, oprot):
21187 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21188 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21189 
      return
21190 
    oprot.writeStructBegin('markOrderCancellationRequestReceived_result')
21191 
    if self.ex is not None:
21192 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
21193 
      self.ex.write(oprot)
21194 
      oprot.writeFieldEnd()
21195 
    oprot.writeFieldStop()
21196 
    oprot.writeStructEnd()
21197 
 
21198 
  def validate(self):
21199 
    return
21200 
 
21201 
 
21202 
  def __repr__(self):
21203 
    L = ['%s=%r' % (key, value)
21204 
      for key, value in self.__dict__.iteritems()]
21205 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21206 
 
21207 
  def __eq__(self, other):
21208 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21209 
 
21210 
  def __ne__(self, other):
21211 
    return not (self == other)
21212 
 
21213 
class markOrderCancellationRequestConfirmed_args:
21214 
  """
21215 
  Attributes:
21216 
   - orderId
21217 
  """
21218 
 
21219 
  thrift_spec = (
21220 
    None, # 0
21221 
    (1, TType.I64, 'orderId', None, None, ), # 1
21222 
  )
21223 
 
21224 
  def __init__(self, orderId=None,):
21225 
    self.orderId = orderId
21226 
 
21227 
  def read(self, iprot):
21228 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21229 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21230 
      return
21231 
    iprot.readStructBegin()
21232 
    while True:
21233 
      (fname, ftype, fid) = iprot.readFieldBegin()
21234 
      if ftype == TType.STOP:
21235 
        break
21236 
      if fid == 1:
21237 
        if ftype == TType.I64:
21238 
          self.orderId = iprot.readI64();
21239 
        else:
21240 
          iprot.skip(ftype)
21241 
      else:
21242 
        iprot.skip(ftype)
21243 
      iprot.readFieldEnd()
21244 
    iprot.readStructEnd()
21245 
 
21246 
  def write(self, oprot):
21247 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21248 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21249 
      return
21250 
    oprot.writeStructBegin('markOrderCancellationRequestConfirmed_args')
21251 
    if self.orderId is not None:
21252 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
21253 
      oprot.writeI64(self.orderId)
21254 
      oprot.writeFieldEnd()
21255 
    oprot.writeFieldStop()
21256 
    oprot.writeStructEnd()
21257 
 
21258 
  def validate(self):
21259 
    return
21260 
 
21261 
 
21262 
  def __repr__(self):
21263 
    L = ['%s=%r' % (key, value)
21264 
      for key, value in self.__dict__.iteritems()]
21265 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21266 
 
21267 
  def __eq__(self, other):
21268 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21269 
 
21270 
  def __ne__(self, other):
21271 
    return not (self == other)
21272 
 
21273 
class markOrderCancellationRequestConfirmed_result:
21274 
  """
21275 
  Attributes:
21276 
   - ex
21277 
  """
21278 
 
21279 
  thrift_spec = (
21280 
    None, # 0
21281 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
21282 
  )
21283 
 
21284 
  def __init__(self, ex=None,):
21285 
    self.ex = ex
21286 
 
21287 
  def read(self, iprot):
21288 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21289 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21290 
      return
21291 
    iprot.readStructBegin()
21292 
    while True:
21293 
      (fname, ftype, fid) = iprot.readFieldBegin()
21294 
      if ftype == TType.STOP:
21295 
        break
21296 
      if fid == 1:
21297 
        if ftype == TType.STRUCT:
21298 
          self.ex = TransactionServiceException()
21299 
          self.ex.read(iprot)
21300 
        else:
21301 
          iprot.skip(ftype)
21302 
      else:
21303 
        iprot.skip(ftype)
21304 
      iprot.readFieldEnd()
21305 
    iprot.readStructEnd()
21306 
 
21307 
  def write(self, oprot):
21308 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21309 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21310 
      return
21311 
    oprot.writeStructBegin('markOrderCancellationRequestConfirmed_result')
21312 
    if self.ex is not None:
21313 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
21314 
      self.ex.write(oprot)
21315 
      oprot.writeFieldEnd()
21316 
    oprot.writeFieldStop()
21317 
    oprot.writeStructEnd()
21318 
 
21319 
  def validate(self):
21320 
    return
21321 
 
21322 
 
21323 
  def __repr__(self):
21324 
    L = ['%s=%r' % (key, value)
21325 
      for key, value in self.__dict__.iteritems()]
21326 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21327 
 
21328 
  def __eq__(self, other):
21329 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21330 
 
21331 
  def __ne__(self, other):
21332 
    return not (self == other)
21333 
 
21334 
class markOrderCancellationRequestDenied_args:
21335 
  """
21336 
  Attributes:
21337 
   - orderId
21338 
  """
21339 
 
21340 
  thrift_spec = (
21341 
    None, # 0
21342 
    (1, TType.I64, 'orderId', None, None, ), # 1
21343 
  )
21344 
 
21345 
  def __init__(self, orderId=None,):
21346 
    self.orderId = orderId
21347 
 
21348 
  def read(self, iprot):
21349 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21350 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21351 
      return
21352 
    iprot.readStructBegin()
21353 
    while True:
21354 
      (fname, ftype, fid) = iprot.readFieldBegin()
21355 
      if ftype == TType.STOP:
21356 
        break
21357 
      if fid == 1:
21358 
        if ftype == TType.I64:
21359 
          self.orderId = iprot.readI64();
21360 
        else:
21361 
          iprot.skip(ftype)
21362 
      else:
21363 
        iprot.skip(ftype)
21364 
      iprot.readFieldEnd()
21365 
    iprot.readStructEnd()
21366 
 
21367 
  def write(self, oprot):
21368 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21369 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21370 
      return
21371 
    oprot.writeStructBegin('markOrderCancellationRequestDenied_args')
21372 
    if self.orderId is not None:
21373 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
21374 
      oprot.writeI64(self.orderId)
21375 
      oprot.writeFieldEnd()
21376 
    oprot.writeFieldStop()
21377 
    oprot.writeStructEnd()
21378 
 
21379 
  def validate(self):
21380 
    return
21381 
 
21382 
 
21383 
  def __repr__(self):
21384 
    L = ['%s=%r' % (key, value)
21385 
      for key, value in self.__dict__.iteritems()]
21386 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21387 
 
21388 
  def __eq__(self, other):
21389 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21390 
 
21391 
  def __ne__(self, other):
21392 
    return not (self == other)
21393 
 
21394 
class markOrderCancellationRequestDenied_result:
21395 
  """
21396 
  Attributes:
21397 
   - ex
21398 
  """
21399 
 
21400 
  thrift_spec = (
21401 
    None, # 0
21402 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
21403 
  )
21404 
 
21405 
  def __init__(self, ex=None,):
21406 
    self.ex = ex
21407 
 
21408 
  def read(self, iprot):
21409 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21410 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21411 
      return
21412 
    iprot.readStructBegin()
21413 
    while True:
21414 
      (fname, ftype, fid) = iprot.readFieldBegin()
21415 
      if ftype == TType.STOP:
21416 
        break
21417 
      if fid == 1:
21418 
        if ftype == TType.STRUCT:
21419 
          self.ex = TransactionServiceException()
21420 
          self.ex.read(iprot)
21421 
        else:
21422 
          iprot.skip(ftype)
21423 
      else:
21424 
        iprot.skip(ftype)
21425 
      iprot.readFieldEnd()
21426 
    iprot.readStructEnd()
21427 
 
21428 
  def write(self, oprot):
21429 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21430 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21431 
      return
21432 
    oprot.writeStructBegin('markOrderCancellationRequestDenied_result')
21433 
    if self.ex is not None:
21434 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
21435 
      self.ex.write(oprot)
21436 
      oprot.writeFieldEnd()
21437 
    oprot.writeFieldStop()
21438 
    oprot.writeStructEnd()
21439 
 
21440 
  def validate(self):
21441 
    return
21442 
 
21443 
 
21444 
  def __repr__(self):
21445 
    L = ['%s=%r' % (key, value)
21446 
      for key, value in self.__dict__.iteritems()]
21447 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21448 
 
21449 
  def __eq__(self, other):
21450 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21451 
 
21452 
  def __ne__(self, other):
21453 
    return not (self == other)
21454 
 
4258 rajveer 21455 
class markTransactionAsPaymentFlagRemoved_args:
4247 rajveer 21456 
  """
21457 
  Attributes:
4258 rajveer 21458 
   - transactionId
4247 rajveer 21459 
  """
21460 
 
21461 
  thrift_spec = (
21462 
    None, # 0
4258 rajveer 21463 
    (1, TType.I64, 'transactionId', None, None, ), # 1
4247 rajveer 21464 
  )
21465 
 
4258 rajveer 21466 
  def __init__(self, transactionId=None,):
21467 
    self.transactionId = transactionId
4247 rajveer 21468 
 
21469 
  def read(self, iprot):
21470 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21471 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21472 
      return
21473 
    iprot.readStructBegin()
21474 
    while True:
21475 
      (fname, ftype, fid) = iprot.readFieldBegin()
21476 
      if ftype == TType.STOP:
21477 
        break
21478 
      if fid == 1:
21479 
        if ftype == TType.I64:
4258 rajveer 21480 
          self.transactionId = iprot.readI64();
4247 rajveer 21481 
        else:
21482 
          iprot.skip(ftype)
21483 
      else:
21484 
        iprot.skip(ftype)
21485 
      iprot.readFieldEnd()
21486 
    iprot.readStructEnd()
21487 
 
21488 
  def write(self, oprot):
21489 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21490 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21491 
      return
4258 rajveer 21492 
    oprot.writeStructBegin('markTransactionAsPaymentFlagRemoved_args')
21493 
    if self.transactionId is not None:
21494 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
21495 
      oprot.writeI64(self.transactionId)
4247 rajveer 21496 
      oprot.writeFieldEnd()
21497 
    oprot.writeFieldStop()
21498 
    oprot.writeStructEnd()
21499 
 
21500 
  def validate(self):
21501 
    return
21502 
 
21503 
 
21504 
  def __repr__(self):
21505 
    L = ['%s=%r' % (key, value)
21506 
      for key, value in self.__dict__.iteritems()]
21507 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21508 
 
21509 
  def __eq__(self, other):
21510 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21511 
 
21512 
  def __ne__(self, other):
21513 
    return not (self == other)
21514 
 
4258 rajveer 21515 
class markTransactionAsPaymentFlagRemoved_result:
4247 rajveer 21516 
  """
21517 
  Attributes:
21518 
   - ex
21519 
  """
21520 
 
21521 
  thrift_spec = (
21522 
    None, # 0
21523 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
21524 
  )
21525 
 
21526 
  def __init__(self, ex=None,):
21527 
    self.ex = ex
21528 
 
21529 
  def read(self, iprot):
21530 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21531 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21532 
      return
21533 
    iprot.readStructBegin()
21534 
    while True:
21535 
      (fname, ftype, fid) = iprot.readFieldBegin()
21536 
      if ftype == TType.STOP:
21537 
        break
21538 
      if fid == 1:
21539 
        if ftype == TType.STRUCT:
21540 
          self.ex = TransactionServiceException()
21541 
          self.ex.read(iprot)
21542 
        else:
21543 
          iprot.skip(ftype)
21544 
      else:
21545 
        iprot.skip(ftype)
21546 
      iprot.readFieldEnd()
21547 
    iprot.readStructEnd()
21548 
 
21549 
  def write(self, oprot):
21550 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21551 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21552 
      return
4258 rajveer 21553 
    oprot.writeStructBegin('markTransactionAsPaymentFlagRemoved_result')
4247 rajveer 21554 
    if self.ex is not None:
21555 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
21556 
      self.ex.write(oprot)
21557 
      oprot.writeFieldEnd()
21558 
    oprot.writeFieldStop()
21559 
    oprot.writeStructEnd()
21560 
 
21561 
  def validate(self):
21562 
    return
21563 
 
21564 
 
21565 
  def __repr__(self):
21566 
    L = ['%s=%r' % (key, value)
21567 
      for key, value in self.__dict__.iteritems()]
21568 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21569 
 
21570 
  def __eq__(self, other):
21571 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21572 
 
21573 
  def __ne__(self, other):
21574 
    return not (self == other)
4259 anupam.sin 21575 
 
21576 
class refundTransaction_args:
21577 
  """
21578 
  Attributes:
21579 
   - transactionId
21580 
   - refundedBy
21581 
   - reason
21582 
  """
21583 
 
21584 
  thrift_spec = (
21585 
    None, # 0
21586 
    (1, TType.I64, 'transactionId', None, None, ), # 1
21587 
    (2, TType.STRING, 'refundedBy', None, None, ), # 2
21588 
    (3, TType.STRING, 'reason', None, None, ), # 3
21589 
  )
21590 
 
21591 
  def __init__(self, transactionId=None, refundedBy=None, reason=None,):
21592 
    self.transactionId = transactionId
21593 
    self.refundedBy = refundedBy
21594 
    self.reason = reason
21595 
 
21596 
  def read(self, iprot):
21597 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21598 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21599 
      return
21600 
    iprot.readStructBegin()
21601 
    while True:
21602 
      (fname, ftype, fid) = iprot.readFieldBegin()
21603 
      if ftype == TType.STOP:
21604 
        break
21605 
      if fid == 1:
21606 
        if ftype == TType.I64:
21607 
          self.transactionId = iprot.readI64();
21608 
        else:
21609 
          iprot.skip(ftype)
21610 
      elif fid == 2:
21611 
        if ftype == TType.STRING:
21612 
          self.refundedBy = iprot.readString();
21613 
        else:
21614 
          iprot.skip(ftype)
21615 
      elif fid == 3:
21616 
        if ftype == TType.STRING:
21617 
          self.reason = iprot.readString();
21618 
        else:
21619 
          iprot.skip(ftype)
21620 
      else:
21621 
        iprot.skip(ftype)
21622 
      iprot.readFieldEnd()
21623 
    iprot.readStructEnd()
21624 
 
21625 
  def write(self, oprot):
21626 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21627 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21628 
      return
21629 
    oprot.writeStructBegin('refundTransaction_args')
21630 
    if self.transactionId is not None:
21631 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
21632 
      oprot.writeI64(self.transactionId)
21633 
      oprot.writeFieldEnd()
21634 
    if self.refundedBy is not None:
21635 
      oprot.writeFieldBegin('refundedBy', TType.STRING, 2)
21636 
      oprot.writeString(self.refundedBy)
21637 
      oprot.writeFieldEnd()
21638 
    if self.reason is not None:
21639 
      oprot.writeFieldBegin('reason', TType.STRING, 3)
21640 
      oprot.writeString(self.reason)
21641 
      oprot.writeFieldEnd()
21642 
    oprot.writeFieldStop()
21643 
    oprot.writeStructEnd()
21644 
 
21645 
  def validate(self):
21646 
    return
21647 
 
21648 
 
21649 
  def __repr__(self):
21650 
    L = ['%s=%r' % (key, value)
21651 
      for key, value in self.__dict__.iteritems()]
21652 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21653 
 
21654 
  def __eq__(self, other):
21655 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21656 
 
21657 
  def __ne__(self, other):
21658 
    return not (self == other)
21659 
 
21660 
class refundTransaction_result:
21661 
  """
21662 
  Attributes:
21663 
   - ex
21664 
  """
21665 
 
21666 
  thrift_spec = (
21667 
    None, # 0
21668 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
21669 
  )
21670 
 
21671 
  def __init__(self, ex=None,):
21672 
    self.ex = ex
21673 
 
21674 
  def read(self, iprot):
21675 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21676 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21677 
      return
21678 
    iprot.readStructBegin()
21679 
    while True:
21680 
      (fname, ftype, fid) = iprot.readFieldBegin()
21681 
      if ftype == TType.STOP:
21682 
        break
21683 
      if fid == 1:
21684 
        if ftype == TType.STRUCT:
21685 
          self.ex = TransactionServiceException()
21686 
          self.ex.read(iprot)
21687 
        else:
21688 
          iprot.skip(ftype)
21689 
      else:
21690 
        iprot.skip(ftype)
21691 
      iprot.readFieldEnd()
21692 
    iprot.readStructEnd()
21693 
 
21694 
  def write(self, oprot):
21695 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21696 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21697 
      return
21698 
    oprot.writeStructBegin('refundTransaction_result')
21699 
    if self.ex is not None:
21700 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
21701 
      self.ex.write(oprot)
21702 
      oprot.writeFieldEnd()
21703 
    oprot.writeFieldStop()
21704 
    oprot.writeStructEnd()
21705 
 
21706 
  def validate(self):
21707 
    return
21708 
 
21709 
 
21710 
  def __repr__(self):
21711 
    L = ['%s=%r' % (key, value)
21712 
      for key, value in self.__dict__.iteritems()]
21713 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21714 
 
21715 
  def __eq__(self, other):
21716 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21717 
 
21718 
  def __ne__(self, other):
21719 
    return not (self == other)
4285 rajveer 21720 
 
4324 mandeep.dh 21721 
class updateShipmentAddress_args:
21722 
  """
21723 
  Attributes:
21724 
   - orderId
21725 
   - addressId
21726 
  """
21727 
 
21728 
  thrift_spec = (
21729 
    None, # 0
21730 
    (1, TType.I64, 'orderId', None, None, ), # 1
21731 
    (2, TType.I64, 'addressId', None, None, ), # 2
21732 
  )
21733 
 
21734 
  def __init__(self, orderId=None, addressId=None,):
21735 
    self.orderId = orderId
21736 
    self.addressId = addressId
21737 
 
21738 
  def read(self, iprot):
21739 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21740 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21741 
      return
21742 
    iprot.readStructBegin()
21743 
    while True:
21744 
      (fname, ftype, fid) = iprot.readFieldBegin()
21745 
      if ftype == TType.STOP:
21746 
        break
21747 
      if fid == 1:
21748 
        if ftype == TType.I64:
21749 
          self.orderId = iprot.readI64();
21750 
        else:
21751 
          iprot.skip(ftype)
21752 
      elif fid == 2:
21753 
        if ftype == TType.I64:
21754 
          self.addressId = iprot.readI64();
21755 
        else:
21756 
          iprot.skip(ftype)
21757 
      else:
21758 
        iprot.skip(ftype)
21759 
      iprot.readFieldEnd()
21760 
    iprot.readStructEnd()
21761 
 
21762 
  def write(self, oprot):
21763 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21764 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21765 
      return
21766 
    oprot.writeStructBegin('updateShipmentAddress_args')
21767 
    if self.orderId is not None:
21768 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
21769 
      oprot.writeI64(self.orderId)
21770 
      oprot.writeFieldEnd()
21771 
    if self.addressId is not None:
21772 
      oprot.writeFieldBegin('addressId', TType.I64, 2)
21773 
      oprot.writeI64(self.addressId)
21774 
      oprot.writeFieldEnd()
21775 
    oprot.writeFieldStop()
21776 
    oprot.writeStructEnd()
21777 
 
21778 
  def validate(self):
21779 
    return
21780 
 
21781 
 
21782 
  def __repr__(self):
21783 
    L = ['%s=%r' % (key, value)
21784 
      for key, value in self.__dict__.iteritems()]
21785 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21786 
 
21787 
  def __eq__(self, other):
21788 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21789 
 
21790 
  def __ne__(self, other):
21791 
    return not (self == other)
21792 
 
21793 
class updateShipmentAddress_result:
21794 
  """
21795 
  Attributes:
21796 
   - ex
21797 
  """
21798 
 
21799 
  thrift_spec = (
21800 
    None, # 0
21801 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
21802 
  )
21803 
 
21804 
  def __init__(self, ex=None,):
21805 
    self.ex = ex
21806 
 
21807 
  def read(self, iprot):
21808 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21809 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21810 
      return
21811 
    iprot.readStructBegin()
21812 
    while True:
21813 
      (fname, ftype, fid) = iprot.readFieldBegin()
21814 
      if ftype == TType.STOP:
21815 
        break
21816 
      if fid == 1:
21817 
        if ftype == TType.STRUCT:
21818 
          self.ex = TransactionServiceException()
21819 
          self.ex.read(iprot)
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
21831 
    oprot.writeStructBegin('updateShipmentAddress_result')
21832 
    if self.ex is not None:
21833 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
21834 
      self.ex.write(oprot)
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 
 
4285 rajveer 21854 
class acceptOrdersForItemId_args:
21855 
  """
21856 
  Attributes:
21857 
   - itemId
21858 
   - inventory
21859 
  """
21860 
 
21861 
  thrift_spec = (
21862 
    None, # 0
21863 
    (1, TType.I64, 'itemId', None, None, ), # 1
21864 
    (2, TType.I64, 'inventory', None, None, ), # 2
21865 
  )
21866 
 
21867 
  def __init__(self, itemId=None, inventory=None,):
21868 
    self.itemId = itemId
21869 
    self.inventory = inventory
21870 
 
21871 
  def read(self, iprot):
21872 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21873 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21874 
      return
21875 
    iprot.readStructBegin()
21876 
    while True:
21877 
      (fname, ftype, fid) = iprot.readFieldBegin()
21878 
      if ftype == TType.STOP:
21879 
        break
21880 
      if fid == 1:
21881 
        if ftype == TType.I64:
21882 
          self.itemId = iprot.readI64();
21883 
        else:
21884 
          iprot.skip(ftype)
21885 
      elif fid == 2:
21886 
        if ftype == TType.I64:
21887 
          self.inventory = iprot.readI64();
21888 
        else:
21889 
          iprot.skip(ftype)
21890 
      else:
21891 
        iprot.skip(ftype)
21892 
      iprot.readFieldEnd()
21893 
    iprot.readStructEnd()
21894 
 
21895 
  def write(self, oprot):
21896 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21897 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21898 
      return
21899 
    oprot.writeStructBegin('acceptOrdersForItemId_args')
21900 
    if self.itemId is not None:
21901 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
21902 
      oprot.writeI64(self.itemId)
21903 
      oprot.writeFieldEnd()
21904 
    if self.inventory is not None:
21905 
      oprot.writeFieldBegin('inventory', TType.I64, 2)
21906 
      oprot.writeI64(self.inventory)
21907 
      oprot.writeFieldEnd()
21908 
    oprot.writeFieldStop()
21909 
    oprot.writeStructEnd()
21910 
 
21911 
  def validate(self):
21912 
    return
21913 
 
21914 
 
21915 
  def __repr__(self):
21916 
    L = ['%s=%r' % (key, value)
21917 
      for key, value in self.__dict__.iteritems()]
21918 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21919 
 
21920 
  def __eq__(self, other):
21921 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21922 
 
21923 
  def __ne__(self, other):
21924 
    return not (self == other)
21925 
 
21926 
class acceptOrdersForItemId_result:
21927 
  """
21928 
  Attributes:
21929 
   - success
21930 
   - ex
21931 
  """
21932 
 
21933 
  thrift_spec = (
21934 
    (0, TType.BOOL, 'success', None, None, ), # 0
21935 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
21936 
  )
21937 
 
21938 
  def __init__(self, success=None, ex=None,):
21939 
    self.success = success
21940 
    self.ex = ex
21941 
 
21942 
  def read(self, iprot):
21943 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21944 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21945 
      return
21946 
    iprot.readStructBegin()
21947 
    while True:
21948 
      (fname, ftype, fid) = iprot.readFieldBegin()
21949 
      if ftype == TType.STOP:
21950 
        break
21951 
      if fid == 0:
21952 
        if ftype == TType.BOOL:
21953 
          self.success = iprot.readBool();
21954 
        else:
21955 
          iprot.skip(ftype)
21956 
      elif fid == 1:
21957 
        if ftype == TType.STRUCT:
21958 
          self.ex = TransactionServiceException()
21959 
          self.ex.read(iprot)
21960 
        else:
21961 
          iprot.skip(ftype)
21962 
      else:
21963 
        iprot.skip(ftype)
21964 
      iprot.readFieldEnd()
21965 
    iprot.readStructEnd()
21966 
 
21967 
  def write(self, oprot):
21968 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21969 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21970 
      return
21971 
    oprot.writeStructBegin('acceptOrdersForItemId_result')
21972 
    if self.success is not None:
21973 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
21974 
      oprot.writeBool(self.success)
21975 
      oprot.writeFieldEnd()
21976 
    if self.ex is not None:
21977 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
21978 
      self.ex.write(oprot)
21979 
      oprot.writeFieldEnd()
21980 
    oprot.writeFieldStop()
21981 
    oprot.writeStructEnd()
21982 
 
21983 
  def validate(self):
21984 
    return
21985 
 
21986 
 
21987 
  def __repr__(self):
21988 
    L = ['%s=%r' % (key, value)
21989 
      for key, value in self.__dict__.iteritems()]
21990 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21991 
 
21992 
  def __eq__(self, other):
21993 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21994 
 
21995 
  def __ne__(self, other):
21996 
    return not (self == other)
4303 rajveer 21997 
 
21998 
class markOrdersAsPORaised_args:
21999 
  """
22000 
  Attributes:
22001 
   - vendorId
22002 
   - itemId
22003 
   - quantity
22004 
   - estimate
4369 rajveer 22005 
   - isReminder
4303 rajveer 22006 
  """
22007 
 
22008 
  thrift_spec = (
22009 
    None, # 0
22010 
    (1, TType.I64, 'vendorId', None, None, ), # 1
22011 
    (2, TType.I64, 'itemId', None, None, ), # 2
22012 
    (3, TType.I64, 'quantity', None, None, ), # 3
22013 
    (4, TType.I64, 'estimate', None, None, ), # 4
4369 rajveer 22014 
    (5, TType.BOOL, 'isReminder', None, None, ), # 5
4303 rajveer 22015 
  )
22016 
 
4369 rajveer 22017 
  def __init__(self, vendorId=None, itemId=None, quantity=None, estimate=None, isReminder=None,):
4303 rajveer 22018 
    self.vendorId = vendorId
22019 
    self.itemId = itemId
22020 
    self.quantity = quantity
22021 
    self.estimate = estimate
4369 rajveer 22022 
    self.isReminder = isReminder
4303 rajveer 22023 
 
22024 
  def read(self, iprot):
22025 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22026 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22027 
      return
22028 
    iprot.readStructBegin()
22029 
    while True:
22030 
      (fname, ftype, fid) = iprot.readFieldBegin()
22031 
      if ftype == TType.STOP:
22032 
        break
22033 
      if fid == 1:
22034 
        if ftype == TType.I64:
22035 
          self.vendorId = iprot.readI64();
22036 
        else:
22037 
          iprot.skip(ftype)
22038 
      elif fid == 2:
22039 
        if ftype == TType.I64:
22040 
          self.itemId = iprot.readI64();
22041 
        else:
22042 
          iprot.skip(ftype)
22043 
      elif fid == 3:
22044 
        if ftype == TType.I64:
22045 
          self.quantity = iprot.readI64();
22046 
        else:
22047 
          iprot.skip(ftype)
22048 
      elif fid == 4:
22049 
        if ftype == TType.I64:
22050 
          self.estimate = iprot.readI64();
22051 
        else:
22052 
          iprot.skip(ftype)
4369 rajveer 22053 
      elif fid == 5:
22054 
        if ftype == TType.BOOL:
22055 
          self.isReminder = iprot.readBool();
22056 
        else:
22057 
          iprot.skip(ftype)
4303 rajveer 22058 
      else:
22059 
        iprot.skip(ftype)
22060 
      iprot.readFieldEnd()
22061 
    iprot.readStructEnd()
22062 
 
22063 
  def write(self, oprot):
22064 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22065 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22066 
      return
22067 
    oprot.writeStructBegin('markOrdersAsPORaised_args')
22068 
    if self.vendorId is not None:
22069 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
22070 
      oprot.writeI64(self.vendorId)
22071 
      oprot.writeFieldEnd()
22072 
    if self.itemId is not None:
22073 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
22074 
      oprot.writeI64(self.itemId)
22075 
      oprot.writeFieldEnd()
22076 
    if self.quantity is not None:
22077 
      oprot.writeFieldBegin('quantity', TType.I64, 3)
22078 
      oprot.writeI64(self.quantity)
22079 
      oprot.writeFieldEnd()
22080 
    if self.estimate is not None:
22081 
      oprot.writeFieldBegin('estimate', TType.I64, 4)
22082 
      oprot.writeI64(self.estimate)
22083 
      oprot.writeFieldEnd()
4369 rajveer 22084 
    if self.isReminder is not None:
22085 
      oprot.writeFieldBegin('isReminder', TType.BOOL, 5)
22086 
      oprot.writeBool(self.isReminder)
22087 
      oprot.writeFieldEnd()
4303 rajveer 22088 
    oprot.writeFieldStop()
22089 
    oprot.writeStructEnd()
22090 
 
22091 
  def validate(self):
22092 
    return
22093 
 
22094 
 
22095 
  def __repr__(self):
22096 
    L = ['%s=%r' % (key, value)
22097 
      for key, value in self.__dict__.iteritems()]
22098 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22099 
 
22100 
  def __eq__(self, other):
22101 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22102 
 
22103 
  def __ne__(self, other):
22104 
    return not (self == other)
22105 
 
22106 
class markOrdersAsPORaised_result:
22107 
  """
22108 
  Attributes:
22109 
   - ex
22110 
  """
22111 
 
22112 
  thrift_spec = (
22113 
    None, # 0
22114 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
22115 
  )
22116 
 
22117 
  def __init__(self, ex=None,):
22118 
    self.ex = ex
22119 
 
22120 
  def read(self, iprot):
22121 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22122 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22123 
      return
22124 
    iprot.readStructBegin()
22125 
    while True:
22126 
      (fname, ftype, fid) = iprot.readFieldBegin()
22127 
      if ftype == TType.STOP:
22128 
        break
22129 
      if fid == 1:
22130 
        if ftype == TType.STRUCT:
22131 
          self.ex = TransactionServiceException()
22132 
          self.ex.read(iprot)
22133 
        else:
22134 
          iprot.skip(ftype)
22135 
      else:
22136 
        iprot.skip(ftype)
22137 
      iprot.readFieldEnd()
22138 
    iprot.readStructEnd()
22139 
 
22140 
  def write(self, oprot):
22141 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22142 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22143 
      return
22144 
    oprot.writeStructBegin('markOrdersAsPORaised_result')
22145 
    if self.ex is not None:
22146 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
22147 
      self.ex.write(oprot)
22148 
      oprot.writeFieldEnd()
22149 
    oprot.writeFieldStop()
22150 
    oprot.writeStructEnd()
22151 
 
22152 
  def validate(self):
22153 
    return
22154 
 
22155 
 
22156 
  def __repr__(self):
22157 
    L = ['%s=%r' % (key, value)
22158 
      for key, value in self.__dict__.iteritems()]
22159 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22160 
 
22161 
  def __eq__(self, other):
22162 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22163 
 
22164 
  def __ne__(self, other):
22165 
    return not (self == other)
22166 
 
22167 
class markOrdersAsReversalInitiated_args:
22168 
  """
22169 
  Attributes:
22170 
   - vendorId
22171 
   - itemId
22172 
   - quantity
22173 
   - estimate
4369 rajveer 22174 
   - isReminder
4303 rajveer 22175 
  """
22176 
 
22177 
  thrift_spec = (
22178 
    None, # 0
22179 
    (1, TType.I64, 'vendorId', None, None, ), # 1
22180 
    (2, TType.I64, 'itemId', None, None, ), # 2
22181 
    (3, TType.I64, 'quantity', None, None, ), # 3
22182 
    (4, TType.I64, 'estimate', None, None, ), # 4
4369 rajveer 22183 
    (5, TType.BOOL, 'isReminder', None, None, ), # 5
4303 rajveer 22184 
  )
22185 
 
4369 rajveer 22186 
  def __init__(self, vendorId=None, itemId=None, quantity=None, estimate=None, isReminder=None,):
4303 rajveer 22187 
    self.vendorId = vendorId
22188 
    self.itemId = itemId
22189 
    self.quantity = quantity
22190 
    self.estimate = estimate
4369 rajveer 22191 
    self.isReminder = isReminder
4303 rajveer 22192 
 
22193 
  def read(self, iprot):
22194 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22195 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22196 
      return
22197 
    iprot.readStructBegin()
22198 
    while True:
22199 
      (fname, ftype, fid) = iprot.readFieldBegin()
22200 
      if ftype == TType.STOP:
22201 
        break
22202 
      if fid == 1:
22203 
        if ftype == TType.I64:
22204 
          self.vendorId = iprot.readI64();
22205 
        else:
22206 
          iprot.skip(ftype)
22207 
      elif fid == 2:
22208 
        if ftype == TType.I64:
22209 
          self.itemId = iprot.readI64();
22210 
        else:
22211 
          iprot.skip(ftype)
22212 
      elif fid == 3:
22213 
        if ftype == TType.I64:
22214 
          self.quantity = iprot.readI64();
22215 
        else:
22216 
          iprot.skip(ftype)
22217 
      elif fid == 4:
22218 
        if ftype == TType.I64:
22219 
          self.estimate = iprot.readI64();
22220 
        else:
22221 
          iprot.skip(ftype)
4369 rajveer 22222 
      elif fid == 5:
22223 
        if ftype == TType.BOOL:
22224 
          self.isReminder = iprot.readBool();
22225 
        else:
22226 
          iprot.skip(ftype)
4303 rajveer 22227 
      else:
22228 
        iprot.skip(ftype)
22229 
      iprot.readFieldEnd()
22230 
    iprot.readStructEnd()
22231 
 
22232 
  def write(self, oprot):
22233 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22234 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22235 
      return
22236 
    oprot.writeStructBegin('markOrdersAsReversalInitiated_args')
22237 
    if self.vendorId is not None:
22238 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
22239 
      oprot.writeI64(self.vendorId)
22240 
      oprot.writeFieldEnd()
22241 
    if self.itemId is not None:
22242 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
22243 
      oprot.writeI64(self.itemId)
22244 
      oprot.writeFieldEnd()
22245 
    if self.quantity is not None:
22246 
      oprot.writeFieldBegin('quantity', TType.I64, 3)
22247 
      oprot.writeI64(self.quantity)
22248 
      oprot.writeFieldEnd()
22249 
    if self.estimate is not None:
22250 
      oprot.writeFieldBegin('estimate', TType.I64, 4)
22251 
      oprot.writeI64(self.estimate)
22252 
      oprot.writeFieldEnd()
4369 rajveer 22253 
    if self.isReminder is not None:
22254 
      oprot.writeFieldBegin('isReminder', TType.BOOL, 5)
22255 
      oprot.writeBool(self.isReminder)
22256 
      oprot.writeFieldEnd()
4303 rajveer 22257 
    oprot.writeFieldStop()
22258 
    oprot.writeStructEnd()
22259 
 
22260 
  def validate(self):
22261 
    return
22262 
 
22263 
 
22264 
  def __repr__(self):
22265 
    L = ['%s=%r' % (key, value)
22266 
      for key, value in self.__dict__.iteritems()]
22267 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22268 
 
22269 
  def __eq__(self, other):
22270 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22271 
 
22272 
  def __ne__(self, other):
22273 
    return not (self == other)
22274 
 
22275 
class markOrdersAsReversalInitiated_result:
22276 
  """
22277 
  Attributes:
22278 
   - ex
22279 
  """
22280 
 
22281 
  thrift_spec = (
22282 
    None, # 0
22283 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
22284 
  )
22285 
 
22286 
  def __init__(self, ex=None,):
22287 
    self.ex = ex
22288 
 
22289 
  def read(self, iprot):
22290 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22291 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22292 
      return
22293 
    iprot.readStructBegin()
22294 
    while True:
22295 
      (fname, ftype, fid) = iprot.readFieldBegin()
22296 
      if ftype == TType.STOP:
22297 
        break
22298 
      if fid == 1:
22299 
        if ftype == TType.STRUCT:
22300 
          self.ex = TransactionServiceException()
22301 
          self.ex.read(iprot)
22302 
        else:
22303 
          iprot.skip(ftype)
22304 
      else:
22305 
        iprot.skip(ftype)
22306 
      iprot.readFieldEnd()
22307 
    iprot.readStructEnd()
22308 
 
22309 
  def write(self, oprot):
22310 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22311 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22312 
      return
22313 
    oprot.writeStructBegin('markOrdersAsReversalInitiated_result')
22314 
    if self.ex is not None:
22315 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
22316 
      self.ex.write(oprot)
22317 
      oprot.writeFieldEnd()
22318 
    oprot.writeFieldStop()
22319 
    oprot.writeStructEnd()
22320 
 
22321 
  def validate(self):
22322 
    return
22323 
 
22324 
 
22325 
  def __repr__(self):
22326 
    L = ['%s=%r' % (key, value)
22327 
      for key, value in self.__dict__.iteritems()]
22328 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22329 
 
22330 
  def __eq__(self, other):
22331 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22332 
 
22333 
  def __ne__(self, other):
22334 
    return not (self == other)
22335 
 
22336 
class markOrdersAsNotAvailabke_args:
22337 
  """
22338 
  Attributes:
22339 
   - vendorId
22340 
   - itemId
22341 
   - quantity
22342 
   - estimate
4369 rajveer 22343 
   - isReminder
4303 rajveer 22344 
  """
22345 
 
22346 
  thrift_spec = (
22347 
    None, # 0
22348 
    (1, TType.I64, 'vendorId', None, None, ), # 1
22349 
    (2, TType.I64, 'itemId', None, None, ), # 2
22350 
    (3, TType.I64, 'quantity', None, None, ), # 3
22351 
    (4, TType.I64, 'estimate', None, None, ), # 4
4369 rajveer 22352 
    (5, TType.BOOL, 'isReminder', None, None, ), # 5
4303 rajveer 22353 
  )
22354 
 
4369 rajveer 22355 
  def __init__(self, vendorId=None, itemId=None, quantity=None, estimate=None, isReminder=None,):
4303 rajveer 22356 
    self.vendorId = vendorId
22357 
    self.itemId = itemId
22358 
    self.quantity = quantity
22359 
    self.estimate = estimate
4369 rajveer 22360 
    self.isReminder = isReminder
4303 rajveer 22361 
 
22362 
  def read(self, iprot):
22363 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22364 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22365 
      return
22366 
    iprot.readStructBegin()
22367 
    while True:
22368 
      (fname, ftype, fid) = iprot.readFieldBegin()
22369 
      if ftype == TType.STOP:
22370 
        break
22371 
      if fid == 1:
22372 
        if ftype == TType.I64:
22373 
          self.vendorId = iprot.readI64();
22374 
        else:
22375 
          iprot.skip(ftype)
22376 
      elif fid == 2:
22377 
        if ftype == TType.I64:
22378 
          self.itemId = iprot.readI64();
22379 
        else:
22380 
          iprot.skip(ftype)
22381 
      elif fid == 3:
22382 
        if ftype == TType.I64:
22383 
          self.quantity = iprot.readI64();
22384 
        else:
22385 
          iprot.skip(ftype)
22386 
      elif fid == 4:
22387 
        if ftype == TType.I64:
22388 
          self.estimate = iprot.readI64();
22389 
        else:
22390 
          iprot.skip(ftype)
4369 rajveer 22391 
      elif fid == 5:
22392 
        if ftype == TType.BOOL:
22393 
          self.isReminder = iprot.readBool();
22394 
        else:
22395 
          iprot.skip(ftype)
4303 rajveer 22396 
      else:
22397 
        iprot.skip(ftype)
22398 
      iprot.readFieldEnd()
22399 
    iprot.readStructEnd()
22400 
 
22401 
  def write(self, oprot):
22402 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22403 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22404 
      return
22405 
    oprot.writeStructBegin('markOrdersAsNotAvailabke_args')
22406 
    if self.vendorId is not None:
22407 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
22408 
      oprot.writeI64(self.vendorId)
22409 
      oprot.writeFieldEnd()
22410 
    if self.itemId is not None:
22411 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
22412 
      oprot.writeI64(self.itemId)
22413 
      oprot.writeFieldEnd()
22414 
    if self.quantity is not None:
22415 
      oprot.writeFieldBegin('quantity', TType.I64, 3)
22416 
      oprot.writeI64(self.quantity)
22417 
      oprot.writeFieldEnd()
22418 
    if self.estimate is not None:
22419 
      oprot.writeFieldBegin('estimate', TType.I64, 4)
22420 
      oprot.writeI64(self.estimate)
22421 
      oprot.writeFieldEnd()
4369 rajveer 22422 
    if self.isReminder is not None:
22423 
      oprot.writeFieldBegin('isReminder', TType.BOOL, 5)
22424 
      oprot.writeBool(self.isReminder)
22425 
      oprot.writeFieldEnd()
4303 rajveer 22426 
    oprot.writeFieldStop()
22427 
    oprot.writeStructEnd()
22428 
 
22429 
  def validate(self):
22430 
    return
22431 
 
22432 
 
22433 
  def __repr__(self):
22434 
    L = ['%s=%r' % (key, value)
22435 
      for key, value in self.__dict__.iteritems()]
22436 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22437 
 
22438 
  def __eq__(self, other):
22439 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22440 
 
22441 
  def __ne__(self, other):
22442 
    return not (self == other)
22443 
 
22444 
class markOrdersAsNotAvailabke_result:
22445 
  """
22446 
  Attributes:
22447 
   - ex
22448 
  """
22449 
 
22450 
  thrift_spec = (
22451 
    None, # 0
22452 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
22453 
  )
22454 
 
22455 
  def __init__(self, ex=None,):
22456 
    self.ex = ex
22457 
 
22458 
  def read(self, iprot):
22459 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22460 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22461 
      return
22462 
    iprot.readStructBegin()
22463 
    while True:
22464 
      (fname, ftype, fid) = iprot.readFieldBegin()
22465 
      if ftype == TType.STOP:
22466 
        break
22467 
      if fid == 1:
22468 
        if ftype == TType.STRUCT:
22469 
          self.ex = TransactionServiceException()
22470 
          self.ex.read(iprot)
22471 
        else:
22472 
          iprot.skip(ftype)
22473 
      else:
22474 
        iprot.skip(ftype)
22475 
      iprot.readFieldEnd()
22476 
    iprot.readStructEnd()
22477 
 
22478 
  def write(self, oprot):
22479 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22480 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22481 
      return
22482 
    oprot.writeStructBegin('markOrdersAsNotAvailabke_result')
22483 
    if self.ex is not None:
22484 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
22485 
      self.ex.write(oprot)
22486 
      oprot.writeFieldEnd()
22487 
    oprot.writeFieldStop()
22488 
    oprot.writeStructEnd()
22489 
 
22490 
  def validate(self):
22491 
    return
22492 
 
22493 
 
22494 
  def __repr__(self):
22495 
    L = ['%s=%r' % (key, value)
22496 
      for key, value in self.__dict__.iteritems()]
22497 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22498 
 
22499 
  def __eq__(self, other):
22500 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22501 
 
22502 
  def __ne__(self, other):
22503 
    return not (self == other)
4369 rajveer 22504 
 
22505 
class markOrdersAsTimeout_args:
22506 
  """
22507 
  Attributes:
22508 
   - vendorId
22509 
  """
22510 
 
22511 
  thrift_spec = (
22512 
    None, # 0
22513 
    (1, TType.I64, 'vendorId', None, None, ), # 1
22514 
  )
22515 
 
22516 
  def __init__(self, vendorId=None,):
22517 
    self.vendorId = vendorId
22518 
 
22519 
  def read(self, iprot):
22520 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22521 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22522 
      return
22523 
    iprot.readStructBegin()
22524 
    while True:
22525 
      (fname, ftype, fid) = iprot.readFieldBegin()
22526 
      if ftype == TType.STOP:
22527 
        break
22528 
      if fid == 1:
22529 
        if ftype == TType.I64:
22530 
          self.vendorId = iprot.readI64();
22531 
        else:
22532 
          iprot.skip(ftype)
22533 
      else:
22534 
        iprot.skip(ftype)
22535 
      iprot.readFieldEnd()
22536 
    iprot.readStructEnd()
22537 
 
22538 
  def write(self, oprot):
22539 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22540 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22541 
      return
22542 
    oprot.writeStructBegin('markOrdersAsTimeout_args')
22543 
    if self.vendorId is not None:
22544 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
22545 
      oprot.writeI64(self.vendorId)
22546 
      oprot.writeFieldEnd()
22547 
    oprot.writeFieldStop()
22548 
    oprot.writeStructEnd()
22549 
 
22550 
  def validate(self):
22551 
    return
22552 
 
22553 
 
22554 
  def __repr__(self):
22555 
    L = ['%s=%r' % (key, value)
22556 
      for key, value in self.__dict__.iteritems()]
22557 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22558 
 
22559 
  def __eq__(self, other):
22560 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22561 
 
22562 
  def __ne__(self, other):
22563 
    return not (self == other)
22564 
 
22565 
class markOrdersAsTimeout_result:
22566 
  """
22567 
  Attributes:
22568 
   - success
22569 
   - ex
22570 
  """
22571 
 
22572 
  thrift_spec = (
22573 
    (0, TType.MAP, 'success', (TType.I32,None,TType.STRUCT,(TimeoutSummary, TimeoutSummary.thrift_spec)), None, ), # 0
22574 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
22575 
  )
22576 
 
22577 
  def __init__(self, success=None, ex=None,):
22578 
    self.success = success
22579 
    self.ex = ex
22580 
 
22581 
  def read(self, iprot):
22582 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22583 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22584 
      return
22585 
    iprot.readStructBegin()
22586 
    while True:
22587 
      (fname, ftype, fid) = iprot.readFieldBegin()
22588 
      if ftype == TType.STOP:
22589 
        break
22590 
      if fid == 0:
22591 
        if ftype == TType.MAP:
22592 
          self.success = {}
6188 rajveer 22593 
          (_ktype502, _vtype503, _size501 ) = iprot.readMapBegin()
22594 
          for _i505 in xrange(_size501):
22595 
            _key506 = iprot.readI32();
22596 
            _val507 = TimeoutSummary()
22597 
            _val507.read(iprot)
22598 
            self.success[_key506] = _val507
4369 rajveer 22599 
          iprot.readMapEnd()
22600 
        else:
22601 
          iprot.skip(ftype)
22602 
      elif fid == 1:
22603 
        if ftype == TType.STRUCT:
22604 
          self.ex = TransactionServiceException()
22605 
          self.ex.read(iprot)
22606 
        else:
22607 
          iprot.skip(ftype)
22608 
      else:
22609 
        iprot.skip(ftype)
22610 
      iprot.readFieldEnd()
22611 
    iprot.readStructEnd()
22612 
 
22613 
  def write(self, oprot):
22614 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22615 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22616 
      return
22617 
    oprot.writeStructBegin('markOrdersAsTimeout_result')
22618 
    if self.success is not None:
22619 
      oprot.writeFieldBegin('success', TType.MAP, 0)
22620 
      oprot.writeMapBegin(TType.I32, TType.STRUCT, len(self.success))
6188 rajveer 22621 
      for kiter508,viter509 in self.success.items():
22622 
        oprot.writeI32(kiter508)
22623 
        viter509.write(oprot)
4369 rajveer 22624 
      oprot.writeMapEnd()
22625 
      oprot.writeFieldEnd()
22626 
    if self.ex is not None:
22627 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
22628 
      self.ex.write(oprot)
22629 
      oprot.writeFieldEnd()
22630 
    oprot.writeFieldStop()
22631 
    oprot.writeStructEnd()
22632 
 
22633 
  def validate(self):
22634 
    return
22635 
 
22636 
 
22637 
  def __repr__(self):
22638 
    L = ['%s=%r' % (key, value)
22639 
      for key, value in self.__dict__.iteritems()]
22640 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22641 
 
22642 
  def __eq__(self, other):
22643 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22644 
 
22645 
  def __ne__(self, other):
22646 
    return not (self == other)
4386 anupam.sin 22647 
 
4662 rajveer 22648 
class markOrderAsLostInTransit_args:
22649 
  """
22650 
  Attributes:
22651 
   - orderId
22652 
  """
22653 
 
22654 
  thrift_spec = (
22655 
    None, # 0
22656 
    (1, TType.I64, 'orderId', None, None, ), # 1
22657 
  )
22658 
 
22659 
  def __init__(self, orderId=None,):
22660 
    self.orderId = orderId
22661 
 
22662 
  def read(self, iprot):
22663 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22664 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22665 
      return
22666 
    iprot.readStructBegin()
22667 
    while True:
22668 
      (fname, ftype, fid) = iprot.readFieldBegin()
22669 
      if ftype == TType.STOP:
22670 
        break
22671 
      if fid == 1:
22672 
        if ftype == TType.I64:
22673 
          self.orderId = iprot.readI64();
22674 
        else:
22675 
          iprot.skip(ftype)
22676 
      else:
22677 
        iprot.skip(ftype)
22678 
      iprot.readFieldEnd()
22679 
    iprot.readStructEnd()
22680 
 
22681 
  def write(self, oprot):
22682 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22683 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22684 
      return
22685 
    oprot.writeStructBegin('markOrderAsLostInTransit_args')
22686 
    if self.orderId is not None:
22687 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
22688 
      oprot.writeI64(self.orderId)
22689 
      oprot.writeFieldEnd()
22690 
    oprot.writeFieldStop()
22691 
    oprot.writeStructEnd()
22692 
 
22693 
  def validate(self):
22694 
    return
22695 
 
22696 
 
22697 
  def __repr__(self):
22698 
    L = ['%s=%r' % (key, value)
22699 
      for key, value in self.__dict__.iteritems()]
22700 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22701 
 
22702 
  def __eq__(self, other):
22703 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22704 
 
22705 
  def __ne__(self, other):
22706 
    return not (self == other)
22707 
 
22708 
class markOrderAsLostInTransit_result:
22709 
  """
22710 
  Attributes:
22711 
   - success
22712 
   - ex
22713 
  """
22714 
 
22715 
  thrift_spec = (
22716 
    (0, TType.BOOL, 'success', None, None, ), # 0
22717 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
22718 
  )
22719 
 
22720 
  def __init__(self, success=None, ex=None,):
22721 
    self.success = success
22722 
    self.ex = ex
22723 
 
22724 
  def read(self, iprot):
22725 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22726 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22727 
      return
22728 
    iprot.readStructBegin()
22729 
    while True:
22730 
      (fname, ftype, fid) = iprot.readFieldBegin()
22731 
      if ftype == TType.STOP:
22732 
        break
22733 
      if fid == 0:
22734 
        if ftype == TType.BOOL:
22735 
          self.success = iprot.readBool();
22736 
        else:
22737 
          iprot.skip(ftype)
22738 
      elif fid == 1:
22739 
        if ftype == TType.STRUCT:
22740 
          self.ex = TransactionServiceException()
22741 
          self.ex.read(iprot)
22742 
        else:
22743 
          iprot.skip(ftype)
22744 
      else:
22745 
        iprot.skip(ftype)
22746 
      iprot.readFieldEnd()
22747 
    iprot.readStructEnd()
22748 
 
22749 
  def write(self, oprot):
22750 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22751 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22752 
      return
22753 
    oprot.writeStructBegin('markOrderAsLostInTransit_result')
22754 
    if self.success is not None:
22755 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
22756 
      oprot.writeBool(self.success)
22757 
      oprot.writeFieldEnd()
22758 
    if self.ex is not None:
22759 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
22760 
      self.ex.write(oprot)
22761 
      oprot.writeFieldEnd()
22762 
    oprot.writeFieldStop()
22763 
    oprot.writeStructEnd()
22764 
 
22765 
  def validate(self):
22766 
    return
22767 
 
22768 
 
22769 
  def __repr__(self):
22770 
    L = ['%s=%r' % (key, value)
22771 
      for key, value in self.__dict__.iteritems()]
22772 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22773 
 
22774 
  def __eq__(self, other):
22775 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22776 
 
22777 
  def __ne__(self, other):
22778 
    return not (self == other)
22779 
 
4386 anupam.sin 22780 
class getOrderForAwb_args:
22781 
  """
22782 
  Attributes:
22783 
   - awb
22784 
  """
22785 
 
22786 
  thrift_spec = (
22787 
    None, # 0
22788 
    (1, TType.STRING, 'awb', None, None, ), # 1
22789 
  )
22790 
 
22791 
  def __init__(self, awb=None,):
22792 
    self.awb = awb
22793 
 
22794 
  def read(self, iprot):
22795 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22796 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22797 
      return
22798 
    iprot.readStructBegin()
22799 
    while True:
22800 
      (fname, ftype, fid) = iprot.readFieldBegin()
22801 
      if ftype == TType.STOP:
22802 
        break
22803 
      if fid == 1:
22804 
        if ftype == TType.STRING:
22805 
          self.awb = iprot.readString();
22806 
        else:
22807 
          iprot.skip(ftype)
22808 
      else:
22809 
        iprot.skip(ftype)
22810 
      iprot.readFieldEnd()
22811 
    iprot.readStructEnd()
22812 
 
22813 
  def write(self, oprot):
22814 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22815 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22816 
      return
22817 
    oprot.writeStructBegin('getOrderForAwb_args')
22818 
    if self.awb is not None:
22819 
      oprot.writeFieldBegin('awb', TType.STRING, 1)
22820 
      oprot.writeString(self.awb)
22821 
      oprot.writeFieldEnd()
22822 
    oprot.writeFieldStop()
22823 
    oprot.writeStructEnd()
22824 
 
22825 
  def validate(self):
22826 
    return
22827 
 
22828 
 
22829 
  def __repr__(self):
22830 
    L = ['%s=%r' % (key, value)
22831 
      for key, value in self.__dict__.iteritems()]
22832 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22833 
 
22834 
  def __eq__(self, other):
22835 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22836 
 
22837 
  def __ne__(self, other):
22838 
    return not (self == other)
22839 
 
22840 
class getOrderForAwb_result:
22841 
  """
22842 
  Attributes:
22843 
   - success
22844 
   - ex
22845 
  """
22846 
 
22847 
  thrift_spec = (
22848 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
22849 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
22850 
  )
22851 
 
22852 
  def __init__(self, success=None, ex=None,):
22853 
    self.success = success
22854 
    self.ex = ex
22855 
 
22856 
  def read(self, iprot):
22857 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22858 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22859 
      return
22860 
    iprot.readStructBegin()
22861 
    while True:
22862 
      (fname, ftype, fid) = iprot.readFieldBegin()
22863 
      if ftype == TType.STOP:
22864 
        break
22865 
      if fid == 0:
22866 
        if ftype == TType.STRUCT:
22867 
          self.success = Order()
22868 
          self.success.read(iprot)
22869 
        else:
22870 
          iprot.skip(ftype)
22871 
      elif fid == 1:
22872 
        if ftype == TType.STRUCT:
22873 
          self.ex = TransactionServiceException()
22874 
          self.ex.read(iprot)
22875 
        else:
22876 
          iprot.skip(ftype)
22877 
      else:
22878 
        iprot.skip(ftype)
22879 
      iprot.readFieldEnd()
22880 
    iprot.readStructEnd()
22881 
 
22882 
  def write(self, oprot):
22883 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22884 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22885 
      return
22886 
    oprot.writeStructBegin('getOrderForAwb_result')
22887 
    if self.success is not None:
22888 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
22889 
      self.success.write(oprot)
22890 
      oprot.writeFieldEnd()
22891 
    if self.ex is not None:
22892 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
22893 
      self.ex.write(oprot)
22894 
      oprot.writeFieldEnd()
22895 
    oprot.writeFieldStop()
22896 
    oprot.writeStructEnd()
22897 
 
22898 
  def validate(self):
22899 
    return
22900 
 
22901 
 
22902 
  def __repr__(self):
22903 
    L = ['%s=%r' % (key, value)
22904 
      for key, value in self.__dict__.iteritems()]
22905 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22906 
 
22907 
  def __eq__(self, other):
22908 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22909 
 
22910 
  def __ne__(self, other):
22911 
    return not (self == other)
4506 phani.kuma 22912 
 
22913 
class getOrdersForProviderForStatus_args:
22914 
  """
22915 
  Attributes:
22916 
   - logistics_provider_id
4910 phani.kuma 22917 
   - order_status_list
4506 phani.kuma 22918 
  """
22919 
 
22920 
  thrift_spec = (
22921 
    None, # 0
22922 
    (1, TType.I64, 'logistics_provider_id', None, None, ), # 1
4910 phani.kuma 22923 
    (2, TType.LIST, 'order_status_list', (TType.I32,None), None, ), # 2
4506 phani.kuma 22924 
  )
22925 
 
4910 phani.kuma 22926 
  def __init__(self, logistics_provider_id=None, order_status_list=None,):
4506 phani.kuma 22927 
    self.logistics_provider_id = logistics_provider_id
4910 phani.kuma 22928 
    self.order_status_list = order_status_list
4506 phani.kuma 22929 
 
22930 
  def read(self, iprot):
22931 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22932 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22933 
      return
22934 
    iprot.readStructBegin()
22935 
    while True:
22936 
      (fname, ftype, fid) = iprot.readFieldBegin()
22937 
      if ftype == TType.STOP:
22938 
        break
22939 
      if fid == 1:
22940 
        if ftype == TType.I64:
22941 
          self.logistics_provider_id = iprot.readI64();
22942 
        else:
22943 
          iprot.skip(ftype)
22944 
      elif fid == 2:
4910 phani.kuma 22945 
        if ftype == TType.LIST:
22946 
          self.order_status_list = []
6188 rajveer 22947 
          (_etype513, _size510) = iprot.readListBegin()
22948 
          for _i514 in xrange(_size510):
22949 
            _elem515 = iprot.readI32();
22950 
            self.order_status_list.append(_elem515)
4910 phani.kuma 22951 
          iprot.readListEnd()
4506 phani.kuma 22952 
        else:
22953 
          iprot.skip(ftype)
22954 
      else:
22955 
        iprot.skip(ftype)
22956 
      iprot.readFieldEnd()
22957 
    iprot.readStructEnd()
22958 
 
22959 
  def write(self, oprot):
22960 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22961 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22962 
      return
22963 
    oprot.writeStructBegin('getOrdersForProviderForStatus_args')
22964 
    if self.logistics_provider_id is not None:
22965 
      oprot.writeFieldBegin('logistics_provider_id', TType.I64, 1)
22966 
      oprot.writeI64(self.logistics_provider_id)
22967 
      oprot.writeFieldEnd()
4910 phani.kuma 22968 
    if self.order_status_list is not None:
22969 
      oprot.writeFieldBegin('order_status_list', TType.LIST, 2)
22970 
      oprot.writeListBegin(TType.I32, len(self.order_status_list))
6188 rajveer 22971 
      for iter516 in self.order_status_list:
22972 
        oprot.writeI32(iter516)
4910 phani.kuma 22973 
      oprot.writeListEnd()
4506 phani.kuma 22974 
      oprot.writeFieldEnd()
22975 
    oprot.writeFieldStop()
22976 
    oprot.writeStructEnd()
22977 
 
22978 
  def validate(self):
22979 
    return
22980 
 
22981 
 
22982 
  def __repr__(self):
22983 
    L = ['%s=%r' % (key, value)
22984 
      for key, value in self.__dict__.iteritems()]
22985 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22986 
 
22987 
  def __eq__(self, other):
22988 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22989 
 
22990 
  def __ne__(self, other):
22991 
    return not (self == other)
22992 
 
22993 
class getOrdersForProviderForStatus_result:
22994 
  """
22995 
  Attributes:
22996 
   - success
22997 
   - ex
22998 
  """
22999 
 
23000 
  thrift_spec = (
23001 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
23002 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
23003 
  )
23004 
 
23005 
  def __init__(self, success=None, ex=None,):
23006 
    self.success = success
23007 
    self.ex = ex
23008 
 
23009 
  def read(self, iprot):
23010 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23011 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23012 
      return
23013 
    iprot.readStructBegin()
23014 
    while True:
23015 
      (fname, ftype, fid) = iprot.readFieldBegin()
23016 
      if ftype == TType.STOP:
23017 
        break
23018 
      if fid == 0:
23019 
        if ftype == TType.LIST:
23020 
          self.success = []
6188 rajveer 23021 
          (_etype520, _size517) = iprot.readListBegin()
23022 
          for _i521 in xrange(_size517):
23023 
            _elem522 = Order()
23024 
            _elem522.read(iprot)
23025 
            self.success.append(_elem522)
4506 phani.kuma 23026 
          iprot.readListEnd()
23027 
        else:
23028 
          iprot.skip(ftype)
23029 
      elif fid == 1:
23030 
        if ftype == TType.STRUCT:
23031 
          self.ex = TransactionServiceException()
23032 
          self.ex.read(iprot)
23033 
        else:
23034 
          iprot.skip(ftype)
23035 
      else:
23036 
        iprot.skip(ftype)
23037 
      iprot.readFieldEnd()
23038 
    iprot.readStructEnd()
23039 
 
23040 
  def write(self, oprot):
23041 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23042 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23043 
      return
23044 
    oprot.writeStructBegin('getOrdersForProviderForStatus_result')
23045 
    if self.success is not None:
23046 
      oprot.writeFieldBegin('success', TType.LIST, 0)
23047 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 23048 
      for iter523 in self.success:
23049 
        iter523.write(oprot)
4506 phani.kuma 23050 
      oprot.writeListEnd()
23051 
      oprot.writeFieldEnd()
23052 
    if self.ex is not None:
23053 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
23054 
      self.ex.write(oprot)
23055 
      oprot.writeFieldEnd()
23056 
    oprot.writeFieldStop()
23057 
    oprot.writeStructEnd()
23058 
 
23059 
  def validate(self):
23060 
    return
23061 
 
23062 
 
23063 
  def __repr__(self):
23064 
    L = ['%s=%r' % (key, value)
23065 
      for key, value in self.__dict__.iteritems()]
23066 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23067 
 
23068 
  def __eq__(self, other):
23069 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23070 
 
23071 
  def __ne__(self, other):
23072 
    return not (self == other)
4600 varun.gupt 23073 
 
23074 
class getBilledOrdersForVendor_args:
23075 
  """
23076 
  Attributes:
23077 
   - vendorId
23078 
   - billingDateFrom
23079 
   - billingDateTo
23080 
  """
23081 
 
23082 
  thrift_spec = (
23083 
    None, # 0
23084 
    (1, TType.I64, 'vendorId', None, None, ), # 1
23085 
    (2, TType.I64, 'billingDateFrom', None, None, ), # 2
23086 
    (3, TType.I64, 'billingDateTo', None, None, ), # 3
23087 
  )
23088 
 
23089 
  def __init__(self, vendorId=None, billingDateFrom=None, billingDateTo=None,):
23090 
    self.vendorId = vendorId
23091 
    self.billingDateFrom = billingDateFrom
23092 
    self.billingDateTo = billingDateTo
23093 
 
23094 
  def read(self, iprot):
23095 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23096 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23097 
      return
23098 
    iprot.readStructBegin()
23099 
    while True:
23100 
      (fname, ftype, fid) = iprot.readFieldBegin()
23101 
      if ftype == TType.STOP:
23102 
        break
23103 
      if fid == 1:
23104 
        if ftype == TType.I64:
23105 
          self.vendorId = iprot.readI64();
23106 
        else:
23107 
          iprot.skip(ftype)
23108 
      elif fid == 2:
23109 
        if ftype == TType.I64:
23110 
          self.billingDateFrom = iprot.readI64();
23111 
        else:
23112 
          iprot.skip(ftype)
23113 
      elif fid == 3:
23114 
        if ftype == TType.I64:
23115 
          self.billingDateTo = iprot.readI64();
23116 
        else:
23117 
          iprot.skip(ftype)
23118 
      else:
23119 
        iprot.skip(ftype)
23120 
      iprot.readFieldEnd()
23121 
    iprot.readStructEnd()
23122 
 
23123 
  def write(self, oprot):
23124 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23125 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23126 
      return
23127 
    oprot.writeStructBegin('getBilledOrdersForVendor_args')
23128 
    if self.vendorId is not None:
23129 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
23130 
      oprot.writeI64(self.vendorId)
23131 
      oprot.writeFieldEnd()
23132 
    if self.billingDateFrom is not None:
23133 
      oprot.writeFieldBegin('billingDateFrom', TType.I64, 2)
23134 
      oprot.writeI64(self.billingDateFrom)
23135 
      oprot.writeFieldEnd()
23136 
    if self.billingDateTo is not None:
23137 
      oprot.writeFieldBegin('billingDateTo', TType.I64, 3)
23138 
      oprot.writeI64(self.billingDateTo)
23139 
      oprot.writeFieldEnd()
23140 
    oprot.writeFieldStop()
23141 
    oprot.writeStructEnd()
23142 
 
23143 
  def validate(self):
23144 
    return
23145 
 
23146 
 
23147 
  def __repr__(self):
23148 
    L = ['%s=%r' % (key, value)
23149 
      for key, value in self.__dict__.iteritems()]
23150 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23151 
 
23152 
  def __eq__(self, other):
23153 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23154 
 
23155 
  def __ne__(self, other):
23156 
    return not (self == other)
23157 
 
23158 
class getBilledOrdersForVendor_result:
23159 
  """
23160 
  Attributes:
23161 
   - success
23162 
   - ex
23163 
  """
23164 
 
23165 
  thrift_spec = (
23166 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
23167 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
23168 
  )
23169 
 
23170 
  def __init__(self, success=None, ex=None,):
23171 
    self.success = success
23172 
    self.ex = ex
23173 
 
23174 
  def read(self, iprot):
23175 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23176 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23177 
      return
23178 
    iprot.readStructBegin()
23179 
    while True:
23180 
      (fname, ftype, fid) = iprot.readFieldBegin()
23181 
      if ftype == TType.STOP:
23182 
        break
23183 
      if fid == 0:
23184 
        if ftype == TType.LIST:
23185 
          self.success = []
6188 rajveer 23186 
          (_etype527, _size524) = iprot.readListBegin()
23187 
          for _i528 in xrange(_size524):
23188 
            _elem529 = Order()
23189 
            _elem529.read(iprot)
23190 
            self.success.append(_elem529)
4600 varun.gupt 23191 
          iprot.readListEnd()
23192 
        else:
23193 
          iprot.skip(ftype)
23194 
      elif fid == 1:
23195 
        if ftype == TType.STRUCT:
23196 
          self.ex = TransactionServiceException()
23197 
          self.ex.read(iprot)
23198 
        else:
23199 
          iprot.skip(ftype)
23200 
      else:
23201 
        iprot.skip(ftype)
23202 
      iprot.readFieldEnd()
23203 
    iprot.readStructEnd()
23204 
 
23205 
  def write(self, oprot):
23206 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23207 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23208 
      return
23209 
    oprot.writeStructBegin('getBilledOrdersForVendor_result')
23210 
    if self.success is not None:
23211 
      oprot.writeFieldBegin('success', TType.LIST, 0)
23212 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 23213 
      for iter530 in self.success:
23214 
        iter530.write(oprot)
4600 varun.gupt 23215 
      oprot.writeListEnd()
23216 
      oprot.writeFieldEnd()
23217 
    if self.ex is not None:
23218 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
23219 
      self.ex.write(oprot)
23220 
      oprot.writeFieldEnd()
23221 
    oprot.writeFieldStop()
23222 
    oprot.writeStructEnd()
23223 
 
23224 
  def validate(self):
23225 
    return
23226 
 
23227 
 
23228 
  def __repr__(self):
23229 
    L = ['%s=%r' % (key, value)
23230 
      for key, value in self.__dict__.iteritems()]
23231 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23232 
 
23233 
  def __eq__(self, other):
23234 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23235 
 
23236 
  def __ne__(self, other):
23237 
    return not (self == other)
23238 
 
4607 rajveer 23239 
class getSlippedSippingDateOrders_args:
23240 
 
23241 
  thrift_spec = (
23242 
  )
23243 
 
23244 
  def read(self, iprot):
23245 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23246 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23247 
      return
23248 
    iprot.readStructBegin()
23249 
    while True:
23250 
      (fname, ftype, fid) = iprot.readFieldBegin()
23251 
      if ftype == TType.STOP:
23252 
        break
23253 
      else:
23254 
        iprot.skip(ftype)
23255 
      iprot.readFieldEnd()
23256 
    iprot.readStructEnd()
23257 
 
23258 
  def write(self, oprot):
23259 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23260 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23261 
      return
23262 
    oprot.writeStructBegin('getSlippedSippingDateOrders_args')
23263 
    oprot.writeFieldStop()
23264 
    oprot.writeStructEnd()
23265 
 
23266 
  def validate(self):
23267 
    return
23268 
 
23269 
 
23270 
  def __repr__(self):
23271 
    L = ['%s=%r' % (key, value)
23272 
      for key, value in self.__dict__.iteritems()]
23273 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23274 
 
23275 
  def __eq__(self, other):
23276 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23277 
 
23278 
  def __ne__(self, other):
23279 
    return not (self == other)
23280 
 
23281 
class getSlippedSippingDateOrders_result:
23282 
  """
23283 
  Attributes:
23284 
   - success
23285 
   - ex
23286 
  """
23287 
 
23288 
  thrift_spec = (
23289 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
23290 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
23291 
  )
23292 
 
23293 
  def __init__(self, success=None, ex=None,):
23294 
    self.success = success
23295 
    self.ex = ex
23296 
 
23297 
  def read(self, iprot):
23298 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23299 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23300 
      return
23301 
    iprot.readStructBegin()
23302 
    while True:
23303 
      (fname, ftype, fid) = iprot.readFieldBegin()
23304 
      if ftype == TType.STOP:
23305 
        break
23306 
      if fid == 0:
23307 
        if ftype == TType.LIST:
23308 
          self.success = []
6188 rajveer 23309 
          (_etype534, _size531) = iprot.readListBegin()
23310 
          for _i535 in xrange(_size531):
23311 
            _elem536 = Order()
23312 
            _elem536.read(iprot)
23313 
            self.success.append(_elem536)
4607 rajveer 23314 
          iprot.readListEnd()
23315 
        else:
23316 
          iprot.skip(ftype)
23317 
      elif fid == 1:
23318 
        if ftype == TType.STRUCT:
23319 
          self.ex = TransactionServiceException()
23320 
          self.ex.read(iprot)
23321 
        else:
23322 
          iprot.skip(ftype)
23323 
      else:
23324 
        iprot.skip(ftype)
23325 
      iprot.readFieldEnd()
23326 
    iprot.readStructEnd()
23327 
 
23328 
  def write(self, oprot):
23329 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23330 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23331 
      return
23332 
    oprot.writeStructBegin('getSlippedSippingDateOrders_result')
23333 
    if self.success is not None:
23334 
      oprot.writeFieldBegin('success', TType.LIST, 0)
23335 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 23336 
      for iter537 in self.success:
23337 
        iter537.write(oprot)
4607 rajveer 23338 
      oprot.writeListEnd()
23339 
      oprot.writeFieldEnd()
23340 
    if self.ex is not None:
23341 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
23342 
      self.ex.write(oprot)
23343 
      oprot.writeFieldEnd()
23344 
    oprot.writeFieldStop()
23345 
    oprot.writeStructEnd()
23346 
 
23347 
  def validate(self):
23348 
    return
23349 
 
23350 
 
23351 
  def __repr__(self):
23352 
    L = ['%s=%r' % (key, value)
23353 
      for key, value in self.__dict__.iteritems()]
23354 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23355 
 
23356 
  def __eq__(self, other):
23357 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23358 
 
23359 
  def __ne__(self, other):
23360 
    return not (self == other)
23361 
 
4709 rajveer 23362 
class getCancelledOrders_args:
23363 
  """
23364 
  Attributes:
23365 
   - cancelDateFrom
23366 
   - cancelDateTo
23367 
  """
23368 
 
23369 
  thrift_spec = (
23370 
    None, # 0
23371 
    (1, TType.I64, 'cancelDateFrom', None, None, ), # 1
23372 
    (2, TType.I64, 'cancelDateTo', None, None, ), # 2
23373 
  )
23374 
 
23375 
  def __init__(self, cancelDateFrom=None, cancelDateTo=None,):
23376 
    self.cancelDateFrom = cancelDateFrom
23377 
    self.cancelDateTo = cancelDateTo
23378 
 
23379 
  def read(self, iprot):
23380 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23381 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23382 
      return
23383 
    iprot.readStructBegin()
23384 
    while True:
23385 
      (fname, ftype, fid) = iprot.readFieldBegin()
23386 
      if ftype == TType.STOP:
23387 
        break
23388 
      if fid == 1:
23389 
        if ftype == TType.I64:
23390 
          self.cancelDateFrom = iprot.readI64();
23391 
        else:
23392 
          iprot.skip(ftype)
23393 
      elif fid == 2:
23394 
        if ftype == TType.I64:
23395 
          self.cancelDateTo = iprot.readI64();
23396 
        else:
23397 
          iprot.skip(ftype)
23398 
      else:
23399 
        iprot.skip(ftype)
23400 
      iprot.readFieldEnd()
23401 
    iprot.readStructEnd()
23402 
 
23403 
  def write(self, oprot):
23404 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23405 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23406 
      return
23407 
    oprot.writeStructBegin('getCancelledOrders_args')
23408 
    if self.cancelDateFrom is not None:
23409 
      oprot.writeFieldBegin('cancelDateFrom', TType.I64, 1)
23410 
      oprot.writeI64(self.cancelDateFrom)
23411 
      oprot.writeFieldEnd()
23412 
    if self.cancelDateTo is not None:
23413 
      oprot.writeFieldBegin('cancelDateTo', TType.I64, 2)
23414 
      oprot.writeI64(self.cancelDateTo)
23415 
      oprot.writeFieldEnd()
23416 
    oprot.writeFieldStop()
23417 
    oprot.writeStructEnd()
23418 
 
23419 
  def validate(self):
23420 
    return
23421 
 
23422 
 
23423 
  def __repr__(self):
23424 
    L = ['%s=%r' % (key, value)
23425 
      for key, value in self.__dict__.iteritems()]
23426 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23427 
 
23428 
  def __eq__(self, other):
23429 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23430 
 
23431 
  def __ne__(self, other):
23432 
    return not (self == other)
23433 
 
23434 
class getCancelledOrders_result:
23435 
  """
23436 
  Attributes:
23437 
   - success
23438 
   - ex
23439 
  """
23440 
 
23441 
  thrift_spec = (
23442 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
23443 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
23444 
  )
23445 
 
23446 
  def __init__(self, success=None, ex=None,):
23447 
    self.success = success
23448 
    self.ex = ex
23449 
 
23450 
  def read(self, iprot):
23451 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23452 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23453 
      return
23454 
    iprot.readStructBegin()
23455 
    while True:
23456 
      (fname, ftype, fid) = iprot.readFieldBegin()
23457 
      if ftype == TType.STOP:
23458 
        break
23459 
      if fid == 0:
23460 
        if ftype == TType.LIST:
23461 
          self.success = []
6188 rajveer 23462 
          (_etype541, _size538) = iprot.readListBegin()
23463 
          for _i542 in xrange(_size538):
23464 
            _elem543 = Order()
23465 
            _elem543.read(iprot)
23466 
            self.success.append(_elem543)
4709 rajveer 23467 
          iprot.readListEnd()
23468 
        else:
23469 
          iprot.skip(ftype)
23470 
      elif fid == 1:
23471 
        if ftype == TType.STRUCT:
23472 
          self.ex = TransactionServiceException()
23473 
          self.ex.read(iprot)
23474 
        else:
23475 
          iprot.skip(ftype)
23476 
      else:
23477 
        iprot.skip(ftype)
23478 
      iprot.readFieldEnd()
23479 
    iprot.readStructEnd()
23480 
 
23481 
  def write(self, oprot):
23482 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23483 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23484 
      return
23485 
    oprot.writeStructBegin('getCancelledOrders_result')
23486 
    if self.success is not None:
23487 
      oprot.writeFieldBegin('success', TType.LIST, 0)
23488 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 23489 
      for iter544 in self.success:
23490 
        iter544.write(oprot)
4709 rajveer 23491 
      oprot.writeListEnd()
23492 
      oprot.writeFieldEnd()
23493 
    if self.ex is not None:
23494 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
23495 
      self.ex.write(oprot)
23496 
      oprot.writeFieldEnd()
23497 
    oprot.writeFieldStop()
23498 
    oprot.writeStructEnd()
23499 
 
23500 
  def validate(self):
23501 
    return
23502 
 
23503 
 
23504 
  def __repr__(self):
23505 
    L = ['%s=%r' % (key, value)
23506 
      for key, value in self.__dict__.iteritems()]
23507 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23508 
 
23509 
  def __eq__(self, other):
23510 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23511 
 
23512 
  def __ne__(self, other):
23513 
    return not (self == other)
23514 
 
4600 varun.gupt 23515 
class saveBluedartSettlements_args:
23516 
  """
23517 
  Attributes:
23518 
   - mapAWBAndAmount
23519 
  """
23520 
 
23521 
  thrift_spec = (
23522 
    None, # 0
23523 
    (1, TType.MAP, 'mapAWBAndAmount', (TType.I64,None,TType.DOUBLE,None), None, ), # 1
23524 
  )
23525 
 
23526 
  def __init__(self, mapAWBAndAmount=None,):
23527 
    self.mapAWBAndAmount = mapAWBAndAmount
23528 
 
23529 
  def read(self, iprot):
23530 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23531 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23532 
      return
23533 
    iprot.readStructBegin()
23534 
    while True:
23535 
      (fname, ftype, fid) = iprot.readFieldBegin()
23536 
      if ftype == TType.STOP:
23537 
        break
23538 
      if fid == 1:
23539 
        if ftype == TType.MAP:
23540 
          self.mapAWBAndAmount = {}
6188 rajveer 23541 
          (_ktype546, _vtype547, _size545 ) = iprot.readMapBegin()
23542 
          for _i549 in xrange(_size545):
23543 
            _key550 = iprot.readI64();
23544 
            _val551 = iprot.readDouble();
23545 
            self.mapAWBAndAmount[_key550] = _val551
4600 varun.gupt 23546 
          iprot.readMapEnd()
23547 
        else:
23548 
          iprot.skip(ftype)
23549 
      else:
23550 
        iprot.skip(ftype)
23551 
      iprot.readFieldEnd()
23552 
    iprot.readStructEnd()
23553 
 
23554 
  def write(self, oprot):
23555 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23556 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23557 
      return
23558 
    oprot.writeStructBegin('saveBluedartSettlements_args')
23559 
    if self.mapAWBAndAmount is not None:
23560 
      oprot.writeFieldBegin('mapAWBAndAmount', TType.MAP, 1)
23561 
      oprot.writeMapBegin(TType.I64, TType.DOUBLE, len(self.mapAWBAndAmount))
6188 rajveer 23562 
      for kiter552,viter553 in self.mapAWBAndAmount.items():
23563 
        oprot.writeI64(kiter552)
23564 
        oprot.writeDouble(viter553)
4600 varun.gupt 23565 
      oprot.writeMapEnd()
23566 
      oprot.writeFieldEnd()
23567 
    oprot.writeFieldStop()
23568 
    oprot.writeStructEnd()
23569 
 
23570 
  def validate(self):
23571 
    return
23572 
 
23573 
 
23574 
  def __repr__(self):
23575 
    L = ['%s=%r' % (key, value)
23576 
      for key, value in self.__dict__.iteritems()]
23577 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23578 
 
23579 
  def __eq__(self, other):
23580 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23581 
 
23582 
  def __ne__(self, other):
23583 
    return not (self == other)
23584 
 
23585 
class saveBluedartSettlements_result:
23586 
  """
23587 
  Attributes:
23588 
   - ex
23589 
  """
23590 
 
23591 
  thrift_spec = (
23592 
    None, # 0
23593 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
23594 
  )
23595 
 
23596 
  def __init__(self, ex=None,):
23597 
    self.ex = ex
23598 
 
23599 
  def read(self, iprot):
23600 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23601 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23602 
      return
23603 
    iprot.readStructBegin()
23604 
    while True:
23605 
      (fname, ftype, fid) = iprot.readFieldBegin()
23606 
      if ftype == TType.STOP:
23607 
        break
23608 
      if fid == 1:
23609 
        if ftype == TType.STRUCT:
23610 
          self.ex = TransactionServiceException()
23611 
          self.ex.read(iprot)
23612 
        else:
23613 
          iprot.skip(ftype)
23614 
      else:
23615 
        iprot.skip(ftype)
23616 
      iprot.readFieldEnd()
23617 
    iprot.readStructEnd()
23618 
 
23619 
  def write(self, oprot):
23620 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23621 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23622 
      return
23623 
    oprot.writeStructBegin('saveBluedartSettlements_result')
23624 
    if self.ex is not None:
23625 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
23626 
      self.ex.write(oprot)
23627 
      oprot.writeFieldEnd()
23628 
    oprot.writeFieldStop()
23629 
    oprot.writeStructEnd()
23630 
 
23631 
  def validate(self):
23632 
    return
23633 
 
23634 
 
23635 
  def __repr__(self):
23636 
    L = ['%s=%r' % (key, value)
23637 
      for key, value in self.__dict__.iteritems()]
23638 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23639 
 
23640 
  def __eq__(self, other):
23641 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23642 
 
23643 
  def __ne__(self, other):
23644 
    return not (self == other)
23645 
 
23646 
class savePaymentSettlements_args:
23647 
  """
23648 
  Attributes:
23649 
   - settlementDate
23650 
   - paymentGatewayId
4905 varun.gupt 23651 
   - referenceId
4600 varun.gupt 23652 
   - serviceTax
23653 
   - otherCharges
23654 
   - netCollection
23655 
  """
23656 
 
23657 
  thrift_spec = (
23658 
    None, # 0
23659 
    (1, TType.I64, 'settlementDate', None, None, ), # 1
23660 
    (2, TType.I64, 'paymentGatewayId', None, None, ), # 2
4905 varun.gupt 23661 
    (3, TType.I64, 'referenceId', None, None, ), # 3
4600 varun.gupt 23662 
    (4, TType.DOUBLE, 'serviceTax', None, None, ), # 4
23663 
    (5, TType.DOUBLE, 'otherCharges', None, None, ), # 5
23664 
    (6, TType.DOUBLE, 'netCollection', None, None, ), # 6
23665 
  )
23666 
 
4905 varun.gupt 23667 
  def __init__(self, settlementDate=None, paymentGatewayId=None, referenceId=None, serviceTax=None, otherCharges=None, netCollection=None,):
4600 varun.gupt 23668 
    self.settlementDate = settlementDate
23669 
    self.paymentGatewayId = paymentGatewayId
4905 varun.gupt 23670 
    self.referenceId = referenceId
4600 varun.gupt 23671 
    self.serviceTax = serviceTax
23672 
    self.otherCharges = otherCharges
23673 
    self.netCollection = netCollection
23674 
 
23675 
  def read(self, iprot):
23676 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23677 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23678 
      return
23679 
    iprot.readStructBegin()
23680 
    while True:
23681 
      (fname, ftype, fid) = iprot.readFieldBegin()
23682 
      if ftype == TType.STOP:
23683 
        break
23684 
      if fid == 1:
23685 
        if ftype == TType.I64:
23686 
          self.settlementDate = iprot.readI64();
23687 
        else:
23688 
          iprot.skip(ftype)
23689 
      elif fid == 2:
23690 
        if ftype == TType.I64:
23691 
          self.paymentGatewayId = iprot.readI64();
23692 
        else:
23693 
          iprot.skip(ftype)
23694 
      elif fid == 3:
23695 
        if ftype == TType.I64:
4905 varun.gupt 23696 
          self.referenceId = iprot.readI64();
4600 varun.gupt 23697 
        else:
23698 
          iprot.skip(ftype)
23699 
      elif fid == 4:
23700 
        if ftype == TType.DOUBLE:
23701 
          self.serviceTax = iprot.readDouble();
23702 
        else:
23703 
          iprot.skip(ftype)
23704 
      elif fid == 5:
23705 
        if ftype == TType.DOUBLE:
23706 
          self.otherCharges = iprot.readDouble();
23707 
        else:
23708 
          iprot.skip(ftype)
23709 
      elif fid == 6:
23710 
        if ftype == TType.DOUBLE:
23711 
          self.netCollection = iprot.readDouble();
23712 
        else:
23713 
          iprot.skip(ftype)
23714 
      else:
23715 
        iprot.skip(ftype)
23716 
      iprot.readFieldEnd()
23717 
    iprot.readStructEnd()
23718 
 
23719 
  def write(self, oprot):
23720 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23721 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23722 
      return
23723 
    oprot.writeStructBegin('savePaymentSettlements_args')
23724 
    if self.settlementDate is not None:
23725 
      oprot.writeFieldBegin('settlementDate', TType.I64, 1)
23726 
      oprot.writeI64(self.settlementDate)
23727 
      oprot.writeFieldEnd()
23728 
    if self.paymentGatewayId is not None:
23729 
      oprot.writeFieldBegin('paymentGatewayId', TType.I64, 2)
23730 
      oprot.writeI64(self.paymentGatewayId)
23731 
      oprot.writeFieldEnd()
4905 varun.gupt 23732 
    if self.referenceId is not None:
23733 
      oprot.writeFieldBegin('referenceId', TType.I64, 3)
23734 
      oprot.writeI64(self.referenceId)
4600 varun.gupt 23735 
      oprot.writeFieldEnd()
23736 
    if self.serviceTax is not None:
23737 
      oprot.writeFieldBegin('serviceTax', TType.DOUBLE, 4)
23738 
      oprot.writeDouble(self.serviceTax)
23739 
      oprot.writeFieldEnd()
23740 
    if self.otherCharges is not None:
23741 
      oprot.writeFieldBegin('otherCharges', TType.DOUBLE, 5)
23742 
      oprot.writeDouble(self.otherCharges)
23743 
      oprot.writeFieldEnd()
23744 
    if self.netCollection is not None:
23745 
      oprot.writeFieldBegin('netCollection', TType.DOUBLE, 6)
23746 
      oprot.writeDouble(self.netCollection)
23747 
      oprot.writeFieldEnd()
23748 
    oprot.writeFieldStop()
23749 
    oprot.writeStructEnd()
23750 
 
23751 
  def validate(self):
23752 
    return
23753 
 
23754 
 
23755 
  def __repr__(self):
23756 
    L = ['%s=%r' % (key, value)
23757 
      for key, value in self.__dict__.iteritems()]
23758 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23759 
 
23760 
  def __eq__(self, other):
23761 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23762 
 
23763 
  def __ne__(self, other):
23764 
    return not (self == other)
23765 
 
23766 
class savePaymentSettlements_result:
23767 
  """
23768 
  Attributes:
23769 
   - ex
23770 
  """
23771 
 
23772 
  thrift_spec = (
23773 
    None, # 0
23774 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
23775 
  )
23776 
 
23777 
  def __init__(self, ex=None,):
23778 
    self.ex = ex
23779 
 
23780 
  def read(self, iprot):
23781 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23782 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23783 
      return
23784 
    iprot.readStructBegin()
23785 
    while True:
23786 
      (fname, ftype, fid) = iprot.readFieldBegin()
23787 
      if ftype == TType.STOP:
23788 
        break
23789 
      if fid == 1:
23790 
        if ftype == TType.STRUCT:
23791 
          self.ex = TransactionServiceException()
23792 
          self.ex.read(iprot)
23793 
        else:
23794 
          iprot.skip(ftype)
23795 
      else:
23796 
        iprot.skip(ftype)
23797 
      iprot.readFieldEnd()
23798 
    iprot.readStructEnd()
23799 
 
23800 
  def write(self, oprot):
23801 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23802 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23803 
      return
23804 
    oprot.writeStructBegin('savePaymentSettlements_result')
23805 
    if self.ex is not None:
23806 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
23807 
      self.ex.write(oprot)
23808 
      oprot.writeFieldEnd()
23809 
    oprot.writeFieldStop()
23810 
    oprot.writeStructEnd()
23811 
 
23812 
  def validate(self):
23813 
    return
23814 
 
23815 
 
23816 
  def __repr__(self):
23817 
    L = ['%s=%r' % (key, value)
23818 
      for key, value in self.__dict__.iteritems()]
23819 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23820 
 
23821 
  def __eq__(self, other):
23822 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23823 
 
23824 
  def __ne__(self, other):
23825 
    return not (self == other)
23826 
 
23827 
class saveEBSSettlementSummary_args:
23828 
  """
23829 
  Attributes:
23830 
   - settlementId
23831 
   - settlementDate
23832 
   - transactionDateFrom
23833 
   - transactionDateTo
23834 
   - amount
23835 
  """
23836 
 
23837 
  thrift_spec = (
23838 
    None, # 0
23839 
    (1, TType.I64, 'settlementId', None, None, ), # 1
23840 
    (2, TType.I64, 'settlementDate', None, None, ), # 2
23841 
    (3, TType.I64, 'transactionDateFrom', None, None, ), # 3
23842 
    (4, TType.I64, 'transactionDateTo', None, None, ), # 4
23843 
    (5, TType.DOUBLE, 'amount', None, None, ), # 5
23844 
  )
23845 
 
23846 
  def __init__(self, settlementId=None, settlementDate=None, transactionDateFrom=None, transactionDateTo=None, amount=None,):
23847 
    self.settlementId = settlementId
23848 
    self.settlementDate = settlementDate
23849 
    self.transactionDateFrom = transactionDateFrom
23850 
    self.transactionDateTo = transactionDateTo
23851 
    self.amount = amount
23852 
 
23853 
  def read(self, iprot):
23854 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23855 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23856 
      return
23857 
    iprot.readStructBegin()
23858 
    while True:
23859 
      (fname, ftype, fid) = iprot.readFieldBegin()
23860 
      if ftype == TType.STOP:
23861 
        break
23862 
      if fid == 1:
23863 
        if ftype == TType.I64:
23864 
          self.settlementId = iprot.readI64();
23865 
        else:
23866 
          iprot.skip(ftype)
23867 
      elif fid == 2:
23868 
        if ftype == TType.I64:
23869 
          self.settlementDate = iprot.readI64();
23870 
        else:
23871 
          iprot.skip(ftype)
23872 
      elif fid == 3:
23873 
        if ftype == TType.I64:
23874 
          self.transactionDateFrom = iprot.readI64();
23875 
        else:
23876 
          iprot.skip(ftype)
23877 
      elif fid == 4:
23878 
        if ftype == TType.I64:
23879 
          self.transactionDateTo = iprot.readI64();
23880 
        else:
23881 
          iprot.skip(ftype)
23882 
      elif fid == 5:
23883 
        if ftype == TType.DOUBLE:
23884 
          self.amount = iprot.readDouble();
23885 
        else:
23886 
          iprot.skip(ftype)
23887 
      else:
23888 
        iprot.skip(ftype)
23889 
      iprot.readFieldEnd()
23890 
    iprot.readStructEnd()
23891 
 
23892 
  def write(self, oprot):
23893 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23894 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23895 
      return
23896 
    oprot.writeStructBegin('saveEBSSettlementSummary_args')
23897 
    if self.settlementId is not None:
23898 
      oprot.writeFieldBegin('settlementId', TType.I64, 1)
23899 
      oprot.writeI64(self.settlementId)
23900 
      oprot.writeFieldEnd()
23901 
    if self.settlementDate is not None:
23902 
      oprot.writeFieldBegin('settlementDate', TType.I64, 2)
23903 
      oprot.writeI64(self.settlementDate)
23904 
      oprot.writeFieldEnd()
23905 
    if self.transactionDateFrom is not None:
23906 
      oprot.writeFieldBegin('transactionDateFrom', TType.I64, 3)
23907 
      oprot.writeI64(self.transactionDateFrom)
23908 
      oprot.writeFieldEnd()
23909 
    if self.transactionDateTo is not None:
23910 
      oprot.writeFieldBegin('transactionDateTo', TType.I64, 4)
23911 
      oprot.writeI64(self.transactionDateTo)
23912 
      oprot.writeFieldEnd()
23913 
    if self.amount is not None:
23914 
      oprot.writeFieldBegin('amount', TType.DOUBLE, 5)
23915 
      oprot.writeDouble(self.amount)
23916 
      oprot.writeFieldEnd()
23917 
    oprot.writeFieldStop()
23918 
    oprot.writeStructEnd()
23919 
 
23920 
  def validate(self):
23921 
    return
23922 
 
23923 
 
23924 
  def __repr__(self):
23925 
    L = ['%s=%r' % (key, value)
23926 
      for key, value in self.__dict__.iteritems()]
23927 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23928 
 
23929 
  def __eq__(self, other):
23930 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23931 
 
23932 
  def __ne__(self, other):
23933 
    return not (self == other)
23934 
 
23935 
class saveEBSSettlementSummary_result:
23936 
  """
23937 
  Attributes:
23938 
   - ex
23939 
  """
23940 
 
23941 
  thrift_spec = (
23942 
    None, # 0
23943 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
23944 
  )
23945 
 
23946 
  def __init__(self, ex=None,):
23947 
    self.ex = ex
23948 
 
23949 
  def read(self, iprot):
23950 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23951 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23952 
      return
23953 
    iprot.readStructBegin()
23954 
    while True:
23955 
      (fname, ftype, fid) = iprot.readFieldBegin()
23956 
      if ftype == TType.STOP:
23957 
        break
23958 
      if fid == 1:
23959 
        if ftype == TType.STRUCT:
23960 
          self.ex = TransactionServiceException()
23961 
          self.ex.read(iprot)
23962 
        else:
23963 
          iprot.skip(ftype)
23964 
      else:
23965 
        iprot.skip(ftype)
23966 
      iprot.readFieldEnd()
23967 
    iprot.readStructEnd()
23968 
 
23969 
  def write(self, oprot):
23970 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23971 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23972 
      return
23973 
    oprot.writeStructBegin('saveEBSSettlementSummary_result')
23974 
    if self.ex is not None:
23975 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
23976 
      self.ex.write(oprot)
23977 
      oprot.writeFieldEnd()
23978 
    oprot.writeFieldStop()
23979 
    oprot.writeStructEnd()
23980 
 
23981 
  def validate(self):
23982 
    return
23983 
 
23984 
 
23985 
  def __repr__(self):
23986 
    L = ['%s=%r' % (key, value)
23987 
      for key, value in self.__dict__.iteritems()]
23988 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23989 
 
23990 
  def __eq__(self, other):
23991 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23992 
 
23993 
  def __ne__(self, other):
23994 
    return not (self == other)
23995 
 
5386 phani.kuma 23996 
class getSettlementForPrepaid_args:
4600 varun.gupt 23997 
  """
23998 
  Attributes:
5189 varun.gupt 23999 
   - referenceId
24000 
   - isRefund
4600 varun.gupt 24001 
  """
24002 
 
24003 
  thrift_spec = (
24004 
    None, # 0
5189 varun.gupt 24005 
    (1, TType.I64, 'referenceId', None, None, ), # 1
5386 phani.kuma 24006 
    (2, TType.BOOL, 'isRefund', None, None, ), # 2
4600 varun.gupt 24007 
  )
24008 
 
5386 phani.kuma 24009 
  def __init__(self, referenceId=None, isRefund=None,):
5189 varun.gupt 24010 
    self.referenceId = referenceId
24011 
    self.isRefund = isRefund
4600 varun.gupt 24012 
 
24013 
  def read(self, iprot):
24014 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24015 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24016 
      return
24017 
    iprot.readStructBegin()
24018 
    while True:
24019 
      (fname, ftype, fid) = iprot.readFieldBegin()
24020 
      if ftype == TType.STOP:
24021 
        break
24022 
      if fid == 1:
24023 
        if ftype == TType.I64:
5189 varun.gupt 24024 
          self.referenceId = iprot.readI64();
4600 varun.gupt 24025 
        else:
24026 
          iprot.skip(ftype)
5189 varun.gupt 24027 
      elif fid == 2:
24028 
        if ftype == TType.BOOL:
24029 
          self.isRefund = iprot.readBool();
24030 
        else:
24031 
          iprot.skip(ftype)
4600 varun.gupt 24032 
      else:
24033 
        iprot.skip(ftype)
24034 
      iprot.readFieldEnd()
24035 
    iprot.readStructEnd()
24036 
 
24037 
  def write(self, oprot):
24038 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24039 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24040 
      return
5386 phani.kuma 24041 
    oprot.writeStructBegin('getSettlementForPrepaid_args')
5189 varun.gupt 24042 
    if self.referenceId is not None:
24043 
      oprot.writeFieldBegin('referenceId', TType.I64, 1)
24044 
      oprot.writeI64(self.referenceId)
4600 varun.gupt 24045 
      oprot.writeFieldEnd()
5386 phani.kuma 24046 
    if self.isRefund is not None:
24047 
      oprot.writeFieldBegin('isRefund', TType.BOOL, 2)
24048 
      oprot.writeBool(self.isRefund)
5382 varun.gupt 24049 
      oprot.writeFieldEnd()
5386 phani.kuma 24050 
    oprot.writeFieldStop()
24051 
    oprot.writeStructEnd()
24052 
 
24053 
  def validate(self):
24054 
    return
24055 
 
24056 
 
24057 
  def __repr__(self):
24058 
    L = ['%s=%r' % (key, value)
24059 
      for key, value in self.__dict__.iteritems()]
24060 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24061 
 
24062 
  def __eq__(self, other):
24063 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24064 
 
24065 
  def __ne__(self, other):
24066 
    return not (self == other)
24067 
 
24068 
class getSettlementForPrepaid_result:
24069 
  """
24070 
  Attributes:
24071 
   - success
24072 
   - ex
24073 
  """
24074 
 
24075 
  thrift_spec = (
24076 
    (0, TType.STRUCT, 'success', (PaymentSettlement, PaymentSettlement.thrift_spec), None, ), # 0
24077 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
24078 
  )
24079 
 
24080 
  def __init__(self, success=None, ex=None,):
24081 
    self.success = success
24082 
    self.ex = ex
24083 
 
24084 
  def read(self, iprot):
24085 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24086 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24087 
      return
24088 
    iprot.readStructBegin()
24089 
    while True:
24090 
      (fname, ftype, fid) = iprot.readFieldBegin()
24091 
      if ftype == TType.STOP:
24092 
        break
24093 
      if fid == 0:
24094 
        if ftype == TType.STRUCT:
24095 
          self.success = PaymentSettlement()
24096 
          self.success.read(iprot)
24097 
        else:
24098 
          iprot.skip(ftype)
24099 
      elif fid == 1:
24100 
        if ftype == TType.STRUCT:
24101 
          self.ex = TransactionServiceException()
24102 
          self.ex.read(iprot)
24103 
        else:
24104 
          iprot.skip(ftype)
24105 
      else:
24106 
        iprot.skip(ftype)
24107 
      iprot.readFieldEnd()
24108 
    iprot.readStructEnd()
24109 
 
24110 
  def write(self, oprot):
24111 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24112 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24113 
      return
24114 
    oprot.writeStructBegin('getSettlementForPrepaid_result')
24115 
    if self.success is not None:
24116 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
24117 
      self.success.write(oprot)
24118 
      oprot.writeFieldEnd()
24119 
    if self.ex is not None:
24120 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
24121 
      self.ex.write(oprot)
24122 
      oprot.writeFieldEnd()
24123 
    oprot.writeFieldStop()
24124 
    oprot.writeStructEnd()
24125 
 
24126 
  def validate(self):
24127 
    return
24128 
 
24129 
 
24130 
  def __repr__(self):
24131 
    L = ['%s=%r' % (key, value)
24132 
      for key, value in self.__dict__.iteritems()]
24133 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24134 
 
24135 
  def __eq__(self, other):
24136 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24137 
 
24138 
  def __ne__(self, other):
24139 
    return not (self == other)
24140 
 
24141 
class getSettlementForCod_args:
24142 
  """
24143 
  Attributes:
24144 
   - orderId
24145 
   - isRefund
24146 
  """
24147 
 
24148 
  thrift_spec = (
24149 
    None, # 0
24150 
    (1, TType.I64, 'orderId', None, None, ), # 1
24151 
    (2, TType.BOOL, 'isRefund', None, None, ), # 2
24152 
  )
24153 
 
24154 
  def __init__(self, orderId=None, isRefund=None,):
24155 
    self.orderId = orderId
24156 
    self.isRefund = isRefund
24157 
 
24158 
  def read(self, iprot):
24159 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24160 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24161 
      return
24162 
    iprot.readStructBegin()
24163 
    while True:
24164 
      (fname, ftype, fid) = iprot.readFieldBegin()
24165 
      if ftype == TType.STOP:
24166 
        break
24167 
      if fid == 1:
24168 
        if ftype == TType.I64:
24169 
          self.orderId = iprot.readI64();
24170 
        else:
24171 
          iprot.skip(ftype)
24172 
      elif fid == 2:
24173 
        if ftype == TType.BOOL:
24174 
          self.isRefund = iprot.readBool();
24175 
        else:
24176 
          iprot.skip(ftype)
24177 
      else:
24178 
        iprot.skip(ftype)
24179 
      iprot.readFieldEnd()
24180 
    iprot.readStructEnd()
24181 
 
24182 
  def write(self, oprot):
24183 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24184 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24185 
      return
24186 
    oprot.writeStructBegin('getSettlementForCod_args')
24187 
    if self.orderId is not None:
24188 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
24189 
      oprot.writeI64(self.orderId)
24190 
      oprot.writeFieldEnd()
5189 varun.gupt 24191 
    if self.isRefund is not None:
5386 phani.kuma 24192 
      oprot.writeFieldBegin('isRefund', TType.BOOL, 2)
5189 varun.gupt 24193 
      oprot.writeBool(self.isRefund)
24194 
      oprot.writeFieldEnd()
4600 varun.gupt 24195 
    oprot.writeFieldStop()
24196 
    oprot.writeStructEnd()
24197 
 
24198 
  def validate(self):
24199 
    return
24200 
 
24201 
 
24202 
  def __repr__(self):
24203 
    L = ['%s=%r' % (key, value)
24204 
      for key, value in self.__dict__.iteritems()]
24205 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24206 
 
24207 
  def __eq__(self, other):
24208 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24209 
 
24210 
  def __ne__(self, other):
24211 
    return not (self == other)
24212 
 
5386 phani.kuma 24213 
class getSettlementForCod_result:
4600 varun.gupt 24214 
  """
24215 
  Attributes:
24216 
   - success
24217 
   - ex
24218 
  """
24219 
 
24220 
  thrift_spec = (
24221 
    (0, TType.STRUCT, 'success', (PaymentSettlement, PaymentSettlement.thrift_spec), None, ), # 0
24222 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
24223 
  )
24224 
 
24225 
  def __init__(self, success=None, ex=None,):
24226 
    self.success = success
24227 
    self.ex = ex
24228 
 
24229 
  def read(self, iprot):
24230 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24231 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24232 
      return
24233 
    iprot.readStructBegin()
24234 
    while True:
24235 
      (fname, ftype, fid) = iprot.readFieldBegin()
24236 
      if ftype == TType.STOP:
24237 
        break
24238 
      if fid == 0:
24239 
        if ftype == TType.STRUCT:
24240 
          self.success = PaymentSettlement()
24241 
          self.success.read(iprot)
24242 
        else:
24243 
          iprot.skip(ftype)
24244 
      elif fid == 1:
24245 
        if ftype == TType.STRUCT:
24246 
          self.ex = TransactionServiceException()
24247 
          self.ex.read(iprot)
24248 
        else:
24249 
          iprot.skip(ftype)
24250 
      else:
24251 
        iprot.skip(ftype)
24252 
      iprot.readFieldEnd()
24253 
    iprot.readStructEnd()
24254 
 
24255 
  def write(self, oprot):
24256 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24257 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24258 
      return
5386 phani.kuma 24259 
    oprot.writeStructBegin('getSettlementForCod_result')
4600 varun.gupt 24260 
    if self.success is not None:
24261 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
24262 
      self.success.write(oprot)
24263 
      oprot.writeFieldEnd()
24264 
    if self.ex is not None:
24265 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
24266 
      self.ex.write(oprot)
24267 
      oprot.writeFieldEnd()
24268 
    oprot.writeFieldStop()
24269 
    oprot.writeStructEnd()
24270 
 
24271 
  def validate(self):
24272 
    return
24273 
 
24274 
 
24275 
  def __repr__(self):
24276 
    L = ['%s=%r' % (key, value)
24277 
      for key, value in self.__dict__.iteritems()]
24278 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24279 
 
24280 
  def __eq__(self, other):
24281 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24282 
 
24283 
  def __ne__(self, other):
24284 
    return not (self == other)
24285 
 
24286 
class getEBSSettlementSummaries_args:
24287 
 
24288 
  thrift_spec = (
24289 
  )
24290 
 
24291 
  def read(self, iprot):
24292 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24293 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24294 
      return
24295 
    iprot.readStructBegin()
24296 
    while True:
24297 
      (fname, ftype, fid) = iprot.readFieldBegin()
24298 
      if ftype == TType.STOP:
24299 
        break
24300 
      else:
24301 
        iprot.skip(ftype)
24302 
      iprot.readFieldEnd()
24303 
    iprot.readStructEnd()
24304 
 
24305 
  def write(self, oprot):
24306 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24307 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24308 
      return
24309 
    oprot.writeStructBegin('getEBSSettlementSummaries_args')
24310 
    oprot.writeFieldStop()
24311 
    oprot.writeStructEnd()
24312 
 
24313 
  def validate(self):
24314 
    return
24315 
 
24316 
 
24317 
  def __repr__(self):
24318 
    L = ['%s=%r' % (key, value)
24319 
      for key, value in self.__dict__.iteritems()]
24320 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24321 
 
24322 
  def __eq__(self, other):
24323 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24324 
 
24325 
  def __ne__(self, other):
24326 
    return not (self == other)
24327 
 
24328 
class getEBSSettlementSummaries_result:
24329 
  """
24330 
  Attributes:
24331 
   - success
24332 
   - ex
24333 
  """
24334 
 
24335 
  thrift_spec = (
24336 
    (0, TType.MAP, 'success', (TType.I64,None,TType.STRING,None), None, ), # 0
24337 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
24338 
  )
24339 
 
24340 
  def __init__(self, success=None, ex=None,):
24341 
    self.success = success
24342 
    self.ex = ex
24343 
 
24344 
  def read(self, iprot):
24345 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24346 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24347 
      return
24348 
    iprot.readStructBegin()
24349 
    while True:
24350 
      (fname, ftype, fid) = iprot.readFieldBegin()
24351 
      if ftype == TType.STOP:
24352 
        break
24353 
      if fid == 0:
24354 
        if ftype == TType.MAP:
24355 
          self.success = {}
6188 rajveer 24356 
          (_ktype555, _vtype556, _size554 ) = iprot.readMapBegin()
24357 
          for _i558 in xrange(_size554):
24358 
            _key559 = iprot.readI64();
24359 
            _val560 = iprot.readString();
24360 
            self.success[_key559] = _val560
4600 varun.gupt 24361 
          iprot.readMapEnd()
24362 
        else:
24363 
          iprot.skip(ftype)
24364 
      elif fid == 1:
24365 
        if ftype == TType.STRUCT:
24366 
          self.ex = TransactionServiceException()
24367 
          self.ex.read(iprot)
24368 
        else:
24369 
          iprot.skip(ftype)
24370 
      else:
24371 
        iprot.skip(ftype)
24372 
      iprot.readFieldEnd()
24373 
    iprot.readStructEnd()
24374 
 
24375 
  def write(self, oprot):
24376 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24377 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24378 
      return
24379 
    oprot.writeStructBegin('getEBSSettlementSummaries_result')
24380 
    if self.success is not None:
24381 
      oprot.writeFieldBegin('success', TType.MAP, 0)
24382 
      oprot.writeMapBegin(TType.I64, TType.STRING, len(self.success))
6188 rajveer 24383 
      for kiter561,viter562 in self.success.items():
24384 
        oprot.writeI64(kiter561)
24385 
        oprot.writeString(viter562)
4600 varun.gupt 24386 
      oprot.writeMapEnd()
24387 
      oprot.writeFieldEnd()
24388 
    if self.ex is not None:
24389 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
24390 
      self.ex.write(oprot)
24391 
      oprot.writeFieldEnd()
24392 
    oprot.writeFieldStop()
24393 
    oprot.writeStructEnd()
24394 
 
24395 
  def validate(self):
24396 
    return
24397 
 
24398 
 
24399 
  def __repr__(self):
24400 
    L = ['%s=%r' % (key, value)
24401 
      for key, value in self.__dict__.iteritems()]
24402 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24403 
 
24404 
  def __eq__(self, other):
24405 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24406 
 
24407 
  def __ne__(self, other):
24408 
    return not (self == other)
24409 
 
24410 
class markEBSSettlementUploaded_args:
24411 
  """
24412 
  Attributes:
24413 
   - settlementId
24414 
  """
24415 
 
24416 
  thrift_spec = (
24417 
    None, # 0
24418 
    (1, TType.I64, 'settlementId', None, None, ), # 1
24419 
  )
24420 
 
24421 
  def __init__(self, settlementId=None,):
24422 
    self.settlementId = settlementId
24423 
 
24424 
  def read(self, iprot):
24425 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24426 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24427 
      return
24428 
    iprot.readStructBegin()
24429 
    while True:
24430 
      (fname, ftype, fid) = iprot.readFieldBegin()
24431 
      if ftype == TType.STOP:
24432 
        break
24433 
      if fid == 1:
24434 
        if ftype == TType.I64:
24435 
          self.settlementId = iprot.readI64();
24436 
        else:
24437 
          iprot.skip(ftype)
24438 
      else:
24439 
        iprot.skip(ftype)
24440 
      iprot.readFieldEnd()
24441 
    iprot.readStructEnd()
24442 
 
24443 
  def write(self, oprot):
24444 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24445 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24446 
      return
24447 
    oprot.writeStructBegin('markEBSSettlementUploaded_args')
24448 
    if self.settlementId is not None:
24449 
      oprot.writeFieldBegin('settlementId', TType.I64, 1)
24450 
      oprot.writeI64(self.settlementId)
24451 
      oprot.writeFieldEnd()
24452 
    oprot.writeFieldStop()
24453 
    oprot.writeStructEnd()
24454 
 
24455 
  def validate(self):
24456 
    return
24457 
 
24458 
 
24459 
  def __repr__(self):
24460 
    L = ['%s=%r' % (key, value)
24461 
      for key, value in self.__dict__.iteritems()]
24462 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24463 
 
24464 
  def __eq__(self, other):
24465 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24466 
 
24467 
  def __ne__(self, other):
24468 
    return not (self == other)
24469 
 
24470 
class markEBSSettlementUploaded_result:
24471 
  """
24472 
  Attributes:
24473 
   - ex
24474 
  """
24475 
 
24476 
  thrift_spec = (
24477 
    None, # 0
24478 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
24479 
  )
24480 
 
24481 
  def __init__(self, ex=None,):
24482 
    self.ex = ex
24483 
 
24484 
  def read(self, iprot):
24485 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24486 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24487 
      return
24488 
    iprot.readStructBegin()
24489 
    while True:
24490 
      (fname, ftype, fid) = iprot.readFieldBegin()
24491 
      if ftype == TType.STOP:
24492 
        break
24493 
      if fid == 1:
24494 
        if ftype == TType.STRUCT:
24495 
          self.ex = TransactionServiceException()
24496 
          self.ex.read(iprot)
24497 
        else:
24498 
          iprot.skip(ftype)
24499 
      else:
24500 
        iprot.skip(ftype)
24501 
      iprot.readFieldEnd()
24502 
    iprot.readStructEnd()
24503 
 
24504 
  def write(self, oprot):
24505 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24506 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24507 
      return
24508 
    oprot.writeStructBegin('markEBSSettlementUploaded_result')
24509 
    if self.ex is not None:
24510 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
24511 
      self.ex.write(oprot)
24512 
      oprot.writeFieldEnd()
24513 
    oprot.writeFieldStop()
24514 
    oprot.writeStructEnd()
24515 
 
24516 
  def validate(self):
24517 
    return
24518 
 
24519 
 
24520 
  def __repr__(self):
24521 
    L = ['%s=%r' % (key, value)
24522 
      for key, value in self.__dict__.iteritems()]
24523 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24524 
 
24525 
  def __eq__(self, other):
24526 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24527 
 
24528 
  def __ne__(self, other):
24529 
    return not (self == other)
24530 
 
24531 
class getEBSSettlementDate_args:
24532 
  """
24533 
  Attributes:
24534 
   - settlementId
24535 
  """
24536 
 
24537 
  thrift_spec = (
24538 
    None, # 0
24539 
    (1, TType.I64, 'settlementId', None, None, ), # 1
24540 
  )
24541 
 
24542 
  def __init__(self, settlementId=None,):
24543 
    self.settlementId = settlementId
24544 
 
24545 
  def read(self, iprot):
24546 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24547 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24548 
      return
24549 
    iprot.readStructBegin()
24550 
    while True:
24551 
      (fname, ftype, fid) = iprot.readFieldBegin()
24552 
      if ftype == TType.STOP:
24553 
        break
24554 
      if fid == 1:
24555 
        if ftype == TType.I64:
24556 
          self.settlementId = iprot.readI64();
24557 
        else:
24558 
          iprot.skip(ftype)
24559 
      else:
24560 
        iprot.skip(ftype)
24561 
      iprot.readFieldEnd()
24562 
    iprot.readStructEnd()
24563 
 
24564 
  def write(self, oprot):
24565 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24566 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24567 
      return
24568 
    oprot.writeStructBegin('getEBSSettlementDate_args')
24569 
    if self.settlementId is not None:
24570 
      oprot.writeFieldBegin('settlementId', TType.I64, 1)
24571 
      oprot.writeI64(self.settlementId)
24572 
      oprot.writeFieldEnd()
24573 
    oprot.writeFieldStop()
24574 
    oprot.writeStructEnd()
24575 
 
24576 
  def validate(self):
24577 
    return
24578 
 
24579 
 
24580 
  def __repr__(self):
24581 
    L = ['%s=%r' % (key, value)
24582 
      for key, value in self.__dict__.iteritems()]
24583 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24584 
 
24585 
  def __eq__(self, other):
24586 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24587 
 
24588 
  def __ne__(self, other):
24589 
    return not (self == other)
24590 
 
24591 
class getEBSSettlementDate_result:
24592 
  """
24593 
  Attributes:
24594 
   - success
24595 
   - ex
24596 
  """
24597 
 
24598 
  thrift_spec = (
24599 
    (0, TType.I64, 'success', None, None, ), # 0
24600 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
24601 
  )
24602 
 
24603 
  def __init__(self, success=None, ex=None,):
24604 
    self.success = success
24605 
    self.ex = ex
24606 
 
24607 
  def read(self, iprot):
24608 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24609 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24610 
      return
24611 
    iprot.readStructBegin()
24612 
    while True:
24613 
      (fname, ftype, fid) = iprot.readFieldBegin()
24614 
      if ftype == TType.STOP:
24615 
        break
24616 
      if fid == 0:
24617 
        if ftype == TType.I64:
24618 
          self.success = iprot.readI64();
24619 
        else:
24620 
          iprot.skip(ftype)
24621 
      elif fid == 1:
24622 
        if ftype == TType.STRUCT:
24623 
          self.ex = TransactionServiceException()
24624 
          self.ex.read(iprot)
24625 
        else:
24626 
          iprot.skip(ftype)
24627 
      else:
24628 
        iprot.skip(ftype)
24629 
      iprot.readFieldEnd()
24630 
    iprot.readStructEnd()
24631 
 
24632 
  def write(self, oprot):
24633 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24634 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24635 
      return
24636 
    oprot.writeStructBegin('getEBSSettlementDate_result')
24637 
    if self.success is not None:
24638 
      oprot.writeFieldBegin('success', TType.I64, 0)
24639 
      oprot.writeI64(self.success)
24640 
      oprot.writeFieldEnd()
24641 
    if self.ex is not None:
24642 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
24643 
      self.ex.write(oprot)
24644 
      oprot.writeFieldEnd()
24645 
    oprot.writeFieldStop()
24646 
    oprot.writeStructEnd()
24647 
 
24648 
  def validate(self):
24649 
    return
24650 
 
24651 
 
24652 
  def __repr__(self):
24653 
    L = ['%s=%r' % (key, value)
24654 
      for key, value in self.__dict__.iteritems()]
24655 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24656 
 
24657 
  def __eq__(self, other):
24658 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24659 
 
24660 
  def __ne__(self, other):
24661 
    return not (self == other)
4715 varun.gupt 24662 
 
24663 
class getSettlementsByDate_args:
24664 
  """
24665 
  Attributes:
24666 
   - settlementDateFrom
24667 
   - settlementDateTo
24668 
   - isRefund
24669 
  """
24670 
 
24671 
  thrift_spec = (
24672 
    None, # 0
24673 
    (1, TType.I64, 'settlementDateFrom', None, None, ), # 1
24674 
    (2, TType.I64, 'settlementDateTo', None, None, ), # 2
24675 
    (3, TType.BOOL, 'isRefund', None, None, ), # 3
24676 
  )
24677 
 
24678 
  def __init__(self, settlementDateFrom=None, settlementDateTo=None, isRefund=None,):
24679 
    self.settlementDateFrom = settlementDateFrom
24680 
    self.settlementDateTo = settlementDateTo
24681 
    self.isRefund = isRefund
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 == 1:
24693 
        if ftype == TType.I64:
24694 
          self.settlementDateFrom = iprot.readI64();
24695 
        else:
24696 
          iprot.skip(ftype)
24697 
      elif fid == 2:
24698 
        if ftype == TType.I64:
24699 
          self.settlementDateTo = iprot.readI64();
24700 
        else:
24701 
          iprot.skip(ftype)
24702 
      elif fid == 3:
24703 
        if ftype == TType.BOOL:
24704 
          self.isRefund = iprot.readBool();
24705 
        else:
24706 
          iprot.skip(ftype)
24707 
      else:
24708 
        iprot.skip(ftype)
24709 
      iprot.readFieldEnd()
24710 
    iprot.readStructEnd()
24711 
 
24712 
  def write(self, oprot):
24713 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24714 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24715 
      return
24716 
    oprot.writeStructBegin('getSettlementsByDate_args')
24717 
    if self.settlementDateFrom is not None:
24718 
      oprot.writeFieldBegin('settlementDateFrom', TType.I64, 1)
24719 
      oprot.writeI64(self.settlementDateFrom)
24720 
      oprot.writeFieldEnd()
24721 
    if self.settlementDateTo is not None:
24722 
      oprot.writeFieldBegin('settlementDateTo', TType.I64, 2)
24723 
      oprot.writeI64(self.settlementDateTo)
24724 
      oprot.writeFieldEnd()
24725 
    if self.isRefund is not None:
24726 
      oprot.writeFieldBegin('isRefund', TType.BOOL, 3)
24727 
      oprot.writeBool(self.isRefund)
24728 
      oprot.writeFieldEnd()
24729 
    oprot.writeFieldStop()
24730 
    oprot.writeStructEnd()
24731 
 
24732 
  def validate(self):
24733 
    return
24734 
 
24735 
 
24736 
  def __repr__(self):
24737 
    L = ['%s=%r' % (key, value)
24738 
      for key, value in self.__dict__.iteritems()]
24739 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24740 
 
24741 
  def __eq__(self, other):
24742 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24743 
 
24744 
  def __ne__(self, other):
24745 
    return not (self == other)
24746 
 
24747 
class getSettlementsByDate_result:
24748 
  """
24749 
  Attributes:
24750 
   - success
24751 
   - ex
24752 
  """
24753 
 
24754 
  thrift_spec = (
24755 
    (0, TType.LIST, 'success', (TType.STRUCT,(PaymentSettlement, PaymentSettlement.thrift_spec)), None, ), # 0
24756 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
24757 
  )
24758 
 
24759 
  def __init__(self, success=None, ex=None,):
24760 
    self.success = success
24761 
    self.ex = ex
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 == 0:
24773 
        if ftype == TType.LIST:
24774 
          self.success = []
6188 rajveer 24775 
          (_etype566, _size563) = iprot.readListBegin()
24776 
          for _i567 in xrange(_size563):
24777 
            _elem568 = PaymentSettlement()
24778 
            _elem568.read(iprot)
24779 
            self.success.append(_elem568)
4715 varun.gupt 24780 
          iprot.readListEnd()
24781 
        else:
24782 
          iprot.skip(ftype)
24783 
      elif fid == 1:
24784 
        if ftype == TType.STRUCT:
24785 
          self.ex = TransactionServiceException()
24786 
          self.ex.read(iprot)
24787 
        else:
24788 
          iprot.skip(ftype)
24789 
      else:
24790 
        iprot.skip(ftype)
24791 
      iprot.readFieldEnd()
24792 
    iprot.readStructEnd()
24793 
 
24794 
  def write(self, oprot):
24795 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24796 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24797 
      return
24798 
    oprot.writeStructBegin('getSettlementsByDate_result')
24799 
    if self.success is not None:
24800 
      oprot.writeFieldBegin('success', TType.LIST, 0)
24801 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 24802 
      for iter569 in self.success:
24803 
        iter569.write(oprot)
4715 varun.gupt 24804 
      oprot.writeListEnd()
24805 
      oprot.writeFieldEnd()
24806 
    if self.ex is not None:
24807 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
24808 
      self.ex.write(oprot)
24809 
      oprot.writeFieldEnd()
24810 
    oprot.writeFieldStop()
24811 
    oprot.writeStructEnd()
24812 
 
24813 
  def validate(self):
24814 
    return
24815 
 
24816 
 
24817 
  def __repr__(self):
24818 
    L = ['%s=%r' % (key, value)
24819 
      for key, value in self.__dict__.iteritems()]
24820 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24821 
 
24822 
  def __eq__(self, other):
24823 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24824 
 
24825 
  def __ne__(self, other):
24826 
    return not (self == other)
24827 
 
24828 
class getReshippedOrderIds_args:
24829 
  """
24830 
  Attributes:
24831 
   - orderIds
24832 
  """
24833 
 
24834 
  thrift_spec = (
24835 
    None, # 0
24836 
    (1, TType.LIST, 'orderIds', (TType.I64,None), None, ), # 1
24837 
  )
24838 
 
24839 
  def __init__(self, orderIds=None,):
24840 
    self.orderIds = orderIds
24841 
 
24842 
  def read(self, iprot):
24843 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24844 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24845 
      return
24846 
    iprot.readStructBegin()
24847 
    while True:
24848 
      (fname, ftype, fid) = iprot.readFieldBegin()
24849 
      if ftype == TType.STOP:
24850 
        break
24851 
      if fid == 1:
24852 
        if ftype == TType.LIST:
24853 
          self.orderIds = []
6188 rajveer 24854 
          (_etype573, _size570) = iprot.readListBegin()
24855 
          for _i574 in xrange(_size570):
24856 
            _elem575 = iprot.readI64();
24857 
            self.orderIds.append(_elem575)
4715 varun.gupt 24858 
          iprot.readListEnd()
24859 
        else:
24860 
          iprot.skip(ftype)
24861 
      else:
24862 
        iprot.skip(ftype)
24863 
      iprot.readFieldEnd()
24864 
    iprot.readStructEnd()
24865 
 
24866 
  def write(self, oprot):
24867 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24868 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24869 
      return
24870 
    oprot.writeStructBegin('getReshippedOrderIds_args')
24871 
    if self.orderIds is not None:
24872 
      oprot.writeFieldBegin('orderIds', TType.LIST, 1)
24873 
      oprot.writeListBegin(TType.I64, len(self.orderIds))
6188 rajveer 24874 
      for iter576 in self.orderIds:
24875 
        oprot.writeI64(iter576)
4715 varun.gupt 24876 
      oprot.writeListEnd()
24877 
      oprot.writeFieldEnd()
24878 
    oprot.writeFieldStop()
24879 
    oprot.writeStructEnd()
24880 
 
24881 
  def validate(self):
24882 
    return
24883 
 
24884 
 
24885 
  def __repr__(self):
24886 
    L = ['%s=%r' % (key, value)
24887 
      for key, value in self.__dict__.iteritems()]
24888 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24889 
 
24890 
  def __eq__(self, other):
24891 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24892 
 
24893 
  def __ne__(self, other):
24894 
    return not (self == other)
24895 
 
24896 
class getReshippedOrderIds_result:
24897 
  """
24898 
  Attributes:
24899 
   - success
24900 
   - ex
24901 
  """
24902 
 
24903 
  thrift_spec = (
24904 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
24905 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
24906 
  )
24907 
 
24908 
  def __init__(self, success=None, ex=None,):
24909 
    self.success = success
24910 
    self.ex = ex
24911 
 
24912 
  def read(self, iprot):
24913 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24914 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24915 
      return
24916 
    iprot.readStructBegin()
24917 
    while True:
24918 
      (fname, ftype, fid) = iprot.readFieldBegin()
24919 
      if ftype == TType.STOP:
24920 
        break
24921 
      if fid == 0:
24922 
        if ftype == TType.LIST:
24923 
          self.success = []
6188 rajveer 24924 
          (_etype580, _size577) = iprot.readListBegin()
24925 
          for _i581 in xrange(_size577):
24926 
            _elem582 = iprot.readI64();
24927 
            self.success.append(_elem582)
4715 varun.gupt 24928 
          iprot.readListEnd()
24929 
        else:
24930 
          iprot.skip(ftype)
24931 
      elif fid == 1:
24932 
        if ftype == TType.STRUCT:
24933 
          self.ex = TransactionServiceException()
24934 
          self.ex.read(iprot)
24935 
        else:
24936 
          iprot.skip(ftype)
24937 
      else:
24938 
        iprot.skip(ftype)
24939 
      iprot.readFieldEnd()
24940 
    iprot.readStructEnd()
24941 
 
24942 
  def write(self, oprot):
24943 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24944 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24945 
      return
24946 
    oprot.writeStructBegin('getReshippedOrderIds_result')
24947 
    if self.success is not None:
24948 
      oprot.writeFieldBegin('success', TType.LIST, 0)
24949 
      oprot.writeListBegin(TType.I64, len(self.success))
6188 rajveer 24950 
      for iter583 in self.success:
24951 
        oprot.writeI64(iter583)
4715 varun.gupt 24952 
      oprot.writeListEnd()
24953 
      oprot.writeFieldEnd()
24954 
    if self.ex is not None:
24955 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
24956 
      self.ex.write(oprot)
24957 
      oprot.writeFieldEnd()
24958 
    oprot.writeFieldStop()
24959 
    oprot.writeStructEnd()
24960 
 
24961 
  def validate(self):
24962 
    return
24963 
 
24964 
 
24965 
  def __repr__(self):
24966 
    L = ['%s=%r' % (key, value)
24967 
      for key, value in self.__dict__.iteritems()]
24968 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24969 
 
24970 
  def __eq__(self, other):
24971 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24972 
 
24973 
  def __ne__(self, other):
24974 
    return not (self == other)
4757 mandeep.dh 24975 
 
5481 phani.kuma 24976 
class getBilledOrders_args:
4875 varun.gupt 24977 
  """
24978 
  Attributes:
24979 
   - vendorId
5481 phani.kuma 24980 
   - onlyVendorNotPaid
24981 
   - billingDateFrom
24982 
   - billingDateTo
4875 varun.gupt 24983 
  """
24984 
 
24985 
  thrift_spec = (
24986 
    None, # 0
24987 
    (1, TType.I64, 'vendorId', None, None, ), # 1
5481 phani.kuma 24988 
    (2, TType.BOOL, 'onlyVendorNotPaid', None, None, ), # 2
24989 
    (3, TType.I64, 'billingDateFrom', None, None, ), # 3
24990 
    (4, TType.I64, 'billingDateTo', None, None, ), # 4
4875 varun.gupt 24991 
  )
24992 
 
5481 phani.kuma 24993 
  def __init__(self, vendorId=None, onlyVendorNotPaid=None, billingDateFrom=None, billingDateTo=None,):
4875 varun.gupt 24994 
    self.vendorId = vendorId
5481 phani.kuma 24995 
    self.onlyVendorNotPaid = onlyVendorNotPaid
24996 
    self.billingDateFrom = billingDateFrom
24997 
    self.billingDateTo = billingDateTo
4875 varun.gupt 24998 
 
24999 
  def read(self, iprot):
25000 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25001 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25002 
      return
25003 
    iprot.readStructBegin()
25004 
    while True:
25005 
      (fname, ftype, fid) = iprot.readFieldBegin()
25006 
      if ftype == TType.STOP:
25007 
        break
25008 
      if fid == 1:
25009 
        if ftype == TType.I64:
25010 
          self.vendorId = iprot.readI64();
25011 
        else:
25012 
          iprot.skip(ftype)
5481 phani.kuma 25013 
      elif fid == 2:
25014 
        if ftype == TType.BOOL:
25015 
          self.onlyVendorNotPaid = iprot.readBool();
25016 
        else:
25017 
          iprot.skip(ftype)
25018 
      elif fid == 3:
25019 
        if ftype == TType.I64:
25020 
          self.billingDateFrom = iprot.readI64();
25021 
        else:
25022 
          iprot.skip(ftype)
25023 
      elif fid == 4:
25024 
        if ftype == TType.I64:
25025 
          self.billingDateTo = iprot.readI64();
25026 
        else:
25027 
          iprot.skip(ftype)
4875 varun.gupt 25028 
      else:
25029 
        iprot.skip(ftype)
25030 
      iprot.readFieldEnd()
25031 
    iprot.readStructEnd()
25032 
 
25033 
  def write(self, oprot):
25034 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25035 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25036 
      return
5481 phani.kuma 25037 
    oprot.writeStructBegin('getBilledOrders_args')
4875 varun.gupt 25038 
    if self.vendorId is not None:
25039 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
25040 
      oprot.writeI64(self.vendorId)
25041 
      oprot.writeFieldEnd()
5481 phani.kuma 25042 
    if self.onlyVendorNotPaid is not None:
25043 
      oprot.writeFieldBegin('onlyVendorNotPaid', TType.BOOL, 2)
25044 
      oprot.writeBool(self.onlyVendorNotPaid)
25045 
      oprot.writeFieldEnd()
25046 
    if self.billingDateFrom is not None:
25047 
      oprot.writeFieldBegin('billingDateFrom', TType.I64, 3)
25048 
      oprot.writeI64(self.billingDateFrom)
25049 
      oprot.writeFieldEnd()
25050 
    if self.billingDateTo is not None:
25051 
      oprot.writeFieldBegin('billingDateTo', TType.I64, 4)
25052 
      oprot.writeI64(self.billingDateTo)
25053 
      oprot.writeFieldEnd()
4875 varun.gupt 25054 
    oprot.writeFieldStop()
25055 
    oprot.writeStructEnd()
25056 
 
25057 
  def validate(self):
25058 
    return
25059 
 
25060 
 
25061 
  def __repr__(self):
25062 
    L = ['%s=%r' % (key, value)
25063 
      for key, value in self.__dict__.iteritems()]
25064 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25065 
 
25066 
  def __eq__(self, other):
25067 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25068 
 
25069 
  def __ne__(self, other):
25070 
    return not (self == other)
25071 
 
5481 phani.kuma 25072 
class getBilledOrders_result:
4875 varun.gupt 25073 
  """
25074 
  Attributes:
25075 
   - success
25076 
   - ex
25077 
  """
25078 
 
25079 
  thrift_spec = (
25080 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
25081 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
25082 
  )
25083 
 
25084 
  def __init__(self, success=None, ex=None,):
25085 
    self.success = success
25086 
    self.ex = ex
25087 
 
25088 
  def read(self, iprot):
25089 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25090 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25091 
      return
25092 
    iprot.readStructBegin()
25093 
    while True:
25094 
      (fname, ftype, fid) = iprot.readFieldBegin()
25095 
      if ftype == TType.STOP:
25096 
        break
25097 
      if fid == 0:
25098 
        if ftype == TType.LIST:
25099 
          self.success = []
6188 rajveer 25100 
          (_etype587, _size584) = iprot.readListBegin()
25101 
          for _i588 in xrange(_size584):
25102 
            _elem589 = Order()
25103 
            _elem589.read(iprot)
25104 
            self.success.append(_elem589)
4875 varun.gupt 25105 
          iprot.readListEnd()
25106 
        else:
25107 
          iprot.skip(ftype)
25108 
      elif fid == 1:
25109 
        if ftype == TType.STRUCT:
25110 
          self.ex = TransactionServiceException()
25111 
          self.ex.read(iprot)
25112 
        else:
25113 
          iprot.skip(ftype)
25114 
      else:
25115 
        iprot.skip(ftype)
25116 
      iprot.readFieldEnd()
25117 
    iprot.readStructEnd()
25118 
 
25119 
  def write(self, oprot):
25120 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25121 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25122 
      return
5481 phani.kuma 25123 
    oprot.writeStructBegin('getBilledOrders_result')
4875 varun.gupt 25124 
    if self.success is not None:
25125 
      oprot.writeFieldBegin('success', TType.LIST, 0)
25126 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 25127 
      for iter590 in self.success:
25128 
        iter590.write(oprot)
4875 varun.gupt 25129 
      oprot.writeListEnd()
25130 
      oprot.writeFieldEnd()
25131 
    if self.ex is not None:
25132 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
25133 
      self.ex.write(oprot)
25134 
      oprot.writeFieldEnd()
25135 
    oprot.writeFieldStop()
25136 
    oprot.writeStructEnd()
25137 
 
25138 
  def validate(self):
25139 
    return
25140 
 
25141 
 
25142 
  def __repr__(self):
25143 
    L = ['%s=%r' % (key, value)
25144 
      for key, value in self.__dict__.iteritems()]
25145 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25146 
 
25147 
  def __eq__(self, other):
25148 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25149 
 
25150 
  def __ne__(self, other):
25151 
    return not (self == other)
5031 varun.gupt 25152 
 
25153 
class getStatusDistributionOfOrders_args:
25154 
  """
25155 
  Attributes:
25156 
   - startDate
25157 
   - endDate
25158 
  """
25159 
 
25160 
  thrift_spec = (
25161 
    None, # 0
25162 
    (1, TType.I64, 'startDate', None, None, ), # 1
25163 
    (2, TType.I64, 'endDate', None, None, ), # 2
25164 
  )
25165 
 
25166 
  def __init__(self, startDate=None, endDate=None,):
25167 
    self.startDate = startDate
25168 
    self.endDate = endDate
25169 
 
25170 
  def read(self, iprot):
25171 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25172 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25173 
      return
25174 
    iprot.readStructBegin()
25175 
    while True:
25176 
      (fname, ftype, fid) = iprot.readFieldBegin()
25177 
      if ftype == TType.STOP:
25178 
        break
25179 
      if fid == 1:
25180 
        if ftype == TType.I64:
25181 
          self.startDate = iprot.readI64();
25182 
        else:
25183 
          iprot.skip(ftype)
25184 
      elif fid == 2:
25185 
        if ftype == TType.I64:
25186 
          self.endDate = iprot.readI64();
25187 
        else:
25188 
          iprot.skip(ftype)
25189 
      else:
25190 
        iprot.skip(ftype)
25191 
      iprot.readFieldEnd()
25192 
    iprot.readStructEnd()
25193 
 
25194 
  def write(self, oprot):
25195 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25196 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25197 
      return
25198 
    oprot.writeStructBegin('getStatusDistributionOfOrders_args')
25199 
    if self.startDate is not None:
25200 
      oprot.writeFieldBegin('startDate', TType.I64, 1)
25201 
      oprot.writeI64(self.startDate)
25202 
      oprot.writeFieldEnd()
25203 
    if self.endDate is not None:
25204 
      oprot.writeFieldBegin('endDate', TType.I64, 2)
25205 
      oprot.writeI64(self.endDate)
25206 
      oprot.writeFieldEnd()
25207 
    oprot.writeFieldStop()
25208 
    oprot.writeStructEnd()
25209 
 
25210 
  def validate(self):
25211 
    return
25212 
 
25213 
 
25214 
  def __repr__(self):
25215 
    L = ['%s=%r' % (key, value)
25216 
      for key, value in self.__dict__.iteritems()]
25217 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25218 
 
25219 
  def __eq__(self, other):
25220 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25221 
 
25222 
  def __ne__(self, other):
25223 
    return not (self == other)
25224 
 
25225 
class getStatusDistributionOfOrders_result:
25226 
  """
25227 
  Attributes:
25228 
   - success
25229 
   - ex
25230 
  """
25231 
 
25232 
  thrift_spec = (
25233 
    (0, TType.MAP, 'success', (TType.I64,None,TType.I64,None), None, ), # 0
25234 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
25235 
  )
25236 
 
25237 
  def __init__(self, success=None, ex=None,):
25238 
    self.success = success
25239 
    self.ex = ex
25240 
 
25241 
  def read(self, iprot):
25242 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25243 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25244 
      return
25245 
    iprot.readStructBegin()
25246 
    while True:
25247 
      (fname, ftype, fid) = iprot.readFieldBegin()
25248 
      if ftype == TType.STOP:
25249 
        break
25250 
      if fid == 0:
25251 
        if ftype == TType.MAP:
25252 
          self.success = {}
6188 rajveer 25253 
          (_ktype592, _vtype593, _size591 ) = iprot.readMapBegin()
25254 
          for _i595 in xrange(_size591):
25255 
            _key596 = iprot.readI64();
25256 
            _val597 = iprot.readI64();
25257 
            self.success[_key596] = _val597
5031 varun.gupt 25258 
          iprot.readMapEnd()
25259 
        else:
25260 
          iprot.skip(ftype)
25261 
      elif fid == 1:
25262 
        if ftype == TType.STRUCT:
25263 
          self.ex = TransactionServiceException()
25264 
          self.ex.read(iprot)
25265 
        else:
25266 
          iprot.skip(ftype)
25267 
      else:
25268 
        iprot.skip(ftype)
25269 
      iprot.readFieldEnd()
25270 
    iprot.readStructEnd()
25271 
 
25272 
  def write(self, oprot):
25273 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25274 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25275 
      return
25276 
    oprot.writeStructBegin('getStatusDistributionOfOrders_result')
25277 
    if self.success is not None:
25278 
      oprot.writeFieldBegin('success', TType.MAP, 0)
25279 
      oprot.writeMapBegin(TType.I64, TType.I64, len(self.success))
6188 rajveer 25280 
      for kiter598,viter599 in self.success.items():
25281 
        oprot.writeI64(kiter598)
25282 
        oprot.writeI64(viter599)
5031 varun.gupt 25283 
      oprot.writeMapEnd()
25284 
      oprot.writeFieldEnd()
25285 
    if self.ex is not None:
25286 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
25287 
      self.ex.write(oprot)
25288 
      oprot.writeFieldEnd()
25289 
    oprot.writeFieldStop()
25290 
    oprot.writeStructEnd()
25291 
 
25292 
  def validate(self):
25293 
    return
25294 
 
25295 
 
25296 
  def __repr__(self):
25297 
    L = ['%s=%r' % (key, value)
25298 
      for key, value in self.__dict__.iteritems()]
25299 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25300 
 
25301 
  def __eq__(self, other):
25302 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25303 
 
25304 
  def __ne__(self, other):
25305 
    return not (self == other)
5067 varun.gupt 25306 
 
25307 
class getOrderIdsForStatus_args:
25308 
  """
25309 
  Attributes:
25310 
   - status
25311 
   - startDatetime
25312 
   - endDatetime
25313 
  """
25314 
 
25315 
  thrift_spec = (
25316 
    None, # 0
25317 
    (1, TType.I64, 'status', None, None, ), # 1
25318 
    (2, TType.I64, 'startDatetime', None, None, ), # 2
25319 
    (3, TType.I64, 'endDatetime', None, None, ), # 3
25320 
  )
25321 
 
25322 
  def __init__(self, status=None, startDatetime=None, endDatetime=None,):
25323 
    self.status = status
25324 
    self.startDatetime = startDatetime
25325 
    self.endDatetime = endDatetime
25326 
 
25327 
  def read(self, iprot):
25328 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25329 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25330 
      return
25331 
    iprot.readStructBegin()
25332 
    while True:
25333 
      (fname, ftype, fid) = iprot.readFieldBegin()
25334 
      if ftype == TType.STOP:
25335 
        break
25336 
      if fid == 1:
25337 
        if ftype == TType.I64:
25338 
          self.status = iprot.readI64();
25339 
        else:
25340 
          iprot.skip(ftype)
25341 
      elif fid == 2:
25342 
        if ftype == TType.I64:
25343 
          self.startDatetime = iprot.readI64();
25344 
        else:
25345 
          iprot.skip(ftype)
25346 
      elif fid == 3:
25347 
        if ftype == TType.I64:
25348 
          self.endDatetime = iprot.readI64();
25349 
        else:
25350 
          iprot.skip(ftype)
25351 
      else:
25352 
        iprot.skip(ftype)
25353 
      iprot.readFieldEnd()
25354 
    iprot.readStructEnd()
25355 
 
25356 
  def write(self, oprot):
25357 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25358 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25359 
      return
25360 
    oprot.writeStructBegin('getOrderIdsForStatus_args')
25361 
    if self.status is not None:
25362 
      oprot.writeFieldBegin('status', TType.I64, 1)
25363 
      oprot.writeI64(self.status)
25364 
      oprot.writeFieldEnd()
25365 
    if self.startDatetime is not None:
25366 
      oprot.writeFieldBegin('startDatetime', TType.I64, 2)
25367 
      oprot.writeI64(self.startDatetime)
25368 
      oprot.writeFieldEnd()
25369 
    if self.endDatetime is not None:
25370 
      oprot.writeFieldBegin('endDatetime', TType.I64, 3)
25371 
      oprot.writeI64(self.endDatetime)
25372 
      oprot.writeFieldEnd()
25373 
    oprot.writeFieldStop()
25374 
    oprot.writeStructEnd()
25375 
 
25376 
  def validate(self):
25377 
    return
25378 
 
25379 
 
25380 
  def __repr__(self):
25381 
    L = ['%s=%r' % (key, value)
25382 
      for key, value in self.__dict__.iteritems()]
25383 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25384 
 
25385 
  def __eq__(self, other):
25386 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25387 
 
25388 
  def __ne__(self, other):
25389 
    return not (self == other)
25390 
 
25391 
class getOrderIdsForStatus_result:
25392 
  """
25393 
  Attributes:
25394 
   - success
25395 
   - ex
25396 
  """
25397 
 
25398 
  thrift_spec = (
25399 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
25400 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
25401 
  )
25402 
 
25403 
  def __init__(self, success=None, ex=None,):
25404 
    self.success = success
25405 
    self.ex = ex
25406 
 
25407 
  def read(self, iprot):
25408 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25409 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25410 
      return
25411 
    iprot.readStructBegin()
25412 
    while True:
25413 
      (fname, ftype, fid) = iprot.readFieldBegin()
25414 
      if ftype == TType.STOP:
25415 
        break
25416 
      if fid == 0:
25417 
        if ftype == TType.LIST:
25418 
          self.success = []
6188 rajveer 25419 
          (_etype603, _size600) = iprot.readListBegin()
25420 
          for _i604 in xrange(_size600):
25421 
            _elem605 = iprot.readI64();
25422 
            self.success.append(_elem605)
5067 varun.gupt 25423 
          iprot.readListEnd()
25424 
        else:
25425 
          iprot.skip(ftype)
25426 
      elif fid == 1:
25427 
        if ftype == TType.STRUCT:
25428 
          self.ex = TransactionServiceException()
25429 
          self.ex.read(iprot)
25430 
        else:
25431 
          iprot.skip(ftype)
25432 
      else:
25433 
        iprot.skip(ftype)
25434 
      iprot.readFieldEnd()
25435 
    iprot.readStructEnd()
25436 
 
25437 
  def write(self, oprot):
25438 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25439 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25440 
      return
25441 
    oprot.writeStructBegin('getOrderIdsForStatus_result')
25442 
    if self.success is not None:
25443 
      oprot.writeFieldBegin('success', TType.LIST, 0)
25444 
      oprot.writeListBegin(TType.I64, len(self.success))
6188 rajveer 25445 
      for iter606 in self.success:
25446 
        oprot.writeI64(iter606)
5067 varun.gupt 25447 
      oprot.writeListEnd()
25448 
      oprot.writeFieldEnd()
25449 
    if self.ex is not None:
25450 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
25451 
      self.ex.write(oprot)
25452 
      oprot.writeFieldEnd()
25453 
    oprot.writeFieldStop()
25454 
    oprot.writeStructEnd()
25455 
 
25456 
  def validate(self):
25457 
    return
25458 
 
25459 
 
25460 
  def __repr__(self):
25461 
    L = ['%s=%r' % (key, value)
25462 
      for key, value in self.__dict__.iteritems()]
25463 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25464 
 
25465 
  def __eq__(self, other):
25466 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25467 
 
25468 
  def __ne__(self, other):
25469 
    return not (self == other)
5099 varun.gupt 25470 
 
5348 anupam.sin 25471 
class updateCODAgent_args:
25472 
  """
25473 
  Attributes:
25474 
   - agent
25475 
   - orderId
25476 
  """
25477 
 
25478 
  thrift_spec = (
25479 
    None, # 0
25480 
    (1, TType.STRING, 'agent', None, None, ), # 1
25481 
    (2, TType.I64, 'orderId', None, None, ), # 2
25482 
  )
25483 
 
25484 
  def __init__(self, agent=None, orderId=None,):
25485 
    self.agent = agent
25486 
    self.orderId = orderId
25487 
 
25488 
  def read(self, iprot):
25489 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25490 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25491 
      return
25492 
    iprot.readStructBegin()
25493 
    while True:
25494 
      (fname, ftype, fid) = iprot.readFieldBegin()
25495 
      if ftype == TType.STOP:
25496 
        break
25497 
      if fid == 1:
25498 
        if ftype == TType.STRING:
25499 
          self.agent = iprot.readString();
25500 
        else:
25501 
          iprot.skip(ftype)
25502 
      elif fid == 2:
25503 
        if ftype == TType.I64:
25504 
          self.orderId = iprot.readI64();
25505 
        else:
25506 
          iprot.skip(ftype)
25507 
      else:
25508 
        iprot.skip(ftype)
25509 
      iprot.readFieldEnd()
25510 
    iprot.readStructEnd()
25511 
 
25512 
  def write(self, oprot):
25513 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25514 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25515 
      return
25516 
    oprot.writeStructBegin('updateCODAgent_args')
25517 
    if self.agent is not None:
25518 
      oprot.writeFieldBegin('agent', TType.STRING, 1)
25519 
      oprot.writeString(self.agent)
25520 
      oprot.writeFieldEnd()
25521 
    if self.orderId is not None:
25522 
      oprot.writeFieldBegin('orderId', TType.I64, 2)
25523 
      oprot.writeI64(self.orderId)
25524 
      oprot.writeFieldEnd()
25525 
    oprot.writeFieldStop()
25526 
    oprot.writeStructEnd()
25527 
 
25528 
  def validate(self):
25529 
    return
25530 
 
25531 
 
25532 
  def __repr__(self):
25533 
    L = ['%s=%r' % (key, value)
25534 
      for key, value in self.__dict__.iteritems()]
25535 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25536 
 
25537 
  def __eq__(self, other):
25538 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25539 
 
25540 
  def __ne__(self, other):
25541 
    return not (self == other)
25542 
 
25543 
class updateCODAgent_result:
25544 
  """
25545 
  Attributes:
25546 
   - ex
25547 
  """
25548 
 
25549 
  thrift_spec = (
25550 
    None, # 0
25551 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
25552 
  )
25553 
 
25554 
  def __init__(self, ex=None,):
25555 
    self.ex = ex
25556 
 
25557 
  def read(self, iprot):
25558 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25559 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25560 
      return
25561 
    iprot.readStructBegin()
25562 
    while True:
25563 
      (fname, ftype, fid) = iprot.readFieldBegin()
25564 
      if ftype == TType.STOP:
25565 
        break
25566 
      if fid == 1:
25567 
        if ftype == TType.STRUCT:
25568 
          self.ex = TransactionServiceException()
25569 
          self.ex.read(iprot)
25570 
        else:
25571 
          iprot.skip(ftype)
25572 
      else:
25573 
        iprot.skip(ftype)
25574 
      iprot.readFieldEnd()
25575 
    iprot.readStructEnd()
25576 
 
25577 
  def write(self, oprot):
25578 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25579 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25580 
      return
25581 
    oprot.writeStructBegin('updateCODAgent_result')
25582 
    if self.ex is not None:
25583 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
25584 
      self.ex.write(oprot)
25585 
      oprot.writeFieldEnd()
25586 
    oprot.writeFieldStop()
25587 
    oprot.writeStructEnd()
25588 
 
25589 
  def validate(self):
25590 
    return
25591 
 
25592 
 
25593 
  def __repr__(self):
25594 
    L = ['%s=%r' % (key, value)
25595 
      for key, value in self.__dict__.iteritems()]
25596 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25597 
 
25598 
  def __eq__(self, other):
25599 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25600 
 
25601 
  def __ne__(self, other):
25602 
    return not (self == other)
25603 
 
5099 varun.gupt 25604 
class updateOrderAsPaidToVendor_args:
25605 
  """
25606 
  Attributes:
25607 
   - orderId
25608 
  """
25609 
 
25610 
  thrift_spec = (
25611 
    None, # 0
25612 
    (1, TType.I64, 'orderId', None, None, ), # 1
25613 
  )
25614 
 
25615 
  def __init__(self, orderId=None,):
25616 
    self.orderId = orderId
25617 
 
25618 
  def read(self, iprot):
25619 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25620 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25621 
      return
25622 
    iprot.readStructBegin()
25623 
    while True:
25624 
      (fname, ftype, fid) = iprot.readFieldBegin()
25625 
      if ftype == TType.STOP:
25626 
        break
25627 
      if fid == 1:
25628 
        if ftype == TType.I64:
25629 
          self.orderId = iprot.readI64();
25630 
        else:
25631 
          iprot.skip(ftype)
25632 
      else:
25633 
        iprot.skip(ftype)
25634 
      iprot.readFieldEnd()
25635 
    iprot.readStructEnd()
25636 
 
25637 
  def write(self, oprot):
25638 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25639 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25640 
      return
25641 
    oprot.writeStructBegin('updateOrderAsPaidToVendor_args')
25642 
    if self.orderId is not None:
25643 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
25644 
      oprot.writeI64(self.orderId)
25645 
      oprot.writeFieldEnd()
25646 
    oprot.writeFieldStop()
25647 
    oprot.writeStructEnd()
25648 
 
25649 
  def validate(self):
25650 
    return
25651 
 
25652 
 
25653 
  def __repr__(self):
25654 
    L = ['%s=%r' % (key, value)
25655 
      for key, value in self.__dict__.iteritems()]
25656 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25657 
 
25658 
  def __eq__(self, other):
25659 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25660 
 
25661 
  def __ne__(self, other):
25662 
    return not (self == other)
25663 
 
25664 
class updateOrderAsPaidToVendor_result:
25665 
  """
25666 
  Attributes:
25667 
   - ex
25668 
  """
25669 
 
25670 
  thrift_spec = (
25671 
    None, # 0
25672 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
25673 
  )
25674 
 
25675 
  def __init__(self, ex=None,):
25676 
    self.ex = ex
25677 
 
25678 
  def read(self, iprot):
25679 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25680 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25681 
      return
25682 
    iprot.readStructBegin()
25683 
    while True:
25684 
      (fname, ftype, fid) = iprot.readFieldBegin()
25685 
      if ftype == TType.STOP:
25686 
        break
25687 
      if fid == 1:
25688 
        if ftype == TType.STRUCT:
25689 
          self.ex = TransactionServiceException()
25690 
          self.ex.read(iprot)
25691 
        else:
25692 
          iprot.skip(ftype)
25693 
      else:
25694 
        iprot.skip(ftype)
25695 
      iprot.readFieldEnd()
25696 
    iprot.readStructEnd()
25697 
 
25698 
  def write(self, oprot):
25699 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25700 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25701 
      return
25702 
    oprot.writeStructBegin('updateOrderAsPaidToVendor_result')
25703 
    if self.ex is not None:
25704 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
25705 
      self.ex.write(oprot)
25706 
      oprot.writeFieldEnd()
25707 
    oprot.writeFieldStop()
25708 
    oprot.writeStructEnd()
25709 
 
25710 
  def validate(self):
25711 
    return
25712 
 
25713 
 
25714 
  def __repr__(self):
25715 
    L = ['%s=%r' % (key, value)
25716 
      for key, value in self.__dict__.iteritems()]
25717 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25718 
 
25719 
  def __eq__(self, other):
25720 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25721 
 
25722 
  def __ne__(self, other):
25723 
    return not (self == other)
5208 varun.gupt 25724 
 
5386 phani.kuma 25725 
class updateOrderOnlyAsPaidToVendor_args:
25726 
  """
25727 
  Attributes:
25728 
   - orderId
25729 
  """
25730 
 
25731 
  thrift_spec = (
25732 
    None, # 0
25733 
    (1, TType.I64, 'orderId', None, None, ), # 1
25734 
  )
25735 
 
25736 
  def __init__(self, orderId=None,):
25737 
    self.orderId = orderId
25738 
 
25739 
  def read(self, iprot):
25740 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25741 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25742 
      return
25743 
    iprot.readStructBegin()
25744 
    while True:
25745 
      (fname, ftype, fid) = iprot.readFieldBegin()
25746 
      if ftype == TType.STOP:
25747 
        break
25748 
      if fid == 1:
25749 
        if ftype == TType.I64:
25750 
          self.orderId = iprot.readI64();
25751 
        else:
25752 
          iprot.skip(ftype)
25753 
      else:
25754 
        iprot.skip(ftype)
25755 
      iprot.readFieldEnd()
25756 
    iprot.readStructEnd()
25757 
 
25758 
  def write(self, oprot):
25759 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25760 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25761 
      return
25762 
    oprot.writeStructBegin('updateOrderOnlyAsPaidToVendor_args')
25763 
    if self.orderId is not None:
25764 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
25765 
      oprot.writeI64(self.orderId)
25766 
      oprot.writeFieldEnd()
25767 
    oprot.writeFieldStop()
25768 
    oprot.writeStructEnd()
25769 
 
25770 
  def validate(self):
25771 
    return
25772 
 
25773 
 
25774 
  def __repr__(self):
25775 
    L = ['%s=%r' % (key, value)
25776 
      for key, value in self.__dict__.iteritems()]
25777 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25778 
 
25779 
  def __eq__(self, other):
25780 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25781 
 
25782 
  def __ne__(self, other):
25783 
    return not (self == other)
25784 
 
25785 
class updateOrderOnlyAsPaidToVendor_result:
25786 
  """
25787 
  Attributes:
25788 
   - ex
25789 
  """
25790 
 
25791 
  thrift_spec = (
25792 
    None, # 0
25793 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
25794 
  )
25795 
 
25796 
  def __init__(self, ex=None,):
25797 
    self.ex = ex
25798 
 
25799 
  def read(self, iprot):
25800 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25801 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25802 
      return
25803 
    iprot.readStructBegin()
25804 
    while True:
25805 
      (fname, ftype, fid) = iprot.readFieldBegin()
25806 
      if ftype == TType.STOP:
25807 
        break
25808 
      if fid == 1:
25809 
        if ftype == TType.STRUCT:
25810 
          self.ex = TransactionServiceException()
25811 
          self.ex.read(iprot)
25812 
        else:
25813 
          iprot.skip(ftype)
25814 
      else:
25815 
        iprot.skip(ftype)
25816 
      iprot.readFieldEnd()
25817 
    iprot.readStructEnd()
25818 
 
25819 
  def write(self, oprot):
25820 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25821 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25822 
      return
25823 
    oprot.writeStructBegin('updateOrderOnlyAsPaidToVendor_result')
25824 
    if self.ex is not None:
25825 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
25826 
      self.ex.write(oprot)
25827 
      oprot.writeFieldEnd()
25828 
    oprot.writeFieldStop()
25829 
    oprot.writeStructEnd()
25830 
 
25831 
  def validate(self):
25832 
    return
25833 
 
25834 
 
25835 
  def __repr__(self):
25836 
    L = ['%s=%r' % (key, value)
25837 
      for key, value in self.__dict__.iteritems()]
25838 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25839 
 
25840 
  def __eq__(self, other):
25841 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25842 
 
25843 
  def __ne__(self, other):
25844 
    return not (self == other)
25845 
 
5208 varun.gupt 25846 
class getRefundedOrdersMarkedPaid_args:
25847 
 
25848 
  thrift_spec = (
25849 
  )
25850 
 
25851 
  def read(self, iprot):
25852 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25853 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25854 
      return
25855 
    iprot.readStructBegin()
25856 
    while True:
25857 
      (fname, ftype, fid) = iprot.readFieldBegin()
25858 
      if ftype == TType.STOP:
25859 
        break
25860 
      else:
25861 
        iprot.skip(ftype)
25862 
      iprot.readFieldEnd()
25863 
    iprot.readStructEnd()
25864 
 
25865 
  def write(self, oprot):
25866 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25867 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25868 
      return
25869 
    oprot.writeStructBegin('getRefundedOrdersMarkedPaid_args')
25870 
    oprot.writeFieldStop()
25871 
    oprot.writeStructEnd()
25872 
 
25873 
  def validate(self):
25874 
    return
25875 
 
25876 
 
25877 
  def __repr__(self):
25878 
    L = ['%s=%r' % (key, value)
25879 
      for key, value in self.__dict__.iteritems()]
25880 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25881 
 
25882 
  def __eq__(self, other):
25883 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25884 
 
25885 
  def __ne__(self, other):
25886 
    return not (self == other)
25887 
 
25888 
class getRefundedOrdersMarkedPaid_result:
25889 
  """
25890 
  Attributes:
25891 
   - success
25892 
   - ex
25893 
  """
25894 
 
25895 
  thrift_spec = (
25896 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
25897 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
25898 
  )
25899 
 
25900 
  def __init__(self, success=None, ex=None,):
25901 
    self.success = success
25902 
    self.ex = ex
25903 
 
25904 
  def read(self, iprot):
25905 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25906 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25907 
      return
25908 
    iprot.readStructBegin()
25909 
    while True:
25910 
      (fname, ftype, fid) = iprot.readFieldBegin()
25911 
      if ftype == TType.STOP:
25912 
        break
25913 
      if fid == 0:
25914 
        if ftype == TType.LIST:
25915 
          self.success = []
6188 rajveer 25916 
          (_etype610, _size607) = iprot.readListBegin()
25917 
          for _i611 in xrange(_size607):
25918 
            _elem612 = Order()
25919 
            _elem612.read(iprot)
25920 
            self.success.append(_elem612)
5208 varun.gupt 25921 
          iprot.readListEnd()
25922 
        else:
25923 
          iprot.skip(ftype)
25924 
      elif fid == 1:
25925 
        if ftype == TType.STRUCT:
25926 
          self.ex = TransactionServiceException()
25927 
          self.ex.read(iprot)
25928 
        else:
25929 
          iprot.skip(ftype)
25930 
      else:
25931 
        iprot.skip(ftype)
25932 
      iprot.readFieldEnd()
25933 
    iprot.readStructEnd()
25934 
 
25935 
  def write(self, oprot):
25936 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25937 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25938 
      return
25939 
    oprot.writeStructBegin('getRefundedOrdersMarkedPaid_result')
25940 
    if self.success is not None:
25941 
      oprot.writeFieldBegin('success', TType.LIST, 0)
25942 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 25943 
      for iter613 in self.success:
25944 
        iter613.write(oprot)
5208 varun.gupt 25945 
      oprot.writeListEnd()
25946 
      oprot.writeFieldEnd()
25947 
    if self.ex is not None:
25948 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
25949 
      self.ex.write(oprot)
25950 
      oprot.writeFieldEnd()
25951 
    oprot.writeFieldStop()
25952 
    oprot.writeStructEnd()
25953 
 
25954 
  def validate(self):
25955 
    return
25956 
 
25957 
 
25958 
  def __repr__(self):
25959 
    L = ['%s=%r' % (key, value)
25960 
      for key, value in self.__dict__.iteritems()]
25961 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25962 
 
25963 
  def __eq__(self, other):
25964 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25965 
 
25966 
  def __ne__(self, other):
25967 
    return not (self == other)
5447 anupam.sin 25968 
 
25969 
class getAllVerificationAgents_args:
25970 
  """
25971 
  Attributes:
25972 
   - minOrderId
25973 
   - maxOrderId
25974 
  """
25975 
 
25976 
  thrift_spec = (
25977 
    None, # 0
25978 
    (1, TType.I64, 'minOrderId', None, None, ), # 1
25979 
    (2, TType.I64, 'maxOrderId', None, None, ), # 2
25980 
  )
25981 
 
25982 
  def __init__(self, minOrderId=None, maxOrderId=None,):
25983 
    self.minOrderId = minOrderId
25984 
    self.maxOrderId = maxOrderId
25985 
 
25986 
  def read(self, iprot):
25987 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25988 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25989 
      return
25990 
    iprot.readStructBegin()
25991 
    while True:
25992 
      (fname, ftype, fid) = iprot.readFieldBegin()
25993 
      if ftype == TType.STOP:
25994 
        break
25995 
      if fid == 1:
25996 
        if ftype == TType.I64:
25997 
          self.minOrderId = iprot.readI64();
25998 
        else:
25999 
          iprot.skip(ftype)
26000 
      elif fid == 2:
26001 
        if ftype == TType.I64:
26002 
          self.maxOrderId = iprot.readI64();
26003 
        else:
26004 
          iprot.skip(ftype)
26005 
      else:
26006 
        iprot.skip(ftype)
26007 
      iprot.readFieldEnd()
26008 
    iprot.readStructEnd()
26009 
 
26010 
  def write(self, oprot):
26011 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26012 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26013 
      return
26014 
    oprot.writeStructBegin('getAllVerificationAgents_args')
26015 
    if self.minOrderId is not None:
26016 
      oprot.writeFieldBegin('minOrderId', TType.I64, 1)
26017 
      oprot.writeI64(self.minOrderId)
26018 
      oprot.writeFieldEnd()
26019 
    if self.maxOrderId is not None:
26020 
      oprot.writeFieldBegin('maxOrderId', TType.I64, 2)
26021 
      oprot.writeI64(self.maxOrderId)
26022 
      oprot.writeFieldEnd()
26023 
    oprot.writeFieldStop()
26024 
    oprot.writeStructEnd()
26025 
 
26026 
  def validate(self):
26027 
    return
26028 
 
26029 
 
26030 
  def __repr__(self):
26031 
    L = ['%s=%r' % (key, value)
26032 
      for key, value in self.__dict__.iteritems()]
26033 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26034 
 
26035 
  def __eq__(self, other):
26036 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26037 
 
26038 
  def __ne__(self, other):
26039 
    return not (self == other)
26040 
 
26041 
class getAllVerificationAgents_result:
26042 
  """
26043 
  Attributes:
26044 
   - success
26045 
  """
26046 
 
26047 
  thrift_spec = (
26048 
    (0, TType.LIST, 'success', (TType.STRUCT,(CODVerificationAgent, CODVerificationAgent.thrift_spec)), None, ), # 0
26049 
  )
26050 
 
26051 
  def __init__(self, success=None,):
26052 
    self.success = success
26053 
 
26054 
  def read(self, iprot):
26055 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26056 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26057 
      return
26058 
    iprot.readStructBegin()
26059 
    while True:
26060 
      (fname, ftype, fid) = iprot.readFieldBegin()
26061 
      if ftype == TType.STOP:
26062 
        break
26063 
      if fid == 0:
26064 
        if ftype == TType.LIST:
26065 
          self.success = []
6188 rajveer 26066 
          (_etype617, _size614) = iprot.readListBegin()
26067 
          for _i618 in xrange(_size614):
26068 
            _elem619 = CODVerificationAgent()
26069 
            _elem619.read(iprot)
26070 
            self.success.append(_elem619)
5447 anupam.sin 26071 
          iprot.readListEnd()
26072 
        else:
26073 
          iprot.skip(ftype)
26074 
      else:
26075 
        iprot.skip(ftype)
26076 
      iprot.readFieldEnd()
26077 
    iprot.readStructEnd()
26078 
 
26079 
  def write(self, oprot):
26080 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26081 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26082 
      return
26083 
    oprot.writeStructBegin('getAllVerificationAgents_result')
26084 
    if self.success is not None:
26085 
      oprot.writeFieldBegin('success', TType.LIST, 0)
26086 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 26087 
      for iter620 in self.success:
26088 
        iter620.write(oprot)
5447 anupam.sin 26089 
      oprot.writeListEnd()
26090 
      oprot.writeFieldEnd()
26091 
    oprot.writeFieldStop()
26092 
    oprot.writeStructEnd()
26093 
 
26094 
  def validate(self):
26095 
    return
26096 
 
26097 
 
26098 
  def __repr__(self):
26099 
    L = ['%s=%r' % (key, value)
26100 
      for key, value in self.__dict__.iteritems()]
26101 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26102 
 
26103 
  def __eq__(self, other):
26104 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26105 
 
26106 
  def __ne__(self, other):
26107 
    return not (self == other)
5527 anupam.sin 26108 
 
26109 
class getAllAttributesForOrderId_args:
26110 
  """
26111 
  Attributes:
26112 
   - orderId
26113 
  """
26114 
 
26115 
  thrift_spec = (
26116 
    None, # 0
26117 
    (1, TType.I64, 'orderId', None, None, ), # 1
26118 
  )
26119 
 
26120 
  def __init__(self, orderId=None,):
26121 
    self.orderId = orderId
26122 
 
26123 
  def read(self, iprot):
26124 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26125 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26126 
      return
26127 
    iprot.readStructBegin()
26128 
    while True:
26129 
      (fname, ftype, fid) = iprot.readFieldBegin()
26130 
      if ftype == TType.STOP:
26131 
        break
26132 
      if fid == 1:
26133 
        if ftype == TType.I64:
26134 
          self.orderId = iprot.readI64();
26135 
        else:
26136 
          iprot.skip(ftype)
26137 
      else:
26138 
        iprot.skip(ftype)
26139 
      iprot.readFieldEnd()
26140 
    iprot.readStructEnd()
26141 
 
26142 
  def write(self, oprot):
26143 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26144 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26145 
      return
26146 
    oprot.writeStructBegin('getAllAttributesForOrderId_args')
26147 
    if self.orderId is not None:
26148 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
26149 
      oprot.writeI64(self.orderId)
26150 
      oprot.writeFieldEnd()
26151 
    oprot.writeFieldStop()
26152 
    oprot.writeStructEnd()
26153 
 
26154 
  def validate(self):
26155 
    return
26156 
 
26157 
 
26158 
  def __repr__(self):
26159 
    L = ['%s=%r' % (key, value)
26160 
      for key, value in self.__dict__.iteritems()]
26161 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26162 
 
26163 
  def __eq__(self, other):
26164 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26165 
 
26166 
  def __ne__(self, other):
26167 
    return not (self == other)
26168 
 
26169 
class getAllAttributesForOrderId_result:
26170 
  """
26171 
  Attributes:
26172 
   - success
26173 
  """
26174 
 
26175 
  thrift_spec = (
26176 
    (0, TType.LIST, 'success', (TType.STRUCT,(Attribute, Attribute.thrift_spec)), None, ), # 0
26177 
  )
26178 
 
26179 
  def __init__(self, success=None,):
26180 
    self.success = success
26181 
 
26182 
  def read(self, iprot):
26183 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26184 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26185 
      return
26186 
    iprot.readStructBegin()
26187 
    while True:
26188 
      (fname, ftype, fid) = iprot.readFieldBegin()
26189 
      if ftype == TType.STOP:
26190 
        break
26191 
      if fid == 0:
26192 
        if ftype == TType.LIST:
26193 
          self.success = []
6188 rajveer 26194 
          (_etype624, _size621) = iprot.readListBegin()
26195 
          for _i625 in xrange(_size621):
26196 
            _elem626 = Attribute()
26197 
            _elem626.read(iprot)
26198 
            self.success.append(_elem626)
5527 anupam.sin 26199 
          iprot.readListEnd()
26200 
        else:
26201 
          iprot.skip(ftype)
26202 
      else:
26203 
        iprot.skip(ftype)
26204 
      iprot.readFieldEnd()
26205 
    iprot.readStructEnd()
26206 
 
26207 
  def write(self, oprot):
26208 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26209 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26210 
      return
26211 
    oprot.writeStructBegin('getAllAttributesForOrderId_result')
26212 
    if self.success is not None:
26213 
      oprot.writeFieldBegin('success', TType.LIST, 0)
26214 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 26215 
      for iter627 in self.success:
26216 
        iter627.write(oprot)
5527 anupam.sin 26217 
      oprot.writeListEnd()
26218 
      oprot.writeFieldEnd()
26219 
    oprot.writeFieldStop()
26220 
    oprot.writeStructEnd()
26221 
 
26222 
  def validate(self):
26223 
    return
26224 
 
26225 
 
26226 
  def __repr__(self):
26227 
    L = ['%s=%r' % (key, value)
26228 
      for key, value in self.__dict__.iteritems()]
26229 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26230 
 
26231 
  def __eq__(self, other):
26232 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26233 
 
26234 
  def __ne__(self, other):
26235 
    return not (self == other)
26236 
 
5676 rajveer 26237 
class setOrderAttributes_args:
26238 
  """
26239 
  Attributes:
26240 
   - orderId
26241 
   - attributes
26242 
  """
26243 
 
26244 
  thrift_spec = None
26245 
  def __init__(self, orderId=None, attributes=None,):
26246 
    self.orderId = orderId
26247 
    self.attributes = attributes
26248 
 
26249 
  def read(self, iprot):
26250 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26251 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26252 
      return
26253 
    iprot.readStructBegin()
26254 
    while True:
26255 
      (fname, ftype, fid) = iprot.readFieldBegin()
26256 
      if ftype == TType.STOP:
26257 
        break
26258 
      if fid == 1:
26259 
        if ftype == TType.I64:
26260 
          self.orderId = iprot.readI64();
26261 
        else:
26262 
          iprot.skip(ftype)
26263 
      elif fid == -1:
26264 
        if ftype == TType.LIST:
26265 
          self.attributes = []
6188 rajveer 26266 
          (_etype631, _size628) = iprot.readListBegin()
26267 
          for _i632 in xrange(_size628):
26268 
            _elem633 = Attribute()
26269 
            _elem633.read(iprot)
26270 
            self.attributes.append(_elem633)
5676 rajveer 26271 
          iprot.readListEnd()
26272 
        else:
26273 
          iprot.skip(ftype)
26274 
      else:
26275 
        iprot.skip(ftype)
26276 
      iprot.readFieldEnd()
26277 
    iprot.readStructEnd()
26278 
 
26279 
  def write(self, oprot):
26280 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26281 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26282 
      return
26283 
    oprot.writeStructBegin('setOrderAttributes_args')
26284 
    if self.attributes is not None:
26285 
      oprot.writeFieldBegin('attributes', TType.LIST, -1)
26286 
      oprot.writeListBegin(TType.STRUCT, len(self.attributes))
6188 rajveer 26287 
      for iter634 in self.attributes:
26288 
        iter634.write(oprot)
5676 rajveer 26289 
      oprot.writeListEnd()
26290 
      oprot.writeFieldEnd()
26291 
    if self.orderId is not None:
26292 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
26293 
      oprot.writeI64(self.orderId)
26294 
      oprot.writeFieldEnd()
26295 
    oprot.writeFieldStop()
26296 
    oprot.writeStructEnd()
26297 
 
26298 
  def validate(self):
26299 
    return
26300 
 
26301 
 
26302 
  def __repr__(self):
26303 
    L = ['%s=%r' % (key, value)
26304 
      for key, value in self.__dict__.iteritems()]
26305 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26306 
 
26307 
  def __eq__(self, other):
26308 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26309 
 
26310 
  def __ne__(self, other):
26311 
    return not (self == other)
26312 
 
26313 
class setOrderAttributes_result:
26314 
 
26315 
  thrift_spec = (
26316 
  )
26317 
 
26318 
  def read(self, iprot):
26319 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26320 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26321 
      return
26322 
    iprot.readStructBegin()
26323 
    while True:
26324 
      (fname, ftype, fid) = iprot.readFieldBegin()
26325 
      if ftype == TType.STOP:
26326 
        break
26327 
      else:
26328 
        iprot.skip(ftype)
26329 
      iprot.readFieldEnd()
26330 
    iprot.readStructEnd()
26331 
 
26332 
  def write(self, oprot):
26333 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26334 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26335 
      return
26336 
    oprot.writeStructBegin('setOrderAttributes_result')
26337 
    oprot.writeFieldStop()
26338 
    oprot.writeStructEnd()
26339 
 
26340 
  def validate(self):
26341 
    return
26342 
 
26343 
 
26344 
  def __repr__(self):
26345 
    L = ['%s=%r' % (key, value)
26346 
      for key, value in self.__dict__.iteritems()]
26347 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26348 
 
26349 
  def __eq__(self, other):
26350 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26351 
 
26352 
  def __ne__(self, other):
26353 
    return not (self == other)
26354 
 
5527 anupam.sin 26355 
class setOrderAttributeForTransaction_args:
26356 
  """
26357 
  Attributes:
26358 
   - transactionId
26359 
   - attribute
26360 
  """
26361 
 
26362 
  thrift_spec = None
26363 
  def __init__(self, transactionId=None, attribute=None,):
26364 
    self.transactionId = transactionId
26365 
    self.attribute = attribute
26366 
 
26367 
  def read(self, iprot):
26368 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26369 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26370 
      return
26371 
    iprot.readStructBegin()
26372 
    while True:
26373 
      (fname, ftype, fid) = iprot.readFieldBegin()
26374 
      if ftype == TType.STOP:
26375 
        break
26376 
      if fid == 1:
26377 
        if ftype == TType.I64:
26378 
          self.transactionId = iprot.readI64();
26379 
        else:
26380 
          iprot.skip(ftype)
26381 
      elif fid == -1:
26382 
        if ftype == TType.STRUCT:
26383 
          self.attribute = Attribute()
26384 
          self.attribute.read(iprot)
26385 
        else:
26386 
          iprot.skip(ftype)
26387 
      else:
26388 
        iprot.skip(ftype)
26389 
      iprot.readFieldEnd()
26390 
    iprot.readStructEnd()
26391 
 
26392 
  def write(self, oprot):
26393 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26394 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26395 
      return
26396 
    oprot.writeStructBegin('setOrderAttributeForTransaction_args')
26397 
    if self.attribute is not None:
26398 
      oprot.writeFieldBegin('attribute', TType.STRUCT, -1)
26399 
      self.attribute.write(oprot)
26400 
      oprot.writeFieldEnd()
26401 
    if self.transactionId is not None:
26402 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
26403 
      oprot.writeI64(self.transactionId)
26404 
      oprot.writeFieldEnd()
26405 
    oprot.writeFieldStop()
26406 
    oprot.writeStructEnd()
26407 
 
26408 
  def validate(self):
26409 
    return
26410 
 
26411 
 
26412 
  def __repr__(self):
26413 
    L = ['%s=%r' % (key, value)
26414 
      for key, value in self.__dict__.iteritems()]
26415 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26416 
 
26417 
  def __eq__(self, other):
26418 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26419 
 
26420 
  def __ne__(self, other):
26421 
    return not (self == other)
26422 
 
26423 
class setOrderAttributeForTransaction_result:
26424 
 
26425 
  thrift_spec = (
26426 
  )
26427 
 
26428 
  def read(self, iprot):
26429 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26430 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26431 
      return
26432 
    iprot.readStructBegin()
26433 
    while True:
26434 
      (fname, ftype, fid) = iprot.readFieldBegin()
26435 
      if ftype == TType.STOP:
26436 
        break
26437 
      else:
26438 
        iprot.skip(ftype)
26439 
      iprot.readFieldEnd()
26440 
    iprot.readStructEnd()
26441 
 
26442 
  def write(self, oprot):
26443 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26444 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26445 
      return
26446 
    oprot.writeStructBegin('setOrderAttributeForTransaction_result')
26447 
    oprot.writeFieldStop()
26448 
    oprot.writeStructEnd()
26449 
 
26450 
  def validate(self):
26451 
    return
26452 
 
26453 
 
26454 
  def __repr__(self):
26455 
    L = ['%s=%r' % (key, value)
26456 
      for key, value in self.__dict__.iteritems()]
26457 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26458 
 
26459 
  def __eq__(self, other):
26460 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26461 
 
26462 
  def __ne__(self, other):
26463 
    return not (self == other)
5553 rajveer 26464 
 
26465 
class getReceivePendingOrders_args:
26466 
  """
26467 
  Attributes:
26468 
   - storeId
26469 
  """
26470 
 
26471 
  thrift_spec = (
26472 
    None, # 0
26473 
    (1, TType.I64, 'storeId', None, None, ), # 1
26474 
  )
26475 
 
26476 
  def __init__(self, storeId=None,):
26477 
    self.storeId = storeId
26478 
 
26479 
  def read(self, iprot):
26480 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26481 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26482 
      return
26483 
    iprot.readStructBegin()
26484 
    while True:
26485 
      (fname, ftype, fid) = iprot.readFieldBegin()
26486 
      if ftype == TType.STOP:
26487 
        break
26488 
      if fid == 1:
26489 
        if ftype == TType.I64:
26490 
          self.storeId = iprot.readI64();
26491 
        else:
26492 
          iprot.skip(ftype)
26493 
      else:
26494 
        iprot.skip(ftype)
26495 
      iprot.readFieldEnd()
26496 
    iprot.readStructEnd()
26497 
 
26498 
  def write(self, oprot):
26499 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26500 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26501 
      return
26502 
    oprot.writeStructBegin('getReceivePendingOrders_args')
26503 
    if self.storeId is not None:
26504 
      oprot.writeFieldBegin('storeId', TType.I64, 1)
26505 
      oprot.writeI64(self.storeId)
26506 
      oprot.writeFieldEnd()
26507 
    oprot.writeFieldStop()
26508 
    oprot.writeStructEnd()
26509 
 
26510 
  def validate(self):
26511 
    return
26512 
 
26513 
 
26514 
  def __repr__(self):
26515 
    L = ['%s=%r' % (key, value)
26516 
      for key, value in self.__dict__.iteritems()]
26517 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26518 
 
26519 
  def __eq__(self, other):
26520 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26521 
 
26522 
  def __ne__(self, other):
26523 
    return not (self == other)
26524 
 
26525 
class getReceivePendingOrders_result:
26526 
  """
26527 
  Attributes:
26528 
   - success
26529 
  """
26530 
 
26531 
  thrift_spec = (
26532 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
26533 
  )
26534 
 
26535 
  def __init__(self, success=None,):
26536 
    self.success = success
26537 
 
26538 
  def read(self, iprot):
26539 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26540 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26541 
      return
26542 
    iprot.readStructBegin()
26543 
    while True:
26544 
      (fname, ftype, fid) = iprot.readFieldBegin()
26545 
      if ftype == TType.STOP:
26546 
        break
26547 
      if fid == 0:
26548 
        if ftype == TType.LIST:
26549 
          self.success = []
6188 rajveer 26550 
          (_etype638, _size635) = iprot.readListBegin()
26551 
          for _i639 in xrange(_size635):
26552 
            _elem640 = Order()
26553 
            _elem640.read(iprot)
26554 
            self.success.append(_elem640)
5553 rajveer 26555 
          iprot.readListEnd()
26556 
        else:
26557 
          iprot.skip(ftype)
26558 
      else:
26559 
        iprot.skip(ftype)
26560 
      iprot.readFieldEnd()
26561 
    iprot.readStructEnd()
26562 
 
26563 
  def write(self, oprot):
26564 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26565 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26566 
      return
26567 
    oprot.writeStructBegin('getReceivePendingOrders_result')
26568 
    if self.success is not None:
26569 
      oprot.writeFieldBegin('success', TType.LIST, 0)
26570 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 26571 
      for iter641 in self.success:
26572 
        iter641.write(oprot)
5553 rajveer 26573 
      oprot.writeListEnd()
26574 
      oprot.writeFieldEnd()
26575 
    oprot.writeFieldStop()
26576 
    oprot.writeStructEnd()
26577 
 
26578 
  def validate(self):
26579 
    return
26580 
 
26581 
 
26582 
  def __repr__(self):
26583 
    L = ['%s=%r' % (key, value)
26584 
      for key, value in self.__dict__.iteritems()]
26585 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26586 
 
26587 
  def __eq__(self, other):
26588 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26589 
 
26590 
  def __ne__(self, other):
26591 
    return not (self == other)
26592 
 
26593 
class getReceivedAtStoreOrders_args:
26594 
  """
26595 
  Attributes:
26596 
   - storeId
26597 
  """
26598 
 
26599 
  thrift_spec = (
26600 
    None, # 0
26601 
    (1, TType.I64, 'storeId', None, None, ), # 1
26602 
  )
26603 
 
26604 
  def __init__(self, storeId=None,):
26605 
    self.storeId = storeId
26606 
 
26607 
  def read(self, iprot):
26608 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26609 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26610 
      return
26611 
    iprot.readStructBegin()
26612 
    while True:
26613 
      (fname, ftype, fid) = iprot.readFieldBegin()
26614 
      if ftype == TType.STOP:
26615 
        break
26616 
      if fid == 1:
26617 
        if ftype == TType.I64:
26618 
          self.storeId = iprot.readI64();
26619 
        else:
26620 
          iprot.skip(ftype)
26621 
      else:
26622 
        iprot.skip(ftype)
26623 
      iprot.readFieldEnd()
26624 
    iprot.readStructEnd()
26625 
 
26626 
  def write(self, oprot):
26627 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26628 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26629 
      return
26630 
    oprot.writeStructBegin('getReceivedAtStoreOrders_args')
26631 
    if self.storeId is not None:
26632 
      oprot.writeFieldBegin('storeId', TType.I64, 1)
26633 
      oprot.writeI64(self.storeId)
26634 
      oprot.writeFieldEnd()
26635 
    oprot.writeFieldStop()
26636 
    oprot.writeStructEnd()
26637 
 
26638 
  def validate(self):
26639 
    return
26640 
 
26641 
 
26642 
  def __repr__(self):
26643 
    L = ['%s=%r' % (key, value)
26644 
      for key, value in self.__dict__.iteritems()]
26645 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26646 
 
26647 
  def __eq__(self, other):
26648 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26649 
 
26650 
  def __ne__(self, other):
26651 
    return not (self == other)
26652 
 
26653 
class getReceivedAtStoreOrders_result:
26654 
  """
26655 
  Attributes:
26656 
   - success
26657 
  """
26658 
 
26659 
  thrift_spec = (
26660 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
26661 
  )
26662 
 
26663 
  def __init__(self, success=None,):
26664 
    self.success = success
26665 
 
26666 
  def read(self, iprot):
26667 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26668 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26669 
      return
26670 
    iprot.readStructBegin()
26671 
    while True:
26672 
      (fname, ftype, fid) = iprot.readFieldBegin()
26673 
      if ftype == TType.STOP:
26674 
        break
26675 
      if fid == 0:
26676 
        if ftype == TType.LIST:
26677 
          self.success = []
6188 rajveer 26678 
          (_etype645, _size642) = iprot.readListBegin()
26679 
          for _i646 in xrange(_size642):
26680 
            _elem647 = Order()
26681 
            _elem647.read(iprot)
26682 
            self.success.append(_elem647)
5553 rajveer 26683 
          iprot.readListEnd()
26684 
        else:
26685 
          iprot.skip(ftype)
26686 
      else:
26687 
        iprot.skip(ftype)
26688 
      iprot.readFieldEnd()
26689 
    iprot.readStructEnd()
26690 
 
26691 
  def write(self, oprot):
26692 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26693 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26694 
      return
26695 
    oprot.writeStructBegin('getReceivedAtStoreOrders_result')
26696 
    if self.success is not None:
26697 
      oprot.writeFieldBegin('success', TType.LIST, 0)
26698 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 26699 
      for iter648 in self.success:
26700 
        iter648.write(oprot)
5553 rajveer 26701 
      oprot.writeListEnd()
26702 
      oprot.writeFieldEnd()
26703 
    oprot.writeFieldStop()
26704 
    oprot.writeStructEnd()
26705 
 
26706 
  def validate(self):
26707 
    return
26708 
 
26709 
 
26710 
  def __repr__(self):
26711 
    L = ['%s=%r' % (key, value)
26712 
      for key, value in self.__dict__.iteritems()]
26713 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26714 
 
26715 
  def __eq__(self, other):
26716 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26717 
 
26718 
  def __ne__(self, other):
26719 
    return not (self == other)
5593 mandeep.dh 26720 
 
5713 rajveer 26721 
class getOrdersCollectionAtStore_args:
26722 
  """
26723 
  Attributes:
26724 
   - storeId
26725 
   - fromDate
26726 
   - toDate
26727 
   - onlyCod
26728 
  """
26729 
 
26730 
  thrift_spec = (
26731 
    None, # 0
26732 
    (1, TType.I64, 'storeId', None, None, ), # 1
26733 
    (2, TType.I64, 'fromDate', None, None, ), # 2
26734 
    (3, TType.I64, 'toDate', None, None, ), # 3
26735 
    (4, TType.BOOL, 'onlyCod', None, None, ), # 4
26736 
  )
26737 
 
26738 
  def __init__(self, storeId=None, fromDate=None, toDate=None, onlyCod=None,):
26739 
    self.storeId = storeId
26740 
    self.fromDate = fromDate
26741 
    self.toDate = toDate
26742 
    self.onlyCod = onlyCod
26743 
 
26744 
  def read(self, iprot):
26745 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26746 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26747 
      return
26748 
    iprot.readStructBegin()
26749 
    while True:
26750 
      (fname, ftype, fid) = iprot.readFieldBegin()
26751 
      if ftype == TType.STOP:
26752 
        break
26753 
      if fid == 1:
26754 
        if ftype == TType.I64:
26755 
          self.storeId = iprot.readI64();
26756 
        else:
26757 
          iprot.skip(ftype)
26758 
      elif fid == 2:
26759 
        if ftype == TType.I64:
26760 
          self.fromDate = iprot.readI64();
26761 
        else:
26762 
          iprot.skip(ftype)
26763 
      elif fid == 3:
26764 
        if ftype == TType.I64:
26765 
          self.toDate = iprot.readI64();
26766 
        else:
26767 
          iprot.skip(ftype)
26768 
      elif fid == 4:
26769 
        if ftype == TType.BOOL:
26770 
          self.onlyCod = iprot.readBool();
26771 
        else:
26772 
          iprot.skip(ftype)
26773 
      else:
26774 
        iprot.skip(ftype)
26775 
      iprot.readFieldEnd()
26776 
    iprot.readStructEnd()
26777 
 
26778 
  def write(self, oprot):
26779 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26780 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26781 
      return
26782 
    oprot.writeStructBegin('getOrdersCollectionAtStore_args')
26783 
    if self.storeId is not None:
26784 
      oprot.writeFieldBegin('storeId', TType.I64, 1)
26785 
      oprot.writeI64(self.storeId)
26786 
      oprot.writeFieldEnd()
26787 
    if self.fromDate is not None:
26788 
      oprot.writeFieldBegin('fromDate', TType.I64, 2)
26789 
      oprot.writeI64(self.fromDate)
26790 
      oprot.writeFieldEnd()
26791 
    if self.toDate is not None:
26792 
      oprot.writeFieldBegin('toDate', TType.I64, 3)
26793 
      oprot.writeI64(self.toDate)
26794 
      oprot.writeFieldEnd()
26795 
    if self.onlyCod is not None:
26796 
      oprot.writeFieldBegin('onlyCod', TType.BOOL, 4)
26797 
      oprot.writeBool(self.onlyCod)
26798 
      oprot.writeFieldEnd()
26799 
    oprot.writeFieldStop()
26800 
    oprot.writeStructEnd()
26801 
 
26802 
  def validate(self):
26803 
    return
26804 
 
26805 
 
26806 
  def __repr__(self):
26807 
    L = ['%s=%r' % (key, value)
26808 
      for key, value in self.__dict__.iteritems()]
26809 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26810 
 
26811 
  def __eq__(self, other):
26812 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26813 
 
26814 
  def __ne__(self, other):
26815 
    return not (self == other)
26816 
 
26817 
class getOrdersCollectionAtStore_result:
26818 
  """
26819 
  Attributes:
26820 
   - success
26821 
  """
26822 
 
26823 
  thrift_spec = (
26824 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
26825 
  )
26826 
 
26827 
  def __init__(self, success=None,):
26828 
    self.success = success
26829 
 
26830 
  def read(self, iprot):
26831 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26832 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26833 
      return
26834 
    iprot.readStructBegin()
26835 
    while True:
26836 
      (fname, ftype, fid) = iprot.readFieldBegin()
26837 
      if ftype == TType.STOP:
26838 
        break
26839 
      if fid == 0:
26840 
        if ftype == TType.LIST:
26841 
          self.success = []
6188 rajveer 26842 
          (_etype652, _size649) = iprot.readListBegin()
26843 
          for _i653 in xrange(_size649):
26844 
            _elem654 = Order()
26845 
            _elem654.read(iprot)
26846 
            self.success.append(_elem654)
5713 rajveer 26847 
          iprot.readListEnd()
26848 
        else:
26849 
          iprot.skip(ftype)
26850 
      else:
26851 
        iprot.skip(ftype)
26852 
      iprot.readFieldEnd()
26853 
    iprot.readStructEnd()
26854 
 
26855 
  def write(self, oprot):
26856 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26857 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26858 
      return
26859 
    oprot.writeStructBegin('getOrdersCollectionAtStore_result')
26860 
    if self.success is not None:
26861 
      oprot.writeFieldBegin('success', TType.LIST, 0)
26862 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 26863 
      for iter655 in self.success:
26864 
        iter655.write(oprot)
5713 rajveer 26865 
      oprot.writeListEnd()
26866 
      oprot.writeFieldEnd()
26867 
    oprot.writeFieldStop()
26868 
    oprot.writeStructEnd()
26869 
 
26870 
  def validate(self):
26871 
    return
26872 
 
26873 
 
26874 
  def __repr__(self):
26875 
    L = ['%s=%r' % (key, value)
26876 
      for key, value in self.__dict__.iteritems()]
26877 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26878 
 
26879 
  def __eq__(self, other):
26880 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26881 
 
26882 
  def __ne__(self, other):
26883 
    return not (self == other)
26884 
 
5833 rajveer 26885 
class getOrderAttributeValue_args:
26886 
  """
26887 
  Attributes:
26888 
   - orderId
26889 
   - attributeName
26890 
  """
26891 
 
26892 
  thrift_spec = None
26893 
  def __init__(self, orderId=None, attributeName=None,):
26894 
    self.orderId = orderId
26895 
    self.attributeName = attributeName
26896 
 
26897 
  def read(self, iprot):
26898 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26899 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26900 
      return
26901 
    iprot.readStructBegin()
26902 
    while True:
26903 
      (fname, ftype, fid) = iprot.readFieldBegin()
26904 
      if ftype == TType.STOP:
26905 
        break
26906 
      if fid == 1:
26907 
        if ftype == TType.I64:
26908 
          self.orderId = iprot.readI64();
26909 
        else:
26910 
          iprot.skip(ftype)
26911 
      elif fid == -1:
26912 
        if ftype == TType.STRING:
26913 
          self.attributeName = iprot.readString();
26914 
        else:
26915 
          iprot.skip(ftype)
26916 
      else:
26917 
        iprot.skip(ftype)
26918 
      iprot.readFieldEnd()
26919 
    iprot.readStructEnd()
26920 
 
26921 
  def write(self, oprot):
26922 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26923 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26924 
      return
26925 
    oprot.writeStructBegin('getOrderAttributeValue_args')
26926 
    if self.attributeName is not None:
26927 
      oprot.writeFieldBegin('attributeName', TType.STRING, -1)
26928 
      oprot.writeString(self.attributeName)
26929 
      oprot.writeFieldEnd()
26930 
    if self.orderId is not None:
26931 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
26932 
      oprot.writeI64(self.orderId)
26933 
      oprot.writeFieldEnd()
26934 
    oprot.writeFieldStop()
26935 
    oprot.writeStructEnd()
26936 
 
26937 
  def validate(self):
26938 
    return
26939 
 
26940 
 
26941 
  def __repr__(self):
26942 
    L = ['%s=%r' % (key, value)
26943 
      for key, value in self.__dict__.iteritems()]
26944 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26945 
 
26946 
  def __eq__(self, other):
26947 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26948 
 
26949 
  def __ne__(self, other):
26950 
    return not (self == other)
26951 
 
26952 
class getOrderAttributeValue_result:
26953 
  """
26954 
  Attributes:
26955 
   - success
26956 
  """
26957 
 
26958 
  thrift_spec = (
26959 
    (0, TType.STRING, 'success', None, None, ), # 0
26960 
  )
26961 
 
26962 
  def __init__(self, success=None,):
26963 
    self.success = success
26964 
 
26965 
  def read(self, iprot):
26966 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26967 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26968 
      return
26969 
    iprot.readStructBegin()
26970 
    while True:
26971 
      (fname, ftype, fid) = iprot.readFieldBegin()
26972 
      if ftype == TType.STOP:
26973 
        break
26974 
      if fid == 0:
26975 
        if ftype == TType.STRING:
26976 
          self.success = iprot.readString();
26977 
        else:
26978 
          iprot.skip(ftype)
26979 
      else:
26980 
        iprot.skip(ftype)
26981 
      iprot.readFieldEnd()
26982 
    iprot.readStructEnd()
26983 
 
26984 
  def write(self, oprot):
26985 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26986 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26987 
      return
26988 
    oprot.writeStructBegin('getOrderAttributeValue_result')
26989 
    if self.success is not None:
26990 
      oprot.writeFieldBegin('success', TType.STRING, 0)
26991 
      oprot.writeString(self.success)
26992 
      oprot.writeFieldEnd()
26993 
    oprot.writeFieldStop()
26994 
    oprot.writeStructEnd()
26995 
 
26996 
  def validate(self):
26997 
    return
26998 
 
26999 
 
27000 
  def __repr__(self):
27001 
    L = ['%s=%r' % (key, value)
27002 
      for key, value in self.__dict__.iteritems()]
27003 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27004 
 
27005 
  def __eq__(self, other):
27006 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27007 
 
27008 
  def __ne__(self, other):
27009 
    return not (self == other)
27010 
 
6019 rajveer 27011 
class changeJacketNumber_args:
27012 
  """
27013 
  Attributes:
27014 
   - orderId
27015 
   - jacketNumber
27016 
  """
27017 
 
27018 
  thrift_spec = (
27019 
    None, # 0
27020 
    (1, TType.I64, 'orderId', None, None, ), # 1
27021 
    (2, TType.I64, 'jacketNumber', None, None, ), # 2
27022 
  )
27023 
 
27024 
  def __init__(self, orderId=None, jacketNumber=None,):
27025 
    self.orderId = orderId
27026 
    self.jacketNumber = jacketNumber
27027 
 
27028 
  def read(self, iprot):
27029 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27030 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27031 
      return
27032 
    iprot.readStructBegin()
27033 
    while True:
27034 
      (fname, ftype, fid) = iprot.readFieldBegin()
27035 
      if ftype == TType.STOP:
27036 
        break
27037 
      if fid == 1:
27038 
        if ftype == TType.I64:
27039 
          self.orderId = iprot.readI64();
27040 
        else:
27041 
          iprot.skip(ftype)
27042 
      elif fid == 2:
27043 
        if ftype == TType.I64:
27044 
          self.jacketNumber = iprot.readI64();
27045 
        else:
27046 
          iprot.skip(ftype)
27047 
      else:
27048 
        iprot.skip(ftype)
27049 
      iprot.readFieldEnd()
27050 
    iprot.readStructEnd()
27051 
 
27052 
  def write(self, oprot):
27053 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27054 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27055 
      return
27056 
    oprot.writeStructBegin('changeJacketNumber_args')
27057 
    if self.orderId is not None:
27058 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
27059 
      oprot.writeI64(self.orderId)
27060 
      oprot.writeFieldEnd()
27061 
    if self.jacketNumber is not None:
27062 
      oprot.writeFieldBegin('jacketNumber', TType.I64, 2)
27063 
      oprot.writeI64(self.jacketNumber)
27064 
      oprot.writeFieldEnd()
27065 
    oprot.writeFieldStop()
27066 
    oprot.writeStructEnd()
27067 
 
27068 
  def validate(self):
27069 
    return
27070 
 
27071 
 
27072 
  def __repr__(self):
27073 
    L = ['%s=%r' % (key, value)
27074 
      for key, value in self.__dict__.iteritems()]
27075 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27076 
 
27077 
  def __eq__(self, other):
27078 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27079 
 
27080 
  def __ne__(self, other):
27081 
    return not (self == other)
27082 
 
27083 
class changeJacketNumber_result:
27084 
  """
27085 
  Attributes:
27086 
   - success
27087 
  """
27088 
 
27089 
  thrift_spec = (
27090 
    (0, TType.BOOL, 'success', None, None, ), # 0
27091 
  )
27092 
 
27093 
  def __init__(self, success=None,):
27094 
    self.success = success
27095 
 
27096 
  def read(self, iprot):
27097 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27098 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27099 
      return
27100 
    iprot.readStructBegin()
27101 
    while True:
27102 
      (fname, ftype, fid) = iprot.readFieldBegin()
27103 
      if ftype == TType.STOP:
27104 
        break
27105 
      if fid == 0:
27106 
        if ftype == TType.BOOL:
27107 
          self.success = iprot.readBool();
27108 
        else:
27109 
          iprot.skip(ftype)
27110 
      else:
27111 
        iprot.skip(ftype)
27112 
      iprot.readFieldEnd()
27113 
    iprot.readStructEnd()
27114 
 
27115 
  def write(self, oprot):
27116 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27117 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27118 
      return
27119 
    oprot.writeStructBegin('changeJacketNumber_result')
27120 
    if self.success is not None:
27121 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
27122 
      oprot.writeBool(self.success)
27123 
      oprot.writeFieldEnd()
27124 
    oprot.writeFieldStop()
27125 
    oprot.writeStructEnd()
27126 
 
27127 
  def validate(self):
27128 
    return
27129 
 
27130 
 
27131 
  def __repr__(self):
27132 
    L = ['%s=%r' % (key, value)
27133 
      for key, value in self.__dict__.iteritems()]
27134 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27135 
 
27136 
  def __eq__(self, other):
27137 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27138 
 
27139 
  def __ne__(self, other):
27140 
    return not (self == other)
27141 
 
27142 
class markOrderAsRtoInTransit_args:
27143 
  """
27144 
  Attributes:
27145 
   - orderId
27146 
  """
27147 
 
27148 
  thrift_spec = (
27149 
    None, # 0
27150 
    (1, TType.I64, 'orderId', None, None, ), # 1
27151 
  )
27152 
 
27153 
  def __init__(self, orderId=None,):
27154 
    self.orderId = orderId
27155 
 
27156 
  def read(self, iprot):
27157 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27158 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27159 
      return
27160 
    iprot.readStructBegin()
27161 
    while True:
27162 
      (fname, ftype, fid) = iprot.readFieldBegin()
27163 
      if ftype == TType.STOP:
27164 
        break
27165 
      if fid == 1:
27166 
        if ftype == TType.I64:
27167 
          self.orderId = iprot.readI64();
27168 
        else:
27169 
          iprot.skip(ftype)
27170 
      else:
27171 
        iprot.skip(ftype)
27172 
      iprot.readFieldEnd()
27173 
    iprot.readStructEnd()
27174 
 
27175 
  def write(self, oprot):
27176 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27177 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27178 
      return
27179 
    oprot.writeStructBegin('markOrderAsRtoInTransit_args')
27180 
    if self.orderId is not None:
27181 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
27182 
      oprot.writeI64(self.orderId)
27183 
      oprot.writeFieldEnd()
27184 
    oprot.writeFieldStop()
27185 
    oprot.writeStructEnd()
27186 
 
27187 
  def validate(self):
27188 
    return
27189 
 
27190 
 
27191 
  def __repr__(self):
27192 
    L = ['%s=%r' % (key, value)
27193 
      for key, value in self.__dict__.iteritems()]
27194 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27195 
 
27196 
  def __eq__(self, other):
27197 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27198 
 
27199 
  def __ne__(self, other):
27200 
    return not (self == other)
27201 
 
27202 
class markOrderAsRtoInTransit_result:
27203 
  """
27204 
  Attributes:
27205 
   - success
27206 
  """
27207 
 
27208 
  thrift_spec = (
27209 
    (0, TType.BOOL, 'success', None, None, ), # 0
27210 
  )
27211 
 
27212 
  def __init__(self, success=None,):
27213 
    self.success = success
27214 
 
27215 
  def read(self, iprot):
27216 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27217 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27218 
      return
27219 
    iprot.readStructBegin()
27220 
    while True:
27221 
      (fname, ftype, fid) = iprot.readFieldBegin()
27222 
      if ftype == TType.STOP:
27223 
        break
27224 
      if fid == 0:
27225 
        if ftype == TType.BOOL:
27226 
          self.success = iprot.readBool();
27227 
        else:
27228 
          iprot.skip(ftype)
27229 
      else:
27230 
        iprot.skip(ftype)
27231 
      iprot.readFieldEnd()
27232 
    iprot.readStructEnd()
27233 
 
27234 
  def write(self, oprot):
27235 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27236 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27237 
      return
27238 
    oprot.writeStructBegin('markOrderAsRtoInTransit_result')
27239 
    if self.success is not None:
27240 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
27241 
      oprot.writeBool(self.success)
27242 
      oprot.writeFieldEnd()
27243 
    oprot.writeFieldStop()
27244 
    oprot.writeStructEnd()
27245 
 
27246 
  def validate(self):
27247 
    return
27248 
 
27249 
 
27250 
  def __repr__(self):
27251 
    L = ['%s=%r' % (key, value)
27252 
      for key, value in self.__dict__.iteritems()]
27253 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27254 
 
27255 
  def __eq__(self, other):
27256 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27257 
 
27258 
  def __ne__(self, other):
27259 
    return not (self == other)
27260 
 
5593 mandeep.dh 27261 
class acceptOrderForItem_args:
27262 
  """
27263 
  Attributes:
27264 
   - itemId
27265 
   - quantity
27266 
   - fulfilmentWarehouseId
27267 
   - billingWarehouseId
27268 
  """
27269 
 
27270 
  thrift_spec = (
27271 
    None, # 0
27272 
    (1, TType.I64, 'itemId', None, None, ), # 1
27273 
    (2, TType.I64, 'quantity', None, None, ), # 2
27274 
    (3, TType.I64, 'fulfilmentWarehouseId', None, None, ), # 3
27275 
    (4, TType.I64, 'billingWarehouseId', None, None, ), # 4
27276 
  )
27277 
 
27278 
  def __init__(self, itemId=None, quantity=None, fulfilmentWarehouseId=None, billingWarehouseId=None,):
27279 
    self.itemId = itemId
27280 
    self.quantity = quantity
27281 
    self.fulfilmentWarehouseId = fulfilmentWarehouseId
27282 
    self.billingWarehouseId = billingWarehouseId
27283 
 
27284 
  def read(self, iprot):
27285 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27286 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27287 
      return
27288 
    iprot.readStructBegin()
27289 
    while True:
27290 
      (fname, ftype, fid) = iprot.readFieldBegin()
27291 
      if ftype == TType.STOP:
27292 
        break
27293 
      if fid == 1:
27294 
        if ftype == TType.I64:
27295 
          self.itemId = iprot.readI64();
27296 
        else:
27297 
          iprot.skip(ftype)
27298 
      elif fid == 2:
27299 
        if ftype == TType.I64:
27300 
          self.quantity = iprot.readI64();
27301 
        else:
27302 
          iprot.skip(ftype)
27303 
      elif fid == 3:
27304 
        if ftype == TType.I64:
27305 
          self.fulfilmentWarehouseId = iprot.readI64();
27306 
        else:
27307 
          iprot.skip(ftype)
27308 
      elif fid == 4:
27309 
        if ftype == TType.I64:
27310 
          self.billingWarehouseId = iprot.readI64();
27311 
        else:
27312 
          iprot.skip(ftype)
27313 
      else:
27314 
        iprot.skip(ftype)
27315 
      iprot.readFieldEnd()
27316 
    iprot.readStructEnd()
27317 
 
27318 
  def write(self, oprot):
27319 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27320 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27321 
      return
27322 
    oprot.writeStructBegin('acceptOrderForItem_args')
27323 
    if self.itemId is not None:
27324 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
27325 
      oprot.writeI64(self.itemId)
27326 
      oprot.writeFieldEnd()
27327 
    if self.quantity is not None:
27328 
      oprot.writeFieldBegin('quantity', TType.I64, 2)
27329 
      oprot.writeI64(self.quantity)
27330 
      oprot.writeFieldEnd()
27331 
    if self.fulfilmentWarehouseId is not None:
27332 
      oprot.writeFieldBegin('fulfilmentWarehouseId', TType.I64, 3)
27333 
      oprot.writeI64(self.fulfilmentWarehouseId)
27334 
      oprot.writeFieldEnd()
27335 
    if self.billingWarehouseId is not None:
27336 
      oprot.writeFieldBegin('billingWarehouseId', TType.I64, 4)
27337 
      oprot.writeI64(self.billingWarehouseId)
27338 
      oprot.writeFieldEnd()
27339 
    oprot.writeFieldStop()
27340 
    oprot.writeStructEnd()
27341 
 
27342 
  def validate(self):
27343 
    return
27344 
 
27345 
 
27346 
  def __repr__(self):
27347 
    L = ['%s=%r' % (key, value)
27348 
      for key, value in self.__dict__.iteritems()]
27349 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27350 
 
27351 
  def __eq__(self, other):
27352 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27353 
 
27354 
  def __ne__(self, other):
27355 
    return not (self == other)
27356 
 
27357 
class acceptOrderForItem_result:
27358 
 
27359 
  thrift_spec = (
27360 
  )
27361 
 
27362 
  def read(self, iprot):
27363 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27364 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27365 
      return
27366 
    iprot.readStructBegin()
27367 
    while True:
27368 
      (fname, ftype, fid) = iprot.readFieldBegin()
27369 
      if ftype == TType.STOP:
27370 
        break
27371 
      else:
27372 
        iprot.skip(ftype)
27373 
      iprot.readFieldEnd()
27374 
    iprot.readStructEnd()
27375 
 
27376 
  def write(self, oprot):
27377 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27378 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27379 
      return
27380 
    oprot.writeStructBegin('acceptOrderForItem_result')
27381 
    oprot.writeFieldStop()
27382 
    oprot.writeStructEnd()
27383 
 
27384 
  def validate(self):
27385 
    return
27386 
 
27387 
 
27388 
  def __repr__(self):
27389 
    L = ['%s=%r' % (key, value)
27390 
      for key, value in self.__dict__.iteritems()]
27391 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27392 
 
27393 
  def __eq__(self, other):
27394 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27395 
 
27396 
  def __ne__(self, other):
27397 
    return not (self == other)
6000 mandeep.dh 27398 
 
27399 
class createRechargeOrder_args:
27400 
  """
27401 
  Attributes:
27402 
   - rechargeOrder
27403 
  """
27404 
 
27405 
  thrift_spec = (
27406 
    None, # 0
27407 
    (1, TType.STRUCT, 'rechargeOrder', (RechargeOrder, RechargeOrder.thrift_spec), None, ), # 1
27408 
  )
27409 
 
27410 
  def __init__(self, rechargeOrder=None,):
27411 
    self.rechargeOrder = rechargeOrder
27412 
 
27413 
  def read(self, iprot):
27414 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27415 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27416 
      return
27417 
    iprot.readStructBegin()
27418 
    while True:
27419 
      (fname, ftype, fid) = iprot.readFieldBegin()
27420 
      if ftype == TType.STOP:
27421 
        break
27422 
      if fid == 1:
27423 
        if ftype == TType.STRUCT:
27424 
          self.rechargeOrder = RechargeOrder()
27425 
          self.rechargeOrder.read(iprot)
27426 
        else:
27427 
          iprot.skip(ftype)
27428 
      else:
27429 
        iprot.skip(ftype)
27430 
      iprot.readFieldEnd()
27431 
    iprot.readStructEnd()
27432 
 
27433 
  def write(self, oprot):
27434 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27435 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27436 
      return
27437 
    oprot.writeStructBegin('createRechargeOrder_args')
27438 
    if self.rechargeOrder is not None:
27439 
      oprot.writeFieldBegin('rechargeOrder', TType.STRUCT, 1)
27440 
      self.rechargeOrder.write(oprot)
27441 
      oprot.writeFieldEnd()
27442 
    oprot.writeFieldStop()
27443 
    oprot.writeStructEnd()
27444 
 
27445 
  def validate(self):
27446 
    return
27447 
 
27448 
 
27449 
  def __repr__(self):
27450 
    L = ['%s=%r' % (key, value)
27451 
      for key, value in self.__dict__.iteritems()]
27452 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27453 
 
27454 
  def __eq__(self, other):
27455 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27456 
 
27457 
  def __ne__(self, other):
27458 
    return not (self == other)
27459 
 
27460 
class createRechargeOrder_result:
27461 
  """
27462 
  Attributes:
27463 
   - success
27464 
   - ex
27465 
  """
27466 
 
27467 
  thrift_spec = (
27468 
    (0, TType.STRUCT, 'success', (RechargeOrder, RechargeOrder.thrift_spec), None, ), # 0
27469 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
27470 
  )
27471 
 
27472 
  def __init__(self, success=None, ex=None,):
27473 
    self.success = success
27474 
    self.ex = ex
27475 
 
27476 
  def read(self, iprot):
27477 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27478 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27479 
      return
27480 
    iprot.readStructBegin()
27481 
    while True:
27482 
      (fname, ftype, fid) = iprot.readFieldBegin()
27483 
      if ftype == TType.STOP:
27484 
        break
27485 
      if fid == 0:
27486 
        if ftype == TType.STRUCT:
27487 
          self.success = RechargeOrder()
27488 
          self.success.read(iprot)
27489 
        else:
27490 
          iprot.skip(ftype)
27491 
      elif fid == 1:
27492 
        if ftype == TType.STRUCT:
27493 
          self.ex = TransactionServiceException()
27494 
          self.ex.read(iprot)
27495 
        else:
27496 
          iprot.skip(ftype)
27497 
      else:
27498 
        iprot.skip(ftype)
27499 
      iprot.readFieldEnd()
27500 
    iprot.readStructEnd()
27501 
 
27502 
  def write(self, oprot):
27503 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27504 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27505 
      return
27506 
    oprot.writeStructBegin('createRechargeOrder_result')
27507 
    if self.success is not None:
27508 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
27509 
      self.success.write(oprot)
27510 
      oprot.writeFieldEnd()
27511 
    if self.ex is not None:
27512 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
27513 
      self.ex.write(oprot)
27514 
      oprot.writeFieldEnd()
27515 
    oprot.writeFieldStop()
27516 
    oprot.writeStructEnd()
27517 
 
27518 
  def validate(self):
27519 
    return
27520 
 
27521 
 
27522 
  def __repr__(self):
27523 
    L = ['%s=%r' % (key, value)
27524 
      for key, value in self.__dict__.iteritems()]
27525 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27526 
 
27527 
  def __eq__(self, other):
27528 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27529 
 
27530 
  def __ne__(self, other):
27531 
    return not (self == other)
27532 
 
6031 rajveer 27533 
class getRechargeOrder_args:
27534 
  """
27535 
  Attributes:
27536 
   - rechargeRrderId
27537 
  """
27538 
 
27539 
  thrift_spec = (
27540 
    None, # 0
27541 
    (1, TType.I64, 'rechargeRrderId', None, None, ), # 1
27542 
  )
27543 
 
27544 
  def __init__(self, rechargeRrderId=None,):
27545 
    self.rechargeRrderId = rechargeRrderId
27546 
 
27547 
  def read(self, iprot):
27548 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27549 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27550 
      return
27551 
    iprot.readStructBegin()
27552 
    while True:
27553 
      (fname, ftype, fid) = iprot.readFieldBegin()
27554 
      if ftype == TType.STOP:
27555 
        break
27556 
      if fid == 1:
27557 
        if ftype == TType.I64:
27558 
          self.rechargeRrderId = iprot.readI64();
27559 
        else:
27560 
          iprot.skip(ftype)
27561 
      else:
27562 
        iprot.skip(ftype)
27563 
      iprot.readFieldEnd()
27564 
    iprot.readStructEnd()
27565 
 
27566 
  def write(self, oprot):
27567 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27568 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27569 
      return
27570 
    oprot.writeStructBegin('getRechargeOrder_args')
27571 
    if self.rechargeRrderId is not None:
27572 
      oprot.writeFieldBegin('rechargeRrderId', TType.I64, 1)
27573 
      oprot.writeI64(self.rechargeRrderId)
27574 
      oprot.writeFieldEnd()
27575 
    oprot.writeFieldStop()
27576 
    oprot.writeStructEnd()
27577 
 
27578 
  def validate(self):
27579 
    return
27580 
 
27581 
 
27582 
  def __repr__(self):
27583 
    L = ['%s=%r' % (key, value)
27584 
      for key, value in self.__dict__.iteritems()]
27585 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27586 
 
27587 
  def __eq__(self, other):
27588 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27589 
 
27590 
  def __ne__(self, other):
27591 
    return not (self == other)
27592 
 
27593 
class getRechargeOrder_result:
27594 
  """
27595 
  Attributes:
27596 
   - success
27597 
   - ex
27598 
  """
27599 
 
27600 
  thrift_spec = (
27601 
    (0, TType.STRUCT, 'success', (RechargeOrder, RechargeOrder.thrift_spec), None, ), # 0
27602 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
27603 
  )
27604 
 
27605 
  def __init__(self, success=None, ex=None,):
27606 
    self.success = success
27607 
    self.ex = ex
27608 
 
27609 
  def read(self, iprot):
27610 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27611 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27612 
      return
27613 
    iprot.readStructBegin()
27614 
    while True:
27615 
      (fname, ftype, fid) = iprot.readFieldBegin()
27616 
      if ftype == TType.STOP:
27617 
        break
27618 
      if fid == 0:
27619 
        if ftype == TType.STRUCT:
27620 
          self.success = RechargeOrder()
27621 
          self.success.read(iprot)
27622 
        else:
27623 
          iprot.skip(ftype)
27624 
      elif fid == 1:
27625 
        if ftype == TType.STRUCT:
27626 
          self.ex = TransactionServiceException()
27627 
          self.ex.read(iprot)
27628 
        else:
27629 
          iprot.skip(ftype)
27630 
      else:
27631 
        iprot.skip(ftype)
27632 
      iprot.readFieldEnd()
27633 
    iprot.readStructEnd()
27634 
 
27635 
  def write(self, oprot):
27636 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27637 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27638 
      return
27639 
    oprot.writeStructBegin('getRechargeOrder_result')
27640 
    if self.success is not None:
27641 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
27642 
      self.success.write(oprot)
27643 
      oprot.writeFieldEnd()
27644 
    if self.ex is not None:
27645 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
27646 
      self.ex.write(oprot)
27647 
      oprot.writeFieldEnd()
27648 
    oprot.writeFieldStop()
27649 
    oprot.writeStructEnd()
27650 
 
27651 
  def validate(self):
27652 
    return
27653 
 
27654 
 
27655 
  def __repr__(self):
27656 
    L = ['%s=%r' % (key, value)
27657 
      for key, value in self.__dict__.iteritems()]
27658 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27659 
 
27660 
  def __eq__(self, other):
27661 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27662 
 
27663 
  def __ne__(self, other):
27664 
    return not (self == other)
27665 
 
27666 
class getRechargeOrders_args:
27667 
  """
27668 
  Attributes:
27669 
   - userId
27670 
  """
27671 
 
27672 
  thrift_spec = (
27673 
    None, # 0
27674 
    (1, TType.I64, 'userId', None, None, ), # 1
27675 
  )
27676 
 
27677 
  def __init__(self, userId=None,):
27678 
    self.userId = userId
27679 
 
27680 
  def read(self, iprot):
27681 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27682 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27683 
      return
27684 
    iprot.readStructBegin()
27685 
    while True:
27686 
      (fname, ftype, fid) = iprot.readFieldBegin()
27687 
      if ftype == TType.STOP:
27688 
        break
27689 
      if fid == 1:
27690 
        if ftype == TType.I64:
27691 
          self.userId = iprot.readI64();
27692 
        else:
27693 
          iprot.skip(ftype)
27694 
      else:
27695 
        iprot.skip(ftype)
27696 
      iprot.readFieldEnd()
27697 
    iprot.readStructEnd()
27698 
 
27699 
  def write(self, oprot):
27700 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27701 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27702 
      return
27703 
    oprot.writeStructBegin('getRechargeOrders_args')
27704 
    if self.userId is not None:
27705 
      oprot.writeFieldBegin('userId', TType.I64, 1)
27706 
      oprot.writeI64(self.userId)
27707 
      oprot.writeFieldEnd()
27708 
    oprot.writeFieldStop()
27709 
    oprot.writeStructEnd()
27710 
 
27711 
  def validate(self):
27712 
    return
27713 
 
27714 
 
27715 
  def __repr__(self):
27716 
    L = ['%s=%r' % (key, value)
27717 
      for key, value in self.__dict__.iteritems()]
27718 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27719 
 
27720 
  def __eq__(self, other):
27721 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27722 
 
27723 
  def __ne__(self, other):
27724 
    return not (self == other)
27725 
 
27726 
class getRechargeOrders_result:
27727 
  """
27728 
  Attributes:
27729 
   - success
27730 
  """
27731 
 
27732 
  thrift_spec = (
27733 
    (0, TType.LIST, 'success', (TType.STRUCT,(RechargeOrder, RechargeOrder.thrift_spec)), None, ), # 0
27734 
  )
27735 
 
27736 
  def __init__(self, success=None,):
27737 
    self.success = success
27738 
 
27739 
  def read(self, iprot):
27740 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27741 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27742 
      return
27743 
    iprot.readStructBegin()
27744 
    while True:
27745 
      (fname, ftype, fid) = iprot.readFieldBegin()
27746 
      if ftype == TType.STOP:
27747 
        break
27748 
      if fid == 0:
27749 
        if ftype == TType.LIST:
27750 
          self.success = []
6188 rajveer 27751 
          (_etype659, _size656) = iprot.readListBegin()
27752 
          for _i660 in xrange(_size656):
27753 
            _elem661 = RechargeOrder()
27754 
            _elem661.read(iprot)
27755 
            self.success.append(_elem661)
6031 rajveer 27756 
          iprot.readListEnd()
27757 
        else:
27758 
          iprot.skip(ftype)
27759 
      else:
27760 
        iprot.skip(ftype)
27761 
      iprot.readFieldEnd()
27762 
    iprot.readStructEnd()
27763 
 
27764 
  def write(self, oprot):
27765 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27766 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27767 
      return
27768 
    oprot.writeStructBegin('getRechargeOrders_result')
27769 
    if self.success is not None:
27770 
      oprot.writeFieldBegin('success', TType.LIST, 0)
27771 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 27772 
      for iter662 in self.success:
27773 
        iter662.write(oprot)
6031 rajveer 27774 
      oprot.writeListEnd()
27775 
      oprot.writeFieldEnd()
27776 
    oprot.writeFieldStop()
27777 
    oprot.writeStructEnd()
27778 
 
27779 
  def validate(self):
27780 
    return
27781 
 
27782 
 
27783 
  def __repr__(self):
27784 
    L = ['%s=%r' % (key, value)
27785 
      for key, value in self.__dict__.iteritems()]
27786 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27787 
 
27788 
  def __eq__(self, other):
27789 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27790 
 
27791 
  def __ne__(self, other):
27792 
    return not (self == other)
27793 
 
6000 mandeep.dh 27794 
class updateRechargeOrderStatus_args:
27795 
  """
27796 
  Attributes:
27797 
   - rechargeOrderId
27798 
   - rechargeOrderStatus
27799 
  """
27800 
 
27801 
  thrift_spec = (
27802 
    None, # 0
27803 
    (1, TType.I64, 'rechargeOrderId', None, None, ), # 1
27804 
    (2, TType.I32, 'rechargeOrderStatus', None, None, ), # 2
27805 
  )
27806 
 
27807 
  def __init__(self, rechargeOrderId=None, rechargeOrderStatus=None,):
27808 
    self.rechargeOrderId = rechargeOrderId
27809 
    self.rechargeOrderStatus = rechargeOrderStatus
27810 
 
27811 
  def read(self, iprot):
27812 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27813 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27814 
      return
27815 
    iprot.readStructBegin()
27816 
    while True:
27817 
      (fname, ftype, fid) = iprot.readFieldBegin()
27818 
      if ftype == TType.STOP:
27819 
        break
27820 
      if fid == 1:
27821 
        if ftype == TType.I64:
27822 
          self.rechargeOrderId = iprot.readI64();
27823 
        else:
27824 
          iprot.skip(ftype)
27825 
      elif fid == 2:
27826 
        if ftype == TType.I32:
27827 
          self.rechargeOrderStatus = iprot.readI32();
27828 
        else:
27829 
          iprot.skip(ftype)
27830 
      else:
27831 
        iprot.skip(ftype)
27832 
      iprot.readFieldEnd()
27833 
    iprot.readStructEnd()
27834 
 
27835 
  def write(self, oprot):
27836 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27837 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27838 
      return
27839 
    oprot.writeStructBegin('updateRechargeOrderStatus_args')
27840 
    if self.rechargeOrderId is not None:
27841 
      oprot.writeFieldBegin('rechargeOrderId', TType.I64, 1)
27842 
      oprot.writeI64(self.rechargeOrderId)
27843 
      oprot.writeFieldEnd()
27844 
    if self.rechargeOrderStatus is not None:
27845 
      oprot.writeFieldBegin('rechargeOrderStatus', TType.I32, 2)
27846 
      oprot.writeI32(self.rechargeOrderStatus)
27847 
      oprot.writeFieldEnd()
27848 
    oprot.writeFieldStop()
27849 
    oprot.writeStructEnd()
27850 
 
27851 
  def validate(self):
27852 
    return
27853 
 
27854 
 
27855 
  def __repr__(self):
27856 
    L = ['%s=%r' % (key, value)
27857 
      for key, value in self.__dict__.iteritems()]
27858 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27859 
 
27860 
  def __eq__(self, other):
27861 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27862 
 
27863 
  def __ne__(self, other):
27864 
    return not (self == other)
27865 
 
27866 
class updateRechargeOrderStatus_result:
27867 
  """
27868 
  Attributes:
6031 rajveer 27869 
   - success
6000 mandeep.dh 27870 
   - ex
27871 
  """
27872 
 
27873 
  thrift_spec = (
6031 rajveer 27874 
    (0, TType.BOOL, 'success', None, None, ), # 0
6000 mandeep.dh 27875 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
27876 
  )
27877 
 
6031 rajveer 27878 
  def __init__(self, success=None, ex=None,):
27879 
    self.success = success
6000 mandeep.dh 27880 
    self.ex = ex
27881 
 
27882 
  def read(self, iprot):
27883 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27884 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27885 
      return
27886 
    iprot.readStructBegin()
27887 
    while True:
27888 
      (fname, ftype, fid) = iprot.readFieldBegin()
27889 
      if ftype == TType.STOP:
27890 
        break
6031 rajveer 27891 
      if fid == 0:
27892 
        if ftype == TType.BOOL:
27893 
          self.success = iprot.readBool();
27894 
        else:
27895 
          iprot.skip(ftype)
27896 
      elif fid == 1:
6000 mandeep.dh 27897 
        if ftype == TType.STRUCT:
27898 
          self.ex = TransactionServiceException()
27899 
          self.ex.read(iprot)
27900 
        else:
27901 
          iprot.skip(ftype)
27902 
      else:
27903 
        iprot.skip(ftype)
27904 
      iprot.readFieldEnd()
27905 
    iprot.readStructEnd()
27906 
 
27907 
  def write(self, oprot):
27908 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27909 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27910 
      return
27911 
    oprot.writeStructBegin('updateRechargeOrderStatus_result')
6031 rajveer 27912 
    if self.success is not None:
27913 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
27914 
      oprot.writeBool(self.success)
27915 
      oprot.writeFieldEnd()
6000 mandeep.dh 27916 
    if self.ex is not None:
27917 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
27918 
      self.ex.write(oprot)
27919 
      oprot.writeFieldEnd()
27920 
    oprot.writeFieldStop()
27921 
    oprot.writeStructEnd()
27922 
 
27923 
  def validate(self):
27924 
    return
27925 
 
27926 
 
27927 
  def __repr__(self):
27928 
    L = ['%s=%r' % (key, value)
27929 
      for key, value in self.__dict__.iteritems()]
27930 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27931 
 
27932 
  def __eq__(self, other):
27933 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27934 
 
27935 
  def __ne__(self, other):
27936 
    return not (self == other)
27937 
 
27938 
class activateRechargeTxn_args:
27939 
  """
27940 
  Attributes:
6031 rajveer 27941 
   - rechargeOrderId
6000 mandeep.dh 27942 
  """
27943 
 
27944 
  thrift_spec = (
27945 
    None, # 0
6031 rajveer 27946 
    (1, TType.I64, 'rechargeOrderId', None, None, ), # 1
6000 mandeep.dh 27947 
  )
27948 
 
6031 rajveer 27949 
  def __init__(self, rechargeOrderId=None,):
27950 
    self.rechargeOrderId = rechargeOrderId
6000 mandeep.dh 27951 
 
27952 
  def read(self, iprot):
27953 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27954 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27955 
      return
27956 
    iprot.readStructBegin()
27957 
    while True:
27958 
      (fname, ftype, fid) = iprot.readFieldBegin()
27959 
      if ftype == TType.STOP:
27960 
        break
27961 
      if fid == 1:
6031 rajveer 27962 
        if ftype == TType.I64:
27963 
          self.rechargeOrderId = iprot.readI64();
6000 mandeep.dh 27964 
        else:
27965 
          iprot.skip(ftype)
27966 
      else:
27967 
        iprot.skip(ftype)
27968 
      iprot.readFieldEnd()
27969 
    iprot.readStructEnd()
27970 
 
27971 
  def write(self, oprot):
27972 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27973 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27974 
      return
27975 
    oprot.writeStructBegin('activateRechargeTxn_args')
6031 rajveer 27976 
    if self.rechargeOrderId is not None:
27977 
      oprot.writeFieldBegin('rechargeOrderId', TType.I64, 1)
27978 
      oprot.writeI64(self.rechargeOrderId)
6000 mandeep.dh 27979 
      oprot.writeFieldEnd()
27980 
    oprot.writeFieldStop()
27981 
    oprot.writeStructEnd()
27982 
 
27983 
  def validate(self):
27984 
    return
27985 
 
27986 
 
27987 
  def __repr__(self):
27988 
    L = ['%s=%r' % (key, value)
27989 
      for key, value in self.__dict__.iteritems()]
27990 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27991 
 
27992 
  def __eq__(self, other):
27993 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27994 
 
27995 
  def __ne__(self, other):
27996 
    return not (self == other)
27997 
 
27998 
class activateRechargeTxn_result:
27999 
  """
28000 
  Attributes:
28001 
   - success
28002 
   - ex
28003 
  """
28004 
 
28005 
  thrift_spec = (
6031 rajveer 28006 
    (0, TType.BOOL, 'success', None, None, ), # 0
6000 mandeep.dh 28007 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
28008 
  )
28009 
 
28010 
  def __init__(self, success=None, ex=None,):
28011 
    self.success = success
28012 
    self.ex = ex
28013 
 
28014 
  def read(self, iprot):
28015 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28016 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28017 
      return
28018 
    iprot.readStructBegin()
28019 
    while True:
28020 
      (fname, ftype, fid) = iprot.readFieldBegin()
28021 
      if ftype == TType.STOP:
28022 
        break
28023 
      if fid == 0:
6031 rajveer 28024 
        if ftype == TType.BOOL:
28025 
          self.success = iprot.readBool();
6000 mandeep.dh 28026 
        else:
28027 
          iprot.skip(ftype)
28028 
      elif fid == 1:
28029 
        if ftype == TType.STRUCT:
28030 
          self.ex = TransactionServiceException()
28031 
          self.ex.read(iprot)
28032 
        else:
28033 
          iprot.skip(ftype)
28034 
      else:
28035 
        iprot.skip(ftype)
28036 
      iprot.readFieldEnd()
28037 
    iprot.readStructEnd()
28038 
 
28039 
  def write(self, oprot):
28040 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28041 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28042 
      return
28043 
    oprot.writeStructBegin('activateRechargeTxn_result')
28044 
    if self.success is not None:
6031 rajveer 28045 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
28046 
      oprot.writeBool(self.success)
6000 mandeep.dh 28047 
      oprot.writeFieldEnd()
28048 
    if self.ex is not None:
28049 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
28050 
      self.ex.write(oprot)
28051 
      oprot.writeFieldEnd()
28052 
    oprot.writeFieldStop()
28053 
    oprot.writeStructEnd()
28054 
 
28055 
  def validate(self):
28056 
    return
28057 
 
28058 
 
28059 
  def __repr__(self):
28060 
    L = ['%s=%r' % (key, value)
28061 
      for key, value in self.__dict__.iteritems()]
28062 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28063 
 
28064 
  def __eq__(self, other):
28065 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28066 
 
28067 
  def __ne__(self, other):
28068 
    return not (self == other)
28069 
 
6031 rajveer 28070 
class getUserWallet_args:
6000 mandeep.dh 28071 
  """
28072 
  Attributes:
6031 rajveer 28073 
   - userId
6000 mandeep.dh 28074 
  """
28075 
 
28076 
  thrift_spec = (
28077 
    None, # 0
6031 rajveer 28078 
    (1, TType.I64, 'userId', None, None, ), # 1
6000 mandeep.dh 28079 
  )
28080 
 
6031 rajveer 28081 
  def __init__(self, userId=None,):
28082 
    self.userId = userId
6000 mandeep.dh 28083 
 
28084 
  def read(self, iprot):
28085 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28086 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28087 
      return
28088 
    iprot.readStructBegin()
28089 
    while True:
28090 
      (fname, ftype, fid) = iprot.readFieldBegin()
28091 
      if ftype == TType.STOP:
28092 
        break
28093 
      if fid == 1:
28094 
        if ftype == TType.I64:
6031 rajveer 28095 
          self.userId = iprot.readI64();
6000 mandeep.dh 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
6031 rajveer 28107 
    oprot.writeStructBegin('getUserWallet_args')
28108 
    if self.userId is not None:
28109 
      oprot.writeFieldBegin('userId', TType.I64, 1)
28110 
      oprot.writeI64(self.userId)
6000 mandeep.dh 28111 
      oprot.writeFieldEnd()
28112 
    oprot.writeFieldStop()
28113 
    oprot.writeStructEnd()
28114 
 
28115 
  def validate(self):
28116 
    return
28117 
 
28118 
 
28119 
  def __repr__(self):
28120 
    L = ['%s=%r' % (key, value)
28121 
      for key, value in self.__dict__.iteritems()]
28122 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28123 
 
28124 
  def __eq__(self, other):
28125 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28126 
 
28127 
  def __ne__(self, other):
28128 
    return not (self == other)
28129 
 
6031 rajveer 28130 
class getUserWallet_result:
6000 mandeep.dh 28131 
  """
28132 
  Attributes:
28133 
   - success
28134 
  """
28135 
 
28136 
  thrift_spec = (
6031 rajveer 28137 
    (0, TType.STRUCT, 'success', (UserWallet, UserWallet.thrift_spec), None, ), # 0
6000 mandeep.dh 28138 
  )
28139 
 
28140 
  def __init__(self, success=None,):
28141 
    self.success = success
28142 
 
28143 
  def read(self, iprot):
28144 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28145 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28146 
      return
28147 
    iprot.readStructBegin()
28148 
    while True:
28149 
      (fname, ftype, fid) = iprot.readFieldBegin()
28150 
      if ftype == TType.STOP:
28151 
        break
28152 
      if fid == 0:
6031 rajveer 28153 
        if ftype == TType.STRUCT:
28154 
          self.success = UserWallet()
28155 
          self.success.read(iprot)
6000 mandeep.dh 28156 
        else:
28157 
          iprot.skip(ftype)
28158 
      else:
28159 
        iprot.skip(ftype)
28160 
      iprot.readFieldEnd()
28161 
    iprot.readStructEnd()
28162 
 
28163 
  def write(self, oprot):
28164 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28165 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28166 
      return
6031 rajveer 28167 
    oprot.writeStructBegin('getUserWallet_result')
6000 mandeep.dh 28168 
    if self.success is not None:
6031 rajveer 28169 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
28170 
      self.success.write(oprot)
6000 mandeep.dh 28171 
      oprot.writeFieldEnd()
28172 
    oprot.writeFieldStop()
28173 
    oprot.writeStructEnd()
28174 
 
28175 
  def validate(self):
28176 
    return
28177 
 
28178 
 
28179 
  def __repr__(self):
28180 
    L = ['%s=%r' % (key, value)
28181 
      for key, value in self.__dict__.iteritems()]
28182 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28183 
 
28184 
  def __eq__(self, other):
28185 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28186 
 
28187 
  def __ne__(self, other):
28188 
    return not (self == other)
28189 
 
6031 rajveer 28190 
class getUserWalletHistory_args:
6000 mandeep.dh 28191 
  """
28192 
  Attributes:
6031 rajveer 28193 
   - userId
6000 mandeep.dh 28194 
  """
28195 
 
28196 
  thrift_spec = (
28197 
    None, # 0
6031 rajveer 28198 
    (1, TType.I64, 'userId', None, None, ), # 1
6000 mandeep.dh 28199 
  )
28200 
 
6031 rajveer 28201 
  def __init__(self, userId=None,):
28202 
    self.userId = userId
6000 mandeep.dh 28203 
 
28204 
  def read(self, iprot):
28205 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28206 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28207 
      return
28208 
    iprot.readStructBegin()
28209 
    while True:
28210 
      (fname, ftype, fid) = iprot.readFieldBegin()
28211 
      if ftype == TType.STOP:
28212 
        break
28213 
      if fid == 1:
28214 
        if ftype == TType.I64:
6031 rajveer 28215 
          self.userId = iprot.readI64();
6000 mandeep.dh 28216 
        else:
28217 
          iprot.skip(ftype)
28218 
      else:
28219 
        iprot.skip(ftype)
28220 
      iprot.readFieldEnd()
28221 
    iprot.readStructEnd()
28222 
 
28223 
  def write(self, oprot):
28224 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28225 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28226 
      return
6031 rajveer 28227 
    oprot.writeStructBegin('getUserWalletHistory_args')
28228 
    if self.userId is not None:
28229 
      oprot.writeFieldBegin('userId', TType.I64, 1)
28230 
      oprot.writeI64(self.userId)
6000 mandeep.dh 28231 
      oprot.writeFieldEnd()
28232 
    oprot.writeFieldStop()
28233 
    oprot.writeStructEnd()
28234 
 
28235 
  def validate(self):
28236 
    return
28237 
 
28238 
 
28239 
  def __repr__(self):
28240 
    L = ['%s=%r' % (key, value)
28241 
      for key, value in self.__dict__.iteritems()]
28242 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28243 
 
28244 
  def __eq__(self, other):
28245 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28246 
 
28247 
  def __ne__(self, other):
28248 
    return not (self == other)
28249 
 
6031 rajveer 28250 
class getUserWalletHistory_result:
6000 mandeep.dh 28251 
  """
28252 
  Attributes:
28253 
   - success
28254 
  """
28255 
 
28256 
  thrift_spec = (
6031 rajveer 28257 
    (0, TType.LIST, 'success', (TType.STRUCT,(UserWalletHistory, UserWalletHistory.thrift_spec)), None, ), # 0
6000 mandeep.dh 28258 
  )
28259 
 
28260 
  def __init__(self, success=None,):
28261 
    self.success = success
28262 
 
28263 
  def read(self, iprot):
28264 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28265 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28266 
      return
28267 
    iprot.readStructBegin()
28268 
    while True:
28269 
      (fname, ftype, fid) = iprot.readFieldBegin()
28270 
      if ftype == TType.STOP:
28271 
        break
28272 
      if fid == 0:
28273 
        if ftype == TType.LIST:
28274 
          self.success = []
6188 rajveer 28275 
          (_etype666, _size663) = iprot.readListBegin()
28276 
          for _i667 in xrange(_size663):
28277 
            _elem668 = UserWalletHistory()
28278 
            _elem668.read(iprot)
28279 
            self.success.append(_elem668)
6000 mandeep.dh 28280 
          iprot.readListEnd()
28281 
        else:
28282 
          iprot.skip(ftype)
28283 
      else:
28284 
        iprot.skip(ftype)
28285 
      iprot.readFieldEnd()
28286 
    iprot.readStructEnd()
28287 
 
28288 
  def write(self, oprot):
28289 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28290 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28291 
      return
6031 rajveer 28292 
    oprot.writeStructBegin('getUserWalletHistory_result')
6000 mandeep.dh 28293 
    if self.success is not None:
28294 
      oprot.writeFieldBegin('success', TType.LIST, 0)
28295 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 28296 
      for iter669 in self.success:
28297 
        iter669.write(oprot)
6000 mandeep.dh 28298 
      oprot.writeListEnd()
28299 
      oprot.writeFieldEnd()
28300 
    oprot.writeFieldStop()
28301 
    oprot.writeStructEnd()
28302 
 
28303 
  def validate(self):
28304 
    return
28305 
 
28306 
 
28307 
  def __repr__(self):
28308 
    L = ['%s=%r' % (key, value)
28309 
      for key, value in self.__dict__.iteritems()]
28310 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28311 
 
28312 
  def __eq__(self, other):
28313 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28314 
 
28315 
  def __ne__(self, other):
28316 
    return not (self == other)
6048 rajveer 28317 
 
6050 anupam.sin 28318 
class getRechargeOrdersForTransaction_args:
28319 
  """
28320 
  Attributes:
28321 
   - txnId
28322 
  """
28323 
 
28324 
  thrift_spec = (
28325 
    None, # 0
28326 
    (1, TType.I64, 'txnId', None, None, ), # 1
28327 
  )
28328 
 
28329 
  def __init__(self, txnId=None,):
28330 
    self.txnId = txnId
28331 
 
28332 
  def read(self, iprot):
28333 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28334 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28335 
      return
28336 
    iprot.readStructBegin()
28337 
    while True:
28338 
      (fname, ftype, fid) = iprot.readFieldBegin()
28339 
      if ftype == TType.STOP:
28340 
        break
28341 
      if fid == 1:
28342 
        if ftype == TType.I64:
28343 
          self.txnId = iprot.readI64();
28344 
        else:
28345 
          iprot.skip(ftype)
28346 
      else:
28347 
        iprot.skip(ftype)
28348 
      iprot.readFieldEnd()
28349 
    iprot.readStructEnd()
28350 
 
28351 
  def write(self, oprot):
28352 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28353 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28354 
      return
28355 
    oprot.writeStructBegin('getRechargeOrdersForTransaction_args')
28356 
    if self.txnId is not None:
28357 
      oprot.writeFieldBegin('txnId', TType.I64, 1)
28358 
      oprot.writeI64(self.txnId)
28359 
      oprot.writeFieldEnd()
28360 
    oprot.writeFieldStop()
28361 
    oprot.writeStructEnd()
28362 
 
28363 
  def validate(self):
28364 
    return
28365 
 
28366 
 
28367 
  def __repr__(self):
28368 
    L = ['%s=%r' % (key, value)
28369 
      for key, value in self.__dict__.iteritems()]
28370 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28371 
 
28372 
  def __eq__(self, other):
28373 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28374 
 
28375 
  def __ne__(self, other):
28376 
    return not (self == other)
28377 
 
28378 
class getRechargeOrdersForTransaction_result:
28379 
  """
28380 
  Attributes:
28381 
   - success
28382 
   - ex
28383 
  """
28384 
 
28385 
  thrift_spec = (
28386 
    (0, TType.STRUCT, 'success', (RechargeOrder, RechargeOrder.thrift_spec), None, ), # 0
28387 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
28388 
  )
28389 
 
28390 
  def __init__(self, success=None, ex=None,):
28391 
    self.success = success
28392 
    self.ex = ex
28393 
 
28394 
  def read(self, iprot):
28395 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28396 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28397 
      return
28398 
    iprot.readStructBegin()
28399 
    while True:
28400 
      (fname, ftype, fid) = iprot.readFieldBegin()
28401 
      if ftype == TType.STOP:
28402 
        break
28403 
      if fid == 0:
28404 
        if ftype == TType.STRUCT:
28405 
          self.success = RechargeOrder()
28406 
          self.success.read(iprot)
28407 
        else:
28408 
          iprot.skip(ftype)
28409 
      elif fid == 1:
28410 
        if ftype == TType.STRUCT:
28411 
          self.ex = TransactionServiceException()
28412 
          self.ex.read(iprot)
28413 
        else:
28414 
          iprot.skip(ftype)
28415 
      else:
28416 
        iprot.skip(ftype)
28417 
      iprot.readFieldEnd()
28418 
    iprot.readStructEnd()
28419 
 
28420 
  def write(self, oprot):
28421 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28422 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28423 
      return
28424 
    oprot.writeStructBegin('getRechargeOrdersForTransaction_result')
28425 
    if self.success is not None:
28426 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
28427 
      self.success.write(oprot)
28428 
      oprot.writeFieldEnd()
28429 
    if self.ex is not None:
28430 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
28431 
      self.ex.write(oprot)
28432 
      oprot.writeFieldEnd()
28433 
    oprot.writeFieldStop()
28434 
    oprot.writeStructEnd()
28435 
 
28436 
  def validate(self):
28437 
    return
28438 
 
28439 
 
28440 
  def __repr__(self):
28441 
    L = ['%s=%r' % (key, value)
28442 
      for key, value in self.__dict__.iteritems()]
28443 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28444 
 
28445 
  def __eq__(self, other):
28446 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28447 
 
28448 
  def __ne__(self, other):
28449 
    return not (self == other)
28450 
 
6048 rajveer 28451 
class getServiceProviders_args:
28452 
  """
28453 
  Attributes:
28454 
   - rechargeType
6206 rajveer 28455 
   - onlyActive
6048 rajveer 28456 
  """
28457 
 
28458 
  thrift_spec = (
28459 
    None, # 0
28460 
    (1, TType.I32, 'rechargeType', None, None, ), # 1
6206 rajveer 28461 
    (2, TType.BOOL, 'onlyActive', None, None, ), # 2
6048 rajveer 28462 
  )
28463 
 
6206 rajveer 28464 
  def __init__(self, rechargeType=None, onlyActive=None,):
6048 rajveer 28465 
    self.rechargeType = rechargeType
6206 rajveer 28466 
    self.onlyActive = onlyActive
6048 rajveer 28467 
 
28468 
  def read(self, iprot):
28469 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28470 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28471 
      return
28472 
    iprot.readStructBegin()
28473 
    while True:
28474 
      (fname, ftype, fid) = iprot.readFieldBegin()
28475 
      if ftype == TType.STOP:
28476 
        break
28477 
      if fid == 1:
28478 
        if ftype == TType.I32:
28479 
          self.rechargeType = iprot.readI32();
28480 
        else:
28481 
          iprot.skip(ftype)
6206 rajveer 28482 
      elif fid == 2:
28483 
        if ftype == TType.BOOL:
28484 
          self.onlyActive = iprot.readBool();
28485 
        else:
28486 
          iprot.skip(ftype)
6048 rajveer 28487 
      else:
28488 
        iprot.skip(ftype)
28489 
      iprot.readFieldEnd()
28490 
    iprot.readStructEnd()
28491 
 
28492 
  def write(self, oprot):
28493 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28494 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28495 
      return
28496 
    oprot.writeStructBegin('getServiceProviders_args')
28497 
    if self.rechargeType is not None:
28498 
      oprot.writeFieldBegin('rechargeType', TType.I32, 1)
28499 
      oprot.writeI32(self.rechargeType)
28500 
      oprot.writeFieldEnd()
6206 rajveer 28501 
    if self.onlyActive is not None:
28502 
      oprot.writeFieldBegin('onlyActive', TType.BOOL, 2)
28503 
      oprot.writeBool(self.onlyActive)
28504 
      oprot.writeFieldEnd()
6048 rajveer 28505 
    oprot.writeFieldStop()
28506 
    oprot.writeStructEnd()
28507 
 
28508 
  def validate(self):
28509 
    return
28510 
 
28511 
 
28512 
  def __repr__(self):
28513 
    L = ['%s=%r' % (key, value)
28514 
      for key, value in self.__dict__.iteritems()]
28515 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28516 
 
28517 
  def __eq__(self, other):
28518 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28519 
 
28520 
  def __ne__(self, other):
28521 
    return not (self == other)
28522 
 
28523 
class getServiceProviders_result:
28524 
  """
28525 
  Attributes:
28526 
   - success
28527 
  """
28528 
 
28529 
  thrift_spec = (
28530 
    (0, TType.MAP, 'success', (TType.I64,None,TType.STRING,None), None, ), # 0
28531 
  )
28532 
 
28533 
  def __init__(self, success=None,):
28534 
    self.success = success
28535 
 
28536 
  def read(self, iprot):
28537 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28538 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28539 
      return
28540 
    iprot.readStructBegin()
28541 
    while True:
28542 
      (fname, ftype, fid) = iprot.readFieldBegin()
28543 
      if ftype == TType.STOP:
28544 
        break
28545 
      if fid == 0:
28546 
        if ftype == TType.MAP:
28547 
          self.success = {}
6188 rajveer 28548 
          (_ktype671, _vtype672, _size670 ) = iprot.readMapBegin()
28549 
          for _i674 in xrange(_size670):
28550 
            _key675 = iprot.readI64();
28551 
            _val676 = iprot.readString();
28552 
            self.success[_key675] = _val676
6048 rajveer 28553 
          iprot.readMapEnd()
28554 
        else:
28555 
          iprot.skip(ftype)
28556 
      else:
28557 
        iprot.skip(ftype)
28558 
      iprot.readFieldEnd()
28559 
    iprot.readStructEnd()
28560 
 
28561 
  def write(self, oprot):
28562 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28563 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28564 
      return
28565 
    oprot.writeStructBegin('getServiceProviders_result')
28566 
    if self.success is not None:
28567 
      oprot.writeFieldBegin('success', TType.MAP, 0)
28568 
      oprot.writeMapBegin(TType.I64, TType.STRING, len(self.success))
6188 rajveer 28569 
      for kiter677,viter678 in self.success.items():
28570 
        oprot.writeI64(kiter677)
28571 
        oprot.writeString(viter678)
6048 rajveer 28572 
      oprot.writeMapEnd()
28573 
      oprot.writeFieldEnd()
28574 
    oprot.writeFieldStop()
28575 
    oprot.writeStructEnd()
28576 
 
28577 
  def validate(self):
28578 
    return
28579 
 
28580 
 
28581 
  def __repr__(self):
28582 
    L = ['%s=%r' % (key, value)
28583 
      for key, value in self.__dict__.iteritems()]
28584 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28585 
 
28586 
  def __eq__(self, other):
28587 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28588 
 
28589 
  def __ne__(self, other):
28590 
    return not (self == other)
28591 
 
28592 
class getServiceProviderForDevice_args:
28593 
  """
28594 
  Attributes:
6049 rajveer 28595 
   - rechargeType
6048 rajveer 28596 
   - deviceNumber
28597 
  """
28598 
 
28599 
  thrift_spec = (
28600 
    None, # 0
6049 rajveer 28601 
    (1, TType.I32, 'rechargeType', None, None, ), # 1
28602 
    (2, TType.STRING, 'deviceNumber', None, None, ), # 2
6048 rajveer 28603 
  )
28604 
 
6049 rajveer 28605 
  def __init__(self, rechargeType=None, deviceNumber=None,):
28606 
    self.rechargeType = rechargeType
6048 rajveer 28607 
    self.deviceNumber = deviceNumber
28608 
 
28609 
  def read(self, iprot):
28610 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28611 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28612 
      return
28613 
    iprot.readStructBegin()
28614 
    while True:
28615 
      (fname, ftype, fid) = iprot.readFieldBegin()
28616 
      if ftype == TType.STOP:
28617 
        break
28618 
      if fid == 1:
6049 rajveer 28619 
        if ftype == TType.I32:
28620 
          self.rechargeType = iprot.readI32();
28621 
        else:
28622 
          iprot.skip(ftype)
28623 
      elif fid == 2:
6048 rajveer 28624 
        if ftype == TType.STRING:
28625 
          self.deviceNumber = iprot.readString();
28626 
        else:
28627 
          iprot.skip(ftype)
28628 
      else:
28629 
        iprot.skip(ftype)
28630 
      iprot.readFieldEnd()
28631 
    iprot.readStructEnd()
28632 
 
28633 
  def write(self, oprot):
28634 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28635 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28636 
      return
28637 
    oprot.writeStructBegin('getServiceProviderForDevice_args')
6049 rajveer 28638 
    if self.rechargeType is not None:
28639 
      oprot.writeFieldBegin('rechargeType', TType.I32, 1)
28640 
      oprot.writeI32(self.rechargeType)
28641 
      oprot.writeFieldEnd()
6048 rajveer 28642 
    if self.deviceNumber is not None:
6049 rajveer 28643 
      oprot.writeFieldBegin('deviceNumber', TType.STRING, 2)
6048 rajveer 28644 
      oprot.writeString(self.deviceNumber)
28645 
      oprot.writeFieldEnd()
28646 
    oprot.writeFieldStop()
28647 
    oprot.writeStructEnd()
28648 
 
28649 
  def validate(self):
28650 
    return
28651 
 
28652 
 
28653 
  def __repr__(self):
28654 
    L = ['%s=%r' % (key, value)
28655 
      for key, value in self.__dict__.iteritems()]
28656 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28657 
 
28658 
  def __eq__(self, other):
28659 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28660 
 
28661 
  def __ne__(self, other):
28662 
    return not (self == other)
28663 
 
28664 
class getServiceProviderForDevice_result:
28665 
  """
28666 
  Attributes:
28667 
   - success
28668 
  """
28669 
 
28670 
  thrift_spec = (
6289 anupam.sin 28671 
    (0, TType.STRUCT, 'success', (DeviceNumberInfo, DeviceNumberInfo.thrift_spec), None, ), # 0
6048 rajveer 28672 
  )
28673 
 
28674 
  def __init__(self, success=None,):
28675 
    self.success = success
28676 
 
28677 
  def read(self, iprot):
28678 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28679 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28680 
      return
28681 
    iprot.readStructBegin()
28682 
    while True:
28683 
      (fname, ftype, fid) = iprot.readFieldBegin()
28684 
      if ftype == TType.STOP:
28685 
        break
28686 
      if fid == 0:
6289 anupam.sin 28687 
        if ftype == TType.STRUCT:
28688 
          self.success = DeviceNumberInfo()
28689 
          self.success.read(iprot)
6048 rajveer 28690 
        else:
28691 
          iprot.skip(ftype)
28692 
      else:
28693 
        iprot.skip(ftype)
28694 
      iprot.readFieldEnd()
28695 
    iprot.readStructEnd()
28696 
 
28697 
  def write(self, oprot):
28698 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28699 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28700 
      return
28701 
    oprot.writeStructBegin('getServiceProviderForDevice_result')
28702 
    if self.success is not None:
6289 anupam.sin 28703 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
28704 
      self.success.write(oprot)
6048 rajveer 28705 
      oprot.writeFieldEnd()
28706 
    oprot.writeFieldStop()
28707 
    oprot.writeStructEnd()
28708 
 
28709 
  def validate(self):
28710 
    return
28711 
 
28712 
 
28713 
  def __repr__(self):
28714 
    L = ['%s=%r' % (key, value)
28715 
      for key, value in self.__dict__.iteritems()]
28716 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28717 
 
28718 
  def __eq__(self, other):
28719 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28720 
 
28721 
  def __ne__(self, other):
28722 
    return not (self == other)
6094 rajveer 28723 
 
6269 rajveer 28724 
class validateRecharge_args:
28725 
  """
28726 
  Attributes:
28727 
   - rechargeType
28728 
   - deviceNumber
6307 anupam.sin 28729 
   - userSelectedProviderId
6591 anupam.sin 28730 
   - clientAddress
6269 rajveer 28731 
  """
28732 
 
28733 
  thrift_spec = (
28734 
    None, # 0
28735 
    (1, TType.I32, 'rechargeType', None, None, ), # 1
28736 
    (2, TType.STRING, 'deviceNumber', None, None, ), # 2
6336 anupam.sin 28737 
    (3, TType.I64, 'userSelectedProviderId', None, None, ), # 3
6591 anupam.sin 28738 
    (4, TType.STRING, 'clientAddress', None, None, ), # 4
6269 rajveer 28739 
  )
28740 
 
6591 anupam.sin 28741 
  def __init__(self, rechargeType=None, deviceNumber=None, userSelectedProviderId=None, clientAddress=None,):
6269 rajveer 28742 
    self.rechargeType = rechargeType
28743 
    self.deviceNumber = deviceNumber
6307 anupam.sin 28744 
    self.userSelectedProviderId = userSelectedProviderId
6591 anupam.sin 28745 
    self.clientAddress = clientAddress
6269 rajveer 28746 
 
28747 
  def read(self, iprot):
28748 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28749 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28750 
      return
28751 
    iprot.readStructBegin()
28752 
    while True:
28753 
      (fname, ftype, fid) = iprot.readFieldBegin()
28754 
      if ftype == TType.STOP:
28755 
        break
28756 
      if fid == 1:
28757 
        if ftype == TType.I32:
28758 
          self.rechargeType = iprot.readI32();
28759 
        else:
28760 
          iprot.skip(ftype)
28761 
      elif fid == 2:
28762 
        if ftype == TType.STRING:
28763 
          self.deviceNumber = iprot.readString();
28764 
        else:
28765 
          iprot.skip(ftype)
6307 anupam.sin 28766 
      elif fid == 3:
28767 
        if ftype == TType.I64:
28768 
          self.userSelectedProviderId = iprot.readI64();
28769 
        else:
28770 
          iprot.skip(ftype)
6591 anupam.sin 28771 
      elif fid == 4:
28772 
        if ftype == TType.STRING:
28773 
          self.clientAddress = iprot.readString();
28774 
        else:
28775 
          iprot.skip(ftype)
6269 rajveer 28776 
      else:
28777 
        iprot.skip(ftype)
28778 
      iprot.readFieldEnd()
28779 
    iprot.readStructEnd()
28780 
 
28781 
  def write(self, oprot):
28782 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28783 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28784 
      return
28785 
    oprot.writeStructBegin('validateRecharge_args')
28786 
    if self.rechargeType is not None:
28787 
      oprot.writeFieldBegin('rechargeType', TType.I32, 1)
28788 
      oprot.writeI32(self.rechargeType)
28789 
      oprot.writeFieldEnd()
28790 
    if self.deviceNumber is not None:
28791 
      oprot.writeFieldBegin('deviceNumber', TType.STRING, 2)
28792 
      oprot.writeString(self.deviceNumber)
28793 
      oprot.writeFieldEnd()
6307 anupam.sin 28794 
    if self.userSelectedProviderId is not None:
6336 anupam.sin 28795 
      oprot.writeFieldBegin('userSelectedProviderId', TType.I64, 3)
6307 anupam.sin 28796 
      oprot.writeI64(self.userSelectedProviderId)
28797 
      oprot.writeFieldEnd()
6591 anupam.sin 28798 
    if self.clientAddress is not None:
28799 
      oprot.writeFieldBegin('clientAddress', TType.STRING, 4)
28800 
      oprot.writeString(self.clientAddress)
28801 
      oprot.writeFieldEnd()
6269 rajveer 28802 
    oprot.writeFieldStop()
28803 
    oprot.writeStructEnd()
28804 
 
28805 
  def validate(self):
28806 
    return
28807 
 
28808 
 
28809 
  def __repr__(self):
28810 
    L = ['%s=%r' % (key, value)
28811 
      for key, value in self.__dict__.iteritems()]
28812 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28813 
 
28814 
  def __eq__(self, other):
28815 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28816 
 
28817 
  def __ne__(self, other):
28818 
    return not (self == other)
28819 
 
28820 
class validateRecharge_result:
28821 
  """
28822 
  Attributes:
28823 
   - success
28824 
  """
28825 
 
28826 
  thrift_spec = (
28827 
    (0, TType.STRING, 'success', None, None, ), # 0
28828 
  )
28829 
 
28830 
  def __init__(self, success=None,):
28831 
    self.success = success
28832 
 
28833 
  def read(self, iprot):
28834 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28835 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28836 
      return
28837 
    iprot.readStructBegin()
28838 
    while True:
28839 
      (fname, ftype, fid) = iprot.readFieldBegin()
28840 
      if ftype == TType.STOP:
28841 
        break
28842 
      if fid == 0:
28843 
        if ftype == TType.STRING:
28844 
          self.success = iprot.readString();
28845 
        else:
28846 
          iprot.skip(ftype)
28847 
      else:
28848 
        iprot.skip(ftype)
28849 
      iprot.readFieldEnd()
28850 
    iprot.readStructEnd()
28851 
 
28852 
  def write(self, oprot):
28853 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28854 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28855 
      return
28856 
    oprot.writeStructBegin('validateRecharge_result')
28857 
    if self.success is not None:
28858 
      oprot.writeFieldBegin('success', TType.STRING, 0)
28859 
      oprot.writeString(self.success)
28860 
      oprot.writeFieldEnd()
28861 
    oprot.writeFieldStop()
28862 
    oprot.writeStructEnd()
28863 
 
28864 
  def validate(self):
28865 
    return
28866 
 
28867 
 
28868 
  def __repr__(self):
28869 
    L = ['%s=%r' % (key, value)
28870 
      for key, value in self.__dict__.iteritems()]
28871 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28872 
 
28873 
  def __eq__(self, other):
28874 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28875 
 
28876 
  def __ne__(self, other):
28877 
    return not (self == other)
28878 
 
6094 rajveer 28879 
class getRechargeOrdersForDevice_args:
28880 
  """
28881 
  Attributes:
28882 
   - deviceNumber
28883 
  """
28884 
 
28885 
  thrift_spec = (
28886 
    None, # 0
28887 
    (1, TType.STRING, 'deviceNumber', None, None, ), # 1
28888 
  )
28889 
 
28890 
  def __init__(self, deviceNumber=None,):
28891 
    self.deviceNumber = deviceNumber
28892 
 
28893 
  def read(self, iprot):
28894 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28895 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28896 
      return
28897 
    iprot.readStructBegin()
28898 
    while True:
28899 
      (fname, ftype, fid) = iprot.readFieldBegin()
28900 
      if ftype == TType.STOP:
28901 
        break
28902 
      if fid == 1:
28903 
        if ftype == TType.STRING:
28904 
          self.deviceNumber = iprot.readString();
28905 
        else:
28906 
          iprot.skip(ftype)
28907 
      else:
28908 
        iprot.skip(ftype)
28909 
      iprot.readFieldEnd()
28910 
    iprot.readStructEnd()
28911 
 
28912 
  def write(self, oprot):
28913 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28914 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28915 
      return
28916 
    oprot.writeStructBegin('getRechargeOrdersForDevice_args')
28917 
    if self.deviceNumber is not None:
28918 
      oprot.writeFieldBegin('deviceNumber', TType.STRING, 1)
28919 
      oprot.writeString(self.deviceNumber)
28920 
      oprot.writeFieldEnd()
28921 
    oprot.writeFieldStop()
28922 
    oprot.writeStructEnd()
28923 
 
28924 
  def validate(self):
28925 
    return
28926 
 
28927 
 
28928 
  def __repr__(self):
28929 
    L = ['%s=%r' % (key, value)
28930 
      for key, value in self.__dict__.iteritems()]
28931 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28932 
 
28933 
  def __eq__(self, other):
28934 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28935 
 
28936 
  def __ne__(self, other):
28937 
    return not (self == other)
28938 
 
28939 
class getRechargeOrdersForDevice_result:
28940 
  """
28941 
  Attributes:
28942 
   - success
28943 
  """
28944 
 
28945 
  thrift_spec = (
28946 
    (0, TType.LIST, 'success', (TType.STRUCT,(RechargeOrder, RechargeOrder.thrift_spec)), None, ), # 0
28947 
  )
28948 
 
28949 
  def __init__(self, success=None,):
28950 
    self.success = success
28951 
 
28952 
  def read(self, iprot):
28953 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28954 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28955 
      return
28956 
    iprot.readStructBegin()
28957 
    while True:
28958 
      (fname, ftype, fid) = iprot.readFieldBegin()
28959 
      if ftype == TType.STOP:
28960 
        break
28961 
      if fid == 0:
28962 
        if ftype == TType.LIST:
28963 
          self.success = []
6188 rajveer 28964 
          (_etype682, _size679) = iprot.readListBegin()
28965 
          for _i683 in xrange(_size679):
28966 
            _elem684 = RechargeOrder()
28967 
            _elem684.read(iprot)
28968 
            self.success.append(_elem684)
6094 rajveer 28969 
          iprot.readListEnd()
28970 
        else:
28971 
          iprot.skip(ftype)
28972 
      else:
28973 
        iprot.skip(ftype)
28974 
      iprot.readFieldEnd()
28975 
    iprot.readStructEnd()
28976 
 
28977 
  def write(self, oprot):
28978 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28979 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28980 
      return
28981 
    oprot.writeStructBegin('getRechargeOrdersForDevice_result')
28982 
    if self.success is not None:
28983 
      oprot.writeFieldBegin('success', TType.LIST, 0)
28984 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 28985 
      for iter685 in self.success:
28986 
        iter685.write(oprot)
6094 rajveer 28987 
      oprot.writeListEnd()
28988 
      oprot.writeFieldEnd()
28989 
    oprot.writeFieldStop()
28990 
    oprot.writeStructEnd()
28991 
 
28992 
  def validate(self):
28993 
    return
28994 
 
28995 
 
28996 
  def __repr__(self):
28997 
    L = ['%s=%r' % (key, value)
28998 
      for key, value in self.__dict__.iteritems()]
28999 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
29000 
 
29001 
  def __eq__(self, other):
29002 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
29003 
 
29004 
  def __ne__(self, other):
29005 
    return not (self == other)
29006 
 
29007 
class addAmountToWallet_args:
29008 
  """
29009 
  Attributes:
29010 
   - userId
29011 
   - orderId
29012 
   - amount
29013 
  """
29014 
 
29015 
  thrift_spec = (
29016 
    None, # 0
29017 
    (1, TType.I64, 'userId', None, None, ), # 1
29018 
    (2, TType.I64, 'orderId', None, None, ), # 2
29019 
    (3, TType.I64, 'amount', None, None, ), # 3
29020 
  )
29021 
 
29022 
  def __init__(self, userId=None, orderId=None, amount=None,):
29023 
    self.userId = userId
29024 
    self.orderId = orderId
29025 
    self.amount = amount
29026 
 
29027 
  def read(self, iprot):
29028 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
29029 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
29030 
      return
29031 
    iprot.readStructBegin()
29032 
    while True:
29033 
      (fname, ftype, fid) = iprot.readFieldBegin()
29034 
      if ftype == TType.STOP:
29035 
        break
29036 
      if fid == 1:
29037 
        if ftype == TType.I64:
29038 
          self.userId = iprot.readI64();
29039 
        else:
29040 
          iprot.skip(ftype)
29041 
      elif fid == 2:
29042 
        if ftype == TType.I64:
29043 
          self.orderId = iprot.readI64();
29044 
        else:
29045 
          iprot.skip(ftype)
29046 
      elif fid == 3:
29047 
        if ftype == TType.I64:
29048 
          self.amount = iprot.readI64();
29049 
        else:
29050 
          iprot.skip(ftype)
29051 
      else:
29052 
        iprot.skip(ftype)
29053 
      iprot.readFieldEnd()
29054 
    iprot.readStructEnd()
29055 
 
29056 
  def write(self, oprot):
29057 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
29058 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
29059 
      return
29060 
    oprot.writeStructBegin('addAmountToWallet_args')
29061 
    if self.userId is not None:
29062 
      oprot.writeFieldBegin('userId', TType.I64, 1)
29063 
      oprot.writeI64(self.userId)
29064 
      oprot.writeFieldEnd()
29065 
    if self.orderId is not None:
29066 
      oprot.writeFieldBegin('orderId', TType.I64, 2)
29067 
      oprot.writeI64(self.orderId)
29068 
      oprot.writeFieldEnd()
29069 
    if self.amount is not None:
29070 
      oprot.writeFieldBegin('amount', TType.I64, 3)
29071 
      oprot.writeI64(self.amount)
29072 
      oprot.writeFieldEnd()
29073 
    oprot.writeFieldStop()
29074 
    oprot.writeStructEnd()
29075 
 
29076 
  def validate(self):
29077 
    return
29078 
 
29079 
 
29080 
  def __repr__(self):
29081 
    L = ['%s=%r' % (key, value)
29082 
      for key, value in self.__dict__.iteritems()]
29083 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
29084 
 
29085 
  def __eq__(self, other):
29086 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
29087 
 
29088 
  def __ne__(self, other):
29089 
    return not (self == other)
29090 
 
29091 
class addAmountToWallet_result:
29092 
 
29093 
  thrift_spec = (
29094 
  )
29095 
 
29096 
  def read(self, iprot):
29097 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
29098 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
29099 
      return
29100 
    iprot.readStructBegin()
29101 
    while True:
29102 
      (fname, ftype, fid) = iprot.readFieldBegin()
29103 
      if ftype == TType.STOP:
29104 
        break
29105 
      else:
29106 
        iprot.skip(ftype)
29107 
      iprot.readFieldEnd()
29108 
    iprot.readStructEnd()
29109 
 
29110 
  def write(self, oprot):
29111 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
29112 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
29113 
      return
29114 
    oprot.writeStructBegin('addAmountToWallet_result')
29115 
    oprot.writeFieldStop()
29116 
    oprot.writeStructEnd()
29117 
 
29118 
  def validate(self):
29119 
    return
29120 
 
29121 
 
29122 
  def __repr__(self):
29123 
    L = ['%s=%r' % (key, value)
29124 
      for key, value in self.__dict__.iteritems()]
29125 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
29126 
 
29127 
  def __eq__(self, other):
29128 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
29129 
 
29130 
  def __ne__(self, other):
29131 
    return not (self == other)
6154 rajveer 29132 
 
6188 rajveer 29133 
class getRechargeStatistics_args:
29134 
 
29135 
  thrift_spec = (
29136 
  )
29137 
 
29138 
  def read(self, iprot):
29139 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
29140 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
29141 
      return
29142 
    iprot.readStructBegin()
29143 
    while True:
29144 
      (fname, ftype, fid) = iprot.readFieldBegin()
29145 
      if ftype == TType.STOP:
29146 
        break
29147 
      else:
29148 
        iprot.skip(ftype)
29149 
      iprot.readFieldEnd()
29150 
    iprot.readStructEnd()
29151 
 
29152 
  def write(self, oprot):
29153 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
29154 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
29155 
      return
29156 
    oprot.writeStructBegin('getRechargeStatistics_args')
29157 
    oprot.writeFieldStop()
29158 
    oprot.writeStructEnd()
29159 
 
29160 
  def validate(self):
29161 
    return
29162 
 
29163 
 
29164 
  def __repr__(self):
29165 
    L = ['%s=%r' % (key, value)
29166 
      for key, value in self.__dict__.iteritems()]
29167 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
29168 
 
29169 
  def __eq__(self, other):
29170 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
29171 
 
29172 
  def __ne__(self, other):
29173 
    return not (self == other)
29174 
 
29175 
class getRechargeStatistics_result:
29176 
  """
29177 
  Attributes:
29178 
   - success
29179 
  """
29180 
 
29181 
  thrift_spec = (
29182 
    (0, TType.STRUCT, 'success', (RechargeStatistics, RechargeStatistics.thrift_spec), None, ), # 0
29183 
  )
29184 
 
29185 
  def __init__(self, success=None,):
29186 
    self.success = success
29187 
 
29188 
  def read(self, iprot):
29189 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
29190 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
29191 
      return
29192 
    iprot.readStructBegin()
29193 
    while True:
29194 
      (fname, ftype, fid) = iprot.readFieldBegin()
29195 
      if ftype == TType.STOP:
29196 
        break
29197 
      if fid == 0:
29198 
        if ftype == TType.STRUCT:
29199 
          self.success = RechargeStatistics()
29200 
          self.success.read(iprot)
29201 
        else:
29202 
          iprot.skip(ftype)
29203 
      else:
29204 
        iprot.skip(ftype)
29205 
      iprot.readFieldEnd()
29206 
    iprot.readStructEnd()
29207 
 
29208 
  def write(self, oprot):
29209 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
29210 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
29211 
      return
29212 
    oprot.writeStructBegin('getRechargeStatistics_result')
29213 
    if self.success is not None:
29214 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
29215 
      self.success.write(oprot)
29216 
      oprot.writeFieldEnd()
29217 
    oprot.writeFieldStop()
29218 
    oprot.writeStructEnd()
29219 
 
29220 
  def validate(self):
29221 
    return
29222 
 
29223 
 
29224 
  def __repr__(self):
29225 
    L = ['%s=%r' % (key, value)
29226 
      for key, value in self.__dict__.iteritems()]
29227 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
29228 
 
29229 
  def __eq__(self, other):
29230 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
29231 
 
29232 
  def __ne__(self, other):
29233 
    return not (self == other)
29234 
 
6154 rajveer 29235 
class getRechargeOrdersForStatus_args:
29236 
  """
29237 
  Attributes:
29238 
   - status
29239 
  """
29240 
 
29241 
  thrift_spec = (
29242 
    None, # 0
29243 
    (1, TType.I64, 'status', None, None, ), # 1
29244 
  )
29245 
 
29246 
  def __init__(self, status=None,):
29247 
    self.status = status
29248 
 
29249 
  def read(self, iprot):
29250 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
29251 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
29252 
      return
29253 
    iprot.readStructBegin()
29254 
    while True:
29255 
      (fname, ftype, fid) = iprot.readFieldBegin()
29256 
      if ftype == TType.STOP:
29257 
        break
29258 
      if fid == 1:
29259 
        if ftype == TType.I64:
29260 
          self.status = iprot.readI64();
29261 
        else:
29262 
          iprot.skip(ftype)
29263 
      else:
29264 
        iprot.skip(ftype)
29265 
      iprot.readFieldEnd()
29266 
    iprot.readStructEnd()
29267 
 
29268 
  def write(self, oprot):
29269 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
29270 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
29271 
      return
29272 
    oprot.writeStructBegin('getRechargeOrdersForStatus_args')
29273 
    if self.status is not None:
29274 
      oprot.writeFieldBegin('status', TType.I64, 1)
29275 
      oprot.writeI64(self.status)
29276 
      oprot.writeFieldEnd()
29277 
    oprot.writeFieldStop()
29278 
    oprot.writeStructEnd()
29279 
 
29280 
  def validate(self):
29281 
    return
29282 
 
29283 
 
29284 
  def __repr__(self):
29285 
    L = ['%s=%r' % (key, value)
29286 
      for key, value in self.__dict__.iteritems()]
29287 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
29288 
 
29289 
  def __eq__(self, other):
29290 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
29291 
 
29292 
  def __ne__(self, other):
29293 
    return not (self == other)
29294 
 
29295 
class getRechargeOrdersForStatus_result:
29296 
  """
29297 
  Attributes:
29298 
   - success
29299 
  """
29300 
 
29301 
  thrift_spec = (
29302 
    (0, TType.LIST, 'success', (TType.STRUCT,(RechargeOrder, RechargeOrder.thrift_spec)), None, ), # 0
29303 
  )
29304 
 
29305 
  def __init__(self, success=None,):
29306 
    self.success = success
29307 
 
29308 
  def read(self, iprot):
29309 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
29310 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
29311 
      return
29312 
    iprot.readStructBegin()
29313 
    while True:
29314 
      (fname, ftype, fid) = iprot.readFieldBegin()
29315 
      if ftype == TType.STOP:
29316 
        break
29317 
      if fid == 0:
29318 
        if ftype == TType.LIST:
29319 
          self.success = []
6188 rajveer 29320 
          (_etype689, _size686) = iprot.readListBegin()
29321 
          for _i690 in xrange(_size686):
29322 
            _elem691 = RechargeOrder()
29323 
            _elem691.read(iprot)
29324 
            self.success.append(_elem691)
6154 rajveer 29325 
          iprot.readListEnd()
29326 
        else:
29327 
          iprot.skip(ftype)
29328 
      else:
29329 
        iprot.skip(ftype)
29330 
      iprot.readFieldEnd()
29331 
    iprot.readStructEnd()
29332 
 
29333 
  def write(self, oprot):
29334 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
29335 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
29336 
      return
29337 
    oprot.writeStructBegin('getRechargeOrdersForStatus_result')
29338 
    if self.success is not None:
29339 
      oprot.writeFieldBegin('success', TType.LIST, 0)
29340 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 29341 
      for iter692 in self.success:
29342 
        iter692.write(oprot)
6154 rajveer 29343 
      oprot.writeListEnd()
29344 
      oprot.writeFieldEnd()
29345 
    oprot.writeFieldStop()
29346 
    oprot.writeStructEnd()
29347 
 
29348 
  def validate(self):
29349 
    return
29350 
 
29351 
 
29352 
  def __repr__(self):
29353 
    L = ['%s=%r' % (key, value)
29354 
      for key, value in self.__dict__.iteritems()]
29355 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
29356 
 
29357 
  def __eq__(self, other):
29358 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
29359 
 
29360 
  def __ne__(self, other):
29361 
    return not (self == other)
6159 rajveer 29362 
 
29363 
class getPlansForOperator_args:
29364 
  """
29365 
  Attributes:
29366 
   - operatorId
29367 
  """
29368 
 
29369 
  thrift_spec = (
29370 
    None, # 0
29371 
    (1, TType.I64, 'operatorId', None, None, ), # 1
29372 
  )
29373 
 
29374 
  def __init__(self, operatorId=None,):
29375 
    self.operatorId = operatorId
29376 
 
29377 
  def read(self, iprot):
29378 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
29379 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
29380 
      return
29381 
    iprot.readStructBegin()
29382 
    while True:
29383 
      (fname, ftype, fid) = iprot.readFieldBegin()
29384 
      if ftype == TType.STOP:
29385 
        break
29386 
      if fid == 1:
29387 
        if ftype == TType.I64:
29388 
          self.operatorId = iprot.readI64();
29389 
        else:
29390 
          iprot.skip(ftype)
29391 
      else:
29392 
        iprot.skip(ftype)
29393 
      iprot.readFieldEnd()
29394 
    iprot.readStructEnd()
29395 
 
29396 
  def write(self, oprot):
29397 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
29398 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
29399 
      return
29400 
    oprot.writeStructBegin('getPlansForOperator_args')
29401 
    if self.operatorId is not None:
29402 
      oprot.writeFieldBegin('operatorId', TType.I64, 1)
29403 
      oprot.writeI64(self.operatorId)
29404 
      oprot.writeFieldEnd()
29405 
    oprot.writeFieldStop()
29406 
    oprot.writeStructEnd()
29407 
 
29408 
  def validate(self):
29409 
    return
29410 
 
29411 
 
29412 
  def __repr__(self):
29413 
    L = ['%s=%r' % (key, value)
29414 
      for key, value in self.__dict__.iteritems()]
29415 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
29416 
 
29417 
  def __eq__(self, other):
29418 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
29419 
 
29420 
  def __ne__(self, other):
29421 
    return not (self == other)
29422 
 
29423 
class getPlansForOperator_result:
29424 
  """
29425 
  Attributes:
29426 
   - success
29427 
  """
29428 
 
29429 
  thrift_spec = (
29430 
    (0, TType.LIST, 'success', (TType.STRUCT,(RechargePlan, RechargePlan.thrift_spec)), None, ), # 0
29431 
  )
29432 
 
29433 
  def __init__(self, success=None,):
29434 
    self.success = success
29435 
 
29436 
  def read(self, iprot):
29437 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
29438 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
29439 
      return
29440 
    iprot.readStructBegin()
29441 
    while True:
29442 
      (fname, ftype, fid) = iprot.readFieldBegin()
29443 
      if ftype == TType.STOP:
29444 
        break
29445 
      if fid == 0:
29446 
        if ftype == TType.LIST:
29447 
          self.success = []
6188 rajveer 29448 
          (_etype696, _size693) = iprot.readListBegin()
29449 
          for _i697 in xrange(_size693):
29450 
            _elem698 = RechargePlan()
29451 
            _elem698.read(iprot)
29452 
            self.success.append(_elem698)
6159 rajveer 29453 
          iprot.readListEnd()
29454 
        else:
29455 
          iprot.skip(ftype)
29456 
      else:
29457 
        iprot.skip(ftype)
29458 
      iprot.readFieldEnd()
29459 
    iprot.readStructEnd()
29460 
 
29461 
  def write(self, oprot):
29462 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
29463 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
29464 
      return
29465 
    oprot.writeStructBegin('getPlansForOperator_result')
29466 
    if self.success is not None:
29467 
      oprot.writeFieldBegin('success', TType.LIST, 0)
29468 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 29469 
      for iter699 in self.success:
29470 
        iter699.write(oprot)
6159 rajveer 29471 
      oprot.writeListEnd()
29472 
      oprot.writeFieldEnd()
29473 
    oprot.writeFieldStop()
29474 
    oprot.writeStructEnd()
29475 
 
29476 
  def validate(self):
29477 
    return
29478 
 
29479 
 
29480 
  def __repr__(self):
29481 
    L = ['%s=%r' % (key, value)
29482 
      for key, value in self.__dict__.iteritems()]
29483 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
29484 
 
29485 
  def __eq__(self, other):
29486 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
29487 
 
29488 
  def __ne__(self, other):
29489 
    return not (self == other)
6289 anupam.sin 29490 
 
29491 
class getRechargeDenominations_args:
29492 
  """
29493 
  Attributes:
29494 
   - operatorId
6307 anupam.sin 29495 
   - circleCode
6289 anupam.sin 29496 
   - denominationType
29497 
  """
29498 
 
29499 
  thrift_spec = (
29500 
    None, # 0
29501 
    (1, TType.I64, 'operatorId', None, None, ), # 1
6307 anupam.sin 29502 
    (2, TType.STRING, 'circleCode', None, None, ), # 2
6289 anupam.sin 29503 
    (3, TType.I32, 'denominationType', None, None, ), # 3
29504 
  )
29505 
 
6307 anupam.sin 29506 
  def __init__(self, operatorId=None, circleCode=None, denominationType=None,):
6289 anupam.sin 29507 
    self.operatorId = operatorId
6307 anupam.sin 29508 
    self.circleCode = circleCode
6289 anupam.sin 29509 
    self.denominationType = denominationType
29510 
 
29511 
  def read(self, iprot):
29512 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
29513 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
29514 
      return
29515 
    iprot.readStructBegin()
29516 
    while True:
29517 
      (fname, ftype, fid) = iprot.readFieldBegin()
29518 
      if ftype == TType.STOP:
29519 
        break
29520 
      if fid == 1:
29521 
        if ftype == TType.I64:
29522 
          self.operatorId = iprot.readI64();
29523 
        else:
29524 
          iprot.skip(ftype)
29525 
      elif fid == 2:
29526 
        if ftype == TType.STRING:
6307 anupam.sin 29527 
          self.circleCode = iprot.readString();
6289 anupam.sin 29528 
        else:
29529 
          iprot.skip(ftype)
29530 
      elif fid == 3:
29531 
        if ftype == TType.I32:
29532 
          self.denominationType = iprot.readI32();
29533 
        else:
29534 
          iprot.skip(ftype)
29535 
      else:
29536 
        iprot.skip(ftype)
29537 
      iprot.readFieldEnd()
29538 
    iprot.readStructEnd()
29539 
 
29540 
  def write(self, oprot):
29541 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
29542 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
29543 
      return
29544 
    oprot.writeStructBegin('getRechargeDenominations_args')
29545 
    if self.operatorId is not None:
29546 
      oprot.writeFieldBegin('operatorId', TType.I64, 1)
29547 
      oprot.writeI64(self.operatorId)
29548 
      oprot.writeFieldEnd()
6307 anupam.sin 29549 
    if self.circleCode is not None:
29550 
      oprot.writeFieldBegin('circleCode', TType.STRING, 2)
29551 
      oprot.writeString(self.circleCode)
6289 anupam.sin 29552 
      oprot.writeFieldEnd()
29553 
    if self.denominationType is not None:
29554 
      oprot.writeFieldBegin('denominationType', TType.I32, 3)
29555 
      oprot.writeI32(self.denominationType)
29556 
      oprot.writeFieldEnd()
29557 
    oprot.writeFieldStop()
29558 
    oprot.writeStructEnd()
29559 
 
29560 
  def validate(self):
29561 
    return
29562 
 
29563 
 
29564 
  def __repr__(self):
29565 
    L = ['%s=%r' % (key, value)
29566 
      for key, value in self.__dict__.iteritems()]
29567 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
29568 
 
29569 
  def __eq__(self, other):
29570 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
29571 
 
29572 
  def __ne__(self, other):
29573 
    return not (self == other)
29574 
 
29575 
class getRechargeDenominations_result:
29576 
  """
29577 
  Attributes:
29578 
   - success
29579 
   - ex
29580 
  """
29581 
 
29582 
  thrift_spec = (
29583 
    (0, TType.LIST, 'success', (TType.STRUCT,(RechargeDenomination, RechargeDenomination.thrift_spec)), None, ), # 0
29584 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
29585 
  )
29586 
 
29587 
  def __init__(self, success=None, ex=None,):
29588 
    self.success = success
29589 
    self.ex = ex
29590 
 
29591 
  def read(self, iprot):
29592 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
29593 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
29594 
      return
29595 
    iprot.readStructBegin()
29596 
    while True:
29597 
      (fname, ftype, fid) = iprot.readFieldBegin()
29598 
      if ftype == TType.STOP:
29599 
        break
29600 
      if fid == 0:
29601 
        if ftype == TType.LIST:
29602 
          self.success = []
29603 
          (_etype703, _size700) = iprot.readListBegin()
29604 
          for _i704 in xrange(_size700):
29605 
            _elem705 = RechargeDenomination()
29606 
            _elem705.read(iprot)
29607 
            self.success.append(_elem705)
29608 
          iprot.readListEnd()
29609 
        else:
29610 
          iprot.skip(ftype)
29611 
      elif fid == 1:
29612 
        if ftype == TType.STRUCT:
29613 
          self.ex = TransactionServiceException()
29614 
          self.ex.read(iprot)
29615 
        else:
29616 
          iprot.skip(ftype)
29617 
      else:
29618 
        iprot.skip(ftype)
29619 
      iprot.readFieldEnd()
29620 
    iprot.readStructEnd()
29621 
 
29622 
  def write(self, oprot):
29623 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
29624 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
29625 
      return
29626 
    oprot.writeStructBegin('getRechargeDenominations_result')
29627 
    if self.success is not None:
29628 
      oprot.writeFieldBegin('success', TType.LIST, 0)
29629 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
29630 
      for iter706 in self.success:
29631 
        iter706.write(oprot)
29632 
      oprot.writeListEnd()
29633 
      oprot.writeFieldEnd()
29634 
    if self.ex is not None:
29635 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
29636 
      self.ex.write(oprot)
29637 
      oprot.writeFieldEnd()
29638 
    oprot.writeFieldStop()
29639 
    oprot.writeStructEnd()
29640 
 
29641 
  def validate(self):
29642 
    return
29643 
 
29644 
 
29645 
  def __repr__(self):
29646 
    L = ['%s=%r' % (key, value)
29647 
      for key, value in self.__dict__.iteritems()]
29648 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
29649 
 
29650 
  def __eq__(self, other):
29651 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
29652 
 
29653 
  def __ne__(self, other):
29654 
    return not (self == other)
6371 rajveer 29655 
 
29656 
class updateAvailabilityStatus_args:
29657 
  """
29658 
  Attributes:
29659 
   - operatorId
29660 
   - circleId
29661 
   - isAvailable
29662 
  """
29663 
 
29664 
  thrift_spec = (
29665 
    None, # 0
29666 
    (1, TType.I64, 'operatorId', None, None, ), # 1
29667 
    (2, TType.I64, 'circleId', None, None, ), # 2
29668 
    (3, TType.BOOL, 'isAvailable', None, None, ), # 3
29669 
  )
29670 
 
29671 
  def __init__(self, operatorId=None, circleId=None, isAvailable=None,):
29672 
    self.operatorId = operatorId
29673 
    self.circleId = circleId
29674 
    self.isAvailable = isAvailable
29675 
 
29676 
  def read(self, iprot):
29677 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
29678 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
29679 
      return
29680 
    iprot.readStructBegin()
29681 
    while True:
29682 
      (fname, ftype, fid) = iprot.readFieldBegin()
29683 
      if ftype == TType.STOP:
29684 
        break
29685 
      if fid == 1:
29686 
        if ftype == TType.I64:
29687 
          self.operatorId = iprot.readI64();
29688 
        else:
29689 
          iprot.skip(ftype)
29690 
      elif fid == 2:
29691 
        if ftype == TType.I64:
29692 
          self.circleId = iprot.readI64();
29693 
        else:
29694 
          iprot.skip(ftype)
29695 
      elif fid == 3:
29696 
        if ftype == TType.BOOL:
29697 
          self.isAvailable = iprot.readBool();
29698 
        else:
29699 
          iprot.skip(ftype)
29700 
      else:
29701 
        iprot.skip(ftype)
29702 
      iprot.readFieldEnd()
29703 
    iprot.readStructEnd()
29704 
 
29705 
  def write(self, oprot):
29706 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
29707 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
29708 
      return
29709 
    oprot.writeStructBegin('updateAvailabilityStatus_args')
29710 
    if self.operatorId is not None:
29711 
      oprot.writeFieldBegin('operatorId', TType.I64, 1)
29712 
      oprot.writeI64(self.operatorId)
29713 
      oprot.writeFieldEnd()
29714 
    if self.circleId is not None:
29715 
      oprot.writeFieldBegin('circleId', TType.I64, 2)
29716 
      oprot.writeI64(self.circleId)
29717 
      oprot.writeFieldEnd()
29718 
    if self.isAvailable is not None:
29719 
      oprot.writeFieldBegin('isAvailable', TType.BOOL, 3)
29720 
      oprot.writeBool(self.isAvailable)
29721 
      oprot.writeFieldEnd()
29722 
    oprot.writeFieldStop()
29723 
    oprot.writeStructEnd()
29724 
 
29725 
  def validate(self):
29726 
    return
29727 
 
29728 
 
29729 
  def __repr__(self):
29730 
    L = ['%s=%r' % (key, value)
29731 
      for key, value in self.__dict__.iteritems()]
29732 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
29733 
 
29734 
  def __eq__(self, other):
29735 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
29736 
 
29737 
  def __ne__(self, other):
29738 
    return not (self == other)
29739 
 
29740 
class updateAvailabilityStatus_result:
29741 
 
29742 
  thrift_spec = (
29743 
  )
29744 
 
29745 
  def read(self, iprot):
29746 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
29747 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
29748 
      return
29749 
    iprot.readStructBegin()
29750 
    while True:
29751 
      (fname, ftype, fid) = iprot.readFieldBegin()
29752 
      if ftype == TType.STOP:
29753 
        break
29754 
      else:
29755 
        iprot.skip(ftype)
29756 
      iprot.readFieldEnd()
29757 
    iprot.readStructEnd()
29758 
 
29759 
  def write(self, oprot):
29760 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
29761 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
29762 
      return
29763 
    oprot.writeStructBegin('updateAvailabilityStatus_result')
29764 
    oprot.writeFieldStop()
29765 
    oprot.writeStructEnd()
29766 
 
29767 
  def validate(self):
29768 
    return
29769 
 
29770 
 
29771 
  def __repr__(self):
29772 
    L = ['%s=%r' % (key, value)
29773 
      for key, value in self.__dict__.iteritems()]
29774 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
29775 
 
29776 
  def __eq__(self, other):
29777 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
29778 
 
29779 
  def __ne__(self, other):
29780 
    return not (self == other)
6389 rajveer 29781 
 
29782 
class getAvailableEmiSchemes_args:
29783 
 
29784 
  thrift_spec = (
29785 
  )
29786 
 
29787 
  def read(self, iprot):
29788 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
29789 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
29790 
      return
29791 
    iprot.readStructBegin()
29792 
    while True:
29793 
      (fname, ftype, fid) = iprot.readFieldBegin()
29794 
      if ftype == TType.STOP:
29795 
        break
29796 
      else:
29797 
        iprot.skip(ftype)
29798 
      iprot.readFieldEnd()
29799 
    iprot.readStructEnd()
29800 
 
29801 
  def write(self, oprot):
29802 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
29803 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
29804 
      return
29805 
    oprot.writeStructBegin('getAvailableEmiSchemes_args')
29806 
    oprot.writeFieldStop()
29807 
    oprot.writeStructEnd()
29808 
 
29809 
  def validate(self):
29810 
    return
29811 
 
29812 
 
29813 
  def __repr__(self):
29814 
    L = ['%s=%r' % (key, value)
29815 
      for key, value in self.__dict__.iteritems()]
29816 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
29817 
 
29818 
  def __eq__(self, other):
29819 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
29820 
 
29821 
  def __ne__(self, other):
29822 
    return not (self == other)
29823 
 
29824 
class getAvailableEmiSchemes_result:
29825 
  """
29826 
  Attributes:
29827 
   - success
29828 
  """
29829 
 
29830 
  thrift_spec = (
29831 
    (0, TType.LIST, 'success', (TType.STRUCT,(EmiScheme, EmiScheme.thrift_spec)), None, ), # 0
29832 
  )
29833 
 
29834 
  def __init__(self, success=None,):
29835 
    self.success = success
29836 
 
29837 
  def read(self, iprot):
29838 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
29839 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
29840 
      return
29841 
    iprot.readStructBegin()
29842 
    while True:
29843 
      (fname, ftype, fid) = iprot.readFieldBegin()
29844 
      if ftype == TType.STOP:
29845 
        break
29846 
      if fid == 0:
29847 
        if ftype == TType.LIST:
29848 
          self.success = []
29849 
          (_etype710, _size707) = iprot.readListBegin()
29850 
          for _i711 in xrange(_size707):
29851 
            _elem712 = EmiScheme()
29852 
            _elem712.read(iprot)
29853 
            self.success.append(_elem712)
29854 
          iprot.readListEnd()
29855 
        else:
29856 
          iprot.skip(ftype)
29857 
      else:
29858 
        iprot.skip(ftype)
29859 
      iprot.readFieldEnd()
29860 
    iprot.readStructEnd()
29861 
 
29862 
  def write(self, oprot):
29863 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
29864 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
29865 
      return
29866 
    oprot.writeStructBegin('getAvailableEmiSchemes_result')
29867 
    if self.success is not None:
29868 
      oprot.writeFieldBegin('success', TType.LIST, 0)
29869 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
29870 
      for iter713 in self.success:
29871 
        iter713.write(oprot)
29872 
      oprot.writeListEnd()
29873 
      oprot.writeFieldEnd()
29874 
    oprot.writeFieldStop()
29875 
    oprot.writeStructEnd()
29876 
 
29877 
  def validate(self):
29878 
    return
29879 
 
29880 
 
29881 
  def __repr__(self):
29882 
    L = ['%s=%r' % (key, value)
29883 
      for key, value in self.__dict__.iteritems()]
29884 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
29885 
 
29886 
  def __eq__(self, other):
29887 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
29888 
 
29889 
  def __ne__(self, other):
29890 
    return not (self == other)
29891 
 
29892 
class getMiscCharges_args:
29893 
  """
29894 
  Attributes:
29895 
   - transactionId
29896 
  """
29897 
 
29898 
  thrift_spec = (
29899 
    None, # 0
29900 
    (1, TType.I64, 'transactionId', None, None, ), # 1
29901 
  )
29902 
 
29903 
  def __init__(self, transactionId=None,):
29904 
    self.transactionId = transactionId
29905 
 
29906 
  def read(self, iprot):
29907 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
29908 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
29909 
      return
29910 
    iprot.readStructBegin()
29911 
    while True:
29912 
      (fname, ftype, fid) = iprot.readFieldBegin()
29913 
      if ftype == TType.STOP:
29914 
        break
29915 
      if fid == 1:
29916 
        if ftype == TType.I64:
29917 
          self.transactionId = iprot.readI64();
29918 
        else:
29919 
          iprot.skip(ftype)
29920 
      else:
29921 
        iprot.skip(ftype)
29922 
      iprot.readFieldEnd()
29923 
    iprot.readStructEnd()
29924 
 
29925 
  def write(self, oprot):
29926 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
29927 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
29928 
      return
29929 
    oprot.writeStructBegin('getMiscCharges_args')
29930 
    if self.transactionId is not None:
29931 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
29932 
      oprot.writeI64(self.transactionId)
29933 
      oprot.writeFieldEnd()
29934 
    oprot.writeFieldStop()
29935 
    oprot.writeStructEnd()
29936 
 
29937 
  def validate(self):
29938 
    return
29939 
 
29940 
 
29941 
  def __repr__(self):
29942 
    L = ['%s=%r' % (key, value)
29943 
      for key, value in self.__dict__.iteritems()]
29944 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
29945 
 
29946 
  def __eq__(self, other):
29947 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
29948 
 
29949 
  def __ne__(self, other):
29950 
    return not (self == other)
29951 
 
29952 
class getMiscCharges_result:
29953 
  """
29954 
  Attributes:
29955 
   - success
29956 
  """
29957 
 
29958 
  thrift_spec = (
6412 rajveer 29959 
    (0, TType.MAP, 'success', (TType.I64,None,TType.DOUBLE,None), None, ), # 0
6389 rajveer 29960 
  )
29961 
 
29962 
  def __init__(self, success=None,):
29963 
    self.success = success
29964 
 
29965 
  def read(self, iprot):
29966 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
29967 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
29968 
      return
29969 
    iprot.readStructBegin()
29970 
    while True:
29971 
      (fname, ftype, fid) = iprot.readFieldBegin()
29972 
      if ftype == TType.STOP:
29973 
        break
29974 
      if fid == 0:
29975 
        if ftype == TType.MAP:
29976 
          self.success = {}
29977 
          (_ktype715, _vtype716, _size714 ) = iprot.readMapBegin()
29978 
          for _i718 in xrange(_size714):
29979 
            _key719 = iprot.readI64();
6412 rajveer 29980 
            _val720 = iprot.readDouble();
6389 rajveer 29981 
            self.success[_key719] = _val720
29982 
          iprot.readMapEnd()
29983 
        else:
29984 
          iprot.skip(ftype)
29985 
      else:
29986 
        iprot.skip(ftype)
29987 
      iprot.readFieldEnd()
29988 
    iprot.readStructEnd()
29989 
 
29990 
  def write(self, oprot):
29991 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
29992 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
29993 
      return
29994 
    oprot.writeStructBegin('getMiscCharges_result')
29995 
    if self.success is not None:
29996 
      oprot.writeFieldBegin('success', TType.MAP, 0)
6412 rajveer 29997 
      oprot.writeMapBegin(TType.I64, TType.DOUBLE, len(self.success))
6389 rajveer 29998 
      for kiter721,viter722 in self.success.items():
29999 
        oprot.writeI64(kiter721)
6412 rajveer 30000 
        oprot.writeDouble(viter722)
6389 rajveer 30001 
      oprot.writeMapEnd()
30002 
      oprot.writeFieldEnd()
30003 
    oprot.writeFieldStop()
30004 
    oprot.writeStructEnd()
30005 
 
30006 
  def validate(self):
30007 
    return
30008 
 
30009 
 
30010 
  def __repr__(self):
30011 
    L = ['%s=%r' % (key, value)
30012 
      for key, value in self.__dict__.iteritems()]
30013 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
30014 
 
30015 
  def __eq__(self, other):
30016 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
30017 
 
30018 
  def __ne__(self, other):
30019 
    return not (self == other)
6507 anupam.sin 30020 
 
30021 
class refundRechargeOrder_args:
30022 
  """
30023 
  Attributes:
30024 
   - rechargeOrderId
30025 
  """
30026 
 
30027 
  thrift_spec = (
30028 
    None, # 0
30029 
    (1, TType.I64, 'rechargeOrderId', None, None, ), # 1
30030 
  )
30031 
 
30032 
  def __init__(self, rechargeOrderId=None,):
30033 
    self.rechargeOrderId = rechargeOrderId
30034 
 
30035 
  def read(self, iprot):
30036 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
30037 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
30038 
      return
30039 
    iprot.readStructBegin()
30040 
    while True:
30041 
      (fname, ftype, fid) = iprot.readFieldBegin()
30042 
      if ftype == TType.STOP:
30043 
        break
30044 
      if fid == 1:
30045 
        if ftype == TType.I64:
30046 
          self.rechargeOrderId = iprot.readI64();
30047 
        else:
30048 
          iprot.skip(ftype)
30049 
      else:
30050 
        iprot.skip(ftype)
30051 
      iprot.readFieldEnd()
30052 
    iprot.readStructEnd()
30053 
 
30054 
  def write(self, oprot):
30055 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
30056 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
30057 
      return
30058 
    oprot.writeStructBegin('refundRechargeOrder_args')
30059 
    if self.rechargeOrderId is not None:
30060 
      oprot.writeFieldBegin('rechargeOrderId', TType.I64, 1)
30061 
      oprot.writeI64(self.rechargeOrderId)
30062 
      oprot.writeFieldEnd()
30063 
    oprot.writeFieldStop()
30064 
    oprot.writeStructEnd()
30065 
 
30066 
  def validate(self):
30067 
    return
30068 
 
30069 
 
30070 
  def __repr__(self):
30071 
    L = ['%s=%r' % (key, value)
30072 
      for key, value in self.__dict__.iteritems()]
30073 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
30074 
 
30075 
  def __eq__(self, other):
30076 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
30077 
 
30078 
  def __ne__(self, other):
30079 
    return not (self == other)
30080 
 
30081 
class refundRechargeOrder_result:
30082 
  """
30083 
  Attributes:
30084 
   - success
30085 
   - ex
30086 
  """
30087 
 
30088 
  thrift_spec = (
30089 
    (0, TType.BOOL, 'success', None, None, ), # 0
30090 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
30091 
  )
30092 
 
30093 
  def __init__(self, success=None, ex=None,):
30094 
    self.success = success
30095 
    self.ex = ex
30096 
 
30097 
  def read(self, iprot):
30098 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
30099 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
30100 
      return
30101 
    iprot.readStructBegin()
30102 
    while True:
30103 
      (fname, ftype, fid) = iprot.readFieldBegin()
30104 
      if ftype == TType.STOP:
30105 
        break
30106 
      if fid == 0:
30107 
        if ftype == TType.BOOL:
30108 
          self.success = iprot.readBool();
30109 
        else:
30110 
          iprot.skip(ftype)
30111 
      elif fid == 1:
30112 
        if ftype == TType.STRUCT:
30113 
          self.ex = TransactionServiceException()
30114 
          self.ex.read(iprot)
30115 
        else:
30116 
          iprot.skip(ftype)
30117 
      else:
30118 
        iprot.skip(ftype)
30119 
      iprot.readFieldEnd()
30120 
    iprot.readStructEnd()
30121 
 
30122 
  def write(self, oprot):
30123 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
30124 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
30125 
      return
30126 
    oprot.writeStructBegin('refundRechargeOrder_result')
30127 
    if self.success is not None:
30128 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
30129 
      oprot.writeBool(self.success)
30130 
      oprot.writeFieldEnd()
30131 
    if self.ex is not None:
30132 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
30133 
      self.ex.write(oprot)
30134 
      oprot.writeFieldEnd()
30135 
    oprot.writeFieldStop()
30136 
    oprot.writeStructEnd()
30137 
 
30138 
  def validate(self):
30139 
    return
30140 
 
30141 
 
30142 
  def __repr__(self):
30143 
    L = ['%s=%r' % (key, value)
30144 
      for key, value in self.__dict__.iteritems()]
30145 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
30146 
 
30147 
  def __eq__(self, other):
30148 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
30149 
 
30150 
  def __ne__(self, other):
30151 
    return not (self == other)
6821 amar.kumar 30152 
 
30153 
class getPhysicalOrders_args:
30154 
  """
30155 
  Attributes:
30156 
   - fromDate
30157 
   - toDate
30158 
  """
30159 
 
30160 
  thrift_spec = (
30161 
    None, # 0
30162 
    (1, TType.I64, 'fromDate', None, None, ), # 1
30163 
    (2, TType.I64, 'toDate', None, None, ), # 2
30164 
  )
30165 
 
30166 
  def __init__(self, fromDate=None, toDate=None,):
30167 
    self.fromDate = fromDate
30168 
    self.toDate = toDate
30169 
 
30170 
  def read(self, iprot):
30171 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
30172 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
30173 
      return
30174 
    iprot.readStructBegin()
30175 
    while True:
30176 
      (fname, ftype, fid) = iprot.readFieldBegin()
30177 
      if ftype == TType.STOP:
30178 
        break
30179 
      if fid == 1:
30180 
        if ftype == TType.I64:
30181 
          self.fromDate = iprot.readI64();
30182 
        else:
30183 
          iprot.skip(ftype)
30184 
      elif fid == 2:
30185 
        if ftype == TType.I64:
30186 
          self.toDate = iprot.readI64();
30187 
        else:
30188 
          iprot.skip(ftype)
30189 
      else:
30190 
        iprot.skip(ftype)
30191 
      iprot.readFieldEnd()
30192 
    iprot.readStructEnd()
30193 
 
30194 
  def write(self, oprot):
30195 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
30196 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
30197 
      return
30198 
    oprot.writeStructBegin('getPhysicalOrders_args')
30199 
    if self.fromDate is not None:
30200 
      oprot.writeFieldBegin('fromDate', TType.I64, 1)
30201 
      oprot.writeI64(self.fromDate)
30202 
      oprot.writeFieldEnd()
30203 
    if self.toDate is not None:
30204 
      oprot.writeFieldBegin('toDate', TType.I64, 2)
30205 
      oprot.writeI64(self.toDate)
30206 
      oprot.writeFieldEnd()
30207 
    oprot.writeFieldStop()
30208 
    oprot.writeStructEnd()
30209 
 
30210 
  def validate(self):
30211 
    return
30212 
 
30213 
 
30214 
  def __repr__(self):
30215 
    L = ['%s=%r' % (key, value)
30216 
      for key, value in self.__dict__.iteritems()]
30217 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
30218 
 
30219 
  def __eq__(self, other):
30220 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
30221 
 
30222 
  def __ne__(self, other):
30223 
    return not (self == other)
30224 
 
30225 
class getPhysicalOrders_result:
30226 
  """
30227 
  Attributes:
30228 
   - success
30229 
  """
30230 
 
30231 
  thrift_spec = (
30232 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
30233 
  )
30234 
 
30235 
  def __init__(self, success=None,):
30236 
    self.success = success
30237 
 
30238 
  def read(self, iprot):
30239 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
30240 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
30241 
      return
30242 
    iprot.readStructBegin()
30243 
    while True:
30244 
      (fname, ftype, fid) = iprot.readFieldBegin()
30245 
      if ftype == TType.STOP:
30246 
        break
30247 
      if fid == 0:
30248 
        if ftype == TType.LIST:
30249 
          self.success = []
30250 
          (_etype726, _size723) = iprot.readListBegin()
30251 
          for _i727 in xrange(_size723):
30252 
            _elem728 = Order()
30253 
            _elem728.read(iprot)
30254 
            self.success.append(_elem728)
30255 
          iprot.readListEnd()
30256 
        else:
30257 
          iprot.skip(ftype)
30258 
      else:
30259 
        iprot.skip(ftype)
30260 
      iprot.readFieldEnd()
30261 
    iprot.readStructEnd()
30262 
 
30263 
  def write(self, oprot):
30264 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
30265 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
30266 
      return
30267 
    oprot.writeStructBegin('getPhysicalOrders_result')
30268 
    if self.success is not None:
30269 
      oprot.writeFieldBegin('success', TType.LIST, 0)
30270 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
30271 
      for iter729 in self.success:
30272 
        iter729.write(oprot)
30273 
      oprot.writeListEnd()
30274 
      oprot.writeFieldEnd()
30275 
    oprot.writeFieldStop()
30276 
    oprot.writeStructEnd()
30277 
 
30278 
  def validate(self):
30279 
    return
30280 
 
30281 
 
30282 
  def __repr__(self):
30283 
    L = ['%s=%r' % (key, value)
30284 
      for key, value in self.__dict__.iteritems()]
30285 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
30286 
 
30287 
  def __eq__(self, other):
30288 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
30289 
 
30290 
  def __ne__(self, other):
30291 
    return not (self == other)
6906 rajveer 30292 
 
30293 
class getDocument_args:
30294 
  """
30295 
  Attributes:
30296 
   - docType
30297 
   - docSource
30298 
  """
30299 
 
30300 
  thrift_spec = (
30301 
    None, # 0
30302 
    (1, TType.I64, 'docType', None, None, ), # 1
30303 
    (2, TType.I64, 'docSource', None, None, ), # 2
30304 
  )
30305 
 
30306 
  def __init__(self, docType=None, docSource=None,):
30307 
    self.docType = docType
30308 
    self.docSource = docSource
30309 
 
30310 
  def read(self, iprot):
30311 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
30312 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
30313 
      return
30314 
    iprot.readStructBegin()
30315 
    while True:
30316 
      (fname, ftype, fid) = iprot.readFieldBegin()
30317 
      if ftype == TType.STOP:
30318 
        break
30319 
      if fid == 1:
30320 
        if ftype == TType.I64:
30321 
          self.docType = iprot.readI64();
30322 
        else:
30323 
          iprot.skip(ftype)
30324 
      elif fid == 2:
30325 
        if ftype == TType.I64:
30326 
          self.docSource = iprot.readI64();
30327 
        else:
30328 
          iprot.skip(ftype)
30329 
      else:
30330 
        iprot.skip(ftype)
30331 
      iprot.readFieldEnd()
30332 
    iprot.readStructEnd()
30333 
 
30334 
  def write(self, oprot):
30335 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
30336 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
30337 
      return
30338 
    oprot.writeStructBegin('getDocument_args')
30339 
    if self.docType is not None:
30340 
      oprot.writeFieldBegin('docType', TType.I64, 1)
30341 
      oprot.writeI64(self.docType)
30342 
      oprot.writeFieldEnd()
30343 
    if self.docSource is not None:
30344 
      oprot.writeFieldBegin('docSource', TType.I64, 2)
30345 
      oprot.writeI64(self.docSource)
30346 
      oprot.writeFieldEnd()
30347 
    oprot.writeFieldStop()
30348 
    oprot.writeStructEnd()
30349 
 
30350 
  def validate(self):
30351 
    return
30352 
 
30353 
 
30354 
  def __repr__(self):
30355 
    L = ['%s=%r' % (key, value)
30356 
      for key, value in self.__dict__.iteritems()]
30357 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
30358 
 
30359 
  def __eq__(self, other):
30360 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
30361 
 
30362 
  def __ne__(self, other):
30363 
    return not (self == other)
30364 
 
30365 
class getDocument_result:
30366 
  """
30367 
  Attributes:
30368 
   - success
30369 
  """
30370 
 
30371 
  thrift_spec = (
30372 
    (0, TType.STRING, 'success', None, None, ), # 0
30373 
  )
30374 
 
30375 
  def __init__(self, success=None,):
30376 
    self.success = success
30377 
 
30378 
  def read(self, iprot):
30379 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
30380 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
30381 
      return
30382 
    iprot.readStructBegin()
30383 
    while True:
30384 
      (fname, ftype, fid) = iprot.readFieldBegin()
30385 
      if ftype == TType.STOP:
30386 
        break
30387 
      if fid == 0:
30388 
        if ftype == TType.STRING:
30389 
          self.success = iprot.readString();
30390 
        else:
30391 
          iprot.skip(ftype)
30392 
      else:
30393 
        iprot.skip(ftype)
30394 
      iprot.readFieldEnd()
30395 
    iprot.readStructEnd()
30396 
 
30397 
  def write(self, oprot):
30398 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
30399 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
30400 
      return
30401 
    oprot.writeStructBegin('getDocument_result')
30402 
    if self.success is not None:
30403 
      oprot.writeFieldBegin('success', TType.STRING, 0)
30404 
      oprot.writeString(self.success)
30405 
      oprot.writeFieldEnd()
30406 
    oprot.writeFieldStop()
30407 
    oprot.writeStructEnd()
30408 
 
30409 
  def validate(self):
30410 
    return
30411 
 
30412 
 
30413 
  def __repr__(self):
30414 
    L = ['%s=%r' % (key, value)
30415 
      for key, value in self.__dict__.iteritems()]
30416 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
30417 
 
30418 
  def __eq__(self, other):
30419 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
30420 
 
30421 
  def __ne__(self, other):
30422 
    return not (self == other)
6985 anupam.sin 30423 
 
30424 
class changeShippingAddress_args:
30425 
  """
30426 
  Attributes:
30427 
   - orderId
30428 
   - line1
30429 
   - line2
30430 
   - city
30431 
   - state
30432 
   - pin
30433 
  """
30434 
 
30435 
  thrift_spec = (
30436 
    None, # 0
30437 
    (1, TType.I64, 'orderId', None, None, ), # 1
30438 
    (2, TType.STRING, 'line1', None, None, ), # 2
30439 
    (3, TType.STRING, 'line2', None, None, ), # 3
30440 
    (4, TType.STRING, 'city', None, None, ), # 4
30441 
    (5, TType.STRING, 'state', None, None, ), # 5
30442 
    (6, TType.STRING, 'pin', None, None, ), # 6
30443 
  )
30444 
 
30445 
  def __init__(self, orderId=None, line1=None, line2=None, city=None, state=None, pin=None,):
30446 
    self.orderId = orderId
30447 
    self.line1 = line1
30448 
    self.line2 = line2
30449 
    self.city = city
30450 
    self.state = state
30451 
    self.pin = pin
30452 
 
30453 
  def read(self, iprot):
30454 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
30455 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
30456 
      return
30457 
    iprot.readStructBegin()
30458 
    while True:
30459 
      (fname, ftype, fid) = iprot.readFieldBegin()
30460 
      if ftype == TType.STOP:
30461 
        break
30462 
      if fid == 1:
30463 
        if ftype == TType.I64:
30464 
          self.orderId = iprot.readI64();
30465 
        else:
30466 
          iprot.skip(ftype)
30467 
      elif fid == 2:
30468 
        if ftype == TType.STRING:
30469 
          self.line1 = iprot.readString();
30470 
        else:
30471 
          iprot.skip(ftype)
30472 
      elif fid == 3:
30473 
        if ftype == TType.STRING:
30474 
          self.line2 = iprot.readString();
30475 
        else:
30476 
          iprot.skip(ftype)
30477 
      elif fid == 4:
30478 
        if ftype == TType.STRING:
30479 
          self.city = iprot.readString();
30480 
        else:
30481 
          iprot.skip(ftype)
30482 
      elif fid == 5:
30483 
        if ftype == TType.STRING:
30484 
          self.state = iprot.readString();
30485 
        else:
30486 
          iprot.skip(ftype)
30487 
      elif fid == 6:
30488 
        if ftype == TType.STRING:
30489 
          self.pin = iprot.readString();
30490 
        else:
30491 
          iprot.skip(ftype)
30492 
      else:
30493 
        iprot.skip(ftype)
30494 
      iprot.readFieldEnd()
30495 
    iprot.readStructEnd()
30496 
 
30497 
  def write(self, oprot):
30498 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
30499 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
30500 
      return
30501 
    oprot.writeStructBegin('changeShippingAddress_args')
30502 
    if self.orderId is not None:
30503 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
30504 
      oprot.writeI64(self.orderId)
30505 
      oprot.writeFieldEnd()
30506 
    if self.line1 is not None:
30507 
      oprot.writeFieldBegin('line1', TType.STRING, 2)
30508 
      oprot.writeString(self.line1)
30509 
      oprot.writeFieldEnd()
30510 
    if self.line2 is not None:
30511 
      oprot.writeFieldBegin('line2', TType.STRING, 3)
30512 
      oprot.writeString(self.line2)
30513 
      oprot.writeFieldEnd()
30514 
    if self.city is not None:
30515 
      oprot.writeFieldBegin('city', TType.STRING, 4)
30516 
      oprot.writeString(self.city)
30517 
      oprot.writeFieldEnd()
30518 
    if self.state is not None:
30519 
      oprot.writeFieldBegin('state', TType.STRING, 5)
30520 
      oprot.writeString(self.state)
30521 
      oprot.writeFieldEnd()
30522 
    if self.pin is not None:
30523 
      oprot.writeFieldBegin('pin', TType.STRING, 6)
30524 
      oprot.writeString(self.pin)
30525 
      oprot.writeFieldEnd()
30526 
    oprot.writeFieldStop()
30527 
    oprot.writeStructEnd()
30528 
 
30529 
  def validate(self):
30530 
    return
30531 
 
30532 
 
30533 
  def __repr__(self):
30534 
    L = ['%s=%r' % (key, value)
30535 
      for key, value in self.__dict__.iteritems()]
30536 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
30537 
 
30538 
  def __eq__(self, other):
30539 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
30540 
 
30541 
  def __ne__(self, other):
30542 
    return not (self == other)
30543 
 
30544 
class changeShippingAddress_result:
30545 
  """
30546 
  Attributes:
30547 
   - success
30548 
  """
30549 
 
30550 
  thrift_spec = (
30551 
    (0, TType.BOOL, 'success', None, None, ), # 0
30552 
  )
30553 
 
30554 
  def __init__(self, success=None,):
30555 
    self.success = success
30556 
 
30557 
  def read(self, iprot):
30558 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
30559 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
30560 
      return
30561 
    iprot.readStructBegin()
30562 
    while True:
30563 
      (fname, ftype, fid) = iprot.readFieldBegin()
30564 
      if ftype == TType.STOP:
30565 
        break
30566 
      if fid == 0:
30567 
        if ftype == TType.BOOL:
30568 
          self.success = iprot.readBool();
30569 
        else:
30570 
          iprot.skip(ftype)
30571 
      else:
30572 
        iprot.skip(ftype)
30573 
      iprot.readFieldEnd()
30574 
    iprot.readStructEnd()
30575 
 
30576 
  def write(self, oprot):
30577 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
30578 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
30579 
      return
30580 
    oprot.writeStructBegin('changeShippingAddress_result')
30581 
    if self.success is not None:
30582 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
30583 
      oprot.writeBool(self.success)
30584 
      oprot.writeFieldEnd()
30585 
    oprot.writeFieldStop()
30586 
    oprot.writeStructEnd()
30587 
 
30588 
  def validate(self):
30589 
    return
30590 
 
30591 
 
30592 
  def __repr__(self):
30593 
    L = ['%s=%r' % (key, value)
30594 
      for key, value in self.__dict__.iteritems()]
30595 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
30596 
 
30597 
  def __eq__(self, other):
30598 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
30599 
 
30600 
  def __ne__(self, other):
30601 
    return not (self == other)
6988 rajveer 30602 
 
30603 
class retrieveInvoice_args:
30604 
  """
30605 
  Attributes:
30606 
   - orderId
7075 rajveer 30607 
   - userId
6988 rajveer 30608 
  """
30609 
 
30610 
  thrift_spec = (
30611 
    None, # 0
30612 
    (1, TType.I64, 'orderId', None, None, ), # 1
7075 rajveer 30613 
    (2, TType.I64, 'userId', None, None, ), # 2
6988 rajveer 30614 
  )
30615 
 
7075 rajveer 30616 
  def __init__(self, orderId=None, userId=None,):
6988 rajveer 30617 
    self.orderId = orderId
7075 rajveer 30618 
    self.userId = userId
6988 rajveer 30619 
 
30620 
  def read(self, iprot):
30621 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
30622 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
30623 
      return
30624 
    iprot.readStructBegin()
30625 
    while True:
30626 
      (fname, ftype, fid) = iprot.readFieldBegin()
30627 
      if ftype == TType.STOP:
30628 
        break
30629 
      if fid == 1:
30630 
        if ftype == TType.I64:
30631 
          self.orderId = iprot.readI64();
30632 
        else:
30633 
          iprot.skip(ftype)
7075 rajveer 30634 
      elif fid == 2:
30635 
        if ftype == TType.I64:
30636 
          self.userId = iprot.readI64();
30637 
        else:
30638 
          iprot.skip(ftype)
6988 rajveer 30639 
      else:
30640 
        iprot.skip(ftype)
30641 
      iprot.readFieldEnd()
30642 
    iprot.readStructEnd()
30643 
 
30644 
  def write(self, oprot):
30645 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
30646 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
30647 
      return
30648 
    oprot.writeStructBegin('retrieveInvoice_args')
30649 
    if self.orderId is not None:
30650 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
30651 
      oprot.writeI64(self.orderId)
30652 
      oprot.writeFieldEnd()
7075 rajveer 30653 
    if self.userId is not None:
30654 
      oprot.writeFieldBegin('userId', TType.I64, 2)
30655 
      oprot.writeI64(self.userId)
30656 
      oprot.writeFieldEnd()
6988 rajveer 30657 
    oprot.writeFieldStop()
30658 
    oprot.writeStructEnd()
30659 
 
30660 
  def validate(self):
30661 
    return
30662 
 
30663 
 
30664 
  def __repr__(self):
30665 
    L = ['%s=%r' % (key, value)
30666 
      for key, value in self.__dict__.iteritems()]
30667 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
30668 
 
30669 
  def __eq__(self, other):
30670 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
30671 
 
30672 
  def __ne__(self, other):
30673 
    return not (self == other)
30674 
 
30675 
class retrieveInvoice_result:
30676 
  """
30677 
  Attributes:
30678 
   - success
30679 
  """
30680 
 
30681 
  thrift_spec = (
30682 
    (0, TType.STRING, 'success', None, None, ), # 0
30683 
  )
30684 
 
30685 
  def __init__(self, success=None,):
30686 
    self.success = success
30687 
 
30688 
  def read(self, iprot):
30689 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
30690 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
30691 
      return
30692 
    iprot.readStructBegin()
30693 
    while True:
30694 
      (fname, ftype, fid) = iprot.readFieldBegin()
30695 
      if ftype == TType.STOP:
30696 
        break
30697 
      if fid == 0:
30698 
        if ftype == TType.STRING:
30699 
          self.success = iprot.readString();
30700 
        else:
30701 
          iprot.skip(ftype)
30702 
      else:
30703 
        iprot.skip(ftype)
30704 
      iprot.readFieldEnd()
30705 
    iprot.readStructEnd()
30706 
 
30707 
  def write(self, oprot):
30708 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
30709 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
30710 
      return
30711 
    oprot.writeStructBegin('retrieveInvoice_result')
30712 
    if self.success is not None:
30713 
      oprot.writeFieldBegin('success', TType.STRING, 0)
30714 
      oprot.writeString(self.success)
30715 
      oprot.writeFieldEnd()
30716 
    oprot.writeFieldStop()
30717 
    oprot.writeStructEnd()
30718 
 
30719 
  def validate(self):
30720 
    return
30721 
 
30722 
 
30723 
  def __repr__(self):
30724 
    L = ['%s=%r' % (key, value)
30725 
      for key, value in self.__dict__.iteritems()]
30726 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
30727 
 
30728 
  def __eq__(self, other):
30729 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
30730 
 
30731 
  def __ne__(self, other):
30732 
    return not (self == other)
7026 rajveer 30733 
 
30734 
class receiveUpdatesForRedExpress_args:
30735 
  """
30736 
  Attributes:
30737 
   - awbNumber
30738 
  """
30739 
 
30740 
  thrift_spec = (
30741 
    None, # 0
30742 
    (1, TType.STRING, 'awbNumber', None, None, ), # 1
30743 
  )
30744 
 
30745 
  def __init__(self, awbNumber=None,):
30746 
    self.awbNumber = awbNumber
30747 
 
30748 
  def read(self, iprot):
30749 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
30750 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
30751 
      return
30752 
    iprot.readStructBegin()
30753 
    while True:
30754 
      (fname, ftype, fid) = iprot.readFieldBegin()
30755 
      if ftype == TType.STOP:
30756 
        break
30757 
      if fid == 1:
30758 
        if ftype == TType.STRING:
30759 
          self.awbNumber = iprot.readString();
30760 
        else:
30761 
          iprot.skip(ftype)
30762 
      else:
30763 
        iprot.skip(ftype)
30764 
      iprot.readFieldEnd()
30765 
    iprot.readStructEnd()
30766 
 
30767 
  def write(self, oprot):
30768 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
30769 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
30770 
      return
30771 
    oprot.writeStructBegin('receiveUpdatesForRedExpress_args')
30772 
    if self.awbNumber is not None:
30773 
      oprot.writeFieldBegin('awbNumber', TType.STRING, 1)
30774 
      oprot.writeString(self.awbNumber)
30775 
      oprot.writeFieldEnd()
30776 
    oprot.writeFieldStop()
30777 
    oprot.writeStructEnd()
30778 
 
30779 
  def validate(self):
30780 
    return
30781 
 
30782 
 
30783 
  def __repr__(self):
30784 
    L = ['%s=%r' % (key, value)
30785 
      for key, value in self.__dict__.iteritems()]
30786 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
30787 
 
30788 
  def __eq__(self, other):
30789 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
30790 
 
30791 
  def __ne__(self, other):
30792 
    return not (self == other)
30793 
 
30794 
class receiveUpdatesForRedExpress_result:
30795 
  """
30796 
  Attributes:
30797 
   - success
30798 
  """
30799 
 
30800 
  thrift_spec = (
30801 
    (0, TType.LIST, 'success', (TType.STRING,None), None, ), # 0
30802 
  )
30803 
 
30804 
  def __init__(self, success=None,):
30805 
    self.success = success
30806 
 
30807 
  def read(self, iprot):
30808 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
30809 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
30810 
      return
30811 
    iprot.readStructBegin()
30812 
    while True:
30813 
      (fname, ftype, fid) = iprot.readFieldBegin()
30814 
      if ftype == TType.STOP:
30815 
        break
30816 
      if fid == 0:
30817 
        if ftype == TType.LIST:
30818 
          self.success = []
30819 
          (_etype733, _size730) = iprot.readListBegin()
30820 
          for _i734 in xrange(_size730):
30821 
            _elem735 = iprot.readString();
30822 
            self.success.append(_elem735)
30823 
          iprot.readListEnd()
30824 
        else:
30825 
          iprot.skip(ftype)
30826 
      else:
30827 
        iprot.skip(ftype)
30828 
      iprot.readFieldEnd()
30829 
    iprot.readStructEnd()
30830 
 
30831 
  def write(self, oprot):
30832 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
30833 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
30834 
      return
30835 
    oprot.writeStructBegin('receiveUpdatesForRedExpress_result')
30836 
    if self.success is not None:
30837 
      oprot.writeFieldBegin('success', TType.LIST, 0)
30838 
      oprot.writeListBegin(TType.STRING, len(self.success))
30839 
      for iter736 in self.success:
30840 
        oprot.writeString(iter736)
30841 
      oprot.writeListEnd()
30842 
      oprot.writeFieldEnd()
30843 
    oprot.writeFieldStop()
30844 
    oprot.writeStructEnd()
30845 
 
30846 
  def validate(self):
30847 
    return
30848 
 
30849 
 
30850 
  def __repr__(self):
30851 
    L = ['%s=%r' % (key, value)
30852 
      for key, value in self.__dict__.iteritems()]
30853 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
30854 
 
30855 
  def __eq__(self, other):
30856 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
30857 
 
30858 
  def __ne__(self, other):
30859 
    return not (self == other)
7073 anupam.sin 30860 
 
30861 
class createRechargeTransaction_args:
30862 
  """
30863 
  Attributes:
30864 
   - thriftRechargeTransaction
30865 
  """
30866 
 
30867 
  thrift_spec = (
30868 
    None, # 0
30869 
    (1, TType.STRUCT, 'thriftRechargeTransaction', (RechargeTransaction, RechargeTransaction.thrift_spec), None, ), # 1
30870 
  )
30871 
 
30872 
  def __init__(self, thriftRechargeTransaction=None,):
30873 
    self.thriftRechargeTransaction = thriftRechargeTransaction
30874 
 
30875 
  def read(self, iprot):
30876 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
30877 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
30878 
      return
30879 
    iprot.readStructBegin()
30880 
    while True:
30881 
      (fname, ftype, fid) = iprot.readFieldBegin()
30882 
      if ftype == TType.STOP:
30883 
        break
30884 
      if fid == 1:
30885 
        if ftype == TType.STRUCT:
30886 
          self.thriftRechargeTransaction = RechargeTransaction()
30887 
          self.thriftRechargeTransaction.read(iprot)
30888 
        else:
30889 
          iprot.skip(ftype)
30890 
      else:
30891 
        iprot.skip(ftype)
30892 
      iprot.readFieldEnd()
30893 
    iprot.readStructEnd()
30894 
 
30895 
  def write(self, oprot):
30896 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
30897 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
30898 
      return
30899 
    oprot.writeStructBegin('createRechargeTransaction_args')
30900 
    if self.thriftRechargeTransaction is not None:
30901 
      oprot.writeFieldBegin('thriftRechargeTransaction', TType.STRUCT, 1)
30902 
      self.thriftRechargeTransaction.write(oprot)
30903 
      oprot.writeFieldEnd()
30904 
    oprot.writeFieldStop()
30905 
    oprot.writeStructEnd()
30906 
 
30907 
  def validate(self):
30908 
    return
30909 
 
30910 
 
30911 
  def __repr__(self):
30912 
    L = ['%s=%r' % (key, value)
30913 
      for key, value in self.__dict__.iteritems()]
30914 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
30915 
 
30916 
  def __eq__(self, other):
30917 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
30918 
 
30919 
  def __ne__(self, other):
30920 
    return not (self == other)
30921 
 
30922 
class createRechargeTransaction_result:
30923 
  """
30924 
  Attributes:
30925 
   - success
30926 
  """
30927 
 
30928 
  thrift_spec = (
30929 
    (0, TType.STRUCT, 'success', (RechargeTransaction, RechargeTransaction.thrift_spec), None, ), # 0
30930 
  )
30931 
 
30932 
  def __init__(self, success=None,):
30933 
    self.success = success
30934 
 
30935 
  def read(self, iprot):
30936 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
30937 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
30938 
      return
30939 
    iprot.readStructBegin()
30940 
    while True:
30941 
      (fname, ftype, fid) = iprot.readFieldBegin()
30942 
      if ftype == TType.STOP:
30943 
        break
30944 
      if fid == 0:
30945 
        if ftype == TType.STRUCT:
30946 
          self.success = RechargeTransaction()
30947 
          self.success.read(iprot)
30948 
        else:
30949 
          iprot.skip(ftype)
30950 
      else:
30951 
        iprot.skip(ftype)
30952 
      iprot.readFieldEnd()
30953 
    iprot.readStructEnd()
30954 
 
30955 
  def write(self, oprot):
30956 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
30957 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
30958 
      return
30959 
    oprot.writeStructBegin('createRechargeTransaction_result')
30960 
    if self.success is not None:
30961 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
30962 
      self.success.write(oprot)
30963 
      oprot.writeFieldEnd()
30964 
    oprot.writeFieldStop()
30965 
    oprot.writeStructEnd()
30966 
 
30967 
  def validate(self):
30968 
    return
30969 
 
30970 
 
30971 
  def __repr__(self):
30972 
    L = ['%s=%r' % (key, value)
30973 
      for key, value in self.__dict__.iteritems()]
30974 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
30975 
 
30976 
  def __eq__(self, other):
30977 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
30978 
 
30979 
  def __ne__(self, other):
30980 
    return not (self == other)
7080 anupam.sin 30981 
 
7085 rajveer 30982 
class getRechargeTransactions_args:
30983 
  """
30984 
  Attributes:
30985 
   - storeId
30986 
  """
30987 
 
30988 
  thrift_spec = (
30989 
    None, # 0
30990 
    (1, TType.I64, 'storeId', None, None, ), # 1
30991 
  )
30992 
 
30993 
  def __init__(self, storeId=None,):
30994 
    self.storeId = storeId
30995 
 
30996 
  def read(self, iprot):
30997 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
30998 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
30999 
      return
31000 
    iprot.readStructBegin()
31001 
    while True:
31002 
      (fname, ftype, fid) = iprot.readFieldBegin()
31003 
      if ftype == TType.STOP:
31004 
        break
31005 
      if fid == 1:
31006 
        if ftype == TType.I64:
31007 
          self.storeId = iprot.readI64();
31008 
        else:
31009 
          iprot.skip(ftype)
31010 
      else:
31011 
        iprot.skip(ftype)
31012 
      iprot.readFieldEnd()
31013 
    iprot.readStructEnd()
31014 
 
31015 
  def write(self, oprot):
31016 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
31017 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
31018 
      return
31019 
    oprot.writeStructBegin('getRechargeTransactions_args')
31020 
    if self.storeId is not None:
31021 
      oprot.writeFieldBegin('storeId', TType.I64, 1)
31022 
      oprot.writeI64(self.storeId)
31023 
      oprot.writeFieldEnd()
31024 
    oprot.writeFieldStop()
31025 
    oprot.writeStructEnd()
31026 
 
31027 
  def validate(self):
31028 
    return
31029 
 
31030 
 
31031 
  def __repr__(self):
31032 
    L = ['%s=%r' % (key, value)
31033 
      for key, value in self.__dict__.iteritems()]
31034 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
31035 
 
31036 
  def __eq__(self, other):
31037 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
31038 
 
31039 
  def __ne__(self, other):
31040 
    return not (self == other)
31041 
 
31042 
class getRechargeTransactions_result:
31043 
  """
31044 
  Attributes:
31045 
   - success
31046 
  """
31047 
 
31048 
  thrift_spec = (
31049 
    (0, TType.LIST, 'success', (TType.STRUCT,(RechargeTransaction, RechargeTransaction.thrift_spec)), None, ), # 0
31050 
  )
31051 
 
31052 
  def __init__(self, success=None,):
31053 
    self.success = success
31054 
 
31055 
  def read(self, iprot):
31056 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
31057 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
31058 
      return
31059 
    iprot.readStructBegin()
31060 
    while True:
31061 
      (fname, ftype, fid) = iprot.readFieldBegin()
31062 
      if ftype == TType.STOP:
31063 
        break
31064 
      if fid == 0:
31065 
        if ftype == TType.LIST:
31066 
          self.success = []
31067 
          (_etype740, _size737) = iprot.readListBegin()
31068 
          for _i741 in xrange(_size737):
31069 
            _elem742 = RechargeTransaction()
31070 
            _elem742.read(iprot)
31071 
            self.success.append(_elem742)
31072 
          iprot.readListEnd()
31073 
        else:
31074 
          iprot.skip(ftype)
31075 
      else:
31076 
        iprot.skip(ftype)
31077 
      iprot.readFieldEnd()
31078 
    iprot.readStructEnd()
31079 
 
31080 
  def write(self, oprot):
31081 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
31082 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
31083 
      return
31084 
    oprot.writeStructBegin('getRechargeTransactions_result')
31085 
    if self.success is not None:
31086 
      oprot.writeFieldBegin('success', TType.LIST, 0)
31087 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
31088 
      for iter743 in self.success:
31089 
        iter743.write(oprot)
31090 
      oprot.writeListEnd()
31091 
      oprot.writeFieldEnd()
31092 
    oprot.writeFieldStop()
31093 
    oprot.writeStructEnd()
31094 
 
31095 
  def validate(self):
31096 
    return
31097 
 
31098 
 
31099 
  def __repr__(self):
31100 
    L = ['%s=%r' % (key, value)
31101 
      for key, value in self.__dict__.iteritems()]
31102 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
31103 
 
31104 
  def __eq__(self, other):
31105 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
31106 
 
31107 
  def __ne__(self, other):
31108 
    return not (self == other)
31109 
 
7151 amit.gupta 31110 
class getRechargeTrans_args:
31111 
  """
31112 
  Attributes:
31113 
   - storeId
31114 
   - startDate
31115 
   - endDate
31116 
   - status
31117 
  """
31118 
 
31119 
  thrift_spec = (
31120 
    None, # 0
31121 
    (1, TType.I64, 'storeId', None, None, ), # 1
31122 
    (2, TType.I64, 'startDate', None, None, ), # 2
31123 
    (3, TType.I64, 'endDate', None, None, ), # 3
31124 
    (4, TType.I32, 'status', None, None, ), # 4
31125 
  )
31126 
 
31127 
  def __init__(self, storeId=None, startDate=None, endDate=None, status=None,):
31128 
    self.storeId = storeId
31129 
    self.startDate = startDate
31130 
    self.endDate = endDate
31131 
    self.status = status
31132 
 
31133 
  def read(self, iprot):
31134 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
31135 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
31136 
      return
31137 
    iprot.readStructBegin()
31138 
    while True:
31139 
      (fname, ftype, fid) = iprot.readFieldBegin()
31140 
      if ftype == TType.STOP:
31141 
        break
31142 
      if fid == 1:
31143 
        if ftype == TType.I64:
31144 
          self.storeId = iprot.readI64();
31145 
        else:
31146 
          iprot.skip(ftype)
31147 
      elif fid == 2:
31148 
        if ftype == TType.I64:
31149 
          self.startDate = iprot.readI64();
31150 
        else:
31151 
          iprot.skip(ftype)
31152 
      elif fid == 3:
31153 
        if ftype == TType.I64:
31154 
          self.endDate = iprot.readI64();
31155 
        else:
31156 
          iprot.skip(ftype)
31157 
      elif fid == 4:
31158 
        if ftype == TType.I32:
31159 
          self.status = iprot.readI32();
31160 
        else:
31161 
          iprot.skip(ftype)
31162 
      else:
31163 
        iprot.skip(ftype)
31164 
      iprot.readFieldEnd()
31165 
    iprot.readStructEnd()
31166 
 
31167 
  def write(self, oprot):
31168 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
31169 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
31170 
      return
31171 
    oprot.writeStructBegin('getRechargeTrans_args')
31172 
    if self.storeId is not None:
31173 
      oprot.writeFieldBegin('storeId', TType.I64, 1)
31174 
      oprot.writeI64(self.storeId)
31175 
      oprot.writeFieldEnd()
31176 
    if self.startDate is not None:
31177 
      oprot.writeFieldBegin('startDate', TType.I64, 2)
31178 
      oprot.writeI64(self.startDate)
31179 
      oprot.writeFieldEnd()
31180 
    if self.endDate is not None:
31181 
      oprot.writeFieldBegin('endDate', TType.I64, 3)
31182 
      oprot.writeI64(self.endDate)
31183 
      oprot.writeFieldEnd()
31184 
    if self.status is not None:
31185 
      oprot.writeFieldBegin('status', TType.I32, 4)
31186 
      oprot.writeI32(self.status)
31187 
      oprot.writeFieldEnd()
31188 
    oprot.writeFieldStop()
31189 
    oprot.writeStructEnd()
31190 
 
31191 
  def validate(self):
31192 
    return
31193 
 
31194 
 
31195 
  def __repr__(self):
31196 
    L = ['%s=%r' % (key, value)
31197 
      for key, value in self.__dict__.iteritems()]
31198 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
31199 
 
31200 
  def __eq__(self, other):
31201 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
31202 
 
31203 
  def __ne__(self, other):
31204 
    return not (self == other)
31205 
 
31206 
class getRechargeTrans_result:
31207 
  """
31208 
  Attributes:
31209 
   - success
31210 
  """
31211 
 
31212 
  thrift_spec = (
31213 
    (0, TType.LIST, 'success', (TType.STRUCT,(RechargeTransaction, RechargeTransaction.thrift_spec)), None, ), # 0
31214 
  )
31215 
 
31216 
  def __init__(self, success=None,):
31217 
    self.success = success
31218 
 
31219 
  def read(self, iprot):
31220 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
31221 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
31222 
      return
31223 
    iprot.readStructBegin()
31224 
    while True:
31225 
      (fname, ftype, fid) = iprot.readFieldBegin()
31226 
      if ftype == TType.STOP:
31227 
        break
31228 
      if fid == 0:
31229 
        if ftype == TType.LIST:
31230 
          self.success = []
31231 
          (_etype747, _size744) = iprot.readListBegin()
31232 
          for _i748 in xrange(_size744):
31233 
            _elem749 = RechargeTransaction()
31234 
            _elem749.read(iprot)
31235 
            self.success.append(_elem749)
31236 
          iprot.readListEnd()
31237 
        else:
31238 
          iprot.skip(ftype)
31239 
      else:
31240 
        iprot.skip(ftype)
31241 
      iprot.readFieldEnd()
31242 
    iprot.readStructEnd()
31243 
 
31244 
  def write(self, oprot):
31245 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
31246 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
31247 
      return
31248 
    oprot.writeStructBegin('getRechargeTrans_result')
31249 
    if self.success is not None:
31250 
      oprot.writeFieldBegin('success', TType.LIST, 0)
31251 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
31252 
      for iter750 in self.success:
31253 
        iter750.write(oprot)
31254 
      oprot.writeListEnd()
31255 
      oprot.writeFieldEnd()
31256 
    oprot.writeFieldStop()
31257 
    oprot.writeStructEnd()
31258 
 
31259 
  def validate(self):
31260 
    return
31261 
 
31262 
 
31263 
  def __repr__(self):
31264 
    L = ['%s=%r' % (key, value)
31265 
      for key, value in self.__dict__.iteritems()]
31266 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
31267 
 
31268 
  def __eq__(self, other):
31269 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
31270 
 
31271 
  def __ne__(self, other):
31272 
    return not (self == other)
31273 
 
7080 anupam.sin 31274 
class getRechargeTransaction_args:
31275 
  """
31276 
  Attributes:
31277 
   - rechargeId
31278 
  """
31279 
 
31280 
  thrift_spec = (
31281 
    None, # 0
31282 
    (1, TType.I64, 'rechargeId', None, None, ), # 1
31283 
  )
31284 
 
31285 
  def __init__(self, rechargeId=None,):
31286 
    self.rechargeId = rechargeId
31287 
 
31288 
  def read(self, iprot):
31289 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
31290 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
31291 
      return
31292 
    iprot.readStructBegin()
31293 
    while True:
31294 
      (fname, ftype, fid) = iprot.readFieldBegin()
31295 
      if ftype == TType.STOP:
31296 
        break
31297 
      if fid == 1:
31298 
        if ftype == TType.I64:
31299 
          self.rechargeId = iprot.readI64();
31300 
        else:
31301 
          iprot.skip(ftype)
31302 
      else:
31303 
        iprot.skip(ftype)
31304 
      iprot.readFieldEnd()
31305 
    iprot.readStructEnd()
31306 
 
31307 
  def write(self, oprot):
31308 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
31309 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
31310 
      return
31311 
    oprot.writeStructBegin('getRechargeTransaction_args')
31312 
    if self.rechargeId is not None:
31313 
      oprot.writeFieldBegin('rechargeId', TType.I64, 1)
31314 
      oprot.writeI64(self.rechargeId)
31315 
      oprot.writeFieldEnd()
31316 
    oprot.writeFieldStop()
31317 
    oprot.writeStructEnd()
31318 
 
31319 
  def validate(self):
31320 
    return
31321 
 
31322 
 
31323 
  def __repr__(self):
31324 
    L = ['%s=%r' % (key, value)
31325 
      for key, value in self.__dict__.iteritems()]
31326 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
31327 
 
31328 
  def __eq__(self, other):
31329 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
31330 
 
31331 
  def __ne__(self, other):
31332 
    return not (self == other)
31333 
 
31334 
class getRechargeTransaction_result:
31335 
  """
31336 
  Attributes:
31337 
   - success
31338 
  """
31339 
 
31340 
  thrift_spec = (
31341 
    (0, TType.STRUCT, 'success', (RechargeTransaction, RechargeTransaction.thrift_spec), None, ), # 0
31342 
  )
31343 
 
31344 
  def __init__(self, success=None,):
31345 
    self.success = success
31346 
 
31347 
  def read(self, iprot):
31348 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
31349 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
31350 
      return
31351 
    iprot.readStructBegin()
31352 
    while True:
31353 
      (fname, ftype, fid) = iprot.readFieldBegin()
31354 
      if ftype == TType.STOP:
31355 
        break
31356 
      if fid == 0:
31357 
        if ftype == TType.STRUCT:
31358 
          self.success = RechargeTransaction()
31359 
          self.success.read(iprot)
31360 
        else:
31361 
          iprot.skip(ftype)
31362 
      else:
31363 
        iprot.skip(ftype)
31364 
      iprot.readFieldEnd()
31365 
    iprot.readStructEnd()
31366 
 
31367 
  def write(self, oprot):
31368 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
31369 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
31370 
      return
31371 
    oprot.writeStructBegin('getRechargeTransaction_result')
31372 
    if self.success is not None:
31373 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
31374 
      self.success.write(oprot)
31375 
      oprot.writeFieldEnd()
31376 
    oprot.writeFieldStop()
31377 
    oprot.writeStructEnd()
31378 
 
31379 
  def validate(self):
31380 
    return
31381 
 
31382 
 
31383 
  def __repr__(self):
31384 
    L = ['%s=%r' % (key, value)
31385 
      for key, value in self.__dict__.iteritems()]
31386 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
31387 
 
31388 
  def __eq__(self, other):
31389 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
31390 
 
31391 
  def __ne__(self, other):
31392 
    return not (self == other)
31393 
 
31394 
class getFRCs_args:
31395 
  """
31396 
  Attributes:
31397 
   - circleId
31398 
   - operatorId
31399 
  """
31400 
 
31401 
  thrift_spec = (
31402 
    None, # 0
31403 
    (1, TType.I64, 'circleId', None, None, ), # 1
31404 
    (2, TType.I64, 'operatorId', None, None, ), # 2
31405 
  )
31406 
 
31407 
  def __init__(self, circleId=None, operatorId=None,):
31408 
    self.circleId = circleId
31409 
    self.operatorId = operatorId
31410 
 
31411 
  def read(self, iprot):
31412 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
31413 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
31414 
      return
31415 
    iprot.readStructBegin()
31416 
    while True:
31417 
      (fname, ftype, fid) = iprot.readFieldBegin()
31418 
      if ftype == TType.STOP:
31419 
        break
31420 
      if fid == 1:
31421 
        if ftype == TType.I64:
31422 
          self.circleId = iprot.readI64();
31423 
        else:
31424 
          iprot.skip(ftype)
31425 
      elif fid == 2:
31426 
        if ftype == TType.I64:
31427 
          self.operatorId = iprot.readI64();
31428 
        else:
31429 
          iprot.skip(ftype)
31430 
      else:
31431 
        iprot.skip(ftype)
31432 
      iprot.readFieldEnd()
31433 
    iprot.readStructEnd()
31434 
 
31435 
  def write(self, oprot):
31436 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
31437 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
31438 
      return
31439 
    oprot.writeStructBegin('getFRCs_args')
31440 
    if self.circleId is not None:
31441 
      oprot.writeFieldBegin('circleId', TType.I64, 1)
31442 
      oprot.writeI64(self.circleId)
31443 
      oprot.writeFieldEnd()
31444 
    if self.operatorId is not None:
31445 
      oprot.writeFieldBegin('operatorId', TType.I64, 2)
31446 
      oprot.writeI64(self.operatorId)
31447 
      oprot.writeFieldEnd()
31448 
    oprot.writeFieldStop()
31449 
    oprot.writeStructEnd()
31450 
 
31451 
  def validate(self):
31452 
    return
31453 
 
31454 
 
31455 
  def __repr__(self):
31456 
    L = ['%s=%r' % (key, value)
31457 
      for key, value in self.__dict__.iteritems()]
31458 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
31459 
 
31460 
  def __eq__(self, other):
31461 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
31462 
 
31463 
  def __ne__(self, other):
31464 
    return not (self == other)
31465 
 
31466 
class getFRCs_result:
31467 
  """
31468 
  Attributes:
31469 
   - success
31470 
  """
31471 
 
31472 
  thrift_spec = (
31473 
    (0, TType.LIST, 'success', (TType.STRUCT,(FRC, FRC.thrift_spec)), None, ), # 0
31474 
  )
31475 
 
31476 
  def __init__(self, success=None,):
31477 
    self.success = success
31478 
 
31479 
  def read(self, iprot):
31480 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
31481 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
31482 
      return
31483 
    iprot.readStructBegin()
31484 
    while True:
31485 
      (fname, ftype, fid) = iprot.readFieldBegin()
31486 
      if ftype == TType.STOP:
31487 
        break
31488 
      if fid == 0:
31489 
        if ftype == TType.LIST:
31490 
          self.success = []
7151 amit.gupta 31491 
          (_etype754, _size751) = iprot.readListBegin()
31492 
          for _i755 in xrange(_size751):
31493 
            _elem756 = FRC()
31494 
            _elem756.read(iprot)
31495 
            self.success.append(_elem756)
7080 anupam.sin 31496 
          iprot.readListEnd()
31497 
        else:
31498 
          iprot.skip(ftype)
31499 
      else:
31500 
        iprot.skip(ftype)
31501 
      iprot.readFieldEnd()
31502 
    iprot.readStructEnd()
31503 
 
31504 
  def write(self, oprot):
31505 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
31506 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
31507 
      return
31508 
    oprot.writeStructBegin('getFRCs_result')
31509 
    if self.success is not None:
31510 
      oprot.writeFieldBegin('success', TType.LIST, 0)
31511 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
7151 amit.gupta 31512 
      for iter757 in self.success:
31513 
        iter757.write(oprot)
7080 anupam.sin 31514 
      oprot.writeListEnd()
31515 
      oprot.writeFieldEnd()
31516 
    oprot.writeFieldStop()
31517 
    oprot.writeStructEnd()
31518 
 
31519 
  def validate(self):
31520 
    return
31521 
 
31522 
 
31523 
  def __repr__(self):
31524 
    L = ['%s=%r' % (key, value)
31525 
      for key, value in self.__dict__.iteritems()]
31526 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
31527 
 
31528 
  def __eq__(self, other):
31529 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
31530 
 
31531 
  def __ne__(self, other):
31532 
    return not (self == other)
7096 anupam.sin 31533 
 
31534 
class getHotspotStore_args:
31535 
  """
31536 
  Attributes:
31537 
   - id
31538 
   - hotspotid
31539 
  """
31540 
 
31541 
  thrift_spec = (
31542 
    None, # 0
31543 
    (1, TType.I64, 'id', None, None, ), # 1
31544 
    (2, TType.STRING, 'hotspotid', None, None, ), # 2
31545 
  )
31546 
 
31547 
  def __init__(self, id=None, hotspotid=None,):
31548 
    self.id = id
31549 
    self.hotspotid = hotspotid
31550 
 
31551 
  def read(self, iprot):
31552 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
31553 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
31554 
      return
31555 
    iprot.readStructBegin()
31556 
    while True:
31557 
      (fname, ftype, fid) = iprot.readFieldBegin()
31558 
      if ftype == TType.STOP:
31559 
        break
31560 
      if fid == 1:
31561 
        if ftype == TType.I64:
31562 
          self.id = iprot.readI64();
31563 
        else:
31564 
          iprot.skip(ftype)
31565 
      elif fid == 2:
31566 
        if ftype == TType.STRING:
31567 
          self.hotspotid = iprot.readString();
31568 
        else:
31569 
          iprot.skip(ftype)
31570 
      else:
31571 
        iprot.skip(ftype)
31572 
      iprot.readFieldEnd()
31573 
    iprot.readStructEnd()
31574 
 
31575 
  def write(self, oprot):
31576 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
31577 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
31578 
      return
31579 
    oprot.writeStructBegin('getHotspotStore_args')
31580 
    if self.id is not None:
31581 
      oprot.writeFieldBegin('id', TType.I64, 1)
31582 
      oprot.writeI64(self.id)
31583 
      oprot.writeFieldEnd()
31584 
    if self.hotspotid is not None:
31585 
      oprot.writeFieldBegin('hotspotid', TType.STRING, 2)
31586 
      oprot.writeString(self.hotspotid)
31587 
      oprot.writeFieldEnd()
31588 
    oprot.writeFieldStop()
31589 
    oprot.writeStructEnd()
31590 
 
31591 
  def validate(self):
31592 
    return
31593 
 
31594 
 
31595 
  def __repr__(self):
31596 
    L = ['%s=%r' % (key, value)
31597 
      for key, value in self.__dict__.iteritems()]
31598 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
31599 
 
31600 
  def __eq__(self, other):
31601 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
31602 
 
31603 
  def __ne__(self, other):
31604 
    return not (self == other)
31605 
 
31606 
class getHotspotStore_result:
31607 
  """
31608 
  Attributes:
31609 
   - success
31610 
  """
31611 
 
31612 
  thrift_spec = (
31613 
    (0, TType.STRUCT, 'success', (HotspotStore, HotspotStore.thrift_spec), None, ), # 0
31614 
  )
31615 
 
31616 
  def __init__(self, success=None,):
31617 
    self.success = success
31618 
 
31619 
  def read(self, iprot):
31620 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
31621 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
31622 
      return
31623 
    iprot.readStructBegin()
31624 
    while True:
31625 
      (fname, ftype, fid) = iprot.readFieldBegin()
31626 
      if ftype == TType.STOP:
31627 
        break
31628 
      if fid == 0:
31629 
        if ftype == TType.STRUCT:
31630 
          self.success = HotspotStore()
31631 
          self.success.read(iprot)
31632 
        else:
31633 
          iprot.skip(ftype)
31634 
      else:
31635 
        iprot.skip(ftype)
31636 
      iprot.readFieldEnd()
31637 
    iprot.readStructEnd()
31638 
 
31639 
  def write(self, oprot):
31640 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
31641 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
31642 
      return
31643 
    oprot.writeStructBegin('getHotspotStore_result')
31644 
    if self.success is not None:
31645 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
31646 
      self.success.write(oprot)
31647 
      oprot.writeFieldEnd()
31648 
    oprot.writeFieldStop()
31649 
    oprot.writeStructEnd()
31650 
 
31651 
  def validate(self):
31652 
    return
31653 
 
31654 
 
31655 
  def __repr__(self):
31656 
    L = ['%s=%r' % (key, value)
31657 
      for key, value in self.__dict__.iteritems()]
31658 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
31659 
 
31660 
  def __eq__(self, other):
31661 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
31662 
 
31663 
  def __ne__(self, other):
31664 
    return not (self == other)
31665 
 
31666 
class getTelecomCircle_args:
31667 
  """
31668 
  Attributes:
31669 
   - id
31670 
   - code
31671 
  """
31672 
 
31673 
  thrift_spec = (
31674 
    None, # 0
31675 
    (1, TType.I64, 'id', None, None, ), # 1
31676 
    (2, TType.STRING, 'code', None, None, ), # 2
31677 
  )
31678 
 
31679 
  def __init__(self, id=None, code=None,):
31680 
    self.id = id
31681 
    self.code = code
31682 
 
31683 
  def read(self, iprot):
31684 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
31685 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
31686 
      return
31687 
    iprot.readStructBegin()
31688 
    while True:
31689 
      (fname, ftype, fid) = iprot.readFieldBegin()
31690 
      if ftype == TType.STOP:
31691 
        break
31692 
      if fid == 1:
31693 
        if ftype == TType.I64:
31694 
          self.id = iprot.readI64();
31695 
        else:
31696 
          iprot.skip(ftype)
31697 
      elif fid == 2:
31698 
        if ftype == TType.STRING:
31699 
          self.code = iprot.readString();
31700 
        else:
31701 
          iprot.skip(ftype)
31702 
      else:
31703 
        iprot.skip(ftype)
31704 
      iprot.readFieldEnd()
31705 
    iprot.readStructEnd()
31706 
 
31707 
  def write(self, oprot):
31708 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
31709 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
31710 
      return
31711 
    oprot.writeStructBegin('getTelecomCircle_args')
31712 
    if self.id is not None:
31713 
      oprot.writeFieldBegin('id', TType.I64, 1)
31714 
      oprot.writeI64(self.id)
31715 
      oprot.writeFieldEnd()
31716 
    if self.code is not None:
31717 
      oprot.writeFieldBegin('code', TType.STRING, 2)
31718 
      oprot.writeString(self.code)
31719 
      oprot.writeFieldEnd()
31720 
    oprot.writeFieldStop()
31721 
    oprot.writeStructEnd()
31722 
 
31723 
  def validate(self):
31724 
    return
31725 
 
31726 
 
31727 
  def __repr__(self):
31728 
    L = ['%s=%r' % (key, value)
31729 
      for key, value in self.__dict__.iteritems()]
31730 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
31731 
 
31732 
  def __eq__(self, other):
31733 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
31734 
 
31735 
  def __ne__(self, other):
31736 
    return not (self == other)
31737 
 
31738 
class getTelecomCircle_result:
31739 
  """
31740 
  Attributes:
31741 
   - success
31742 
  """
31743 
 
31744 
  thrift_spec = (
31745 
    (0, TType.STRUCT, 'success', (TelecomCircle, TelecomCircle.thrift_spec), None, ), # 0
31746 
  )
31747 
 
31748 
  def __init__(self, success=None,):
31749 
    self.success = success
31750 
 
31751 
  def read(self, iprot):
31752 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
31753 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
31754 
      return
31755 
    iprot.readStructBegin()
31756 
    while True:
31757 
      (fname, ftype, fid) = iprot.readFieldBegin()
31758 
      if ftype == TType.STOP:
31759 
        break
31760 
      if fid == 0:
31761 
        if ftype == TType.STRUCT:
31762 
          self.success = TelecomCircle()
31763 
          self.success.read(iprot)
31764 
        else:
31765 
          iprot.skip(ftype)
31766 
      else:
31767 
        iprot.skip(ftype)
31768 
      iprot.readFieldEnd()
31769 
    iprot.readStructEnd()
31770 
 
31771 
  def write(self, oprot):
31772 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
31773 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
31774 
      return
31775 
    oprot.writeStructBegin('getTelecomCircle_result')
31776 
    if self.success is not None:
31777 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
31778 
      self.success.write(oprot)
31779 
      oprot.writeFieldEnd()
31780 
    oprot.writeFieldStop()
31781 
    oprot.writeStructEnd()
31782 
 
31783 
  def validate(self):
31784 
    return
31785 
 
31786 
 
31787 
  def __repr__(self):
31788 
    L = ['%s=%r' % (key, value)
31789 
      for key, value in self.__dict__.iteritems()]
31790 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
31791 
 
31792 
  def __eq__(self, other):
31793 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
31794 
 
31795 
  def __ne__(self, other):
31796 
    return not (self == other)
7109 anupam.sin 31797 
 
31798 
class retrieveHotspotRechargeInvoice_args:
31799 
  """
31800 
  Attributes:
31801 
   - rechargeId
31802 
  """
31803 
 
31804 
  thrift_spec = (
31805 
    None, # 0
31806 
    (1, TType.I64, 'rechargeId', None, None, ), # 1
31807 
  )
31808 
 
31809 
  def __init__(self, rechargeId=None,):
31810 
    self.rechargeId = rechargeId
31811 
 
31812 
  def read(self, iprot):
31813 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
31814 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
31815 
      return
31816 
    iprot.readStructBegin()
31817 
    while True:
31818 
      (fname, ftype, fid) = iprot.readFieldBegin()
31819 
      if ftype == TType.STOP:
31820 
        break
31821 
      if fid == 1:
31822 
        if ftype == TType.I64:
31823 
          self.rechargeId = iprot.readI64();
31824 
        else:
31825 
          iprot.skip(ftype)
31826 
      else:
31827 
        iprot.skip(ftype)
31828 
      iprot.readFieldEnd()
31829 
    iprot.readStructEnd()
31830 
 
31831 
  def write(self, oprot):
31832 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
31833 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
31834 
      return
31835 
    oprot.writeStructBegin('retrieveHotspotRechargeInvoice_args')
31836 
    if self.rechargeId is not None:
31837 
      oprot.writeFieldBegin('rechargeId', TType.I64, 1)
31838 
      oprot.writeI64(self.rechargeId)
31839 
      oprot.writeFieldEnd()
31840 
    oprot.writeFieldStop()
31841 
    oprot.writeStructEnd()
31842 
 
31843 
  def validate(self):
31844 
    return
31845 
 
31846 
 
31847 
  def __repr__(self):
31848 
    L = ['%s=%r' % (key, value)
31849 
      for key, value in self.__dict__.iteritems()]
31850 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
31851 
 
31852 
  def __eq__(self, other):
31853 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
31854 
 
31855 
  def __ne__(self, other):
31856 
    return not (self == other)
31857 
 
31858 
class retrieveHotspotRechargeInvoice_result:
31859 
  """
31860 
  Attributes:
31861 
   - success
31862 
  """
31863 
 
31864 
  thrift_spec = (
31865 
    (0, TType.STRING, 'success', None, None, ), # 0
31866 
  )
31867 
 
31868 
  def __init__(self, success=None,):
31869 
    self.success = success
31870 
 
31871 
  def read(self, iprot):
31872 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
31873 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
31874 
      return
31875 
    iprot.readStructBegin()
31876 
    while True:
31877 
      (fname, ftype, fid) = iprot.readFieldBegin()
31878 
      if ftype == TType.STOP:
31879 
        break
31880 
      if fid == 0:
31881 
        if ftype == TType.STRING:
31882 
          self.success = iprot.readString();
31883 
        else:
31884 
          iprot.skip(ftype)
31885 
      else:
31886 
        iprot.skip(ftype)
31887 
      iprot.readFieldEnd()
31888 
    iprot.readStructEnd()
31889 
 
31890 
  def write(self, oprot):
31891 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
31892 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
31893 
      return
31894 
    oprot.writeStructBegin('retrieveHotspotRechargeInvoice_result')
31895 
    if self.success is not None:
31896 
      oprot.writeFieldBegin('success', TType.STRING, 0)
31897 
      oprot.writeString(self.success)
31898 
      oprot.writeFieldEnd()
31899 
    oprot.writeFieldStop()
31900 
    oprot.writeStructEnd()
31901 
 
31902 
  def validate(self):
31903 
    return
31904 
 
31905 
 
31906 
  def __repr__(self):
31907 
    L = ['%s=%r' % (key, value)
31908 
      for key, value in self.__dict__.iteritems()]
31909 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
31910 
 
31911 
  def __eq__(self, other):
31912 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
31913 
 
31914 
  def __ne__(self, other):
31915 
    return not (self == other)