Subversion Repositories SmartDukaan

Rev

Rev 7151 | Rev 7172 | 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 
 
7169 anupam.sin 1552 
  def getRechargeTransactionsByNumber(self, number):
1553 
    """
1554 
    Parameters:
1555 
     - number
1556 
    """
1557 
    pass
7109 anupam.sin 1558 
 
7169 anupam.sin 1559 
  def updateHotspotStorePassword(self, storeId, password):
1560 
    """
1561 
    Parameters:
1562 
     - storeId
1563 
     - password
1564 
    """
1565 
    pass
1566 
 
1567 
 
3376 rajveer 1568 
class Client(shop2020.thriftpy.generic.GenericService.Client, Iface):
94 ashish 1569 
  def __init__(self, iprot, oprot=None):
3376 rajveer 1570 
    shop2020.thriftpy.generic.GenericService.Client.__init__(self, iprot, oprot)
94 ashish 1571 
 
1572 
  def createTransaction(self, transaction):
1573 
    """
1574 
    Parameters:
1575 
     - transaction
1576 
    """
1577 
    self.send_createTransaction(transaction)
132 ashish 1578 
    return self.recv_createTransaction()
94 ashish 1579 
 
1580 
  def send_createTransaction(self, transaction):
1581 
    self._oprot.writeMessageBegin('createTransaction', TMessageType.CALL, self._seqid)
1582 
    args = createTransaction_args()
1583 
    args.transaction = transaction
1584 
    args.write(self._oprot)
1585 
    self._oprot.writeMessageEnd()
1586 
    self._oprot.trans.flush()
1587 
 
1588 
  def recv_createTransaction(self, ):
1589 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1590 
    if mtype == TMessageType.EXCEPTION:
1591 
      x = TApplicationException()
1592 
      x.read(self._iprot)
1593 
      self._iprot.readMessageEnd()
1594 
      raise x
1595 
    result = createTransaction_result()
1596 
    result.read(self._iprot)
1597 
    self._iprot.readMessageEnd()
3431 rajveer 1598 
    if result.success is not None:
132 ashish 1599 
      return result.success
3431 rajveer 1600 
    if result.ex is not None:
94 ashish 1601 
      raise result.ex
132 ashish 1602 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createTransaction failed: unknown result");
94 ashish 1603 
 
1604 
  def getTransaction(self, id):
1605 
    """
1606 
    Parameters:
1607 
     - id
1608 
    """
1609 
    self.send_getTransaction(id)
1610 
    return self.recv_getTransaction()
1611 
 
1612 
  def send_getTransaction(self, id):
1613 
    self._oprot.writeMessageBegin('getTransaction', TMessageType.CALL, self._seqid)
1614 
    args = getTransaction_args()
1615 
    args.id = id
1616 
    args.write(self._oprot)
1617 
    self._oprot.writeMessageEnd()
1618 
    self._oprot.trans.flush()
1619 
 
1620 
  def recv_getTransaction(self, ):
1621 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1622 
    if mtype == TMessageType.EXCEPTION:
1623 
      x = TApplicationException()
1624 
      x.read(self._iprot)
1625 
      self._iprot.readMessageEnd()
1626 
      raise x
1627 
    result = getTransaction_result()
1628 
    result.read(self._iprot)
1629 
    self._iprot.readMessageEnd()
3431 rajveer 1630 
    if result.success is not None:
94 ashish 1631 
      return result.success
3431 rajveer 1632 
    if result.ex is not None:
94 ashish 1633 
      raise result.ex
1634 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransaction failed: unknown result");
1635 
 
1636 
  def getTransactionsForCustomer(self, customerId, from_date, to_date, status):
1637 
    """
1638 
    Parameters:
1639 
     - customerId
1640 
     - from_date
1641 
     - to_date
1642 
     - status
1643 
    """
1644 
    self.send_getTransactionsForCustomer(customerId, from_date, to_date, status)
1645 
    return self.recv_getTransactionsForCustomer()
1646 
 
1647 
  def send_getTransactionsForCustomer(self, customerId, from_date, to_date, status):
1648 
    self._oprot.writeMessageBegin('getTransactionsForCustomer', TMessageType.CALL, self._seqid)
1649 
    args = getTransactionsForCustomer_args()
1650 
    args.customerId = customerId
1651 
    args.from_date = from_date
1652 
    args.to_date = to_date
1653 
    args.status = status
1654 
    args.write(self._oprot)
1655 
    self._oprot.writeMessageEnd()
1656 
    self._oprot.trans.flush()
1657 
 
1658 
  def recv_getTransactionsForCustomer(self, ):
1659 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1660 
    if mtype == TMessageType.EXCEPTION:
1661 
      x = TApplicationException()
1662 
      x.read(self._iprot)
1663 
      self._iprot.readMessageEnd()
1664 
      raise x
1665 
    result = getTransactionsForCustomer_result()
1666 
    result.read(self._iprot)
1667 
    self._iprot.readMessageEnd()
3431 rajveer 1668 
    if result.success is not None:
94 ashish 1669 
      return result.success
3431 rajveer 1670 
    if result.ex is not None:
94 ashish 1671 
      raise result.ex
1672 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransactionsForCustomer failed: unknown result");
1673 
 
132 ashish 1674 
  def getTransactionsForShoppingCartId(self, shoppingCartId):
1675 
    """
1676 
    Parameters:
1677 
     - shoppingCartId
1678 
    """
1679 
    self.send_getTransactionsForShoppingCartId(shoppingCartId)
1680 
    return self.recv_getTransactionsForShoppingCartId()
1681 
 
1682 
  def send_getTransactionsForShoppingCartId(self, shoppingCartId):
1683 
    self._oprot.writeMessageBegin('getTransactionsForShoppingCartId', TMessageType.CALL, self._seqid)
1684 
    args = getTransactionsForShoppingCartId_args()
1685 
    args.shoppingCartId = shoppingCartId
1686 
    args.write(self._oprot)
1687 
    self._oprot.writeMessageEnd()
1688 
    self._oprot.trans.flush()
1689 
 
1690 
  def recv_getTransactionsForShoppingCartId(self, ):
1691 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1692 
    if mtype == TMessageType.EXCEPTION:
1693 
      x = TApplicationException()
1694 
      x.read(self._iprot)
1695 
      self._iprot.readMessageEnd()
1696 
      raise x
1697 
    result = getTransactionsForShoppingCartId_result()
1698 
    result.read(self._iprot)
1699 
    self._iprot.readMessageEnd()
3431 rajveer 1700 
    if result.success is not None:
132 ashish 1701 
      return result.success
3431 rajveer 1702 
    if result.ex is not None:
132 ashish 1703 
      raise result.ex
1704 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransactionsForShoppingCartId failed: unknown result");
1705 
 
94 ashish 1706 
  def getTransactionStatus(self, transactionId):
1707 
    """
1708 
    Parameters:
1709 
     - transactionId
1710 
    """
1711 
    self.send_getTransactionStatus(transactionId)
1712 
    return self.recv_getTransactionStatus()
1713 
 
1714 
  def send_getTransactionStatus(self, transactionId):
1715 
    self._oprot.writeMessageBegin('getTransactionStatus', TMessageType.CALL, self._seqid)
1716 
    args = getTransactionStatus_args()
1717 
    args.transactionId = transactionId
1718 
    args.write(self._oprot)
1719 
    self._oprot.writeMessageEnd()
1720 
    self._oprot.trans.flush()
1721 
 
1722 
  def recv_getTransactionStatus(self, ):
1723 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1724 
    if mtype == TMessageType.EXCEPTION:
1725 
      x = TApplicationException()
1726 
      x.read(self._iprot)
1727 
      self._iprot.readMessageEnd()
1728 
      raise x
1729 
    result = getTransactionStatus_result()
1730 
    result.read(self._iprot)
1731 
    self._iprot.readMessageEnd()
3431 rajveer 1732 
    if result.success is not None:
94 ashish 1733 
      return result.success
3431 rajveer 1734 
    if result.ex is not None:
94 ashish 1735 
      raise result.ex
1736 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransactionStatus failed: unknown result");
1737 
 
5527 anupam.sin 1738 
  def changeTransactionStatus(self, transactionId, status, description, pickUp, orderType):
94 ashish 1739 
    """
1740 
    Parameters:
1741 
     - transactionId
1742 
     - status
1743 
     - description
5527 anupam.sin 1744 
     - pickUp
1745 
     - orderType
94 ashish 1746 
    """
5527 anupam.sin 1747 
    self.send_changeTransactionStatus(transactionId, status, description, pickUp, orderType)
94 ashish 1748 
    return self.recv_changeTransactionStatus()
1749 
 
5527 anupam.sin 1750 
  def send_changeTransactionStatus(self, transactionId, status, description, pickUp, orderType):
94 ashish 1751 
    self._oprot.writeMessageBegin('changeTransactionStatus', TMessageType.CALL, self._seqid)
1752 
    args = changeTransactionStatus_args()
1753 
    args.transactionId = transactionId
1754 
    args.status = status
1755 
    args.description = description
5527 anupam.sin 1756 
    args.pickUp = pickUp
1757 
    args.orderType = orderType
94 ashish 1758 
    args.write(self._oprot)
1759 
    self._oprot.writeMessageEnd()
1760 
    self._oprot.trans.flush()
1761 
 
1762 
  def recv_changeTransactionStatus(self, ):
1763 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1764 
    if mtype == TMessageType.EXCEPTION:
1765 
      x = TApplicationException()
1766 
      x.read(self._iprot)
1767 
      self._iprot.readMessageEnd()
1768 
      raise x
1769 
    result = changeTransactionStatus_result()
1770 
    result.read(self._iprot)
1771 
    self._iprot.readMessageEnd()
3431 rajveer 1772 
    if result.success is not None:
94 ashish 1773 
      return result.success
3431 rajveer 1774 
    if result.ex is not None:
94 ashish 1775 
      raise result.ex
1776 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "changeTransactionStatus failed: unknown result");
1777 
 
1398 varun.gupt 1778 
  def enqueueTransactionInfoEmail(self, transactionId):
1382 varun.gupt 1779 
    """
1780 
    Parameters:
1781 
     - transactionId
1782 
    """
1398 varun.gupt 1783 
    self.send_enqueueTransactionInfoEmail(transactionId)
1784 
    return self.recv_enqueueTransactionInfoEmail()
1382 varun.gupt 1785 
 
1398 varun.gupt 1786 
  def send_enqueueTransactionInfoEmail(self, transactionId):
1787 
    self._oprot.writeMessageBegin('enqueueTransactionInfoEmail', TMessageType.CALL, self._seqid)
1788 
    args = enqueueTransactionInfoEmail_args()
1382 varun.gupt 1789 
    args.transactionId = transactionId
1790 
    args.write(self._oprot)
1791 
    self._oprot.writeMessageEnd()
1792 
    self._oprot.trans.flush()
1793 
 
1398 varun.gupt 1794 
  def recv_enqueueTransactionInfoEmail(self, ):
1382 varun.gupt 1795 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1796 
    if mtype == TMessageType.EXCEPTION:
1797 
      x = TApplicationException()
1798 
      x.read(self._iprot)
1799 
      self._iprot.readMessageEnd()
1800 
      raise x
1398 varun.gupt 1801 
    result = enqueueTransactionInfoEmail_result()
1382 varun.gupt 1802 
    result.read(self._iprot)
1803 
    self._iprot.readMessageEnd()
3431 rajveer 1804 
    if result.success is not None:
1382 varun.gupt 1805 
      return result.success
3431 rajveer 1806 
    if result.ex is not None:
1382 varun.gupt 1807 
      raise result.ex
1398 varun.gupt 1808 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "enqueueTransactionInfoEmail failed: unknown result");
1382 varun.gupt 1809 
 
4801 anupam.sin 1810 
  def getAllOrders(self, statuses, from_date, to_date, warehouse_id):
94 ashish 1811 
    """
1812 
    Parameters:
4801 anupam.sin 1813 
     - statuses
483 rajveer 1814 
     - from_date
1815 
     - to_date
1816 
     - warehouse_id
94 ashish 1817 
    """
4801 anupam.sin 1818 
    self.send_getAllOrders(statuses, from_date, to_date, warehouse_id)
483 rajveer 1819 
    return self.recv_getAllOrders()
94 ashish 1820 
 
4801 anupam.sin 1821 
  def send_getAllOrders(self, statuses, from_date, to_date, warehouse_id):
483 rajveer 1822 
    self._oprot.writeMessageBegin('getAllOrders', TMessageType.CALL, self._seqid)
1823 
    args = getAllOrders_args()
4801 anupam.sin 1824 
    args.statuses = statuses
483 rajveer 1825 
    args.from_date = from_date
1826 
    args.to_date = to_date
1827 
    args.warehouse_id = warehouse_id
94 ashish 1828 
    args.write(self._oprot)
1829 
    self._oprot.writeMessageEnd()
1830 
    self._oprot.trans.flush()
1831 
 
483 rajveer 1832 
  def recv_getAllOrders(self, ):
94 ashish 1833 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1834 
    if mtype == TMessageType.EXCEPTION:
1835 
      x = TApplicationException()
1836 
      x.read(self._iprot)
1837 
      self._iprot.readMessageEnd()
1838 
      raise x
483 rajveer 1839 
    result = getAllOrders_result()
94 ashish 1840 
    result.read(self._iprot)
1841 
    self._iprot.readMessageEnd()
3431 rajveer 1842 
    if result.success is not None:
94 ashish 1843 
      return result.success
3431 rajveer 1844 
    if result.ex is not None:
94 ashish 1845 
      raise result.ex
483 rajveer 1846 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllOrders failed: unknown result");
94 ashish 1847 
 
4133 chandransh 1848 
  def getOrdersInBatch(self, statuses, offset, limit, warehouse_id):
1849 
    """
1850 
    Returns at most 'limit' orders with the given statuses for the given warehouse starting from the given offset.
1851 
    Pass the status as null and the limit as 0 to ignore them.
1852 
 
1853 
    Parameters:
1854 
     - statuses
1855 
     - offset
1856 
     - limit
1857 
     - warehouse_id
1858 
    """
1859 
    self.send_getOrdersInBatch(statuses, offset, limit, warehouse_id)
1860 
    return self.recv_getOrdersInBatch()
1861 
 
1862 
  def send_getOrdersInBatch(self, statuses, offset, limit, warehouse_id):
1863 
    self._oprot.writeMessageBegin('getOrdersInBatch', TMessageType.CALL, self._seqid)
1864 
    args = getOrdersInBatch_args()
1865 
    args.statuses = statuses
1866 
    args.offset = offset
1867 
    args.limit = limit
1868 
    args.warehouse_id = warehouse_id
1869 
    args.write(self._oprot)
1870 
    self._oprot.writeMessageEnd()
1871 
    self._oprot.trans.flush()
1872 
 
1873 
  def recv_getOrdersInBatch(self, ):
1874 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1875 
    if mtype == TMessageType.EXCEPTION:
1876 
      x = TApplicationException()
1877 
      x.read(self._iprot)
1878 
      self._iprot.readMessageEnd()
1879 
      raise x
1880 
    result = getOrdersInBatch_result()
1881 
    result.read(self._iprot)
1882 
    self._iprot.readMessageEnd()
1883 
    if result.success is not None:
1884 
      return result.success
1885 
    if result.ex is not None:
1886 
      raise result.ex
1887 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersInBatch failed: unknown result");
1888 
 
1889 
  def getOrderCount(self, statuses, warehouseId):
1890 
    """
1891 
    Returns the count of orders with the given statuses assigned to the given warehouse.
1892 
 
1893 
    Parameters:
1894 
     - statuses
1895 
     - warehouseId
1896 
    """
1897 
    self.send_getOrderCount(statuses, warehouseId)
1898 
    return self.recv_getOrderCount()
1899 
 
1900 
  def send_getOrderCount(self, statuses, warehouseId):
1901 
    self._oprot.writeMessageBegin('getOrderCount', TMessageType.CALL, self._seqid)
1902 
    args = getOrderCount_args()
1903 
    args.statuses = statuses
1904 
    args.warehouseId = warehouseId
1905 
    args.write(self._oprot)
1906 
    self._oprot.writeMessageEnd()
1907 
    self._oprot.trans.flush()
1908 
 
1909 
  def recv_getOrderCount(self, ):
1910 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1911 
    if mtype == TMessageType.EXCEPTION:
1912 
      x = TApplicationException()
1913 
      x.read(self._iprot)
1914 
      self._iprot.readMessageEnd()
1915 
      raise x
1916 
    result = getOrderCount_result()
1917 
    result.read(self._iprot)
1918 
    self._iprot.readMessageEnd()
1919 
    if result.success is not None:
1920 
      return result.success
1921 
    if result.ex is not None:
1922 
      raise result.ex
1923 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderCount failed: unknown result");
1924 
 
999 varun.gupt 1925 
  def getOrdersByBillingDate(self, status, start_billing_date, end_billing_date, warehouse_id):
1926 
    """
1132 chandransh 1927 
    Returns orders within a range of their billing dates
3431 rajveer 1928 
 
999 varun.gupt 1929 
    Parameters:
1930 
     - status
1931 
     - start_billing_date
1932 
     - end_billing_date
1933 
     - warehouse_id
1934 
    """
1935 
    self.send_getOrdersByBillingDate(status, start_billing_date, end_billing_date, warehouse_id)
1936 
    return self.recv_getOrdersByBillingDate()
1937 
 
1938 
  def send_getOrdersByBillingDate(self, status, start_billing_date, end_billing_date, warehouse_id):
1939 
    self._oprot.writeMessageBegin('getOrdersByBillingDate', TMessageType.CALL, self._seqid)
1940 
    args = getOrdersByBillingDate_args()
1941 
    args.status = status
1942 
    args.start_billing_date = start_billing_date
1943 
    args.end_billing_date = end_billing_date
1944 
    args.warehouse_id = warehouse_id
1945 
    args.write(self._oprot)
1946 
    self._oprot.writeMessageEnd()
1947 
    self._oprot.trans.flush()
1948 
 
1949 
  def recv_getOrdersByBillingDate(self, ):
1950 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1951 
    if mtype == TMessageType.EXCEPTION:
1952 
      x = TApplicationException()
1953 
      x.read(self._iprot)
1954 
      self._iprot.readMessageEnd()
1955 
      raise x
1956 
    result = getOrdersByBillingDate_result()
1957 
    result.read(self._iprot)
1958 
    self._iprot.readMessageEnd()
3431 rajveer 1959 
    if result.success is not None:
999 varun.gupt 1960 
      return result.success
3431 rajveer 1961 
    if result.ex is not None:
999 varun.gupt 1962 
      raise result.ex
1963 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersByBillingDate failed: unknown result");
1964 
 
3451 chandransh 1965 
  def getOrdersByShippingDate(self, fromShippingDate, toShippingDate, providerId, warehouseId, cod):
3427 chandransh 1966 
    """
1967 
    Returns orders for a particular provider and warehouse which were shipped between the given dates.
3451 chandransh 1968 
    Returned orders comprise of COD orders if cod parameter is true. It comprises of prepaid orders otherwise.
1969 
    Pass providerId and warehouseId as -1 to ignore both these parameters.
3431 rajveer 1970 
 
3427 chandransh 1971 
    Parameters:
1972 
     - fromShippingDate
1973 
     - toShippingDate
1974 
     - providerId
1975 
     - warehouseId
3451 chandransh 1976 
     - cod
3427 chandransh 1977 
    """
3451 chandransh 1978 
    self.send_getOrdersByShippingDate(fromShippingDate, toShippingDate, providerId, warehouseId, cod)
3427 chandransh 1979 
    return self.recv_getOrdersByShippingDate()
1980 
 
3451 chandransh 1981 
  def send_getOrdersByShippingDate(self, fromShippingDate, toShippingDate, providerId, warehouseId, cod):
3427 chandransh 1982 
    self._oprot.writeMessageBegin('getOrdersByShippingDate', TMessageType.CALL, self._seqid)
1983 
    args = getOrdersByShippingDate_args()
1984 
    args.fromShippingDate = fromShippingDate
1985 
    args.toShippingDate = toShippingDate
1986 
    args.providerId = providerId
1987 
    args.warehouseId = warehouseId
3451 chandransh 1988 
    args.cod = cod
3427 chandransh 1989 
    args.write(self._oprot)
1990 
    self._oprot.writeMessageEnd()
1991 
    self._oprot.trans.flush()
1992 
 
1993 
  def recv_getOrdersByShippingDate(self, ):
1994 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1995 
    if mtype == TMessageType.EXCEPTION:
1996 
      x = TApplicationException()
1997 
      x.read(self._iprot)
1998 
      self._iprot.readMessageEnd()
1999 
      raise x
2000 
    result = getOrdersByShippingDate_result()
2001 
    result.read(self._iprot)
2002 
    self._iprot.readMessageEnd()
3431 rajveer 2003 
    if result.success is not None:
3427 chandransh 2004 
      return result.success
3431 rajveer 2005 
    if result.ex is not None:
3427 chandransh 2006 
      raise result.ex
2007 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersByShippingDate failed: unknown result");
2008 
 
1382 varun.gupt 2009 
  def getReturnableOrdersForCustomer(self, customer_id, limit):
2010 
    """
2011 
    Returns order ids for orders which can be returned
3431 rajveer 2012 
 
1382 varun.gupt 2013 
    Parameters:
2014 
     - customer_id
2015 
     - limit
2016 
    """
2017 
    self.send_getReturnableOrdersForCustomer(customer_id, limit)
2018 
    return self.recv_getReturnableOrdersForCustomer()
2019 
 
2020 
  def send_getReturnableOrdersForCustomer(self, customer_id, limit):
2021 
    self._oprot.writeMessageBegin('getReturnableOrdersForCustomer', TMessageType.CALL, self._seqid)
2022 
    args = getReturnableOrdersForCustomer_args()
2023 
    args.customer_id = customer_id
2024 
    args.limit = limit
2025 
    args.write(self._oprot)
2026 
    self._oprot.writeMessageEnd()
2027 
    self._oprot.trans.flush()
2028 
 
2029 
  def recv_getReturnableOrdersForCustomer(self, ):
2030 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2031 
    if mtype == TMessageType.EXCEPTION:
2032 
      x = TApplicationException()
2033 
      x.read(self._iprot)
2034 
      self._iprot.readMessageEnd()
2035 
      raise x
2036 
    result = getReturnableOrdersForCustomer_result()
2037 
    result.read(self._iprot)
2038 
    self._iprot.readMessageEnd()
3431 rajveer 2039 
    if result.success is not None:
1382 varun.gupt 2040 
      return result.success
3431 rajveer 2041 
    if result.ex is not None:
1382 varun.gupt 2042 
      raise result.ex
2043 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReturnableOrdersForCustomer failed: unknown result");
2044 
 
2045 
  def getCancellableOrdersForCustomer(self, customer_id, limit):
2046 
    """
2047 
    Returns order ids for orders which can be cancelled
3431 rajveer 2048 
 
1382 varun.gupt 2049 
    Parameters:
2050 
     - customer_id
2051 
     - limit
2052 
    """
2053 
    self.send_getCancellableOrdersForCustomer(customer_id, limit)
2054 
    return self.recv_getCancellableOrdersForCustomer()
2055 
 
2056 
  def send_getCancellableOrdersForCustomer(self, customer_id, limit):
2057 
    self._oprot.writeMessageBegin('getCancellableOrdersForCustomer', TMessageType.CALL, self._seqid)
2058 
    args = getCancellableOrdersForCustomer_args()
2059 
    args.customer_id = customer_id
2060 
    args.limit = limit
2061 
    args.write(self._oprot)
2062 
    self._oprot.writeMessageEnd()
2063 
    self._oprot.trans.flush()
2064 
 
2065 
  def recv_getCancellableOrdersForCustomer(self, ):
2066 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2067 
    if mtype == TMessageType.EXCEPTION:
2068 
      x = TApplicationException()
2069 
      x.read(self._iprot)
2070 
      self._iprot.readMessageEnd()
2071 
      raise x
2072 
    result = getCancellableOrdersForCustomer_result()
2073 
    result.read(self._iprot)
2074 
    self._iprot.readMessageEnd()
3431 rajveer 2075 
    if result.success is not None:
1382 varun.gupt 2076 
      return result.success
3431 rajveer 2077 
    if result.ex is not None:
1382 varun.gupt 2078 
      raise result.ex
2079 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCancellableOrdersForCustomer failed: unknown result");
2080 
 
483 rajveer 2081 
  def changeOrderStatus(self, orderId, status, description):
94 ashish 2082 
    """
2083 
    Parameters:
483 rajveer 2084 
     - orderId
2085 
     - status
2086 
     - description
94 ashish 2087 
    """
483 rajveer 2088 
    self.send_changeOrderStatus(orderId, status, description)
2089 
    return self.recv_changeOrderStatus()
94 ashish 2090 
 
483 rajveer 2091 
  def send_changeOrderStatus(self, orderId, status, description):
2092 
    self._oprot.writeMessageBegin('changeOrderStatus', TMessageType.CALL, self._seqid)
2093 
    args = changeOrderStatus_args()
2094 
    args.orderId = orderId
2095 
    args.status = status
2096 
    args.description = description
94 ashish 2097 
    args.write(self._oprot)
2098 
    self._oprot.writeMessageEnd()
2099 
    self._oprot.trans.flush()
2100 
 
483 rajveer 2101 
  def recv_changeOrderStatus(self, ):
94 ashish 2102 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2103 
    if mtype == TMessageType.EXCEPTION:
2104 
      x = TApplicationException()
2105 
      x.read(self._iprot)
2106 
      self._iprot.readMessageEnd()
2107 
      raise x
483 rajveer 2108 
    result = changeOrderStatus_result()
94 ashish 2109 
    result.read(self._iprot)
2110 
    self._iprot.readMessageEnd()
3431 rajveer 2111 
    if result.success is not None:
94 ashish 2112 
      return result.success
3431 rajveer 2113 
    if result.ex is not None:
94 ashish 2114 
      raise result.ex
483 rajveer 2115 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "changeOrderStatus failed: unknown result");
94 ashish 2116 
 
1528 ankur.sing 2117 
  def getOrdersForTransaction(self, transactionId, customerId):
94 ashish 2118 
    """
1528 ankur.sing 2119 
    Returns list of orders for given transaction Id. Also filters based on customer Id so that
2120 
    only user who owns the transaction can view its order details.
3431 rajveer 2121 
 
94 ashish 2122 
    Parameters:
2123 
     - transactionId
1528 ankur.sing 2124 
     - customerId
94 ashish 2125 
    """
1528 ankur.sing 2126 
    self.send_getOrdersForTransaction(transactionId, customerId)
483 rajveer 2127 
    return self.recv_getOrdersForTransaction()
94 ashish 2128 
 
1528 ankur.sing 2129 
  def send_getOrdersForTransaction(self, transactionId, customerId):
483 rajveer 2130 
    self._oprot.writeMessageBegin('getOrdersForTransaction', TMessageType.CALL, self._seqid)
2131 
    args = getOrdersForTransaction_args()
94 ashish 2132 
    args.transactionId = transactionId
1528 ankur.sing 2133 
    args.customerId = customerId
94 ashish 2134 
    args.write(self._oprot)
2135 
    self._oprot.writeMessageEnd()
2136 
    self._oprot.trans.flush()
2137 
 
483 rajveer 2138 
  def recv_getOrdersForTransaction(self, ):
94 ashish 2139 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2140 
    if mtype == TMessageType.EXCEPTION:
2141 
      x = TApplicationException()
2142 
      x.read(self._iprot)
2143 
      self._iprot.readMessageEnd()
2144 
      raise x
483 rajveer 2145 
    result = getOrdersForTransaction_result()
94 ashish 2146 
    result.read(self._iprot)
2147 
    self._iprot.readMessageEnd()
3431 rajveer 2148 
    if result.success is not None:
94 ashish 2149 
      return result.success
3431 rajveer 2150 
    if result.ex is not None:
94 ashish 2151 
      raise result.ex
483 rajveer 2152 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersForTransaction failed: unknown result");
94 ashish 2153 
 
3014 chandransh 2154 
  def getOrdersForCustomer(self, customerId, from_date, to_date, statuses):
94 ashish 2155 
    """
3014 chandransh 2156 
    Returns list of orders for the given customer created between the given dates and having the given statuses.
2157 
    Pass and empty list to ignore filtering on statuses.
3431 rajveer 2158 
 
94 ashish 2159 
    Parameters:
483 rajveer 2160 
     - customerId
2161 
     - from_date
2162 
     - to_date
3014 chandransh 2163 
     - statuses
94 ashish 2164 
    """
3014 chandransh 2165 
    self.send_getOrdersForCustomer(customerId, from_date, to_date, statuses)
483 rajveer 2166 
    return self.recv_getOrdersForCustomer()
94 ashish 2167 
 
3014 chandransh 2168 
  def send_getOrdersForCustomer(self, customerId, from_date, to_date, statuses):
483 rajveer 2169 
    self._oprot.writeMessageBegin('getOrdersForCustomer', TMessageType.CALL, self._seqid)
2170 
    args = getOrdersForCustomer_args()
2171 
    args.customerId = customerId
2172 
    args.from_date = from_date
2173 
    args.to_date = to_date
3014 chandransh 2174 
    args.statuses = statuses
94 ashish 2175 
    args.write(self._oprot)
2176 
    self._oprot.writeMessageEnd()
2177 
    self._oprot.trans.flush()
2178 
 
483 rajveer 2179 
  def recv_getOrdersForCustomer(self, ):
94 ashish 2180 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2181 
    if mtype == TMessageType.EXCEPTION:
2182 
      x = TApplicationException()
2183 
      x.read(self._iprot)
2184 
      self._iprot.readMessageEnd()
2185 
      raise x
483 rajveer 2186 
    result = getOrdersForCustomer_result()
94 ashish 2187 
    result.read(self._iprot)
2188 
    self._iprot.readMessageEnd()
3431 rajveer 2189 
    if result.success is not None:
94 ashish 2190 
      return result.success
3431 rajveer 2191 
    if result.ex is not None:
94 ashish 2192 
      raise result.ex
483 rajveer 2193 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersForCustomer failed: unknown result");
94 ashish 2194 
 
483 rajveer 2195 
  def createOrder(self, order):
94 ashish 2196 
    """
2197 
    Parameters:
483 rajveer 2198 
     - order
94 ashish 2199 
    """
483 rajveer 2200 
    self.send_createOrder(order)
2201 
    return self.recv_createOrder()
94 ashish 2202 
 
483 rajveer 2203 
  def send_createOrder(self, order):
2204 
    self._oprot.writeMessageBegin('createOrder', TMessageType.CALL, self._seqid)
2205 
    args = createOrder_args()
2206 
    args.order = order
94 ashish 2207 
    args.write(self._oprot)
2208 
    self._oprot.writeMessageEnd()
2209 
    self._oprot.trans.flush()
2210 
 
483 rajveer 2211 
  def recv_createOrder(self, ):
94 ashish 2212 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2213 
    if mtype == TMessageType.EXCEPTION:
2214 
      x = TApplicationException()
2215 
      x.read(self._iprot)
2216 
      self._iprot.readMessageEnd()
2217 
      raise x
483 rajveer 2218 
    result = createOrder_result()
94 ashish 2219 
    result.read(self._iprot)
2220 
    self._iprot.readMessageEnd()
3431 rajveer 2221 
    if result.success is not None:
94 ashish 2222 
      return result.success
3431 rajveer 2223 
    if result.ex is not None:
94 ashish 2224 
      raise result.ex
483 rajveer 2225 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createOrder failed: unknown result");
94 ashish 2226 
 
483 rajveer 2227 
  def getOrder(self, id):
94 ashish 2228 
    """
2229 
    Parameters:
483 rajveer 2230 
     - id
94 ashish 2231 
    """
483 rajveer 2232 
    self.send_getOrder(id)
2233 
    return self.recv_getOrder()
94 ashish 2234 
 
483 rajveer 2235 
  def send_getOrder(self, id):
2236 
    self._oprot.writeMessageBegin('getOrder', TMessageType.CALL, self._seqid)
2237 
    args = getOrder_args()
2238 
    args.id = id
94 ashish 2239 
    args.write(self._oprot)
2240 
    self._oprot.writeMessageEnd()
2241 
    self._oprot.trans.flush()
2242 
 
483 rajveer 2243 
  def recv_getOrder(self, ):
94 ashish 2244 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2245 
    if mtype == TMessageType.EXCEPTION:
2246 
      x = TApplicationException()
2247 
      x.read(self._iprot)
2248 
      self._iprot.readMessageEnd()
2249 
      raise x
483 rajveer 2250 
    result = getOrder_result()
94 ashish 2251 
    result.read(self._iprot)
2252 
    self._iprot.readMessageEnd()
3431 rajveer 2253 
    if result.success is not None:
94 ashish 2254 
      return result.success
3431 rajveer 2255 
    if result.ex is not None:
94 ashish 2256 
      raise result.ex
483 rajveer 2257 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrder failed: unknown result");
94 ashish 2258 
 
483 rajveer 2259 
  def getLineItemsForOrder(self, orderId):
94 ashish 2260 
    """
2261 
    Parameters:
483 rajveer 2262 
     - orderId
94 ashish 2263 
    """
483 rajveer 2264 
    self.send_getLineItemsForOrder(orderId)
2265 
    return self.recv_getLineItemsForOrder()
94 ashish 2266 
 
483 rajveer 2267 
  def send_getLineItemsForOrder(self, orderId):
2268 
    self._oprot.writeMessageBegin('getLineItemsForOrder', TMessageType.CALL, self._seqid)
2269 
    args = getLineItemsForOrder_args()
2270 
    args.orderId = orderId
94 ashish 2271 
    args.write(self._oprot)
2272 
    self._oprot.writeMessageEnd()
2273 
    self._oprot.trans.flush()
2274 
 
483 rajveer 2275 
  def recv_getLineItemsForOrder(self, ):
94 ashish 2276 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2277 
    if mtype == TMessageType.EXCEPTION:
2278 
      x = TApplicationException()
2279 
      x.read(self._iprot)
2280 
      self._iprot.readMessageEnd()
2281 
      raise x
483 rajveer 2282 
    result = getLineItemsForOrder_result()
94 ashish 2283 
    result.read(self._iprot)
2284 
    self._iprot.readMessageEnd()
3431 rajveer 2285 
    if result.success is not None:
94 ashish 2286 
      return result.success
3431 rajveer 2287 
    if result.ex is not None:
94 ashish 2288 
      raise result.ex
483 rajveer 2289 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getLineItemsForOrder failed: unknown result");
94 ashish 2290 
 
4999 phani.kuma 2291 
  def getOrderList(self, order_ids):
2292 
    """
2293 
    Parameters:
2294 
     - order_ids
2295 
    """
2296 
    self.send_getOrderList(order_ids)
2297 
    return self.recv_getOrderList()
2298 
 
2299 
  def send_getOrderList(self, order_ids):
2300 
    self._oprot.writeMessageBegin('getOrderList', TMessageType.CALL, self._seqid)
2301 
    args = getOrderList_args()
2302 
    args.order_ids = order_ids
2303 
    args.write(self._oprot)
2304 
    self._oprot.writeMessageEnd()
2305 
    self._oprot.trans.flush()
2306 
 
2307 
  def recv_getOrderList(self, ):
2308 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2309 
    if mtype == TMessageType.EXCEPTION:
2310 
      x = TApplicationException()
2311 
      x.read(self._iprot)
2312 
      self._iprot.readMessageEnd()
2313 
      raise x
2314 
    result = getOrderList_result()
2315 
    result.read(self._iprot)
2316 
    self._iprot.readMessageEnd()
2317 
    if result.success is not None:
2318 
      return result.success
2319 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderList failed: unknown result");
2320 
 
5386 phani.kuma 2321 
  def getOrderListForVendor(self, order_ids, vendorId):
2322 
    """
2323 
    Parameters:
2324 
     - order_ids
2325 
     - vendorId
2326 
    """
2327 
    self.send_getOrderListForVendor(order_ids, vendorId)
2328 
    return self.recv_getOrderListForVendor()
2329 
 
2330 
  def send_getOrderListForVendor(self, order_ids, vendorId):
2331 
    self._oprot.writeMessageBegin('getOrderListForVendor', TMessageType.CALL, self._seqid)
2332 
    args = getOrderListForVendor_args()
2333 
    args.order_ids = order_ids
2334 
    args.vendorId = vendorId
2335 
    args.write(self._oprot)
2336 
    self._oprot.writeMessageEnd()
2337 
    self._oprot.trans.flush()
2338 
 
2339 
  def recv_getOrderListForVendor(self, ):
2340 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2341 
    if mtype == TMessageType.EXCEPTION:
2342 
      x = TApplicationException()
2343 
      x.read(self._iprot)
2344 
      self._iprot.readMessageEnd()
2345 
      raise x
2346 
    result = getOrderListForVendor_result()
2347 
    result.read(self._iprot)
2348 
    self._iprot.readMessageEnd()
2349 
    if result.success is not None:
2350 
      return result.success
2351 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderListForVendor failed: unknown result");
2352 
 
1528 ankur.sing 2353 
  def getOrderForCustomer(self, orderId, customerId):
2354 
    """
2355 
    Returns an order for the order Id. Also checks if the order belongs to the customer whose Id is passed.
2356 
    Throws exception if either order Id is invalid or order does not below to the customer whose Id is passed.
3431 rajveer 2357 
 
1528 ankur.sing 2358 
    Parameters:
2359 
     - orderId
2360 
     - customerId
2361 
    """
2362 
    self.send_getOrderForCustomer(orderId, customerId)
2363 
    return self.recv_getOrderForCustomer()
2364 
 
2365 
  def send_getOrderForCustomer(self, orderId, customerId):
2366 
    self._oprot.writeMessageBegin('getOrderForCustomer', TMessageType.CALL, self._seqid)
2367 
    args = getOrderForCustomer_args()
2368 
    args.orderId = orderId
2369 
    args.customerId = customerId
2370 
    args.write(self._oprot)
2371 
    self._oprot.writeMessageEnd()
2372 
    self._oprot.trans.flush()
2373 
 
2374 
  def recv_getOrderForCustomer(self, ):
2375 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2376 
    if mtype == TMessageType.EXCEPTION:
2377 
      x = TApplicationException()
2378 
      x.read(self._iprot)
2379 
      self._iprot.readMessageEnd()
2380 
      raise x
2381 
    result = getOrderForCustomer_result()
2382 
    result.read(self._iprot)
2383 
    self._iprot.readMessageEnd()
3431 rajveer 2384 
    if result.success is not None:
1528 ankur.sing 2385 
      return result.success
3431 rajveer 2386 
    if result.ex is not None:
1528 ankur.sing 2387 
      raise result.ex
2388 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderForCustomer failed: unknown result");
2389 
 
4444 rajveer 2390 
  def getAlerts(self, type, warehouseId, status, timestamp):
3064 chandransh 2391 
    """
2392 
    Parameters:
4394 rajveer 2393 
     - type
4444 rajveer 2394 
     - warehouseId
4394 rajveer 2395 
     - status
2396 
     - timestamp
3064 chandransh 2397 
    """
4444 rajveer 2398 
    self.send_getAlerts(type, warehouseId, status, timestamp)
3064 chandransh 2399 
    return self.recv_getAlerts()
2400 
 
4444 rajveer 2401 
  def send_getAlerts(self, type, warehouseId, status, timestamp):
3064 chandransh 2402 
    self._oprot.writeMessageBegin('getAlerts', TMessageType.CALL, self._seqid)
2403 
    args = getAlerts_args()
4394 rajveer 2404 
    args.type = type
4444 rajveer 2405 
    args.warehouseId = warehouseId
4394 rajveer 2406 
    args.status = status
2407 
    args.timestamp = timestamp
3064 chandransh 2408 
    args.write(self._oprot)
2409 
    self._oprot.writeMessageEnd()
2410 
    self._oprot.trans.flush()
2411 
 
2412 
  def recv_getAlerts(self, ):
2413 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2414 
    if mtype == TMessageType.EXCEPTION:
2415 
      x = TApplicationException()
2416 
      x.read(self._iprot)
2417 
      self._iprot.readMessageEnd()
2418 
      raise x
2419 
    result = getAlerts_result()
2420 
    result.read(self._iprot)
2421 
    self._iprot.readMessageEnd()
3431 rajveer 2422 
    if result.success is not None:
3064 chandransh 2423 
      return result.success
2424 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAlerts failed: unknown result");
2425 
 
4444 rajveer 2426 
  def addAlert(self, type, warehouseId, description):
3064 chandransh 2427 
    """
2428 
    Parameters:
2429 
     - type
4444 rajveer 2430 
     - warehouseId
4394 rajveer 2431 
     - description
3064 chandransh 2432 
    """
4444 rajveer 2433 
    self.send_addAlert(type, warehouseId, description)
4394 rajveer 2434 
    self.recv_addAlert()
3064 chandransh 2435 
 
4444 rajveer 2436 
  def send_addAlert(self, type, warehouseId, description):
4394 rajveer 2437 
    self._oprot.writeMessageBegin('addAlert', TMessageType.CALL, self._seqid)
2438 
    args = addAlert_args()
3064 chandransh 2439 
    args.type = type
4444 rajveer 2440 
    args.warehouseId = warehouseId
4394 rajveer 2441 
    args.description = description
3064 chandransh 2442 
    args.write(self._oprot)
2443 
    self._oprot.writeMessageEnd()
2444 
    self._oprot.trans.flush()
2445 
 
4394 rajveer 2446 
  def recv_addAlert(self, ):
3064 chandransh 2447 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2448 
    if mtype == TMessageType.EXCEPTION:
2449 
      x = TApplicationException()
2450 
      x.read(self._iprot)
2451 
      self._iprot.readMessageEnd()
2452 
      raise x
4394 rajveer 2453 
    result = addAlert_result()
3064 chandransh 2454 
    result.read(self._iprot)
2455 
    self._iprot.readMessageEnd()
2456 
    return
2457 
 
4444 rajveer 2458 
  def markAlertsAsSeen(self, warehouseId):
2459 
    """
2460 
    Parameters:
2461 
     - warehouseId
2462 
    """
2463 
    self.send_markAlertsAsSeen(warehouseId)
2464 
    self.recv_markAlertsAsSeen()
2465 
 
2466 
  def send_markAlertsAsSeen(self, warehouseId):
2467 
    self._oprot.writeMessageBegin('markAlertsAsSeen', TMessageType.CALL, self._seqid)
2468 
    args = markAlertsAsSeen_args()
2469 
    args.warehouseId = warehouseId
2470 
    args.write(self._oprot)
2471 
    self._oprot.writeMessageEnd()
2472 
    self._oprot.trans.flush()
2473 
 
2474 
  def recv_markAlertsAsSeen(self, ):
2475 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2476 
    if mtype == TMessageType.EXCEPTION:
2477 
      x = TApplicationException()
2478 
      x.read(self._iprot)
2479 
      self._iprot.readMessageEnd()
2480 
      raise x
2481 
    result = markAlertsAsSeen_result()
2482 
    result.read(self._iprot)
2483 
    self._iprot.readMessageEnd()
2484 
    return
2485 
 
3064 chandransh 2486 
  def getValidOrderCount(self, ):
2487 
    """
2488 
    Return the number of valid orders. (OrderStatus >= OrderStatus.SUBMITTED_FOR_PROCESSING)
2489 
    """
2490 
    self.send_getValidOrderCount()
2491 
    return self.recv_getValidOrderCount()
2492 
 
2493 
  def send_getValidOrderCount(self, ):
2494 
    self._oprot.writeMessageBegin('getValidOrderCount', TMessageType.CALL, self._seqid)
2495 
    args = getValidOrderCount_args()
2496 
    args.write(self._oprot)
2497 
    self._oprot.writeMessageEnd()
2498 
    self._oprot.trans.flush()
2499 
 
2500 
  def recv_getValidOrderCount(self, ):
2501 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2502 
    if mtype == TMessageType.EXCEPTION:
2503 
      x = TApplicationException()
2504 
      x.read(self._iprot)
2505 
      self._iprot.readMessageEnd()
2506 
      raise x
2507 
    result = getValidOrderCount_result()
2508 
    result.read(self._iprot)
2509 
    self._iprot.readMessageEnd()
3431 rajveer 2510 
    if result.success is not None:
3064 chandransh 2511 
      return result.success
2512 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getValidOrderCount failed: unknown result");
2513 
 
2514 
  def getNoOfCustomersWithSuccessfulTransaction(self, ):
2515 
    """
2516 
    Returns the number of distinct customers who have done successful transactions
2517 
    """
2518 
    self.send_getNoOfCustomersWithSuccessfulTransaction()
2519 
    return self.recv_getNoOfCustomersWithSuccessfulTransaction()
2520 
 
2521 
  def send_getNoOfCustomersWithSuccessfulTransaction(self, ):
2522 
    self._oprot.writeMessageBegin('getNoOfCustomersWithSuccessfulTransaction', TMessageType.CALL, self._seqid)
2523 
    args = getNoOfCustomersWithSuccessfulTransaction_args()
2524 
    args.write(self._oprot)
2525 
    self._oprot.writeMessageEnd()
2526 
    self._oprot.trans.flush()
2527 
 
2528 
  def recv_getNoOfCustomersWithSuccessfulTransaction(self, ):
2529 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2530 
    if mtype == TMessageType.EXCEPTION:
2531 
      x = TApplicationException()
2532 
      x.read(self._iprot)
2533 
      self._iprot.readMessageEnd()
2534 
      raise x
2535 
    result = getNoOfCustomersWithSuccessfulTransaction_result()
2536 
    result.read(self._iprot)
2537 
    self._iprot.readMessageEnd()
3431 rajveer 2538 
    if result.success is not None:
3064 chandransh 2539 
      return result.success
2540 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getNoOfCustomersWithSuccessfulTransaction failed: unknown result");
2541 
 
2542 
  def getValidOrdersAmountRange(self, ):
2543 
    """
2544 
    Returns the minimum and maximum amounts of a valid order. (OrderStatus >= OrderStatus.SUBMITTED_FOR_PROCESSING)
2545 
    List contains two values, first minimum amount and second maximum amount.
2546 
    """
2547 
    self.send_getValidOrdersAmountRange()
2548 
    return self.recv_getValidOrdersAmountRange()
2549 
 
2550 
  def send_getValidOrdersAmountRange(self, ):
2551 
    self._oprot.writeMessageBegin('getValidOrdersAmountRange', TMessageType.CALL, self._seqid)
2552 
    args = getValidOrdersAmountRange_args()
2553 
    args.write(self._oprot)
2554 
    self._oprot.writeMessageEnd()
2555 
    self._oprot.trans.flush()
2556 
 
2557 
  def recv_getValidOrdersAmountRange(self, ):
2558 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2559 
    if mtype == TMessageType.EXCEPTION:
2560 
      x = TApplicationException()
2561 
      x.read(self._iprot)
2562 
      self._iprot.readMessageEnd()
2563 
      raise x
2564 
    result = getValidOrdersAmountRange_result()
2565 
    result.read(self._iprot)
2566 
    self._iprot.readMessageEnd()
3431 rajveer 2567 
    if result.success is not None:
3064 chandransh 2568 
      return result.success
2569 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getValidOrdersAmountRange failed: unknown result");
2570 
 
5874 rajveer 2571 
  def getValidOrders(self, limit, onlyStore):
3064 chandransh 2572 
    """
2573 
    Returns list of Orders in descending order by Order creation date. List is restricted to limit Orders.
2574 
    If limit is passed as 0, then all valid Orders are returned.
3431 rajveer 2575 
 
3064 chandransh 2576 
    Parameters:
2577 
     - limit
5874 rajveer 2578 
     - onlyStore
3064 chandransh 2579 
    """
5874 rajveer 2580 
    self.send_getValidOrders(limit, onlyStore)
3064 chandransh 2581 
    return self.recv_getValidOrders()
2582 
 
5874 rajveer 2583 
  def send_getValidOrders(self, limit, onlyStore):
3064 chandransh 2584 
    self._oprot.writeMessageBegin('getValidOrders', TMessageType.CALL, self._seqid)
2585 
    args = getValidOrders_args()
2586 
    args.limit = limit
5874 rajveer 2587 
    args.onlyStore = onlyStore
3064 chandransh 2588 
    args.write(self._oprot)
2589 
    self._oprot.writeMessageEnd()
2590 
    self._oprot.trans.flush()
2591 
 
2592 
  def recv_getValidOrders(self, ):
2593 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2594 
    if mtype == TMessageType.EXCEPTION:
2595 
      x = TApplicationException()
2596 
      x.read(self._iprot)
2597 
      self._iprot.readMessageEnd()
2598 
      raise x
2599 
    result = getValidOrders_result()
2600 
    result.read(self._iprot)
2601 
    self._iprot.readMessageEnd()
3431 rajveer 2602 
    if result.success is not None:
3064 chandransh 2603 
      return result.success
2604 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getValidOrders failed: unknown result");
2605 
 
1220 chandransh 2606 
  def batchOrders(self, warehouseId):
2607 
    """
2608 
    Create a batch of all the pending orders for the given warehouse.
2609 
    The returned list is orderd by created_timestamp.
2610 
    If there are no pending orders, an empty list is returned.
3431 rajveer 2611 
 
1220 chandransh 2612 
    Parameters:
2613 
     - warehouseId
2614 
    """
2615 
    self.send_batchOrders(warehouseId)
2616 
    return self.recv_batchOrders()
2617 
 
2618 
  def send_batchOrders(self, warehouseId):
2619 
    self._oprot.writeMessageBegin('batchOrders', TMessageType.CALL, self._seqid)
2620 
    args = batchOrders_args()
2621 
    args.warehouseId = warehouseId
2622 
    args.write(self._oprot)
2623 
    self._oprot.writeMessageEnd()
2624 
    self._oprot.trans.flush()
2625 
 
2626 
  def recv_batchOrders(self, ):
2627 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2628 
    if mtype == TMessageType.EXCEPTION:
2629 
      x = TApplicationException()
2630 
      x.read(self._iprot)
2631 
      self._iprot.readMessageEnd()
2632 
      raise x
2633 
    result = batchOrders_result()
2634 
    result.read(self._iprot)
2635 
    self._iprot.readMessageEnd()
3431 rajveer 2636 
    if result.success is not None:
1220 chandransh 2637 
      return result.success
3431 rajveer 2638 
    if result.ex is not None:
1220 chandransh 2639 
      raise result.ex
2640 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "batchOrders failed: unknown result");
2641 
 
1208 chandransh 2642 
  def markOrderAsOutOfStock(self, orderId):
2643 
    """
2644 
    Mark the given order as out of stock. Throws an exception if the order with the given Id couldn't be found.
3431 rajveer 2645 
 
1208 chandransh 2646 
    Parameters:
2647 
     - orderId
2648 
    """
2649 
    self.send_markOrderAsOutOfStock(orderId)
2650 
    return self.recv_markOrderAsOutOfStock()
2651 
 
2652 
  def send_markOrderAsOutOfStock(self, orderId):
2653 
    self._oprot.writeMessageBegin('markOrderAsOutOfStock', TMessageType.CALL, self._seqid)
2654 
    args = markOrderAsOutOfStock_args()
2655 
    args.orderId = orderId
2656 
    args.write(self._oprot)
2657 
    self._oprot.writeMessageEnd()
2658 
    self._oprot.trans.flush()
2659 
 
2660 
  def recv_markOrderAsOutOfStock(self, ):
2661 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2662 
    if mtype == TMessageType.EXCEPTION:
2663 
      x = TApplicationException()
2664 
      x.read(self._iprot)
2665 
      self._iprot.readMessageEnd()
2666 
      raise x
2667 
    result = markOrderAsOutOfStock_result()
2668 
    result.read(self._iprot)
2669 
    self._iprot.readMessageEnd()
3431 rajveer 2670 
    if result.success is not None:
1208 chandransh 2671 
      return result.success
3431 rajveer 2672 
    if result.ex is not None:
1208 chandransh 2673 
      raise result.ex
2674 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderAsOutOfStock failed: unknown result");
2675 
 
3064 chandransh 2676 
  def verifyOrder(self, orderId):
759 chandransh 2677 
    """
3064 chandransh 2678 
    Marks the given order as SUBMITTED_FOR_PROCESSING and updates the verified
2679 
    timestamp. It is intended to be used for COD orders but can be harmlessly
2680 
    used for all other orders as well.
2681 
    Throws an exception if no such order exists.
3431 rajveer 2682 
 
759 chandransh 2683 
    Parameters:
3064 chandransh 2684 
     - orderId
759 chandransh 2685 
    """
3064 chandransh 2686 
    self.send_verifyOrder(orderId)
2687 
    return self.recv_verifyOrder()
759 chandransh 2688 
 
3064 chandransh 2689 
  def send_verifyOrder(self, orderId):
2690 
    self._oprot.writeMessageBegin('verifyOrder', TMessageType.CALL, self._seqid)
2691 
    args = verifyOrder_args()
2692 
    args.orderId = orderId
759 chandransh 2693 
    args.write(self._oprot)
2694 
    self._oprot.writeMessageEnd()
2695 
    self._oprot.trans.flush()
2696 
 
3064 chandransh 2697 
  def recv_verifyOrder(self, ):
759 chandransh 2698 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2699 
    if mtype == TMessageType.EXCEPTION:
2700 
      x = TApplicationException()
2701 
      x.read(self._iprot)
2702 
      self._iprot.readMessageEnd()
2703 
      raise x
3064 chandransh 2704 
    result = verifyOrder_result()
759 chandransh 2705 
    result.read(self._iprot)
2706 
    self._iprot.readMessageEnd()
3431 rajveer 2707 
    if result.success is not None:
759 chandransh 2708 
      return result.success
3431 rajveer 2709 
    if result.ex is not None:
759 chandransh 2710 
      raise result.ex
3064 chandransh 2711 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "verifyOrder failed: unknown result");
759 chandransh 2712 
 
3064 chandransh 2713 
  def acceptOrder(self, orderId):
1113 chandransh 2714 
    """
3064 chandransh 2715 
    Marks the given order as ACCEPTED and updates the accepted timestamp. If the
2716 
    given order is not a COD order, it also captures the payment if the same has
2717 
    not been captured.
2718 
    Throws an exception if no such order exists.
3431 rajveer 2719 
 
1113 chandransh 2720 
    Parameters:
3064 chandransh 2721 
     - orderId
1113 chandransh 2722 
    """
3064 chandransh 2723 
    self.send_acceptOrder(orderId)
2724 
    return self.recv_acceptOrder()
1113 chandransh 2725 
 
3064 chandransh 2726 
  def send_acceptOrder(self, orderId):
2727 
    self._oprot.writeMessageBegin('acceptOrder', TMessageType.CALL, self._seqid)
2728 
    args = acceptOrder_args()
2729 
    args.orderId = orderId
1113 chandransh 2730 
    args.write(self._oprot)
2731 
    self._oprot.writeMessageEnd()
2732 
    self._oprot.trans.flush()
2733 
 
3064 chandransh 2734 
  def recv_acceptOrder(self, ):
1113 chandransh 2735 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2736 
    if mtype == TMessageType.EXCEPTION:
2737 
      x = TApplicationException()
2738 
      x.read(self._iprot)
2739 
      self._iprot.readMessageEnd()
2740 
      raise x
3064 chandransh 2741 
    result = acceptOrder_result()
1113 chandransh 2742 
    result.read(self._iprot)
2743 
    self._iprot.readMessageEnd()
3431 rajveer 2744 
    if result.success is not None:
1113 chandransh 2745 
      return result.success
3431 rajveer 2746 
    if result.ex is not None:
1113 chandransh 2747 
      raise result.ex
3064 chandransh 2748 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "acceptOrder failed: unknown result");
1113 chandransh 2749 
 
5110 mandeep.dh 2750 
  def addBillingDetails(self, orderId, invoice_number, serialNumber, itemNumber, billed_by, jacketNumber, billingType, fulfilmentWarehouseId, authorize):
1132 chandransh 2751 
    """
3064 chandransh 2752 
    Add billing details such as the bill number and the biller to the Order.
4658 mandeep.dh 2753 
    Adds jacket number, item number and Serial no. to the order. Doesn't update
4283 anupam.sin 2754 
    the IMEI no. if a -1 is supplied.
2755 
    Also, it generates an invoice number for the order, marks the order as
2756 
    BILLED and sets the billing timestamp.
2757 
    Returns false if it doesn't find the order with the given ID.
3431 rajveer 2758 
 
1135 chandransh 2759 
    Parameters:
3064 chandransh 2760 
     - orderId
2761 
     - invoice_number
4658 mandeep.dh 2762 
     - serialNumber
4283 anupam.sin 2763 
     - itemNumber
3064 chandransh 2764 
     - billed_by
4264 rajveer 2765 
     - jacketNumber
4283 anupam.sin 2766 
     - billingType
5110 mandeep.dh 2767 
     - fulfilmentWarehouseId
4763 rajveer 2768 
     - authorize
1135 chandransh 2769 
    """
5110 mandeep.dh 2770 
    self.send_addBillingDetails(orderId, invoice_number, serialNumber, itemNumber, billed_by, jacketNumber, billingType, fulfilmentWarehouseId, authorize)
3064 chandransh 2771 
    return self.recv_addBillingDetails()
1135 chandransh 2772 
 
5110 mandeep.dh 2773 
  def send_addBillingDetails(self, orderId, invoice_number, serialNumber, itemNumber, billed_by, jacketNumber, billingType, fulfilmentWarehouseId, authorize):
3064 chandransh 2774 
    self._oprot.writeMessageBegin('addBillingDetails', TMessageType.CALL, self._seqid)
2775 
    args = addBillingDetails_args()
2776 
    args.orderId = orderId
2777 
    args.invoice_number = invoice_number
4658 mandeep.dh 2778 
    args.serialNumber = serialNumber
4283 anupam.sin 2779 
    args.itemNumber = itemNumber
3064 chandransh 2780 
    args.billed_by = billed_by
4264 rajveer 2781 
    args.jacketNumber = jacketNumber
4283 anupam.sin 2782 
    args.billingType = billingType
5110 mandeep.dh 2783 
    args.fulfilmentWarehouseId = fulfilmentWarehouseId
4763 rajveer 2784 
    args.authorize = authorize
1135 chandransh 2785 
    args.write(self._oprot)
2786 
    self._oprot.writeMessageEnd()
2787 
    self._oprot.trans.flush()
2788 
 
3064 chandransh 2789 
  def recv_addBillingDetails(self, ):
1135 chandransh 2790 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2791 
    if mtype == TMessageType.EXCEPTION:
2792 
      x = TApplicationException()
2793 
      x.read(self._iprot)
2794 
      self._iprot.readMessageEnd()
2795 
      raise x
3064 chandransh 2796 
    result = addBillingDetails_result()
1135 chandransh 2797 
    result.read(self._iprot)
2798 
    self._iprot.readMessageEnd()
3431 rajveer 2799 
    if result.success is not None:
3064 chandransh 2800 
      return result.success
3431 rajveer 2801 
    if result.ex is not None:
1135 chandransh 2802 
      raise result.ex
3064 chandransh 2803 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addBillingDetails failed: unknown result");
1135 chandransh 2804 
 
6756 amar.kumar 2805 
  def addInvoiceNumber(self, orderId, invoiceNumber, color, serialNumber, itemNumber):
4579 rajveer 2806 
    """
2807 
    Add the invoice number to the order.
2808 
 
2809 
    Parameters:
2810 
     - orderId
2811 
     - invoiceNumber
4763 rajveer 2812 
     - color
6756 amar.kumar 2813 
     - serialNumber
2814 
     - itemNumber
4579 rajveer 2815 
    """
6756 amar.kumar 2816 
    self.send_addInvoiceNumber(orderId, invoiceNumber, color, serialNumber, itemNumber)
4579 rajveer 2817 
    self.recv_addInvoiceNumber()
2818 
 
6756 amar.kumar 2819 
  def send_addInvoiceNumber(self, orderId, invoiceNumber, color, serialNumber, itemNumber):
4579 rajveer 2820 
    self._oprot.writeMessageBegin('addInvoiceNumber', TMessageType.CALL, self._seqid)
2821 
    args = addInvoiceNumber_args()
2822 
    args.orderId = orderId
2823 
    args.invoiceNumber = invoiceNumber
4763 rajveer 2824 
    args.color = color
6756 amar.kumar 2825 
    args.serialNumber = serialNumber
2826 
    args.itemNumber = itemNumber
4579 rajveer 2827 
    args.write(self._oprot)
2828 
    self._oprot.writeMessageEnd()
2829 
    self._oprot.trans.flush()
2830 
 
2831 
  def recv_addInvoiceNumber(self, ):
2832 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2833 
    if mtype == TMessageType.EXCEPTION:
2834 
      x = TApplicationException()
2835 
      x.read(self._iprot)
2836 
      self._iprot.readMessageEnd()
2837 
      raise x
2838 
    result = addInvoiceNumber_result()
2839 
    result.read(self._iprot)
2840 
    self._iprot.readMessageEnd()
2841 
    if result.ex is not None:
2842 
      raise result.ex
2843 
    return
2844 
 
4910 phani.kuma 2845 
  def markOrdersAsShippedFromWarehouse(self, warehouseId, providerId, cod, orderIds):
1408 ankur.sing 2846 
    """
3064 chandransh 2847 
    Depending on the third parameter, marks either all prepaid or all cod orders BILLED by the
4910 phani.kuma 2848 
    given warehouse and were picked up by the given provider as SHIPPED_FROM_WH.
3431 rajveer 2849 
 
1408 ankur.sing 2850 
    Parameters:
3064 chandransh 2851 
     - warehouseId
1408 ankur.sing 2852 
     - providerId
3064 chandransh 2853 
     - cod
4910 phani.kuma 2854 
     - orderIds
1408 ankur.sing 2855 
    """
4910 phani.kuma 2856 
    self.send_markOrdersAsShippedFromWarehouse(warehouseId, providerId, cod, orderIds)
2857 
    return self.recv_markOrdersAsShippedFromWarehouse()
1408 ankur.sing 2858 
 
4910 phani.kuma 2859 
  def send_markOrdersAsShippedFromWarehouse(self, warehouseId, providerId, cod, orderIds):
2860 
    self._oprot.writeMessageBegin('markOrdersAsShippedFromWarehouse', TMessageType.CALL, self._seqid)
2861 
    args = markOrdersAsShippedFromWarehouse_args()
3064 chandransh 2862 
    args.warehouseId = warehouseId
1408 ankur.sing 2863 
    args.providerId = providerId
3064 chandransh 2864 
    args.cod = cod
4910 phani.kuma 2865 
    args.orderIds = orderIds
1408 ankur.sing 2866 
    args.write(self._oprot)
2867 
    self._oprot.writeMessageEnd()
2868 
    self._oprot.trans.flush()
2869 
 
4910 phani.kuma 2870 
  def recv_markOrdersAsShippedFromWarehouse(self, ):
1408 ankur.sing 2871 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2872 
    if mtype == TMessageType.EXCEPTION:
2873 
      x = TApplicationException()
2874 
      x.read(self._iprot)
2875 
      self._iprot.readMessageEnd()
2876 
      raise x
4910 phani.kuma 2877 
    result = markOrdersAsShippedFromWarehouse_result()
1408 ankur.sing 2878 
    result.read(self._iprot)
2879 
    self._iprot.readMessageEnd()
3431 rajveer 2880 
    if result.success is not None:
1408 ankur.sing 2881 
      return result.success
3431 rajveer 2882 
    if result.ex is not None:
3064 chandransh 2883 
      raise result.ex
4910 phani.kuma 2884 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrdersAsShippedFromWarehouse failed: unknown result");
1408 ankur.sing 2885 
 
5713 rajveer 2886 
  def markOrdersAsReturnedFromStore(self, providerId, orderIds, awbs):
5676 rajveer 2887 
    """
2888 
    Parameters:
2889 
     - providerId
2890 
     - orderIds
5713 rajveer 2891 
     - awbs
5676 rajveer 2892 
    """
5713 rajveer 2893 
    self.send_markOrdersAsReturnedFromStore(providerId, orderIds, awbs)
5676 rajveer 2894 
    return self.recv_markOrdersAsReturnedFromStore()
2895 
 
5713 rajveer 2896 
  def send_markOrdersAsReturnedFromStore(self, providerId, orderIds, awbs):
5676 rajveer 2897 
    self._oprot.writeMessageBegin('markOrdersAsReturnedFromStore', TMessageType.CALL, self._seqid)
2898 
    args = markOrdersAsReturnedFromStore_args()
2899 
    args.providerId = providerId
2900 
    args.orderIds = orderIds
5713 rajveer 2901 
    args.awbs = awbs
5676 rajveer 2902 
    args.write(self._oprot)
2903 
    self._oprot.writeMessageEnd()
2904 
    self._oprot.trans.flush()
2905 
 
2906 
  def recv_markOrdersAsReturnedFromStore(self, ):
2907 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2908 
    if mtype == TMessageType.EXCEPTION:
2909 
      x = TApplicationException()
2910 
      x.read(self._iprot)
2911 
      self._iprot.readMessageEnd()
2912 
      raise x
2913 
    result = markOrdersAsReturnedFromStore_result()
2914 
    result.read(self._iprot)
2915 
    self._iprot.readMessageEnd()
2916 
    if result.success is not None:
2917 
      return result.success
2918 
    if result.ex is not None:
2919 
      raise result.ex
2920 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrdersAsReturnedFromStore failed: unknown result");
2921 
 
4910 phani.kuma 2922 
  def markOrdersAsPickedUp(self, providerId, pickupDetails):
4410 rajveer 2923 
    """
4910 phani.kuma 2924 
    Marks all SHIPPED_FROM_WH orders of the previous day for a provider as SHIPPED_TO_LOGISTICS.
2925 
    Raises an exception if we encounter report for an AWB number that we did not ship.
4410 rajveer 2926 
 
2927 
    Parameters:
2928 
     - providerId
4910 phani.kuma 2929 
     - pickupDetails
4410 rajveer 2930 
    """
4910 phani.kuma 2931 
    self.send_markOrdersAsPickedUp(providerId, pickupDetails)
2932 
    self.recv_markOrdersAsPickedUp()
4410 rajveer 2933 
 
4910 phani.kuma 2934 
  def send_markOrdersAsPickedUp(self, providerId, pickupDetails):
2935 
    self._oprot.writeMessageBegin('markOrdersAsPickedUp', TMessageType.CALL, self._seqid)
2936 
    args = markOrdersAsPickedUp_args()
4410 rajveer 2937 
    args.providerId = providerId
4910 phani.kuma 2938 
    args.pickupDetails = pickupDetails
4410 rajveer 2939 
    args.write(self._oprot)
2940 
    self._oprot.writeMessageEnd()
2941 
    self._oprot.trans.flush()
2942 
 
4910 phani.kuma 2943 
  def recv_markOrdersAsPickedUp(self, ):
4410 rajveer 2944 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2945 
    if mtype == TMessageType.EXCEPTION:
2946 
      x = TApplicationException()
2947 
      x.read(self._iprot)
2948 
      self._iprot.readMessageEnd()
2949 
      raise x
4910 phani.kuma 2950 
    result = markOrdersAsPickedUp_result()
4410 rajveer 2951 
    result.read(self._iprot)
2952 
    self._iprot.readMessageEnd()
2953 
    if result.ex is not None:
2954 
      raise result.ex
4910 phani.kuma 2955 
    return
4410 rajveer 2956 
 
4910 phani.kuma 2957 
  def getOrdersNotPickedUp(self, providerId):
94 ashish 2958 
    """
3064 chandransh 2959 
    Returns a list of orders that were shipped from warehouse but did not appear in the pick-up report.
3431 rajveer 2960 
 
94 ashish 2961 
    Parameters:
3064 chandransh 2962 
     - providerId
304 ashish 2963 
    """
4910 phani.kuma 2964 
    self.send_getOrdersNotPickedUp(providerId)
2965 
    return self.recv_getOrdersNotPickedUp()
94 ashish 2966 
 
4910 phani.kuma 2967 
  def send_getOrdersNotPickedUp(self, providerId):
2968 
    self._oprot.writeMessageBegin('getOrdersNotPickedUp', TMessageType.CALL, self._seqid)
2969 
    args = getOrdersNotPickedUp_args()
3064 chandransh 2970 
    args.providerId = providerId
304 ashish 2971 
    args.write(self._oprot)
2972 
    self._oprot.writeMessageEnd()
2973 
    self._oprot.trans.flush()
2974 
 
4910 phani.kuma 2975 
  def recv_getOrdersNotPickedUp(self, ):
304 ashish 2976 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2977 
    if mtype == TMessageType.EXCEPTION:
2978 
      x = TApplicationException()
2979 
      x.read(self._iprot)
2980 
      self._iprot.readMessageEnd()
2981 
      raise x
4910 phani.kuma 2982 
    result = getOrdersNotPickedUp_result()
304 ashish 2983 
    result.read(self._iprot)
2984 
    self._iprot.readMessageEnd()
3431 rajveer 2985 
    if result.success is not None:
304 ashish 2986 
      return result.success
4910 phani.kuma 2987 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersNotPickedUp failed: unknown result");
304 ashish 2988 
 
3064 chandransh 2989 
  def markOrdersAsDelivered(self, providerId, deliveredOrders):
304 ashish 2990 
    """
3064 chandransh 2991 
    Marks all orders with AWBs in the given map as delivered. Also sets the delivery timestamp and
2992 
    the name of the receiver.
2993 
    Raises an exception if we encounter report for an AWB number that we did not ship.
3431 rajveer 2994 
 
304 ashish 2995 
    Parameters:
3064 chandransh 2996 
     - providerId
2997 
     - deliveredOrders
304 ashish 2998 
    """
3064 chandransh 2999 
    self.send_markOrdersAsDelivered(providerId, deliveredOrders)
3000 
    self.recv_markOrdersAsDelivered()
304 ashish 3001 
 
3064 chandransh 3002 
  def send_markOrdersAsDelivered(self, providerId, deliveredOrders):
3003 
    self._oprot.writeMessageBegin('markOrdersAsDelivered', TMessageType.CALL, self._seqid)
3004 
    args = markOrdersAsDelivered_args()
3005 
    args.providerId = providerId
3006 
    args.deliveredOrders = deliveredOrders
304 ashish 3007 
    args.write(self._oprot)
3008 
    self._oprot.writeMessageEnd()
3009 
    self._oprot.trans.flush()
3010 
 
3064 chandransh 3011 
  def recv_markOrdersAsDelivered(self, ):
304 ashish 3012 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3013 
    if mtype == TMessageType.EXCEPTION:
3014 
      x = TApplicationException()
3015 
      x.read(self._iprot)
3016 
      self._iprot.readMessageEnd()
3017 
      raise x
3064 chandransh 3018 
    result = markOrdersAsDelivered_result()
304 ashish 3019 
    result.read(self._iprot)
3020 
    self._iprot.readMessageEnd()
3431 rajveer 3021 
    if result.ex is not None:
3064 chandransh 3022 
      raise result.ex
304 ashish 3023 
    return
3024 
 
4910 phani.kuma 3025 
  def markAsRTOrders(self, providerId, returnedOrders):
1596 ankur.sing 3026 
    """
4910 phani.kuma 3027 
    Mark all orders with AWBs in the given map as RTO. Also sets the delivery timestamp.
3064 chandransh 3028 
    Raises an exception if we encounter report for an AWB number that we did not ship.
3431 rajveer 3029 
 
3064 chandransh 3030 
    Parameters:
3031 
     - providerId
3032 
     - returnedOrders
1596 ankur.sing 3033 
    """
4910 phani.kuma 3034 
    self.send_markAsRTOrders(providerId, returnedOrders)
3035 
    self.recv_markAsRTOrders()
304 ashish 3036 
 
4910 phani.kuma 3037 
  def send_markAsRTOrders(self, providerId, returnedOrders):
3038 
    self._oprot.writeMessageBegin('markAsRTOrders', TMessageType.CALL, self._seqid)
3039 
    args = markAsRTOrders_args()
3064 chandransh 3040 
    args.providerId = providerId
3041 
    args.returnedOrders = returnedOrders
1596 ankur.sing 3042 
    args.write(self._oprot)
3043 
    self._oprot.writeMessageEnd()
3044 
    self._oprot.trans.flush()
3045 
 
4910 phani.kuma 3046 
  def recv_markAsRTOrders(self, ):
1596 ankur.sing 3047 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3048 
    if mtype == TMessageType.EXCEPTION:
3049 
      x = TApplicationException()
3050 
      x.read(self._iprot)
3051 
      self._iprot.readMessageEnd()
3052 
      raise x
4910 phani.kuma 3053 
    result = markAsRTOrders_result()
1596 ankur.sing 3054 
    result.read(self._iprot)
3055 
    self._iprot.readMessageEnd()
3431 rajveer 3056 
    if result.ex is not None:
3064 chandransh 3057 
      raise result.ex
3058 
    return
1596 ankur.sing 3059 
 
4910 phani.kuma 3060 
  def getRTOrders(self, providerId):
3061 
    """
3062 
    Returns a list of orders that were returned by courier.
3063 
 
3064 
    Parameters:
3065 
     - providerId
3066 
    """
3067 
    self.send_getRTOrders(providerId)
3068 
    return self.recv_getRTOrders()
3069 
 
3070 
  def send_getRTOrders(self, providerId):
3071 
    self._oprot.writeMessageBegin('getRTOrders', TMessageType.CALL, self._seqid)
3072 
    args = getRTOrders_args()
3073 
    args.providerId = providerId
3074 
    args.write(self._oprot)
3075 
    self._oprot.writeMessageEnd()
3076 
    self._oprot.trans.flush()
3077 
 
3078 
  def recv_getRTOrders(self, ):
3079 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3080 
    if mtype == TMessageType.EXCEPTION:
3081 
      x = TApplicationException()
3082 
      x.read(self._iprot)
3083 
      self._iprot.readMessageEnd()
3084 
      raise x
3085 
    result = getRTOrders_result()
3086 
    result.read(self._iprot)
3087 
    self._iprot.readMessageEnd()
3088 
    if result.success is not None:
3089 
      return result.success
3090 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getRTOrders failed: unknown result");
3091 
 
3064 chandransh 3092 
  def updateNonDeliveryReason(self, providerId, undeliveredOrders):
1627 ankur.sing 3093 
    """
3064 chandransh 3094 
    Update the status description of orders whose AWB numbers are keys of the Map.
3431 rajveer 3095 
 
3064 chandransh 3096 
    Parameters:
3097 
     - providerId
3098 
     - undeliveredOrders
1627 ankur.sing 3099 
    """
3064 chandransh 3100 
    self.send_updateNonDeliveryReason(providerId, undeliveredOrders)
4910 phani.kuma 3101 
    self.recv_updateNonDeliveryReason()
1596 ankur.sing 3102 
 
3064 chandransh 3103 
  def send_updateNonDeliveryReason(self, providerId, undeliveredOrders):
3104 
    self._oprot.writeMessageBegin('updateNonDeliveryReason', TMessageType.CALL, self._seqid)
3105 
    args = updateNonDeliveryReason_args()
3106 
    args.providerId = providerId
3107 
    args.undeliveredOrders = undeliveredOrders
1627 ankur.sing 3108 
    args.write(self._oprot)
3109 
    self._oprot.writeMessageEnd()
3110 
    self._oprot.trans.flush()
3111 
 
3064 chandransh 3112 
  def recv_updateNonDeliveryReason(self, ):
1627 ankur.sing 3113 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3114 
    if mtype == TMessageType.EXCEPTION:
3115 
      x = TApplicationException()
3116 
      x.read(self._iprot)
3117 
      self._iprot.readMessageEnd()
3118 
      raise x
3064 chandransh 3119 
    result = updateNonDeliveryReason_result()
1627 ankur.sing 3120 
    result.read(self._iprot)
3121 
    self._iprot.readMessageEnd()
4910 phani.kuma 3122 
    if result.ex is not None:
3123 
      raise result.ex
3124 
    return
3125 
 
3126 
  def getNonDeliveredOrdersbyCourier(self, providerId):
3127 
    """
3128 
    Returns a list of orders that were picked up or shipped four days ago but did not get delivered.
3129 
 
3130 
    Parameters:
3131 
     - providerId
3132 
    """
3133 
    self.send_getNonDeliveredOrdersbyCourier(providerId)
3134 
    return self.recv_getNonDeliveredOrdersbyCourier()
3135 
 
3136 
  def send_getNonDeliveredOrdersbyCourier(self, providerId):
3137 
    self._oprot.writeMessageBegin('getNonDeliveredOrdersbyCourier', TMessageType.CALL, self._seqid)
3138 
    args = getNonDeliveredOrdersbyCourier_args()
3139 
    args.providerId = providerId
3140 
    args.write(self._oprot)
3141 
    self._oprot.writeMessageEnd()
3142 
    self._oprot.trans.flush()
3143 
 
3144 
  def recv_getNonDeliveredOrdersbyCourier(self, ):
3145 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3146 
    if mtype == TMessageType.EXCEPTION:
3147 
      x = TApplicationException()
3148 
      x.read(self._iprot)
3149 
      self._iprot.readMessageEnd()
3150 
      raise x
3151 
    result = getNonDeliveredOrdersbyCourier_result()
3152 
    result.read(self._iprot)
3153 
    self._iprot.readMessageEnd()
4581 phani.kuma 3154 
    if result.success is not None:
3155 
      return result.success
4910 phani.kuma 3156 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getNonDeliveredOrdersbyCourier failed: unknown result");
3157 
 
3158 
  def markOrdersAsLocalConnected(self, providerId, local_connected_orders):
3159 
    """
3160 
    Mark all orders with AWBs in the given map as local connected. Also sets the local connected timestamp.
3161 
 
3162 
    Parameters:
3163 
     - providerId
3164 
     - local_connected_orders
3165 
    """
3166 
    self.send_markOrdersAsLocalConnected(providerId, local_connected_orders)
3167 
    self.recv_markOrdersAsLocalConnected()
3168 
 
3169 
  def send_markOrdersAsLocalConnected(self, providerId, local_connected_orders):
3170 
    self._oprot.writeMessageBegin('markOrdersAsLocalConnected', TMessageType.CALL, self._seqid)
3171 
    args = markOrdersAsLocalConnected_args()
3172 
    args.providerId = providerId
3173 
    args.local_connected_orders = local_connected_orders
3174 
    args.write(self._oprot)
3175 
    self._oprot.writeMessageEnd()
3176 
    self._oprot.trans.flush()
3177 
 
3178 
  def recv_markOrdersAsLocalConnected(self, ):
3179 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3180 
    if mtype == TMessageType.EXCEPTION:
3181 
      x = TApplicationException()
3182 
      x.read(self._iprot)
3183 
      self._iprot.readMessageEnd()
3184 
      raise x
3185 
    result = markOrdersAsLocalConnected_result()
3186 
    result.read(self._iprot)
3187 
    self._iprot.readMessageEnd()
3431 rajveer 3188 
    if result.ex is not None:
3064 chandransh 3189 
      raise result.ex
4910 phani.kuma 3190 
    return
1627 ankur.sing 3191 
 
4910 phani.kuma 3192 
  def getOrdersNotLocalConnected(self, providerId):
3193 
    """
3194 
    Returns a list of orders that were picked up or shipped but pending local connection.
3195 
 
3196 
    Parameters:
3197 
     - providerId
3198 
    """
3199 
    self.send_getOrdersNotLocalConnected(providerId)
3200 
    return self.recv_getOrdersNotLocalConnected()
3201 
 
3202 
  def send_getOrdersNotLocalConnected(self, providerId):
3203 
    self._oprot.writeMessageBegin('getOrdersNotLocalConnected', TMessageType.CALL, self._seqid)
3204 
    args = getOrdersNotLocalConnected_args()
3205 
    args.providerId = providerId
3206 
    args.write(self._oprot)
3207 
    self._oprot.writeMessageEnd()
3208 
    self._oprot.trans.flush()
3209 
 
3210 
  def recv_getOrdersNotLocalConnected(self, ):
3211 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3212 
    if mtype == TMessageType.EXCEPTION:
3213 
      x = TApplicationException()
3214 
      x.read(self._iprot)
3215 
      self._iprot.readMessageEnd()
3216 
      raise x
3217 
    result = getOrdersNotLocalConnected_result()
3218 
    result.read(self._iprot)
3219 
    self._iprot.readMessageEnd()
3220 
    if result.success is not None:
3221 
      return result.success
3222 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersNotLocalConnected failed: unknown result");
3223 
 
3224 
  def markOrdersAsDestinationCityReached(self, providerId, destination_city_reached_orders):
3225 
    """
3226 
    Mark all orders with AWBs in the given map as reached destination city. Also sets the reached destination timestamp.
3227 
 
3228 
    Parameters:
3229 
     - providerId
3230 
     - destination_city_reached_orders
3231 
    """
3232 
    self.send_markOrdersAsDestinationCityReached(providerId, destination_city_reached_orders)
3233 
    self.recv_markOrdersAsDestinationCityReached()
3234 
 
3235 
  def send_markOrdersAsDestinationCityReached(self, providerId, destination_city_reached_orders):
3236 
    self._oprot.writeMessageBegin('markOrdersAsDestinationCityReached', TMessageType.CALL, self._seqid)
3237 
    args = markOrdersAsDestinationCityReached_args()
3238 
    args.providerId = providerId
3239 
    args.destination_city_reached_orders = destination_city_reached_orders
3240 
    args.write(self._oprot)
3241 
    self._oprot.writeMessageEnd()
3242 
    self._oprot.trans.flush()
3243 
 
3244 
  def recv_markOrdersAsDestinationCityReached(self, ):
3245 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3246 
    if mtype == TMessageType.EXCEPTION:
3247 
      x = TApplicationException()
3248 
      x.read(self._iprot)
3249 
      self._iprot.readMessageEnd()
3250 
      raise x
3251 
    result = markOrdersAsDestinationCityReached_result()
3252 
    result.read(self._iprot)
3253 
    self._iprot.readMessageEnd()
3254 
    if result.ex is not None:
3255 
      raise result.ex
3256 
    return
3257 
 
3258 
  def markOrdersAsFirstDeliveryAttempted(self, providerId, first_atdl_orders):
3259 
    """
3260 
    Mark all orders with AWBs in the given map as first delivery attempt made. Also sets the first delivery attempted timestamp.
3261 
 
3262 
    Parameters:
3263 
     - providerId
3264 
     - first_atdl_orders
3265 
    """
3266 
    self.send_markOrdersAsFirstDeliveryAttempted(providerId, first_atdl_orders)
3267 
    self.recv_markOrdersAsFirstDeliveryAttempted()
3268 
 
3269 
  def send_markOrdersAsFirstDeliveryAttempted(self, providerId, first_atdl_orders):
3270 
    self._oprot.writeMessageBegin('markOrdersAsFirstDeliveryAttempted', TMessageType.CALL, self._seqid)
3271 
    args = markOrdersAsFirstDeliveryAttempted_args()
3272 
    args.providerId = providerId
3273 
    args.first_atdl_orders = first_atdl_orders
3274 
    args.write(self._oprot)
3275 
    self._oprot.writeMessageEnd()
3276 
    self._oprot.trans.flush()
3277 
 
3278 
  def recv_markOrdersAsFirstDeliveryAttempted(self, ):
3279 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3280 
    if mtype == TMessageType.EXCEPTION:
3281 
      x = TApplicationException()
3282 
      x.read(self._iprot)
3283 
      self._iprot.readMessageEnd()
3284 
      raise x
3285 
    result = markOrdersAsFirstDeliveryAttempted_result()
3286 
    result.read(self._iprot)
3287 
    self._iprot.readMessageEnd()
3288 
    if result.ex is not None:
3289 
      raise result.ex
3290 
    return
3291 
 
3064 chandransh 3292 
  def getUndeliveredOrders(self, providerId, warehouseId):
1627 ankur.sing 3293 
    """
3064 chandransh 3294 
    Returns the list of orders whose delivery time has passed but have not been
3295 
    delivered yet for the given provider and warehouse. To get a complete list of
3296 
    undelivered orders, pass them as -1.
3297 
    Returns an empty list if no such orders exist.
3431 rajveer 3298 
 
1886 ankur.sing 3299 
    Parameters:
3064 chandransh 3300 
     - providerId
3301 
     - warehouseId
1886 ankur.sing 3302 
    """
3064 chandransh 3303 
    self.send_getUndeliveredOrders(providerId, warehouseId)
3304 
    return self.recv_getUndeliveredOrders()
1627 ankur.sing 3305 
 
3064 chandransh 3306 
  def send_getUndeliveredOrders(self, providerId, warehouseId):
3307 
    self._oprot.writeMessageBegin('getUndeliveredOrders', TMessageType.CALL, self._seqid)
3308 
    args = getUndeliveredOrders_args()
3309 
    args.providerId = providerId
3310 
    args.warehouseId = warehouseId
1886 ankur.sing 3311 
    args.write(self._oprot)
3312 
    self._oprot.writeMessageEnd()
3313 
    self._oprot.trans.flush()
3314 
 
3064 chandransh 3315 
  def recv_getUndeliveredOrders(self, ):
1886 ankur.sing 3316 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3317 
    if mtype == TMessageType.EXCEPTION:
3318 
      x = TApplicationException()
3319 
      x.read(self._iprot)
3320 
      self._iprot.readMessageEnd()
3321 
      raise x
3064 chandransh 3322 
    result = getUndeliveredOrders_result()
1886 ankur.sing 3323 
    result.read(self._iprot)
3324 
    self._iprot.readMessageEnd()
3431 rajveer 3325 
    if result.success is not None:
1886 ankur.sing 3326 
      return result.success
3064 chandransh 3327 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUndeliveredOrders failed: unknown result");
1886 ankur.sing 3328 
 
4783 phani.kuma 3329 
  def getUndeliveredOrdersExpectedDeliveryDateNotMet(self, ):
3330 
    """
3331 
    Returns the list of orders whose expected delivery date has passed but have not been
3332 
    delivered yet.
3333 
    Returns an empty list if no such orders exist.
3334 
    """
3335 
    self.send_getUndeliveredOrdersExpectedDeliveryDateNotMet()
3336 
    return self.recv_getUndeliveredOrdersExpectedDeliveryDateNotMet()
3337 
 
3338 
  def send_getUndeliveredOrdersExpectedDeliveryDateNotMet(self, ):
3339 
    self._oprot.writeMessageBegin('getUndeliveredOrdersExpectedDeliveryDateNotMet', TMessageType.CALL, self._seqid)
3340 
    args = getUndeliveredOrdersExpectedDeliveryDateNotMet_args()
3341 
    args.write(self._oprot)
3342 
    self._oprot.writeMessageEnd()
3343 
    self._oprot.trans.flush()
3344 
 
3345 
  def recv_getUndeliveredOrdersExpectedDeliveryDateNotMet(self, ):
3346 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3347 
    if mtype == TMessageType.EXCEPTION:
3348 
      x = TApplicationException()
3349 
      x.read(self._iprot)
3350 
      self._iprot.readMessageEnd()
3351 
      raise x
3352 
    result = getUndeliveredOrdersExpectedDeliveryDateNotMet_result()
3353 
    result.read(self._iprot)
3354 
    self._iprot.readMessageEnd()
3355 
    if result.success is not None:
3356 
      return result.success
3357 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUndeliveredOrdersExpectedDeliveryDateNotMet failed: unknown result");
3358 
 
2536 chandransh 3359 
  def toggleDOAFlag(self, orderId):
3360 
    """
3361 
    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.
3362 
    Returns the final flag status.
3363 
    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 3364 
 
2536 chandransh 3365 
    Parameters:
3366 
     - orderId
3367 
    """
3368 
    self.send_toggleDOAFlag(orderId)
3369 
    return self.recv_toggleDOAFlag()
1886 ankur.sing 3370 
 
2536 chandransh 3371 
  def send_toggleDOAFlag(self, orderId):
3372 
    self._oprot.writeMessageBegin('toggleDOAFlag', TMessageType.CALL, self._seqid)
3373 
    args = toggleDOAFlag_args()
3374 
    args.orderId = orderId
3375 
    args.write(self._oprot)
3376 
    self._oprot.writeMessageEnd()
3377 
    self._oprot.trans.flush()
3378 
 
3379 
  def recv_toggleDOAFlag(self, ):
3380 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3381 
    if mtype == TMessageType.EXCEPTION:
3382 
      x = TApplicationException()
3383 
      x.read(self._iprot)
3384 
      self._iprot.readMessageEnd()
3385 
      raise x
3386 
    result = toggleDOAFlag_result()
3387 
    result.read(self._iprot)
3388 
    self._iprot.readMessageEnd()
3431 rajveer 3389 
    if result.success is not None:
2536 chandransh 3390 
      return result.success
3431 rajveer 3391 
    if result.ex is not None:
2536 chandransh 3392 
      raise result.ex
3393 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "toggleDOAFlag failed: unknown result");
3394 
 
4712 rajveer 3395 
  def markOrderAsDelivered(self, orderId, deliveryTimestamp, receiver):
3396 
    """
3397 
    Parameters:
3398 
     - orderId
3399 
     - deliveryTimestamp
3400 
     - receiver
3401 
    """
3402 
    self.send_markOrderAsDelivered(orderId, deliveryTimestamp, receiver)
3403 
    self.recv_markOrderAsDelivered()
3404 
 
3405 
  def send_markOrderAsDelivered(self, orderId, deliveryTimestamp, receiver):
3406 
    self._oprot.writeMessageBegin('markOrderAsDelivered', TMessageType.CALL, self._seqid)
3407 
    args = markOrderAsDelivered_args()
3408 
    args.orderId = orderId
3409 
    args.deliveryTimestamp = deliveryTimestamp
3410 
    args.receiver = receiver
3411 
    args.write(self._oprot)
3412 
    self._oprot.writeMessageEnd()
3413 
    self._oprot.trans.flush()
3414 
 
3415 
  def recv_markOrderAsDelivered(self, ):
3416 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3417 
    if mtype == TMessageType.EXCEPTION:
3418 
      x = TApplicationException()
3419 
      x.read(self._iprot)
3420 
      self._iprot.readMessageEnd()
3421 
      raise x
3422 
    result = markOrderAsDelivered_result()
3423 
    result.read(self._iprot)
3424 
    self._iprot.readMessageEnd()
3425 
    if result.ex is not None:
3426 
      raise result.ex
3427 
    return
3428 
 
5553 rajveer 3429 
  def markOrderAsReceivedAtStore(self, orderId, deliveryTimestamp):
3430 
    """
3431 
    Parameters:
3432 
     - orderId
3433 
     - deliveryTimestamp
3434 
    """
3435 
    self.send_markOrderAsReceivedAtStore(orderId, deliveryTimestamp)
3436 
    self.recv_markOrderAsReceivedAtStore()
3437 
 
3438 
  def send_markOrderAsReceivedAtStore(self, orderId, deliveryTimestamp):
3439 
    self._oprot.writeMessageBegin('markOrderAsReceivedAtStore', TMessageType.CALL, self._seqid)
3440 
    args = markOrderAsReceivedAtStore_args()
3441 
    args.orderId = orderId
3442 
    args.deliveryTimestamp = deliveryTimestamp
3443 
    args.write(self._oprot)
3444 
    self._oprot.writeMessageEnd()
3445 
    self._oprot.trans.flush()
3446 
 
3447 
  def recv_markOrderAsReceivedAtStore(self, ):
3448 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3449 
    if mtype == TMessageType.EXCEPTION:
3450 
      x = TApplicationException()
3451 
      x.read(self._iprot)
3452 
      self._iprot.readMessageEnd()
3453 
      raise x
3454 
    result = markOrderAsReceivedAtStore_result()
3455 
    result.read(self._iprot)
3456 
    self._iprot.readMessageEnd()
3457 
    if result.ex is not None:
3458 
      raise result.ex
3459 
    return
3460 
 
4454 rajveer 3461 
  def markOrderDoaRequestReceived(self, orderId):
3462 
    """
3463 
    Once user raise the request for a DOA, order status will be changed from DELVIERY_SUCCESS to DOA_REQUEST_RECEIVED
3464 
 
3465 
    Parameters:
3466 
     - orderId
3467 
    """
3468 
    self.send_markOrderDoaRequestReceived(orderId)
3469 
    return self.recv_markOrderDoaRequestReceived()
3470 
 
3471 
  def send_markOrderDoaRequestReceived(self, orderId):
3472 
    self._oprot.writeMessageBegin('markOrderDoaRequestReceived', TMessageType.CALL, self._seqid)
3473 
    args = markOrderDoaRequestReceived_args()
3474 
    args.orderId = orderId
3475 
    args.write(self._oprot)
3476 
    self._oprot.writeMessageEnd()
3477 
    self._oprot.trans.flush()
3478 
 
3479 
  def recv_markOrderDoaRequestReceived(self, ):
3480 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3481 
    if mtype == TMessageType.EXCEPTION:
3482 
      x = TApplicationException()
3483 
      x.read(self._iprot)
3484 
      self._iprot.readMessageEnd()
3485 
      raise x
3486 
    result = markOrderDoaRequestReceived_result()
3487 
    result.read(self._iprot)
3488 
    self._iprot.readMessageEnd()
3489 
    if result.success is not None:
3490 
      return result.success
3491 
    if result.ex is not None:
3492 
      raise result.ex
3493 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderDoaRequestReceived failed: unknown result");
3494 
 
3495 
  def markOrderDoaRequestAuthorized(self, orderId, isAuthorized):
3496 
    """
3497 
    CRM person can authorize or deny the request reised by customer. If he authorizes order will change from DOA_REQUEST_RECEIVED
3498 
    to DOA_REQUEST_AUTHORIZED. If he denies, status will be changed back to DELVIERY_SUCCESS.
3499 
 
3500 
    Parameters:
3501 
     - orderId
3502 
     - isAuthorized
3503 
    """
3504 
    self.send_markOrderDoaRequestAuthorized(orderId, isAuthorized)
3505 
    return self.recv_markOrderDoaRequestAuthorized()
3506 
 
3507 
  def send_markOrderDoaRequestAuthorized(self, orderId, isAuthorized):
3508 
    self._oprot.writeMessageBegin('markOrderDoaRequestAuthorized', TMessageType.CALL, self._seqid)
3509 
    args = markOrderDoaRequestAuthorized_args()
3510 
    args.orderId = orderId
3511 
    args.isAuthorized = isAuthorized
3512 
    args.write(self._oprot)
3513 
    self._oprot.writeMessageEnd()
3514 
    self._oprot.trans.flush()
3515 
 
3516 
  def recv_markOrderDoaRequestAuthorized(self, ):
3517 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3518 
    if mtype == TMessageType.EXCEPTION:
3519 
      x = TApplicationException()
3520 
      x.read(self._iprot)
3521 
      self._iprot.readMessageEnd()
3522 
      raise x
3523 
    result = markOrderDoaRequestAuthorized_result()
3524 
    result.read(self._iprot)
3525 
    self._iprot.readMessageEnd()
3526 
    if result.success is not None:
3527 
      return result.success
3528 
    if result.ex is not None:
3529 
      raise result.ex
3530 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderDoaRequestAuthorized failed: unknown result");
3531 
 
4488 rajveer 3532 
  def markOrderReturnRequestReceived(self, orderId):
3533 
    """
3534 
    Once user raise the request for a RET, order status will be changed from DELVIERY_SUCCESS to RET_REQUEST_RECEIVED
3535 
 
3536 
    Parameters:
3537 
     - orderId
3538 
    """
3539 
    self.send_markOrderReturnRequestReceived(orderId)
3540 
    return self.recv_markOrderReturnRequestReceived()
3541 
 
3542 
  def send_markOrderReturnRequestReceived(self, orderId):
3543 
    self._oprot.writeMessageBegin('markOrderReturnRequestReceived', TMessageType.CALL, self._seqid)
3544 
    args = markOrderReturnRequestReceived_args()
3545 
    args.orderId = orderId
3546 
    args.write(self._oprot)
3547 
    self._oprot.writeMessageEnd()
3548 
    self._oprot.trans.flush()
3549 
 
3550 
  def recv_markOrderReturnRequestReceived(self, ):
3551 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3552 
    if mtype == TMessageType.EXCEPTION:
3553 
      x = TApplicationException()
3554 
      x.read(self._iprot)
3555 
      self._iprot.readMessageEnd()
3556 
      raise x
3557 
    result = markOrderReturnRequestReceived_result()
3558 
    result.read(self._iprot)
3559 
    self._iprot.readMessageEnd()
3560 
    if result.success is not None:
3561 
      return result.success
3562 
    if result.ex is not None:
3563 
      raise result.ex
3564 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderReturnRequestReceived failed: unknown result");
3565 
 
3566 
  def markOrderReturnRequestAuthorized(self, orderId, isAuthorized):
3567 
    """
3568 
    CRM person can authorize or deny the request reised by customer. If he authorizes order will change from RET_REQUEST_RECEIVED
3569 
    to RET_REQUEST_AUTHORIZED. If he denies, status will be changed back to DELVIERY_SUCCESS.
3570 
 
3571 
    Parameters:
3572 
     - orderId
3573 
     - isAuthorized
3574 
    """
3575 
    self.send_markOrderReturnRequestAuthorized(orderId, isAuthorized)
3576 
    return self.recv_markOrderReturnRequestAuthorized()
3577 
 
3578 
  def send_markOrderReturnRequestAuthorized(self, orderId, isAuthorized):
3579 
    self._oprot.writeMessageBegin('markOrderReturnRequestAuthorized', TMessageType.CALL, self._seqid)
3580 
    args = markOrderReturnRequestAuthorized_args()
3581 
    args.orderId = orderId
3582 
    args.isAuthorized = isAuthorized
3583 
    args.write(self._oprot)
3584 
    self._oprot.writeMessageEnd()
3585 
    self._oprot.trans.flush()
3586 
 
3587 
  def recv_markOrderReturnRequestAuthorized(self, ):
3588 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3589 
    if mtype == TMessageType.EXCEPTION:
3590 
      x = TApplicationException()
3591 
      x.read(self._iprot)
3592 
      self._iprot.readMessageEnd()
3593 
      raise x
3594 
    result = markOrderReturnRequestAuthorized_result()
3595 
    result.read(self._iprot)
3596 
    self._iprot.readMessageEnd()
3597 
    if result.success is not None:
3598 
      return result.success
3599 
    if result.ex is not None:
3600 
      raise result.ex
3601 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderReturnRequestAuthorized failed: unknown result");
3602 
 
4579 rajveer 3603 
  def requestPickupNumber(self, orderId, providerId):
2536 chandransh 3604 
    """
3605 
    Sends out an email to the account manager of the original courier provider used to ship the order.
4452 rajveer 3606 
    If the order status was DELIVERY_SUCCESS, it is changed to be DOA_PICKUP_REQUEST_RAISED.
3607 
    If the order status was DOA_PICKUP_REQUEST_RAISED, it is left unchanged.
2536 chandransh 3608 
    For any other status, it returns false.
3609 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 3610 
 
2536 chandransh 3611 
    Parameters:
3612 
     - orderId
4579 rajveer 3613 
     - providerId
2536 chandransh 3614 
    """
4579 rajveer 3615 
    self.send_requestPickupNumber(orderId, providerId)
2536 chandransh 3616 
    return self.recv_requestPickupNumber()
3617 
 
4579 rajveer 3618 
  def send_requestPickupNumber(self, orderId, providerId):
2536 chandransh 3619 
    self._oprot.writeMessageBegin('requestPickupNumber', TMessageType.CALL, self._seqid)
3620 
    args = requestPickupNumber_args()
3621 
    args.orderId = orderId
4579 rajveer 3622 
    args.providerId = providerId
2536 chandransh 3623 
    args.write(self._oprot)
3624 
    self._oprot.writeMessageEnd()
3625 
    self._oprot.trans.flush()
3626 
 
3627 
  def recv_requestPickupNumber(self, ):
3628 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3629 
    if mtype == TMessageType.EXCEPTION:
3630 
      x = TApplicationException()
3631 
      x.read(self._iprot)
3632 
      self._iprot.readMessageEnd()
3633 
      raise x
3634 
    result = requestPickupNumber_result()
3635 
    result.read(self._iprot)
3636 
    self._iprot.readMessageEnd()
3431 rajveer 3637 
    if result.success is not None:
2536 chandransh 3638 
      return result.success
3431 rajveer 3639 
    if result.ex is not None:
2536 chandransh 3640 
      raise result.ex
3641 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "requestPickupNumber failed: unknown result");
3642 
 
4602 rajveer 3643 
  def authorizePickup(self, orderId, pickupNumber, providerId):
2536 chandransh 3644 
    """
4452 rajveer 3645 
    If the order status is DOA_PICKUP_REQUEST_RAISED, it does the following
2536 chandransh 3646 
    	1. Sends out an email to the customer with the dispatch advice that he has to print as an attachment.
3647 
    	2. Changes order status to be DOA_PICKUP_AUTHORIZED.
3648 
    	3. Returns true
2591 chandransh 3649 
    If the order is in any other status, it returns false.
2536 chandransh 3650 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 3651 
 
2536 chandransh 3652 
    Parameters:
3653 
     - orderId
3654 
     - pickupNumber
4602 rajveer 3655 
     - providerId
2536 chandransh 3656 
    """
4602 rajveer 3657 
    self.send_authorizePickup(orderId, pickupNumber, providerId)
2536 chandransh 3658 
    return self.recv_authorizePickup()
3659 
 
4602 rajveer 3660 
  def send_authorizePickup(self, orderId, pickupNumber, providerId):
2536 chandransh 3661 
    self._oprot.writeMessageBegin('authorizePickup', TMessageType.CALL, self._seqid)
3662 
    args = authorizePickup_args()
3663 
    args.orderId = orderId
3664 
    args.pickupNumber = pickupNumber
4602 rajveer 3665 
    args.providerId = providerId
2536 chandransh 3666 
    args.write(self._oprot)
3667 
    self._oprot.writeMessageEnd()
3668 
    self._oprot.trans.flush()
3669 
 
3670 
  def recv_authorizePickup(self, ):
3671 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3672 
    if mtype == TMessageType.EXCEPTION:
3673 
      x = TApplicationException()
3674 
      x.read(self._iprot)
3675 
      self._iprot.readMessageEnd()
3676 
      raise x
3677 
    result = authorizePickup_result()
3678 
    result.read(self._iprot)
3679 
    self._iprot.readMessageEnd()
3431 rajveer 3680 
    if result.success is not None:
2536 chandransh 3681 
      return result.success
3431 rajveer 3682 
    if result.ex is not None:
2536 chandransh 3683 
      raise result.ex
3684 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "authorizePickup failed: unknown result");
3685 
 
2764 chandransh 3686 
  def markDoasAsPickedUp(self, providerId, pickupDetails):
3687 
    """
3688 
    Marks all DOA_PICKUP_AUTHORIZED orders of the previous day for a provider as DOA_RETURN_IN_TRANSIT.
3431 rajveer 3689 
 
2764 chandransh 3690 
    Parameters:
3691 
     - providerId
3692 
     - pickupDetails
3693 
    """
3694 
    self.send_markDoasAsPickedUp(providerId, pickupDetails)
4910 phani.kuma 3695 
    self.recv_markDoasAsPickedUp()
2764 chandransh 3696 
 
3697 
  def send_markDoasAsPickedUp(self, providerId, pickupDetails):
3698 
    self._oprot.writeMessageBegin('markDoasAsPickedUp', TMessageType.CALL, self._seqid)
3699 
    args = markDoasAsPickedUp_args()
3700 
    args.providerId = providerId
3701 
    args.pickupDetails = pickupDetails
3702 
    args.write(self._oprot)
3703 
    self._oprot.writeMessageEnd()
3704 
    self._oprot.trans.flush()
3705 
 
3706 
  def recv_markDoasAsPickedUp(self, ):
3707 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3708 
    if mtype == TMessageType.EXCEPTION:
3709 
      x = TApplicationException()
3710 
      x.read(self._iprot)
3711 
      self._iprot.readMessageEnd()
3712 
      raise x
3713 
    result = markDoasAsPickedUp_result()
3714 
    result.read(self._iprot)
3715 
    self._iprot.readMessageEnd()
4910 phani.kuma 3716 
    return
3717 
 
3718 
  def getDoasNotPickedUp(self, providerId):
3719 
    """
3720 
    Returns a list of orders that were authorized for pickup but did not appear in the pick-up report.
3721 
 
3722 
    Parameters:
3723 
     - providerId
3724 
    """
3725 
    self.send_getDoasNotPickedUp(providerId)
3726 
    return self.recv_getDoasNotPickedUp()
3727 
 
3728 
  def send_getDoasNotPickedUp(self, providerId):
3729 
    self._oprot.writeMessageBegin('getDoasNotPickedUp', TMessageType.CALL, self._seqid)
3730 
    args = getDoasNotPickedUp_args()
3731 
    args.providerId = providerId
3732 
    args.write(self._oprot)
3733 
    self._oprot.writeMessageEnd()
3734 
    self._oprot.trans.flush()
3735 
 
3736 
  def recv_getDoasNotPickedUp(self, ):
3737 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3738 
    if mtype == TMessageType.EXCEPTION:
3739 
      x = TApplicationException()
3740 
      x.read(self._iprot)
3741 
      self._iprot.readMessageEnd()
3742 
      raise x
3743 
    result = getDoasNotPickedUp_result()
3744 
    result.read(self._iprot)
3745 
    self._iprot.readMessageEnd()
3431 rajveer 3746 
    if result.success is not None:
2764 chandransh 3747 
      return result.success
4910 phani.kuma 3748 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getDoasNotPickedUp failed: unknown result");
2764 chandransh 3749 
 
4741 phani.kuma 3750 
  def markReturnOrdersAsPickedUp(self, providerId, pickupDetails):
3751 
    """
3752 
    Marks all RET_PICKUP_CONFIRMED orders of the previous day for a provider as RET_RETURN_IN_TRANSIT.
3753 
 
3754 
    Parameters:
3755 
     - providerId
3756 
     - pickupDetails
3757 
    """
3758 
    self.send_markReturnOrdersAsPickedUp(providerId, pickupDetails)
4910 phani.kuma 3759 
    self.recv_markReturnOrdersAsPickedUp()
4741 phani.kuma 3760 
 
3761 
  def send_markReturnOrdersAsPickedUp(self, providerId, pickupDetails):
3762 
    self._oprot.writeMessageBegin('markReturnOrdersAsPickedUp', TMessageType.CALL, self._seqid)
3763 
    args = markReturnOrdersAsPickedUp_args()
3764 
    args.providerId = providerId
3765 
    args.pickupDetails = pickupDetails
3766 
    args.write(self._oprot)
3767 
    self._oprot.writeMessageEnd()
3768 
    self._oprot.trans.flush()
3769 
 
3770 
  def recv_markReturnOrdersAsPickedUp(self, ):
3771 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3772 
    if mtype == TMessageType.EXCEPTION:
3773 
      x = TApplicationException()
3774 
      x.read(self._iprot)
3775 
      self._iprot.readMessageEnd()
3776 
      raise x
3777 
    result = markReturnOrdersAsPickedUp_result()
3778 
    result.read(self._iprot)
3779 
    self._iprot.readMessageEnd()
4910 phani.kuma 3780 
    return
3781 
 
3782 
  def getReturnOrdersNotPickedUp(self, providerId):
3783 
    """
3784 
    Returns a list of orders that were authorized for pickup but did not appear in the pick-up report.
3785 
 
3786 
    Parameters:
3787 
     - providerId
3788 
    """
3789 
    self.send_getReturnOrdersNotPickedUp(providerId)
3790 
    return self.recv_getReturnOrdersNotPickedUp()
3791 
 
3792 
  def send_getReturnOrdersNotPickedUp(self, providerId):
3793 
    self._oprot.writeMessageBegin('getReturnOrdersNotPickedUp', TMessageType.CALL, self._seqid)
3794 
    args = getReturnOrdersNotPickedUp_args()
3795 
    args.providerId = providerId
3796 
    args.write(self._oprot)
3797 
    self._oprot.writeMessageEnd()
3798 
    self._oprot.trans.flush()
3799 
 
3800 
  def recv_getReturnOrdersNotPickedUp(self, ):
3801 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3802 
    if mtype == TMessageType.EXCEPTION:
3803 
      x = TApplicationException()
3804 
      x.read(self._iprot)
3805 
      self._iprot.readMessageEnd()
3806 
      raise x
3807 
    result = getReturnOrdersNotPickedUp_result()
3808 
    result.read(self._iprot)
3809 
    self._iprot.readMessageEnd()
4741 phani.kuma 3810 
    if result.success is not None:
3811 
      return result.success
4910 phani.kuma 3812 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReturnOrdersNotPickedUp failed: unknown result");
4741 phani.kuma 3813 
 
4479 rajveer 3814 
  def receiveReturn(self, orderId, receiveCondition):
2591 chandransh 3815 
    """
4452 rajveer 3816 
    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 3817 
    If the order status is RTO_IN_TRANSIT, marks the order status as RTO_RECEIVED_PRESTINE and returns true.
2591 chandransh 3818 
    If the order is in any other state, it returns false.
3819 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 3820 
 
2591 chandransh 3821 
    Parameters:
3822 
     - orderId
4479 rajveer 3823 
     - receiveCondition
2591 chandransh 3824 
    """
4479 rajveer 3825 
    self.send_receiveReturn(orderId, receiveCondition)
2616 chandransh 3826 
    return self.recv_receiveReturn()
2536 chandransh 3827 
 
4479 rajveer 3828 
  def send_receiveReturn(self, orderId, receiveCondition):
2616 chandransh 3829 
    self._oprot.writeMessageBegin('receiveReturn', TMessageType.CALL, self._seqid)
3830 
    args = receiveReturn_args()
2591 chandransh 3831 
    args.orderId = orderId
4479 rajveer 3832 
    args.receiveCondition = receiveCondition
2591 chandransh 3833 
    args.write(self._oprot)
3834 
    self._oprot.writeMessageEnd()
3835 
    self._oprot.trans.flush()
3836 
 
2616 chandransh 3837 
  def recv_receiveReturn(self, ):
2591 chandransh 3838 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3839 
    if mtype == TMessageType.EXCEPTION:
3840 
      x = TApplicationException()
3841 
      x.read(self._iprot)
3842 
      self._iprot.readMessageEnd()
3843 
      raise x
2616 chandransh 3844 
    result = receiveReturn_result()
2591 chandransh 3845 
    result.read(self._iprot)
3846 
    self._iprot.readMessageEnd()
3431 rajveer 3847 
    if result.success is not None:
2591 chandransh 3848 
      return result.success
3431 rajveer 3849 
    if result.ex is not None:
2591 chandransh 3850 
      raise result.ex
2616 chandransh 3851 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "receiveReturn failed: unknown result");
2591 chandransh 3852 
 
3853 
  def validateDoa(self, orderId, isValid):
3854 
    """
4452 rajveer 3855 
    Used to validate the DOA certificate for an order in the DOA_RECEIVED_PRESTINE state. If the certificate is valid,
2616 chandransh 3856 
    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 3857 
    If the order is in any other state, it returns false.
3858 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 3859 
 
2591 chandransh 3860 
    Parameters:
3861 
     - orderId
3862 
     - isValid
3863 
    """
3864 
    self.send_validateDoa(orderId, isValid)
3865 
    return self.recv_validateDoa()
3866 
 
3867 
  def send_validateDoa(self, orderId, isValid):
3868 
    self._oprot.writeMessageBegin('validateDoa', TMessageType.CALL, self._seqid)
3869 
    args = validateDoa_args()
3870 
    args.orderId = orderId
3871 
    args.isValid = isValid
3872 
    args.write(self._oprot)
3873 
    self._oprot.writeMessageEnd()
3874 
    self._oprot.trans.flush()
3875 
 
3876 
  def recv_validateDoa(self, ):
3877 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3878 
    if mtype == TMessageType.EXCEPTION:
3879 
      x = TApplicationException()
3880 
      x.read(self._iprot)
3881 
      self._iprot.readMessageEnd()
3882 
      raise x
3883 
    result = validateDoa_result()
3884 
    result.read(self._iprot)
3885 
    self._iprot.readMessageEnd()
3431 rajveer 3886 
    if result.success is not None:
2591 chandransh 3887 
      return result.success
3431 rajveer 3888 
    if result.ex is not None:
2591 chandransh 3889 
      raise result.ex
3890 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "validateDoa failed: unknown result");
3891 
 
4495 rajveer 3892 
  def validateReturnProduct(self, orderId, isUsable):
3893 
    """
3894 
    Parameters:
3895 
     - orderId
3896 
     - isUsable
3897 
    """
3898 
    self.send_validateReturnProduct(orderId, isUsable)
3899 
    return self.recv_validateReturnProduct()
3900 
 
3901 
  def send_validateReturnProduct(self, orderId, isUsable):
3902 
    self._oprot.writeMessageBegin('validateReturnProduct', TMessageType.CALL, self._seqid)
3903 
    args = validateReturnProduct_args()
3904 
    args.orderId = orderId
3905 
    args.isUsable = isUsable
3906 
    args.write(self._oprot)
3907 
    self._oprot.writeMessageEnd()
3908 
    self._oprot.trans.flush()
3909 
 
3910 
  def recv_validateReturnProduct(self, ):
3911 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3912 
    if mtype == TMessageType.EXCEPTION:
3913 
      x = TApplicationException()
3914 
      x.read(self._iprot)
3915 
      self._iprot.readMessageEnd()
3916 
      raise x
3917 
    result = validateReturnProduct_result()
3918 
    result.read(self._iprot)
3919 
    self._iprot.readMessageEnd()
3920 
    if result.success is not None:
3921 
      return result.success
3922 
    if result.ex is not None:
3923 
      raise result.ex
3924 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "validateReturnProduct failed: unknown result");
3925 
 
2616 chandransh 3926 
  def reshipOrder(self, orderId):
3927 
    """
4484 rajveer 3928 
    If the order is in RTO_RECEIVED_PRESTINE or DOA_CERT_INVALID state, it does the following:
2616 chandransh 3929 
    	1. Creates a new order for processing in the BILLED state. All billing information is saved.
4484 rajveer 3930 
    	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 3931 
 
3932 
    If the order is in DOA_CERT_VALID state, it does the following:
3933 
    	1. Creates a new order for processing in the SUBMITTED_FOR_PROCESSING state.
3934 
    	2. Creates a return order for the warehouse executive to return the DOA material.
4452 rajveer 3935 
    	3. Marks the current order as the final DOA_VALID_RESHIPPED state.
3431 rajveer 3936 
 
2616 chandransh 3937 
    Returns the id of the newly created order.
3431 rajveer 3938 
 
2616 chandransh 3939 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 3940 
 
2616 chandransh 3941 
    Parameters:
3942 
     - orderId
3943 
    """
3944 
    self.send_reshipOrder(orderId)
3945 
    return self.recv_reshipOrder()
2591 chandransh 3946 
 
2616 chandransh 3947 
  def send_reshipOrder(self, orderId):
3948 
    self._oprot.writeMessageBegin('reshipOrder', TMessageType.CALL, self._seqid)
3949 
    args = reshipOrder_args()
3950 
    args.orderId = orderId
3951 
    args.write(self._oprot)
3952 
    self._oprot.writeMessageEnd()
3953 
    self._oprot.trans.flush()
3954 
 
3955 
  def recv_reshipOrder(self, ):
3956 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3957 
    if mtype == TMessageType.EXCEPTION:
3958 
      x = TApplicationException()
3959 
      x.read(self._iprot)
3960 
      self._iprot.readMessageEnd()
3961 
      raise x
3962 
    result = reshipOrder_result()
3963 
    result.read(self._iprot)
3964 
    self._iprot.readMessageEnd()
3431 rajveer 3965 
    if result.success is not None:
2616 chandransh 3966 
      return result.success
3431 rajveer 3967 
    if result.ex is not None:
2616 chandransh 3968 
      raise result.ex
3969 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "reshipOrder failed: unknown result");
3970 
 
3226 chandransh 3971 
  def refundOrder(self, orderId, refundedBy, reason):
2616 chandransh 3972 
    """
4484 rajveer 3973 
    If the order is in RTO_RECEIVED_PRESTINE, DOA_CERT_VALID or DOA_CERT_INVALID state, it does the following:
2616 chandransh 3974 
    	1. Creates a refund request for batch processing.
3975 
    	2. Creates a return order for the warehouse executive to return the shipped material.
4484 rajveer 3976 
    	3. Marks the current order as RTO_REFUNDED, DOA_VALID_REFUNDED or DOA_INVALID_REFUNDED final states.
3431 rajveer 3977 
 
2616 chandransh 3978 
    If the order is in SUBMITTED_FOR_PROCESSING or INVENTORY_LOW state, it does the following:
3979 
    	1. Creates a refund request for batch processing.
3226 chandransh 3980 
    	2. Cancels the reservation of the item in the warehouse.
3981 
    	3. Marks the current order as the REFUNDED final state.
3431 rajveer 3982 
 
3226 chandransh 3983 
    For all COD orders, if the order is in INIT, SUBMITTED_FOR_PROCESSING or INVENTORY_LOW state, it does the following:
3984 
    	1. Cancels the reservation of the item in the warehouse.
3985 
    	2. Marks the current order as CANCELED.
3986 
 
3987 
    In all cases, it updates the reason for cancellation or refund and the person who performed the action.
3988 
 
2616 chandransh 3989 
    Returns True if it is successful, False otherwise.
3431 rajveer 3990 
 
2616 chandransh 3991 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 3992 
 
2616 chandransh 3993 
    Parameters:
3994 
     - orderId
3226 chandransh 3995 
     - refundedBy
3996 
     - reason
2616 chandransh 3997 
    """
3226 chandransh 3998 
    self.send_refundOrder(orderId, refundedBy, reason)
2616 chandransh 3999 
    return self.recv_refundOrder()
4000 
 
3226 chandransh 4001 
  def send_refundOrder(self, orderId, refundedBy, reason):
2616 chandransh 4002 
    self._oprot.writeMessageBegin('refundOrder', TMessageType.CALL, self._seqid)
4003 
    args = refundOrder_args()
4004 
    args.orderId = orderId
3226 chandransh 4005 
    args.refundedBy = refundedBy
4006 
    args.reason = reason
2616 chandransh 4007 
    args.write(self._oprot)
4008 
    self._oprot.writeMessageEnd()
4009 
    self._oprot.trans.flush()
4010 
 
4011 
  def recv_refundOrder(self, ):
4012 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4013 
    if mtype == TMessageType.EXCEPTION:
4014 
      x = TApplicationException()
4015 
      x.read(self._iprot)
4016 
      self._iprot.readMessageEnd()
4017 
      raise x
4018 
    result = refundOrder_result()
4019 
    result.read(self._iprot)
4020 
    self._iprot.readMessageEnd()
3431 rajveer 4021 
    if result.success is not None:
2616 chandransh 4022 
      return result.success
3431 rajveer 4023 
    if result.ex is not None:
2616 chandransh 4024 
      raise result.ex
4025 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "refundOrder failed: unknown result");
4026 
 
2690 chandransh 4027 
  def getReturnOrders(self, warehouseId, fromDate, toDate):
4028 
    """
4029 
    Get all return orders created between the from and to dates for the given warehouse.
4030 
    Ignores the warehouse if it is passed as -1.
3431 rajveer 4031 
 
2690 chandransh 4032 
    Parameters:
4033 
     - warehouseId
4034 
     - fromDate
4035 
     - toDate
4036 
    """
4037 
    self.send_getReturnOrders(warehouseId, fromDate, toDate)
4038 
    return self.recv_getReturnOrders()
2616 chandransh 4039 
 
2690 chandransh 4040 
  def send_getReturnOrders(self, warehouseId, fromDate, toDate):
4041 
    self._oprot.writeMessageBegin('getReturnOrders', TMessageType.CALL, self._seqid)
4042 
    args = getReturnOrders_args()
4043 
    args.warehouseId = warehouseId
4044 
    args.fromDate = fromDate
4045 
    args.toDate = toDate
4046 
    args.write(self._oprot)
4047 
    self._oprot.writeMessageEnd()
4048 
    self._oprot.trans.flush()
4049 
 
4050 
  def recv_getReturnOrders(self, ):
4051 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4052 
    if mtype == TMessageType.EXCEPTION:
4053 
      x = TApplicationException()
4054 
      x.read(self._iprot)
4055 
      self._iprot.readMessageEnd()
4056 
      raise x
4057 
    result = getReturnOrders_result()
4058 
    result.read(self._iprot)
4059 
    self._iprot.readMessageEnd()
3431 rajveer 4060 
    if result.success is not None:
2690 chandransh 4061 
      return result.success
4062 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReturnOrders failed: unknown result");
4063 
 
5481 phani.kuma 4064 
  def getAllReturnOrders(self, onlyNotProcessed, fromDate, toDate):
4065 
    """
4066 
    Get all return orders created between the from and to dates.
4067 
 
4068 
    Parameters:
4069 
     - onlyNotProcessed
4070 
     - fromDate
4071 
     - toDate
4072 
    """
4073 
    self.send_getAllReturnOrders(onlyNotProcessed, fromDate, toDate)
4074 
    return self.recv_getAllReturnOrders()
4075 
 
4076 
  def send_getAllReturnOrders(self, onlyNotProcessed, fromDate, toDate):
4077 
    self._oprot.writeMessageBegin('getAllReturnOrders', TMessageType.CALL, self._seqid)
4078 
    args = getAllReturnOrders_args()
4079 
    args.onlyNotProcessed = onlyNotProcessed
4080 
    args.fromDate = fromDate
4081 
    args.toDate = toDate
4082 
    args.write(self._oprot)
4083 
    self._oprot.writeMessageEnd()
4084 
    self._oprot.trans.flush()
4085 
 
4086 
  def recv_getAllReturnOrders(self, ):
4087 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4088 
    if mtype == TMessageType.EXCEPTION:
4089 
      x = TApplicationException()
4090 
      x.read(self._iprot)
4091 
      self._iprot.readMessageEnd()
4092 
      raise x
4093 
    result = getAllReturnOrders_result()
4094 
    result.read(self._iprot)
4095 
    self._iprot.readMessageEnd()
4096 
    if result.success is not None:
4097 
      return result.success
4098 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllReturnOrders failed: unknown result");
4099 
 
2700 chandransh 4100 
  def getReturnOrder(self, id):
4101 
    """
4102 
    Returns the ReturnOrder corresponding to the given id.
4103 
    Throws an exception if the return order with the given id couldn't be found.
3431 rajveer 4104 
 
2700 chandransh 4105 
    Parameters:
4106 
     - id
4107 
    """
4108 
    self.send_getReturnOrder(id)
4109 
    return self.recv_getReturnOrder()
4110 
 
4111 
  def send_getReturnOrder(self, id):
4112 
    self._oprot.writeMessageBegin('getReturnOrder', TMessageType.CALL, self._seqid)
4113 
    args = getReturnOrder_args()
4114 
    args.id = id
4115 
    args.write(self._oprot)
4116 
    self._oprot.writeMessageEnd()
4117 
    self._oprot.trans.flush()
4118 
 
4119 
  def recv_getReturnOrder(self, ):
4120 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4121 
    if mtype == TMessageType.EXCEPTION:
4122 
      x = TApplicationException()
4123 
      x.read(self._iprot)
4124 
      self._iprot.readMessageEnd()
4125 
      raise x
4126 
    result = getReturnOrder_result()
4127 
    result.read(self._iprot)
4128 
    self._iprot.readMessageEnd()
3431 rajveer 4129 
    if result.success is not None:
2700 chandransh 4130 
      return result.success
3431 rajveer 4131 
    if result.ex is not None:
2700 chandransh 4132 
      raise result.ex
4133 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReturnOrder failed: unknown result");
4134 
 
2690 chandransh 4135 
  def processReturn(self, returnOrderId):
4136 
    """
4137 
    Marks the return order with the given id as processed. Raises an exception if no such return order exists.
3431 rajveer 4138 
 
2690 chandransh 4139 
    Parameters:
4140 
     - returnOrderId
4141 
    """
4142 
    self.send_processReturn(returnOrderId)
4143 
    self.recv_processReturn()
4144 
 
4145 
  def send_processReturn(self, returnOrderId):
4146 
    self._oprot.writeMessageBegin('processReturn', TMessageType.CALL, self._seqid)
4147 
    args = processReturn_args()
4148 
    args.returnOrderId = returnOrderId
4149 
    args.write(self._oprot)
4150 
    self._oprot.writeMessageEnd()
4151 
    self._oprot.trans.flush()
4152 
 
4153 
  def recv_processReturn(self, ):
4154 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4155 
    if mtype == TMessageType.EXCEPTION:
4156 
      x = TApplicationException()
4157 
      x.read(self._iprot)
4158 
      self._iprot.readMessageEnd()
4159 
      raise x
4160 
    result = processReturn_result()
4161 
    result.read(self._iprot)
4162 
    self._iprot.readMessageEnd()
3431 rajveer 4163 
    if result.ex is not None:
2690 chandransh 4164 
      raise result.ex
4165 
    return
4166 
 
3451 chandransh 4167 
  def updateWeight(self, orderId, weight):
4168 
    """
4169 
    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 4170 
 
3451 chandransh 4171 
    Parameters:
4172 
     - orderId
4173 
     - weight
4174 
    """
4175 
    self.send_updateWeight(orderId, weight)
4176 
    return self.recv_updateWeight()
4177 
 
4178 
  def send_updateWeight(self, orderId, weight):
4179 
    self._oprot.writeMessageBegin('updateWeight', TMessageType.CALL, self._seqid)
4180 
    args = updateWeight_args()
4181 
    args.orderId = orderId
4182 
    args.weight = weight
4183 
    args.write(self._oprot)
4184 
    self._oprot.writeMessageEnd()
4185 
    self._oprot.trans.flush()
4186 
 
4187 
  def recv_updateWeight(self, ):
4188 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4189 
    if mtype == TMessageType.EXCEPTION:
4190 
      x = TApplicationException()
4191 
      x.read(self._iprot)
4192 
      self._iprot.readMessageEnd()
4193 
      raise x
4194 
    result = updateWeight_result()
4195 
    result.read(self._iprot)
4196 
    self._iprot.readMessageEnd()
4197 
    if result.success is not None:
4198 
      return result.success
4199 
    if result.ex is not None:
4200 
      raise result.ex
4201 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updateWeight failed: unknown result");
4202 
 
3469 chandransh 4203 
  def changeItem(self, orderId, itemId):
4204 
    """
4205 
    Change the item to be shipped for this order. Also adjusts the reservation in the inventory accordingly.
4206 
    Currently, it also ensures that only a different color of the given item is shipped.
3451 chandransh 4207 
 
3469 chandransh 4208 
    Parameters:
4209 
     - orderId
4210 
     - itemId
4211 
    """
4212 
    self.send_changeItem(orderId, itemId)
4213 
    return self.recv_changeItem()
4214 
 
4215 
  def send_changeItem(self, orderId, itemId):
4216 
    self._oprot.writeMessageBegin('changeItem', TMessageType.CALL, self._seqid)
4217 
    args = changeItem_args()
4218 
    args.orderId = orderId
4219 
    args.itemId = itemId
4220 
    args.write(self._oprot)
4221 
    self._oprot.writeMessageEnd()
4222 
    self._oprot.trans.flush()
4223 
 
4224 
  def recv_changeItem(self, ):
4225 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4226 
    if mtype == TMessageType.EXCEPTION:
4227 
      x = TApplicationException()
4228 
      x.read(self._iprot)
4229 
      self._iprot.readMessageEnd()
4230 
      raise x
4231 
    result = changeItem_result()
4232 
    result.read(self._iprot)
4233 
    self._iprot.readMessageEnd()
4234 
    if result.success is not None:
4235 
      return result.success
4236 
    if result.ex is not None:
4237 
      raise result.ex
4238 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "changeItem failed: unknown result");
4239 
 
4240 
  def shiftToWarehouse(self, orderId, warehouseId):
4241 
    """
4242 
    Moves the given order to the given warehouse. Also adjusts the inventory reservations accordingly.
4243 
 
4244 
    Parameters:
4245 
     - orderId
4246 
     - warehouseId
4247 
    """
4248 
    self.send_shiftToWarehouse(orderId, warehouseId)
4249 
    return self.recv_shiftToWarehouse()
4250 
 
4251 
  def send_shiftToWarehouse(self, orderId, warehouseId):
4252 
    self._oprot.writeMessageBegin('shiftToWarehouse', TMessageType.CALL, self._seqid)
4253 
    args = shiftToWarehouse_args()
4254 
    args.orderId = orderId
4255 
    args.warehouseId = warehouseId
4256 
    args.write(self._oprot)
4257 
    self._oprot.writeMessageEnd()
4258 
    self._oprot.trans.flush()
4259 
 
4260 
  def recv_shiftToWarehouse(self, ):
4261 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4262 
    if mtype == TMessageType.EXCEPTION:
4263 
      x = TApplicationException()
4264 
      x.read(self._iprot)
4265 
      self._iprot.readMessageEnd()
4266 
      raise x
4267 
    result = shiftToWarehouse_result()
4268 
    result.read(self._iprot)
4269 
    self._iprot.readMessageEnd()
4270 
    if result.success is not None:
4271 
      return result.success
4272 
    if result.ex is not None:
4273 
      raise result.ex
4274 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "shiftToWarehouse failed: unknown result");
4275 
 
4647 rajveer 4276 
  def addDelayReason(self, orderId, delayReason, furtherDelay, delayReasonText):
3553 chandransh 4277 
    """
4278 
    Adds the given delay reason to the given order.
3986 chandransh 4279 
    Increases the expected delivery time of the given order by the given no. of days.
3553 chandransh 4280 
    Raises an exception if no order with the given id can be found.
3469 chandransh 4281 
 
3553 chandransh 4282 
    Parameters:
4283 
     - orderId
4284 
     - delayReason
3986 chandransh 4285 
     - furtherDelay
4647 rajveer 4286 
     - delayReasonText
3553 chandransh 4287 
    """
4647 rajveer 4288 
    self.send_addDelayReason(orderId, delayReason, furtherDelay, delayReasonText)
3553 chandransh 4289 
    return self.recv_addDelayReason()
4290 
 
4647 rajveer 4291 
  def send_addDelayReason(self, orderId, delayReason, furtherDelay, delayReasonText):
3553 chandransh 4292 
    self._oprot.writeMessageBegin('addDelayReason', TMessageType.CALL, self._seqid)
4293 
    args = addDelayReason_args()
4294 
    args.orderId = orderId
4295 
    args.delayReason = delayReason
3986 chandransh 4296 
    args.furtherDelay = furtherDelay
4647 rajveer 4297 
    args.delayReasonText = delayReasonText
3553 chandransh 4298 
    args.write(self._oprot)
4299 
    self._oprot.writeMessageEnd()
4300 
    self._oprot.trans.flush()
4301 
 
4302 
  def recv_addDelayReason(self, ):
4303 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4304 
    if mtype == TMessageType.EXCEPTION:
4305 
      x = TApplicationException()
4306 
      x.read(self._iprot)
4307 
      self._iprot.readMessageEnd()
4308 
      raise x
4309 
    result = addDelayReason_result()
4310 
    result.read(self._iprot)
4311 
    self._iprot.readMessageEnd()
4312 
    if result.success is not None:
4313 
      return result.success
4314 
    if result.ex is not None:
4315 
      raise result.ex
4316 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addDelayReason failed: unknown result");
4317 
 
3956 chandransh 4318 
  def reconcileCodCollection(self, collectedAmountMap, xferBy, xferTxnId, xferDate):
4319 
    """
4320 
    Marks the COD orders with given AWB nos. as having been processed.
4321 
    Updates the captured amount for the corresponding payment.
3553 chandransh 4322 
 
3956 chandransh 4323 
    Returns a map of AWBs which were not processed and the associated reason. An AWB is not processed if:
4324 
    1. There is no order corresponding to an AWB number.
4325 
    2. The captured amount for a payment exceeds the total payment.
4326 
    3. The order corresponding to an AWB no. is in a state prior to DELIVERY_SUCCESS.
4327 
 
4328 
    Parameters:
4329 
     - collectedAmountMap
4330 
     - xferBy
4331 
     - xferTxnId
4332 
     - xferDate
4333 
    """
4334 
    self.send_reconcileCodCollection(collectedAmountMap, xferBy, xferTxnId, xferDate)
4335 
    return self.recv_reconcileCodCollection()
4336 
 
4337 
  def send_reconcileCodCollection(self, collectedAmountMap, xferBy, xferTxnId, xferDate):
4338 
    self._oprot.writeMessageBegin('reconcileCodCollection', TMessageType.CALL, self._seqid)
4339 
    args = reconcileCodCollection_args()
4340 
    args.collectedAmountMap = collectedAmountMap
4341 
    args.xferBy = xferBy
4342 
    args.xferTxnId = xferTxnId
4343 
    args.xferDate = xferDate
4344 
    args.write(self._oprot)
4345 
    self._oprot.writeMessageEnd()
4346 
    self._oprot.trans.flush()
4347 
 
4348 
  def recv_reconcileCodCollection(self, ):
4349 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4350 
    if mtype == TMessageType.EXCEPTION:
4351 
      x = TApplicationException()
4352 
      x.read(self._iprot)
4353 
      self._iprot.readMessageEnd()
4354 
      raise x
4355 
    result = reconcileCodCollection_result()
4356 
    result.read(self._iprot)
4357 
    self._iprot.readMessageEnd()
4358 
    if result.success is not None:
4359 
      return result.success
4360 
    if result.ex is not None:
4361 
      raise result.ex
4362 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "reconcileCodCollection failed: unknown result");
4363 
 
4008 mandeep.dh 4364 
  def getTransactionsRequiringExtraProcessing(self, category):
4365 
    """
4065 mandeep.dh 4366 
    Returns the list of transaction ids that require some extra processing and
4008 mandeep.dh 4367 
    which belong to a particular category. This is currently used by CRM
4065 mandeep.dh 4368 
    application. If no such transaction ids are present, it returns an empty list.
3956 chandransh 4369 
 
4008 mandeep.dh 4370 
    Parameters:
4371 
     - category
4372 
    """
4373 
    self.send_getTransactionsRequiringExtraProcessing(category)
4374 
    return self.recv_getTransactionsRequiringExtraProcessing()
4375 
 
4376 
  def send_getTransactionsRequiringExtraProcessing(self, category):
4377 
    self._oprot.writeMessageBegin('getTransactionsRequiringExtraProcessing', TMessageType.CALL, self._seqid)
4378 
    args = getTransactionsRequiringExtraProcessing_args()
4379 
    args.category = category
4380 
    args.write(self._oprot)
4381 
    self._oprot.writeMessageEnd()
4382 
    self._oprot.trans.flush()
4383 
 
4384 
  def recv_getTransactionsRequiringExtraProcessing(self, ):
4385 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4386 
    if mtype == TMessageType.EXCEPTION:
4387 
      x = TApplicationException()
4388 
      x.read(self._iprot)
4389 
      self._iprot.readMessageEnd()
4390 
      raise x
4391 
    result = getTransactionsRequiringExtraProcessing_result()
4392 
    result.read(self._iprot)
4393 
    self._iprot.readMessageEnd()
4394 
    if result.success is not None:
4395 
      return result.success
4396 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransactionsRequiringExtraProcessing failed: unknown result");
4397 
 
4398 
  def markTransactionAsProcessed(self, transactionId, category):
4399 
    """
4400 
    Marks a particular transaction as processed for a particular cateogory.
4065 mandeep.dh 4401 
    It essentially deletes the transaction id record for a particular
4402 
    processing type category (if present) from DB.
4403 
    This is currently used by CRM application.
4008 mandeep.dh 4404 
 
4405 
    Parameters:
4406 
     - transactionId
4407 
     - category
4408 
    """
4409 
    self.send_markTransactionAsProcessed(transactionId, category)
4410 
    self.recv_markTransactionAsProcessed()
4411 
 
4412 
  def send_markTransactionAsProcessed(self, transactionId, category):
4413 
    self._oprot.writeMessageBegin('markTransactionAsProcessed', TMessageType.CALL, self._seqid)
4414 
    args = markTransactionAsProcessed_args()
4415 
    args.transactionId = transactionId
4416 
    args.category = category
4417 
    args.write(self._oprot)
4418 
    self._oprot.writeMessageEnd()
4419 
    self._oprot.trans.flush()
4420 
 
4421 
  def recv_markTransactionAsProcessed(self, ):
4422 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4423 
    if mtype == TMessageType.EXCEPTION:
4424 
      x = TApplicationException()
4425 
      x.read(self._iprot)
4426 
      self._iprot.readMessageEnd()
4427 
      raise x
4428 
    result = markTransactionAsProcessed_result()
4429 
    result.read(self._iprot)
4430 
    self._iprot.readMessageEnd()
4431 
    return
4432 
 
4018 chandransh 4433 
  def getItemWiseRiskyOrdersCount(self, ):
4434 
    """
4435 
    Returns a map containing the number of risky orders keyed by item id. A risky order
4436 
    is defined as one whose shipping date is about to expire.
4437 
    """
4438 
    self.send_getItemWiseRiskyOrdersCount()
4439 
    return self.recv_getItemWiseRiskyOrdersCount()
4008 mandeep.dh 4440 
 
4018 chandransh 4441 
  def send_getItemWiseRiskyOrdersCount(self, ):
4442 
    self._oprot.writeMessageBegin('getItemWiseRiskyOrdersCount', TMessageType.CALL, self._seqid)
4443 
    args = getItemWiseRiskyOrdersCount_args()
4444 
    args.write(self._oprot)
4445 
    self._oprot.writeMessageEnd()
4446 
    self._oprot.trans.flush()
4447 
 
4448 
  def recv_getItemWiseRiskyOrdersCount(self, ):
4449 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4450 
    if mtype == TMessageType.EXCEPTION:
4451 
      x = TApplicationException()
4452 
      x.read(self._iprot)
4453 
      self._iprot.readMessageEnd()
4454 
      raise x
4455 
    result = getItemWiseRiskyOrdersCount_result()
4456 
    result.read(self._iprot)
4457 
    self._iprot.readMessageEnd()
4458 
    if result.success is not None:
4459 
      return result.success
4460 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItemWiseRiskyOrdersCount failed: unknown result");
4461 
 
4295 varun.gupt 4462 
  def getOrdersForItemIds(self, itemIds):
4463 
    """
4464 
    Returns a list of all orders which have items with given id
4465 
 
4466 
    Parameters:
4467 
     - itemIds
4468 
    """
4469 
    self.send_getOrdersForItemIds(itemIds)
4470 
    return self.recv_getOrdersForItemIds()
4471 
 
4472 
  def send_getOrdersForItemIds(self, itemIds):
4473 
    self._oprot.writeMessageBegin('getOrdersForItemIds', TMessageType.CALL, self._seqid)
4474 
    args = getOrdersForItemIds_args()
4475 
    args.itemIds = itemIds
4476 
    args.write(self._oprot)
4477 
    self._oprot.writeMessageEnd()
4478 
    self._oprot.trans.flush()
4479 
 
4480 
  def recv_getOrdersForItemIds(self, ):
4481 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4482 
    if mtype == TMessageType.EXCEPTION:
4483 
      x = TApplicationException()
4484 
      x.read(self._iprot)
4485 
      self._iprot.readMessageEnd()
4486 
      raise x
4487 
    result = getOrdersForItemIds_result()
4488 
    result.read(self._iprot)
4489 
    self._iprot.readMessageEnd()
4490 
    if result.success is not None:
4491 
      return result.success
4492 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersForItemIds failed: unknown result");
4493 
 
4247 rajveer 4494 
  def markOrderCancellationRequestReceived(self, orderId):
4495 
    """
4496 
    Mark order as cancellation request received. If customer sends request of cancellation of
4497 
    a particular order, this method will be called. It will just change status of the order
4498 
    depending on its current status. It also records the previous status, so that we can move
4499 
    back to that status if cancellation request is denied.
4018 chandransh 4500 
 
4247 rajveer 4501 
    Parameters:
4502 
     - orderId
4503 
    """
4504 
    self.send_markOrderCancellationRequestReceived(orderId)
4505 
    self.recv_markOrderCancellationRequestReceived()
4506 
 
4507 
  def send_markOrderCancellationRequestReceived(self, orderId):
4508 
    self._oprot.writeMessageBegin('markOrderCancellationRequestReceived', TMessageType.CALL, self._seqid)
4509 
    args = markOrderCancellationRequestReceived_args()
4510 
    args.orderId = orderId
4511 
    args.write(self._oprot)
4512 
    self._oprot.writeMessageEnd()
4513 
    self._oprot.trans.flush()
4514 
 
4515 
  def recv_markOrderCancellationRequestReceived(self, ):
4516 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4517 
    if mtype == TMessageType.EXCEPTION:
4518 
      x = TApplicationException()
4519 
      x.read(self._iprot)
4520 
      self._iprot.readMessageEnd()
4521 
      raise x
4522 
    result = markOrderCancellationRequestReceived_result()
4523 
    result.read(self._iprot)
4524 
    self._iprot.readMessageEnd()
4525 
    if result.ex is not None:
4526 
      raise result.ex
4527 
    return
4528 
 
4529 
  def markOrderCancellationRequestConfirmed(self, orderId):
4530 
    """
4531 
    If we decide to to cancel order, CRM will call this method to move the status of order to
4532 
    cancellation request confirmed. After this OM will be able to cancel the order.
4533 
 
4534 
    Parameters:
4535 
     - orderId
4536 
    """
4537 
    self.send_markOrderCancellationRequestConfirmed(orderId)
4538 
    self.recv_markOrderCancellationRequestConfirmed()
4539 
 
4540 
  def send_markOrderCancellationRequestConfirmed(self, orderId):
4541 
    self._oprot.writeMessageBegin('markOrderCancellationRequestConfirmed', TMessageType.CALL, self._seqid)
4542 
    args = markOrderCancellationRequestConfirmed_args()
4543 
    args.orderId = orderId
4544 
    args.write(self._oprot)
4545 
    self._oprot.writeMessageEnd()
4546 
    self._oprot.trans.flush()
4547 
 
4548 
  def recv_markOrderCancellationRequestConfirmed(self, ):
4549 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4550 
    if mtype == TMessageType.EXCEPTION:
4551 
      x = TApplicationException()
4552 
      x.read(self._iprot)
4553 
      self._iprot.readMessageEnd()
4554 
      raise x
4555 
    result = markOrderCancellationRequestConfirmed_result()
4556 
    result.read(self._iprot)
4557 
    self._iprot.readMessageEnd()
4558 
    if result.ex is not None:
4559 
      raise result.ex
4560 
    return
4561 
 
4562 
  def markOrderCancellationRequestDenied(self, orderId):
4563 
    """
4564 
    If we decide to not to cancel order, we will move the order ro previous status.
4565 
 
4566 
    Parameters:
4567 
     - orderId
4568 
    """
4569 
    self.send_markOrderCancellationRequestDenied(orderId)
4570 
    self.recv_markOrderCancellationRequestDenied()
4571 
 
4572 
  def send_markOrderCancellationRequestDenied(self, orderId):
4573 
    self._oprot.writeMessageBegin('markOrderCancellationRequestDenied', TMessageType.CALL, self._seqid)
4574 
    args = markOrderCancellationRequestDenied_args()
4575 
    args.orderId = orderId
4576 
    args.write(self._oprot)
4577 
    self._oprot.writeMessageEnd()
4578 
    self._oprot.trans.flush()
4579 
 
4580 
  def recv_markOrderCancellationRequestDenied(self, ):
4581 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4582 
    if mtype == TMessageType.EXCEPTION:
4583 
      x = TApplicationException()
4584 
      x.read(self._iprot)
4585 
      self._iprot.readMessageEnd()
4586 
      raise x
4587 
    result = markOrderCancellationRequestDenied_result()
4588 
    result.read(self._iprot)
4589 
    self._iprot.readMessageEnd()
4590 
    if result.ex is not None:
4591 
      raise result.ex
4592 
    return
4593 
 
4258 rajveer 4594 
  def markTransactionAsPaymentFlagRemoved(self, transactionId):
4247 rajveer 4595 
    """
4258 rajveer 4596 
    If we and/or payment gateway has decided to accept the payment, this method needs to be called.
4597 
    Changed transaction and all orders status to payment accepted.
4247 rajveer 4598 
 
4599 
    Parameters:
4258 rajveer 4600 
     - transactionId
4247 rajveer 4601 
    """
4258 rajveer 4602 
    self.send_markTransactionAsPaymentFlagRemoved(transactionId)
4603 
    self.recv_markTransactionAsPaymentFlagRemoved()
4247 rajveer 4604 
 
4258 rajveer 4605 
  def send_markTransactionAsPaymentFlagRemoved(self, transactionId):
4606 
    self._oprot.writeMessageBegin('markTransactionAsPaymentFlagRemoved', TMessageType.CALL, self._seqid)
4607 
    args = markTransactionAsPaymentFlagRemoved_args()
4608 
    args.transactionId = transactionId
4247 rajveer 4609 
    args.write(self._oprot)
4610 
    self._oprot.writeMessageEnd()
4611 
    self._oprot.trans.flush()
4612 
 
4258 rajveer 4613 
  def recv_markTransactionAsPaymentFlagRemoved(self, ):
4247 rajveer 4614 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4615 
    if mtype == TMessageType.EXCEPTION:
4616 
      x = TApplicationException()
4617 
      x.read(self._iprot)
4618 
      self._iprot.readMessageEnd()
4619 
      raise x
4258 rajveer 4620 
    result = markTransactionAsPaymentFlagRemoved_result()
4247 rajveer 4621 
    result.read(self._iprot)
4622 
    self._iprot.readMessageEnd()
4623 
    if result.ex is not None:
4624 
      raise result.ex
4625 
    return
4626 
 
4259 anupam.sin 4627 
  def refundTransaction(self, transactionId, refundedBy, reason):
4628 
    """
4629 
    This method is called when a flagged payment is deemed unserviceable and the corresponding orders
4630 
    need to be cancelled
4247 rajveer 4631 
 
4259 anupam.sin 4632 
    Parameters:
4633 
     - transactionId
4634 
     - refundedBy
4635 
     - reason
4636 
    """
4637 
    self.send_refundTransaction(transactionId, refundedBy, reason)
4638 
    self.recv_refundTransaction()
4639 
 
4640 
  def send_refundTransaction(self, transactionId, refundedBy, reason):
4641 
    self._oprot.writeMessageBegin('refundTransaction', TMessageType.CALL, self._seqid)
4642 
    args = refundTransaction_args()
4643 
    args.transactionId = transactionId
4644 
    args.refundedBy = refundedBy
4645 
    args.reason = reason
4646 
    args.write(self._oprot)
4647 
    self._oprot.writeMessageEnd()
4648 
    self._oprot.trans.flush()
4649 
 
4650 
  def recv_refundTransaction(self, ):
4651 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4652 
    if mtype == TMessageType.EXCEPTION:
4653 
      x = TApplicationException()
4654 
      x.read(self._iprot)
4655 
      self._iprot.readMessageEnd()
4656 
      raise x
4657 
    result = refundTransaction_result()
4658 
    result.read(self._iprot)
4659 
    self._iprot.readMessageEnd()
4660 
    if result.ex is not None:
4661 
      raise result.ex
4662 
    return
4663 
 
4324 mandeep.dh 4664 
  def updateShipmentAddress(self, orderId, addressId):
4665 
    """
4666 
    Updates shipment address of an order. Delivery and shipping date estimates
4667 
    etc. are also updated here.
4668 
 
4669 
    Throws TransactionServiceException in case address change is not
4670 
    possible due to certain reasons such as new pincode in address is
4671 
    not serviceable etc.
4672 
 
4673 
    Parameters:
4674 
     - orderId
4675 
     - addressId
4676 
    """
4677 
    self.send_updateShipmentAddress(orderId, addressId)
4678 
    self.recv_updateShipmentAddress()
4679 
 
4680 
  def send_updateShipmentAddress(self, orderId, addressId):
4681 
    self._oprot.writeMessageBegin('updateShipmentAddress', TMessageType.CALL, self._seqid)
4682 
    args = updateShipmentAddress_args()
4683 
    args.orderId = orderId
4684 
    args.addressId = addressId
4685 
    args.write(self._oprot)
4686 
    self._oprot.writeMessageEnd()
4687 
    self._oprot.trans.flush()
4688 
 
4689 
  def recv_updateShipmentAddress(self, ):
4690 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4691 
    if mtype == TMessageType.EXCEPTION:
4692 
      x = TApplicationException()
4693 
      x.read(self._iprot)
4694 
      self._iprot.readMessageEnd()
4695 
      raise x
4696 
    result = updateShipmentAddress_result()
4697 
    result.read(self._iprot)
4698 
    self._iprot.readMessageEnd()
4699 
    if result.ex is not None:
4700 
      raise result.ex
4701 
    return
4702 
 
4285 rajveer 4703 
  def acceptOrdersForItemId(self, itemId, inventory):
4704 
    """
4705 
    Marks the orders as ACCEPTED for the given itemId and inventory. It also updates the accepted timestamp. If the
4706 
    given order is not a COD order, it also captures the payment if the same has not been captured.
4259 anupam.sin 4707 
 
4285 rajveer 4708 
    Parameters:
4709 
     - itemId
4710 
     - inventory
4711 
    """
4712 
    self.send_acceptOrdersForItemId(itemId, inventory)
4713 
    return self.recv_acceptOrdersForItemId()
4714 
 
4715 
  def send_acceptOrdersForItemId(self, itemId, inventory):
4716 
    self._oprot.writeMessageBegin('acceptOrdersForItemId', TMessageType.CALL, self._seqid)
4717 
    args = acceptOrdersForItemId_args()
4718 
    args.itemId = itemId
4719 
    args.inventory = inventory
4720 
    args.write(self._oprot)
4721 
    self._oprot.writeMessageEnd()
4722 
    self._oprot.trans.flush()
4723 
 
4724 
  def recv_acceptOrdersForItemId(self, ):
4725 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4726 
    if mtype == TMessageType.EXCEPTION:
4727 
      x = TApplicationException()
4728 
      x.read(self._iprot)
4729 
      self._iprot.readMessageEnd()
4730 
      raise x
4731 
    result = acceptOrdersForItemId_result()
4732 
    result.read(self._iprot)
4733 
    self._iprot.readMessageEnd()
4734 
    if result.success is not None:
4735 
      return result.success
4736 
    if result.ex is not None:
4737 
      raise result.ex
4738 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "acceptOrdersForItemId failed: unknown result");
4739 
 
4369 rajveer 4740 
  def markOrdersAsPORaised(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 4741 
    """
4742 
    Parameters:
4743 
     - vendorId
4744 
     - itemId
4745 
     - quantity
4746 
     - estimate
4369 rajveer 4747 
     - isReminder
4303 rajveer 4748 
    """
4369 rajveer 4749 
    self.send_markOrdersAsPORaised(vendorId, itemId, quantity, estimate, isReminder)
4303 rajveer 4750 
    self.recv_markOrdersAsPORaised()
4285 rajveer 4751 
 
4369 rajveer 4752 
  def send_markOrdersAsPORaised(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 4753 
    self._oprot.writeMessageBegin('markOrdersAsPORaised', TMessageType.CALL, self._seqid)
4754 
    args = markOrdersAsPORaised_args()
4755 
    args.vendorId = vendorId
4756 
    args.itemId = itemId
4757 
    args.quantity = quantity
4758 
    args.estimate = estimate
4369 rajveer 4759 
    args.isReminder = isReminder
4303 rajveer 4760 
    args.write(self._oprot)
4761 
    self._oprot.writeMessageEnd()
4762 
    self._oprot.trans.flush()
4763 
 
4764 
  def recv_markOrdersAsPORaised(self, ):
4765 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4766 
    if mtype == TMessageType.EXCEPTION:
4767 
      x = TApplicationException()
4768 
      x.read(self._iprot)
4769 
      self._iprot.readMessageEnd()
4770 
      raise x
4771 
    result = markOrdersAsPORaised_result()
4772 
    result.read(self._iprot)
4773 
    self._iprot.readMessageEnd()
4774 
    if result.ex is not None:
4775 
      raise result.ex
4776 
    return
4777 
 
4369 rajveer 4778 
  def markOrdersAsReversalInitiated(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 4779 
    """
4780 
    Parameters:
4781 
     - vendorId
4782 
     - itemId
4783 
     - quantity
4784 
     - estimate
4369 rajveer 4785 
     - isReminder
4303 rajveer 4786 
    """
4369 rajveer 4787 
    self.send_markOrdersAsReversalInitiated(vendorId, itemId, quantity, estimate, isReminder)
4303 rajveer 4788 
    self.recv_markOrdersAsReversalInitiated()
4789 
 
4369 rajveer 4790 
  def send_markOrdersAsReversalInitiated(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 4791 
    self._oprot.writeMessageBegin('markOrdersAsReversalInitiated', TMessageType.CALL, self._seqid)
4792 
    args = markOrdersAsReversalInitiated_args()
4793 
    args.vendorId = vendorId
4794 
    args.itemId = itemId
4795 
    args.quantity = quantity
4796 
    args.estimate = estimate
4369 rajveer 4797 
    args.isReminder = isReminder
4303 rajveer 4798 
    args.write(self._oprot)
4799 
    self._oprot.writeMessageEnd()
4800 
    self._oprot.trans.flush()
4801 
 
4802 
  def recv_markOrdersAsReversalInitiated(self, ):
4803 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4804 
    if mtype == TMessageType.EXCEPTION:
4805 
      x = TApplicationException()
4806 
      x.read(self._iprot)
4807 
      self._iprot.readMessageEnd()
4808 
      raise x
4809 
    result = markOrdersAsReversalInitiated_result()
4810 
    result.read(self._iprot)
4811 
    self._iprot.readMessageEnd()
4812 
    if result.ex is not None:
4813 
      raise result.ex
4814 
    return
4815 
 
4369 rajveer 4816 
  def markOrdersAsNotAvailabke(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 4817 
    """
4818 
    Parameters:
4819 
     - vendorId
4820 
     - itemId
4821 
     - quantity
4822 
     - estimate
4369 rajveer 4823 
     - isReminder
4303 rajveer 4824 
    """
4369 rajveer 4825 
    self.send_markOrdersAsNotAvailabke(vendorId, itemId, quantity, estimate, isReminder)
4303 rajveer 4826 
    self.recv_markOrdersAsNotAvailabke()
4827 
 
4369 rajveer 4828 
  def send_markOrdersAsNotAvailabke(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 4829 
    self._oprot.writeMessageBegin('markOrdersAsNotAvailabke', TMessageType.CALL, self._seqid)
4830 
    args = markOrdersAsNotAvailabke_args()
4831 
    args.vendorId = vendorId
4832 
    args.itemId = itemId
4833 
    args.quantity = quantity
4834 
    args.estimate = estimate
4369 rajveer 4835 
    args.isReminder = isReminder
4303 rajveer 4836 
    args.write(self._oprot)
4837 
    self._oprot.writeMessageEnd()
4838 
    self._oprot.trans.flush()
4839 
 
4840 
  def recv_markOrdersAsNotAvailabke(self, ):
4841 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4842 
    if mtype == TMessageType.EXCEPTION:
4843 
      x = TApplicationException()
4844 
      x.read(self._iprot)
4845 
      self._iprot.readMessageEnd()
4846 
      raise x
4847 
    result = markOrdersAsNotAvailabke_result()
4848 
    result.read(self._iprot)
4849 
    self._iprot.readMessageEnd()
4850 
    if result.ex is not None:
4851 
      raise result.ex
4852 
    return
4853 
 
4369 rajveer 4854 
  def markOrdersAsTimeout(self, vendorId):
4855 
    """
4856 
    Parameters:
4857 
     - vendorId
4858 
    """
4859 
    self.send_markOrdersAsTimeout(vendorId)
4860 
    return self.recv_markOrdersAsTimeout()
4303 rajveer 4861 
 
4369 rajveer 4862 
  def send_markOrdersAsTimeout(self, vendorId):
4863 
    self._oprot.writeMessageBegin('markOrdersAsTimeout', TMessageType.CALL, self._seqid)
4864 
    args = markOrdersAsTimeout_args()
4865 
    args.vendorId = vendorId
4866 
    args.write(self._oprot)
4867 
    self._oprot.writeMessageEnd()
4868 
    self._oprot.trans.flush()
4869 
 
4870 
  def recv_markOrdersAsTimeout(self, ):
4871 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4872 
    if mtype == TMessageType.EXCEPTION:
4873 
      x = TApplicationException()
4874 
      x.read(self._iprot)
4875 
      self._iprot.readMessageEnd()
4876 
      raise x
4877 
    result = markOrdersAsTimeout_result()
4878 
    result.read(self._iprot)
4879 
    self._iprot.readMessageEnd()
4880 
    if result.success is not None:
4881 
      return result.success
4882 
    if result.ex is not None:
4883 
      raise result.ex
4884 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrdersAsTimeout failed: unknown result");
4885 
 
4662 rajveer 4886 
  def markOrderAsLostInTransit(self, orderId):
4887 
    """
4888 
    Mark order as LOST_IN_TRANSIT
4889 
 
4890 
    Parameters:
4891 
     - orderId
4892 
    """
4893 
    self.send_markOrderAsLostInTransit(orderId)
4894 
    return self.recv_markOrderAsLostInTransit()
4895 
 
4896 
  def send_markOrderAsLostInTransit(self, orderId):
4897 
    self._oprot.writeMessageBegin('markOrderAsLostInTransit', TMessageType.CALL, self._seqid)
4898 
    args = markOrderAsLostInTransit_args()
4899 
    args.orderId = orderId
4900 
    args.write(self._oprot)
4901 
    self._oprot.writeMessageEnd()
4902 
    self._oprot.trans.flush()
4903 
 
4904 
  def recv_markOrderAsLostInTransit(self, ):
4905 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4906 
    if mtype == TMessageType.EXCEPTION:
4907 
      x = TApplicationException()
4908 
      x.read(self._iprot)
4909 
      self._iprot.readMessageEnd()
4910 
      raise x
4911 
    result = markOrderAsLostInTransit_result()
4912 
    result.read(self._iprot)
4913 
    self._iprot.readMessageEnd()
4914 
    if result.success is not None:
4915 
      return result.success
4916 
    if result.ex is not None:
4917 
      raise result.ex
4918 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderAsLostInTransit failed: unknown result");
4919 
 
4386 anupam.sin 4920 
  def getOrderForAwb(self, awb):
4921 
    """
4922 
    Returns the order corresponding to an AWB number
4369 rajveer 4923 
 
4386 anupam.sin 4924 
    Parameters:
4925 
     - awb
4926 
    """
4927 
    self.send_getOrderForAwb(awb)
4928 
    return self.recv_getOrderForAwb()
4929 
 
4930 
  def send_getOrderForAwb(self, awb):
4931 
    self._oprot.writeMessageBegin('getOrderForAwb', TMessageType.CALL, self._seqid)
4932 
    args = getOrderForAwb_args()
4933 
    args.awb = awb
4934 
    args.write(self._oprot)
4935 
    self._oprot.writeMessageEnd()
4936 
    self._oprot.trans.flush()
4937 
 
4938 
  def recv_getOrderForAwb(self, ):
4939 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4940 
    if mtype == TMessageType.EXCEPTION:
4941 
      x = TApplicationException()
4942 
      x.read(self._iprot)
4943 
      self._iprot.readMessageEnd()
4944 
      raise x
4945 
    result = getOrderForAwb_result()
4946 
    result.read(self._iprot)
4947 
    self._iprot.readMessageEnd()
4948 
    if result.success is not None:
4949 
      return result.success
4950 
    if result.ex is not None:
4951 
      raise result.ex
4952 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderForAwb failed: unknown result");
4953 
 
4910 phani.kuma 4954 
  def getOrdersForProviderForStatus(self, logistics_provider_id, order_status_list):
4506 phani.kuma 4955 
    """
4910 phani.kuma 4956 
    Returns the order corresponding to a logistics provider id for a given list of order status
4386 anupam.sin 4957 
 
4506 phani.kuma 4958 
    Parameters:
4959 
     - logistics_provider_id
4910 phani.kuma 4960 
     - order_status_list
4506 phani.kuma 4961 
    """
4910 phani.kuma 4962 
    self.send_getOrdersForProviderForStatus(logistics_provider_id, order_status_list)
4506 phani.kuma 4963 
    return self.recv_getOrdersForProviderForStatus()
4964 
 
4910 phani.kuma 4965 
  def send_getOrdersForProviderForStatus(self, logistics_provider_id, order_status_list):
4506 phani.kuma 4966 
    self._oprot.writeMessageBegin('getOrdersForProviderForStatus', TMessageType.CALL, self._seqid)
4967 
    args = getOrdersForProviderForStatus_args()
4968 
    args.logistics_provider_id = logistics_provider_id
4910 phani.kuma 4969 
    args.order_status_list = order_status_list
4506 phani.kuma 4970 
    args.write(self._oprot)
4971 
    self._oprot.writeMessageEnd()
4972 
    self._oprot.trans.flush()
4973 
 
4974 
  def recv_getOrdersForProviderForStatus(self, ):
4975 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4976 
    if mtype == TMessageType.EXCEPTION:
4977 
      x = TApplicationException()
4978 
      x.read(self._iprot)
4979 
      self._iprot.readMessageEnd()
4980 
      raise x
4981 
    result = getOrdersForProviderForStatus_result()
4982 
    result.read(self._iprot)
4983 
    self._iprot.readMessageEnd()
4984 
    if result.success is not None:
4985 
      return result.success
4986 
    if result.ex is not None:
4987 
      raise result.ex
4988 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersForProviderForStatus failed: unknown result");
4989 
 
4600 varun.gupt 4990 
  def getBilledOrdersForVendor(self, vendorId, billingDateFrom, billingDateTo):
4991 
    """
4992 
    Returns list of orders fullfiled from a certain vendor and billed in a given date range
4506 phani.kuma 4993 
 
4600 varun.gupt 4994 
    Parameters:
4995 
     - vendorId
4996 
     - billingDateFrom
4997 
     - billingDateTo
4998 
    """
4999 
    self.send_getBilledOrdersForVendor(vendorId, billingDateFrom, billingDateTo)
5000 
    return self.recv_getBilledOrdersForVendor()
5001 
 
5002 
  def send_getBilledOrdersForVendor(self, vendorId, billingDateFrom, billingDateTo):
5003 
    self._oprot.writeMessageBegin('getBilledOrdersForVendor', TMessageType.CALL, self._seqid)
5004 
    args = getBilledOrdersForVendor_args()
5005 
    args.vendorId = vendorId
5006 
    args.billingDateFrom = billingDateFrom
5007 
    args.billingDateTo = billingDateTo
5008 
    args.write(self._oprot)
5009 
    self._oprot.writeMessageEnd()
5010 
    self._oprot.trans.flush()
5011 
 
5012 
  def recv_getBilledOrdersForVendor(self, ):
5013 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5014 
    if mtype == TMessageType.EXCEPTION:
5015 
      x = TApplicationException()
5016 
      x.read(self._iprot)
5017 
      self._iprot.readMessageEnd()
5018 
      raise x
5019 
    result = getBilledOrdersForVendor_result()
5020 
    result.read(self._iprot)
5021 
    self._iprot.readMessageEnd()
5022 
    if result.success is not None:
5023 
      return result.success
5024 
    if result.ex is not None:
5025 
      raise result.ex
5026 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBilledOrdersForVendor failed: unknown result");
5027 
 
4607 rajveer 5028 
  def getSlippedSippingDateOrders(self, ):
5029 
    self.send_getSlippedSippingDateOrders()
5030 
    return self.recv_getSlippedSippingDateOrders()
5031 
 
5032 
  def send_getSlippedSippingDateOrders(self, ):
5033 
    self._oprot.writeMessageBegin('getSlippedSippingDateOrders', TMessageType.CALL, self._seqid)
5034 
    args = getSlippedSippingDateOrders_args()
5035 
    args.write(self._oprot)
5036 
    self._oprot.writeMessageEnd()
5037 
    self._oprot.trans.flush()
5038 
 
5039 
  def recv_getSlippedSippingDateOrders(self, ):
5040 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5041 
    if mtype == TMessageType.EXCEPTION:
5042 
      x = TApplicationException()
5043 
      x.read(self._iprot)
5044 
      self._iprot.readMessageEnd()
5045 
      raise x
5046 
    result = getSlippedSippingDateOrders_result()
5047 
    result.read(self._iprot)
5048 
    self._iprot.readMessageEnd()
5049 
    if result.success is not None:
5050 
      return result.success
5051 
    if result.ex is not None:
5052 
      raise result.ex
5053 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getSlippedSippingDateOrders failed: unknown result");
5054 
 
4709 rajveer 5055 
  def getCancelledOrders(self, cancelDateFrom, cancelDateTo):
5056 
    """
5057 
    Parameters:
5058 
     - cancelDateFrom
5059 
     - cancelDateTo
5060 
    """
5061 
    self.send_getCancelledOrders(cancelDateFrom, cancelDateTo)
5062 
    return self.recv_getCancelledOrders()
5063 
 
5064 
  def send_getCancelledOrders(self, cancelDateFrom, cancelDateTo):
5065 
    self._oprot.writeMessageBegin('getCancelledOrders', TMessageType.CALL, self._seqid)
5066 
    args = getCancelledOrders_args()
5067 
    args.cancelDateFrom = cancelDateFrom
5068 
    args.cancelDateTo = cancelDateTo
5069 
    args.write(self._oprot)
5070 
    self._oprot.writeMessageEnd()
5071 
    self._oprot.trans.flush()
5072 
 
5073 
  def recv_getCancelledOrders(self, ):
5074 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5075 
    if mtype == TMessageType.EXCEPTION:
5076 
      x = TApplicationException()
5077 
      x.read(self._iprot)
5078 
      self._iprot.readMessageEnd()
5079 
      raise x
5080 
    result = getCancelledOrders_result()
5081 
    result.read(self._iprot)
5082 
    self._iprot.readMessageEnd()
5083 
    if result.success is not None:
5084 
      return result.success
5085 
    if result.ex is not None:
5086 
      raise result.ex
5087 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCancelledOrders failed: unknown result");
5088 
 
4600 varun.gupt 5089 
  def saveBluedartSettlements(self, mapAWBAndAmount):
5090 
    """
5091 
    Parameters:
5092 
     - mapAWBAndAmount
5093 
    """
5094 
    self.send_saveBluedartSettlements(mapAWBAndAmount)
5095 
    self.recv_saveBluedartSettlements()
5096 
 
5097 
  def send_saveBluedartSettlements(self, mapAWBAndAmount):
5098 
    self._oprot.writeMessageBegin('saveBluedartSettlements', TMessageType.CALL, self._seqid)
5099 
    args = saveBluedartSettlements_args()
5100 
    args.mapAWBAndAmount = mapAWBAndAmount
5101 
    args.write(self._oprot)
5102 
    self._oprot.writeMessageEnd()
5103 
    self._oprot.trans.flush()
5104 
 
5105 
  def recv_saveBluedartSettlements(self, ):
5106 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5107 
    if mtype == TMessageType.EXCEPTION:
5108 
      x = TApplicationException()
5109 
      x.read(self._iprot)
5110 
      self._iprot.readMessageEnd()
5111 
      raise x
5112 
    result = saveBluedartSettlements_result()
5113 
    result.read(self._iprot)
5114 
    self._iprot.readMessageEnd()
5115 
    if result.ex is not None:
5116 
      raise result.ex
5117 
    return
5118 
 
4905 varun.gupt 5119 
  def savePaymentSettlements(self, settlementDate, paymentGatewayId, referenceId, serviceTax, otherCharges, netCollection):
4600 varun.gupt 5120 
    """
5121 
    Parameters:
5122 
     - settlementDate
5123 
     - paymentGatewayId
4905 varun.gupt 5124 
     - referenceId
4600 varun.gupt 5125 
     - serviceTax
5126 
     - otherCharges
5127 
     - netCollection
5128 
    """
4905 varun.gupt 5129 
    self.send_savePaymentSettlements(settlementDate, paymentGatewayId, referenceId, serviceTax, otherCharges, netCollection)
4600 varun.gupt 5130 
    self.recv_savePaymentSettlements()
5131 
 
4905 varun.gupt 5132 
  def send_savePaymentSettlements(self, settlementDate, paymentGatewayId, referenceId, serviceTax, otherCharges, netCollection):
4600 varun.gupt 5133 
    self._oprot.writeMessageBegin('savePaymentSettlements', TMessageType.CALL, self._seqid)
5134 
    args = savePaymentSettlements_args()
5135 
    args.settlementDate = settlementDate
5136 
    args.paymentGatewayId = paymentGatewayId
4905 varun.gupt 5137 
    args.referenceId = referenceId
4600 varun.gupt 5138 
    args.serviceTax = serviceTax
5139 
    args.otherCharges = otherCharges
5140 
    args.netCollection = netCollection
5141 
    args.write(self._oprot)
5142 
    self._oprot.writeMessageEnd()
5143 
    self._oprot.trans.flush()
5144 
 
5145 
  def recv_savePaymentSettlements(self, ):
5146 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5147 
    if mtype == TMessageType.EXCEPTION:
5148 
      x = TApplicationException()
5149 
      x.read(self._iprot)
5150 
      self._iprot.readMessageEnd()
5151 
      raise x
5152 
    result = savePaymentSettlements_result()
5153 
    result.read(self._iprot)
5154 
    self._iprot.readMessageEnd()
5155 
    if result.ex is not None:
5156 
      raise result.ex
5157 
    return
5158 
 
5159 
  def saveEBSSettlementSummary(self, settlementId, settlementDate, transactionDateFrom, transactionDateTo, amount):
5160 
    """
5161 
    Parameters:
5162 
     - settlementId
5163 
     - settlementDate
5164 
     - transactionDateFrom
5165 
     - transactionDateTo
5166 
     - amount
5167 
    """
5168 
    self.send_saveEBSSettlementSummary(settlementId, settlementDate, transactionDateFrom, transactionDateTo, amount)
5169 
    self.recv_saveEBSSettlementSummary()
5170 
 
5171 
  def send_saveEBSSettlementSummary(self, settlementId, settlementDate, transactionDateFrom, transactionDateTo, amount):
5172 
    self._oprot.writeMessageBegin('saveEBSSettlementSummary', TMessageType.CALL, self._seqid)
5173 
    args = saveEBSSettlementSummary_args()
5174 
    args.settlementId = settlementId
5175 
    args.settlementDate = settlementDate
5176 
    args.transactionDateFrom = transactionDateFrom
5177 
    args.transactionDateTo = transactionDateTo
5178 
    args.amount = amount
5179 
    args.write(self._oprot)
5180 
    self._oprot.writeMessageEnd()
5181 
    self._oprot.trans.flush()
5182 
 
5183 
  def recv_saveEBSSettlementSummary(self, ):
5184 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5185 
    if mtype == TMessageType.EXCEPTION:
5186 
      x = TApplicationException()
5187 
      x.read(self._iprot)
5188 
      self._iprot.readMessageEnd()
5189 
      raise x
5190 
    result = saveEBSSettlementSummary_result()
5191 
    result.read(self._iprot)
5192 
    self._iprot.readMessageEnd()
5193 
    if result.ex is not None:
5194 
      raise result.ex
5195 
    return
5196 
 
5386 phani.kuma 5197 
  def getSettlementForPrepaid(self, referenceId, isRefund):
4600 varun.gupt 5198 
    """
5199 
    Parameters:
5189 varun.gupt 5200 
     - referenceId
5201 
     - isRefund
4600 varun.gupt 5202 
    """
5386 phani.kuma 5203 
    self.send_getSettlementForPrepaid(referenceId, isRefund)
5204 
    return self.recv_getSettlementForPrepaid()
4600 varun.gupt 5205 
 
5386 phani.kuma 5206 
  def send_getSettlementForPrepaid(self, referenceId, isRefund):
5207 
    self._oprot.writeMessageBegin('getSettlementForPrepaid', TMessageType.CALL, self._seqid)
5208 
    args = getSettlementForPrepaid_args()
5189 varun.gupt 5209 
    args.referenceId = referenceId
5210 
    args.isRefund = isRefund
4600 varun.gupt 5211 
    args.write(self._oprot)
5212 
    self._oprot.writeMessageEnd()
5213 
    self._oprot.trans.flush()
5214 
 
5386 phani.kuma 5215 
  def recv_getSettlementForPrepaid(self, ):
4600 varun.gupt 5216 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5217 
    if mtype == TMessageType.EXCEPTION:
5218 
      x = TApplicationException()
5219 
      x.read(self._iprot)
5220 
      self._iprot.readMessageEnd()
5221 
      raise x
5386 phani.kuma 5222 
    result = getSettlementForPrepaid_result()
4600 varun.gupt 5223 
    result.read(self._iprot)
5224 
    self._iprot.readMessageEnd()
5225 
    if result.success is not None:
5226 
      return result.success
5227 
    if result.ex is not None:
5228 
      raise result.ex
5386 phani.kuma 5229 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getSettlementForPrepaid failed: unknown result");
4600 varun.gupt 5230 
 
5386 phani.kuma 5231 
  def getSettlementForCod(self, orderId, isRefund):
5232 
    """
5233 
    Parameters:
5234 
     - orderId
5235 
     - isRefund
5236 
    """
5237 
    self.send_getSettlementForCod(orderId, isRefund)
5238 
    return self.recv_getSettlementForCod()
5239 
 
5240 
  def send_getSettlementForCod(self, orderId, isRefund):
5241 
    self._oprot.writeMessageBegin('getSettlementForCod', TMessageType.CALL, self._seqid)
5242 
    args = getSettlementForCod_args()
5243 
    args.orderId = orderId
5244 
    args.isRefund = isRefund
5245 
    args.write(self._oprot)
5246 
    self._oprot.writeMessageEnd()
5247 
    self._oprot.trans.flush()
5248 
 
5249 
  def recv_getSettlementForCod(self, ):
5250 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5251 
    if mtype == TMessageType.EXCEPTION:
5252 
      x = TApplicationException()
5253 
      x.read(self._iprot)
5254 
      self._iprot.readMessageEnd()
5255 
      raise x
5256 
    result = getSettlementForCod_result()
5257 
    result.read(self._iprot)
5258 
    self._iprot.readMessageEnd()
5259 
    if result.success is not None:
5260 
      return result.success
5261 
    if result.ex is not None:
5262 
      raise result.ex
5263 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getSettlementForCod failed: unknown result");
5264 
 
4600 varun.gupt 5265 
  def getEBSSettlementSummaries(self, ):
5266 
    self.send_getEBSSettlementSummaries()
5267 
    return self.recv_getEBSSettlementSummaries()
5268 
 
5269 
  def send_getEBSSettlementSummaries(self, ):
5270 
    self._oprot.writeMessageBegin('getEBSSettlementSummaries', TMessageType.CALL, self._seqid)
5271 
    args = getEBSSettlementSummaries_args()
5272 
    args.write(self._oprot)
5273 
    self._oprot.writeMessageEnd()
5274 
    self._oprot.trans.flush()
5275 
 
5276 
  def recv_getEBSSettlementSummaries(self, ):
5277 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5278 
    if mtype == TMessageType.EXCEPTION:
5279 
      x = TApplicationException()
5280 
      x.read(self._iprot)
5281 
      self._iprot.readMessageEnd()
5282 
      raise x
5283 
    result = getEBSSettlementSummaries_result()
5284 
    result.read(self._iprot)
5285 
    self._iprot.readMessageEnd()
5286 
    if result.success is not None:
5287 
      return result.success
5288 
    if result.ex is not None:
5289 
      raise result.ex
5290 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getEBSSettlementSummaries failed: unknown result");
5291 
 
5292 
  def markEBSSettlementUploaded(self, settlementId):
5293 
    """
5294 
    Parameters:
5295 
     - settlementId
5296 
    """
5297 
    self.send_markEBSSettlementUploaded(settlementId)
5298 
    self.recv_markEBSSettlementUploaded()
5299 
 
5300 
  def send_markEBSSettlementUploaded(self, settlementId):
5301 
    self._oprot.writeMessageBegin('markEBSSettlementUploaded', TMessageType.CALL, self._seqid)
5302 
    args = markEBSSettlementUploaded_args()
5303 
    args.settlementId = settlementId
5304 
    args.write(self._oprot)
5305 
    self._oprot.writeMessageEnd()
5306 
    self._oprot.trans.flush()
5307 
 
5308 
  def recv_markEBSSettlementUploaded(self, ):
5309 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5310 
    if mtype == TMessageType.EXCEPTION:
5311 
      x = TApplicationException()
5312 
      x.read(self._iprot)
5313 
      self._iprot.readMessageEnd()
5314 
      raise x
5315 
    result = markEBSSettlementUploaded_result()
5316 
    result.read(self._iprot)
5317 
    self._iprot.readMessageEnd()
5318 
    if result.ex is not None:
5319 
      raise result.ex
5320 
    return
5321 
 
5322 
  def getEBSSettlementDate(self, settlementId):
5323 
    """
5324 
    Parameters:
5325 
     - settlementId
5326 
    """
5327 
    self.send_getEBSSettlementDate(settlementId)
5328 
    return self.recv_getEBSSettlementDate()
5329 
 
5330 
  def send_getEBSSettlementDate(self, settlementId):
5331 
    self._oprot.writeMessageBegin('getEBSSettlementDate', TMessageType.CALL, self._seqid)
5332 
    args = getEBSSettlementDate_args()
5333 
    args.settlementId = settlementId
5334 
    args.write(self._oprot)
5335 
    self._oprot.writeMessageEnd()
5336 
    self._oprot.trans.flush()
5337 
 
5338 
  def recv_getEBSSettlementDate(self, ):
5339 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5340 
    if mtype == TMessageType.EXCEPTION:
5341 
      x = TApplicationException()
5342 
      x.read(self._iprot)
5343 
      self._iprot.readMessageEnd()
5344 
      raise x
5345 
    result = getEBSSettlementDate_result()
5346 
    result.read(self._iprot)
5347 
    self._iprot.readMessageEnd()
5348 
    if result.success is not None:
5349 
      return result.success
5350 
    if result.ex is not None:
5351 
      raise result.ex
5352 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getEBSSettlementDate failed: unknown result");
5353 
 
4715 varun.gupt 5354 
  def getSettlementsByDate(self, settlementDateFrom, settlementDateTo, isRefund):
5355 
    """
5356 
    Parameters:
5357 
     - settlementDateFrom
5358 
     - settlementDateTo
5359 
     - isRefund
5360 
    """
5361 
    self.send_getSettlementsByDate(settlementDateFrom, settlementDateTo, isRefund)
5362 
    return self.recv_getSettlementsByDate()
4600 varun.gupt 5363 
 
4715 varun.gupt 5364 
  def send_getSettlementsByDate(self, settlementDateFrom, settlementDateTo, isRefund):
5365 
    self._oprot.writeMessageBegin('getSettlementsByDate', TMessageType.CALL, self._seqid)
5366 
    args = getSettlementsByDate_args()
5367 
    args.settlementDateFrom = settlementDateFrom
5368 
    args.settlementDateTo = settlementDateTo
5369 
    args.isRefund = isRefund
5370 
    args.write(self._oprot)
5371 
    self._oprot.writeMessageEnd()
5372 
    self._oprot.trans.flush()
5373 
 
5374 
  def recv_getSettlementsByDate(self, ):
5375 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5376 
    if mtype == TMessageType.EXCEPTION:
5377 
      x = TApplicationException()
5378 
      x.read(self._iprot)
5379 
      self._iprot.readMessageEnd()
5380 
      raise x
5381 
    result = getSettlementsByDate_result()
5382 
    result.read(self._iprot)
5383 
    self._iprot.readMessageEnd()
5384 
    if result.success is not None:
5385 
      return result.success
5386 
    if result.ex is not None:
5387 
      raise result.ex
5388 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getSettlementsByDate failed: unknown result");
5389 
 
5390 
  def getReshippedOrderIds(self, orderIds):
5391 
    """
5392 
    Returns list of Order Ids, which belong to reshiped orders, shortlisted from a given list of Order Ids
5393 
 
5394 
    Parameters:
5395 
     - orderIds
5396 
    """
5397 
    self.send_getReshippedOrderIds(orderIds)
5398 
    return self.recv_getReshippedOrderIds()
5399 
 
5400 
  def send_getReshippedOrderIds(self, orderIds):
5401 
    self._oprot.writeMessageBegin('getReshippedOrderIds', TMessageType.CALL, self._seqid)
5402 
    args = getReshippedOrderIds_args()
5403 
    args.orderIds = orderIds
5404 
    args.write(self._oprot)
5405 
    self._oprot.writeMessageEnd()
5406 
    self._oprot.trans.flush()
5407 
 
5408 
  def recv_getReshippedOrderIds(self, ):
5409 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5410 
    if mtype == TMessageType.EXCEPTION:
5411 
      x = TApplicationException()
5412 
      x.read(self._iprot)
5413 
      self._iprot.readMessageEnd()
5414 
      raise x
5415 
    result = getReshippedOrderIds_result()
5416 
    result.read(self._iprot)
5417 
    self._iprot.readMessageEnd()
5418 
    if result.success is not None:
5419 
      return result.success
5420 
    if result.ex is not None:
5421 
      raise result.ex
5422 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReshippedOrderIds failed: unknown result");
5423 
 
5481 phani.kuma 5424 
  def getBilledOrders(self, vendorId, onlyVendorNotPaid, billingDateFrom, billingDateTo):
4875 varun.gupt 5425 
    """
5426 
    Parameters:
5427 
     - vendorId
5481 phani.kuma 5428 
     - onlyVendorNotPaid
5429 
     - billingDateFrom
5430 
     - billingDateTo
4875 varun.gupt 5431 
    """
5481 phani.kuma 5432 
    self.send_getBilledOrders(vendorId, onlyVendorNotPaid, billingDateFrom, billingDateTo)
5433 
    return self.recv_getBilledOrders()
4757 mandeep.dh 5434 
 
5481 phani.kuma 5435 
  def send_getBilledOrders(self, vendorId, onlyVendorNotPaid, billingDateFrom, billingDateTo):
5436 
    self._oprot.writeMessageBegin('getBilledOrders', TMessageType.CALL, self._seqid)
5437 
    args = getBilledOrders_args()
4875 varun.gupt 5438 
    args.vendorId = vendorId
5481 phani.kuma 5439 
    args.onlyVendorNotPaid = onlyVendorNotPaid
5440 
    args.billingDateFrom = billingDateFrom
5441 
    args.billingDateTo = billingDateTo
4875 varun.gupt 5442 
    args.write(self._oprot)
5443 
    self._oprot.writeMessageEnd()
5444 
    self._oprot.trans.flush()
5445 
 
5481 phani.kuma 5446 
  def recv_getBilledOrders(self, ):
4875 varun.gupt 5447 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5448 
    if mtype == TMessageType.EXCEPTION:
5449 
      x = TApplicationException()
5450 
      x.read(self._iprot)
5451 
      self._iprot.readMessageEnd()
5452 
      raise x
5481 phani.kuma 5453 
    result = getBilledOrders_result()
4875 varun.gupt 5454 
    result.read(self._iprot)
5455 
    self._iprot.readMessageEnd()
5456 
    if result.success is not None:
5457 
      return result.success
5458 
    if result.ex is not None:
5459 
      raise result.ex
5481 phani.kuma 5460 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBilledOrders failed: unknown result");
4875 varun.gupt 5461 
 
5031 varun.gupt 5462 
  def getStatusDistributionOfOrders(self, startDate, endDate):
5463 
    """
5464 
    Parameters:
5465 
     - startDate
5466 
     - endDate
5467 
    """
5468 
    self.send_getStatusDistributionOfOrders(startDate, endDate)
5469 
    return self.recv_getStatusDistributionOfOrders()
4875 varun.gupt 5470 
 
5031 varun.gupt 5471 
  def send_getStatusDistributionOfOrders(self, startDate, endDate):
5472 
    self._oprot.writeMessageBegin('getStatusDistributionOfOrders', TMessageType.CALL, self._seqid)
5473 
    args = getStatusDistributionOfOrders_args()
5474 
    args.startDate = startDate
5475 
    args.endDate = endDate
5476 
    args.write(self._oprot)
5477 
    self._oprot.writeMessageEnd()
5478 
    self._oprot.trans.flush()
5479 
 
5480 
  def recv_getStatusDistributionOfOrders(self, ):
5481 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5482 
    if mtype == TMessageType.EXCEPTION:
5483 
      x = TApplicationException()
5484 
      x.read(self._iprot)
5485 
      self._iprot.readMessageEnd()
5486 
      raise x
5487 
    result = getStatusDistributionOfOrders_result()
5488 
    result.read(self._iprot)
5489 
    self._iprot.readMessageEnd()
5490 
    if result.success is not None:
5491 
      return result.success
5492 
    if result.ex is not None:
5493 
      raise result.ex
5494 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getStatusDistributionOfOrders failed: unknown result");
5495 
 
5067 varun.gupt 5496 
  def getOrderIdsForStatus(self, status, startDatetime, endDatetime):
5497 
    """
5498 
    Parameters:
5499 
     - status
5500 
     - startDatetime
5501 
     - endDatetime
5502 
    """
5503 
    self.send_getOrderIdsForStatus(status, startDatetime, endDatetime)
5504 
    return self.recv_getOrderIdsForStatus()
5031 varun.gupt 5505 
 
5067 varun.gupt 5506 
  def send_getOrderIdsForStatus(self, status, startDatetime, endDatetime):
5507 
    self._oprot.writeMessageBegin('getOrderIdsForStatus', TMessageType.CALL, self._seqid)
5508 
    args = getOrderIdsForStatus_args()
5509 
    args.status = status
5510 
    args.startDatetime = startDatetime
5511 
    args.endDatetime = endDatetime
5512 
    args.write(self._oprot)
5513 
    self._oprot.writeMessageEnd()
5514 
    self._oprot.trans.flush()
5515 
 
5516 
  def recv_getOrderIdsForStatus(self, ):
5517 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5518 
    if mtype == TMessageType.EXCEPTION:
5519 
      x = TApplicationException()
5520 
      x.read(self._iprot)
5521 
      self._iprot.readMessageEnd()
5522 
      raise x
5523 
    result = getOrderIdsForStatus_result()
5524 
    result.read(self._iprot)
5525 
    self._iprot.readMessageEnd()
5526 
    if result.success is not None:
5527 
      return result.success
5528 
    if result.ex is not None:
5529 
      raise result.ex
5530 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderIdsForStatus failed: unknown result");
5531 
 
5348 anupam.sin 5532 
  def updateCODAgent(self, agent, orderId):
5533 
    """
5534 
    Updates the agent who handled the COD verification call
5535 
 
5536 
    Parameters:
5537 
     - agent
5538 
     - orderId
5539 
    """
5540 
    self.send_updateCODAgent(agent, orderId)
5541 
    self.recv_updateCODAgent()
5542 
 
5543 
  def send_updateCODAgent(self, agent, orderId):
5544 
    self._oprot.writeMessageBegin('updateCODAgent', TMessageType.CALL, self._seqid)
5545 
    args = updateCODAgent_args()
5546 
    args.agent = agent
5547 
    args.orderId = orderId
5548 
    args.write(self._oprot)
5549 
    self._oprot.writeMessageEnd()
5550 
    self._oprot.trans.flush()
5551 
 
5552 
  def recv_updateCODAgent(self, ):
5553 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5554 
    if mtype == TMessageType.EXCEPTION:
5555 
      x = TApplicationException()
5556 
      x.read(self._iprot)
5557 
      self._iprot.readMessageEnd()
5558 
      raise x
5559 
    result = updateCODAgent_result()
5560 
    result.read(self._iprot)
5561 
    self._iprot.readMessageEnd()
5562 
    if result.ex is not None:
5563 
      raise result.ex
5564 
    return
5565 
 
5099 varun.gupt 5566 
  def updateOrderAsPaidToVendor(self, orderId):
5567 
    """
5568 
    Parameters:
5569 
     - orderId
5570 
    """
5571 
    self.send_updateOrderAsPaidToVendor(orderId)
5572 
    self.recv_updateOrderAsPaidToVendor()
5067 varun.gupt 5573 
 
5099 varun.gupt 5574 
  def send_updateOrderAsPaidToVendor(self, orderId):
5575 
    self._oprot.writeMessageBegin('updateOrderAsPaidToVendor', TMessageType.CALL, self._seqid)
5576 
    args = updateOrderAsPaidToVendor_args()
5577 
    args.orderId = orderId
5578 
    args.write(self._oprot)
5579 
    self._oprot.writeMessageEnd()
5580 
    self._oprot.trans.flush()
5581 
 
5582 
  def recv_updateOrderAsPaidToVendor(self, ):
5583 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5584 
    if mtype == TMessageType.EXCEPTION:
5585 
      x = TApplicationException()
5586 
      x.read(self._iprot)
5587 
      self._iprot.readMessageEnd()
5588 
      raise x
5589 
    result = updateOrderAsPaidToVendor_result()
5590 
    result.read(self._iprot)
5591 
    self._iprot.readMessageEnd()
5592 
    if result.ex is not None:
5593 
      raise result.ex
5594 
    return
5595 
 
5386 phani.kuma 5596 
  def updateOrderOnlyAsPaidToVendor(self, orderId):
5597 
    """
5598 
    Parameters:
5599 
     - orderId
5600 
    """
5601 
    self.send_updateOrderOnlyAsPaidToVendor(orderId)
5602 
    self.recv_updateOrderOnlyAsPaidToVendor()
5603 
 
5604 
  def send_updateOrderOnlyAsPaidToVendor(self, orderId):
5605 
    self._oprot.writeMessageBegin('updateOrderOnlyAsPaidToVendor', TMessageType.CALL, self._seqid)
5606 
    args = updateOrderOnlyAsPaidToVendor_args()
5607 
    args.orderId = orderId
5608 
    args.write(self._oprot)
5609 
    self._oprot.writeMessageEnd()
5610 
    self._oprot.trans.flush()
5611 
 
5612 
  def recv_updateOrderOnlyAsPaidToVendor(self, ):
5613 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5614 
    if mtype == TMessageType.EXCEPTION:
5615 
      x = TApplicationException()
5616 
      x.read(self._iprot)
5617 
      self._iprot.readMessageEnd()
5618 
      raise x
5619 
    result = updateOrderOnlyAsPaidToVendor_result()
5620 
    result.read(self._iprot)
5621 
    self._iprot.readMessageEnd()
5622 
    if result.ex is not None:
5623 
      raise result.ex
5624 
    return
5625 
 
5208 varun.gupt 5626 
  def getRefundedOrdersMarkedPaid(self, ):
5627 
    self.send_getRefundedOrdersMarkedPaid()
5628 
    return self.recv_getRefundedOrdersMarkedPaid()
5099 varun.gupt 5629 
 
5208 varun.gupt 5630 
  def send_getRefundedOrdersMarkedPaid(self, ):
5631 
    self._oprot.writeMessageBegin('getRefundedOrdersMarkedPaid', TMessageType.CALL, self._seqid)
5632 
    args = getRefundedOrdersMarkedPaid_args()
5633 
    args.write(self._oprot)
5634 
    self._oprot.writeMessageEnd()
5635 
    self._oprot.trans.flush()
5636 
 
5637 
  def recv_getRefundedOrdersMarkedPaid(self, ):
5638 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5639 
    if mtype == TMessageType.EXCEPTION:
5640 
      x = TApplicationException()
5641 
      x.read(self._iprot)
5642 
      self._iprot.readMessageEnd()
5643 
      raise x
5644 
    result = getRefundedOrdersMarkedPaid_result()
5645 
    result.read(self._iprot)
5646 
    self._iprot.readMessageEnd()
5647 
    if result.success is not None:
5648 
      return result.success
5649 
    if result.ex is not None:
5650 
      raise result.ex
5651 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getRefundedOrdersMarkedPaid failed: unknown result");
5652 
 
5447 anupam.sin 5653 
  def getAllVerificationAgents(self, minOrderId, maxOrderId):
5654 
    """
5655 
    gets all COD Verification Agents for all orderIds from a minId to maxId
5208 varun.gupt 5656 
 
5447 anupam.sin 5657 
 
5658 
    Parameters:
5659 
     - minOrderId
5660 
     - maxOrderId
5661 
    """
5662 
    self.send_getAllVerificationAgents(minOrderId, maxOrderId)
5663 
    return self.recv_getAllVerificationAgents()
5664 
 
5665 
  def send_getAllVerificationAgents(self, minOrderId, maxOrderId):
5666 
    self._oprot.writeMessageBegin('getAllVerificationAgents', TMessageType.CALL, self._seqid)
5667 
    args = getAllVerificationAgents_args()
5668 
    args.minOrderId = minOrderId
5669 
    args.maxOrderId = maxOrderId
5670 
    args.write(self._oprot)
5671 
    self._oprot.writeMessageEnd()
5672 
    self._oprot.trans.flush()
5673 
 
5674 
  def recv_getAllVerificationAgents(self, ):
5675 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5676 
    if mtype == TMessageType.EXCEPTION:
5677 
      x = TApplicationException()
5678 
      x.read(self._iprot)
5679 
      self._iprot.readMessageEnd()
5680 
      raise x
5681 
    result = getAllVerificationAgents_result()
5682 
    result.read(self._iprot)
5683 
    self._iprot.readMessageEnd()
5684 
    if result.success is not None:
5685 
      return result.success
5686 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllVerificationAgents failed: unknown result");
5687 
 
5527 anupam.sin 5688 
  def getAllAttributesForOrderId(self, orderId):
5689 
    """
5690 
    gets all attributes for a given orderId
5447 anupam.sin 5691 
 
5527 anupam.sin 5692 
    Parameters:
5693 
     - orderId
5694 
    """
5695 
    self.send_getAllAttributesForOrderId(orderId)
5696 
    return self.recv_getAllAttributesForOrderId()
5697 
 
5698 
  def send_getAllAttributesForOrderId(self, orderId):
5699 
    self._oprot.writeMessageBegin('getAllAttributesForOrderId', TMessageType.CALL, self._seqid)
5700 
    args = getAllAttributesForOrderId_args()
5701 
    args.orderId = orderId
5702 
    args.write(self._oprot)
5703 
    self._oprot.writeMessageEnd()
5704 
    self._oprot.trans.flush()
5705 
 
5706 
  def recv_getAllAttributesForOrderId(self, ):
5707 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5708 
    if mtype == TMessageType.EXCEPTION:
5709 
      x = TApplicationException()
5710 
      x.read(self._iprot)
5711 
      self._iprot.readMessageEnd()
5712 
      raise x
5713 
    result = getAllAttributesForOrderId_result()
5714 
    result.read(self._iprot)
5715 
    self._iprot.readMessageEnd()
5716 
    if result.success is not None:
5717 
      return result.success
5718 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllAttributesForOrderId failed: unknown result");
5719 
 
5676 rajveer 5720 
  def setOrderAttributes(self, orderId, attributes):
5721 
    """
5722 
    sets attributes for an order
5723 
 
5724 
    Parameters:
5725 
     - orderId
5726 
     - attributes
5727 
    """
5728 
    self.send_setOrderAttributes(orderId, attributes)
5729 
    self.recv_setOrderAttributes()
5730 
 
5731 
  def send_setOrderAttributes(self, orderId, attributes):
5732 
    self._oprot.writeMessageBegin('setOrderAttributes', TMessageType.CALL, self._seqid)
5733 
    args = setOrderAttributes_args()
5734 
    args.orderId = orderId
5735 
    args.attributes = attributes
5736 
    args.write(self._oprot)
5737 
    self._oprot.writeMessageEnd()
5738 
    self._oprot.trans.flush()
5739 
 
5740 
  def recv_setOrderAttributes(self, ):
5741 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5742 
    if mtype == TMessageType.EXCEPTION:
5743 
      x = TApplicationException()
5744 
      x.read(self._iprot)
5745 
      self._iprot.readMessageEnd()
5746 
      raise x
5747 
    result = setOrderAttributes_result()
5748 
    result.read(self._iprot)
5749 
    self._iprot.readMessageEnd()
5750 
    return
5751 
 
5527 anupam.sin 5752 
  def setOrderAttributeForTransaction(self, transactionId, attribute):
5753 
    """
5754 
    sets attributes for all orders in a transaction
5755 
 
5756 
    Parameters:
5757 
     - transactionId
5758 
     - attribute
5759 
    """
5760 
    self.send_setOrderAttributeForTransaction(transactionId, attribute)
5761 
    self.recv_setOrderAttributeForTransaction()
5762 
 
5763 
  def send_setOrderAttributeForTransaction(self, transactionId, attribute):
5764 
    self._oprot.writeMessageBegin('setOrderAttributeForTransaction', TMessageType.CALL, self._seqid)
5765 
    args = setOrderAttributeForTransaction_args()
5766 
    args.transactionId = transactionId
5767 
    args.attribute = attribute
5768 
    args.write(self._oprot)
5769 
    self._oprot.writeMessageEnd()
5770 
    self._oprot.trans.flush()
5771 
 
5772 
  def recv_setOrderAttributeForTransaction(self, ):
5773 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5774 
    if mtype == TMessageType.EXCEPTION:
5775 
      x = TApplicationException()
5776 
      x.read(self._iprot)
5777 
      self._iprot.readMessageEnd()
5778 
      raise x
5779 
    result = setOrderAttributeForTransaction_result()
5780 
    result.read(self._iprot)
5781 
    self._iprot.readMessageEnd()
5782 
    return
5783 
 
5553 rajveer 5784 
  def getReceivePendingOrders(self, storeId):
5785 
    """
5786 
    Parameters:
5787 
     - storeId
5788 
    """
5789 
    self.send_getReceivePendingOrders(storeId)
5790 
    return self.recv_getReceivePendingOrders()
5527 anupam.sin 5791 
 
5553 rajveer 5792 
  def send_getReceivePendingOrders(self, storeId):
5793 
    self._oprot.writeMessageBegin('getReceivePendingOrders', TMessageType.CALL, self._seqid)
5794 
    args = getReceivePendingOrders_args()
5795 
    args.storeId = storeId
5796 
    args.write(self._oprot)
5797 
    self._oprot.writeMessageEnd()
5798 
    self._oprot.trans.flush()
5799 
 
5800 
  def recv_getReceivePendingOrders(self, ):
5801 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5802 
    if mtype == TMessageType.EXCEPTION:
5803 
      x = TApplicationException()
5804 
      x.read(self._iprot)
5805 
      self._iprot.readMessageEnd()
5806 
      raise x
5807 
    result = getReceivePendingOrders_result()
5808 
    result.read(self._iprot)
5809 
    self._iprot.readMessageEnd()
5810 
    if result.success is not None:
5811 
      return result.success
5812 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReceivePendingOrders failed: unknown result");
5813 
 
5814 
  def getReceivedAtStoreOrders(self, storeId):
5815 
    """
5816 
    Parameters:
5817 
     - storeId
5818 
    """
5819 
    self.send_getReceivedAtStoreOrders(storeId)
5820 
    return self.recv_getReceivedAtStoreOrders()
5821 
 
5822 
  def send_getReceivedAtStoreOrders(self, storeId):
5823 
    self._oprot.writeMessageBegin('getReceivedAtStoreOrders', TMessageType.CALL, self._seqid)
5824 
    args = getReceivedAtStoreOrders_args()
5825 
    args.storeId = storeId
5826 
    args.write(self._oprot)
5827 
    self._oprot.writeMessageEnd()
5828 
    self._oprot.trans.flush()
5829 
 
5830 
  def recv_getReceivedAtStoreOrders(self, ):
5831 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5832 
    if mtype == TMessageType.EXCEPTION:
5833 
      x = TApplicationException()
5834 
      x.read(self._iprot)
5835 
      self._iprot.readMessageEnd()
5836 
      raise x
5837 
    result = getReceivedAtStoreOrders_result()
5838 
    result.read(self._iprot)
5839 
    self._iprot.readMessageEnd()
5840 
    if result.success is not None:
5841 
      return result.success
5842 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReceivedAtStoreOrders failed: unknown result");
5843 
 
5713 rajveer 5844 
  def getOrdersCollectionAtStore(self, storeId, fromDate, toDate, onlyCod):
5845 
    """
5846 
    Parameters:
5847 
     - storeId
5848 
     - fromDate
5849 
     - toDate
5850 
     - onlyCod
5851 
    """
5852 
    self.send_getOrdersCollectionAtStore(storeId, fromDate, toDate, onlyCod)
5853 
    return self.recv_getOrdersCollectionAtStore()
5854 
 
5855 
  def send_getOrdersCollectionAtStore(self, storeId, fromDate, toDate, onlyCod):
5856 
    self._oprot.writeMessageBegin('getOrdersCollectionAtStore', TMessageType.CALL, self._seqid)
5857 
    args = getOrdersCollectionAtStore_args()
5858 
    args.storeId = storeId
5859 
    args.fromDate = fromDate
5860 
    args.toDate = toDate
5861 
    args.onlyCod = onlyCod
5862 
    args.write(self._oprot)
5863 
    self._oprot.writeMessageEnd()
5864 
    self._oprot.trans.flush()
5865 
 
5866 
  def recv_getOrdersCollectionAtStore(self, ):
5867 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5868 
    if mtype == TMessageType.EXCEPTION:
5869 
      x = TApplicationException()
5870 
      x.read(self._iprot)
5871 
      self._iprot.readMessageEnd()
5872 
      raise x
5873 
    result = getOrdersCollectionAtStore_result()
5874 
    result.read(self._iprot)
5875 
    self._iprot.readMessageEnd()
5876 
    if result.success is not None:
5877 
      return result.success
5878 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersCollectionAtStore failed: unknown result");
5879 
 
5833 rajveer 5880 
  def getOrderAttributeValue(self, orderId, attributeName):
5881 
    """
5882 
    Parameters:
5883 
     - orderId
5884 
     - attributeName
5885 
    """
5886 
    self.send_getOrderAttributeValue(orderId, attributeName)
5887 
    return self.recv_getOrderAttributeValue()
5888 
 
5889 
  def send_getOrderAttributeValue(self, orderId, attributeName):
5890 
    self._oprot.writeMessageBegin('getOrderAttributeValue', TMessageType.CALL, self._seqid)
5891 
    args = getOrderAttributeValue_args()
5892 
    args.orderId = orderId
5893 
    args.attributeName = attributeName
5894 
    args.write(self._oprot)
5895 
    self._oprot.writeMessageEnd()
5896 
    self._oprot.trans.flush()
5897 
 
5898 
  def recv_getOrderAttributeValue(self, ):
5899 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5900 
    if mtype == TMessageType.EXCEPTION:
5901 
      x = TApplicationException()
5902 
      x.read(self._iprot)
5903 
      self._iprot.readMessageEnd()
5904 
      raise x
5905 
    result = getOrderAttributeValue_result()
5906 
    result.read(self._iprot)
5907 
    self._iprot.readMessageEnd()
5908 
    if result.success is not None:
5909 
      return result.success
5910 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderAttributeValue failed: unknown result");
5911 
 
6019 rajveer 5912 
  def changeJacketNumber(self, orderId, jacketNumber):
5913 
    """
5914 
    Parameters:
5915 
     - orderId
5916 
     - jacketNumber
5917 
    """
5918 
    self.send_changeJacketNumber(orderId, jacketNumber)
5919 
    return self.recv_changeJacketNumber()
5920 
 
5921 
  def send_changeJacketNumber(self, orderId, jacketNumber):
5922 
    self._oprot.writeMessageBegin('changeJacketNumber', TMessageType.CALL, self._seqid)
5923 
    args = changeJacketNumber_args()
5924 
    args.orderId = orderId
5925 
    args.jacketNumber = jacketNumber
5926 
    args.write(self._oprot)
5927 
    self._oprot.writeMessageEnd()
5928 
    self._oprot.trans.flush()
5929 
 
5930 
  def recv_changeJacketNumber(self, ):
5931 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5932 
    if mtype == TMessageType.EXCEPTION:
5933 
      x = TApplicationException()
5934 
      x.read(self._iprot)
5935 
      self._iprot.readMessageEnd()
5936 
      raise x
5937 
    result = changeJacketNumber_result()
5938 
    result.read(self._iprot)
5939 
    self._iprot.readMessageEnd()
5940 
    if result.success is not None:
5941 
      return result.success
5942 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "changeJacketNumber failed: unknown result");
5943 
 
5944 
  def markOrderAsRtoInTransit(self, orderId):
5945 
    """
5946 
    Parameters:
5947 
     - orderId
5948 
    """
5949 
    self.send_markOrderAsRtoInTransit(orderId)
5950 
    return self.recv_markOrderAsRtoInTransit()
5951 
 
5952 
  def send_markOrderAsRtoInTransit(self, orderId):
5953 
    self._oprot.writeMessageBegin('markOrderAsRtoInTransit', TMessageType.CALL, self._seqid)
5954 
    args = markOrderAsRtoInTransit_args()
5955 
    args.orderId = orderId
5956 
    args.write(self._oprot)
5957 
    self._oprot.writeMessageEnd()
5958 
    self._oprot.trans.flush()
5959 
 
5960 
  def recv_markOrderAsRtoInTransit(self, ):
5961 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5962 
    if mtype == TMessageType.EXCEPTION:
5963 
      x = TApplicationException()
5964 
      x.read(self._iprot)
5965 
      self._iprot.readMessageEnd()
5966 
      raise x
5967 
    result = markOrderAsRtoInTransit_result()
5968 
    result.read(self._iprot)
5969 
    self._iprot.readMessageEnd()
5970 
    if result.success is not None:
5971 
      return result.success
5972 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderAsRtoInTransit failed: unknown result");
5973 
 
5593 mandeep.dh 5974 
  def acceptOrderForItem(self, itemId, quantity, fulfilmentWarehouseId, billingWarehouseId):
5975 
    """
5976 
    Accepts appropriate order for an item in a given billingWarehouse. Usually
5977 
    invoked while scanning IN of items.
5553 rajveer 5978 
 
5593 mandeep.dh 5979 
    Parameters:
5980 
     - itemId
5981 
     - quantity
5982 
     - fulfilmentWarehouseId
5983 
     - billingWarehouseId
5984 
    """
5985 
    self.send_acceptOrderForItem(itemId, quantity, fulfilmentWarehouseId, billingWarehouseId)
5986 
    self.recv_acceptOrderForItem()
5987 
 
5988 
  def send_acceptOrderForItem(self, itemId, quantity, fulfilmentWarehouseId, billingWarehouseId):
5989 
    self._oprot.writeMessageBegin('acceptOrderForItem', TMessageType.CALL, self._seqid)
5990 
    args = acceptOrderForItem_args()
5991 
    args.itemId = itemId
5992 
    args.quantity = quantity
5993 
    args.fulfilmentWarehouseId = fulfilmentWarehouseId
5994 
    args.billingWarehouseId = billingWarehouseId
5995 
    args.write(self._oprot)
5996 
    self._oprot.writeMessageEnd()
5997 
    self._oprot.trans.flush()
5998 
 
5999 
  def recv_acceptOrderForItem(self, ):
6000 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6001 
    if mtype == TMessageType.EXCEPTION:
6002 
      x = TApplicationException()
6003 
      x.read(self._iprot)
6004 
      self._iprot.readMessageEnd()
6005 
      raise x
6006 
    result = acceptOrderForItem_result()
6007 
    result.read(self._iprot)
6008 
    self._iprot.readMessageEnd()
6009 
    return
6010 
 
6000 mandeep.dh 6011 
  def createRechargeOrder(self, rechargeOrder):
6012 
    """
6013 
    Parameters:
6014 
     - rechargeOrder
6015 
    """
6016 
    self.send_createRechargeOrder(rechargeOrder)
6017 
    return self.recv_createRechargeOrder()
5593 mandeep.dh 6018 
 
6000 mandeep.dh 6019 
  def send_createRechargeOrder(self, rechargeOrder):
6020 
    self._oprot.writeMessageBegin('createRechargeOrder', TMessageType.CALL, self._seqid)
6021 
    args = createRechargeOrder_args()
6022 
    args.rechargeOrder = rechargeOrder
6023 
    args.write(self._oprot)
6024 
    self._oprot.writeMessageEnd()
6025 
    self._oprot.trans.flush()
6026 
 
6027 
  def recv_createRechargeOrder(self, ):
6028 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6029 
    if mtype == TMessageType.EXCEPTION:
6030 
      x = TApplicationException()
6031 
      x.read(self._iprot)
6032 
      self._iprot.readMessageEnd()
6033 
      raise x
6034 
    result = createRechargeOrder_result()
6035 
    result.read(self._iprot)
6036 
    self._iprot.readMessageEnd()
6037 
    if result.success is not None:
6038 
      return result.success
6039 
    if result.ex is not None:
6040 
      raise result.ex
6041 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createRechargeOrder failed: unknown result");
6042 
 
6031 rajveer 6043 
  def getRechargeOrder(self, rechargeRrderId):
6044 
    """
6045 
    Parameters:
6046 
     - rechargeRrderId
6047 
    """
6048 
    self.send_getRechargeOrder(rechargeRrderId)
6049 
    return self.recv_getRechargeOrder()
6050 
 
6051 
  def send_getRechargeOrder(self, rechargeRrderId):
6052 
    self._oprot.writeMessageBegin('getRechargeOrder', TMessageType.CALL, self._seqid)
6053 
    args = getRechargeOrder_args()
6054 
    args.rechargeRrderId = rechargeRrderId
6055 
    args.write(self._oprot)
6056 
    self._oprot.writeMessageEnd()
6057 
    self._oprot.trans.flush()
6058 
 
6059 
  def recv_getRechargeOrder(self, ):
6060 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6061 
    if mtype == TMessageType.EXCEPTION:
6062 
      x = TApplicationException()
6063 
      x.read(self._iprot)
6064 
      self._iprot.readMessageEnd()
6065 
      raise x
6066 
    result = getRechargeOrder_result()
6067 
    result.read(self._iprot)
6068 
    self._iprot.readMessageEnd()
6069 
    if result.success is not None:
6070 
      return result.success
6071 
    if result.ex is not None:
6072 
      raise result.ex
6073 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getRechargeOrder failed: unknown result");
6074 
 
6075 
  def getRechargeOrders(self, userId):
6076 
    """
6077 
    Parameters:
6078 
     - userId
6079 
    """
6080 
    self.send_getRechargeOrders(userId)
6081 
    return self.recv_getRechargeOrders()
6082 
 
6083 
  def send_getRechargeOrders(self, userId):
6084 
    self._oprot.writeMessageBegin('getRechargeOrders', TMessageType.CALL, self._seqid)
6085 
    args = getRechargeOrders_args()
6086 
    args.userId = userId
6087 
    args.write(self._oprot)
6088 
    self._oprot.writeMessageEnd()
6089 
    self._oprot.trans.flush()
6090 
 
6091 
  def recv_getRechargeOrders(self, ):
6092 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6093 
    if mtype == TMessageType.EXCEPTION:
6094 
      x = TApplicationException()
6095 
      x.read(self._iprot)
6096 
      self._iprot.readMessageEnd()
6097 
      raise x
6098 
    result = getRechargeOrders_result()
6099 
    result.read(self._iprot)
6100 
    self._iprot.readMessageEnd()
6101 
    if result.success is not None:
6102 
      return result.success
6103 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getRechargeOrders failed: unknown result");
6104 
 
6000 mandeep.dh 6105 
  def updateRechargeOrderStatus(self, rechargeOrderId, rechargeOrderStatus):
6106 
    """
6107 
    Parameters:
6108 
     - rechargeOrderId
6109 
     - rechargeOrderStatus
6110 
    """
6111 
    self.send_updateRechargeOrderStatus(rechargeOrderId, rechargeOrderStatus)
6031 rajveer 6112 
    return self.recv_updateRechargeOrderStatus()
6000 mandeep.dh 6113 
 
6114 
  def send_updateRechargeOrderStatus(self, rechargeOrderId, rechargeOrderStatus):
6115 
    self._oprot.writeMessageBegin('updateRechargeOrderStatus', TMessageType.CALL, self._seqid)
6116 
    args = updateRechargeOrderStatus_args()
6117 
    args.rechargeOrderId = rechargeOrderId
6118 
    args.rechargeOrderStatus = rechargeOrderStatus
6119 
    args.write(self._oprot)
6120 
    self._oprot.writeMessageEnd()
6121 
    self._oprot.trans.flush()
6122 
 
6123 
  def recv_updateRechargeOrderStatus(self, ):
6124 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6125 
    if mtype == TMessageType.EXCEPTION:
6126 
      x = TApplicationException()
6127 
      x.read(self._iprot)
6128 
      self._iprot.readMessageEnd()
6129 
      raise x
6130 
    result = updateRechargeOrderStatus_result()
6131 
    result.read(self._iprot)
6132 
    self._iprot.readMessageEnd()
6031 rajveer 6133 
    if result.success is not None:
6134 
      return result.success
6000 mandeep.dh 6135 
    if result.ex is not None:
6136 
      raise result.ex
6031 rajveer 6137 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updateRechargeOrderStatus failed: unknown result");
6000 mandeep.dh 6138 
 
6031 rajveer 6139 
  def activateRechargeTxn(self, rechargeOrderId):
6000 mandeep.dh 6140 
    """
6141 
    Parameters:
6031 rajveer 6142 
     - rechargeOrderId
6000 mandeep.dh 6143 
    """
6031 rajveer 6144 
    self.send_activateRechargeTxn(rechargeOrderId)
6000 mandeep.dh 6145 
    return self.recv_activateRechargeTxn()
6146 
 
6031 rajveer 6147 
  def send_activateRechargeTxn(self, rechargeOrderId):
6000 mandeep.dh 6148 
    self._oprot.writeMessageBegin('activateRechargeTxn', TMessageType.CALL, self._seqid)
6149 
    args = activateRechargeTxn_args()
6031 rajveer 6150 
    args.rechargeOrderId = rechargeOrderId
6000 mandeep.dh 6151 
    args.write(self._oprot)
6152 
    self._oprot.writeMessageEnd()
6153 
    self._oprot.trans.flush()
6154 
 
6155 
  def recv_activateRechargeTxn(self, ):
6156 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6157 
    if mtype == TMessageType.EXCEPTION:
6158 
      x = TApplicationException()
6159 
      x.read(self._iprot)
6160 
      self._iprot.readMessageEnd()
6161 
      raise x
6162 
    result = activateRechargeTxn_result()
6163 
    result.read(self._iprot)
6164 
    self._iprot.readMessageEnd()
6165 
    if result.success is not None:
6166 
      return result.success
6167 
    if result.ex is not None:
6168 
      raise result.ex
6169 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "activateRechargeTxn failed: unknown result");
6170 
 
6031 rajveer 6171 
  def getUserWallet(self, userId):
6000 mandeep.dh 6172 
    """
6173 
    Parameters:
6031 rajveer 6174 
     - userId
6000 mandeep.dh 6175 
    """
6031 rajveer 6176 
    self.send_getUserWallet(userId)
6177 
    return self.recv_getUserWallet()
6000 mandeep.dh 6178 
 
6031 rajveer 6179 
  def send_getUserWallet(self, userId):
6180 
    self._oprot.writeMessageBegin('getUserWallet', TMessageType.CALL, self._seqid)
6181 
    args = getUserWallet_args()
6182 
    args.userId = userId
6000 mandeep.dh 6183 
    args.write(self._oprot)
6184 
    self._oprot.writeMessageEnd()
6185 
    self._oprot.trans.flush()
6186 
 
6031 rajveer 6187 
  def recv_getUserWallet(self, ):
6000 mandeep.dh 6188 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6189 
    if mtype == TMessageType.EXCEPTION:
6190 
      x = TApplicationException()
6191 
      x.read(self._iprot)
6192 
      self._iprot.readMessageEnd()
6193 
      raise x
6031 rajveer 6194 
    result = getUserWallet_result()
6000 mandeep.dh 6195 
    result.read(self._iprot)
6196 
    self._iprot.readMessageEnd()
6197 
    if result.success is not None:
6198 
      return result.success
6031 rajveer 6199 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUserWallet failed: unknown result");
6000 mandeep.dh 6200 
 
6031 rajveer 6201 
  def getUserWalletHistory(self, userId):
6000 mandeep.dh 6202 
    """
6203 
    Parameters:
6031 rajveer 6204 
     - userId
6000 mandeep.dh 6205 
    """
6031 rajveer 6206 
    self.send_getUserWalletHistory(userId)
6207 
    return self.recv_getUserWalletHistory()
6000 mandeep.dh 6208 
 
6031 rajveer 6209 
  def send_getUserWalletHistory(self, userId):
6210 
    self._oprot.writeMessageBegin('getUserWalletHistory', TMessageType.CALL, self._seqid)
6211 
    args = getUserWalletHistory_args()
6212 
    args.userId = userId
6000 mandeep.dh 6213 
    args.write(self._oprot)
6214 
    self._oprot.writeMessageEnd()
6215 
    self._oprot.trans.flush()
6216 
 
6031 rajveer 6217 
  def recv_getUserWalletHistory(self, ):
6000 mandeep.dh 6218 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6219 
    if mtype == TMessageType.EXCEPTION:
6220 
      x = TApplicationException()
6221 
      x.read(self._iprot)
6222 
      self._iprot.readMessageEnd()
6223 
      raise x
6031 rajveer 6224 
    result = getUserWalletHistory_result()
6000 mandeep.dh 6225 
    result.read(self._iprot)
6226 
    self._iprot.readMessageEnd()
6227 
    if result.success is not None:
6228 
      return result.success
6031 rajveer 6229 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUserWalletHistory failed: unknown result");
6000 mandeep.dh 6230 
 
6050 anupam.sin 6231 
  def getRechargeOrdersForTransaction(self, txnId):
6232 
    """
6233 
    Returns a recharge order for a given transactionId
6234 
 
6235 
    Parameters:
6236 
     - txnId
6237 
    """
6238 
    self.send_getRechargeOrdersForTransaction(txnId)
6239 
    return self.recv_getRechargeOrdersForTransaction()
6240 
 
6241 
  def send_getRechargeOrdersForTransaction(self, txnId):
6242 
    self._oprot.writeMessageBegin('getRechargeOrdersForTransaction', TMessageType.CALL, self._seqid)
6243 
    args = getRechargeOrdersForTransaction_args()
6244 
    args.txnId = txnId
6245 
    args.write(self._oprot)
6246 
    self._oprot.writeMessageEnd()
6247 
    self._oprot.trans.flush()
6248 
 
6249 
  def recv_getRechargeOrdersForTransaction(self, ):
6250 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6251 
    if mtype == TMessageType.EXCEPTION:
6252 
      x = TApplicationException()
6253 
      x.read(self._iprot)
6254 
      self._iprot.readMessageEnd()
6255 
      raise x
6256 
    result = getRechargeOrdersForTransaction_result()
6257 
    result.read(self._iprot)
6258 
    self._iprot.readMessageEnd()
6259 
    if result.success is not None:
6260 
      return result.success
6261 
    if result.ex is not None:
6262 
      raise result.ex
6263 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getRechargeOrdersForTransaction failed: unknown result");
6264 
 
6206 rajveer 6265 
  def getServiceProviders(self, rechargeType, onlyActive):
6048 rajveer 6266 
    """
6267 
    Parameters:
6268 
     - rechargeType
6206 rajveer 6269 
     - onlyActive
6048 rajveer 6270 
    """
6206 rajveer 6271 
    self.send_getServiceProviders(rechargeType, onlyActive)
6048 rajveer 6272 
    return self.recv_getServiceProviders()
6000 mandeep.dh 6273 
 
6206 rajveer 6274 
  def send_getServiceProviders(self, rechargeType, onlyActive):
6048 rajveer 6275 
    self._oprot.writeMessageBegin('getServiceProviders', TMessageType.CALL, self._seqid)
6276 
    args = getServiceProviders_args()
6277 
    args.rechargeType = rechargeType
6206 rajveer 6278 
    args.onlyActive = onlyActive
6048 rajveer 6279 
    args.write(self._oprot)
6280 
    self._oprot.writeMessageEnd()
6281 
    self._oprot.trans.flush()
6282 
 
6283 
  def recv_getServiceProviders(self, ):
6284 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6285 
    if mtype == TMessageType.EXCEPTION:
6286 
      x = TApplicationException()
6287 
      x.read(self._iprot)
6288 
      self._iprot.readMessageEnd()
6289 
      raise x
6290 
    result = getServiceProviders_result()
6291 
    result.read(self._iprot)
6292 
    self._iprot.readMessageEnd()
6293 
    if result.success is not None:
6294 
      return result.success
6295 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getServiceProviders failed: unknown result");
6296 
 
6049 rajveer 6297 
  def getServiceProviderForDevice(self, rechargeType, deviceNumber):
6048 rajveer 6298 
    """
6299 
    Parameters:
6049 rajveer 6300 
     - rechargeType
6048 rajveer 6301 
     - deviceNumber
6302 
    """
6049 rajveer 6303 
    self.send_getServiceProviderForDevice(rechargeType, deviceNumber)
6048 rajveer 6304 
    return self.recv_getServiceProviderForDevice()
6305 
 
6049 rajveer 6306 
  def send_getServiceProviderForDevice(self, rechargeType, deviceNumber):
6048 rajveer 6307 
    self._oprot.writeMessageBegin('getServiceProviderForDevice', TMessageType.CALL, self._seqid)
6308 
    args = getServiceProviderForDevice_args()
6049 rajveer 6309 
    args.rechargeType = rechargeType
6048 rajveer 6310 
    args.deviceNumber = deviceNumber
6311 
    args.write(self._oprot)
6312 
    self._oprot.writeMessageEnd()
6313 
    self._oprot.trans.flush()
6314 
 
6315 
  def recv_getServiceProviderForDevice(self, ):
6316 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6317 
    if mtype == TMessageType.EXCEPTION:
6318 
      x = TApplicationException()
6319 
      x.read(self._iprot)
6320 
      self._iprot.readMessageEnd()
6321 
      raise x
6322 
    result = getServiceProviderForDevice_result()
6323 
    result.read(self._iprot)
6324 
    self._iprot.readMessageEnd()
6325 
    if result.success is not None:
6326 
      return result.success
6327 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getServiceProviderForDevice failed: unknown result");
6328 
 
6591 anupam.sin 6329 
  def validateRecharge(self, rechargeType, deviceNumber, userSelectedProviderId, clientAddress):
6269 rajveer 6330 
    """
6331 
    Parameters:
6332 
     - rechargeType
6333 
     - deviceNumber
6307 anupam.sin 6334 
     - userSelectedProviderId
6591 anupam.sin 6335 
     - clientAddress
6269 rajveer 6336 
    """
6591 anupam.sin 6337 
    self.send_validateRecharge(rechargeType, deviceNumber, userSelectedProviderId, clientAddress)
6269 rajveer 6338 
    return self.recv_validateRecharge()
6339 
 
6591 anupam.sin 6340 
  def send_validateRecharge(self, rechargeType, deviceNumber, userSelectedProviderId, clientAddress):
6269 rajveer 6341 
    self._oprot.writeMessageBegin('validateRecharge', TMessageType.CALL, self._seqid)
6342 
    args = validateRecharge_args()
6343 
    args.rechargeType = rechargeType
6344 
    args.deviceNumber = deviceNumber
6307 anupam.sin 6345 
    args.userSelectedProviderId = userSelectedProviderId
6591 anupam.sin 6346 
    args.clientAddress = clientAddress
6269 rajveer 6347 
    args.write(self._oprot)
6348 
    self._oprot.writeMessageEnd()
6349 
    self._oprot.trans.flush()
6350 
 
6351 
  def recv_validateRecharge(self, ):
6352 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6353 
    if mtype == TMessageType.EXCEPTION:
6354 
      x = TApplicationException()
6355 
      x.read(self._iprot)
6356 
      self._iprot.readMessageEnd()
6357 
      raise x
6358 
    result = validateRecharge_result()
6359 
    result.read(self._iprot)
6360 
    self._iprot.readMessageEnd()
6361 
    if result.success is not None:
6362 
      return result.success
6363 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "validateRecharge failed: unknown result");
6364 
 
6094 rajveer 6365 
  def getRechargeOrdersForDevice(self, deviceNumber):
6366 
    """
6367 
    Parameters:
6368 
     - deviceNumber
6369 
    """
6370 
    self.send_getRechargeOrdersForDevice(deviceNumber)
6371 
    return self.recv_getRechargeOrdersForDevice()
6048 rajveer 6372 
 
6094 rajveer 6373 
  def send_getRechargeOrdersForDevice(self, deviceNumber):
6374 
    self._oprot.writeMessageBegin('getRechargeOrdersForDevice', TMessageType.CALL, self._seqid)
6375 
    args = getRechargeOrdersForDevice_args()
6376 
    args.deviceNumber = deviceNumber
6377 
    args.write(self._oprot)
6378 
    self._oprot.writeMessageEnd()
6379 
    self._oprot.trans.flush()
6380 
 
6381 
  def recv_getRechargeOrdersForDevice(self, ):
6382 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6383 
    if mtype == TMessageType.EXCEPTION:
6384 
      x = TApplicationException()
6385 
      x.read(self._iprot)
6386 
      self._iprot.readMessageEnd()
6387 
      raise x
6388 
    result = getRechargeOrdersForDevice_result()
6389 
    result.read(self._iprot)
6390 
    self._iprot.readMessageEnd()
6391 
    if result.success is not None:
6392 
      return result.success
6393 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getRechargeOrdersForDevice failed: unknown result");
6394 
 
6395 
  def addAmountToWallet(self, userId, orderId, amount):
6396 
    """
6397 
    Parameters:
6398 
     - userId
6399 
     - orderId
6400 
     - amount
6401 
    """
6402 
    self.send_addAmountToWallet(userId, orderId, amount)
6403 
    self.recv_addAmountToWallet()
6404 
 
6405 
  def send_addAmountToWallet(self, userId, orderId, amount):
6406 
    self._oprot.writeMessageBegin('addAmountToWallet', TMessageType.CALL, self._seqid)
6407 
    args = addAmountToWallet_args()
6408 
    args.userId = userId
6409 
    args.orderId = orderId
6410 
    args.amount = amount
6411 
    args.write(self._oprot)
6412 
    self._oprot.writeMessageEnd()
6413 
    self._oprot.trans.flush()
6414 
 
6415 
  def recv_addAmountToWallet(self, ):
6416 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6417 
    if mtype == TMessageType.EXCEPTION:
6418 
      x = TApplicationException()
6419 
      x.read(self._iprot)
6420 
      self._iprot.readMessageEnd()
6421 
      raise x
6422 
    result = addAmountToWallet_result()
6423 
    result.read(self._iprot)
6424 
    self._iprot.readMessageEnd()
6425 
    return
6426 
 
6188 rajveer 6427 
  def getRechargeStatistics(self, ):
6428 
    self.send_getRechargeStatistics()
6429 
    return self.recv_getRechargeStatistics()
6430 
 
6431 
  def send_getRechargeStatistics(self, ):
6432 
    self._oprot.writeMessageBegin('getRechargeStatistics', TMessageType.CALL, self._seqid)
6433 
    args = getRechargeStatistics_args()
6434 
    args.write(self._oprot)
6435 
    self._oprot.writeMessageEnd()
6436 
    self._oprot.trans.flush()
6437 
 
6438 
  def recv_getRechargeStatistics(self, ):
6439 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6440 
    if mtype == TMessageType.EXCEPTION:
6441 
      x = TApplicationException()
6442 
      x.read(self._iprot)
6443 
      self._iprot.readMessageEnd()
6444 
      raise x
6445 
    result = getRechargeStatistics_result()
6446 
    result.read(self._iprot)
6447 
    self._iprot.readMessageEnd()
6448 
    if result.success is not None:
6449 
      return result.success
6450 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getRechargeStatistics failed: unknown result");
6451 
 
6154 rajveer 6452 
  def getRechargeOrdersForStatus(self, status):
6453 
    """
6454 
    Parameters:
6455 
     - status
6456 
    """
6457 
    self.send_getRechargeOrdersForStatus(status)
6458 
    return self.recv_getRechargeOrdersForStatus()
6094 rajveer 6459 
 
6154 rajveer 6460 
  def send_getRechargeOrdersForStatus(self, status):
6461 
    self._oprot.writeMessageBegin('getRechargeOrdersForStatus', TMessageType.CALL, self._seqid)
6462 
    args = getRechargeOrdersForStatus_args()
6463 
    args.status = status
6464 
    args.write(self._oprot)
6465 
    self._oprot.writeMessageEnd()
6466 
    self._oprot.trans.flush()
6467 
 
6468 
  def recv_getRechargeOrdersForStatus(self, ):
6469 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6470 
    if mtype == TMessageType.EXCEPTION:
6471 
      x = TApplicationException()
6472 
      x.read(self._iprot)
6473 
      self._iprot.readMessageEnd()
6474 
      raise x
6475 
    result = getRechargeOrdersForStatus_result()
6476 
    result.read(self._iprot)
6477 
    self._iprot.readMessageEnd()
6478 
    if result.success is not None:
6479 
      return result.success
6480 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getRechargeOrdersForStatus failed: unknown result");
6481 
 
6159 rajveer 6482 
  def getPlansForOperator(self, operatorId):
6483 
    """
6484 
    Parameters:
6485 
     - operatorId
6486 
    """
6487 
    self.send_getPlansForOperator(operatorId)
6488 
    return self.recv_getPlansForOperator()
6154 rajveer 6489 
 
6159 rajveer 6490 
  def send_getPlansForOperator(self, operatorId):
6491 
    self._oprot.writeMessageBegin('getPlansForOperator', TMessageType.CALL, self._seqid)
6492 
    args = getPlansForOperator_args()
6493 
    args.operatorId = operatorId
6494 
    args.write(self._oprot)
6495 
    self._oprot.writeMessageEnd()
6496 
    self._oprot.trans.flush()
6497 
 
6498 
  def recv_getPlansForOperator(self, ):
6499 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6500 
    if mtype == TMessageType.EXCEPTION:
6501 
      x = TApplicationException()
6502 
      x.read(self._iprot)
6503 
      self._iprot.readMessageEnd()
6504 
      raise x
6505 
    result = getPlansForOperator_result()
6506 
    result.read(self._iprot)
6507 
    self._iprot.readMessageEnd()
6508 
    if result.success is not None:
6509 
      return result.success
6510 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getPlansForOperator failed: unknown result");
6511 
 
6307 anupam.sin 6512 
  def getRechargeDenominations(self, operatorId, circleCode, denominationType):
6289 anupam.sin 6513 
    """
6514 
    Returns denominations for a given operator and circle
6159 rajveer 6515 
 
6289 anupam.sin 6516 
    Parameters:
6517 
     - operatorId
6307 anupam.sin 6518 
     - circleCode
6289 anupam.sin 6519 
     - denominationType
6520 
    """
6307 anupam.sin 6521 
    self.send_getRechargeDenominations(operatorId, circleCode, denominationType)
6289 anupam.sin 6522 
    return self.recv_getRechargeDenominations()
6523 
 
6307 anupam.sin 6524 
  def send_getRechargeDenominations(self, operatorId, circleCode, denominationType):
6289 anupam.sin 6525 
    self._oprot.writeMessageBegin('getRechargeDenominations', TMessageType.CALL, self._seqid)
6526 
    args = getRechargeDenominations_args()
6527 
    args.operatorId = operatorId
6307 anupam.sin 6528 
    args.circleCode = circleCode
6289 anupam.sin 6529 
    args.denominationType = denominationType
6530 
    args.write(self._oprot)
6531 
    self._oprot.writeMessageEnd()
6532 
    self._oprot.trans.flush()
6533 
 
6534 
  def recv_getRechargeDenominations(self, ):
6535 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6536 
    if mtype == TMessageType.EXCEPTION:
6537 
      x = TApplicationException()
6538 
      x.read(self._iprot)
6539 
      self._iprot.readMessageEnd()
6540 
      raise x
6541 
    result = getRechargeDenominations_result()
6542 
    result.read(self._iprot)
6543 
    self._iprot.readMessageEnd()
6544 
    if result.success is not None:
6545 
      return result.success
6546 
    if result.ex is not None:
6547 
      raise result.ex
6548 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getRechargeDenominations failed: unknown result");
6549 
 
6371 rajveer 6550 
  def updateAvailabilityStatus(self, operatorId, circleId, isAvailable):
6551 
    """
6552 
    Parameters:
6553 
     - operatorId
6554 
     - circleId
6555 
     - isAvailable
6556 
    """
6557 
    self.send_updateAvailabilityStatus(operatorId, circleId, isAvailable)
6558 
    self.recv_updateAvailabilityStatus()
6289 anupam.sin 6559 
 
6371 rajveer 6560 
  def send_updateAvailabilityStatus(self, operatorId, circleId, isAvailable):
6561 
    self._oprot.writeMessageBegin('updateAvailabilityStatus', TMessageType.CALL, self._seqid)
6562 
    args = updateAvailabilityStatus_args()
6563 
    args.operatorId = operatorId
6564 
    args.circleId = circleId
6565 
    args.isAvailable = isAvailable
6566 
    args.write(self._oprot)
6567 
    self._oprot.writeMessageEnd()
6568 
    self._oprot.trans.flush()
6569 
 
6570 
  def recv_updateAvailabilityStatus(self, ):
6571 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6572 
    if mtype == TMessageType.EXCEPTION:
6573 
      x = TApplicationException()
6574 
      x.read(self._iprot)
6575 
      self._iprot.readMessageEnd()
6576 
      raise x
6577 
    result = updateAvailabilityStatus_result()
6578 
    result.read(self._iprot)
6579 
    self._iprot.readMessageEnd()
6580 
    return
6581 
 
6389 rajveer 6582 
  def getAvailableEmiSchemes(self, ):
6583 
    self.send_getAvailableEmiSchemes()
6584 
    return self.recv_getAvailableEmiSchemes()
6371 rajveer 6585 
 
6389 rajveer 6586 
  def send_getAvailableEmiSchemes(self, ):
6587 
    self._oprot.writeMessageBegin('getAvailableEmiSchemes', TMessageType.CALL, self._seqid)
6588 
    args = getAvailableEmiSchemes_args()
6589 
    args.write(self._oprot)
6590 
    self._oprot.writeMessageEnd()
6591 
    self._oprot.trans.flush()
6592 
 
6593 
  def recv_getAvailableEmiSchemes(self, ):
6594 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6595 
    if mtype == TMessageType.EXCEPTION:
6596 
      x = TApplicationException()
6597 
      x.read(self._iprot)
6598 
      self._iprot.readMessageEnd()
6599 
      raise x
6600 
    result = getAvailableEmiSchemes_result()
6601 
    result.read(self._iprot)
6602 
    self._iprot.readMessageEnd()
6603 
    if result.success is not None:
6604 
      return result.success
6605 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAvailableEmiSchemes failed: unknown result");
6606 
 
6607 
  def getMiscCharges(self, transactionId):
6608 
    """
6609 
    Parameters:
6610 
     - transactionId
6611 
    """
6612 
    self.send_getMiscCharges(transactionId)
6613 
    return self.recv_getMiscCharges()
6614 
 
6615 
  def send_getMiscCharges(self, transactionId):
6616 
    self._oprot.writeMessageBegin('getMiscCharges', TMessageType.CALL, self._seqid)
6617 
    args = getMiscCharges_args()
6618 
    args.transactionId = transactionId
6619 
    args.write(self._oprot)
6620 
    self._oprot.writeMessageEnd()
6621 
    self._oprot.trans.flush()
6622 
 
6623 
  def recv_getMiscCharges(self, ):
6624 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6625 
    if mtype == TMessageType.EXCEPTION:
6626 
      x = TApplicationException()
6627 
      x.read(self._iprot)
6628 
      self._iprot.readMessageEnd()
6629 
      raise x
6630 
    result = getMiscCharges_result()
6631 
    result.read(self._iprot)
6632 
    self._iprot.readMessageEnd()
6633 
    if result.success is not None:
6634 
      return result.success
6635 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getMiscCharges failed: unknown result");
6636 
 
6507 anupam.sin 6637 
  def refundRechargeOrder(self, rechargeOrderId):
6638 
    """
6639 
    Parameters:
6640 
     - rechargeOrderId
6641 
    """
6642 
    self.send_refundRechargeOrder(rechargeOrderId)
6643 
    return self.recv_refundRechargeOrder()
6389 rajveer 6644 
 
6507 anupam.sin 6645 
  def send_refundRechargeOrder(self, rechargeOrderId):
6646 
    self._oprot.writeMessageBegin('refundRechargeOrder', TMessageType.CALL, self._seqid)
6647 
    args = refundRechargeOrder_args()
6648 
    args.rechargeOrderId = rechargeOrderId
6649 
    args.write(self._oprot)
6650 
    self._oprot.writeMessageEnd()
6651 
    self._oprot.trans.flush()
6652 
 
6653 
  def recv_refundRechargeOrder(self, ):
6654 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6655 
    if mtype == TMessageType.EXCEPTION:
6656 
      x = TApplicationException()
6657 
      x.read(self._iprot)
6658 
      self._iprot.readMessageEnd()
6659 
      raise x
6660 
    result = refundRechargeOrder_result()
6661 
    result.read(self._iprot)
6662 
    self._iprot.readMessageEnd()
6663 
    if result.success is not None:
6664 
      return result.success
6665 
    if result.ex is not None:
6666 
      raise result.ex
6667 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "refundRechargeOrder failed: unknown result");
6668 
 
6821 amar.kumar 6669 
  def getPhysicalOrders(self, fromDate, toDate):
6670 
    """
6671 
    Parameters:
6672 
     - fromDate
6673 
     - toDate
6674 
    """
6675 
    self.send_getPhysicalOrders(fromDate, toDate)
6676 
    return self.recv_getPhysicalOrders()
6507 anupam.sin 6677 
 
6821 amar.kumar 6678 
  def send_getPhysicalOrders(self, fromDate, toDate):
6679 
    self._oprot.writeMessageBegin('getPhysicalOrders', TMessageType.CALL, self._seqid)
6680 
    args = getPhysicalOrders_args()
6681 
    args.fromDate = fromDate
6682 
    args.toDate = toDate
6683 
    args.write(self._oprot)
6684 
    self._oprot.writeMessageEnd()
6685 
    self._oprot.trans.flush()
6686 
 
6687 
  def recv_getPhysicalOrders(self, ):
6688 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6689 
    if mtype == TMessageType.EXCEPTION:
6690 
      x = TApplicationException()
6691 
      x.read(self._iprot)
6692 
      self._iprot.readMessageEnd()
6693 
      raise x
6694 
    result = getPhysicalOrders_result()
6695 
    result.read(self._iprot)
6696 
    self._iprot.readMessageEnd()
6697 
    if result.success is not None:
6698 
      return result.success
6699 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getPhysicalOrders failed: unknown result");
6700 
 
6906 rajveer 6701 
  def getDocument(self, docType, docSource):
6702 
    """
6703 
    Parameters:
6704 
     - docType
6705 
     - docSource
6706 
    """
6707 
    self.send_getDocument(docType, docSource)
6708 
    return self.recv_getDocument()
6821 amar.kumar 6709 
 
6906 rajveer 6710 
  def send_getDocument(self, docType, docSource):
6711 
    self._oprot.writeMessageBegin('getDocument', TMessageType.CALL, self._seqid)
6712 
    args = getDocument_args()
6713 
    args.docType = docType
6714 
    args.docSource = docSource
6715 
    args.write(self._oprot)
6716 
    self._oprot.writeMessageEnd()
6717 
    self._oprot.trans.flush()
6718 
 
6719 
  def recv_getDocument(self, ):
6720 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6721 
    if mtype == TMessageType.EXCEPTION:
6722 
      x = TApplicationException()
6723 
      x.read(self._iprot)
6724 
      self._iprot.readMessageEnd()
6725 
      raise x
6726 
    result = getDocument_result()
6727 
    result.read(self._iprot)
6728 
    self._iprot.readMessageEnd()
6729 
    if result.success is not None:
6730 
      return result.success
6731 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getDocument failed: unknown result");
6732 
 
6985 anupam.sin 6733 
  def changeShippingAddress(self, orderId, line1, line2, city, state, pin):
6734 
    """
6735 
    Parameters:
6736 
     - orderId
6737 
     - line1
6738 
     - line2
6739 
     - city
6740 
     - state
6741 
     - pin
6742 
    """
6743 
    self.send_changeShippingAddress(orderId, line1, line2, city, state, pin)
6744 
    return self.recv_changeShippingAddress()
6906 rajveer 6745 
 
6985 anupam.sin 6746 
  def send_changeShippingAddress(self, orderId, line1, line2, city, state, pin):
6747 
    self._oprot.writeMessageBegin('changeShippingAddress', TMessageType.CALL, self._seqid)
6748 
    args = changeShippingAddress_args()
6749 
    args.orderId = orderId
6750 
    args.line1 = line1
6751 
    args.line2 = line2
6752 
    args.city = city
6753 
    args.state = state
6754 
    args.pin = pin
6755 
    args.write(self._oprot)
6756 
    self._oprot.writeMessageEnd()
6757 
    self._oprot.trans.flush()
6758 
 
6759 
  def recv_changeShippingAddress(self, ):
6760 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6761 
    if mtype == TMessageType.EXCEPTION:
6762 
      x = TApplicationException()
6763 
      x.read(self._iprot)
6764 
      self._iprot.readMessageEnd()
6765 
      raise x
6766 
    result = changeShippingAddress_result()
6767 
    result.read(self._iprot)
6768 
    self._iprot.readMessageEnd()
6769 
    if result.success is not None:
6770 
      return result.success
6771 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "changeShippingAddress failed: unknown result");
6772 
 
7075 rajveer 6773 
  def retrieveInvoice(self, orderId, userId):
6988 rajveer 6774 
    """
6775 
    Parameters:
6776 
     - orderId
7075 rajveer 6777 
     - userId
6988 rajveer 6778 
    """
7075 rajveer 6779 
    self.send_retrieveInvoice(orderId, userId)
6988 rajveer 6780 
    return self.recv_retrieveInvoice()
6985 anupam.sin 6781 
 
7075 rajveer 6782 
  def send_retrieveInvoice(self, orderId, userId):
6988 rajveer 6783 
    self._oprot.writeMessageBegin('retrieveInvoice', TMessageType.CALL, self._seqid)
6784 
    args = retrieveInvoice_args()
6785 
    args.orderId = orderId
7075 rajveer 6786 
    args.userId = userId
6988 rajveer 6787 
    args.write(self._oprot)
6788 
    self._oprot.writeMessageEnd()
6789 
    self._oprot.trans.flush()
6790 
 
6791 
  def recv_retrieveInvoice(self, ):
6792 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6793 
    if mtype == TMessageType.EXCEPTION:
6794 
      x = TApplicationException()
6795 
      x.read(self._iprot)
6796 
      self._iprot.readMessageEnd()
6797 
      raise x
6798 
    result = retrieveInvoice_result()
6799 
    result.read(self._iprot)
6800 
    self._iprot.readMessageEnd()
6801 
    if result.success is not None:
6802 
      return result.success
6803 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "retrieveInvoice failed: unknown result");
6804 
 
7026 rajveer 6805 
  def receiveUpdatesForRedExpress(self, awbNumber):
6806 
    """
6807 
    Parameters:
6808 
     - awbNumber
6809 
    """
6810 
    self.send_receiveUpdatesForRedExpress(awbNumber)
6811 
    return self.recv_receiveUpdatesForRedExpress()
6988 rajveer 6812 
 
7026 rajveer 6813 
  def send_receiveUpdatesForRedExpress(self, awbNumber):
6814 
    self._oprot.writeMessageBegin('receiveUpdatesForRedExpress', TMessageType.CALL, self._seqid)
6815 
    args = receiveUpdatesForRedExpress_args()
6816 
    args.awbNumber = awbNumber
6817 
    args.write(self._oprot)
6818 
    self._oprot.writeMessageEnd()
6819 
    self._oprot.trans.flush()
6820 
 
6821 
  def recv_receiveUpdatesForRedExpress(self, ):
6822 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6823 
    if mtype == TMessageType.EXCEPTION:
6824 
      x = TApplicationException()
6825 
      x.read(self._iprot)
6826 
      self._iprot.readMessageEnd()
6827 
      raise x
6828 
    result = receiveUpdatesForRedExpress_result()
6829 
    result.read(self._iprot)
6830 
    self._iprot.readMessageEnd()
6831 
    if result.success is not None:
6832 
      return result.success
6833 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "receiveUpdatesForRedExpress failed: unknown result");
6834 
 
7073 anupam.sin 6835 
  def createRechargeTransaction(self, thriftRechargeTransaction):
6836 
    """
6837 
    Parameters:
6838 
     - thriftRechargeTransaction
6839 
    """
6840 
    self.send_createRechargeTransaction(thriftRechargeTransaction)
6841 
    return self.recv_createRechargeTransaction()
7026 rajveer 6842 
 
7073 anupam.sin 6843 
  def send_createRechargeTransaction(self, thriftRechargeTransaction):
6844 
    self._oprot.writeMessageBegin('createRechargeTransaction', TMessageType.CALL, self._seqid)
6845 
    args = createRechargeTransaction_args()
6846 
    args.thriftRechargeTransaction = thriftRechargeTransaction
6847 
    args.write(self._oprot)
6848 
    self._oprot.writeMessageEnd()
6849 
    self._oprot.trans.flush()
6850 
 
6851 
  def recv_createRechargeTransaction(self, ):
6852 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6853 
    if mtype == TMessageType.EXCEPTION:
6854 
      x = TApplicationException()
6855 
      x.read(self._iprot)
6856 
      self._iprot.readMessageEnd()
6857 
      raise x
6858 
    result = createRechargeTransaction_result()
6859 
    result.read(self._iprot)
6860 
    self._iprot.readMessageEnd()
6861 
    if result.success is not None:
6862 
      return result.success
6863 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createRechargeTransaction failed: unknown result");
6864 
 
7085 rajveer 6865 
  def getRechargeTransactions(self, storeId):
6866 
    """
6867 
    Parameters:
6868 
     - storeId
6869 
    """
6870 
    self.send_getRechargeTransactions(storeId)
6871 
    return self.recv_getRechargeTransactions()
6872 
 
6873 
  def send_getRechargeTransactions(self, storeId):
6874 
    self._oprot.writeMessageBegin('getRechargeTransactions', TMessageType.CALL, self._seqid)
6875 
    args = getRechargeTransactions_args()
6876 
    args.storeId = storeId
6877 
    args.write(self._oprot)
6878 
    self._oprot.writeMessageEnd()
6879 
    self._oprot.trans.flush()
6880 
 
6881 
  def recv_getRechargeTransactions(self, ):
6882 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6883 
    if mtype == TMessageType.EXCEPTION:
6884 
      x = TApplicationException()
6885 
      x.read(self._iprot)
6886 
      self._iprot.readMessageEnd()
6887 
      raise x
6888 
    result = getRechargeTransactions_result()
6889 
    result.read(self._iprot)
6890 
    self._iprot.readMessageEnd()
6891 
    if result.success is not None:
6892 
      return result.success
6893 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getRechargeTransactions failed: unknown result");
6894 
 
7151 amit.gupta 6895 
  def getRechargeTrans(self, storeId, startDate, endDate, status):
6896 
    """
6897 
    Parameters:
6898 
     - storeId
6899 
     - startDate
6900 
     - endDate
6901 
     - status
6902 
    """
6903 
    self.send_getRechargeTrans(storeId, startDate, endDate, status)
6904 
    return self.recv_getRechargeTrans()
6905 
 
6906 
  def send_getRechargeTrans(self, storeId, startDate, endDate, status):
6907 
    self._oprot.writeMessageBegin('getRechargeTrans', TMessageType.CALL, self._seqid)
6908 
    args = getRechargeTrans_args()
6909 
    args.storeId = storeId
6910 
    args.startDate = startDate
6911 
    args.endDate = endDate
6912 
    args.status = status
6913 
    args.write(self._oprot)
6914 
    self._oprot.writeMessageEnd()
6915 
    self._oprot.trans.flush()
6916 
 
6917 
  def recv_getRechargeTrans(self, ):
6918 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6919 
    if mtype == TMessageType.EXCEPTION:
6920 
      x = TApplicationException()
6921 
      x.read(self._iprot)
6922 
      self._iprot.readMessageEnd()
6923 
      raise x
6924 
    result = getRechargeTrans_result()
6925 
    result.read(self._iprot)
6926 
    self._iprot.readMessageEnd()
6927 
    if result.success is not None:
6928 
      return result.success
6929 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getRechargeTrans failed: unknown result");
6930 
 
7080 anupam.sin 6931 
  def getRechargeTransaction(self, rechargeId):
6932 
    """
6933 
    Parameters:
6934 
     - rechargeId
6935 
    """
6936 
    self.send_getRechargeTransaction(rechargeId)
6937 
    return self.recv_getRechargeTransaction()
7073 anupam.sin 6938 
 
7080 anupam.sin 6939 
  def send_getRechargeTransaction(self, rechargeId):
6940 
    self._oprot.writeMessageBegin('getRechargeTransaction', TMessageType.CALL, self._seqid)
6941 
    args = getRechargeTransaction_args()
6942 
    args.rechargeId = rechargeId
6943 
    args.write(self._oprot)
6944 
    self._oprot.writeMessageEnd()
6945 
    self._oprot.trans.flush()
6946 
 
6947 
  def recv_getRechargeTransaction(self, ):
6948 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6949 
    if mtype == TMessageType.EXCEPTION:
6950 
      x = TApplicationException()
6951 
      x.read(self._iprot)
6952 
      self._iprot.readMessageEnd()
6953 
      raise x
6954 
    result = getRechargeTransaction_result()
6955 
    result.read(self._iprot)
6956 
    self._iprot.readMessageEnd()
6957 
    if result.success is not None:
6958 
      return result.success
6959 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getRechargeTransaction failed: unknown result");
6960 
 
6961 
  def getFRCs(self, circleId, operatorId):
6962 
    """
6963 
    Parameters:
6964 
     - circleId
6965 
     - operatorId
6966 
    """
6967 
    self.send_getFRCs(circleId, operatorId)
6968 
    return self.recv_getFRCs()
6969 
 
6970 
  def send_getFRCs(self, circleId, operatorId):
6971 
    self._oprot.writeMessageBegin('getFRCs', TMessageType.CALL, self._seqid)
6972 
    args = getFRCs_args()
6973 
    args.circleId = circleId
6974 
    args.operatorId = operatorId
6975 
    args.write(self._oprot)
6976 
    self._oprot.writeMessageEnd()
6977 
    self._oprot.trans.flush()
6978 
 
6979 
  def recv_getFRCs(self, ):
6980 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6981 
    if mtype == TMessageType.EXCEPTION:
6982 
      x = TApplicationException()
6983 
      x.read(self._iprot)
6984 
      self._iprot.readMessageEnd()
6985 
      raise x
6986 
    result = getFRCs_result()
6987 
    result.read(self._iprot)
6988 
    self._iprot.readMessageEnd()
6989 
    if result.success is not None:
6990 
      return result.success
6991 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getFRCs failed: unknown result");
6992 
 
7096 anupam.sin 6993 
  def getHotspotStore(self, id, hotspotid):
6994 
    """
6995 
    Parameters:
6996 
     - id
6997 
     - hotspotid
6998 
    """
6999 
    self.send_getHotspotStore(id, hotspotid)
7000 
    return self.recv_getHotspotStore()
7080 anupam.sin 7001 
 
7096 anupam.sin 7002 
  def send_getHotspotStore(self, id, hotspotid):
7003 
    self._oprot.writeMessageBegin('getHotspotStore', TMessageType.CALL, self._seqid)
7004 
    args = getHotspotStore_args()
7005 
    args.id = id
7006 
    args.hotspotid = hotspotid
7007 
    args.write(self._oprot)
7008 
    self._oprot.writeMessageEnd()
7009 
    self._oprot.trans.flush()
7010 
 
7011 
  def recv_getHotspotStore(self, ):
7012 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
7013 
    if mtype == TMessageType.EXCEPTION:
7014 
      x = TApplicationException()
7015 
      x.read(self._iprot)
7016 
      self._iprot.readMessageEnd()
7017 
      raise x
7018 
    result = getHotspotStore_result()
7019 
    result.read(self._iprot)
7020 
    self._iprot.readMessageEnd()
7021 
    if result.success is not None:
7022 
      return result.success
7023 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getHotspotStore failed: unknown result");
7024 
 
7025 
  def getTelecomCircle(self, id, code):
7026 
    """
7027 
    Parameters:
7028 
     - id
7029 
     - code
7030 
    """
7031 
    self.send_getTelecomCircle(id, code)
7032 
    return self.recv_getTelecomCircle()
7033 
 
7034 
  def send_getTelecomCircle(self, id, code):
7035 
    self._oprot.writeMessageBegin('getTelecomCircle', TMessageType.CALL, self._seqid)
7036 
    args = getTelecomCircle_args()
7037 
    args.id = id
7038 
    args.code = code
7039 
    args.write(self._oprot)
7040 
    self._oprot.writeMessageEnd()
7041 
    self._oprot.trans.flush()
7042 
 
7043 
  def recv_getTelecomCircle(self, ):
7044 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
7045 
    if mtype == TMessageType.EXCEPTION:
7046 
      x = TApplicationException()
7047 
      x.read(self._iprot)
7048 
      self._iprot.readMessageEnd()
7049 
      raise x
7050 
    result = getTelecomCircle_result()
7051 
    result.read(self._iprot)
7052 
    self._iprot.readMessageEnd()
7053 
    if result.success is not None:
7054 
      return result.success
7055 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTelecomCircle failed: unknown result");
7056 
 
7109 anupam.sin 7057 
  def retrieveHotspotRechargeInvoice(self, rechargeId):
7058 
    """
7059 
    Parameters:
7060 
     - rechargeId
7061 
    """
7062 
    self.send_retrieveHotspotRechargeInvoice(rechargeId)
7063 
    return self.recv_retrieveHotspotRechargeInvoice()
7096 anupam.sin 7064 
 
7109 anupam.sin 7065 
  def send_retrieveHotspotRechargeInvoice(self, rechargeId):
7066 
    self._oprot.writeMessageBegin('retrieveHotspotRechargeInvoice', TMessageType.CALL, self._seqid)
7067 
    args = retrieveHotspotRechargeInvoice_args()
7068 
    args.rechargeId = rechargeId
7069 
    args.write(self._oprot)
7070 
    self._oprot.writeMessageEnd()
7071 
    self._oprot.trans.flush()
7072 
 
7073 
  def recv_retrieveHotspotRechargeInvoice(self, ):
7074 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
7075 
    if mtype == TMessageType.EXCEPTION:
7076 
      x = TApplicationException()
7077 
      x.read(self._iprot)
7078 
      self._iprot.readMessageEnd()
7079 
      raise x
7080 
    result = retrieveHotspotRechargeInvoice_result()
7081 
    result.read(self._iprot)
7082 
    self._iprot.readMessageEnd()
7083 
    if result.success is not None:
7084 
      return result.success
7085 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "retrieveHotspotRechargeInvoice failed: unknown result");
7086 
 
7169 anupam.sin 7087 
  def getRechargeTransactionsByNumber(self, number):
7088 
    """
7089 
    Parameters:
7090 
     - number
7091 
    """
7092 
    self.send_getRechargeTransactionsByNumber(number)
7093 
    return self.recv_getRechargeTransactionsByNumber()
7109 anupam.sin 7094 
 
7169 anupam.sin 7095 
  def send_getRechargeTransactionsByNumber(self, number):
7096 
    self._oprot.writeMessageBegin('getRechargeTransactionsByNumber', TMessageType.CALL, self._seqid)
7097 
    args = getRechargeTransactionsByNumber_args()
7098 
    args.number = number
7099 
    args.write(self._oprot)
7100 
    self._oprot.writeMessageEnd()
7101 
    self._oprot.trans.flush()
7102 
 
7103 
  def recv_getRechargeTransactionsByNumber(self, ):
7104 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
7105 
    if mtype == TMessageType.EXCEPTION:
7106 
      x = TApplicationException()
7107 
      x.read(self._iprot)
7108 
      self._iprot.readMessageEnd()
7109 
      raise x
7110 
    result = getRechargeTransactionsByNumber_result()
7111 
    result.read(self._iprot)
7112 
    self._iprot.readMessageEnd()
7113 
    if result.success is not None:
7114 
      return result.success
7115 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getRechargeTransactionsByNumber failed: unknown result");
7116 
 
7117 
  def updateHotspotStorePassword(self, storeId, password):
7118 
    """
7119 
    Parameters:
7120 
     - storeId
7121 
     - password
7122 
    """
7123 
    self.send_updateHotspotStorePassword(storeId, password)
7124 
    return self.recv_updateHotspotStorePassword()
7125 
 
7126 
  def send_updateHotspotStorePassword(self, storeId, password):
7127 
    self._oprot.writeMessageBegin('updateHotspotStorePassword', TMessageType.CALL, self._seqid)
7128 
    args = updateHotspotStorePassword_args()
7129 
    args.storeId = storeId
7130 
    args.password = password
7131 
    args.write(self._oprot)
7132 
    self._oprot.writeMessageEnd()
7133 
    self._oprot.trans.flush()
7134 
 
7135 
  def recv_updateHotspotStorePassword(self, ):
7136 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
7137 
    if mtype == TMessageType.EXCEPTION:
7138 
      x = TApplicationException()
7139 
      x.read(self._iprot)
7140 
      self._iprot.readMessageEnd()
7141 
      raise x
7142 
    result = updateHotspotStorePassword_result()
7143 
    result.read(self._iprot)
7144 
    self._iprot.readMessageEnd()
7145 
    if result.success is not None:
7146 
      return result.success
7147 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updateHotspotStorePassword failed: unknown result");
7148 
 
7149 
 
3376 rajveer 7150 
class Processor(shop2020.thriftpy.generic.GenericService.Processor, Iface, TProcessor):
94 ashish 7151 
  def __init__(self, handler):
3376 rajveer 7152 
    shop2020.thriftpy.generic.GenericService.Processor.__init__(self, handler)
94 ashish 7153 
    self._processMap["createTransaction"] = Processor.process_createTransaction
7154 
    self._processMap["getTransaction"] = Processor.process_getTransaction
7155 
    self._processMap["getTransactionsForCustomer"] = Processor.process_getTransactionsForCustomer
132 ashish 7156 
    self._processMap["getTransactionsForShoppingCartId"] = Processor.process_getTransactionsForShoppingCartId
94 ashish 7157 
    self._processMap["getTransactionStatus"] = Processor.process_getTransactionStatus
7158 
    self._processMap["changeTransactionStatus"] = Processor.process_changeTransactionStatus
1398 varun.gupt 7159 
    self._processMap["enqueueTransactionInfoEmail"] = Processor.process_enqueueTransactionInfoEmail
483 rajveer 7160 
    self._processMap["getAllOrders"] = Processor.process_getAllOrders
4133 chandransh 7161 
    self._processMap["getOrdersInBatch"] = Processor.process_getOrdersInBatch
7162 
    self._processMap["getOrderCount"] = Processor.process_getOrderCount
999 varun.gupt 7163 
    self._processMap["getOrdersByBillingDate"] = Processor.process_getOrdersByBillingDate
3427 chandransh 7164 
    self._processMap["getOrdersByShippingDate"] = Processor.process_getOrdersByShippingDate
1382 varun.gupt 7165 
    self._processMap["getReturnableOrdersForCustomer"] = Processor.process_getReturnableOrdersForCustomer
7166 
    self._processMap["getCancellableOrdersForCustomer"] = Processor.process_getCancellableOrdersForCustomer
483 rajveer 7167 
    self._processMap["changeOrderStatus"] = Processor.process_changeOrderStatus
7168 
    self._processMap["getOrdersForTransaction"] = Processor.process_getOrdersForTransaction
7169 
    self._processMap["getOrdersForCustomer"] = Processor.process_getOrdersForCustomer
7170 
    self._processMap["createOrder"] = Processor.process_createOrder
7171 
    self._processMap["getOrder"] = Processor.process_getOrder
7172 
    self._processMap["getLineItemsForOrder"] = Processor.process_getLineItemsForOrder
4999 phani.kuma 7173 
    self._processMap["getOrderList"] = Processor.process_getOrderList
5386 phani.kuma 7174 
    self._processMap["getOrderListForVendor"] = Processor.process_getOrderListForVendor
1528 ankur.sing 7175 
    self._processMap["getOrderForCustomer"] = Processor.process_getOrderForCustomer
3064 chandransh 7176 
    self._processMap["getAlerts"] = Processor.process_getAlerts
4394 rajveer 7177 
    self._processMap["addAlert"] = Processor.process_addAlert
4444 rajveer 7178 
    self._processMap["markAlertsAsSeen"] = Processor.process_markAlertsAsSeen
3064 chandransh 7179 
    self._processMap["getValidOrderCount"] = Processor.process_getValidOrderCount
7180 
    self._processMap["getNoOfCustomersWithSuccessfulTransaction"] = Processor.process_getNoOfCustomersWithSuccessfulTransaction
7181 
    self._processMap["getValidOrdersAmountRange"] = Processor.process_getValidOrdersAmountRange
7182 
    self._processMap["getValidOrders"] = Processor.process_getValidOrders
1220 chandransh 7183 
    self._processMap["batchOrders"] = Processor.process_batchOrders
1208 chandransh 7184 
    self._processMap["markOrderAsOutOfStock"] = Processor.process_markOrderAsOutOfStock
3064 chandransh 7185 
    self._processMap["verifyOrder"] = Processor.process_verifyOrder
7186 
    self._processMap["acceptOrder"] = Processor.process_acceptOrder
7187 
    self._processMap["addBillingDetails"] = Processor.process_addBillingDetails
4579 rajveer 7188 
    self._processMap["addInvoiceNumber"] = Processor.process_addInvoiceNumber
4410 rajveer 7189 
    self._processMap["markOrdersAsShippedFromWarehouse"] = Processor.process_markOrdersAsShippedFromWarehouse
5676 rajveer 7190 
    self._processMap["markOrdersAsReturnedFromStore"] = Processor.process_markOrdersAsReturnedFromStore
1113 chandransh 7191 
    self._processMap["markOrdersAsPickedUp"] = Processor.process_markOrdersAsPickedUp
4910 phani.kuma 7192 
    self._processMap["getOrdersNotPickedUp"] = Processor.process_getOrdersNotPickedUp
1132 chandransh 7193 
    self._processMap["markOrdersAsDelivered"] = Processor.process_markOrdersAsDelivered
4910 phani.kuma 7194 
    self._processMap["markAsRTOrders"] = Processor.process_markAsRTOrders
7195 
    self._processMap["getRTOrders"] = Processor.process_getRTOrders
1246 chandransh 7196 
    self._processMap["updateNonDeliveryReason"] = Processor.process_updateNonDeliveryReason
4910 phani.kuma 7197 
    self._processMap["getNonDeliveredOrdersbyCourier"] = Processor.process_getNonDeliveredOrdersbyCourier
7198 
    self._processMap["markOrdersAsLocalConnected"] = Processor.process_markOrdersAsLocalConnected
7199 
    self._processMap["getOrdersNotLocalConnected"] = Processor.process_getOrdersNotLocalConnected
7200 
    self._processMap["markOrdersAsDestinationCityReached"] = Processor.process_markOrdersAsDestinationCityReached
7201 
    self._processMap["markOrdersAsFirstDeliveryAttempted"] = Processor.process_markOrdersAsFirstDeliveryAttempted
1408 ankur.sing 7202 
    self._processMap["getUndeliveredOrders"] = Processor.process_getUndeliveredOrders
4783 phani.kuma 7203 
    self._processMap["getUndeliveredOrdersExpectedDeliveryDateNotMet"] = Processor.process_getUndeliveredOrdersExpectedDeliveryDateNotMet
2536 chandransh 7204 
    self._processMap["toggleDOAFlag"] = Processor.process_toggleDOAFlag
4712 rajveer 7205 
    self._processMap["markOrderAsDelivered"] = Processor.process_markOrderAsDelivered
5553 rajveer 7206 
    self._processMap["markOrderAsReceivedAtStore"] = Processor.process_markOrderAsReceivedAtStore
4454 rajveer 7207 
    self._processMap["markOrderDoaRequestReceived"] = Processor.process_markOrderDoaRequestReceived
7208 
    self._processMap["markOrderDoaRequestAuthorized"] = Processor.process_markOrderDoaRequestAuthorized
4488 rajveer 7209 
    self._processMap["markOrderReturnRequestReceived"] = Processor.process_markOrderReturnRequestReceived
7210 
    self._processMap["markOrderReturnRequestAuthorized"] = Processor.process_markOrderReturnRequestAuthorized
2536 chandransh 7211 
    self._processMap["requestPickupNumber"] = Processor.process_requestPickupNumber
7212 
    self._processMap["authorizePickup"] = Processor.process_authorizePickup
2764 chandransh 7213 
    self._processMap["markDoasAsPickedUp"] = Processor.process_markDoasAsPickedUp
4910 phani.kuma 7214 
    self._processMap["getDoasNotPickedUp"] = Processor.process_getDoasNotPickedUp
4741 phani.kuma 7215 
    self._processMap["markReturnOrdersAsPickedUp"] = Processor.process_markReturnOrdersAsPickedUp
4910 phani.kuma 7216 
    self._processMap["getReturnOrdersNotPickedUp"] = Processor.process_getReturnOrdersNotPickedUp
2616 chandransh 7217 
    self._processMap["receiveReturn"] = Processor.process_receiveReturn
2591 chandransh 7218 
    self._processMap["validateDoa"] = Processor.process_validateDoa
4495 rajveer 7219 
    self._processMap["validateReturnProduct"] = Processor.process_validateReturnProduct
2616 chandransh 7220 
    self._processMap["reshipOrder"] = Processor.process_reshipOrder
7221 
    self._processMap["refundOrder"] = Processor.process_refundOrder
2690 chandransh 7222 
    self._processMap["getReturnOrders"] = Processor.process_getReturnOrders
5481 phani.kuma 7223 
    self._processMap["getAllReturnOrders"] = Processor.process_getAllReturnOrders
2700 chandransh 7224 
    self._processMap["getReturnOrder"] = Processor.process_getReturnOrder
2690 chandransh 7225 
    self._processMap["processReturn"] = Processor.process_processReturn
3451 chandransh 7226 
    self._processMap["updateWeight"] = Processor.process_updateWeight
3469 chandransh 7227 
    self._processMap["changeItem"] = Processor.process_changeItem
7228 
    self._processMap["shiftToWarehouse"] = Processor.process_shiftToWarehouse
3553 chandransh 7229 
    self._processMap["addDelayReason"] = Processor.process_addDelayReason
3956 chandransh 7230 
    self._processMap["reconcileCodCollection"] = Processor.process_reconcileCodCollection
4008 mandeep.dh 7231 
    self._processMap["getTransactionsRequiringExtraProcessing"] = Processor.process_getTransactionsRequiringExtraProcessing
7232 
    self._processMap["markTransactionAsProcessed"] = Processor.process_markTransactionAsProcessed
4018 chandransh 7233 
    self._processMap["getItemWiseRiskyOrdersCount"] = Processor.process_getItemWiseRiskyOrdersCount
4295 varun.gupt 7234 
    self._processMap["getOrdersForItemIds"] = Processor.process_getOrdersForItemIds
4247 rajveer 7235 
    self._processMap["markOrderCancellationRequestReceived"] = Processor.process_markOrderCancellationRequestReceived
7236 
    self._processMap["markOrderCancellationRequestConfirmed"] = Processor.process_markOrderCancellationRequestConfirmed
7237 
    self._processMap["markOrderCancellationRequestDenied"] = Processor.process_markOrderCancellationRequestDenied
4258 rajveer 7238 
    self._processMap["markTransactionAsPaymentFlagRemoved"] = Processor.process_markTransactionAsPaymentFlagRemoved
4259 anupam.sin 7239 
    self._processMap["refundTransaction"] = Processor.process_refundTransaction
4324 mandeep.dh 7240 
    self._processMap["updateShipmentAddress"] = Processor.process_updateShipmentAddress
4285 rajveer 7241 
    self._processMap["acceptOrdersForItemId"] = Processor.process_acceptOrdersForItemId
4303 rajveer 7242 
    self._processMap["markOrdersAsPORaised"] = Processor.process_markOrdersAsPORaised
7243 
    self._processMap["markOrdersAsReversalInitiated"] = Processor.process_markOrdersAsReversalInitiated
7244 
    self._processMap["markOrdersAsNotAvailabke"] = Processor.process_markOrdersAsNotAvailabke
4369 rajveer 7245 
    self._processMap["markOrdersAsTimeout"] = Processor.process_markOrdersAsTimeout
4662 rajveer 7246 
    self._processMap["markOrderAsLostInTransit"] = Processor.process_markOrderAsLostInTransit
4386 anupam.sin 7247 
    self._processMap["getOrderForAwb"] = Processor.process_getOrderForAwb
4506 phani.kuma 7248 
    self._processMap["getOrdersForProviderForStatus"] = Processor.process_getOrdersForProviderForStatus
4600 varun.gupt 7249 
    self._processMap["getBilledOrdersForVendor"] = Processor.process_getBilledOrdersForVendor
4607 rajveer 7250 
    self._processMap["getSlippedSippingDateOrders"] = Processor.process_getSlippedSippingDateOrders
4709 rajveer 7251 
    self._processMap["getCancelledOrders"] = Processor.process_getCancelledOrders
4600 varun.gupt 7252 
    self._processMap["saveBluedartSettlements"] = Processor.process_saveBluedartSettlements
7253 
    self._processMap["savePaymentSettlements"] = Processor.process_savePaymentSettlements
7254 
    self._processMap["saveEBSSettlementSummary"] = Processor.process_saveEBSSettlementSummary
5386 phani.kuma 7255 
    self._processMap["getSettlementForPrepaid"] = Processor.process_getSettlementForPrepaid
7256 
    self._processMap["getSettlementForCod"] = Processor.process_getSettlementForCod
4600 varun.gupt 7257 
    self._processMap["getEBSSettlementSummaries"] = Processor.process_getEBSSettlementSummaries
7258 
    self._processMap["markEBSSettlementUploaded"] = Processor.process_markEBSSettlementUploaded
7259 
    self._processMap["getEBSSettlementDate"] = Processor.process_getEBSSettlementDate
4715 varun.gupt 7260 
    self._processMap["getSettlementsByDate"] = Processor.process_getSettlementsByDate
7261 
    self._processMap["getReshippedOrderIds"] = Processor.process_getReshippedOrderIds
5481 phani.kuma 7262 
    self._processMap["getBilledOrders"] = Processor.process_getBilledOrders
5031 varun.gupt 7263 
    self._processMap["getStatusDistributionOfOrders"] = Processor.process_getStatusDistributionOfOrders
5067 varun.gupt 7264 
    self._processMap["getOrderIdsForStatus"] = Processor.process_getOrderIdsForStatus
5348 anupam.sin 7265 
    self._processMap["updateCODAgent"] = Processor.process_updateCODAgent
5099 varun.gupt 7266 
    self._processMap["updateOrderAsPaidToVendor"] = Processor.process_updateOrderAsPaidToVendor
5386 phani.kuma 7267 
    self._processMap["updateOrderOnlyAsPaidToVendor"] = Processor.process_updateOrderOnlyAsPaidToVendor
5208 varun.gupt 7268 
    self._processMap["getRefundedOrdersMarkedPaid"] = Processor.process_getRefundedOrdersMarkedPaid
5447 anupam.sin 7269 
    self._processMap["getAllVerificationAgents"] = Processor.process_getAllVerificationAgents
5527 anupam.sin 7270 
    self._processMap["getAllAttributesForOrderId"] = Processor.process_getAllAttributesForOrderId
5676 rajveer 7271 
    self._processMap["setOrderAttributes"] = Processor.process_setOrderAttributes
5527 anupam.sin 7272 
    self._processMap["setOrderAttributeForTransaction"] = Processor.process_setOrderAttributeForTransaction
5553 rajveer 7273 
    self._processMap["getReceivePendingOrders"] = Processor.process_getReceivePendingOrders
7274 
    self._processMap["getReceivedAtStoreOrders"] = Processor.process_getReceivedAtStoreOrders
5713 rajveer 7275 
    self._processMap["getOrdersCollectionAtStore"] = Processor.process_getOrdersCollectionAtStore
5833 rajveer 7276 
    self._processMap["getOrderAttributeValue"] = Processor.process_getOrderAttributeValue
6019 rajveer 7277 
    self._processMap["changeJacketNumber"] = Processor.process_changeJacketNumber
7278 
    self._processMap["markOrderAsRtoInTransit"] = Processor.process_markOrderAsRtoInTransit
5593 mandeep.dh 7279 
    self._processMap["acceptOrderForItem"] = Processor.process_acceptOrderForItem
6000 mandeep.dh 7280 
    self._processMap["createRechargeOrder"] = Processor.process_createRechargeOrder
6031 rajveer 7281 
    self._processMap["getRechargeOrder"] = Processor.process_getRechargeOrder
7282 
    self._processMap["getRechargeOrders"] = Processor.process_getRechargeOrders
6000 mandeep.dh 7283 
    self._processMap["updateRechargeOrderStatus"] = Processor.process_updateRechargeOrderStatus
7284 
    self._processMap["activateRechargeTxn"] = Processor.process_activateRechargeTxn
6031 rajveer 7285 
    self._processMap["getUserWallet"] = Processor.process_getUserWallet
7286 
    self._processMap["getUserWalletHistory"] = Processor.process_getUserWalletHistory
6050 anupam.sin 7287 
    self._processMap["getRechargeOrdersForTransaction"] = Processor.process_getRechargeOrdersForTransaction
6048 rajveer 7288 
    self._processMap["getServiceProviders"] = Processor.process_getServiceProviders
7289 
    self._processMap["getServiceProviderForDevice"] = Processor.process_getServiceProviderForDevice
6269 rajveer 7290 
    self._processMap["validateRecharge"] = Processor.process_validateRecharge
6094 rajveer 7291 
    self._processMap["getRechargeOrdersForDevice"] = Processor.process_getRechargeOrdersForDevice
7292 
    self._processMap["addAmountToWallet"] = Processor.process_addAmountToWallet
6188 rajveer 7293 
    self._processMap["getRechargeStatistics"] = Processor.process_getRechargeStatistics
6154 rajveer 7294 
    self._processMap["getRechargeOrdersForStatus"] = Processor.process_getRechargeOrdersForStatus
6159 rajveer 7295 
    self._processMap["getPlansForOperator"] = Processor.process_getPlansForOperator
6289 anupam.sin 7296 
    self._processMap["getRechargeDenominations"] = Processor.process_getRechargeDenominations
6371 rajveer 7297 
    self._processMap["updateAvailabilityStatus"] = Processor.process_updateAvailabilityStatus
6389 rajveer 7298 
    self._processMap["getAvailableEmiSchemes"] = Processor.process_getAvailableEmiSchemes
7299 
    self._processMap["getMiscCharges"] = Processor.process_getMiscCharges
6507 anupam.sin 7300 
    self._processMap["refundRechargeOrder"] = Processor.process_refundRechargeOrder
6821 amar.kumar 7301 
    self._processMap["getPhysicalOrders"] = Processor.process_getPhysicalOrders
6906 rajveer 7302 
    self._processMap["getDocument"] = Processor.process_getDocument
6985 anupam.sin 7303 
    self._processMap["changeShippingAddress"] = Processor.process_changeShippingAddress
6988 rajveer 7304 
    self._processMap["retrieveInvoice"] = Processor.process_retrieveInvoice
7026 rajveer 7305 
    self._processMap["receiveUpdatesForRedExpress"] = Processor.process_receiveUpdatesForRedExpress
7073 anupam.sin 7306 
    self._processMap["createRechargeTransaction"] = Processor.process_createRechargeTransaction
7085 rajveer 7307 
    self._processMap["getRechargeTransactions"] = Processor.process_getRechargeTransactions
7151 amit.gupta 7308 
    self._processMap["getRechargeTrans"] = Processor.process_getRechargeTrans
7080 anupam.sin 7309 
    self._processMap["getRechargeTransaction"] = Processor.process_getRechargeTransaction
7310 
    self._processMap["getFRCs"] = Processor.process_getFRCs
7096 anupam.sin 7311 
    self._processMap["getHotspotStore"] = Processor.process_getHotspotStore
7312 
    self._processMap["getTelecomCircle"] = Processor.process_getTelecomCircle
7109 anupam.sin 7313 
    self._processMap["retrieveHotspotRechargeInvoice"] = Processor.process_retrieveHotspotRechargeInvoice
7169 anupam.sin 7314 
    self._processMap["getRechargeTransactionsByNumber"] = Processor.process_getRechargeTransactionsByNumber
7315 
    self._processMap["updateHotspotStorePassword"] = Processor.process_updateHotspotStorePassword
94 ashish 7316 
 
7317 
  def process(self, iprot, oprot):
7318 
    (name, type, seqid) = iprot.readMessageBegin()
7319 
    if name not in self._processMap:
7320 
      iprot.skip(TType.STRUCT)
7321 
      iprot.readMessageEnd()
7322 
      x = TApplicationException(TApplicationException.UNKNOWN_METHOD, 'Unknown function %s' % (name))
7323 
      oprot.writeMessageBegin(name, TMessageType.EXCEPTION, seqid)
7324 
      x.write(oprot)
7325 
      oprot.writeMessageEnd()
7326 
      oprot.trans.flush()
7327 
      return
7328 
    else:
7329 
      self._processMap[name](self, seqid, iprot, oprot)
7330 
    return True
7331 
 
7332 
  def process_createTransaction(self, seqid, iprot, oprot):
7333 
    args = createTransaction_args()
7334 
    args.read(iprot)
7335 
    iprot.readMessageEnd()
7336 
    result = createTransaction_result()
7337 
    try:
132 ashish 7338 
      result.success = self._handler.createTransaction(args.transaction)
94 ashish 7339 
    except TransactionServiceException, ex:
7340 
      result.ex = ex
7341 
    oprot.writeMessageBegin("createTransaction", TMessageType.REPLY, seqid)
7342 
    result.write(oprot)
7343 
    oprot.writeMessageEnd()
7344 
    oprot.trans.flush()
7345 
 
7346 
  def process_getTransaction(self, seqid, iprot, oprot):
7347 
    args = getTransaction_args()
7348 
    args.read(iprot)
7349 
    iprot.readMessageEnd()
7350 
    result = getTransaction_result()
7351 
    try:
7352 
      result.success = self._handler.getTransaction(args.id)
7353 
    except TransactionServiceException, ex:
7354 
      result.ex = ex
7355 
    oprot.writeMessageBegin("getTransaction", TMessageType.REPLY, seqid)
7356 
    result.write(oprot)
7357 
    oprot.writeMessageEnd()
7358 
    oprot.trans.flush()
7359 
 
7360 
  def process_getTransactionsForCustomer(self, seqid, iprot, oprot):
7361 
    args = getTransactionsForCustomer_args()
7362 
    args.read(iprot)
7363 
    iprot.readMessageEnd()
7364 
    result = getTransactionsForCustomer_result()
7365 
    try:
7366 
      result.success = self._handler.getTransactionsForCustomer(args.customerId, args.from_date, args.to_date, args.status)
7367 
    except TransactionServiceException, ex:
7368 
      result.ex = ex
7369 
    oprot.writeMessageBegin("getTransactionsForCustomer", TMessageType.REPLY, seqid)
7370 
    result.write(oprot)
7371 
    oprot.writeMessageEnd()
7372 
    oprot.trans.flush()
7373 
 
132 ashish 7374 
  def process_getTransactionsForShoppingCartId(self, seqid, iprot, oprot):
7375 
    args = getTransactionsForShoppingCartId_args()
7376 
    args.read(iprot)
7377 
    iprot.readMessageEnd()
7378 
    result = getTransactionsForShoppingCartId_result()
7379 
    try:
7380 
      result.success = self._handler.getTransactionsForShoppingCartId(args.shoppingCartId)
7381 
    except TransactionServiceException, ex:
7382 
      result.ex = ex
7383 
    oprot.writeMessageBegin("getTransactionsForShoppingCartId", TMessageType.REPLY, seqid)
7384 
    result.write(oprot)
7385 
    oprot.writeMessageEnd()
7386 
    oprot.trans.flush()
7387 
 
94 ashish 7388 
  def process_getTransactionStatus(self, seqid, iprot, oprot):
7389 
    args = getTransactionStatus_args()
7390 
    args.read(iprot)
7391 
    iprot.readMessageEnd()
7392 
    result = getTransactionStatus_result()
7393 
    try:
7394 
      result.success = self._handler.getTransactionStatus(args.transactionId)
7395 
    except TransactionServiceException, ex:
7396 
      result.ex = ex
7397 
    oprot.writeMessageBegin("getTransactionStatus", TMessageType.REPLY, seqid)
7398 
    result.write(oprot)
7399 
    oprot.writeMessageEnd()
7400 
    oprot.trans.flush()
7401 
 
7402 
  def process_changeTransactionStatus(self, seqid, iprot, oprot):
7403 
    args = changeTransactionStatus_args()
7404 
    args.read(iprot)
7405 
    iprot.readMessageEnd()
7406 
    result = changeTransactionStatus_result()
7407 
    try:
5527 anupam.sin 7408 
      result.success = self._handler.changeTransactionStatus(args.transactionId, args.status, args.description, args.pickUp, args.orderType)
94 ashish 7409 
    except TransactionServiceException, ex:
7410 
      result.ex = ex
7411 
    oprot.writeMessageBegin("changeTransactionStatus", TMessageType.REPLY, seqid)
7412 
    result.write(oprot)
7413 
    oprot.writeMessageEnd()
7414 
    oprot.trans.flush()
7415 
 
1398 varun.gupt 7416 
  def process_enqueueTransactionInfoEmail(self, seqid, iprot, oprot):
7417 
    args = enqueueTransactionInfoEmail_args()
1382 varun.gupt 7418 
    args.read(iprot)
7419 
    iprot.readMessageEnd()
1398 varun.gupt 7420 
    result = enqueueTransactionInfoEmail_result()
1382 varun.gupt 7421 
    try:
1398 varun.gupt 7422 
      result.success = self._handler.enqueueTransactionInfoEmail(args.transactionId)
1382 varun.gupt 7423 
    except TransactionServiceException, ex:
7424 
      result.ex = ex
1398 varun.gupt 7425 
    oprot.writeMessageBegin("enqueueTransactionInfoEmail", TMessageType.REPLY, seqid)
1382 varun.gupt 7426 
    result.write(oprot)
7427 
    oprot.writeMessageEnd()
7428 
    oprot.trans.flush()
7429 
 
483 rajveer 7430 
  def process_getAllOrders(self, seqid, iprot, oprot):
7431 
    args = getAllOrders_args()
94 ashish 7432 
    args.read(iprot)
7433 
    iprot.readMessageEnd()
483 rajveer 7434 
    result = getAllOrders_result()
94 ashish 7435 
    try:
4801 anupam.sin 7436 
      result.success = self._handler.getAllOrders(args.statuses, args.from_date, args.to_date, args.warehouse_id)
94 ashish 7437 
    except TransactionServiceException, ex:
7438 
      result.ex = ex
483 rajveer 7439 
    oprot.writeMessageBegin("getAllOrders", TMessageType.REPLY, seqid)
94 ashish 7440 
    result.write(oprot)
7441 
    oprot.writeMessageEnd()
7442 
    oprot.trans.flush()
7443 
 
4133 chandransh 7444 
  def process_getOrdersInBatch(self, seqid, iprot, oprot):
7445 
    args = getOrdersInBatch_args()
7446 
    args.read(iprot)
7447 
    iprot.readMessageEnd()
7448 
    result = getOrdersInBatch_result()
7449 
    try:
7450 
      result.success = self._handler.getOrdersInBatch(args.statuses, args.offset, args.limit, args.warehouse_id)
7451 
    except TransactionServiceException, ex:
7452 
      result.ex = ex
7453 
    oprot.writeMessageBegin("getOrdersInBatch", TMessageType.REPLY, seqid)
7454 
    result.write(oprot)
7455 
    oprot.writeMessageEnd()
7456 
    oprot.trans.flush()
7457 
 
7458 
  def process_getOrderCount(self, seqid, iprot, oprot):
7459 
    args = getOrderCount_args()
7460 
    args.read(iprot)
7461 
    iprot.readMessageEnd()
7462 
    result = getOrderCount_result()
7463 
    try:
7464 
      result.success = self._handler.getOrderCount(args.statuses, args.warehouseId)
7465 
    except TransactionServiceException, ex:
7466 
      result.ex = ex
7467 
    oprot.writeMessageBegin("getOrderCount", TMessageType.REPLY, seqid)
7468 
    result.write(oprot)
7469 
    oprot.writeMessageEnd()
7470 
    oprot.trans.flush()
7471 
 
999 varun.gupt 7472 
  def process_getOrdersByBillingDate(self, seqid, iprot, oprot):
7473 
    args = getOrdersByBillingDate_args()
7474 
    args.read(iprot)
7475 
    iprot.readMessageEnd()
7476 
    result = getOrdersByBillingDate_result()
7477 
    try:
7478 
      result.success = self._handler.getOrdersByBillingDate(args.status, args.start_billing_date, args.end_billing_date, args.warehouse_id)
7479 
    except TransactionServiceException, ex:
7480 
      result.ex = ex
7481 
    oprot.writeMessageBegin("getOrdersByBillingDate", TMessageType.REPLY, seqid)
7482 
    result.write(oprot)
7483 
    oprot.writeMessageEnd()
7484 
    oprot.trans.flush()
7485 
 
3427 chandransh 7486 
  def process_getOrdersByShippingDate(self, seqid, iprot, oprot):
7487 
    args = getOrdersByShippingDate_args()
7488 
    args.read(iprot)
7489 
    iprot.readMessageEnd()
7490 
    result = getOrdersByShippingDate_result()
7491 
    try:
3451 chandransh 7492 
      result.success = self._handler.getOrdersByShippingDate(args.fromShippingDate, args.toShippingDate, args.providerId, args.warehouseId, args.cod)
3427 chandransh 7493 
    except TransactionServiceException, ex:
7494 
      result.ex = ex
7495 
    oprot.writeMessageBegin("getOrdersByShippingDate", TMessageType.REPLY, seqid)
7496 
    result.write(oprot)
7497 
    oprot.writeMessageEnd()
7498 
    oprot.trans.flush()
7499 
 
1382 varun.gupt 7500 
  def process_getReturnableOrdersForCustomer(self, seqid, iprot, oprot):
7501 
    args = getReturnableOrdersForCustomer_args()
7502 
    args.read(iprot)
7503 
    iprot.readMessageEnd()
7504 
    result = getReturnableOrdersForCustomer_result()
7505 
    try:
7506 
      result.success = self._handler.getReturnableOrdersForCustomer(args.customer_id, args.limit)
7507 
    except TransactionServiceException, ex:
7508 
      result.ex = ex
7509 
    oprot.writeMessageBegin("getReturnableOrdersForCustomer", TMessageType.REPLY, seqid)
7510 
    result.write(oprot)
7511 
    oprot.writeMessageEnd()
7512 
    oprot.trans.flush()
7513 
 
7514 
  def process_getCancellableOrdersForCustomer(self, seqid, iprot, oprot):
7515 
    args = getCancellableOrdersForCustomer_args()
7516 
    args.read(iprot)
7517 
    iprot.readMessageEnd()
7518 
    result = getCancellableOrdersForCustomer_result()
7519 
    try:
7520 
      result.success = self._handler.getCancellableOrdersForCustomer(args.customer_id, args.limit)
7521 
    except TransactionServiceException, ex:
7522 
      result.ex = ex
7523 
    oprot.writeMessageBegin("getCancellableOrdersForCustomer", TMessageType.REPLY, seqid)
7524 
    result.write(oprot)
7525 
    oprot.writeMessageEnd()
7526 
    oprot.trans.flush()
7527 
 
483 rajveer 7528 
  def process_changeOrderStatus(self, seqid, iprot, oprot):
7529 
    args = changeOrderStatus_args()
94 ashish 7530 
    args.read(iprot)
7531 
    iprot.readMessageEnd()
483 rajveer 7532 
    result = changeOrderStatus_result()
94 ashish 7533 
    try:
483 rajveer 7534 
      result.success = self._handler.changeOrderStatus(args.orderId, args.status, args.description)
94 ashish 7535 
    except TransactionServiceException, ex:
7536 
      result.ex = ex
483 rajveer 7537 
    oprot.writeMessageBegin("changeOrderStatus", TMessageType.REPLY, seqid)
94 ashish 7538 
    result.write(oprot)
7539 
    oprot.writeMessageEnd()
7540 
    oprot.trans.flush()
7541 
 
483 rajveer 7542 
  def process_getOrdersForTransaction(self, seqid, iprot, oprot):
7543 
    args = getOrdersForTransaction_args()
94 ashish 7544 
    args.read(iprot)
7545 
    iprot.readMessageEnd()
483 rajveer 7546 
    result = getOrdersForTransaction_result()
94 ashish 7547 
    try:
1528 ankur.sing 7548 
      result.success = self._handler.getOrdersForTransaction(args.transactionId, args.customerId)
94 ashish 7549 
    except TransactionServiceException, ex:
7550 
      result.ex = ex
483 rajveer 7551 
    oprot.writeMessageBegin("getOrdersForTransaction", TMessageType.REPLY, seqid)
94 ashish 7552 
    result.write(oprot)
7553 
    oprot.writeMessageEnd()
7554 
    oprot.trans.flush()
7555 
 
483 rajveer 7556 
  def process_getOrdersForCustomer(self, seqid, iprot, oprot):
7557 
    args = getOrdersForCustomer_args()
94 ashish 7558 
    args.read(iprot)
7559 
    iprot.readMessageEnd()
483 rajveer 7560 
    result = getOrdersForCustomer_result()
94 ashish 7561 
    try:
3014 chandransh 7562 
      result.success = self._handler.getOrdersForCustomer(args.customerId, args.from_date, args.to_date, args.statuses)
94 ashish 7563 
    except TransactionServiceException, ex:
7564 
      result.ex = ex
483 rajveer 7565 
    oprot.writeMessageBegin("getOrdersForCustomer", TMessageType.REPLY, seqid)
94 ashish 7566 
    result.write(oprot)
7567 
    oprot.writeMessageEnd()
7568 
    oprot.trans.flush()
7569 
 
483 rajveer 7570 
  def process_createOrder(self, seqid, iprot, oprot):
7571 
    args = createOrder_args()
94 ashish 7572 
    args.read(iprot)
7573 
    iprot.readMessageEnd()
483 rajveer 7574 
    result = createOrder_result()
94 ashish 7575 
    try:
483 rajveer 7576 
      result.success = self._handler.createOrder(args.order)
94 ashish 7577 
    except TransactionServiceException, ex:
7578 
      result.ex = ex
483 rajveer 7579 
    oprot.writeMessageBegin("createOrder", TMessageType.REPLY, seqid)
94 ashish 7580 
    result.write(oprot)
7581 
    oprot.writeMessageEnd()
7582 
    oprot.trans.flush()
7583 
 
483 rajveer 7584 
  def process_getOrder(self, seqid, iprot, oprot):
7585 
    args = getOrder_args()
94 ashish 7586 
    args.read(iprot)
7587 
    iprot.readMessageEnd()
483 rajveer 7588 
    result = getOrder_result()
94 ashish 7589 
    try:
483 rajveer 7590 
      result.success = self._handler.getOrder(args.id)
94 ashish 7591 
    except TransactionServiceException, ex:
7592 
      result.ex = ex
483 rajveer 7593 
    oprot.writeMessageBegin("getOrder", TMessageType.REPLY, seqid)
94 ashish 7594 
    result.write(oprot)
7595 
    oprot.writeMessageEnd()
7596 
    oprot.trans.flush()
7597 
 
483 rajveer 7598 
  def process_getLineItemsForOrder(self, seqid, iprot, oprot):
7599 
    args = getLineItemsForOrder_args()
94 ashish 7600 
    args.read(iprot)
7601 
    iprot.readMessageEnd()
483 rajveer 7602 
    result = getLineItemsForOrder_result()
94 ashish 7603 
    try:
483 rajveer 7604 
      result.success = self._handler.getLineItemsForOrder(args.orderId)
94 ashish 7605 
    except TransactionServiceException, ex:
7606 
      result.ex = ex
483 rajveer 7607 
    oprot.writeMessageBegin("getLineItemsForOrder", TMessageType.REPLY, seqid)
94 ashish 7608 
    result.write(oprot)
7609 
    oprot.writeMessageEnd()
7610 
    oprot.trans.flush()
7611 
 
4999 phani.kuma 7612 
  def process_getOrderList(self, seqid, iprot, oprot):
7613 
    args = getOrderList_args()
7614 
    args.read(iprot)
7615 
    iprot.readMessageEnd()
7616 
    result = getOrderList_result()
7617 
    result.success = self._handler.getOrderList(args.order_ids)
7618 
    oprot.writeMessageBegin("getOrderList", TMessageType.REPLY, seqid)
7619 
    result.write(oprot)
7620 
    oprot.writeMessageEnd()
7621 
    oprot.trans.flush()
7622 
 
5386 phani.kuma 7623 
  def process_getOrderListForVendor(self, seqid, iprot, oprot):
7624 
    args = getOrderListForVendor_args()
7625 
    args.read(iprot)
7626 
    iprot.readMessageEnd()
7627 
    result = getOrderListForVendor_result()
7628 
    result.success = self._handler.getOrderListForVendor(args.order_ids, args.vendorId)
7629 
    oprot.writeMessageBegin("getOrderListForVendor", TMessageType.REPLY, seqid)
7630 
    result.write(oprot)
7631 
    oprot.writeMessageEnd()
7632 
    oprot.trans.flush()
7633 
 
1528 ankur.sing 7634 
  def process_getOrderForCustomer(self, seqid, iprot, oprot):
7635 
    args = getOrderForCustomer_args()
7636 
    args.read(iprot)
7637 
    iprot.readMessageEnd()
7638 
    result = getOrderForCustomer_result()
7639 
    try:
7640 
      result.success = self._handler.getOrderForCustomer(args.orderId, args.customerId)
7641 
    except TransactionServiceException, ex:
7642 
      result.ex = ex
7643 
    oprot.writeMessageBegin("getOrderForCustomer", TMessageType.REPLY, seqid)
7644 
    result.write(oprot)
7645 
    oprot.writeMessageEnd()
7646 
    oprot.trans.flush()
7647 
 
3064 chandransh 7648 
  def process_getAlerts(self, seqid, iprot, oprot):
7649 
    args = getAlerts_args()
7650 
    args.read(iprot)
7651 
    iprot.readMessageEnd()
7652 
    result = getAlerts_result()
4444 rajveer 7653 
    result.success = self._handler.getAlerts(args.type, args.warehouseId, args.status, args.timestamp)
3064 chandransh 7654 
    oprot.writeMessageBegin("getAlerts", TMessageType.REPLY, seqid)
7655 
    result.write(oprot)
7656 
    oprot.writeMessageEnd()
7657 
    oprot.trans.flush()
7658 
 
4394 rajveer 7659 
  def process_addAlert(self, seqid, iprot, oprot):
7660 
    args = addAlert_args()
3064 chandransh 7661 
    args.read(iprot)
7662 
    iprot.readMessageEnd()
4394 rajveer 7663 
    result = addAlert_result()
4444 rajveer 7664 
    self._handler.addAlert(args.type, args.warehouseId, args.description)
4394 rajveer 7665 
    oprot.writeMessageBegin("addAlert", TMessageType.REPLY, seqid)
3064 chandransh 7666 
    result.write(oprot)
7667 
    oprot.writeMessageEnd()
7668 
    oprot.trans.flush()
7669 
 
4444 rajveer 7670 
  def process_markAlertsAsSeen(self, seqid, iprot, oprot):
7671 
    args = markAlertsAsSeen_args()
7672 
    args.read(iprot)
7673 
    iprot.readMessageEnd()
7674 
    result = markAlertsAsSeen_result()
7675 
    self._handler.markAlertsAsSeen(args.warehouseId)
7676 
    oprot.writeMessageBegin("markAlertsAsSeen", TMessageType.REPLY, seqid)
7677 
    result.write(oprot)
7678 
    oprot.writeMessageEnd()
7679 
    oprot.trans.flush()
7680 
 
3064 chandransh 7681 
  def process_getValidOrderCount(self, seqid, iprot, oprot):
7682 
    args = getValidOrderCount_args()
7683 
    args.read(iprot)
7684 
    iprot.readMessageEnd()
7685 
    result = getValidOrderCount_result()
7686 
    result.success = self._handler.getValidOrderCount()
7687 
    oprot.writeMessageBegin("getValidOrderCount", TMessageType.REPLY, seqid)
7688 
    result.write(oprot)
7689 
    oprot.writeMessageEnd()
7690 
    oprot.trans.flush()
7691 
 
7692 
  def process_getNoOfCustomersWithSuccessfulTransaction(self, seqid, iprot, oprot):
7693 
    args = getNoOfCustomersWithSuccessfulTransaction_args()
7694 
    args.read(iprot)
7695 
    iprot.readMessageEnd()
7696 
    result = getNoOfCustomersWithSuccessfulTransaction_result()
7697 
    result.success = self._handler.getNoOfCustomersWithSuccessfulTransaction()
7698 
    oprot.writeMessageBegin("getNoOfCustomersWithSuccessfulTransaction", TMessageType.REPLY, seqid)
7699 
    result.write(oprot)
7700 
    oprot.writeMessageEnd()
7701 
    oprot.trans.flush()
7702 
 
7703 
  def process_getValidOrdersAmountRange(self, seqid, iprot, oprot):
7704 
    args = getValidOrdersAmountRange_args()
7705 
    args.read(iprot)
7706 
    iprot.readMessageEnd()
7707 
    result = getValidOrdersAmountRange_result()
7708 
    result.success = self._handler.getValidOrdersAmountRange()
7709 
    oprot.writeMessageBegin("getValidOrdersAmountRange", TMessageType.REPLY, seqid)
7710 
    result.write(oprot)
7711 
    oprot.writeMessageEnd()
7712 
    oprot.trans.flush()
7713 
 
7714 
  def process_getValidOrders(self, seqid, iprot, oprot):
7715 
    args = getValidOrders_args()
7716 
    args.read(iprot)
7717 
    iprot.readMessageEnd()
7718 
    result = getValidOrders_result()
5874 rajveer 7719 
    result.success = self._handler.getValidOrders(args.limit, args.onlyStore)
3064 chandransh 7720 
    oprot.writeMessageBegin("getValidOrders", TMessageType.REPLY, seqid)
7721 
    result.write(oprot)
7722 
    oprot.writeMessageEnd()
7723 
    oprot.trans.flush()
7724 
 
1220 chandransh 7725 
  def process_batchOrders(self, seqid, iprot, oprot):
7726 
    args = batchOrders_args()
7727 
    args.read(iprot)
7728 
    iprot.readMessageEnd()
7729 
    result = batchOrders_result()
7730 
    try:
7731 
      result.success = self._handler.batchOrders(args.warehouseId)
7732 
    except TransactionServiceException, ex:
7733 
      result.ex = ex
7734 
    oprot.writeMessageBegin("batchOrders", TMessageType.REPLY, seqid)
7735 
    result.write(oprot)
7736 
    oprot.writeMessageEnd()
7737 
    oprot.trans.flush()
7738 
 
1208 chandransh 7739 
  def process_markOrderAsOutOfStock(self, seqid, iprot, oprot):
7740 
    args = markOrderAsOutOfStock_args()
7741 
    args.read(iprot)
7742 
    iprot.readMessageEnd()
7743 
    result = markOrderAsOutOfStock_result()
7744 
    try:
7745 
      result.success = self._handler.markOrderAsOutOfStock(args.orderId)
7746 
    except TransactionServiceException, ex:
7747 
      result.ex = ex
7748 
    oprot.writeMessageBegin("markOrderAsOutOfStock", TMessageType.REPLY, seqid)
7749 
    result.write(oprot)
7750 
    oprot.writeMessageEnd()
7751 
    oprot.trans.flush()
7752 
 
3064 chandransh 7753 
  def process_verifyOrder(self, seqid, iprot, oprot):
7754 
    args = verifyOrder_args()
759 chandransh 7755 
    args.read(iprot)
7756 
    iprot.readMessageEnd()
3064 chandransh 7757 
    result = verifyOrder_result()
759 chandransh 7758 
    try:
3064 chandransh 7759 
      result.success = self._handler.verifyOrder(args.orderId)
759 chandransh 7760 
    except TransactionServiceException, ex:
7761 
      result.ex = ex
3064 chandransh 7762 
    oprot.writeMessageBegin("verifyOrder", TMessageType.REPLY, seqid)
759 chandransh 7763 
    result.write(oprot)
7764 
    oprot.writeMessageEnd()
7765 
    oprot.trans.flush()
7766 
 
3064 chandransh 7767 
  def process_acceptOrder(self, seqid, iprot, oprot):
7768 
    args = acceptOrder_args()
1113 chandransh 7769 
    args.read(iprot)
7770 
    iprot.readMessageEnd()
3064 chandransh 7771 
    result = acceptOrder_result()
1113 chandransh 7772 
    try:
3064 chandransh 7773 
      result.success = self._handler.acceptOrder(args.orderId)
1113 chandransh 7774 
    except TransactionServiceException, ex:
7775 
      result.ex = ex
3064 chandransh 7776 
    oprot.writeMessageBegin("acceptOrder", TMessageType.REPLY, seqid)
1113 chandransh 7777 
    result.write(oprot)
7778 
    oprot.writeMessageEnd()
7779 
    oprot.trans.flush()
7780 
 
3064 chandransh 7781 
  def process_addBillingDetails(self, seqid, iprot, oprot):
7782 
    args = addBillingDetails_args()
1135 chandransh 7783 
    args.read(iprot)
7784 
    iprot.readMessageEnd()
3064 chandransh 7785 
    result = addBillingDetails_result()
1135 chandransh 7786 
    try:
5110 mandeep.dh 7787 
      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 7788 
    except TransactionServiceException, ex:
7789 
      result.ex = ex
3064 chandransh 7790 
    oprot.writeMessageBegin("addBillingDetails", TMessageType.REPLY, seqid)
1135 chandransh 7791 
    result.write(oprot)
7792 
    oprot.writeMessageEnd()
7793 
    oprot.trans.flush()
7794 
 
4579 rajveer 7795 
  def process_addInvoiceNumber(self, seqid, iprot, oprot):
7796 
    args = addInvoiceNumber_args()
7797 
    args.read(iprot)
7798 
    iprot.readMessageEnd()
7799 
    result = addInvoiceNumber_result()
7800 
    try:
6756 amar.kumar 7801 
      self._handler.addInvoiceNumber(args.orderId, args.invoiceNumber, args.color, args.serialNumber, args.itemNumber)
4579 rajveer 7802 
    except TransactionServiceException, ex:
7803 
      result.ex = ex
7804 
    oprot.writeMessageBegin("addInvoiceNumber", TMessageType.REPLY, seqid)
7805 
    result.write(oprot)
7806 
    oprot.writeMessageEnd()
7807 
    oprot.trans.flush()
7808 
 
4410 rajveer 7809 
  def process_markOrdersAsShippedFromWarehouse(self, seqid, iprot, oprot):
7810 
    args = markOrdersAsShippedFromWarehouse_args()
7811 
    args.read(iprot)
7812 
    iprot.readMessageEnd()
7813 
    result = markOrdersAsShippedFromWarehouse_result()
7814 
    try:
4789 rajveer 7815 
      result.success = self._handler.markOrdersAsShippedFromWarehouse(args.warehouseId, args.providerId, args.cod, args.orderIds)
4410 rajveer 7816 
    except TransactionServiceException, ex:
7817 
      result.ex = ex
7818 
    oprot.writeMessageBegin("markOrdersAsShippedFromWarehouse", TMessageType.REPLY, seqid)
7819 
    result.write(oprot)
7820 
    oprot.writeMessageEnd()
7821 
    oprot.trans.flush()
7822 
 
5676 rajveer 7823 
  def process_markOrdersAsReturnedFromStore(self, seqid, iprot, oprot):
7824 
    args = markOrdersAsReturnedFromStore_args()
7825 
    args.read(iprot)
7826 
    iprot.readMessageEnd()
7827 
    result = markOrdersAsReturnedFromStore_result()
7828 
    try:
5713 rajveer 7829 
      result.success = self._handler.markOrdersAsReturnedFromStore(args.providerId, args.orderIds, args.awbs)
5676 rajveer 7830 
    except TransactionServiceException, ex:
7831 
      result.ex = ex
7832 
    oprot.writeMessageBegin("markOrdersAsReturnedFromStore", TMessageType.REPLY, seqid)
7833 
    result.write(oprot)
7834 
    oprot.writeMessageEnd()
7835 
    oprot.trans.flush()
7836 
 
3064 chandransh 7837 
  def process_markOrdersAsPickedUp(self, seqid, iprot, oprot):
7838 
    args = markOrdersAsPickedUp_args()
304 ashish 7839 
    args.read(iprot)
7840 
    iprot.readMessageEnd()
3064 chandransh 7841 
    result = markOrdersAsPickedUp_result()
7842 
    try:
4910 phani.kuma 7843 
      self._handler.markOrdersAsPickedUp(args.providerId, args.pickupDetails)
3064 chandransh 7844 
    except TransactionServiceException, ex:
7845 
      result.ex = ex
7846 
    oprot.writeMessageBegin("markOrdersAsPickedUp", TMessageType.REPLY, seqid)
304 ashish 7847 
    result.write(oprot)
7848 
    oprot.writeMessageEnd()
7849 
    oprot.trans.flush()
94 ashish 7850 
 
4910 phani.kuma 7851 
  def process_getOrdersNotPickedUp(self, seqid, iprot, oprot):
7852 
    args = getOrdersNotPickedUp_args()
7853 
    args.read(iprot)
7854 
    iprot.readMessageEnd()
7855 
    result = getOrdersNotPickedUp_result()
7856 
    result.success = self._handler.getOrdersNotPickedUp(args.providerId)
7857 
    oprot.writeMessageBegin("getOrdersNotPickedUp", TMessageType.REPLY, seqid)
7858 
    result.write(oprot)
7859 
    oprot.writeMessageEnd()
7860 
    oprot.trans.flush()
7861 
 
3064 chandransh 7862 
  def process_markOrdersAsDelivered(self, seqid, iprot, oprot):
7863 
    args = markOrdersAsDelivered_args()
304 ashish 7864 
    args.read(iprot)
7865 
    iprot.readMessageEnd()
3064 chandransh 7866 
    result = markOrdersAsDelivered_result()
7867 
    try:
7868 
      self._handler.markOrdersAsDelivered(args.providerId, args.deliveredOrders)
7869 
    except TransactionServiceException, ex:
7870 
      result.ex = ex
7871 
    oprot.writeMessageBegin("markOrdersAsDelivered", TMessageType.REPLY, seqid)
304 ashish 7872 
    result.write(oprot)
7873 
    oprot.writeMessageEnd()
7874 
    oprot.trans.flush()
7875 
 
4910 phani.kuma 7876 
  def process_markAsRTOrders(self, seqid, iprot, oprot):
7877 
    args = markAsRTOrders_args()
1596 ankur.sing 7878 
    args.read(iprot)
7879 
    iprot.readMessageEnd()
4910 phani.kuma 7880 
    result = markAsRTOrders_result()
3064 chandransh 7881 
    try:
4910 phani.kuma 7882 
      self._handler.markAsRTOrders(args.providerId, args.returnedOrders)
3064 chandransh 7883 
    except TransactionServiceException, ex:
7884 
      result.ex = ex
4910 phani.kuma 7885 
    oprot.writeMessageBegin("markAsRTOrders", TMessageType.REPLY, seqid)
1596 ankur.sing 7886 
    result.write(oprot)
7887 
    oprot.writeMessageEnd()
7888 
    oprot.trans.flush()
304 ashish 7889 
 
4910 phani.kuma 7890 
  def process_getRTOrders(self, seqid, iprot, oprot):
7891 
    args = getRTOrders_args()
7892 
    args.read(iprot)
7893 
    iprot.readMessageEnd()
7894 
    result = getRTOrders_result()
7895 
    result.success = self._handler.getRTOrders(args.providerId)
7896 
    oprot.writeMessageBegin("getRTOrders", TMessageType.REPLY, seqid)
7897 
    result.write(oprot)
7898 
    oprot.writeMessageEnd()
7899 
    oprot.trans.flush()
7900 
 
3064 chandransh 7901 
  def process_updateNonDeliveryReason(self, seqid, iprot, oprot):
7902 
    args = updateNonDeliveryReason_args()
1627 ankur.sing 7903 
    args.read(iprot)
7904 
    iprot.readMessageEnd()
3064 chandransh 7905 
    result = updateNonDeliveryReason_result()
7906 
    try:
4910 phani.kuma 7907 
      self._handler.updateNonDeliveryReason(args.providerId, args.undeliveredOrders)
3064 chandransh 7908 
    except TransactionServiceException, ex:
7909 
      result.ex = ex
7910 
    oprot.writeMessageBegin("updateNonDeliveryReason", TMessageType.REPLY, seqid)
1627 ankur.sing 7911 
    result.write(oprot)
7912 
    oprot.writeMessageEnd()
7913 
    oprot.trans.flush()
1596 ankur.sing 7914 
 
4910 phani.kuma 7915 
  def process_getNonDeliveredOrdersbyCourier(self, seqid, iprot, oprot):
7916 
    args = getNonDeliveredOrdersbyCourier_args()
7917 
    args.read(iprot)
7918 
    iprot.readMessageEnd()
7919 
    result = getNonDeliveredOrdersbyCourier_result()
7920 
    result.success = self._handler.getNonDeliveredOrdersbyCourier(args.providerId)
7921 
    oprot.writeMessageBegin("getNonDeliveredOrdersbyCourier", TMessageType.REPLY, seqid)
7922 
    result.write(oprot)
7923 
    oprot.writeMessageEnd()
7924 
    oprot.trans.flush()
7925 
 
7926 
  def process_markOrdersAsLocalConnected(self, seqid, iprot, oprot):
7927 
    args = markOrdersAsLocalConnected_args()
7928 
    args.read(iprot)
7929 
    iprot.readMessageEnd()
7930 
    result = markOrdersAsLocalConnected_result()
7931 
    try:
7932 
      self._handler.markOrdersAsLocalConnected(args.providerId, args.local_connected_orders)
7933 
    except TransactionServiceException, ex:
7934 
      result.ex = ex
7935 
    oprot.writeMessageBegin("markOrdersAsLocalConnected", TMessageType.REPLY, seqid)
7936 
    result.write(oprot)
7937 
    oprot.writeMessageEnd()
7938 
    oprot.trans.flush()
7939 
 
7940 
  def process_getOrdersNotLocalConnected(self, seqid, iprot, oprot):
7941 
    args = getOrdersNotLocalConnected_args()
7942 
    args.read(iprot)
7943 
    iprot.readMessageEnd()
7944 
    result = getOrdersNotLocalConnected_result()
7945 
    result.success = self._handler.getOrdersNotLocalConnected(args.providerId)
7946 
    oprot.writeMessageBegin("getOrdersNotLocalConnected", TMessageType.REPLY, seqid)
7947 
    result.write(oprot)
7948 
    oprot.writeMessageEnd()
7949 
    oprot.trans.flush()
7950 
 
7951 
  def process_markOrdersAsDestinationCityReached(self, seqid, iprot, oprot):
7952 
    args = markOrdersAsDestinationCityReached_args()
7953 
    args.read(iprot)
7954 
    iprot.readMessageEnd()
7955 
    result = markOrdersAsDestinationCityReached_result()
7956 
    try:
7957 
      self._handler.markOrdersAsDestinationCityReached(args.providerId, args.destination_city_reached_orders)
7958 
    except TransactionServiceException, ex:
7959 
      result.ex = ex
7960 
    oprot.writeMessageBegin("markOrdersAsDestinationCityReached", TMessageType.REPLY, seqid)
7961 
    result.write(oprot)
7962 
    oprot.writeMessageEnd()
7963 
    oprot.trans.flush()
7964 
 
7965 
  def process_markOrdersAsFirstDeliveryAttempted(self, seqid, iprot, oprot):
7966 
    args = markOrdersAsFirstDeliveryAttempted_args()
7967 
    args.read(iprot)
7968 
    iprot.readMessageEnd()
7969 
    result = markOrdersAsFirstDeliveryAttempted_result()
7970 
    try:
7971 
      self._handler.markOrdersAsFirstDeliveryAttempted(args.providerId, args.first_atdl_orders)
7972 
    except TransactionServiceException, ex:
7973 
      result.ex = ex
7974 
    oprot.writeMessageBegin("markOrdersAsFirstDeliveryAttempted", TMessageType.REPLY, seqid)
7975 
    result.write(oprot)
7976 
    oprot.writeMessageEnd()
7977 
    oprot.trans.flush()
7978 
 
3064 chandransh 7979 
  def process_getUndeliveredOrders(self, seqid, iprot, oprot):
7980 
    args = getUndeliveredOrders_args()
1627 ankur.sing 7981 
    args.read(iprot)
7982 
    iprot.readMessageEnd()
3064 chandransh 7983 
    result = getUndeliveredOrders_result()
7984 
    result.success = self._handler.getUndeliveredOrders(args.providerId, args.warehouseId)
7985 
    oprot.writeMessageBegin("getUndeliveredOrders", TMessageType.REPLY, seqid)
1627 ankur.sing 7986 
    result.write(oprot)
7987 
    oprot.writeMessageEnd()
7988 
    oprot.trans.flush()
7989 
 
4783 phani.kuma 7990 
  def process_getUndeliveredOrdersExpectedDeliveryDateNotMet(self, seqid, iprot, oprot):
7991 
    args = getUndeliveredOrdersExpectedDeliveryDateNotMet_args()
7992 
    args.read(iprot)
7993 
    iprot.readMessageEnd()
7994 
    result = getUndeliveredOrdersExpectedDeliveryDateNotMet_result()
7995 
    result.success = self._handler.getUndeliveredOrdersExpectedDeliveryDateNotMet()
7996 
    oprot.writeMessageBegin("getUndeliveredOrdersExpectedDeliveryDateNotMet", TMessageType.REPLY, seqid)
7997 
    result.write(oprot)
7998 
    oprot.writeMessageEnd()
7999 
    oprot.trans.flush()
8000 
 
2536 chandransh 8001 
  def process_toggleDOAFlag(self, seqid, iprot, oprot):
8002 
    args = toggleDOAFlag_args()
8003 
    args.read(iprot)
8004 
    iprot.readMessageEnd()
8005 
    result = toggleDOAFlag_result()
8006 
    try:
8007 
      result.success = self._handler.toggleDOAFlag(args.orderId)
8008 
    except TransactionServiceException, ex:
8009 
      result.ex = ex
8010 
    oprot.writeMessageBegin("toggleDOAFlag", TMessageType.REPLY, seqid)
8011 
    result.write(oprot)
8012 
    oprot.writeMessageEnd()
8013 
    oprot.trans.flush()
1886 ankur.sing 8014 
 
4712 rajveer 8015 
  def process_markOrderAsDelivered(self, seqid, iprot, oprot):
8016 
    args = markOrderAsDelivered_args()
8017 
    args.read(iprot)
8018 
    iprot.readMessageEnd()
8019 
    result = markOrderAsDelivered_result()
8020 
    try:
8021 
      self._handler.markOrderAsDelivered(args.orderId, args.deliveryTimestamp, args.receiver)
8022 
    except TransactionServiceException, ex:
8023 
      result.ex = ex
8024 
    oprot.writeMessageBegin("markOrderAsDelivered", TMessageType.REPLY, seqid)
8025 
    result.write(oprot)
8026 
    oprot.writeMessageEnd()
8027 
    oprot.trans.flush()
8028 
 
5553 rajveer 8029 
  def process_markOrderAsReceivedAtStore(self, seqid, iprot, oprot):
8030 
    args = markOrderAsReceivedAtStore_args()
8031 
    args.read(iprot)
8032 
    iprot.readMessageEnd()
8033 
    result = markOrderAsReceivedAtStore_result()
8034 
    try:
8035 
      self._handler.markOrderAsReceivedAtStore(args.orderId, args.deliveryTimestamp)
8036 
    except TransactionServiceException, ex:
8037 
      result.ex = ex
8038 
    oprot.writeMessageBegin("markOrderAsReceivedAtStore", TMessageType.REPLY, seqid)
8039 
    result.write(oprot)
8040 
    oprot.writeMessageEnd()
8041 
    oprot.trans.flush()
8042 
 
4454 rajveer 8043 
  def process_markOrderDoaRequestReceived(self, seqid, iprot, oprot):
8044 
    args = markOrderDoaRequestReceived_args()
8045 
    args.read(iprot)
8046 
    iprot.readMessageEnd()
8047 
    result = markOrderDoaRequestReceived_result()
8048 
    try:
8049 
      result.success = self._handler.markOrderDoaRequestReceived(args.orderId)
8050 
    except TransactionServiceException, ex:
8051 
      result.ex = ex
8052 
    oprot.writeMessageBegin("markOrderDoaRequestReceived", TMessageType.REPLY, seqid)
8053 
    result.write(oprot)
8054 
    oprot.writeMessageEnd()
8055 
    oprot.trans.flush()
8056 
 
8057 
  def process_markOrderDoaRequestAuthorized(self, seqid, iprot, oprot):
8058 
    args = markOrderDoaRequestAuthorized_args()
8059 
    args.read(iprot)
8060 
    iprot.readMessageEnd()
8061 
    result = markOrderDoaRequestAuthorized_result()
8062 
    try:
8063 
      result.success = self._handler.markOrderDoaRequestAuthorized(args.orderId, args.isAuthorized)
8064 
    except TransactionServiceException, ex:
8065 
      result.ex = ex
8066 
    oprot.writeMessageBegin("markOrderDoaRequestAuthorized", TMessageType.REPLY, seqid)
8067 
    result.write(oprot)
8068 
    oprot.writeMessageEnd()
8069 
    oprot.trans.flush()
8070 
 
4488 rajveer 8071 
  def process_markOrderReturnRequestReceived(self, seqid, iprot, oprot):
8072 
    args = markOrderReturnRequestReceived_args()
8073 
    args.read(iprot)
8074 
    iprot.readMessageEnd()
8075 
    result = markOrderReturnRequestReceived_result()
8076 
    try:
8077 
      result.success = self._handler.markOrderReturnRequestReceived(args.orderId)
8078 
    except TransactionServiceException, ex:
8079 
      result.ex = ex
8080 
    oprot.writeMessageBegin("markOrderReturnRequestReceived", TMessageType.REPLY, seqid)
8081 
    result.write(oprot)
8082 
    oprot.writeMessageEnd()
8083 
    oprot.trans.flush()
8084 
 
8085 
  def process_markOrderReturnRequestAuthorized(self, seqid, iprot, oprot):
8086 
    args = markOrderReturnRequestAuthorized_args()
8087 
    args.read(iprot)
8088 
    iprot.readMessageEnd()
8089 
    result = markOrderReturnRequestAuthorized_result()
8090 
    try:
8091 
      result.success = self._handler.markOrderReturnRequestAuthorized(args.orderId, args.isAuthorized)
8092 
    except TransactionServiceException, ex:
8093 
      result.ex = ex
8094 
    oprot.writeMessageBegin("markOrderReturnRequestAuthorized", TMessageType.REPLY, seqid)
8095 
    result.write(oprot)
8096 
    oprot.writeMessageEnd()
8097 
    oprot.trans.flush()
8098 
 
2536 chandransh 8099 
  def process_requestPickupNumber(self, seqid, iprot, oprot):
8100 
    args = requestPickupNumber_args()
8101 
    args.read(iprot)
8102 
    iprot.readMessageEnd()
8103 
    result = requestPickupNumber_result()
8104 
    try:
4579 rajveer 8105 
      result.success = self._handler.requestPickupNumber(args.orderId, args.providerId)
2536 chandransh 8106 
    except TransactionServiceException, ex:
8107 
      result.ex = ex
8108 
    oprot.writeMessageBegin("requestPickupNumber", TMessageType.REPLY, seqid)
8109 
    result.write(oprot)
8110 
    oprot.writeMessageEnd()
8111 
    oprot.trans.flush()
8112 
 
8113 
  def process_authorizePickup(self, seqid, iprot, oprot):
8114 
    args = authorizePickup_args()
8115 
    args.read(iprot)
8116 
    iprot.readMessageEnd()
8117 
    result = authorizePickup_result()
8118 
    try:
4602 rajveer 8119 
      result.success = self._handler.authorizePickup(args.orderId, args.pickupNumber, args.providerId)
2536 chandransh 8120 
    except TransactionServiceException, ex:
8121 
      result.ex = ex
8122 
    oprot.writeMessageBegin("authorizePickup", TMessageType.REPLY, seqid)
8123 
    result.write(oprot)
8124 
    oprot.writeMessageEnd()
8125 
    oprot.trans.flush()
8126 
 
2764 chandransh 8127 
  def process_markDoasAsPickedUp(self, seqid, iprot, oprot):
8128 
    args = markDoasAsPickedUp_args()
8129 
    args.read(iprot)
8130 
    iprot.readMessageEnd()
8131 
    result = markDoasAsPickedUp_result()
4910 phani.kuma 8132 
    self._handler.markDoasAsPickedUp(args.providerId, args.pickupDetails)
2764 chandransh 8133 
    oprot.writeMessageBegin("markDoasAsPickedUp", TMessageType.REPLY, seqid)
8134 
    result.write(oprot)
8135 
    oprot.writeMessageEnd()
8136 
    oprot.trans.flush()
8137 
 
4910 phani.kuma 8138 
  def process_getDoasNotPickedUp(self, seqid, iprot, oprot):
8139 
    args = getDoasNotPickedUp_args()
8140 
    args.read(iprot)
8141 
    iprot.readMessageEnd()
8142 
    result = getDoasNotPickedUp_result()
8143 
    result.success = self._handler.getDoasNotPickedUp(args.providerId)
8144 
    oprot.writeMessageBegin("getDoasNotPickedUp", TMessageType.REPLY, seqid)
8145 
    result.write(oprot)
8146 
    oprot.writeMessageEnd()
8147 
    oprot.trans.flush()
8148 
 
4741 phani.kuma 8149 
  def process_markReturnOrdersAsPickedUp(self, seqid, iprot, oprot):
8150 
    args = markReturnOrdersAsPickedUp_args()
8151 
    args.read(iprot)
8152 
    iprot.readMessageEnd()
8153 
    result = markReturnOrdersAsPickedUp_result()
4910 phani.kuma 8154 
    self._handler.markReturnOrdersAsPickedUp(args.providerId, args.pickupDetails)
4741 phani.kuma 8155 
    oprot.writeMessageBegin("markReturnOrdersAsPickedUp", TMessageType.REPLY, seqid)
8156 
    result.write(oprot)
8157 
    oprot.writeMessageEnd()
8158 
    oprot.trans.flush()
8159 
 
4910 phani.kuma 8160 
  def process_getReturnOrdersNotPickedUp(self, seqid, iprot, oprot):
8161 
    args = getReturnOrdersNotPickedUp_args()
8162 
    args.read(iprot)
8163 
    iprot.readMessageEnd()
8164 
    result = getReturnOrdersNotPickedUp_result()
8165 
    result.success = self._handler.getReturnOrdersNotPickedUp(args.providerId)
8166 
    oprot.writeMessageBegin("getReturnOrdersNotPickedUp", TMessageType.REPLY, seqid)
8167 
    result.write(oprot)
8168 
    oprot.writeMessageEnd()
8169 
    oprot.trans.flush()
8170 
 
2616 chandransh 8171 
  def process_receiveReturn(self, seqid, iprot, oprot):
8172 
    args = receiveReturn_args()
2591 chandransh 8173 
    args.read(iprot)
8174 
    iprot.readMessageEnd()
2616 chandransh 8175 
    result = receiveReturn_result()
2591 chandransh 8176 
    try:
4479 rajveer 8177 
      result.success = self._handler.receiveReturn(args.orderId, args.receiveCondition)
2591 chandransh 8178 
    except TransactionServiceException, ex:
8179 
      result.ex = ex
2616 chandransh 8180 
    oprot.writeMessageBegin("receiveReturn", TMessageType.REPLY, seqid)
2591 chandransh 8181 
    result.write(oprot)
8182 
    oprot.writeMessageEnd()
8183 
    oprot.trans.flush()
2536 chandransh 8184 
 
2591 chandransh 8185 
  def process_validateDoa(self, seqid, iprot, oprot):
8186 
    args = validateDoa_args()
8187 
    args.read(iprot)
8188 
    iprot.readMessageEnd()
8189 
    result = validateDoa_result()
8190 
    try:
8191 
      result.success = self._handler.validateDoa(args.orderId, args.isValid)
8192 
    except TransactionServiceException, ex:
8193 
      result.ex = ex
8194 
    oprot.writeMessageBegin("validateDoa", TMessageType.REPLY, seqid)
8195 
    result.write(oprot)
8196 
    oprot.writeMessageEnd()
8197 
    oprot.trans.flush()
8198 
 
4495 rajveer 8199 
  def process_validateReturnProduct(self, seqid, iprot, oprot):
8200 
    args = validateReturnProduct_args()
8201 
    args.read(iprot)
8202 
    iprot.readMessageEnd()
8203 
    result = validateReturnProduct_result()
8204 
    try:
8205 
      result.success = self._handler.validateReturnProduct(args.orderId, args.isUsable)
8206 
    except TransactionServiceException, ex:
8207 
      result.ex = ex
8208 
    oprot.writeMessageBegin("validateReturnProduct", TMessageType.REPLY, seqid)
8209 
    result.write(oprot)
8210 
    oprot.writeMessageEnd()
8211 
    oprot.trans.flush()
8212 
 
2616 chandransh 8213 
  def process_reshipOrder(self, seqid, iprot, oprot):
8214 
    args = reshipOrder_args()
8215 
    args.read(iprot)
8216 
    iprot.readMessageEnd()
8217 
    result = reshipOrder_result()
8218 
    try:
8219 
      result.success = self._handler.reshipOrder(args.orderId)
8220 
    except TransactionServiceException, ex:
8221 
      result.ex = ex
8222 
    oprot.writeMessageBegin("reshipOrder", TMessageType.REPLY, seqid)
8223 
    result.write(oprot)
8224 
    oprot.writeMessageEnd()
8225 
    oprot.trans.flush()
2591 chandransh 8226 
 
2616 chandransh 8227 
  def process_refundOrder(self, seqid, iprot, oprot):
8228 
    args = refundOrder_args()
8229 
    args.read(iprot)
8230 
    iprot.readMessageEnd()
8231 
    result = refundOrder_result()
8232 
    try:
3226 chandransh 8233 
      result.success = self._handler.refundOrder(args.orderId, args.refundedBy, args.reason)
2616 chandransh 8234 
    except TransactionServiceException, ex:
8235 
      result.ex = ex
8236 
    oprot.writeMessageBegin("refundOrder", TMessageType.REPLY, seqid)
8237 
    result.write(oprot)
8238 
    oprot.writeMessageEnd()
8239 
    oprot.trans.flush()
8240 
 
2690 chandransh 8241 
  def process_getReturnOrders(self, seqid, iprot, oprot):
8242 
    args = getReturnOrders_args()
8243 
    args.read(iprot)
8244 
    iprot.readMessageEnd()
8245 
    result = getReturnOrders_result()
8246 
    result.success = self._handler.getReturnOrders(args.warehouseId, args.fromDate, args.toDate)
8247 
    oprot.writeMessageBegin("getReturnOrders", TMessageType.REPLY, seqid)
8248 
    result.write(oprot)
8249 
    oprot.writeMessageEnd()
8250 
    oprot.trans.flush()
2616 chandransh 8251 
 
5481 phani.kuma 8252 
  def process_getAllReturnOrders(self, seqid, iprot, oprot):
8253 
    args = getAllReturnOrders_args()
8254 
    args.read(iprot)
8255 
    iprot.readMessageEnd()
8256 
    result = getAllReturnOrders_result()
8257 
    result.success = self._handler.getAllReturnOrders(args.onlyNotProcessed, args.fromDate, args.toDate)
8258 
    oprot.writeMessageBegin("getAllReturnOrders", TMessageType.REPLY, seqid)
8259 
    result.write(oprot)
8260 
    oprot.writeMessageEnd()
8261 
    oprot.trans.flush()
8262 
 
2700 chandransh 8263 
  def process_getReturnOrder(self, seqid, iprot, oprot):
8264 
    args = getReturnOrder_args()
8265 
    args.read(iprot)
8266 
    iprot.readMessageEnd()
8267 
    result = getReturnOrder_result()
8268 
    try:
8269 
      result.success = self._handler.getReturnOrder(args.id)
8270 
    except TransactionServiceException, ex:
8271 
      result.ex = ex
8272 
    oprot.writeMessageBegin("getReturnOrder", TMessageType.REPLY, seqid)
8273 
    result.write(oprot)
8274 
    oprot.writeMessageEnd()
8275 
    oprot.trans.flush()
8276 
 
2690 chandransh 8277 
  def process_processReturn(self, seqid, iprot, oprot):
8278 
    args = processReturn_args()
8279 
    args.read(iprot)
8280 
    iprot.readMessageEnd()
8281 
    result = processReturn_result()
8282 
    try:
8283 
      self._handler.processReturn(args.returnOrderId)
8284 
    except TransactionServiceException, ex:
8285 
      result.ex = ex
8286 
    oprot.writeMessageBegin("processReturn", TMessageType.REPLY, seqid)
8287 
    result.write(oprot)
8288 
    oprot.writeMessageEnd()
8289 
    oprot.trans.flush()
8290 
 
3451 chandransh 8291 
  def process_updateWeight(self, seqid, iprot, oprot):
8292 
    args = updateWeight_args()
8293 
    args.read(iprot)
8294 
    iprot.readMessageEnd()
8295 
    result = updateWeight_result()
8296 
    try:
8297 
      result.success = self._handler.updateWeight(args.orderId, args.weight)
8298 
    except TransactionServiceException, ex:
8299 
      result.ex = ex
8300 
    oprot.writeMessageBegin("updateWeight", TMessageType.REPLY, seqid)
8301 
    result.write(oprot)
8302 
    oprot.writeMessageEnd()
8303 
    oprot.trans.flush()
2819 chandransh 8304 
 
3469 chandransh 8305 
  def process_changeItem(self, seqid, iprot, oprot):
8306 
    args = changeItem_args()
8307 
    args.read(iprot)
8308 
    iprot.readMessageEnd()
8309 
    result = changeItem_result()
8310 
    try:
8311 
      result.success = self._handler.changeItem(args.orderId, args.itemId)
8312 
    except TransactionServiceException, ex:
8313 
      result.ex = ex
8314 
    oprot.writeMessageBegin("changeItem", TMessageType.REPLY, seqid)
8315 
    result.write(oprot)
8316 
    oprot.writeMessageEnd()
8317 
    oprot.trans.flush()
3451 chandransh 8318 
 
3469 chandransh 8319 
  def process_shiftToWarehouse(self, seqid, iprot, oprot):
8320 
    args = shiftToWarehouse_args()
8321 
    args.read(iprot)
8322 
    iprot.readMessageEnd()
8323 
    result = shiftToWarehouse_result()
8324 
    try:
8325 
      result.success = self._handler.shiftToWarehouse(args.orderId, args.warehouseId)
8326 
    except TransactionServiceException, ex:
8327 
      result.ex = ex
8328 
    oprot.writeMessageBegin("shiftToWarehouse", TMessageType.REPLY, seqid)
8329 
    result.write(oprot)
8330 
    oprot.writeMessageEnd()
8331 
    oprot.trans.flush()
8332 
 
3553 chandransh 8333 
  def process_addDelayReason(self, seqid, iprot, oprot):
8334 
    args = addDelayReason_args()
8335 
    args.read(iprot)
8336 
    iprot.readMessageEnd()
8337 
    result = addDelayReason_result()
8338 
    try:
4647 rajveer 8339 
      result.success = self._handler.addDelayReason(args.orderId, args.delayReason, args.furtherDelay, args.delayReasonText)
3553 chandransh 8340 
    except TransactionServiceException, ex:
8341 
      result.ex = ex
8342 
    oprot.writeMessageBegin("addDelayReason", TMessageType.REPLY, seqid)
8343 
    result.write(oprot)
8344 
    oprot.writeMessageEnd()
8345 
    oprot.trans.flush()
3469 chandransh 8346 
 
3956 chandransh 8347 
  def process_reconcileCodCollection(self, seqid, iprot, oprot):
8348 
    args = reconcileCodCollection_args()
8349 
    args.read(iprot)
8350 
    iprot.readMessageEnd()
8351 
    result = reconcileCodCollection_result()
8352 
    try:
8353 
      result.success = self._handler.reconcileCodCollection(args.collectedAmountMap, args.xferBy, args.xferTxnId, args.xferDate)
8354 
    except TransactionServiceException, ex:
8355 
      result.ex = ex
8356 
    oprot.writeMessageBegin("reconcileCodCollection", TMessageType.REPLY, seqid)
8357 
    result.write(oprot)
8358 
    oprot.writeMessageEnd()
8359 
    oprot.trans.flush()
3553 chandransh 8360 
 
4008 mandeep.dh 8361 
  def process_getTransactionsRequiringExtraProcessing(self, seqid, iprot, oprot):
8362 
    args = getTransactionsRequiringExtraProcessing_args()
8363 
    args.read(iprot)
8364 
    iprot.readMessageEnd()
8365 
    result = getTransactionsRequiringExtraProcessing_result()
8366 
    result.success = self._handler.getTransactionsRequiringExtraProcessing(args.category)
8367 
    oprot.writeMessageBegin("getTransactionsRequiringExtraProcessing", TMessageType.REPLY, seqid)
8368 
    result.write(oprot)
8369 
    oprot.writeMessageEnd()
8370 
    oprot.trans.flush()
3956 chandransh 8371 
 
4008 mandeep.dh 8372 
  def process_markTransactionAsProcessed(self, seqid, iprot, oprot):
8373 
    args = markTransactionAsProcessed_args()
8374 
    args.read(iprot)
8375 
    iprot.readMessageEnd()
8376 
    result = markTransactionAsProcessed_result()
8377 
    self._handler.markTransactionAsProcessed(args.transactionId, args.category)
8378 
    oprot.writeMessageBegin("markTransactionAsProcessed", TMessageType.REPLY, seqid)
8379 
    result.write(oprot)
8380 
    oprot.writeMessageEnd()
8381 
    oprot.trans.flush()
8382 
 
4018 chandransh 8383 
  def process_getItemWiseRiskyOrdersCount(self, seqid, iprot, oprot):
8384 
    args = getItemWiseRiskyOrdersCount_args()
8385 
    args.read(iprot)
8386 
    iprot.readMessageEnd()
8387 
    result = getItemWiseRiskyOrdersCount_result()
8388 
    result.success = self._handler.getItemWiseRiskyOrdersCount()
8389 
    oprot.writeMessageBegin("getItemWiseRiskyOrdersCount", TMessageType.REPLY, seqid)
8390 
    result.write(oprot)
8391 
    oprot.writeMessageEnd()
8392 
    oprot.trans.flush()
4008 mandeep.dh 8393 
 
4295 varun.gupt 8394 
  def process_getOrdersForItemIds(self, seqid, iprot, oprot):
8395 
    args = getOrdersForItemIds_args()
8396 
    args.read(iprot)
8397 
    iprot.readMessageEnd()
8398 
    result = getOrdersForItemIds_result()
8399 
    result.success = self._handler.getOrdersForItemIds(args.itemIds)
8400 
    oprot.writeMessageBegin("getOrdersForItemIds", TMessageType.REPLY, seqid)
8401 
    result.write(oprot)
8402 
    oprot.writeMessageEnd()
8403 
    oprot.trans.flush()
8404 
 
4247 rajveer 8405 
  def process_markOrderCancellationRequestReceived(self, seqid, iprot, oprot):
8406 
    args = markOrderCancellationRequestReceived_args()
8407 
    args.read(iprot)
8408 
    iprot.readMessageEnd()
8409 
    result = markOrderCancellationRequestReceived_result()
8410 
    try:
8411 
      self._handler.markOrderCancellationRequestReceived(args.orderId)
8412 
    except TransactionServiceException, ex:
8413 
      result.ex = ex
8414 
    oprot.writeMessageBegin("markOrderCancellationRequestReceived", TMessageType.REPLY, seqid)
8415 
    result.write(oprot)
8416 
    oprot.writeMessageEnd()
8417 
    oprot.trans.flush()
4018 chandransh 8418 
 
4247 rajveer 8419 
  def process_markOrderCancellationRequestConfirmed(self, seqid, iprot, oprot):
8420 
    args = markOrderCancellationRequestConfirmed_args()
8421 
    args.read(iprot)
8422 
    iprot.readMessageEnd()
8423 
    result = markOrderCancellationRequestConfirmed_result()
8424 
    try:
8425 
      self._handler.markOrderCancellationRequestConfirmed(args.orderId)
8426 
    except TransactionServiceException, ex:
8427 
      result.ex = ex
8428 
    oprot.writeMessageBegin("markOrderCancellationRequestConfirmed", TMessageType.REPLY, seqid)
8429 
    result.write(oprot)
8430 
    oprot.writeMessageEnd()
8431 
    oprot.trans.flush()
8432 
 
8433 
  def process_markOrderCancellationRequestDenied(self, seqid, iprot, oprot):
8434 
    args = markOrderCancellationRequestDenied_args()
8435 
    args.read(iprot)
8436 
    iprot.readMessageEnd()
8437 
    result = markOrderCancellationRequestDenied_result()
8438 
    try:
8439 
      self._handler.markOrderCancellationRequestDenied(args.orderId)
8440 
    except TransactionServiceException, ex:
8441 
      result.ex = ex
8442 
    oprot.writeMessageBegin("markOrderCancellationRequestDenied", TMessageType.REPLY, seqid)
8443 
    result.write(oprot)
8444 
    oprot.writeMessageEnd()
8445 
    oprot.trans.flush()
8446 
 
4258 rajveer 8447 
  def process_markTransactionAsPaymentFlagRemoved(self, seqid, iprot, oprot):
8448 
    args = markTransactionAsPaymentFlagRemoved_args()
4247 rajveer 8449 
    args.read(iprot)
8450 
    iprot.readMessageEnd()
4258 rajveer 8451 
    result = markTransactionAsPaymentFlagRemoved_result()
4247 rajveer 8452 
    try:
4258 rajveer 8453 
      self._handler.markTransactionAsPaymentFlagRemoved(args.transactionId)
4247 rajveer 8454 
    except TransactionServiceException, ex:
8455 
      result.ex = ex
4258 rajveer 8456 
    oprot.writeMessageBegin("markTransactionAsPaymentFlagRemoved", TMessageType.REPLY, seqid)
4247 rajveer 8457 
    result.write(oprot)
8458 
    oprot.writeMessageEnd()
8459 
    oprot.trans.flush()
8460 
 
4259 anupam.sin 8461 
  def process_refundTransaction(self, seqid, iprot, oprot):
8462 
    args = refundTransaction_args()
8463 
    args.read(iprot)
8464 
    iprot.readMessageEnd()
8465 
    result = refundTransaction_result()
8466 
    try:
8467 
      self._handler.refundTransaction(args.transactionId, args.refundedBy, args.reason)
8468 
    except TransactionServiceException, ex:
8469 
      result.ex = ex
8470 
    oprot.writeMessageBegin("refundTransaction", TMessageType.REPLY, seqid)
8471 
    result.write(oprot)
8472 
    oprot.writeMessageEnd()
8473 
    oprot.trans.flush()
4247 rajveer 8474 
 
4324 mandeep.dh 8475 
  def process_updateShipmentAddress(self, seqid, iprot, oprot):
8476 
    args = updateShipmentAddress_args()
8477 
    args.read(iprot)
8478 
    iprot.readMessageEnd()
8479 
    result = updateShipmentAddress_result()
8480 
    try:
8481 
      self._handler.updateShipmentAddress(args.orderId, args.addressId)
8482 
    except TransactionServiceException, ex:
8483 
      result.ex = ex
8484 
    oprot.writeMessageBegin("updateShipmentAddress", TMessageType.REPLY, seqid)
8485 
    result.write(oprot)
8486 
    oprot.writeMessageEnd()
8487 
    oprot.trans.flush()
8488 
 
4285 rajveer 8489 
  def process_acceptOrdersForItemId(self, seqid, iprot, oprot):
8490 
    args = acceptOrdersForItemId_args()
8491 
    args.read(iprot)
8492 
    iprot.readMessageEnd()
8493 
    result = acceptOrdersForItemId_result()
8494 
    try:
8495 
      result.success = self._handler.acceptOrdersForItemId(args.itemId, args.inventory)
8496 
    except TransactionServiceException, ex:
8497 
      result.ex = ex
8498 
    oprot.writeMessageBegin("acceptOrdersForItemId", TMessageType.REPLY, seqid)
8499 
    result.write(oprot)
8500 
    oprot.writeMessageEnd()
8501 
    oprot.trans.flush()
4259 anupam.sin 8502 
 
4303 rajveer 8503 
  def process_markOrdersAsPORaised(self, seqid, iprot, oprot):
8504 
    args = markOrdersAsPORaised_args()
8505 
    args.read(iprot)
8506 
    iprot.readMessageEnd()
8507 
    result = markOrdersAsPORaised_result()
8508 
    try:
4369 rajveer 8509 
      self._handler.markOrdersAsPORaised(args.vendorId, args.itemId, args.quantity, args.estimate, args.isReminder)
4303 rajveer 8510 
    except TransactionServiceException, ex:
8511 
      result.ex = ex
8512 
    oprot.writeMessageBegin("markOrdersAsPORaised", TMessageType.REPLY, seqid)
8513 
    result.write(oprot)
8514 
    oprot.writeMessageEnd()
8515 
    oprot.trans.flush()
4285 rajveer 8516 
 
4303 rajveer 8517 
  def process_markOrdersAsReversalInitiated(self, seqid, iprot, oprot):
8518 
    args = markOrdersAsReversalInitiated_args()
8519 
    args.read(iprot)
8520 
    iprot.readMessageEnd()
8521 
    result = markOrdersAsReversalInitiated_result()
8522 
    try:
4369 rajveer 8523 
      self._handler.markOrdersAsReversalInitiated(args.vendorId, args.itemId, args.quantity, args.estimate, args.isReminder)
4303 rajveer 8524 
    except TransactionServiceException, ex:
8525 
      result.ex = ex
8526 
    oprot.writeMessageBegin("markOrdersAsReversalInitiated", TMessageType.REPLY, seqid)
8527 
    result.write(oprot)
8528 
    oprot.writeMessageEnd()
8529 
    oprot.trans.flush()
8530 
 
8531 
  def process_markOrdersAsNotAvailabke(self, seqid, iprot, oprot):
8532 
    args = markOrdersAsNotAvailabke_args()
8533 
    args.read(iprot)
8534 
    iprot.readMessageEnd()
8535 
    result = markOrdersAsNotAvailabke_result()
8536 
    try:
4369 rajveer 8537 
      self._handler.markOrdersAsNotAvailabke(args.vendorId, args.itemId, args.quantity, args.estimate, args.isReminder)
4303 rajveer 8538 
    except TransactionServiceException, ex:
8539 
      result.ex = ex
8540 
    oprot.writeMessageBegin("markOrdersAsNotAvailabke", TMessageType.REPLY, seqid)
8541 
    result.write(oprot)
8542 
    oprot.writeMessageEnd()
8543 
    oprot.trans.flush()
8544 
 
4369 rajveer 8545 
  def process_markOrdersAsTimeout(self, seqid, iprot, oprot):
8546 
    args = markOrdersAsTimeout_args()
8547 
    args.read(iprot)
8548 
    iprot.readMessageEnd()
8549 
    result = markOrdersAsTimeout_result()
8550 
    try:
8551 
      result.success = self._handler.markOrdersAsTimeout(args.vendorId)
8552 
    except TransactionServiceException, ex:
8553 
      result.ex = ex
8554 
    oprot.writeMessageBegin("markOrdersAsTimeout", TMessageType.REPLY, seqid)
8555 
    result.write(oprot)
8556 
    oprot.writeMessageEnd()
8557 
    oprot.trans.flush()
4303 rajveer 8558 
 
4662 rajveer 8559 
  def process_markOrderAsLostInTransit(self, seqid, iprot, oprot):
8560 
    args = markOrderAsLostInTransit_args()
8561 
    args.read(iprot)
8562 
    iprot.readMessageEnd()
8563 
    result = markOrderAsLostInTransit_result()
8564 
    try:
8565 
      result.success = self._handler.markOrderAsLostInTransit(args.orderId)
8566 
    except TransactionServiceException, ex:
8567 
      result.ex = ex
8568 
    oprot.writeMessageBegin("markOrderAsLostInTransit", TMessageType.REPLY, seqid)
8569 
    result.write(oprot)
8570 
    oprot.writeMessageEnd()
8571 
    oprot.trans.flush()
8572 
 
4386 anupam.sin 8573 
  def process_getOrderForAwb(self, seqid, iprot, oprot):
8574 
    args = getOrderForAwb_args()
8575 
    args.read(iprot)
8576 
    iprot.readMessageEnd()
8577 
    result = getOrderForAwb_result()
8578 
    try:
8579 
      result.success = self._handler.getOrderForAwb(args.awb)
8580 
    except TransactionServiceException, ex:
8581 
      result.ex = ex
8582 
    oprot.writeMessageBegin("getOrderForAwb", TMessageType.REPLY, seqid)
8583 
    result.write(oprot)
8584 
    oprot.writeMessageEnd()
8585 
    oprot.trans.flush()
4369 rajveer 8586 
 
4506 phani.kuma 8587 
  def process_getOrdersForProviderForStatus(self, seqid, iprot, oprot):
8588 
    args = getOrdersForProviderForStatus_args()
8589 
    args.read(iprot)
8590 
    iprot.readMessageEnd()
8591 
    result = getOrdersForProviderForStatus_result()
8592 
    try:
4910 phani.kuma 8593 
      result.success = self._handler.getOrdersForProviderForStatus(args.logistics_provider_id, args.order_status_list)
4506 phani.kuma 8594 
    except TransactionServiceException, ex:
8595 
      result.ex = ex
8596 
    oprot.writeMessageBegin("getOrdersForProviderForStatus", TMessageType.REPLY, seqid)
8597 
    result.write(oprot)
8598 
    oprot.writeMessageEnd()
8599 
    oprot.trans.flush()
4386 anupam.sin 8600 
 
4600 varun.gupt 8601 
  def process_getBilledOrdersForVendor(self, seqid, iprot, oprot):
8602 
    args = getBilledOrdersForVendor_args()
8603 
    args.read(iprot)
8604 
    iprot.readMessageEnd()
8605 
    result = getBilledOrdersForVendor_result()
8606 
    try:
8607 
      result.success = self._handler.getBilledOrdersForVendor(args.vendorId, args.billingDateFrom, args.billingDateTo)
8608 
    except TransactionServiceException, ex:
8609 
      result.ex = ex
8610 
    oprot.writeMessageBegin("getBilledOrdersForVendor", TMessageType.REPLY, seqid)
8611 
    result.write(oprot)
8612 
    oprot.writeMessageEnd()
8613 
    oprot.trans.flush()
4506 phani.kuma 8614 
 
4607 rajveer 8615 
  def process_getSlippedSippingDateOrders(self, seqid, iprot, oprot):
8616 
    args = getSlippedSippingDateOrders_args()
8617 
    args.read(iprot)
8618 
    iprot.readMessageEnd()
8619 
    result = getSlippedSippingDateOrders_result()
8620 
    try:
8621 
      result.success = self._handler.getSlippedSippingDateOrders()
8622 
    except TransactionServiceException, ex:
8623 
      result.ex = ex
8624 
    oprot.writeMessageBegin("getSlippedSippingDateOrders", TMessageType.REPLY, seqid)
8625 
    result.write(oprot)
8626 
    oprot.writeMessageEnd()
8627 
    oprot.trans.flush()
8628 
 
4709 rajveer 8629 
  def process_getCancelledOrders(self, seqid, iprot, oprot):
8630 
    args = getCancelledOrders_args()
8631 
    args.read(iprot)
8632 
    iprot.readMessageEnd()
8633 
    result = getCancelledOrders_result()
8634 
    try:
8635 
      result.success = self._handler.getCancelledOrders(args.cancelDateFrom, args.cancelDateTo)
8636 
    except TransactionServiceException, ex:
8637 
      result.ex = ex
8638 
    oprot.writeMessageBegin("getCancelledOrders", TMessageType.REPLY, seqid)
8639 
    result.write(oprot)
8640 
    oprot.writeMessageEnd()
8641 
    oprot.trans.flush()
8642 
 
4600 varun.gupt 8643 
  def process_saveBluedartSettlements(self, seqid, iprot, oprot):
8644 
    args = saveBluedartSettlements_args()
8645 
    args.read(iprot)
8646 
    iprot.readMessageEnd()
8647 
    result = saveBluedartSettlements_result()
8648 
    try:
8649 
      self._handler.saveBluedartSettlements(args.mapAWBAndAmount)
8650 
    except TransactionServiceException, ex:
8651 
      result.ex = ex
8652 
    oprot.writeMessageBegin("saveBluedartSettlements", TMessageType.REPLY, seqid)
8653 
    result.write(oprot)
8654 
    oprot.writeMessageEnd()
8655 
    oprot.trans.flush()
8656 
 
8657 
  def process_savePaymentSettlements(self, seqid, iprot, oprot):
8658 
    args = savePaymentSettlements_args()
8659 
    args.read(iprot)
8660 
    iprot.readMessageEnd()
8661 
    result = savePaymentSettlements_result()
8662 
    try:
4905 varun.gupt 8663 
      self._handler.savePaymentSettlements(args.settlementDate, args.paymentGatewayId, args.referenceId, args.serviceTax, args.otherCharges, args.netCollection)
4600 varun.gupt 8664 
    except TransactionServiceException, ex:
8665 
      result.ex = ex
8666 
    oprot.writeMessageBegin("savePaymentSettlements", TMessageType.REPLY, seqid)
8667 
    result.write(oprot)
8668 
    oprot.writeMessageEnd()
8669 
    oprot.trans.flush()
8670 
 
8671 
  def process_saveEBSSettlementSummary(self, seqid, iprot, oprot):
8672 
    args = saveEBSSettlementSummary_args()
8673 
    args.read(iprot)
8674 
    iprot.readMessageEnd()
8675 
    result = saveEBSSettlementSummary_result()
8676 
    try:
8677 
      self._handler.saveEBSSettlementSummary(args.settlementId, args.settlementDate, args.transactionDateFrom, args.transactionDateTo, args.amount)
8678 
    except TransactionServiceException, ex:
8679 
      result.ex = ex
8680 
    oprot.writeMessageBegin("saveEBSSettlementSummary", TMessageType.REPLY, seqid)
8681 
    result.write(oprot)
8682 
    oprot.writeMessageEnd()
8683 
    oprot.trans.flush()
8684 
 
5386 phani.kuma 8685 
  def process_getSettlementForPrepaid(self, seqid, iprot, oprot):
8686 
    args = getSettlementForPrepaid_args()
4600 varun.gupt 8687 
    args.read(iprot)
8688 
    iprot.readMessageEnd()
5386 phani.kuma 8689 
    result = getSettlementForPrepaid_result()
4600 varun.gupt 8690 
    try:
5386 phani.kuma 8691 
      result.success = self._handler.getSettlementForPrepaid(args.referenceId, args.isRefund)
4600 varun.gupt 8692 
    except TransactionServiceException, ex:
8693 
      result.ex = ex
5386 phani.kuma 8694 
    oprot.writeMessageBegin("getSettlementForPrepaid", TMessageType.REPLY, seqid)
4600 varun.gupt 8695 
    result.write(oprot)
8696 
    oprot.writeMessageEnd()
8697 
    oprot.trans.flush()
8698 
 
5386 phani.kuma 8699 
  def process_getSettlementForCod(self, seqid, iprot, oprot):
8700 
    args = getSettlementForCod_args()
8701 
    args.read(iprot)
8702 
    iprot.readMessageEnd()
8703 
    result = getSettlementForCod_result()
8704 
    try:
8705 
      result.success = self._handler.getSettlementForCod(args.orderId, args.isRefund)
8706 
    except TransactionServiceException, ex:
8707 
      result.ex = ex
8708 
    oprot.writeMessageBegin("getSettlementForCod", TMessageType.REPLY, seqid)
8709 
    result.write(oprot)
8710 
    oprot.writeMessageEnd()
8711 
    oprot.trans.flush()
8712 
 
4600 varun.gupt 8713 
  def process_getEBSSettlementSummaries(self, seqid, iprot, oprot):
8714 
    args = getEBSSettlementSummaries_args()
8715 
    args.read(iprot)
8716 
    iprot.readMessageEnd()
8717 
    result = getEBSSettlementSummaries_result()
8718 
    try:
8719 
      result.success = self._handler.getEBSSettlementSummaries()
8720 
    except TransactionServiceException, ex:
8721 
      result.ex = ex
8722 
    oprot.writeMessageBegin("getEBSSettlementSummaries", TMessageType.REPLY, seqid)
8723 
    result.write(oprot)
8724 
    oprot.writeMessageEnd()
8725 
    oprot.trans.flush()
8726 
 
8727 
  def process_markEBSSettlementUploaded(self, seqid, iprot, oprot):
8728 
    args = markEBSSettlementUploaded_args()
8729 
    args.read(iprot)
8730 
    iprot.readMessageEnd()
8731 
    result = markEBSSettlementUploaded_result()
8732 
    try:
8733 
      self._handler.markEBSSettlementUploaded(args.settlementId)
8734 
    except TransactionServiceException, ex:
8735 
      result.ex = ex
8736 
    oprot.writeMessageBegin("markEBSSettlementUploaded", TMessageType.REPLY, seqid)
8737 
    result.write(oprot)
8738 
    oprot.writeMessageEnd()
8739 
    oprot.trans.flush()
8740 
 
8741 
  def process_getEBSSettlementDate(self, seqid, iprot, oprot):
8742 
    args = getEBSSettlementDate_args()
8743 
    args.read(iprot)
8744 
    iprot.readMessageEnd()
8745 
    result = getEBSSettlementDate_result()
8746 
    try:
8747 
      result.success = self._handler.getEBSSettlementDate(args.settlementId)
8748 
    except TransactionServiceException, ex:
8749 
      result.ex = ex
8750 
    oprot.writeMessageBegin("getEBSSettlementDate", TMessageType.REPLY, seqid)
8751 
    result.write(oprot)
8752 
    oprot.writeMessageEnd()
8753 
    oprot.trans.flush()
8754 
 
4715 varun.gupt 8755 
  def process_getSettlementsByDate(self, seqid, iprot, oprot):
8756 
    args = getSettlementsByDate_args()
8757 
    args.read(iprot)
8758 
    iprot.readMessageEnd()
8759 
    result = getSettlementsByDate_result()
8760 
    try:
8761 
      result.success = self._handler.getSettlementsByDate(args.settlementDateFrom, args.settlementDateTo, args.isRefund)
8762 
    except TransactionServiceException, ex:
8763 
      result.ex = ex
8764 
    oprot.writeMessageBegin("getSettlementsByDate", TMessageType.REPLY, seqid)
8765 
    result.write(oprot)
8766 
    oprot.writeMessageEnd()
8767 
    oprot.trans.flush()
4600 varun.gupt 8768 
 
4715 varun.gupt 8769 
  def process_getReshippedOrderIds(self, seqid, iprot, oprot):
8770 
    args = getReshippedOrderIds_args()
8771 
    args.read(iprot)
8772 
    iprot.readMessageEnd()
8773 
    result = getReshippedOrderIds_result()
8774 
    try:
8775 
      result.success = self._handler.getReshippedOrderIds(args.orderIds)
8776 
    except TransactionServiceException, ex:
8777 
      result.ex = ex
8778 
    oprot.writeMessageBegin("getReshippedOrderIds", TMessageType.REPLY, seqid)
8779 
    result.write(oprot)
8780 
    oprot.writeMessageEnd()
8781 
    oprot.trans.flush()
8782 
 
5481 phani.kuma 8783 
  def process_getBilledOrders(self, seqid, iprot, oprot):
8784 
    args = getBilledOrders_args()
4875 varun.gupt 8785 
    args.read(iprot)
8786 
    iprot.readMessageEnd()
5481 phani.kuma 8787 
    result = getBilledOrders_result()
4875 varun.gupt 8788 
    try:
5481 phani.kuma 8789 
      result.success = self._handler.getBilledOrders(args.vendorId, args.onlyVendorNotPaid, args.billingDateFrom, args.billingDateTo)
4875 varun.gupt 8790 
    except TransactionServiceException, ex:
8791 
      result.ex = ex
5481 phani.kuma 8792 
    oprot.writeMessageBegin("getBilledOrders", TMessageType.REPLY, seqid)
4875 varun.gupt 8793 
    result.write(oprot)
8794 
    oprot.writeMessageEnd()
8795 
    oprot.trans.flush()
4757 mandeep.dh 8796 
 
5031 varun.gupt 8797 
  def process_getStatusDistributionOfOrders(self, seqid, iprot, oprot):
8798 
    args = getStatusDistributionOfOrders_args()
8799 
    args.read(iprot)
8800 
    iprot.readMessageEnd()
8801 
    result = getStatusDistributionOfOrders_result()
8802 
    try:
8803 
      result.success = self._handler.getStatusDistributionOfOrders(args.startDate, args.endDate)
8804 
    except TransactionServiceException, ex:
8805 
      result.ex = ex
8806 
    oprot.writeMessageBegin("getStatusDistributionOfOrders", TMessageType.REPLY, seqid)
8807 
    result.write(oprot)
8808 
    oprot.writeMessageEnd()
8809 
    oprot.trans.flush()
4875 varun.gupt 8810 
 
5067 varun.gupt 8811 
  def process_getOrderIdsForStatus(self, seqid, iprot, oprot):
8812 
    args = getOrderIdsForStatus_args()
8813 
    args.read(iprot)
8814 
    iprot.readMessageEnd()
8815 
    result = getOrderIdsForStatus_result()
8816 
    try:
8817 
      result.success = self._handler.getOrderIdsForStatus(args.status, args.startDatetime, args.endDatetime)
8818 
    except TransactionServiceException, ex:
8819 
      result.ex = ex
8820 
    oprot.writeMessageBegin("getOrderIdsForStatus", TMessageType.REPLY, seqid)
8821 
    result.write(oprot)
8822 
    oprot.writeMessageEnd()
8823 
    oprot.trans.flush()
5031 varun.gupt 8824 
 
5348 anupam.sin 8825 
  def process_updateCODAgent(self, seqid, iprot, oprot):
8826 
    args = updateCODAgent_args()
8827 
    args.read(iprot)
8828 
    iprot.readMessageEnd()
8829 
    result = updateCODAgent_result()
8830 
    try:
8831 
      self._handler.updateCODAgent(args.agent, args.orderId)
8832 
    except TransactionServiceException, ex:
8833 
      result.ex = ex
8834 
    oprot.writeMessageBegin("updateCODAgent", TMessageType.REPLY, seqid)
8835 
    result.write(oprot)
8836 
    oprot.writeMessageEnd()
8837 
    oprot.trans.flush()
8838 
 
5099 varun.gupt 8839 
  def process_updateOrderAsPaidToVendor(self, seqid, iprot, oprot):
8840 
    args = updateOrderAsPaidToVendor_args()
8841 
    args.read(iprot)
8842 
    iprot.readMessageEnd()
8843 
    result = updateOrderAsPaidToVendor_result()
8844 
    try:
8845 
      self._handler.updateOrderAsPaidToVendor(args.orderId)
8846 
    except TransactionServiceException, ex:
8847 
      result.ex = ex
8848 
    oprot.writeMessageBegin("updateOrderAsPaidToVendor", TMessageType.REPLY, seqid)
8849 
    result.write(oprot)
8850 
    oprot.writeMessageEnd()
8851 
    oprot.trans.flush()
5067 varun.gupt 8852 
 
5386 phani.kuma 8853 
  def process_updateOrderOnlyAsPaidToVendor(self, seqid, iprot, oprot):
8854 
    args = updateOrderOnlyAsPaidToVendor_args()
8855 
    args.read(iprot)
8856 
    iprot.readMessageEnd()
8857 
    result = updateOrderOnlyAsPaidToVendor_result()
8858 
    try:
8859 
      self._handler.updateOrderOnlyAsPaidToVendor(args.orderId)
8860 
    except TransactionServiceException, ex:
8861 
      result.ex = ex
8862 
    oprot.writeMessageBegin("updateOrderOnlyAsPaidToVendor", TMessageType.REPLY, seqid)
8863 
    result.write(oprot)
8864 
    oprot.writeMessageEnd()
8865 
    oprot.trans.flush()
8866 
 
5208 varun.gupt 8867 
  def process_getRefundedOrdersMarkedPaid(self, seqid, iprot, oprot):
8868 
    args = getRefundedOrdersMarkedPaid_args()
8869 
    args.read(iprot)
8870 
    iprot.readMessageEnd()
8871 
    result = getRefundedOrdersMarkedPaid_result()
8872 
    try:
8873 
      result.success = self._handler.getRefundedOrdersMarkedPaid()
8874 
    except TransactionServiceException, ex:
8875 
      result.ex = ex
8876 
    oprot.writeMessageBegin("getRefundedOrdersMarkedPaid", TMessageType.REPLY, seqid)
8877 
    result.write(oprot)
8878 
    oprot.writeMessageEnd()
8879 
    oprot.trans.flush()
5099 varun.gupt 8880 
 
5447 anupam.sin 8881 
  def process_getAllVerificationAgents(self, seqid, iprot, oprot):
8882 
    args = getAllVerificationAgents_args()
8883 
    args.read(iprot)
8884 
    iprot.readMessageEnd()
8885 
    result = getAllVerificationAgents_result()
8886 
    result.success = self._handler.getAllVerificationAgents(args.minOrderId, args.maxOrderId)
8887 
    oprot.writeMessageBegin("getAllVerificationAgents", TMessageType.REPLY, seqid)
8888 
    result.write(oprot)
8889 
    oprot.writeMessageEnd()
8890 
    oprot.trans.flush()
5208 varun.gupt 8891 
 
5527 anupam.sin 8892 
  def process_getAllAttributesForOrderId(self, seqid, iprot, oprot):
8893 
    args = getAllAttributesForOrderId_args()
8894 
    args.read(iprot)
8895 
    iprot.readMessageEnd()
8896 
    result = getAllAttributesForOrderId_result()
8897 
    result.success = self._handler.getAllAttributesForOrderId(args.orderId)
8898 
    oprot.writeMessageBegin("getAllAttributesForOrderId", TMessageType.REPLY, seqid)
8899 
    result.write(oprot)
8900 
    oprot.writeMessageEnd()
8901 
    oprot.trans.flush()
5447 anupam.sin 8902 
 
5676 rajveer 8903 
  def process_setOrderAttributes(self, seqid, iprot, oprot):
8904 
    args = setOrderAttributes_args()
8905 
    args.read(iprot)
8906 
    iprot.readMessageEnd()
8907 
    result = setOrderAttributes_result()
8908 
    self._handler.setOrderAttributes(args.orderId, args.attributes)
8909 
    oprot.writeMessageBegin("setOrderAttributes", TMessageType.REPLY, seqid)
8910 
    result.write(oprot)
8911 
    oprot.writeMessageEnd()
8912 
    oprot.trans.flush()
8913 
 
5527 anupam.sin 8914 
  def process_setOrderAttributeForTransaction(self, seqid, iprot, oprot):
8915 
    args = setOrderAttributeForTransaction_args()
8916 
    args.read(iprot)
8917 
    iprot.readMessageEnd()
8918 
    result = setOrderAttributeForTransaction_result()
8919 
    self._handler.setOrderAttributeForTransaction(args.transactionId, args.attribute)
8920 
    oprot.writeMessageBegin("setOrderAttributeForTransaction", TMessageType.REPLY, seqid)
8921 
    result.write(oprot)
8922 
    oprot.writeMessageEnd()
8923 
    oprot.trans.flush()
8924 
 
5553 rajveer 8925 
  def process_getReceivePendingOrders(self, seqid, iprot, oprot):
8926 
    args = getReceivePendingOrders_args()
8927 
    args.read(iprot)
8928 
    iprot.readMessageEnd()
8929 
    result = getReceivePendingOrders_result()
8930 
    result.success = self._handler.getReceivePendingOrders(args.storeId)
8931 
    oprot.writeMessageBegin("getReceivePendingOrders", TMessageType.REPLY, seqid)
8932 
    result.write(oprot)
8933 
    oprot.writeMessageEnd()
8934 
    oprot.trans.flush()
5527 anupam.sin 8935 
 
5553 rajveer 8936 
  def process_getReceivedAtStoreOrders(self, seqid, iprot, oprot):
8937 
    args = getReceivedAtStoreOrders_args()
8938 
    args.read(iprot)
8939 
    iprot.readMessageEnd()
8940 
    result = getReceivedAtStoreOrders_result()
8941 
    result.success = self._handler.getReceivedAtStoreOrders(args.storeId)
8942 
    oprot.writeMessageBegin("getReceivedAtStoreOrders", TMessageType.REPLY, seqid)
8943 
    result.write(oprot)
8944 
    oprot.writeMessageEnd()
8945 
    oprot.trans.flush()
8946 
 
5713 rajveer 8947 
  def process_getOrdersCollectionAtStore(self, seqid, iprot, oprot):
8948 
    args = getOrdersCollectionAtStore_args()
8949 
    args.read(iprot)
8950 
    iprot.readMessageEnd()
8951 
    result = getOrdersCollectionAtStore_result()
8952 
    result.success = self._handler.getOrdersCollectionAtStore(args.storeId, args.fromDate, args.toDate, args.onlyCod)
8953 
    oprot.writeMessageBegin("getOrdersCollectionAtStore", TMessageType.REPLY, seqid)
8954 
    result.write(oprot)
8955 
    oprot.writeMessageEnd()
8956 
    oprot.trans.flush()
8957 
 
5833 rajveer 8958 
  def process_getOrderAttributeValue(self, seqid, iprot, oprot):
8959 
    args = getOrderAttributeValue_args()
8960 
    args.read(iprot)
8961 
    iprot.readMessageEnd()
8962 
    result = getOrderAttributeValue_result()
8963 
    result.success = self._handler.getOrderAttributeValue(args.orderId, args.attributeName)
8964 
    oprot.writeMessageBegin("getOrderAttributeValue", TMessageType.REPLY, seqid)
8965 
    result.write(oprot)
8966 
    oprot.writeMessageEnd()
8967 
    oprot.trans.flush()
8968 
 
6019 rajveer 8969 
  def process_changeJacketNumber(self, seqid, iprot, oprot):
8970 
    args = changeJacketNumber_args()
8971 
    args.read(iprot)
8972 
    iprot.readMessageEnd()
8973 
    result = changeJacketNumber_result()
8974 
    result.success = self._handler.changeJacketNumber(args.orderId, args.jacketNumber)
8975 
    oprot.writeMessageBegin("changeJacketNumber", TMessageType.REPLY, seqid)
8976 
    result.write(oprot)
8977 
    oprot.writeMessageEnd()
8978 
    oprot.trans.flush()
8979 
 
8980 
  def process_markOrderAsRtoInTransit(self, seqid, iprot, oprot):
8981 
    args = markOrderAsRtoInTransit_args()
8982 
    args.read(iprot)
8983 
    iprot.readMessageEnd()
8984 
    result = markOrderAsRtoInTransit_result()
8985 
    result.success = self._handler.markOrderAsRtoInTransit(args.orderId)
8986 
    oprot.writeMessageBegin("markOrderAsRtoInTransit", TMessageType.REPLY, seqid)
8987 
    result.write(oprot)
8988 
    oprot.writeMessageEnd()
8989 
    oprot.trans.flush()
8990 
 
5593 mandeep.dh 8991 
  def process_acceptOrderForItem(self, seqid, iprot, oprot):
8992 
    args = acceptOrderForItem_args()
8993 
    args.read(iprot)
8994 
    iprot.readMessageEnd()
8995 
    result = acceptOrderForItem_result()
8996 
    self._handler.acceptOrderForItem(args.itemId, args.quantity, args.fulfilmentWarehouseId, args.billingWarehouseId)
8997 
    oprot.writeMessageBegin("acceptOrderForItem", TMessageType.REPLY, seqid)
8998 
    result.write(oprot)
8999 
    oprot.writeMessageEnd()
9000 
    oprot.trans.flush()
5553 rajveer 9001 
 
6000 mandeep.dh 9002 
  def process_createRechargeOrder(self, seqid, iprot, oprot):
9003 
    args = createRechargeOrder_args()
9004 
    args.read(iprot)
9005 
    iprot.readMessageEnd()
9006 
    result = createRechargeOrder_result()
9007 
    try:
9008 
      result.success = self._handler.createRechargeOrder(args.rechargeOrder)
9009 
    except TransactionServiceException, ex:
9010 
      result.ex = ex
9011 
    oprot.writeMessageBegin("createRechargeOrder", TMessageType.REPLY, seqid)
9012 
    result.write(oprot)
9013 
    oprot.writeMessageEnd()
9014 
    oprot.trans.flush()
5593 mandeep.dh 9015 
 
6031 rajveer 9016 
  def process_getRechargeOrder(self, seqid, iprot, oprot):
9017 
    args = getRechargeOrder_args()
9018 
    args.read(iprot)
9019 
    iprot.readMessageEnd()
9020 
    result = getRechargeOrder_result()
9021 
    try:
9022 
      result.success = self._handler.getRechargeOrder(args.rechargeRrderId)
9023 
    except TransactionServiceException, ex:
9024 
      result.ex = ex
9025 
    oprot.writeMessageBegin("getRechargeOrder", TMessageType.REPLY, seqid)
9026 
    result.write(oprot)
9027 
    oprot.writeMessageEnd()
9028 
    oprot.trans.flush()
9029 
 
9030 
  def process_getRechargeOrders(self, seqid, iprot, oprot):
9031 
    args = getRechargeOrders_args()
9032 
    args.read(iprot)
9033 
    iprot.readMessageEnd()
9034 
    result = getRechargeOrders_result()
9035 
    result.success = self._handler.getRechargeOrders(args.userId)
9036 
    oprot.writeMessageBegin("getRechargeOrders", TMessageType.REPLY, seqid)
9037 
    result.write(oprot)
9038 
    oprot.writeMessageEnd()
9039 
    oprot.trans.flush()
9040 
 
6000 mandeep.dh 9041 
  def process_updateRechargeOrderStatus(self, seqid, iprot, oprot):
9042 
    args = updateRechargeOrderStatus_args()
9043 
    args.read(iprot)
9044 
    iprot.readMessageEnd()
9045 
    result = updateRechargeOrderStatus_result()
9046 
    try:
6031 rajveer 9047 
      result.success = self._handler.updateRechargeOrderStatus(args.rechargeOrderId, args.rechargeOrderStatus)
6000 mandeep.dh 9048 
    except TransactionServiceException, ex:
9049 
      result.ex = ex
9050 
    oprot.writeMessageBegin("updateRechargeOrderStatus", TMessageType.REPLY, seqid)
9051 
    result.write(oprot)
9052 
    oprot.writeMessageEnd()
9053 
    oprot.trans.flush()
9054 
 
9055 
  def process_activateRechargeTxn(self, seqid, iprot, oprot):
9056 
    args = activateRechargeTxn_args()
9057 
    args.read(iprot)
9058 
    iprot.readMessageEnd()
9059 
    result = activateRechargeTxn_result()
9060 
    try:
6031 rajveer 9061 
      result.success = self._handler.activateRechargeTxn(args.rechargeOrderId)
6000 mandeep.dh 9062 
    except TransactionServiceException, ex:
9063 
      result.ex = ex
9064 
    oprot.writeMessageBegin("activateRechargeTxn", TMessageType.REPLY, seqid)
9065 
    result.write(oprot)
9066 
    oprot.writeMessageEnd()
9067 
    oprot.trans.flush()
9068 
 
6031 rajveer 9069 
  def process_getUserWallet(self, seqid, iprot, oprot):
9070 
    args = getUserWallet_args()
6000 mandeep.dh 9071 
    args.read(iprot)
9072 
    iprot.readMessageEnd()
6031 rajveer 9073 
    result = getUserWallet_result()
9074 
    result.success = self._handler.getUserWallet(args.userId)
9075 
    oprot.writeMessageBegin("getUserWallet", TMessageType.REPLY, seqid)
6000 mandeep.dh 9076 
    result.write(oprot)
9077 
    oprot.writeMessageEnd()
9078 
    oprot.trans.flush()
9079 
 
6031 rajveer 9080 
  def process_getUserWalletHistory(self, seqid, iprot, oprot):
9081 
    args = getUserWalletHistory_args()
6000 mandeep.dh 9082 
    args.read(iprot)
9083 
    iprot.readMessageEnd()
6031 rajveer 9084 
    result = getUserWalletHistory_result()
9085 
    result.success = self._handler.getUserWalletHistory(args.userId)
9086 
    oprot.writeMessageBegin("getUserWalletHistory", TMessageType.REPLY, seqid)
6000 mandeep.dh 9087 
    result.write(oprot)
9088 
    oprot.writeMessageEnd()
9089 
    oprot.trans.flush()
9090 
 
6050 anupam.sin 9091 
  def process_getRechargeOrdersForTransaction(self, seqid, iprot, oprot):
9092 
    args = getRechargeOrdersForTransaction_args()
9093 
    args.read(iprot)
9094 
    iprot.readMessageEnd()
9095 
    result = getRechargeOrdersForTransaction_result()
9096 
    try:
9097 
      result.success = self._handler.getRechargeOrdersForTransaction(args.txnId)
9098 
    except TransactionServiceException, ex:
9099 
      result.ex = ex
9100 
    oprot.writeMessageBegin("getRechargeOrdersForTransaction", TMessageType.REPLY, seqid)
9101 
    result.write(oprot)
9102 
    oprot.writeMessageEnd()
9103 
    oprot.trans.flush()
9104 
 
6048 rajveer 9105 
  def process_getServiceProviders(self, seqid, iprot, oprot):
9106 
    args = getServiceProviders_args()
9107 
    args.read(iprot)
9108 
    iprot.readMessageEnd()
9109 
    result = getServiceProviders_result()
6206 rajveer 9110 
    result.success = self._handler.getServiceProviders(args.rechargeType, args.onlyActive)
6048 rajveer 9111 
    oprot.writeMessageBegin("getServiceProviders", TMessageType.REPLY, seqid)
9112 
    result.write(oprot)
9113 
    oprot.writeMessageEnd()
9114 
    oprot.trans.flush()
6000 mandeep.dh 9115 
 
6048 rajveer 9116 
  def process_getServiceProviderForDevice(self, seqid, iprot, oprot):
9117 
    args = getServiceProviderForDevice_args()
9118 
    args.read(iprot)
9119 
    iprot.readMessageEnd()
9120 
    result = getServiceProviderForDevice_result()
6049 rajveer 9121 
    result.success = self._handler.getServiceProviderForDevice(args.rechargeType, args.deviceNumber)
6048 rajveer 9122 
    oprot.writeMessageBegin("getServiceProviderForDevice", TMessageType.REPLY, seqid)
9123 
    result.write(oprot)
9124 
    oprot.writeMessageEnd()
9125 
    oprot.trans.flush()
9126 
 
6269 rajveer 9127 
  def process_validateRecharge(self, seqid, iprot, oprot):
9128 
    args = validateRecharge_args()
9129 
    args.read(iprot)
9130 
    iprot.readMessageEnd()
9131 
    result = validateRecharge_result()
6591 anupam.sin 9132 
    result.success = self._handler.validateRecharge(args.rechargeType, args.deviceNumber, args.userSelectedProviderId, args.clientAddress)
6269 rajveer 9133 
    oprot.writeMessageBegin("validateRecharge", TMessageType.REPLY, seqid)
9134 
    result.write(oprot)
9135 
    oprot.writeMessageEnd()
9136 
    oprot.trans.flush()
9137 
 
6094 rajveer 9138 
  def process_getRechargeOrdersForDevice(self, seqid, iprot, oprot):
9139 
    args = getRechargeOrdersForDevice_args()
9140 
    args.read(iprot)
9141 
    iprot.readMessageEnd()
9142 
    result = getRechargeOrdersForDevice_result()
9143 
    result.success = self._handler.getRechargeOrdersForDevice(args.deviceNumber)
9144 
    oprot.writeMessageBegin("getRechargeOrdersForDevice", TMessageType.REPLY, seqid)
9145 
    result.write(oprot)
9146 
    oprot.writeMessageEnd()
9147 
    oprot.trans.flush()
6048 rajveer 9148 
 
6094 rajveer 9149 
  def process_addAmountToWallet(self, seqid, iprot, oprot):
9150 
    args = addAmountToWallet_args()
9151 
    args.read(iprot)
9152 
    iprot.readMessageEnd()
9153 
    result = addAmountToWallet_result()
9154 
    self._handler.addAmountToWallet(args.userId, args.orderId, args.amount)
9155 
    oprot.writeMessageBegin("addAmountToWallet", TMessageType.REPLY, seqid)
9156 
    result.write(oprot)
9157 
    oprot.writeMessageEnd()
9158 
    oprot.trans.flush()
9159 
 
6188 rajveer 9160 
  def process_getRechargeStatistics(self, seqid, iprot, oprot):
9161 
    args = getRechargeStatistics_args()
9162 
    args.read(iprot)
9163 
    iprot.readMessageEnd()
9164 
    result = getRechargeStatistics_result()
9165 
    result.success = self._handler.getRechargeStatistics()
9166 
    oprot.writeMessageBegin("getRechargeStatistics", TMessageType.REPLY, seqid)
9167 
    result.write(oprot)
9168 
    oprot.writeMessageEnd()
9169 
    oprot.trans.flush()
9170 
 
6154 rajveer 9171 
  def process_getRechargeOrdersForStatus(self, seqid, iprot, oprot):
9172 
    args = getRechargeOrdersForStatus_args()
9173 
    args.read(iprot)
9174 
    iprot.readMessageEnd()
9175 
    result = getRechargeOrdersForStatus_result()
9176 
    result.success = self._handler.getRechargeOrdersForStatus(args.status)
9177 
    oprot.writeMessageBegin("getRechargeOrdersForStatus", TMessageType.REPLY, seqid)
9178 
    result.write(oprot)
9179 
    oprot.writeMessageEnd()
9180 
    oprot.trans.flush()
6094 rajveer 9181 
 
6159 rajveer 9182 
  def process_getPlansForOperator(self, seqid, iprot, oprot):
9183 
    args = getPlansForOperator_args()
9184 
    args.read(iprot)
9185 
    iprot.readMessageEnd()
9186 
    result = getPlansForOperator_result()
9187 
    result.success = self._handler.getPlansForOperator(args.operatorId)
9188 
    oprot.writeMessageBegin("getPlansForOperator", TMessageType.REPLY, seqid)
9189 
    result.write(oprot)
9190 
    oprot.writeMessageEnd()
9191 
    oprot.trans.flush()
6154 rajveer 9192 
 
6289 anupam.sin 9193 
  def process_getRechargeDenominations(self, seqid, iprot, oprot):
9194 
    args = getRechargeDenominations_args()
9195 
    args.read(iprot)
9196 
    iprot.readMessageEnd()
9197 
    result = getRechargeDenominations_result()
9198 
    try:
6307 anupam.sin 9199 
      result.success = self._handler.getRechargeDenominations(args.operatorId, args.circleCode, args.denominationType)
6289 anupam.sin 9200 
    except TransactionServiceException, ex:
9201 
      result.ex = ex
9202 
    oprot.writeMessageBegin("getRechargeDenominations", TMessageType.REPLY, seqid)
9203 
    result.write(oprot)
9204 
    oprot.writeMessageEnd()
9205 
    oprot.trans.flush()
6159 rajveer 9206 
 
6371 rajveer 9207 
  def process_updateAvailabilityStatus(self, seqid, iprot, oprot):
9208 
    args = updateAvailabilityStatus_args()
9209 
    args.read(iprot)
9210 
    iprot.readMessageEnd()
9211 
    result = updateAvailabilityStatus_result()
9212 
    self._handler.updateAvailabilityStatus(args.operatorId, args.circleId, args.isAvailable)
9213 
    oprot.writeMessageBegin("updateAvailabilityStatus", TMessageType.REPLY, seqid)
9214 
    result.write(oprot)
9215 
    oprot.writeMessageEnd()
9216 
    oprot.trans.flush()
6289 anupam.sin 9217 
 
6389 rajveer 9218 
  def process_getAvailableEmiSchemes(self, seqid, iprot, oprot):
9219 
    args = getAvailableEmiSchemes_args()
9220 
    args.read(iprot)
9221 
    iprot.readMessageEnd()
9222 
    result = getAvailableEmiSchemes_result()
9223 
    result.success = self._handler.getAvailableEmiSchemes()
9224 
    oprot.writeMessageBegin("getAvailableEmiSchemes", TMessageType.REPLY, seqid)
9225 
    result.write(oprot)
9226 
    oprot.writeMessageEnd()
9227 
    oprot.trans.flush()
6371 rajveer 9228 
 
6389 rajveer 9229 
  def process_getMiscCharges(self, seqid, iprot, oprot):
9230 
    args = getMiscCharges_args()
9231 
    args.read(iprot)
9232 
    iprot.readMessageEnd()
9233 
    result = getMiscCharges_result()
9234 
    result.success = self._handler.getMiscCharges(args.transactionId)
9235 
    oprot.writeMessageBegin("getMiscCharges", TMessageType.REPLY, seqid)
9236 
    result.write(oprot)
9237 
    oprot.writeMessageEnd()
9238 
    oprot.trans.flush()
9239 
 
6507 anupam.sin 9240 
  def process_refundRechargeOrder(self, seqid, iprot, oprot):
9241 
    args = refundRechargeOrder_args()
9242 
    args.read(iprot)
9243 
    iprot.readMessageEnd()
9244 
    result = refundRechargeOrder_result()
9245 
    try:
9246 
      result.success = self._handler.refundRechargeOrder(args.rechargeOrderId)
9247 
    except TransactionServiceException, ex:
9248 
      result.ex = ex
9249 
    oprot.writeMessageBegin("refundRechargeOrder", TMessageType.REPLY, seqid)
9250 
    result.write(oprot)
9251 
    oprot.writeMessageEnd()
9252 
    oprot.trans.flush()
6389 rajveer 9253 
 
6821 amar.kumar 9254 
  def process_getPhysicalOrders(self, seqid, iprot, oprot):
9255 
    args = getPhysicalOrders_args()
9256 
    args.read(iprot)
9257 
    iprot.readMessageEnd()
9258 
    result = getPhysicalOrders_result()
9259 
    result.success = self._handler.getPhysicalOrders(args.fromDate, args.toDate)
9260 
    oprot.writeMessageBegin("getPhysicalOrders", TMessageType.REPLY, seqid)
9261 
    result.write(oprot)
9262 
    oprot.writeMessageEnd()
9263 
    oprot.trans.flush()
6507 anupam.sin 9264 
 
6906 rajveer 9265 
  def process_getDocument(self, seqid, iprot, oprot):
9266 
    args = getDocument_args()
9267 
    args.read(iprot)
9268 
    iprot.readMessageEnd()
9269 
    result = getDocument_result()
9270 
    result.success = self._handler.getDocument(args.docType, args.docSource)
9271 
    oprot.writeMessageBegin("getDocument", TMessageType.REPLY, seqid)
9272 
    result.write(oprot)
9273 
    oprot.writeMessageEnd()
9274 
    oprot.trans.flush()
6821 amar.kumar 9275 
 
6985 anupam.sin 9276 
  def process_changeShippingAddress(self, seqid, iprot, oprot):
9277 
    args = changeShippingAddress_args()
9278 
    args.read(iprot)
9279 
    iprot.readMessageEnd()
9280 
    result = changeShippingAddress_result()
9281 
    result.success = self._handler.changeShippingAddress(args.orderId, args.line1, args.line2, args.city, args.state, args.pin)
9282 
    oprot.writeMessageBegin("changeShippingAddress", TMessageType.REPLY, seqid)
9283 
    result.write(oprot)
9284 
    oprot.writeMessageEnd()
9285 
    oprot.trans.flush()
6906 rajveer 9286 
 
6988 rajveer 9287 
  def process_retrieveInvoice(self, seqid, iprot, oprot):
9288 
    args = retrieveInvoice_args()
9289 
    args.read(iprot)
9290 
    iprot.readMessageEnd()
9291 
    result = retrieveInvoice_result()
7075 rajveer 9292 
    result.success = self._handler.retrieveInvoice(args.orderId, args.userId)
6988 rajveer 9293 
    oprot.writeMessageBegin("retrieveInvoice", TMessageType.REPLY, seqid)
9294 
    result.write(oprot)
9295 
    oprot.writeMessageEnd()
9296 
    oprot.trans.flush()
6985 anupam.sin 9297 
 
7026 rajveer 9298 
  def process_receiveUpdatesForRedExpress(self, seqid, iprot, oprot):
9299 
    args = receiveUpdatesForRedExpress_args()
9300 
    args.read(iprot)
9301 
    iprot.readMessageEnd()
9302 
    result = receiveUpdatesForRedExpress_result()
9303 
    result.success = self._handler.receiveUpdatesForRedExpress(args.awbNumber)
9304 
    oprot.writeMessageBegin("receiveUpdatesForRedExpress", TMessageType.REPLY, seqid)
9305 
    result.write(oprot)
9306 
    oprot.writeMessageEnd()
9307 
    oprot.trans.flush()
6988 rajveer 9308 
 
7073 anupam.sin 9309 
  def process_createRechargeTransaction(self, seqid, iprot, oprot):
9310 
    args = createRechargeTransaction_args()
9311 
    args.read(iprot)
9312 
    iprot.readMessageEnd()
9313 
    result = createRechargeTransaction_result()
9314 
    result.success = self._handler.createRechargeTransaction(args.thriftRechargeTransaction)
9315 
    oprot.writeMessageBegin("createRechargeTransaction", TMessageType.REPLY, seqid)
9316 
    result.write(oprot)
9317 
    oprot.writeMessageEnd()
9318 
    oprot.trans.flush()
7026 rajveer 9319 
 
7085 rajveer 9320 
  def process_getRechargeTransactions(self, seqid, iprot, oprot):
9321 
    args = getRechargeTransactions_args()
9322 
    args.read(iprot)
9323 
    iprot.readMessageEnd()
9324 
    result = getRechargeTransactions_result()
9325 
    result.success = self._handler.getRechargeTransactions(args.storeId)
9326 
    oprot.writeMessageBegin("getRechargeTransactions", TMessageType.REPLY, seqid)
9327 
    result.write(oprot)
9328 
    oprot.writeMessageEnd()
9329 
    oprot.trans.flush()
9330 
 
7151 amit.gupta 9331 
  def process_getRechargeTrans(self, seqid, iprot, oprot):
9332 
    args = getRechargeTrans_args()
9333 
    args.read(iprot)
9334 
    iprot.readMessageEnd()
9335 
    result = getRechargeTrans_result()
9336 
    result.success = self._handler.getRechargeTrans(args.storeId, args.startDate, args.endDate, args.status)
9337 
    oprot.writeMessageBegin("getRechargeTrans", TMessageType.REPLY, seqid)
9338 
    result.write(oprot)
9339 
    oprot.writeMessageEnd()
9340 
    oprot.trans.flush()
9341 
 
7080 anupam.sin 9342 
  def process_getRechargeTransaction(self, seqid, iprot, oprot):
9343 
    args = getRechargeTransaction_args()
9344 
    args.read(iprot)
9345 
    iprot.readMessageEnd()
9346 
    result = getRechargeTransaction_result()
9347 
    result.success = self._handler.getRechargeTransaction(args.rechargeId)
9348 
    oprot.writeMessageBegin("getRechargeTransaction", TMessageType.REPLY, seqid)
9349 
    result.write(oprot)
9350 
    oprot.writeMessageEnd()
9351 
    oprot.trans.flush()
7073 anupam.sin 9352 
 
7080 anupam.sin 9353 
  def process_getFRCs(self, seqid, iprot, oprot):
9354 
    args = getFRCs_args()
9355 
    args.read(iprot)
9356 
    iprot.readMessageEnd()
9357 
    result = getFRCs_result()
9358 
    result.success = self._handler.getFRCs(args.circleId, args.operatorId)
9359 
    oprot.writeMessageBegin("getFRCs", TMessageType.REPLY, seqid)
9360 
    result.write(oprot)
9361 
    oprot.writeMessageEnd()
9362 
    oprot.trans.flush()
9363 
 
7096 anupam.sin 9364 
  def process_getHotspotStore(self, seqid, iprot, oprot):
9365 
    args = getHotspotStore_args()
9366 
    args.read(iprot)
9367 
    iprot.readMessageEnd()
9368 
    result = getHotspotStore_result()
9369 
    result.success = self._handler.getHotspotStore(args.id, args.hotspotid)
9370 
    oprot.writeMessageBegin("getHotspotStore", TMessageType.REPLY, seqid)
9371 
    result.write(oprot)
9372 
    oprot.writeMessageEnd()
9373 
    oprot.trans.flush()
7080 anupam.sin 9374 
 
7096 anupam.sin 9375 
  def process_getTelecomCircle(self, seqid, iprot, oprot):
9376 
    args = getTelecomCircle_args()
9377 
    args.read(iprot)
9378 
    iprot.readMessageEnd()
9379 
    result = getTelecomCircle_result()
9380 
    result.success = self._handler.getTelecomCircle(args.id, args.code)
9381 
    oprot.writeMessageBegin("getTelecomCircle", TMessageType.REPLY, seqid)
9382 
    result.write(oprot)
9383 
    oprot.writeMessageEnd()
9384 
    oprot.trans.flush()
9385 
 
7109 anupam.sin 9386 
  def process_retrieveHotspotRechargeInvoice(self, seqid, iprot, oprot):
9387 
    args = retrieveHotspotRechargeInvoice_args()
9388 
    args.read(iprot)
9389 
    iprot.readMessageEnd()
9390 
    result = retrieveHotspotRechargeInvoice_result()
9391 
    result.success = self._handler.retrieveHotspotRechargeInvoice(args.rechargeId)
9392 
    oprot.writeMessageBegin("retrieveHotspotRechargeInvoice", TMessageType.REPLY, seqid)
9393 
    result.write(oprot)
9394 
    oprot.writeMessageEnd()
9395 
    oprot.trans.flush()
7096 anupam.sin 9396 
 
7169 anupam.sin 9397 
  def process_getRechargeTransactionsByNumber(self, seqid, iprot, oprot):
9398 
    args = getRechargeTransactionsByNumber_args()
9399 
    args.read(iprot)
9400 
    iprot.readMessageEnd()
9401 
    result = getRechargeTransactionsByNumber_result()
9402 
    result.success = self._handler.getRechargeTransactionsByNumber(args.number)
9403 
    oprot.writeMessageBegin("getRechargeTransactionsByNumber", TMessageType.REPLY, seqid)
9404 
    result.write(oprot)
9405 
    oprot.writeMessageEnd()
9406 
    oprot.trans.flush()
7109 anupam.sin 9407 
 
7169 anupam.sin 9408 
  def process_updateHotspotStorePassword(self, seqid, iprot, oprot):
9409 
    args = updateHotspotStorePassword_args()
9410 
    args.read(iprot)
9411 
    iprot.readMessageEnd()
9412 
    result = updateHotspotStorePassword_result()
9413 
    result.success = self._handler.updateHotspotStorePassword(args.storeId, args.password)
9414 
    oprot.writeMessageBegin("updateHotspotStorePassword", TMessageType.REPLY, seqid)
9415 
    result.write(oprot)
9416 
    oprot.writeMessageEnd()
9417 
    oprot.trans.flush()
9418 
 
9419 
 
94 ashish 9420 
# HELPER FUNCTIONS AND STRUCTURES
9421 
 
9422 
class createTransaction_args:
9423 
  """
9424 
  Attributes:
9425 
   - transaction
9426 
  """
9427 
 
9428 
  thrift_spec = (
9429 
    None, # 0
9430 
    (1, TType.STRUCT, 'transaction', (Transaction, Transaction.thrift_spec), None, ), # 1
9431 
  )
9432 
 
9433 
  def __init__(self, transaction=None,):
9434 
    self.transaction = transaction
9435 
 
9436 
  def read(self, iprot):
9437 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9438 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9439 
      return
9440 
    iprot.readStructBegin()
9441 
    while True:
9442 
      (fname, ftype, fid) = iprot.readFieldBegin()
9443 
      if ftype == TType.STOP:
9444 
        break
9445 
      if fid == 1:
9446 
        if ftype == TType.STRUCT:
9447 
          self.transaction = Transaction()
9448 
          self.transaction.read(iprot)
9449 
        else:
9450 
          iprot.skip(ftype)
9451 
      else:
9452 
        iprot.skip(ftype)
9453 
      iprot.readFieldEnd()
9454 
    iprot.readStructEnd()
9455 
 
9456 
  def write(self, oprot):
9457 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9458 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9459 
      return
9460 
    oprot.writeStructBegin('createTransaction_args')
3431 rajveer 9461 
    if self.transaction is not None:
94 ashish 9462 
      oprot.writeFieldBegin('transaction', TType.STRUCT, 1)
9463 
      self.transaction.write(oprot)
9464 
      oprot.writeFieldEnd()
9465 
    oprot.writeFieldStop()
9466 
    oprot.writeStructEnd()
9467 
 
3431 rajveer 9468 
  def validate(self):
9469 
    return
9470 
 
9471 
 
94 ashish 9472 
  def __repr__(self):
9473 
    L = ['%s=%r' % (key, value)
9474 
      for key, value in self.__dict__.iteritems()]
9475 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9476 
 
9477 
  def __eq__(self, other):
9478 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9479 
 
9480 
  def __ne__(self, other):
9481 
    return not (self == other)
9482 
 
9483 
class createTransaction_result:
9484 
  """
9485 
  Attributes:
132 ashish 9486 
   - success
94 ashish 9487 
   - ex
9488 
  """
9489 
 
9490 
  thrift_spec = (
132 ashish 9491 
    (0, TType.I64, 'success', None, None, ), # 0
94 ashish 9492 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
9493 
  )
9494 
 
132 ashish 9495 
  def __init__(self, success=None, ex=None,):
9496 
    self.success = success
94 ashish 9497 
    self.ex = ex
9498 
 
9499 
  def read(self, iprot):
9500 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9501 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9502 
      return
9503 
    iprot.readStructBegin()
9504 
    while True:
9505 
      (fname, ftype, fid) = iprot.readFieldBegin()
9506 
      if ftype == TType.STOP:
9507 
        break
132 ashish 9508 
      if fid == 0:
9509 
        if ftype == TType.I64:
9510 
          self.success = iprot.readI64();
9511 
        else:
9512 
          iprot.skip(ftype)
9513 
      elif fid == 1:
94 ashish 9514 
        if ftype == TType.STRUCT:
9515 
          self.ex = TransactionServiceException()
9516 
          self.ex.read(iprot)
9517 
        else:
9518 
          iprot.skip(ftype)
9519 
      else:
9520 
        iprot.skip(ftype)
9521 
      iprot.readFieldEnd()
9522 
    iprot.readStructEnd()
9523 
 
9524 
  def write(self, oprot):
9525 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9526 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9527 
      return
9528 
    oprot.writeStructBegin('createTransaction_result')
3431 rajveer 9529 
    if self.success is not None:
132 ashish 9530 
      oprot.writeFieldBegin('success', TType.I64, 0)
9531 
      oprot.writeI64(self.success)
9532 
      oprot.writeFieldEnd()
3431 rajveer 9533 
    if self.ex is not None:
94 ashish 9534 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9535 
      self.ex.write(oprot)
9536 
      oprot.writeFieldEnd()
9537 
    oprot.writeFieldStop()
9538 
    oprot.writeStructEnd()
9539 
 
3431 rajveer 9540 
  def validate(self):
9541 
    return
9542 
 
9543 
 
94 ashish 9544 
  def __repr__(self):
9545 
    L = ['%s=%r' % (key, value)
9546 
      for key, value in self.__dict__.iteritems()]
9547 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9548 
 
9549 
  def __eq__(self, other):
9550 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9551 
 
9552 
  def __ne__(self, other):
9553 
    return not (self == other)
9554 
 
9555 
class getTransaction_args:
9556 
  """
9557 
  Attributes:
9558 
   - id
9559 
  """
9560 
 
9561 
  thrift_spec = (
9562 
    None, # 0
9563 
    (1, TType.I64, 'id', None, None, ), # 1
9564 
  )
9565 
 
9566 
  def __init__(self, id=None,):
9567 
    self.id = id
9568 
 
9569 
  def read(self, iprot):
9570 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9571 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9572 
      return
9573 
    iprot.readStructBegin()
9574 
    while True:
9575 
      (fname, ftype, fid) = iprot.readFieldBegin()
9576 
      if ftype == TType.STOP:
9577 
        break
9578 
      if fid == 1:
9579 
        if ftype == TType.I64:
9580 
          self.id = iprot.readI64();
9581 
        else:
9582 
          iprot.skip(ftype)
9583 
      else:
9584 
        iprot.skip(ftype)
9585 
      iprot.readFieldEnd()
9586 
    iprot.readStructEnd()
9587 
 
9588 
  def write(self, oprot):
9589 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9590 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9591 
      return
9592 
    oprot.writeStructBegin('getTransaction_args')
3431 rajveer 9593 
    if self.id is not None:
94 ashish 9594 
      oprot.writeFieldBegin('id', TType.I64, 1)
9595 
      oprot.writeI64(self.id)
9596 
      oprot.writeFieldEnd()
9597 
    oprot.writeFieldStop()
9598 
    oprot.writeStructEnd()
9599 
 
3431 rajveer 9600 
  def validate(self):
9601 
    return
9602 
 
9603 
 
94 ashish 9604 
  def __repr__(self):
9605 
    L = ['%s=%r' % (key, value)
9606 
      for key, value in self.__dict__.iteritems()]
9607 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9608 
 
9609 
  def __eq__(self, other):
9610 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9611 
 
9612 
  def __ne__(self, other):
9613 
    return not (self == other)
9614 
 
9615 
class getTransaction_result:
9616 
  """
9617 
  Attributes:
9618 
   - success
9619 
   - ex
9620 
  """
9621 
 
9622 
  thrift_spec = (
9623 
    (0, TType.STRUCT, 'success', (Transaction, Transaction.thrift_spec), None, ), # 0
9624 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
9625 
  )
9626 
 
9627 
  def __init__(self, success=None, ex=None,):
9628 
    self.success = success
9629 
    self.ex = ex
9630 
 
9631 
  def read(self, iprot):
9632 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9633 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9634 
      return
9635 
    iprot.readStructBegin()
9636 
    while True:
9637 
      (fname, ftype, fid) = iprot.readFieldBegin()
9638 
      if ftype == TType.STOP:
9639 
        break
9640 
      if fid == 0:
9641 
        if ftype == TType.STRUCT:
9642 
          self.success = Transaction()
9643 
          self.success.read(iprot)
9644 
        else:
9645 
          iprot.skip(ftype)
9646 
      elif fid == 1:
9647 
        if ftype == TType.STRUCT:
9648 
          self.ex = TransactionServiceException()
9649 
          self.ex.read(iprot)
9650 
        else:
9651 
          iprot.skip(ftype)
9652 
      else:
9653 
        iprot.skip(ftype)
9654 
      iprot.readFieldEnd()
9655 
    iprot.readStructEnd()
9656 
 
9657 
  def write(self, oprot):
9658 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9659 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9660 
      return
9661 
    oprot.writeStructBegin('getTransaction_result')
3431 rajveer 9662 
    if self.success is not None:
94 ashish 9663 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
9664 
      self.success.write(oprot)
9665 
      oprot.writeFieldEnd()
3431 rajveer 9666 
    if self.ex is not None:
94 ashish 9667 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9668 
      self.ex.write(oprot)
9669 
      oprot.writeFieldEnd()
9670 
    oprot.writeFieldStop()
9671 
    oprot.writeStructEnd()
9672 
 
3431 rajveer 9673 
  def validate(self):
9674 
    return
9675 
 
9676 
 
94 ashish 9677 
  def __repr__(self):
9678 
    L = ['%s=%r' % (key, value)
9679 
      for key, value in self.__dict__.iteritems()]
9680 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9681 
 
9682 
  def __eq__(self, other):
9683 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9684 
 
9685 
  def __ne__(self, other):
9686 
    return not (self == other)
9687 
 
9688 
class getTransactionsForCustomer_args:
9689 
  """
9690 
  Attributes:
9691 
   - customerId
9692 
   - from_date
9693 
   - to_date
9694 
   - status
9695 
  """
9696 
 
9697 
  thrift_spec = (
9698 
    None, # 0
9699 
    (1, TType.I64, 'customerId', None, None, ), # 1
9700 
    (2, TType.I64, 'from_date', None, None, ), # 2
9701 
    (3, TType.I64, 'to_date', None, None, ), # 3
9702 
    (4, TType.I32, 'status', None, None, ), # 4
9703 
  )
9704 
 
9705 
  def __init__(self, customerId=None, from_date=None, to_date=None, status=None,):
9706 
    self.customerId = customerId
9707 
    self.from_date = from_date
9708 
    self.to_date = to_date
9709 
    self.status = status
9710 
 
9711 
  def read(self, iprot):
9712 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9713 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9714 
      return
9715 
    iprot.readStructBegin()
9716 
    while True:
9717 
      (fname, ftype, fid) = iprot.readFieldBegin()
9718 
      if ftype == TType.STOP:
9719 
        break
9720 
      if fid == 1:
9721 
        if ftype == TType.I64:
9722 
          self.customerId = iprot.readI64();
9723 
        else:
9724 
          iprot.skip(ftype)
9725 
      elif fid == 2:
9726 
        if ftype == TType.I64:
9727 
          self.from_date = iprot.readI64();
9728 
        else:
9729 
          iprot.skip(ftype)
9730 
      elif fid == 3:
9731 
        if ftype == TType.I64:
9732 
          self.to_date = iprot.readI64();
9733 
        else:
9734 
          iprot.skip(ftype)
9735 
      elif fid == 4:
9736 
        if ftype == TType.I32:
9737 
          self.status = iprot.readI32();
9738 
        else:
9739 
          iprot.skip(ftype)
9740 
      else:
9741 
        iprot.skip(ftype)
9742 
      iprot.readFieldEnd()
9743 
    iprot.readStructEnd()
9744 
 
9745 
  def write(self, oprot):
9746 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9747 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9748 
      return
9749 
    oprot.writeStructBegin('getTransactionsForCustomer_args')
3431 rajveer 9750 
    if self.customerId is not None:
94 ashish 9751 
      oprot.writeFieldBegin('customerId', TType.I64, 1)
9752 
      oprot.writeI64(self.customerId)
9753 
      oprot.writeFieldEnd()
3431 rajveer 9754 
    if self.from_date is not None:
94 ashish 9755 
      oprot.writeFieldBegin('from_date', TType.I64, 2)
9756 
      oprot.writeI64(self.from_date)
9757 
      oprot.writeFieldEnd()
3431 rajveer 9758 
    if self.to_date is not None:
94 ashish 9759 
      oprot.writeFieldBegin('to_date', TType.I64, 3)
9760 
      oprot.writeI64(self.to_date)
9761 
      oprot.writeFieldEnd()
3431 rajveer 9762 
    if self.status is not None:
94 ashish 9763 
      oprot.writeFieldBegin('status', TType.I32, 4)
9764 
      oprot.writeI32(self.status)
9765 
      oprot.writeFieldEnd()
9766 
    oprot.writeFieldStop()
9767 
    oprot.writeStructEnd()
9768 
 
3431 rajveer 9769 
  def validate(self):
9770 
    return
9771 
 
9772 
 
94 ashish 9773 
  def __repr__(self):
9774 
    L = ['%s=%r' % (key, value)
9775 
      for key, value in self.__dict__.iteritems()]
9776 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9777 
 
9778 
  def __eq__(self, other):
9779 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9780 
 
9781 
  def __ne__(self, other):
9782 
    return not (self == other)
9783 
 
9784 
class getTransactionsForCustomer_result:
9785 
  """
9786 
  Attributes:
9787 
   - success
9788 
   - ex
9789 
  """
9790 
 
9791 
  thrift_spec = (
9792 
    (0, TType.LIST, 'success', (TType.STRUCT,(Transaction, Transaction.thrift_spec)), None, ), # 0
9793 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
9794 
  )
9795 
 
9796 
  def __init__(self, success=None, ex=None,):
9797 
    self.success = success
9798 
    self.ex = ex
9799 
 
9800 
  def read(self, iprot):
9801 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9802 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9803 
      return
9804 
    iprot.readStructBegin()
9805 
    while True:
9806 
      (fname, ftype, fid) = iprot.readFieldBegin()
9807 
      if ftype == TType.STOP:
9808 
        break
9809 
      if fid == 0:
9810 
        if ftype == TType.LIST:
9811 
          self.success = []
6188 rajveer 9812 
          (_etype109, _size106) = iprot.readListBegin()
9813 
          for _i110 in xrange(_size106):
9814 
            _elem111 = Transaction()
9815 
            _elem111.read(iprot)
9816 
            self.success.append(_elem111)
94 ashish 9817 
          iprot.readListEnd()
9818 
        else:
9819 
          iprot.skip(ftype)
9820 
      elif fid == 1:
9821 
        if ftype == TType.STRUCT:
9822 
          self.ex = TransactionServiceException()
9823 
          self.ex.read(iprot)
9824 
        else:
9825 
          iprot.skip(ftype)
9826 
      else:
9827 
        iprot.skip(ftype)
9828 
      iprot.readFieldEnd()
9829 
    iprot.readStructEnd()
9830 
 
9831 
  def write(self, oprot):
9832 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9833 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9834 
      return
9835 
    oprot.writeStructBegin('getTransactionsForCustomer_result')
3431 rajveer 9836 
    if self.success is not None:
94 ashish 9837 
      oprot.writeFieldBegin('success', TType.LIST, 0)
9838 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 9839 
      for iter112 in self.success:
9840 
        iter112.write(oprot)
94 ashish 9841 
      oprot.writeListEnd()
9842 
      oprot.writeFieldEnd()
3431 rajveer 9843 
    if self.ex is not None:
94 ashish 9844 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9845 
      self.ex.write(oprot)
9846 
      oprot.writeFieldEnd()
9847 
    oprot.writeFieldStop()
9848 
    oprot.writeStructEnd()
9849 
 
3431 rajveer 9850 
  def validate(self):
9851 
    return
9852 
 
9853 
 
94 ashish 9854 
  def __repr__(self):
9855 
    L = ['%s=%r' % (key, value)
9856 
      for key, value in self.__dict__.iteritems()]
9857 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9858 
 
9859 
  def __eq__(self, other):
9860 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9861 
 
9862 
  def __ne__(self, other):
9863 
    return not (self == other)
9864 
 
132 ashish 9865 
class getTransactionsForShoppingCartId_args:
9866 
  """
9867 
  Attributes:
9868 
   - shoppingCartId
9869 
  """
9870 
 
9871 
  thrift_spec = (
9872 
    None, # 0
9873 
    (1, TType.I64, 'shoppingCartId', None, None, ), # 1
9874 
  )
9875 
 
9876 
  def __init__(self, shoppingCartId=None,):
9877 
    self.shoppingCartId = shoppingCartId
9878 
 
9879 
  def read(self, iprot):
9880 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9881 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9882 
      return
9883 
    iprot.readStructBegin()
9884 
    while True:
9885 
      (fname, ftype, fid) = iprot.readFieldBegin()
9886 
      if ftype == TType.STOP:
9887 
        break
9888 
      if fid == 1:
9889 
        if ftype == TType.I64:
9890 
          self.shoppingCartId = iprot.readI64();
9891 
        else:
9892 
          iprot.skip(ftype)
9893 
      else:
9894 
        iprot.skip(ftype)
9895 
      iprot.readFieldEnd()
9896 
    iprot.readStructEnd()
9897 
 
9898 
  def write(self, oprot):
9899 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9900 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9901 
      return
9902 
    oprot.writeStructBegin('getTransactionsForShoppingCartId_args')
3431 rajveer 9903 
    if self.shoppingCartId is not None:
132 ashish 9904 
      oprot.writeFieldBegin('shoppingCartId', TType.I64, 1)
9905 
      oprot.writeI64(self.shoppingCartId)
9906 
      oprot.writeFieldEnd()
9907 
    oprot.writeFieldStop()
9908 
    oprot.writeStructEnd()
9909 
 
3431 rajveer 9910 
  def validate(self):
9911 
    return
9912 
 
9913 
 
132 ashish 9914 
  def __repr__(self):
9915 
    L = ['%s=%r' % (key, value)
9916 
      for key, value in self.__dict__.iteritems()]
9917 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9918 
 
9919 
  def __eq__(self, other):
9920 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9921 
 
9922 
  def __ne__(self, other):
9923 
    return not (self == other)
9924 
 
9925 
class getTransactionsForShoppingCartId_result:
9926 
  """
9927 
  Attributes:
9928 
   - success
9929 
   - ex
9930 
  """
9931 
 
9932 
  thrift_spec = (
9933 
    (0, TType.LIST, 'success', (TType.STRUCT,(Transaction, Transaction.thrift_spec)), None, ), # 0
9934 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
9935 
  )
9936 
 
9937 
  def __init__(self, success=None, ex=None,):
9938 
    self.success = success
9939 
    self.ex = ex
9940 
 
9941 
  def read(self, iprot):
9942 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9943 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9944 
      return
9945 
    iprot.readStructBegin()
9946 
    while True:
9947 
      (fname, ftype, fid) = iprot.readFieldBegin()
9948 
      if ftype == TType.STOP:
9949 
        break
9950 
      if fid == 0:
9951 
        if ftype == TType.LIST:
9952 
          self.success = []
6188 rajveer 9953 
          (_etype116, _size113) = iprot.readListBegin()
9954 
          for _i117 in xrange(_size113):
9955 
            _elem118 = Transaction()
9956 
            _elem118.read(iprot)
9957 
            self.success.append(_elem118)
132 ashish 9958 
          iprot.readListEnd()
9959 
        else:
9960 
          iprot.skip(ftype)
9961 
      elif fid == 1:
9962 
        if ftype == TType.STRUCT:
9963 
          self.ex = TransactionServiceException()
9964 
          self.ex.read(iprot)
9965 
        else:
9966 
          iprot.skip(ftype)
9967 
      else:
9968 
        iprot.skip(ftype)
9969 
      iprot.readFieldEnd()
9970 
    iprot.readStructEnd()
9971 
 
9972 
  def write(self, oprot):
9973 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9974 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9975 
      return
9976 
    oprot.writeStructBegin('getTransactionsForShoppingCartId_result')
3431 rajveer 9977 
    if self.success is not None:
132 ashish 9978 
      oprot.writeFieldBegin('success', TType.LIST, 0)
9979 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 9980 
      for iter119 in self.success:
9981 
        iter119.write(oprot)
132 ashish 9982 
      oprot.writeListEnd()
9983 
      oprot.writeFieldEnd()
3431 rajveer 9984 
    if self.ex is not None:
132 ashish 9985 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9986 
      self.ex.write(oprot)
9987 
      oprot.writeFieldEnd()
9988 
    oprot.writeFieldStop()
9989 
    oprot.writeStructEnd()
9990 
 
3431 rajveer 9991 
  def validate(self):
9992 
    return
9993 
 
9994 
 
132 ashish 9995 
  def __repr__(self):
9996 
    L = ['%s=%r' % (key, value)
9997 
      for key, value in self.__dict__.iteritems()]
9998 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9999 
 
10000 
  def __eq__(self, other):
10001 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10002 
 
10003 
  def __ne__(self, other):
10004 
    return not (self == other)
10005 
 
94 ashish 10006 
class getTransactionStatus_args:
10007 
  """
10008 
  Attributes:
10009 
   - transactionId
10010 
  """
10011 
 
10012 
  thrift_spec = (
10013 
    None, # 0
10014 
    (1, TType.I64, 'transactionId', None, None, ), # 1
10015 
  )
10016 
 
10017 
  def __init__(self, transactionId=None,):
10018 
    self.transactionId = transactionId
10019 
 
10020 
  def read(self, iprot):
10021 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10022 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10023 
      return
10024 
    iprot.readStructBegin()
10025 
    while True:
10026 
      (fname, ftype, fid) = iprot.readFieldBegin()
10027 
      if ftype == TType.STOP:
10028 
        break
10029 
      if fid == 1:
10030 
        if ftype == TType.I64:
10031 
          self.transactionId = iprot.readI64();
10032 
        else:
10033 
          iprot.skip(ftype)
10034 
      else:
10035 
        iprot.skip(ftype)
10036 
      iprot.readFieldEnd()
10037 
    iprot.readStructEnd()
10038 
 
10039 
  def write(self, oprot):
10040 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10041 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10042 
      return
10043 
    oprot.writeStructBegin('getTransactionStatus_args')
3431 rajveer 10044 
    if self.transactionId is not None:
94 ashish 10045 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
10046 
      oprot.writeI64(self.transactionId)
10047 
      oprot.writeFieldEnd()
10048 
    oprot.writeFieldStop()
10049 
    oprot.writeStructEnd()
10050 
 
3431 rajveer 10051 
  def validate(self):
10052 
    return
10053 
 
10054 
 
94 ashish 10055 
  def __repr__(self):
10056 
    L = ['%s=%r' % (key, value)
10057 
      for key, value in self.__dict__.iteritems()]
10058 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10059 
 
10060 
  def __eq__(self, other):
10061 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10062 
 
10063 
  def __ne__(self, other):
10064 
    return not (self == other)
10065 
 
10066 
class getTransactionStatus_result:
10067 
  """
10068 
  Attributes:
10069 
   - success
10070 
   - ex
10071 
  """
10072 
 
10073 
  thrift_spec = (
10074 
    (0, TType.I32, 'success', None, None, ), # 0
10075 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
10076 
  )
10077 
 
10078 
  def __init__(self, success=None, ex=None,):
10079 
    self.success = success
10080 
    self.ex = ex
10081 
 
10082 
  def read(self, iprot):
10083 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10084 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10085 
      return
10086 
    iprot.readStructBegin()
10087 
    while True:
10088 
      (fname, ftype, fid) = iprot.readFieldBegin()
10089 
      if ftype == TType.STOP:
10090 
        break
10091 
      if fid == 0:
10092 
        if ftype == TType.I32:
10093 
          self.success = iprot.readI32();
10094 
        else:
10095 
          iprot.skip(ftype)
10096 
      elif fid == 1:
10097 
        if ftype == TType.STRUCT:
10098 
          self.ex = TransactionServiceException()
10099 
          self.ex.read(iprot)
10100 
        else:
10101 
          iprot.skip(ftype)
10102 
      else:
10103 
        iprot.skip(ftype)
10104 
      iprot.readFieldEnd()
10105 
    iprot.readStructEnd()
10106 
 
10107 
  def write(self, oprot):
10108 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10109 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10110 
      return
10111 
    oprot.writeStructBegin('getTransactionStatus_result')
3431 rajveer 10112 
    if self.success is not None:
94 ashish 10113 
      oprot.writeFieldBegin('success', TType.I32, 0)
10114 
      oprot.writeI32(self.success)
10115 
      oprot.writeFieldEnd()
3431 rajveer 10116 
    if self.ex is not None:
94 ashish 10117 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10118 
      self.ex.write(oprot)
10119 
      oprot.writeFieldEnd()
10120 
    oprot.writeFieldStop()
10121 
    oprot.writeStructEnd()
10122 
 
3431 rajveer 10123 
  def validate(self):
10124 
    return
10125 
 
10126 
 
94 ashish 10127 
  def __repr__(self):
10128 
    L = ['%s=%r' % (key, value)
10129 
      for key, value in self.__dict__.iteritems()]
10130 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10131 
 
10132 
  def __eq__(self, other):
10133 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10134 
 
10135 
  def __ne__(self, other):
10136 
    return not (self == other)
10137 
 
10138 
class changeTransactionStatus_args:
10139 
  """
10140 
  Attributes:
10141 
   - transactionId
10142 
   - status
10143 
   - description
5527 anupam.sin 10144 
   - pickUp
10145 
   - orderType
94 ashish 10146 
  """
10147 
 
10148 
  thrift_spec = (
10149 
    None, # 0
10150 
    (1, TType.I64, 'transactionId', None, None, ), # 1
10151 
    (2, TType.I32, 'status', None, None, ), # 2
10152 
    (3, TType.STRING, 'description', None, None, ), # 3
5527 anupam.sin 10153 
    (4, TType.I64, 'pickUp', None, None, ), # 4
10154 
    (5, TType.I32, 'orderType', None, None, ), # 5
94 ashish 10155 
  )
10156 
 
5527 anupam.sin 10157 
  def __init__(self, transactionId=None, status=None, description=None, pickUp=None, orderType=None,):
94 ashish 10158 
    self.transactionId = transactionId
10159 
    self.status = status
10160 
    self.description = description
5527 anupam.sin 10161 
    self.pickUp = pickUp
10162 
    self.orderType = orderType
94 ashish 10163 
 
10164 
  def read(self, iprot):
10165 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10166 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10167 
      return
10168 
    iprot.readStructBegin()
10169 
    while True:
10170 
      (fname, ftype, fid) = iprot.readFieldBegin()
10171 
      if ftype == TType.STOP:
10172 
        break
10173 
      if fid == 1:
10174 
        if ftype == TType.I64:
10175 
          self.transactionId = iprot.readI64();
10176 
        else:
10177 
          iprot.skip(ftype)
10178 
      elif fid == 2:
10179 
        if ftype == TType.I32:
10180 
          self.status = iprot.readI32();
10181 
        else:
10182 
          iprot.skip(ftype)
10183 
      elif fid == 3:
10184 
        if ftype == TType.STRING:
10185 
          self.description = iprot.readString();
10186 
        else:
10187 
          iprot.skip(ftype)
5387 rajveer 10188 
      elif fid == 4:
5527 anupam.sin 10189 
        if ftype == TType.I64:
10190 
          self.pickUp = iprot.readI64();
5387 rajveer 10191 
        else:
10192 
          iprot.skip(ftype)
5527 anupam.sin 10193 
      elif fid == 5:
10194 
        if ftype == TType.I32:
10195 
          self.orderType = iprot.readI32();
10196 
        else:
10197 
          iprot.skip(ftype)
94 ashish 10198 
      else:
10199 
        iprot.skip(ftype)
10200 
      iprot.readFieldEnd()
10201 
    iprot.readStructEnd()
10202 
 
10203 
  def write(self, oprot):
10204 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10205 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10206 
      return
10207 
    oprot.writeStructBegin('changeTransactionStatus_args')
3431 rajveer 10208 
    if self.transactionId is not None:
94 ashish 10209 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
10210 
      oprot.writeI64(self.transactionId)
10211 
      oprot.writeFieldEnd()
3431 rajveer 10212 
    if self.status is not None:
94 ashish 10213 
      oprot.writeFieldBegin('status', TType.I32, 2)
10214 
      oprot.writeI32(self.status)
10215 
      oprot.writeFieldEnd()
3431 rajveer 10216 
    if self.description is not None:
94 ashish 10217 
      oprot.writeFieldBegin('description', TType.STRING, 3)
10218 
      oprot.writeString(self.description)
10219 
      oprot.writeFieldEnd()
5527 anupam.sin 10220 
    if self.pickUp is not None:
10221 
      oprot.writeFieldBegin('pickUp', TType.I64, 4)
10222 
      oprot.writeI64(self.pickUp)
5387 rajveer 10223 
      oprot.writeFieldEnd()
5527 anupam.sin 10224 
    if self.orderType is not None:
10225 
      oprot.writeFieldBegin('orderType', TType.I32, 5)
10226 
      oprot.writeI32(self.orderType)
10227 
      oprot.writeFieldEnd()
94 ashish 10228 
    oprot.writeFieldStop()
10229 
    oprot.writeStructEnd()
10230 
 
3431 rajveer 10231 
  def validate(self):
10232 
    return
10233 
 
10234 
 
94 ashish 10235 
  def __repr__(self):
10236 
    L = ['%s=%r' % (key, value)
10237 
      for key, value in self.__dict__.iteritems()]
10238 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10239 
 
10240 
  def __eq__(self, other):
10241 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10242 
 
10243 
  def __ne__(self, other):
10244 
    return not (self == other)
10245 
 
10246 
class changeTransactionStatus_result:
10247 
  """
10248 
  Attributes:
10249 
   - success
10250 
   - ex
10251 
  """
10252 
 
10253 
  thrift_spec = (
10254 
    (0, TType.BOOL, 'success', None, None, ), # 0
10255 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
10256 
  )
10257 
 
10258 
  def __init__(self, success=None, ex=None,):
10259 
    self.success = success
10260 
    self.ex = ex
10261 
 
10262 
  def read(self, iprot):
10263 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10264 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10265 
      return
10266 
    iprot.readStructBegin()
10267 
    while True:
10268 
      (fname, ftype, fid) = iprot.readFieldBegin()
10269 
      if ftype == TType.STOP:
10270 
        break
10271 
      if fid == 0:
10272 
        if ftype == TType.BOOL:
10273 
          self.success = iprot.readBool();
10274 
        else:
10275 
          iprot.skip(ftype)
10276 
      elif fid == 1:
10277 
        if ftype == TType.STRUCT:
10278 
          self.ex = TransactionServiceException()
10279 
          self.ex.read(iprot)
10280 
        else:
10281 
          iprot.skip(ftype)
10282 
      else:
10283 
        iprot.skip(ftype)
10284 
      iprot.readFieldEnd()
10285 
    iprot.readStructEnd()
10286 
 
10287 
  def write(self, oprot):
10288 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10289 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10290 
      return
10291 
    oprot.writeStructBegin('changeTransactionStatus_result')
3431 rajveer 10292 
    if self.success is not None:
94 ashish 10293 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
10294 
      oprot.writeBool(self.success)
10295 
      oprot.writeFieldEnd()
3431 rajveer 10296 
    if self.ex is not None:
94 ashish 10297 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10298 
      self.ex.write(oprot)
10299 
      oprot.writeFieldEnd()
10300 
    oprot.writeFieldStop()
10301 
    oprot.writeStructEnd()
10302 
 
3431 rajveer 10303 
  def validate(self):
10304 
    return
10305 
 
10306 
 
94 ashish 10307 
  def __repr__(self):
10308 
    L = ['%s=%r' % (key, value)
10309 
      for key, value in self.__dict__.iteritems()]
10310 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10311 
 
10312 
  def __eq__(self, other):
10313 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10314 
 
10315 
  def __ne__(self, other):
10316 
    return not (self == other)
10317 
 
1398 varun.gupt 10318 
class enqueueTransactionInfoEmail_args:
1382 varun.gupt 10319 
  """
10320 
  Attributes:
10321 
   - transactionId
10322 
  """
10323 
 
10324 
  thrift_spec = (
10325 
    None, # 0
10326 
    (1, TType.I64, 'transactionId', None, None, ), # 1
10327 
  )
10328 
 
10329 
  def __init__(self, transactionId=None,):
10330 
    self.transactionId = transactionId
10331 
 
10332 
  def read(self, iprot):
10333 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10334 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10335 
      return
10336 
    iprot.readStructBegin()
10337 
    while True:
10338 
      (fname, ftype, fid) = iprot.readFieldBegin()
10339 
      if ftype == TType.STOP:
10340 
        break
10341 
      if fid == 1:
10342 
        if ftype == TType.I64:
10343 
          self.transactionId = iprot.readI64();
10344 
        else:
10345 
          iprot.skip(ftype)
10346 
      else:
10347 
        iprot.skip(ftype)
10348 
      iprot.readFieldEnd()
10349 
    iprot.readStructEnd()
10350 
 
10351 
  def write(self, oprot):
10352 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10353 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10354 
      return
1398 varun.gupt 10355 
    oprot.writeStructBegin('enqueueTransactionInfoEmail_args')
3431 rajveer 10356 
    if self.transactionId is not None:
1382 varun.gupt 10357 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
10358 
      oprot.writeI64(self.transactionId)
10359 
      oprot.writeFieldEnd()
10360 
    oprot.writeFieldStop()
10361 
    oprot.writeStructEnd()
10362 
 
3431 rajveer 10363 
  def validate(self):
10364 
    return
10365 
 
10366 
 
1382 varun.gupt 10367 
  def __repr__(self):
10368 
    L = ['%s=%r' % (key, value)
10369 
      for key, value in self.__dict__.iteritems()]
10370 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10371 
 
10372 
  def __eq__(self, other):
10373 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10374 
 
10375 
  def __ne__(self, other):
10376 
    return not (self == other)
10377 
 
1398 varun.gupt 10378 
class enqueueTransactionInfoEmail_result:
1382 varun.gupt 10379 
  """
10380 
  Attributes:
10381 
   - success
10382 
   - ex
10383 
  """
10384 
 
10385 
  thrift_spec = (
10386 
    (0, TType.BOOL, 'success', None, None, ), # 0
10387 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
10388 
  )
10389 
 
10390 
  def __init__(self, success=None, ex=None,):
10391 
    self.success = success
10392 
    self.ex = ex
10393 
 
10394 
  def read(self, iprot):
10395 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10396 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10397 
      return
10398 
    iprot.readStructBegin()
10399 
    while True:
10400 
      (fname, ftype, fid) = iprot.readFieldBegin()
10401 
      if ftype == TType.STOP:
10402 
        break
10403 
      if fid == 0:
10404 
        if ftype == TType.BOOL:
10405 
          self.success = iprot.readBool();
10406 
        else:
10407 
          iprot.skip(ftype)
10408 
      elif fid == 1:
10409 
        if ftype == TType.STRUCT:
10410 
          self.ex = TransactionServiceException()
10411 
          self.ex.read(iprot)
10412 
        else:
10413 
          iprot.skip(ftype)
10414 
      else:
10415 
        iprot.skip(ftype)
10416 
      iprot.readFieldEnd()
10417 
    iprot.readStructEnd()
10418 
 
10419 
  def write(self, oprot):
10420 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10421 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10422 
      return
1398 varun.gupt 10423 
    oprot.writeStructBegin('enqueueTransactionInfoEmail_result')
3431 rajveer 10424 
    if self.success is not None:
1382 varun.gupt 10425 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
10426 
      oprot.writeBool(self.success)
10427 
      oprot.writeFieldEnd()
3431 rajveer 10428 
    if self.ex is not None:
1382 varun.gupt 10429 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10430 
      self.ex.write(oprot)
10431 
      oprot.writeFieldEnd()
10432 
    oprot.writeFieldStop()
10433 
    oprot.writeStructEnd()
10434 
 
3431 rajveer 10435 
  def validate(self):
10436 
    return
10437 
 
10438 
 
1382 varun.gupt 10439 
  def __repr__(self):
10440 
    L = ['%s=%r' % (key, value)
10441 
      for key, value in self.__dict__.iteritems()]
10442 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10443 
 
10444 
  def __eq__(self, other):
10445 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10446 
 
10447 
  def __ne__(self, other):
10448 
    return not (self == other)
10449 
 
483 rajveer 10450 
class getAllOrders_args:
94 ashish 10451 
  """
10452 
  Attributes:
4801 anupam.sin 10453 
   - statuses
483 rajveer 10454 
   - from_date
10455 
   - to_date
10456 
   - warehouse_id
94 ashish 10457 
  """
10458 
 
10459 
  thrift_spec = (
10460 
    None, # 0
4801 anupam.sin 10461 
    (1, TType.LIST, 'statuses', (TType.I32,None), None, ), # 1
483 rajveer 10462 
    (2, TType.I64, 'from_date', None, None, ), # 2
10463 
    (3, TType.I64, 'to_date', None, None, ), # 3
10464 
    (4, TType.I64, 'warehouse_id', None, None, ), # 4
94 ashish 10465 
  )
10466 
 
4801 anupam.sin 10467 
  def __init__(self, statuses=None, from_date=None, to_date=None, warehouse_id=None,):
10468 
    self.statuses = statuses
483 rajveer 10469 
    self.from_date = from_date
10470 
    self.to_date = to_date
10471 
    self.warehouse_id = warehouse_id
94 ashish 10472 
 
10473 
  def read(self, iprot):
10474 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10475 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10476 
      return
10477 
    iprot.readStructBegin()
10478 
    while True:
10479 
      (fname, ftype, fid) = iprot.readFieldBegin()
10480 
      if ftype == TType.STOP:
10481 
        break
10482 
      if fid == 1:
4801 anupam.sin 10483 
        if ftype == TType.LIST:
10484 
          self.statuses = []
6188 rajveer 10485 
          (_etype123, _size120) = iprot.readListBegin()
10486 
          for _i124 in xrange(_size120):
10487 
            _elem125 = iprot.readI32();
10488 
            self.statuses.append(_elem125)
4801 anupam.sin 10489 
          iprot.readListEnd()
94 ashish 10490 
        else:
10491 
          iprot.skip(ftype)
483 rajveer 10492 
      elif fid == 2:
10493 
        if ftype == TType.I64:
10494 
          self.from_date = iprot.readI64();
94 ashish 10495 
        else:
10496 
          iprot.skip(ftype)
483 rajveer 10497 
      elif fid == 3:
10498 
        if ftype == TType.I64:
10499 
          self.to_date = iprot.readI64();
94 ashish 10500 
        else:
10501 
          iprot.skip(ftype)
483 rajveer 10502 
      elif fid == 4:
94 ashish 10503 
        if ftype == TType.I64:
483 rajveer 10504 
          self.warehouse_id = iprot.readI64();
94 ashish 10505 
        else:
10506 
          iprot.skip(ftype)
10507 
      else:
10508 
        iprot.skip(ftype)
10509 
      iprot.readFieldEnd()
10510 
    iprot.readStructEnd()
10511 
 
10512 
  def write(self, oprot):
10513 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10514 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10515 
      return
483 rajveer 10516 
    oprot.writeStructBegin('getAllOrders_args')
4801 anupam.sin 10517 
    if self.statuses is not None:
10518 
      oprot.writeFieldBegin('statuses', TType.LIST, 1)
10519 
      oprot.writeListBegin(TType.I32, len(self.statuses))
6188 rajveer 10520 
      for iter126 in self.statuses:
10521 
        oprot.writeI32(iter126)
4801 anupam.sin 10522 
      oprot.writeListEnd()
94 ashish 10523 
      oprot.writeFieldEnd()
3431 rajveer 10524 
    if self.from_date is not None:
483 rajveer 10525 
      oprot.writeFieldBegin('from_date', TType.I64, 2)
10526 
      oprot.writeI64(self.from_date)
94 ashish 10527 
      oprot.writeFieldEnd()
3431 rajveer 10528 
    if self.to_date is not None:
483 rajveer 10529 
      oprot.writeFieldBegin('to_date', TType.I64, 3)
10530 
      oprot.writeI64(self.to_date)
94 ashish 10531 
      oprot.writeFieldEnd()
3431 rajveer 10532 
    if self.warehouse_id is not None:
483 rajveer 10533 
      oprot.writeFieldBegin('warehouse_id', TType.I64, 4)
10534 
      oprot.writeI64(self.warehouse_id)
94 ashish 10535 
      oprot.writeFieldEnd()
10536 
    oprot.writeFieldStop()
10537 
    oprot.writeStructEnd()
10538 
 
3431 rajveer 10539 
  def validate(self):
10540 
    return
10541 
 
10542 
 
94 ashish 10543 
  def __repr__(self):
10544 
    L = ['%s=%r' % (key, value)
10545 
      for key, value in self.__dict__.iteritems()]
10546 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10547 
 
10548 
  def __eq__(self, other):
10549 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10550 
 
10551 
  def __ne__(self, other):
10552 
    return not (self == other)
10553 
 
483 rajveer 10554 
class getAllOrders_result:
94 ashish 10555 
  """
10556 
  Attributes:
10557 
   - success
10558 
   - ex
10559 
  """
10560 
 
10561 
  thrift_spec = (
483 rajveer 10562 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
94 ashish 10563 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
10564 
  )
10565 
 
10566 
  def __init__(self, success=None, ex=None,):
10567 
    self.success = success
10568 
    self.ex = ex
10569 
 
10570 
  def read(self, iprot):
10571 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10572 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10573 
      return
10574 
    iprot.readStructBegin()
10575 
    while True:
10576 
      (fname, ftype, fid) = iprot.readFieldBegin()
10577 
      if ftype == TType.STOP:
10578 
        break
10579 
      if fid == 0:
483 rajveer 10580 
        if ftype == TType.LIST:
10581 
          self.success = []
6188 rajveer 10582 
          (_etype130, _size127) = iprot.readListBegin()
10583 
          for _i131 in xrange(_size127):
10584 
            _elem132 = Order()
10585 
            _elem132.read(iprot)
10586 
            self.success.append(_elem132)
483 rajveer 10587 
          iprot.readListEnd()
94 ashish 10588 
        else:
10589 
          iprot.skip(ftype)
10590 
      elif fid == 1:
10591 
        if ftype == TType.STRUCT:
10592 
          self.ex = TransactionServiceException()
10593 
          self.ex.read(iprot)
10594 
        else:
10595 
          iprot.skip(ftype)
10596 
      else:
10597 
        iprot.skip(ftype)
10598 
      iprot.readFieldEnd()
10599 
    iprot.readStructEnd()
10600 
 
10601 
  def write(self, oprot):
10602 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10603 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10604 
      return
483 rajveer 10605 
    oprot.writeStructBegin('getAllOrders_result')
3431 rajveer 10606 
    if self.success is not None:
483 rajveer 10607 
      oprot.writeFieldBegin('success', TType.LIST, 0)
10608 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 10609 
      for iter133 in self.success:
10610 
        iter133.write(oprot)
483 rajveer 10611 
      oprot.writeListEnd()
94 ashish 10612 
      oprot.writeFieldEnd()
3431 rajveer 10613 
    if self.ex is not None:
94 ashish 10614 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10615 
      self.ex.write(oprot)
10616 
      oprot.writeFieldEnd()
10617 
    oprot.writeFieldStop()
10618 
    oprot.writeStructEnd()
10619 
 
3431 rajveer 10620 
  def validate(self):
10621 
    return
10622 
 
10623 
 
94 ashish 10624 
  def __repr__(self):
10625 
    L = ['%s=%r' % (key, value)
10626 
      for key, value in self.__dict__.iteritems()]
10627 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10628 
 
10629 
  def __eq__(self, other):
10630 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10631 
 
10632 
  def __ne__(self, other):
10633 
    return not (self == other)
10634 
 
4133 chandransh 10635 
class getOrdersInBatch_args:
10636 
  """
10637 
  Attributes:
10638 
   - statuses
10639 
   - offset
10640 
   - limit
10641 
   - warehouse_id
10642 
  """
10643 
 
10644 
  thrift_spec = (
10645 
    None, # 0
10646 
    (1, TType.LIST, 'statuses', (TType.I32,None), None, ), # 1
10647 
    (2, TType.I64, 'offset', None, None, ), # 2
10648 
    (3, TType.I64, 'limit', None, None, ), # 3
10649 
    (4, TType.I64, 'warehouse_id', None, None, ), # 4
10650 
  )
10651 
 
10652 
  def __init__(self, statuses=None, offset=None, limit=None, warehouse_id=None,):
10653 
    self.statuses = statuses
10654 
    self.offset = offset
10655 
    self.limit = limit
10656 
    self.warehouse_id = warehouse_id
10657 
 
10658 
  def read(self, iprot):
10659 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10660 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10661 
      return
10662 
    iprot.readStructBegin()
10663 
    while True:
10664 
      (fname, ftype, fid) = iprot.readFieldBegin()
10665 
      if ftype == TType.STOP:
10666 
        break
10667 
      if fid == 1:
10668 
        if ftype == TType.LIST:
10669 
          self.statuses = []
6188 rajveer 10670 
          (_etype137, _size134) = iprot.readListBegin()
10671 
          for _i138 in xrange(_size134):
10672 
            _elem139 = iprot.readI32();
10673 
            self.statuses.append(_elem139)
4133 chandransh 10674 
          iprot.readListEnd()
10675 
        else:
10676 
          iprot.skip(ftype)
10677 
      elif fid == 2:
10678 
        if ftype == TType.I64:
10679 
          self.offset = iprot.readI64();
10680 
        else:
10681 
          iprot.skip(ftype)
10682 
      elif fid == 3:
10683 
        if ftype == TType.I64:
10684 
          self.limit = iprot.readI64();
10685 
        else:
10686 
          iprot.skip(ftype)
10687 
      elif fid == 4:
10688 
        if ftype == TType.I64:
10689 
          self.warehouse_id = iprot.readI64();
10690 
        else:
10691 
          iprot.skip(ftype)
10692 
      else:
10693 
        iprot.skip(ftype)
10694 
      iprot.readFieldEnd()
10695 
    iprot.readStructEnd()
10696 
 
10697 
  def write(self, oprot):
10698 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10699 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10700 
      return
10701 
    oprot.writeStructBegin('getOrdersInBatch_args')
10702 
    if self.statuses is not None:
10703 
      oprot.writeFieldBegin('statuses', TType.LIST, 1)
10704 
      oprot.writeListBegin(TType.I32, len(self.statuses))
6188 rajveer 10705 
      for iter140 in self.statuses:
10706 
        oprot.writeI32(iter140)
4133 chandransh 10707 
      oprot.writeListEnd()
10708 
      oprot.writeFieldEnd()
10709 
    if self.offset is not None:
10710 
      oprot.writeFieldBegin('offset', TType.I64, 2)
10711 
      oprot.writeI64(self.offset)
10712 
      oprot.writeFieldEnd()
10713 
    if self.limit is not None:
10714 
      oprot.writeFieldBegin('limit', TType.I64, 3)
10715 
      oprot.writeI64(self.limit)
10716 
      oprot.writeFieldEnd()
10717 
    if self.warehouse_id is not None:
10718 
      oprot.writeFieldBegin('warehouse_id', TType.I64, 4)
10719 
      oprot.writeI64(self.warehouse_id)
10720 
      oprot.writeFieldEnd()
10721 
    oprot.writeFieldStop()
10722 
    oprot.writeStructEnd()
10723 
 
10724 
  def validate(self):
10725 
    return
10726 
 
10727 
 
10728 
  def __repr__(self):
10729 
    L = ['%s=%r' % (key, value)
10730 
      for key, value in self.__dict__.iteritems()]
10731 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10732 
 
10733 
  def __eq__(self, other):
10734 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10735 
 
10736 
  def __ne__(self, other):
10737 
    return not (self == other)
10738 
 
10739 
class getOrdersInBatch_result:
10740 
  """
10741 
  Attributes:
10742 
   - success
10743 
   - ex
10744 
  """
10745 
 
10746 
  thrift_spec = (
10747 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
10748 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
10749 
  )
10750 
 
10751 
  def __init__(self, success=None, ex=None,):
10752 
    self.success = success
10753 
    self.ex = ex
10754 
 
10755 
  def read(self, iprot):
10756 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10757 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10758 
      return
10759 
    iprot.readStructBegin()
10760 
    while True:
10761 
      (fname, ftype, fid) = iprot.readFieldBegin()
10762 
      if ftype == TType.STOP:
10763 
        break
10764 
      if fid == 0:
10765 
        if ftype == TType.LIST:
10766 
          self.success = []
6188 rajveer 10767 
          (_etype144, _size141) = iprot.readListBegin()
10768 
          for _i145 in xrange(_size141):
10769 
            _elem146 = Order()
10770 
            _elem146.read(iprot)
10771 
            self.success.append(_elem146)
4133 chandransh 10772 
          iprot.readListEnd()
10773 
        else:
10774 
          iprot.skip(ftype)
10775 
      elif fid == 1:
10776 
        if ftype == TType.STRUCT:
10777 
          self.ex = TransactionServiceException()
10778 
          self.ex.read(iprot)
10779 
        else:
10780 
          iprot.skip(ftype)
10781 
      else:
10782 
        iprot.skip(ftype)
10783 
      iprot.readFieldEnd()
10784 
    iprot.readStructEnd()
10785 
 
10786 
  def write(self, oprot):
10787 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10788 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10789 
      return
10790 
    oprot.writeStructBegin('getOrdersInBatch_result')
10791 
    if self.success is not None:
10792 
      oprot.writeFieldBegin('success', TType.LIST, 0)
10793 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 10794 
      for iter147 in self.success:
10795 
        iter147.write(oprot)
4133 chandransh 10796 
      oprot.writeListEnd()
10797 
      oprot.writeFieldEnd()
10798 
    if self.ex is not None:
10799 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10800 
      self.ex.write(oprot)
10801 
      oprot.writeFieldEnd()
10802 
    oprot.writeFieldStop()
10803 
    oprot.writeStructEnd()
10804 
 
10805 
  def validate(self):
10806 
    return
10807 
 
10808 
 
10809 
  def __repr__(self):
10810 
    L = ['%s=%r' % (key, value)
10811 
      for key, value in self.__dict__.iteritems()]
10812 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10813 
 
10814 
  def __eq__(self, other):
10815 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10816 
 
10817 
  def __ne__(self, other):
10818 
    return not (self == other)
10819 
 
10820 
class getOrderCount_args:
10821 
  """
10822 
  Attributes:
10823 
   - statuses
10824 
   - warehouseId
10825 
  """
10826 
 
10827 
  thrift_spec = (
10828 
    None, # 0
10829 
    (1, TType.LIST, 'statuses', (TType.I32,None), None, ), # 1
10830 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
10831 
  )
10832 
 
10833 
  def __init__(self, statuses=None, warehouseId=None,):
10834 
    self.statuses = statuses
10835 
    self.warehouseId = warehouseId
10836 
 
10837 
  def read(self, iprot):
10838 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10839 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10840 
      return
10841 
    iprot.readStructBegin()
10842 
    while True:
10843 
      (fname, ftype, fid) = iprot.readFieldBegin()
10844 
      if ftype == TType.STOP:
10845 
        break
10846 
      if fid == 1:
10847 
        if ftype == TType.LIST:
10848 
          self.statuses = []
6188 rajveer 10849 
          (_etype151, _size148) = iprot.readListBegin()
10850 
          for _i152 in xrange(_size148):
10851 
            _elem153 = iprot.readI32();
10852 
            self.statuses.append(_elem153)
4133 chandransh 10853 
          iprot.readListEnd()
10854 
        else:
10855 
          iprot.skip(ftype)
10856 
      elif fid == 2:
10857 
        if ftype == TType.I64:
10858 
          self.warehouseId = iprot.readI64();
10859 
        else:
10860 
          iprot.skip(ftype)
10861 
      else:
10862 
        iprot.skip(ftype)
10863 
      iprot.readFieldEnd()
10864 
    iprot.readStructEnd()
10865 
 
10866 
  def write(self, oprot):
10867 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10868 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10869 
      return
10870 
    oprot.writeStructBegin('getOrderCount_args')
10871 
    if self.statuses is not None:
10872 
      oprot.writeFieldBegin('statuses', TType.LIST, 1)
10873 
      oprot.writeListBegin(TType.I32, len(self.statuses))
6188 rajveer 10874 
      for iter154 in self.statuses:
10875 
        oprot.writeI32(iter154)
4133 chandransh 10876 
      oprot.writeListEnd()
10877 
      oprot.writeFieldEnd()
10878 
    if self.warehouseId is not None:
10879 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
10880 
      oprot.writeI64(self.warehouseId)
10881 
      oprot.writeFieldEnd()
10882 
    oprot.writeFieldStop()
10883 
    oprot.writeStructEnd()
10884 
 
10885 
  def validate(self):
10886 
    return
10887 
 
10888 
 
10889 
  def __repr__(self):
10890 
    L = ['%s=%r' % (key, value)
10891 
      for key, value in self.__dict__.iteritems()]
10892 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10893 
 
10894 
  def __eq__(self, other):
10895 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10896 
 
10897 
  def __ne__(self, other):
10898 
    return not (self == other)
10899 
 
10900 
class getOrderCount_result:
10901 
  """
10902 
  Attributes:
10903 
   - success
10904 
   - ex
10905 
  """
10906 
 
10907 
  thrift_spec = (
10908 
    (0, TType.I32, 'success', None, None, ), # 0
10909 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
10910 
  )
10911 
 
10912 
  def __init__(self, success=None, ex=None,):
10913 
    self.success = success
10914 
    self.ex = ex
10915 
 
10916 
  def read(self, iprot):
10917 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10918 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10919 
      return
10920 
    iprot.readStructBegin()
10921 
    while True:
10922 
      (fname, ftype, fid) = iprot.readFieldBegin()
10923 
      if ftype == TType.STOP:
10924 
        break
10925 
      if fid == 0:
10926 
        if ftype == TType.I32:
10927 
          self.success = iprot.readI32();
10928 
        else:
10929 
          iprot.skip(ftype)
10930 
      elif fid == 1:
10931 
        if ftype == TType.STRUCT:
10932 
          self.ex = TransactionServiceException()
10933 
          self.ex.read(iprot)
10934 
        else:
10935 
          iprot.skip(ftype)
10936 
      else:
10937 
        iprot.skip(ftype)
10938 
      iprot.readFieldEnd()
10939 
    iprot.readStructEnd()
10940 
 
10941 
  def write(self, oprot):
10942 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10943 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10944 
      return
10945 
    oprot.writeStructBegin('getOrderCount_result')
10946 
    if self.success is not None:
10947 
      oprot.writeFieldBegin('success', TType.I32, 0)
10948 
      oprot.writeI32(self.success)
10949 
      oprot.writeFieldEnd()
10950 
    if self.ex is not None:
10951 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10952 
      self.ex.write(oprot)
10953 
      oprot.writeFieldEnd()
10954 
    oprot.writeFieldStop()
10955 
    oprot.writeStructEnd()
10956 
 
10957 
  def validate(self):
10958 
    return
10959 
 
10960 
 
10961 
  def __repr__(self):
10962 
    L = ['%s=%r' % (key, value)
10963 
      for key, value in self.__dict__.iteritems()]
10964 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10965 
 
10966 
  def __eq__(self, other):
10967 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10968 
 
10969 
  def __ne__(self, other):
10970 
    return not (self == other)
10971 
 
999 varun.gupt 10972 
class getOrdersByBillingDate_args:
10973 
  """
10974 
  Attributes:
10975 
   - status
10976 
   - start_billing_date
10977 
   - end_billing_date
10978 
   - warehouse_id
10979 
  """
10980 
 
10981 
  thrift_spec = (
10982 
    None, # 0
10983 
    (1, TType.I32, 'status', None, None, ), # 1
10984 
    (2, TType.I64, 'start_billing_date', None, None, ), # 2
10985 
    (3, TType.I64, 'end_billing_date', None, None, ), # 3
10986 
    (4, TType.I64, 'warehouse_id', None, None, ), # 4
10987 
  )
10988 
 
10989 
  def __init__(self, status=None, start_billing_date=None, end_billing_date=None, warehouse_id=None,):
10990 
    self.status = status
10991 
    self.start_billing_date = start_billing_date
10992 
    self.end_billing_date = end_billing_date
10993 
    self.warehouse_id = warehouse_id
10994 
 
10995 
  def read(self, iprot):
10996 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10997 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10998 
      return
10999 
    iprot.readStructBegin()
11000 
    while True:
11001 
      (fname, ftype, fid) = iprot.readFieldBegin()
11002 
      if ftype == TType.STOP:
11003 
        break
11004 
      if fid == 1:
11005 
        if ftype == TType.I32:
11006 
          self.status = iprot.readI32();
11007 
        else:
11008 
          iprot.skip(ftype)
11009 
      elif fid == 2:
11010 
        if ftype == TType.I64:
11011 
          self.start_billing_date = iprot.readI64();
11012 
        else:
11013 
          iprot.skip(ftype)
11014 
      elif fid == 3:
11015 
        if ftype == TType.I64:
11016 
          self.end_billing_date = iprot.readI64();
11017 
        else:
11018 
          iprot.skip(ftype)
11019 
      elif fid == 4:
11020 
        if ftype == TType.I64:
11021 
          self.warehouse_id = iprot.readI64();
11022 
        else:
11023 
          iprot.skip(ftype)
11024 
      else:
11025 
        iprot.skip(ftype)
11026 
      iprot.readFieldEnd()
11027 
    iprot.readStructEnd()
11028 
 
11029 
  def write(self, oprot):
11030 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11031 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11032 
      return
11033 
    oprot.writeStructBegin('getOrdersByBillingDate_args')
3431 rajveer 11034 
    if self.status is not None:
999 varun.gupt 11035 
      oprot.writeFieldBegin('status', TType.I32, 1)
11036 
      oprot.writeI32(self.status)
11037 
      oprot.writeFieldEnd()
3431 rajveer 11038 
    if self.start_billing_date is not None:
999 varun.gupt 11039 
      oprot.writeFieldBegin('start_billing_date', TType.I64, 2)
11040 
      oprot.writeI64(self.start_billing_date)
11041 
      oprot.writeFieldEnd()
3431 rajveer 11042 
    if self.end_billing_date is not None:
999 varun.gupt 11043 
      oprot.writeFieldBegin('end_billing_date', TType.I64, 3)
11044 
      oprot.writeI64(self.end_billing_date)
11045 
      oprot.writeFieldEnd()
3431 rajveer 11046 
    if self.warehouse_id is not None:
999 varun.gupt 11047 
      oprot.writeFieldBegin('warehouse_id', TType.I64, 4)
11048 
      oprot.writeI64(self.warehouse_id)
11049 
      oprot.writeFieldEnd()
11050 
    oprot.writeFieldStop()
11051 
    oprot.writeStructEnd()
11052 
 
3431 rajveer 11053 
  def validate(self):
11054 
    return
11055 
 
11056 
 
999 varun.gupt 11057 
  def __repr__(self):
11058 
    L = ['%s=%r' % (key, value)
11059 
      for key, value in self.__dict__.iteritems()]
11060 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11061 
 
11062 
  def __eq__(self, other):
11063 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11064 
 
11065 
  def __ne__(self, other):
11066 
    return not (self == other)
11067 
 
11068 
class getOrdersByBillingDate_result:
11069 
  """
11070 
  Attributes:
11071 
   - success
11072 
   - ex
11073 
  """
11074 
 
11075 
  thrift_spec = (
11076 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
11077 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
11078 
  )
11079 
 
11080 
  def __init__(self, success=None, ex=None,):
11081 
    self.success = success
11082 
    self.ex = ex
11083 
 
11084 
  def read(self, iprot):
11085 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11086 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11087 
      return
11088 
    iprot.readStructBegin()
11089 
    while True:
11090 
      (fname, ftype, fid) = iprot.readFieldBegin()
11091 
      if ftype == TType.STOP:
11092 
        break
11093 
      if fid == 0:
11094 
        if ftype == TType.LIST:
11095 
          self.success = []
6188 rajveer 11096 
          (_etype158, _size155) = iprot.readListBegin()
11097 
          for _i159 in xrange(_size155):
11098 
            _elem160 = Order()
11099 
            _elem160.read(iprot)
11100 
            self.success.append(_elem160)
999 varun.gupt 11101 
          iprot.readListEnd()
11102 
        else:
11103 
          iprot.skip(ftype)
11104 
      elif fid == 1:
11105 
        if ftype == TType.STRUCT:
11106 
          self.ex = TransactionServiceException()
11107 
          self.ex.read(iprot)
11108 
        else:
11109 
          iprot.skip(ftype)
11110 
      else:
11111 
        iprot.skip(ftype)
11112 
      iprot.readFieldEnd()
11113 
    iprot.readStructEnd()
11114 
 
11115 
  def write(self, oprot):
11116 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11117 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11118 
      return
11119 
    oprot.writeStructBegin('getOrdersByBillingDate_result')
3431 rajveer 11120 
    if self.success is not None:
999 varun.gupt 11121 
      oprot.writeFieldBegin('success', TType.LIST, 0)
11122 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 11123 
      for iter161 in self.success:
11124 
        iter161.write(oprot)
999 varun.gupt 11125 
      oprot.writeListEnd()
11126 
      oprot.writeFieldEnd()
3431 rajveer 11127 
    if self.ex is not None:
999 varun.gupt 11128 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11129 
      self.ex.write(oprot)
11130 
      oprot.writeFieldEnd()
11131 
    oprot.writeFieldStop()
11132 
    oprot.writeStructEnd()
11133 
 
3431 rajveer 11134 
  def validate(self):
11135 
    return
11136 
 
11137 
 
999 varun.gupt 11138 
  def __repr__(self):
11139 
    L = ['%s=%r' % (key, value)
11140 
      for key, value in self.__dict__.iteritems()]
11141 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11142 
 
11143 
  def __eq__(self, other):
11144 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11145 
 
11146 
  def __ne__(self, other):
11147 
    return not (self == other)
11148 
 
3427 chandransh 11149 
class getOrdersByShippingDate_args:
11150 
  """
11151 
  Attributes:
11152 
   - fromShippingDate
11153 
   - toShippingDate
11154 
   - providerId
11155 
   - warehouseId
3451 chandransh 11156 
   - cod
3427 chandransh 11157 
  """
11158 
 
11159 
  thrift_spec = (
11160 
    None, # 0
11161 
    (1, TType.I64, 'fromShippingDate', None, None, ), # 1
11162 
    (2, TType.I64, 'toShippingDate', None, None, ), # 2
11163 
    (3, TType.I64, 'providerId', None, None, ), # 3
11164 
    (4, TType.I64, 'warehouseId', None, None, ), # 4
3451 chandransh 11165 
    (5, TType.BOOL, 'cod', None, None, ), # 5
3427 chandransh 11166 
  )
11167 
 
3451 chandransh 11168 
  def __init__(self, fromShippingDate=None, toShippingDate=None, providerId=None, warehouseId=None, cod=None,):
3427 chandransh 11169 
    self.fromShippingDate = fromShippingDate
11170 
    self.toShippingDate = toShippingDate
11171 
    self.providerId = providerId
11172 
    self.warehouseId = warehouseId
3451 chandransh 11173 
    self.cod = cod
3427 chandransh 11174 
 
11175 
  def read(self, iprot):
11176 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11177 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11178 
      return
11179 
    iprot.readStructBegin()
11180 
    while True:
11181 
      (fname, ftype, fid) = iprot.readFieldBegin()
11182 
      if ftype == TType.STOP:
11183 
        break
11184 
      if fid == 1:
11185 
        if ftype == TType.I64:
11186 
          self.fromShippingDate = iprot.readI64();
11187 
        else:
11188 
          iprot.skip(ftype)
11189 
      elif fid == 2:
11190 
        if ftype == TType.I64:
11191 
          self.toShippingDate = iprot.readI64();
11192 
        else:
11193 
          iprot.skip(ftype)
11194 
      elif fid == 3:
11195 
        if ftype == TType.I64:
11196 
          self.providerId = iprot.readI64();
11197 
        else:
11198 
          iprot.skip(ftype)
11199 
      elif fid == 4:
11200 
        if ftype == TType.I64:
11201 
          self.warehouseId = iprot.readI64();
11202 
        else:
11203 
          iprot.skip(ftype)
3451 chandransh 11204 
      elif fid == 5:
11205 
        if ftype == TType.BOOL:
11206 
          self.cod = iprot.readBool();
11207 
        else:
11208 
          iprot.skip(ftype)
3427 chandransh 11209 
      else:
11210 
        iprot.skip(ftype)
11211 
      iprot.readFieldEnd()
11212 
    iprot.readStructEnd()
11213 
 
11214 
  def write(self, oprot):
11215 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11216 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11217 
      return
11218 
    oprot.writeStructBegin('getOrdersByShippingDate_args')
3431 rajveer 11219 
    if self.fromShippingDate is not None:
3427 chandransh 11220 
      oprot.writeFieldBegin('fromShippingDate', TType.I64, 1)
11221 
      oprot.writeI64(self.fromShippingDate)
11222 
      oprot.writeFieldEnd()
3431 rajveer 11223 
    if self.toShippingDate is not None:
3427 chandransh 11224 
      oprot.writeFieldBegin('toShippingDate', TType.I64, 2)
11225 
      oprot.writeI64(self.toShippingDate)
11226 
      oprot.writeFieldEnd()
3431 rajveer 11227 
    if self.providerId is not None:
3427 chandransh 11228 
      oprot.writeFieldBegin('providerId', TType.I64, 3)
11229 
      oprot.writeI64(self.providerId)
11230 
      oprot.writeFieldEnd()
3431 rajveer 11231 
    if self.warehouseId is not None:
3427 chandransh 11232 
      oprot.writeFieldBegin('warehouseId', TType.I64, 4)
11233 
      oprot.writeI64(self.warehouseId)
11234 
      oprot.writeFieldEnd()
3451 chandransh 11235 
    if self.cod is not None:
11236 
      oprot.writeFieldBegin('cod', TType.BOOL, 5)
11237 
      oprot.writeBool(self.cod)
11238 
      oprot.writeFieldEnd()
3427 chandransh 11239 
    oprot.writeFieldStop()
11240 
    oprot.writeStructEnd()
11241 
 
3431 rajveer 11242 
  def validate(self):
11243 
    return
11244 
 
11245 
 
3427 chandransh 11246 
  def __repr__(self):
11247 
    L = ['%s=%r' % (key, value)
11248 
      for key, value in self.__dict__.iteritems()]
11249 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11250 
 
11251 
  def __eq__(self, other):
11252 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11253 
 
11254 
  def __ne__(self, other):
11255 
    return not (self == other)
11256 
 
11257 
class getOrdersByShippingDate_result:
11258 
  """
11259 
  Attributes:
11260 
   - success
11261 
   - ex
11262 
  """
11263 
 
11264 
  thrift_spec = (
11265 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
11266 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
11267 
  )
11268 
 
11269 
  def __init__(self, success=None, ex=None,):
11270 
    self.success = success
11271 
    self.ex = ex
11272 
 
11273 
  def read(self, iprot):
11274 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11275 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11276 
      return
11277 
    iprot.readStructBegin()
11278 
    while True:
11279 
      (fname, ftype, fid) = iprot.readFieldBegin()
11280 
      if ftype == TType.STOP:
11281 
        break
11282 
      if fid == 0:
11283 
        if ftype == TType.LIST:
11284 
          self.success = []
6188 rajveer 11285 
          (_etype165, _size162) = iprot.readListBegin()
11286 
          for _i166 in xrange(_size162):
11287 
            _elem167 = Order()
11288 
            _elem167.read(iprot)
11289 
            self.success.append(_elem167)
3427 chandransh 11290 
          iprot.readListEnd()
11291 
        else:
11292 
          iprot.skip(ftype)
11293 
      elif fid == 1:
11294 
        if ftype == TType.STRUCT:
11295 
          self.ex = TransactionServiceException()
11296 
          self.ex.read(iprot)
11297 
        else:
11298 
          iprot.skip(ftype)
11299 
      else:
11300 
        iprot.skip(ftype)
11301 
      iprot.readFieldEnd()
11302 
    iprot.readStructEnd()
11303 
 
11304 
  def write(self, oprot):
11305 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11306 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11307 
      return
11308 
    oprot.writeStructBegin('getOrdersByShippingDate_result')
3431 rajveer 11309 
    if self.success is not None:
3427 chandransh 11310 
      oprot.writeFieldBegin('success', TType.LIST, 0)
11311 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 11312 
      for iter168 in self.success:
11313 
        iter168.write(oprot)
3427 chandransh 11314 
      oprot.writeListEnd()
11315 
      oprot.writeFieldEnd()
3431 rajveer 11316 
    if self.ex is not None:
3427 chandransh 11317 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11318 
      self.ex.write(oprot)
11319 
      oprot.writeFieldEnd()
11320 
    oprot.writeFieldStop()
11321 
    oprot.writeStructEnd()
11322 
 
3431 rajveer 11323 
  def validate(self):
11324 
    return
11325 
 
11326 
 
3427 chandransh 11327 
  def __repr__(self):
11328 
    L = ['%s=%r' % (key, value)
11329 
      for key, value in self.__dict__.iteritems()]
11330 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11331 
 
11332 
  def __eq__(self, other):
11333 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11334 
 
11335 
  def __ne__(self, other):
11336 
    return not (self == other)
11337 
 
1382 varun.gupt 11338 
class getReturnableOrdersForCustomer_args:
11339 
  """
11340 
  Attributes:
11341 
   - customer_id
11342 
   - limit
11343 
  """
11344 
 
11345 
  thrift_spec = (
11346 
    None, # 0
11347 
    (1, TType.I64, 'customer_id', None, None, ), # 1
11348 
    (2, TType.I64, 'limit', None, None, ), # 2
11349 
  )
11350 
 
11351 
  def __init__(self, customer_id=None, limit=None,):
11352 
    self.customer_id = customer_id
11353 
    self.limit = limit
11354 
 
11355 
  def read(self, iprot):
11356 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11357 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11358 
      return
11359 
    iprot.readStructBegin()
11360 
    while True:
11361 
      (fname, ftype, fid) = iprot.readFieldBegin()
11362 
      if ftype == TType.STOP:
11363 
        break
11364 
      if fid == 1:
11365 
        if ftype == TType.I64:
11366 
          self.customer_id = iprot.readI64();
11367 
        else:
11368 
          iprot.skip(ftype)
11369 
      elif fid == 2:
11370 
        if ftype == TType.I64:
11371 
          self.limit = iprot.readI64();
11372 
        else:
11373 
          iprot.skip(ftype)
11374 
      else:
11375 
        iprot.skip(ftype)
11376 
      iprot.readFieldEnd()
11377 
    iprot.readStructEnd()
11378 
 
11379 
  def write(self, oprot):
11380 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11381 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11382 
      return
11383 
    oprot.writeStructBegin('getReturnableOrdersForCustomer_args')
3431 rajveer 11384 
    if self.customer_id is not None:
1382 varun.gupt 11385 
      oprot.writeFieldBegin('customer_id', TType.I64, 1)
11386 
      oprot.writeI64(self.customer_id)
11387 
      oprot.writeFieldEnd()
3431 rajveer 11388 
    if self.limit is not None:
1382 varun.gupt 11389 
      oprot.writeFieldBegin('limit', TType.I64, 2)
11390 
      oprot.writeI64(self.limit)
11391 
      oprot.writeFieldEnd()
11392 
    oprot.writeFieldStop()
11393 
    oprot.writeStructEnd()
11394 
 
3431 rajveer 11395 
  def validate(self):
11396 
    return
11397 
 
11398 
 
1382 varun.gupt 11399 
  def __repr__(self):
11400 
    L = ['%s=%r' % (key, value)
11401 
      for key, value in self.__dict__.iteritems()]
11402 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11403 
 
11404 
  def __eq__(self, other):
11405 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11406 
 
11407 
  def __ne__(self, other):
11408 
    return not (self == other)
11409 
 
11410 
class getReturnableOrdersForCustomer_result:
11411 
  """
11412 
  Attributes:
11413 
   - success
11414 
   - ex
11415 
  """
11416 
 
11417 
  thrift_spec = (
11418 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
11419 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
11420 
  )
11421 
 
11422 
  def __init__(self, success=None, ex=None,):
11423 
    self.success = success
11424 
    self.ex = ex
11425 
 
11426 
  def read(self, iprot):
11427 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11428 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11429 
      return
11430 
    iprot.readStructBegin()
11431 
    while True:
11432 
      (fname, ftype, fid) = iprot.readFieldBegin()
11433 
      if ftype == TType.STOP:
11434 
        break
11435 
      if fid == 0:
11436 
        if ftype == TType.LIST:
11437 
          self.success = []
6188 rajveer 11438 
          (_etype172, _size169) = iprot.readListBegin()
11439 
          for _i173 in xrange(_size169):
11440 
            _elem174 = iprot.readI64();
11441 
            self.success.append(_elem174)
1382 varun.gupt 11442 
          iprot.readListEnd()
11443 
        else:
11444 
          iprot.skip(ftype)
11445 
      elif fid == 1:
11446 
        if ftype == TType.STRUCT:
11447 
          self.ex = TransactionServiceException()
11448 
          self.ex.read(iprot)
11449 
        else:
11450 
          iprot.skip(ftype)
11451 
      else:
11452 
        iprot.skip(ftype)
11453 
      iprot.readFieldEnd()
11454 
    iprot.readStructEnd()
11455 
 
11456 
  def write(self, oprot):
11457 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11458 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11459 
      return
11460 
    oprot.writeStructBegin('getReturnableOrdersForCustomer_result')
3431 rajveer 11461 
    if self.success is not None:
1382 varun.gupt 11462 
      oprot.writeFieldBegin('success', TType.LIST, 0)
11463 
      oprot.writeListBegin(TType.I64, len(self.success))
6188 rajveer 11464 
      for iter175 in self.success:
11465 
        oprot.writeI64(iter175)
1382 varun.gupt 11466 
      oprot.writeListEnd()
11467 
      oprot.writeFieldEnd()
3431 rajveer 11468 
    if self.ex is not None:
1382 varun.gupt 11469 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11470 
      self.ex.write(oprot)
11471 
      oprot.writeFieldEnd()
11472 
    oprot.writeFieldStop()
11473 
    oprot.writeStructEnd()
11474 
 
3431 rajveer 11475 
  def validate(self):
11476 
    return
11477 
 
11478 
 
1382 varun.gupt 11479 
  def __repr__(self):
11480 
    L = ['%s=%r' % (key, value)
11481 
      for key, value in self.__dict__.iteritems()]
11482 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11483 
 
11484 
  def __eq__(self, other):
11485 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11486 
 
11487 
  def __ne__(self, other):
11488 
    return not (self == other)
11489 
 
11490 
class getCancellableOrdersForCustomer_args:
11491 
  """
11492 
  Attributes:
11493 
   - customer_id
11494 
   - limit
11495 
  """
11496 
 
11497 
  thrift_spec = (
11498 
    None, # 0
11499 
    (1, TType.I64, 'customer_id', None, None, ), # 1
11500 
    (2, TType.I64, 'limit', None, None, ), # 2
11501 
  )
11502 
 
11503 
  def __init__(self, customer_id=None, limit=None,):
11504 
    self.customer_id = customer_id
11505 
    self.limit = limit
11506 
 
11507 
  def read(self, iprot):
11508 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11509 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11510 
      return
11511 
    iprot.readStructBegin()
11512 
    while True:
11513 
      (fname, ftype, fid) = iprot.readFieldBegin()
11514 
      if ftype == TType.STOP:
11515 
        break
11516 
      if fid == 1:
11517 
        if ftype == TType.I64:
11518 
          self.customer_id = iprot.readI64();
11519 
        else:
11520 
          iprot.skip(ftype)
11521 
      elif fid == 2:
11522 
        if ftype == TType.I64:
11523 
          self.limit = iprot.readI64();
11524 
        else:
11525 
          iprot.skip(ftype)
11526 
      else:
11527 
        iprot.skip(ftype)
11528 
      iprot.readFieldEnd()
11529 
    iprot.readStructEnd()
11530 
 
11531 
  def write(self, oprot):
11532 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11533 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11534 
      return
11535 
    oprot.writeStructBegin('getCancellableOrdersForCustomer_args')
3431 rajveer 11536 
    if self.customer_id is not None:
1382 varun.gupt 11537 
      oprot.writeFieldBegin('customer_id', TType.I64, 1)
11538 
      oprot.writeI64(self.customer_id)
11539 
      oprot.writeFieldEnd()
3431 rajveer 11540 
    if self.limit is not None:
1382 varun.gupt 11541 
      oprot.writeFieldBegin('limit', TType.I64, 2)
11542 
      oprot.writeI64(self.limit)
11543 
      oprot.writeFieldEnd()
11544 
    oprot.writeFieldStop()
11545 
    oprot.writeStructEnd()
11546 
 
3431 rajveer 11547 
  def validate(self):
11548 
    return
11549 
 
11550 
 
1382 varun.gupt 11551 
  def __repr__(self):
11552 
    L = ['%s=%r' % (key, value)
11553 
      for key, value in self.__dict__.iteritems()]
11554 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11555 
 
11556 
  def __eq__(self, other):
11557 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11558 
 
11559 
  def __ne__(self, other):
11560 
    return not (self == other)
11561 
 
11562 
class getCancellableOrdersForCustomer_result:
11563 
  """
11564 
  Attributes:
11565 
   - success
11566 
   - ex
11567 
  """
11568 
 
11569 
  thrift_spec = (
11570 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
11571 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
11572 
  )
11573 
 
11574 
  def __init__(self, success=None, ex=None,):
11575 
    self.success = success
11576 
    self.ex = ex
11577 
 
11578 
  def read(self, iprot):
11579 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11580 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11581 
      return
11582 
    iprot.readStructBegin()
11583 
    while True:
11584 
      (fname, ftype, fid) = iprot.readFieldBegin()
11585 
      if ftype == TType.STOP:
11586 
        break
11587 
      if fid == 0:
11588 
        if ftype == TType.LIST:
11589 
          self.success = []
6188 rajveer 11590 
          (_etype179, _size176) = iprot.readListBegin()
11591 
          for _i180 in xrange(_size176):
11592 
            _elem181 = iprot.readI64();
11593 
            self.success.append(_elem181)
1382 varun.gupt 11594 
          iprot.readListEnd()
11595 
        else:
11596 
          iprot.skip(ftype)
11597 
      elif fid == 1:
11598 
        if ftype == TType.STRUCT:
11599 
          self.ex = TransactionServiceException()
11600 
          self.ex.read(iprot)
11601 
        else:
11602 
          iprot.skip(ftype)
11603 
      else:
11604 
        iprot.skip(ftype)
11605 
      iprot.readFieldEnd()
11606 
    iprot.readStructEnd()
11607 
 
11608 
  def write(self, oprot):
11609 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11610 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11611 
      return
11612 
    oprot.writeStructBegin('getCancellableOrdersForCustomer_result')
3431 rajveer 11613 
    if self.success is not None:
1382 varun.gupt 11614 
      oprot.writeFieldBegin('success', TType.LIST, 0)
11615 
      oprot.writeListBegin(TType.I64, len(self.success))
6188 rajveer 11616 
      for iter182 in self.success:
11617 
        oprot.writeI64(iter182)
1382 varun.gupt 11618 
      oprot.writeListEnd()
11619 
      oprot.writeFieldEnd()
3431 rajveer 11620 
    if self.ex is not None:
1382 varun.gupt 11621 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11622 
      self.ex.write(oprot)
11623 
      oprot.writeFieldEnd()
11624 
    oprot.writeFieldStop()
11625 
    oprot.writeStructEnd()
11626 
 
3431 rajveer 11627 
  def validate(self):
11628 
    return
11629 
 
11630 
 
1382 varun.gupt 11631 
  def __repr__(self):
11632 
    L = ['%s=%r' % (key, value)
11633 
      for key, value in self.__dict__.iteritems()]
11634 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11635 
 
11636 
  def __eq__(self, other):
11637 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11638 
 
11639 
  def __ne__(self, other):
11640 
    return not (self == other)
11641 
 
483 rajveer 11642 
class changeOrderStatus_args:
94 ashish 11643 
  """
11644 
  Attributes:
483 rajveer 11645 
   - orderId
11646 
   - status
11647 
   - description
94 ashish 11648 
  """
11649 
 
11650 
  thrift_spec = (
11651 
    None, # 0
483 rajveer 11652 
    (1, TType.I64, 'orderId', None, None, ), # 1
11653 
    (2, TType.I32, 'status', None, None, ), # 2
11654 
    (3, TType.STRING, 'description', None, None, ), # 3
94 ashish 11655 
  )
11656 
 
483 rajveer 11657 
  def __init__(self, orderId=None, status=None, description=None,):
11658 
    self.orderId = orderId
11659 
    self.status = status
11660 
    self.description = description
94 ashish 11661 
 
11662 
  def read(self, iprot):
11663 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11664 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11665 
      return
11666 
    iprot.readStructBegin()
11667 
    while True:
11668 
      (fname, ftype, fid) = iprot.readFieldBegin()
11669 
      if ftype == TType.STOP:
11670 
        break
11671 
      if fid == 1:
11672 
        if ftype == TType.I64:
483 rajveer 11673 
          self.orderId = iprot.readI64();
94 ashish 11674 
        else:
11675 
          iprot.skip(ftype)
11676 
      elif fid == 2:
483 rajveer 11677 
        if ftype == TType.I32:
11678 
          self.status = iprot.readI32();
94 ashish 11679 
        else:
11680 
          iprot.skip(ftype)
483 rajveer 11681 
      elif fid == 3:
11682 
        if ftype == TType.STRING:
11683 
          self.description = iprot.readString();
11684 
        else:
11685 
          iprot.skip(ftype)
94 ashish 11686 
      else:
11687 
        iprot.skip(ftype)
11688 
      iprot.readFieldEnd()
11689 
    iprot.readStructEnd()
11690 
 
11691 
  def write(self, oprot):
11692 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11693 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11694 
      return
483 rajveer 11695 
    oprot.writeStructBegin('changeOrderStatus_args')
3431 rajveer 11696 
    if self.orderId is not None:
483 rajveer 11697 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
11698 
      oprot.writeI64(self.orderId)
94 ashish 11699 
      oprot.writeFieldEnd()
3431 rajveer 11700 
    if self.status is not None:
483 rajveer 11701 
      oprot.writeFieldBegin('status', TType.I32, 2)
11702 
      oprot.writeI32(self.status)
94 ashish 11703 
      oprot.writeFieldEnd()
3431 rajveer 11704 
    if self.description is not None:
483 rajveer 11705 
      oprot.writeFieldBegin('description', TType.STRING, 3)
11706 
      oprot.writeString(self.description)
11707 
      oprot.writeFieldEnd()
94 ashish 11708 
    oprot.writeFieldStop()
11709 
    oprot.writeStructEnd()
11710 
 
3431 rajveer 11711 
  def validate(self):
11712 
    return
11713 
 
11714 
 
94 ashish 11715 
  def __repr__(self):
11716 
    L = ['%s=%r' % (key, value)
11717 
      for key, value in self.__dict__.iteritems()]
11718 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11719 
 
11720 
  def __eq__(self, other):
11721 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11722 
 
11723 
  def __ne__(self, other):
11724 
    return not (self == other)
11725 
 
483 rajveer 11726 
class changeOrderStatus_result:
94 ashish 11727 
  """
11728 
  Attributes:
11729 
   - success
11730 
   - ex
11731 
  """
11732 
 
11733 
  thrift_spec = (
11734 
    (0, TType.BOOL, 'success', None, None, ), # 0
11735 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
11736 
  )
11737 
 
11738 
  def __init__(self, success=None, ex=None,):
11739 
    self.success = success
11740 
    self.ex = ex
11741 
 
11742 
  def read(self, iprot):
11743 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11744 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11745 
      return
11746 
    iprot.readStructBegin()
11747 
    while True:
11748 
      (fname, ftype, fid) = iprot.readFieldBegin()
11749 
      if ftype == TType.STOP:
11750 
        break
11751 
      if fid == 0:
11752 
        if ftype == TType.BOOL:
11753 
          self.success = iprot.readBool();
11754 
        else:
11755 
          iprot.skip(ftype)
11756 
      elif fid == 1:
11757 
        if ftype == TType.STRUCT:
11758 
          self.ex = TransactionServiceException()
11759 
          self.ex.read(iprot)
11760 
        else:
11761 
          iprot.skip(ftype)
11762 
      else:
11763 
        iprot.skip(ftype)
11764 
      iprot.readFieldEnd()
11765 
    iprot.readStructEnd()
11766 
 
11767 
  def write(self, oprot):
11768 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11769 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11770 
      return
483 rajveer 11771 
    oprot.writeStructBegin('changeOrderStatus_result')
3431 rajveer 11772 
    if self.success is not None:
94 ashish 11773 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
11774 
      oprot.writeBool(self.success)
11775 
      oprot.writeFieldEnd()
3431 rajveer 11776 
    if self.ex is not None:
94 ashish 11777 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11778 
      self.ex.write(oprot)
11779 
      oprot.writeFieldEnd()
11780 
    oprot.writeFieldStop()
11781 
    oprot.writeStructEnd()
11782 
 
3431 rajveer 11783 
  def validate(self):
11784 
    return
11785 
 
11786 
 
94 ashish 11787 
  def __repr__(self):
11788 
    L = ['%s=%r' % (key, value)
11789 
      for key, value in self.__dict__.iteritems()]
11790 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11791 
 
11792 
  def __eq__(self, other):
11793 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11794 
 
11795 
  def __ne__(self, other):
11796 
    return not (self == other)
11797 
 
3064 chandransh 11798 
class getOrdersForTransaction_args:
494 rajveer 11799 
  """
11800 
  Attributes:
3064 chandransh 11801 
   - transactionId
11802 
   - customerId
494 rajveer 11803 
  """
11804 
 
11805 
  thrift_spec = (
11806 
    None, # 0
3064 chandransh 11807 
    (1, TType.I64, 'transactionId', None, None, ), # 1
11808 
    (2, TType.I64, 'customerId', None, None, ), # 2
494 rajveer 11809 
  )
11810 
 
3064 chandransh 11811 
  def __init__(self, transactionId=None, customerId=None,):
11812 
    self.transactionId = transactionId
11813 
    self.customerId = customerId
494 rajveer 11814 
 
11815 
  def read(self, iprot):
11816 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11817 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11818 
      return
11819 
    iprot.readStructBegin()
11820 
    while True:
11821 
      (fname, ftype, fid) = iprot.readFieldBegin()
11822 
      if ftype == TType.STOP:
11823 
        break
11824 
      if fid == 1:
11825 
        if ftype == TType.I64:
3064 chandransh 11826 
          self.transactionId = iprot.readI64();
494 rajveer 11827 
        else:
11828 
          iprot.skip(ftype)
11829 
      elif fid == 2:
3064 chandransh 11830 
        if ftype == TType.I64:
11831 
          self.customerId = iprot.readI64();
494 rajveer 11832 
        else:
11833 
          iprot.skip(ftype)
11834 
      else:
11835 
        iprot.skip(ftype)
11836 
      iprot.readFieldEnd()
11837 
    iprot.readStructEnd()
11838 
 
11839 
  def write(self, oprot):
11840 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11841 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11842 
      return
3064 chandransh 11843 
    oprot.writeStructBegin('getOrdersForTransaction_args')
3431 rajveer 11844 
    if self.transactionId is not None:
3064 chandransh 11845 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
11846 
      oprot.writeI64(self.transactionId)
494 rajveer 11847 
      oprot.writeFieldEnd()
3431 rajveer 11848 
    if self.customerId is not None:
3064 chandransh 11849 
      oprot.writeFieldBegin('customerId', TType.I64, 2)
11850 
      oprot.writeI64(self.customerId)
494 rajveer 11851 
      oprot.writeFieldEnd()
11852 
    oprot.writeFieldStop()
11853 
    oprot.writeStructEnd()
11854 
 
3431 rajveer 11855 
  def validate(self):
11856 
    return
11857 
 
11858 
 
494 rajveer 11859 
  def __repr__(self):
11860 
    L = ['%s=%r' % (key, value)
11861 
      for key, value in self.__dict__.iteritems()]
11862 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11863 
 
11864 
  def __eq__(self, other):
11865 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11866 
 
11867 
  def __ne__(self, other):
11868 
    return not (self == other)
11869 
 
3064 chandransh 11870 
class getOrdersForTransaction_result:
494 rajveer 11871 
  """
11872 
  Attributes:
11873 
   - success
11874 
   - ex
11875 
  """
11876 
 
11877 
  thrift_spec = (
3064 chandransh 11878 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
494 rajveer 11879 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
11880 
  )
11881 
 
11882 
  def __init__(self, success=None, ex=None,):
11883 
    self.success = success
11884 
    self.ex = ex
11885 
 
11886 
  def read(self, iprot):
11887 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11888 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11889 
      return
11890 
    iprot.readStructBegin()
11891 
    while True:
11892 
      (fname, ftype, fid) = iprot.readFieldBegin()
11893 
      if ftype == TType.STOP:
11894 
        break
11895 
      if fid == 0:
3064 chandransh 11896 
        if ftype == TType.LIST:
11897 
          self.success = []
6188 rajveer 11898 
          (_etype186, _size183) = iprot.readListBegin()
11899 
          for _i187 in xrange(_size183):
11900 
            _elem188 = Order()
11901 
            _elem188.read(iprot)
11902 
            self.success.append(_elem188)
3064 chandransh 11903 
          iprot.readListEnd()
494 rajveer 11904 
        else:
11905 
          iprot.skip(ftype)
11906 
      elif fid == 1:
11907 
        if ftype == TType.STRUCT:
11908 
          self.ex = TransactionServiceException()
11909 
          self.ex.read(iprot)
11910 
        else:
11911 
          iprot.skip(ftype)
11912 
      else:
11913 
        iprot.skip(ftype)
11914 
      iprot.readFieldEnd()
11915 
    iprot.readStructEnd()
11916 
 
11917 
  def write(self, oprot):
11918 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11919 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11920 
      return
3064 chandransh 11921 
    oprot.writeStructBegin('getOrdersForTransaction_result')
3431 rajveer 11922 
    if self.success is not None:
3064 chandransh 11923 
      oprot.writeFieldBegin('success', TType.LIST, 0)
11924 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 11925 
      for iter189 in self.success:
11926 
        iter189.write(oprot)
3064 chandransh 11927 
      oprot.writeListEnd()
494 rajveer 11928 
      oprot.writeFieldEnd()
3431 rajveer 11929 
    if self.ex is not None:
494 rajveer 11930 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11931 
      self.ex.write(oprot)
11932 
      oprot.writeFieldEnd()
11933 
    oprot.writeFieldStop()
11934 
    oprot.writeStructEnd()
11935 
 
3431 rajveer 11936 
  def validate(self):
11937 
    return
11938 
 
11939 
 
494 rajveer 11940 
  def __repr__(self):
11941 
    L = ['%s=%r' % (key, value)
11942 
      for key, value in self.__dict__.iteritems()]
11943 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11944 
 
11945 
  def __eq__(self, other):
11946 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11947 
 
11948 
  def __ne__(self, other):
11949 
    return not (self == other)
11950 
 
3064 chandransh 11951 
class getOrdersForCustomer_args:
1149 chandransh 11952 
  """
11953 
  Attributes:
3064 chandransh 11954 
   - customerId
11955 
   - from_date
11956 
   - to_date
11957 
   - statuses
1149 chandransh 11958 
  """
11959 
 
11960 
  thrift_spec = (
11961 
    None, # 0
3064 chandransh 11962 
    (1, TType.I64, 'customerId', None, None, ), # 1
11963 
    (2, TType.I64, 'from_date', None, None, ), # 2
11964 
    (3, TType.I64, 'to_date', None, None, ), # 3
11965 
    (4, TType.LIST, 'statuses', (TType.I32,None), None, ), # 4
1149 chandransh 11966 
  )
11967 
 
3064 chandransh 11968 
  def __init__(self, customerId=None, from_date=None, to_date=None, statuses=None,):
11969 
    self.customerId = customerId
11970 
    self.from_date = from_date
11971 
    self.to_date = to_date
11972 
    self.statuses = statuses
1149 chandransh 11973 
 
11974 
  def read(self, iprot):
11975 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11976 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11977 
      return
11978 
    iprot.readStructBegin()
11979 
    while True:
11980 
      (fname, ftype, fid) = iprot.readFieldBegin()
11981 
      if ftype == TType.STOP:
11982 
        break
11983 
      if fid == 1:
11984 
        if ftype == TType.I64:
3064 chandransh 11985 
          self.customerId = iprot.readI64();
1149 chandransh 11986 
        else:
11987 
          iprot.skip(ftype)
11988 
      elif fid == 2:
11989 
        if ftype == TType.I64:
3064 chandransh 11990 
          self.from_date = iprot.readI64();
1149 chandransh 11991 
        else:
11992 
          iprot.skip(ftype)
2783 chandransh 11993 
      elif fid == 3:
11994 
        if ftype == TType.I64:
3064 chandransh 11995 
          self.to_date = iprot.readI64();
2783 chandransh 11996 
        else:
11997 
          iprot.skip(ftype)
11998 
      elif fid == 4:
3064 chandransh 11999 
        if ftype == TType.LIST:
12000 
          self.statuses = []
6188 rajveer 12001 
          (_etype193, _size190) = iprot.readListBegin()
12002 
          for _i194 in xrange(_size190):
12003 
            _elem195 = iprot.readI32();
12004 
            self.statuses.append(_elem195)
3064 chandransh 12005 
          iprot.readListEnd()
2783 chandransh 12006 
        else:
12007 
          iprot.skip(ftype)
1149 chandransh 12008 
      else:
12009 
        iprot.skip(ftype)
12010 
      iprot.readFieldEnd()
12011 
    iprot.readStructEnd()
12012 
 
12013 
  def write(self, oprot):
12014 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12015 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12016 
      return
3064 chandransh 12017 
    oprot.writeStructBegin('getOrdersForCustomer_args')
3431 rajveer 12018 
    if self.customerId is not None:
3064 chandransh 12019 
      oprot.writeFieldBegin('customerId', TType.I64, 1)
12020 
      oprot.writeI64(self.customerId)
1149 chandransh 12021 
      oprot.writeFieldEnd()
3431 rajveer 12022 
    if self.from_date is not None:
3064 chandransh 12023 
      oprot.writeFieldBegin('from_date', TType.I64, 2)
12024 
      oprot.writeI64(self.from_date)
1149 chandransh 12025 
      oprot.writeFieldEnd()
3431 rajveer 12026 
    if self.to_date is not None:
3064 chandransh 12027 
      oprot.writeFieldBegin('to_date', TType.I64, 3)
12028 
      oprot.writeI64(self.to_date)
2783 chandransh 12029 
      oprot.writeFieldEnd()
3431 rajveer 12030 
    if self.statuses is not None:
3064 chandransh 12031 
      oprot.writeFieldBegin('statuses', TType.LIST, 4)
12032 
      oprot.writeListBegin(TType.I32, len(self.statuses))
6188 rajveer 12033 
      for iter196 in self.statuses:
12034 
        oprot.writeI32(iter196)
3064 chandransh 12035 
      oprot.writeListEnd()
2783 chandransh 12036 
      oprot.writeFieldEnd()
1149 chandransh 12037 
    oprot.writeFieldStop()
12038 
    oprot.writeStructEnd()
12039 
 
3431 rajveer 12040 
  def validate(self):
12041 
    return
12042 
 
12043 
 
1149 chandransh 12044 
  def __repr__(self):
12045 
    L = ['%s=%r' % (key, value)
12046 
      for key, value in self.__dict__.iteritems()]
12047 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12048 
 
12049 
  def __eq__(self, other):
12050 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12051 
 
12052 
  def __ne__(self, other):
12053 
    return not (self == other)
12054 
 
3064 chandransh 12055 
class getOrdersForCustomer_result:
1149 chandransh 12056 
  """
12057 
  Attributes:
12058 
   - success
12059 
   - ex
12060 
  """
12061 
 
12062 
  thrift_spec = (
3064 chandransh 12063 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
1149 chandransh 12064 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
12065 
  )
12066 
 
12067 
  def __init__(self, success=None, ex=None,):
12068 
    self.success = success
12069 
    self.ex = ex
12070 
 
12071 
  def read(self, iprot):
12072 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12073 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12074 
      return
12075 
    iprot.readStructBegin()
12076 
    while True:
12077 
      (fname, ftype, fid) = iprot.readFieldBegin()
12078 
      if ftype == TType.STOP:
12079 
        break
12080 
      if fid == 0:
3064 chandransh 12081 
        if ftype == TType.LIST:
12082 
          self.success = []
6188 rajveer 12083 
          (_etype200, _size197) = iprot.readListBegin()
12084 
          for _i201 in xrange(_size197):
12085 
            _elem202 = Order()
12086 
            _elem202.read(iprot)
12087 
            self.success.append(_elem202)
3064 chandransh 12088 
          iprot.readListEnd()
1149 chandransh 12089 
        else:
12090 
          iprot.skip(ftype)
12091 
      elif fid == 1:
12092 
        if ftype == TType.STRUCT:
12093 
          self.ex = TransactionServiceException()
12094 
          self.ex.read(iprot)
12095 
        else:
12096 
          iprot.skip(ftype)
12097 
      else:
12098 
        iprot.skip(ftype)
12099 
      iprot.readFieldEnd()
12100 
    iprot.readStructEnd()
12101 
 
12102 
  def write(self, oprot):
12103 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12104 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12105 
      return
3064 chandransh 12106 
    oprot.writeStructBegin('getOrdersForCustomer_result')
3431 rajveer 12107 
    if self.success is not None:
3064 chandransh 12108 
      oprot.writeFieldBegin('success', TType.LIST, 0)
12109 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 12110 
      for iter203 in self.success:
12111 
        iter203.write(oprot)
3064 chandransh 12112 
      oprot.writeListEnd()
1149 chandransh 12113 
      oprot.writeFieldEnd()
3431 rajveer 12114 
    if self.ex is not None:
1149 chandransh 12115 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
12116 
      self.ex.write(oprot)
12117 
      oprot.writeFieldEnd()
12118 
    oprot.writeFieldStop()
12119 
    oprot.writeStructEnd()
12120 
 
3431 rajveer 12121 
  def validate(self):
12122 
    return
12123 
 
12124 
 
1149 chandransh 12125 
  def __repr__(self):
12126 
    L = ['%s=%r' % (key, value)
12127 
      for key, value in self.__dict__.iteritems()]
12128 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12129 
 
12130 
  def __eq__(self, other):
12131 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12132 
 
12133 
  def __ne__(self, other):
12134 
    return not (self == other)
12135 
 
3064 chandransh 12136 
class createOrder_args:
921 rajveer 12137 
  """
12138 
  Attributes:
3064 chandransh 12139 
   - order
921 rajveer 12140 
  """
12141 
 
12142 
  thrift_spec = (
12143 
    None, # 0
3064 chandransh 12144 
    (1, TType.STRUCT, 'order', (Order, Order.thrift_spec), None, ), # 1
921 rajveer 12145 
  )
12146 
 
3064 chandransh 12147 
  def __init__(self, order=None,):
12148 
    self.order = order
921 rajveer 12149 
 
12150 
  def read(self, iprot):
12151 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12152 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12153 
      return
12154 
    iprot.readStructBegin()
12155 
    while True:
12156 
      (fname, ftype, fid) = iprot.readFieldBegin()
12157 
      if ftype == TType.STOP:
12158 
        break
12159 
      if fid == 1:
3064 chandransh 12160 
        if ftype == TType.STRUCT:
12161 
          self.order = Order()
12162 
          self.order.read(iprot)
921 rajveer 12163 
        else:
12164 
          iprot.skip(ftype)
12165 
      else:
12166 
        iprot.skip(ftype)
12167 
      iprot.readFieldEnd()
12168 
    iprot.readStructEnd()
12169 
 
12170 
  def write(self, oprot):
12171 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12172 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12173 
      return
3064 chandransh 12174 
    oprot.writeStructBegin('createOrder_args')
3431 rajveer 12175 
    if self.order is not None:
3064 chandransh 12176 
      oprot.writeFieldBegin('order', TType.STRUCT, 1)
12177 
      self.order.write(oprot)
921 rajveer 12178 
      oprot.writeFieldEnd()
12179 
    oprot.writeFieldStop()
12180 
    oprot.writeStructEnd()
12181 
 
3431 rajveer 12182 
  def validate(self):
12183 
    return
12184 
 
12185 
 
921 rajveer 12186 
  def __repr__(self):
12187 
    L = ['%s=%r' % (key, value)
12188 
      for key, value in self.__dict__.iteritems()]
12189 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12190 
 
12191 
  def __eq__(self, other):
12192 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12193 
 
12194 
  def __ne__(self, other):
12195 
    return not (self == other)
12196 
 
3064 chandransh 12197 
class createOrder_result:
921 rajveer 12198 
  """
12199 
  Attributes:
12200 
   - success
12201 
   - ex
12202 
  """
12203 
 
12204 
  thrift_spec = (
3064 chandransh 12205 
    (0, TType.I64, 'success', None, None, ), # 0
921 rajveer 12206 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
12207 
  )
12208 
 
12209 
  def __init__(self, success=None, ex=None,):
12210 
    self.success = success
12211 
    self.ex = ex
12212 
 
12213 
  def read(self, iprot):
12214 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12215 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12216 
      return
12217 
    iprot.readStructBegin()
12218 
    while True:
12219 
      (fname, ftype, fid) = iprot.readFieldBegin()
12220 
      if ftype == TType.STOP:
12221 
        break
12222 
      if fid == 0:
3064 chandransh 12223 
        if ftype == TType.I64:
12224 
          self.success = iprot.readI64();
921 rajveer 12225 
        else:
12226 
          iprot.skip(ftype)
12227 
      elif fid == 1:
12228 
        if ftype == TType.STRUCT:
12229 
          self.ex = TransactionServiceException()
12230 
          self.ex.read(iprot)
12231 
        else:
12232 
          iprot.skip(ftype)
12233 
      else:
12234 
        iprot.skip(ftype)
12235 
      iprot.readFieldEnd()
12236 
    iprot.readStructEnd()
12237 
 
12238 
  def write(self, oprot):
12239 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12240 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12241 
      return
3064 chandransh 12242 
    oprot.writeStructBegin('createOrder_result')
3431 rajveer 12243 
    if self.success is not None:
3064 chandransh 12244 
      oprot.writeFieldBegin('success', TType.I64, 0)
12245 
      oprot.writeI64(self.success)
921 rajveer 12246 
      oprot.writeFieldEnd()
3431 rajveer 12247 
    if self.ex is not None:
921 rajveer 12248 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
12249 
      self.ex.write(oprot)
12250 
      oprot.writeFieldEnd()
12251 
    oprot.writeFieldStop()
12252 
    oprot.writeStructEnd()
12253 
 
3431 rajveer 12254 
  def validate(self):
12255 
    return
12256 
 
12257 
 
921 rajveer 12258 
  def __repr__(self):
12259 
    L = ['%s=%r' % (key, value)
12260 
      for key, value in self.__dict__.iteritems()]
12261 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12262 
 
12263 
  def __eq__(self, other):
12264 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12265 
 
12266 
  def __ne__(self, other):
12267 
    return not (self == other)
12268 
 
3064 chandransh 12269 
class getOrder_args:
921 rajveer 12270 
  """
12271 
  Attributes:
3064 chandransh 12272 
   - id
921 rajveer 12273 
  """
12274 
 
12275 
  thrift_spec = (
12276 
    None, # 0
3064 chandransh 12277 
    (1, TType.I64, 'id', None, None, ), # 1
921 rajveer 12278 
  )
12279 
 
3064 chandransh 12280 
  def __init__(self, id=None,):
12281 
    self.id = id
921 rajveer 12282 
 
12283 
  def read(self, iprot):
12284 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12285 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12286 
      return
12287 
    iprot.readStructBegin()
12288 
    while True:
12289 
      (fname, ftype, fid) = iprot.readFieldBegin()
12290 
      if ftype == TType.STOP:
12291 
        break
12292 
      if fid == 1:
12293 
        if ftype == TType.I64:
3064 chandransh 12294 
          self.id = iprot.readI64();
921 rajveer 12295 
        else:
12296 
          iprot.skip(ftype)
12297 
      else:
12298 
        iprot.skip(ftype)
12299 
      iprot.readFieldEnd()
12300 
    iprot.readStructEnd()
12301 
 
12302 
  def write(self, oprot):
12303 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12304 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12305 
      return
3064 chandransh 12306 
    oprot.writeStructBegin('getOrder_args')
3431 rajveer 12307 
    if self.id is not None:
3064 chandransh 12308 
      oprot.writeFieldBegin('id', TType.I64, 1)
12309 
      oprot.writeI64(self.id)
921 rajveer 12310 
      oprot.writeFieldEnd()
12311 
    oprot.writeFieldStop()
12312 
    oprot.writeStructEnd()
12313 
 
3431 rajveer 12314 
  def validate(self):
12315 
    return
12316 
 
12317 
 
921 rajveer 12318 
  def __repr__(self):
12319 
    L = ['%s=%r' % (key, value)
12320 
      for key, value in self.__dict__.iteritems()]
12321 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12322 
 
12323 
  def __eq__(self, other):
12324 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12325 
 
12326 
  def __ne__(self, other):
12327 
    return not (self == other)
12328 
 
3064 chandransh 12329 
class getOrder_result:
921 rajveer 12330 
  """
12331 
  Attributes:
12332 
   - success
12333 
   - ex
12334 
  """
12335 
 
12336 
  thrift_spec = (
3064 chandransh 12337 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
921 rajveer 12338 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
12339 
  )
12340 
 
12341 
  def __init__(self, success=None, ex=None,):
12342 
    self.success = success
12343 
    self.ex = ex
12344 
 
12345 
  def read(self, iprot):
12346 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12347 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12348 
      return
12349 
    iprot.readStructBegin()
12350 
    while True:
12351 
      (fname, ftype, fid) = iprot.readFieldBegin()
12352 
      if ftype == TType.STOP:
12353 
        break
12354 
      if fid == 0:
3064 chandransh 12355 
        if ftype == TType.STRUCT:
12356 
          self.success = Order()
12357 
          self.success.read(iprot)
921 rajveer 12358 
        else:
12359 
          iprot.skip(ftype)
12360 
      elif fid == 1:
12361 
        if ftype == TType.STRUCT:
12362 
          self.ex = TransactionServiceException()
12363 
          self.ex.read(iprot)
12364 
        else:
12365 
          iprot.skip(ftype)
12366 
      else:
12367 
        iprot.skip(ftype)
12368 
      iprot.readFieldEnd()
12369 
    iprot.readStructEnd()
12370 
 
12371 
  def write(self, oprot):
12372 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12373 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12374 
      return
3064 chandransh 12375 
    oprot.writeStructBegin('getOrder_result')
3431 rajveer 12376 
    if self.success is not None:
3064 chandransh 12377 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
12378 
      self.success.write(oprot)
921 rajveer 12379 
      oprot.writeFieldEnd()
3431 rajveer 12380 
    if self.ex is not None:
921 rajveer 12381 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
12382 
      self.ex.write(oprot)
12383 
      oprot.writeFieldEnd()
12384 
    oprot.writeFieldStop()
12385 
    oprot.writeStructEnd()
12386 
 
3431 rajveer 12387 
  def validate(self):
12388 
    return
12389 
 
12390 
 
921 rajveer 12391 
  def __repr__(self):
12392 
    L = ['%s=%r' % (key, value)
12393 
      for key, value in self.__dict__.iteritems()]
12394 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12395 
 
12396 
  def __eq__(self, other):
12397 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12398 
 
12399 
  def __ne__(self, other):
12400 
    return not (self == other)
12401 
 
3064 chandransh 12402 
class getLineItemsForOrder_args:
94 ashish 12403 
  """
12404 
  Attributes:
3064 chandransh 12405 
   - orderId
94 ashish 12406 
  """
12407 
 
12408 
  thrift_spec = (
12409 
    None, # 0
3064 chandransh 12410 
    (1, TType.I64, 'orderId', None, None, ), # 1
94 ashish 12411 
  )
12412 
 
3064 chandransh 12413 
  def __init__(self, orderId=None,):
12414 
    self.orderId = orderId
94 ashish 12415 
 
12416 
  def read(self, iprot):
12417 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12418 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12419 
      return
12420 
    iprot.readStructBegin()
12421 
    while True:
12422 
      (fname, ftype, fid) = iprot.readFieldBegin()
12423 
      if ftype == TType.STOP:
12424 
        break
12425 
      if fid == 1:
12426 
        if ftype == TType.I64:
3064 chandransh 12427 
          self.orderId = iprot.readI64();
94 ashish 12428 
        else:
12429 
          iprot.skip(ftype)
12430 
      else:
12431 
        iprot.skip(ftype)
12432 
      iprot.readFieldEnd()
12433 
    iprot.readStructEnd()
12434 
 
12435 
  def write(self, oprot):
12436 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12437 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12438 
      return
3064 chandransh 12439 
    oprot.writeStructBegin('getLineItemsForOrder_args')
3431 rajveer 12440 
    if self.orderId is not None:
3064 chandransh 12441 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
12442 
      oprot.writeI64(self.orderId)
94 ashish 12443 
      oprot.writeFieldEnd()
12444 
    oprot.writeFieldStop()
12445 
    oprot.writeStructEnd()
12446 
 
3431 rajveer 12447 
  def validate(self):
12448 
    return
12449 
 
12450 
 
94 ashish 12451 
  def __repr__(self):
12452 
    L = ['%s=%r' % (key, value)
12453 
      for key, value in self.__dict__.iteritems()]
12454 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12455 
 
12456 
  def __eq__(self, other):
12457 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12458 
 
12459 
  def __ne__(self, other):
12460 
    return not (self == other)
12461 
 
3064 chandransh 12462 
class getLineItemsForOrder_result:
94 ashish 12463 
  """
12464 
  Attributes:
12465 
   - success
12466 
   - ex
12467 
  """
12468 
 
12469 
  thrift_spec = (
3064 chandransh 12470 
    (0, TType.LIST, 'success', (TType.STRUCT,(LineItem, LineItem.thrift_spec)), None, ), # 0
94 ashish 12471 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
12472 
  )
12473 
 
12474 
  def __init__(self, success=None, ex=None,):
12475 
    self.success = success
12476 
    self.ex = ex
12477 
 
12478 
  def read(self, iprot):
12479 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12480 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12481 
      return
12482 
    iprot.readStructBegin()
12483 
    while True:
12484 
      (fname, ftype, fid) = iprot.readFieldBegin()
12485 
      if ftype == TType.STOP:
12486 
        break
12487 
      if fid == 0:
483 rajveer 12488 
        if ftype == TType.LIST:
12489 
          self.success = []
6188 rajveer 12490 
          (_etype207, _size204) = iprot.readListBegin()
12491 
          for _i208 in xrange(_size204):
12492 
            _elem209 = LineItem()
12493 
            _elem209.read(iprot)
12494 
            self.success.append(_elem209)
483 rajveer 12495 
          iprot.readListEnd()
94 ashish 12496 
        else:
12497 
          iprot.skip(ftype)
12498 
      elif fid == 1:
12499 
        if ftype == TType.STRUCT:
12500 
          self.ex = TransactionServiceException()
12501 
          self.ex.read(iprot)
12502 
        else:
12503 
          iprot.skip(ftype)
12504 
      else:
12505 
        iprot.skip(ftype)
12506 
      iprot.readFieldEnd()
12507 
    iprot.readStructEnd()
12508 
 
12509 
  def write(self, oprot):
12510 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12511 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12512 
      return
3064 chandransh 12513 
    oprot.writeStructBegin('getLineItemsForOrder_result')
3431 rajveer 12514 
    if self.success is not None:
483 rajveer 12515 
      oprot.writeFieldBegin('success', TType.LIST, 0)
12516 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 12517 
      for iter210 in self.success:
12518 
        iter210.write(oprot)
483 rajveer 12519 
      oprot.writeListEnd()
94 ashish 12520 
      oprot.writeFieldEnd()
3431 rajveer 12521 
    if self.ex is not None:
94 ashish 12522 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
12523 
      self.ex.write(oprot)
12524 
      oprot.writeFieldEnd()
12525 
    oprot.writeFieldStop()
12526 
    oprot.writeStructEnd()
12527 
 
3431 rajveer 12528 
  def validate(self):
12529 
    return
12530 
 
12531 
 
94 ashish 12532 
  def __repr__(self):
12533 
    L = ['%s=%r' % (key, value)
12534 
      for key, value in self.__dict__.iteritems()]
12535 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12536 
 
12537 
  def __eq__(self, other):
12538 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12539 
 
12540 
  def __ne__(self, other):
12541 
    return not (self == other)
12542 
 
4999 phani.kuma 12543 
class getOrderList_args:
12544 
  """
12545 
  Attributes:
12546 
   - order_ids
12547 
  """
12548 
 
12549 
  thrift_spec = (
12550 
    None, # 0
12551 
    (1, TType.LIST, 'order_ids', (TType.I64,None), None, ), # 1
12552 
  )
12553 
 
12554 
  def __init__(self, order_ids=None,):
12555 
    self.order_ids = order_ids
12556 
 
12557 
  def read(self, iprot):
12558 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12559 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12560 
      return
12561 
    iprot.readStructBegin()
12562 
    while True:
12563 
      (fname, ftype, fid) = iprot.readFieldBegin()
12564 
      if ftype == TType.STOP:
12565 
        break
12566 
      if fid == 1:
12567 
        if ftype == TType.LIST:
12568 
          self.order_ids = []
6188 rajveer 12569 
          (_etype214, _size211) = iprot.readListBegin()
12570 
          for _i215 in xrange(_size211):
12571 
            _elem216 = iprot.readI64();
12572 
            self.order_ids.append(_elem216)
4999 phani.kuma 12573 
          iprot.readListEnd()
12574 
        else:
12575 
          iprot.skip(ftype)
12576 
      else:
12577 
        iprot.skip(ftype)
12578 
      iprot.readFieldEnd()
12579 
    iprot.readStructEnd()
12580 
 
12581 
  def write(self, oprot):
12582 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12583 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12584 
      return
12585 
    oprot.writeStructBegin('getOrderList_args')
12586 
    if self.order_ids is not None:
12587 
      oprot.writeFieldBegin('order_ids', TType.LIST, 1)
12588 
      oprot.writeListBegin(TType.I64, len(self.order_ids))
6188 rajveer 12589 
      for iter217 in self.order_ids:
12590 
        oprot.writeI64(iter217)
4999 phani.kuma 12591 
      oprot.writeListEnd()
12592 
      oprot.writeFieldEnd()
12593 
    oprot.writeFieldStop()
12594 
    oprot.writeStructEnd()
12595 
 
12596 
  def validate(self):
12597 
    return
12598 
 
12599 
 
12600 
  def __repr__(self):
12601 
    L = ['%s=%r' % (key, value)
12602 
      for key, value in self.__dict__.iteritems()]
12603 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12604 
 
12605 
  def __eq__(self, other):
12606 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12607 
 
12608 
  def __ne__(self, other):
12609 
    return not (self == other)
12610 
 
12611 
class getOrderList_result:
12612 
  """
12613 
  Attributes:
12614 
   - success
12615 
  """
12616 
 
12617 
  thrift_spec = (
12618 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
12619 
  )
12620 
 
12621 
  def __init__(self, success=None,):
12622 
    self.success = success
12623 
 
12624 
  def read(self, iprot):
12625 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12626 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12627 
      return
12628 
    iprot.readStructBegin()
12629 
    while True:
12630 
      (fname, ftype, fid) = iprot.readFieldBegin()
12631 
      if ftype == TType.STOP:
12632 
        break
12633 
      if fid == 0:
12634 
        if ftype == TType.LIST:
12635 
          self.success = []
6188 rajveer 12636 
          (_etype221, _size218) = iprot.readListBegin()
12637 
          for _i222 in xrange(_size218):
12638 
            _elem223 = Order()
12639 
            _elem223.read(iprot)
12640 
            self.success.append(_elem223)
4999 phani.kuma 12641 
          iprot.readListEnd()
12642 
        else:
12643 
          iprot.skip(ftype)
12644 
      else:
12645 
        iprot.skip(ftype)
12646 
      iprot.readFieldEnd()
12647 
    iprot.readStructEnd()
12648 
 
12649 
  def write(self, oprot):
12650 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12651 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12652 
      return
12653 
    oprot.writeStructBegin('getOrderList_result')
12654 
    if self.success is not None:
12655 
      oprot.writeFieldBegin('success', TType.LIST, 0)
12656 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 12657 
      for iter224 in self.success:
12658 
        iter224.write(oprot)
4999 phani.kuma 12659 
      oprot.writeListEnd()
12660 
      oprot.writeFieldEnd()
12661 
    oprot.writeFieldStop()
12662 
    oprot.writeStructEnd()
12663 
 
12664 
  def validate(self):
12665 
    return
12666 
 
12667 
 
12668 
  def __repr__(self):
12669 
    L = ['%s=%r' % (key, value)
12670 
      for key, value in self.__dict__.iteritems()]
12671 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12672 
 
12673 
  def __eq__(self, other):
12674 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12675 
 
12676 
  def __ne__(self, other):
12677 
    return not (self == other)
12678 
 
5386 phani.kuma 12679 
class getOrderListForVendor_args:
12680 
  """
12681 
  Attributes:
12682 
   - order_ids
12683 
   - vendorId
12684 
  """
12685 
 
12686 
  thrift_spec = (
12687 
    None, # 0
12688 
    (1, TType.LIST, 'order_ids', (TType.I64,None), None, ), # 1
12689 
    (2, TType.I64, 'vendorId', None, None, ), # 2
12690 
  )
12691 
 
12692 
  def __init__(self, order_ids=None, vendorId=None,):
12693 
    self.order_ids = order_ids
12694 
    self.vendorId = vendorId
12695 
 
12696 
  def read(self, iprot):
12697 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12698 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12699 
      return
12700 
    iprot.readStructBegin()
12701 
    while True:
12702 
      (fname, ftype, fid) = iprot.readFieldBegin()
12703 
      if ftype == TType.STOP:
12704 
        break
12705 
      if fid == 1:
12706 
        if ftype == TType.LIST:
12707 
          self.order_ids = []
6188 rajveer 12708 
          (_etype228, _size225) = iprot.readListBegin()
12709 
          for _i229 in xrange(_size225):
12710 
            _elem230 = iprot.readI64();
12711 
            self.order_ids.append(_elem230)
5386 phani.kuma 12712 
          iprot.readListEnd()
12713 
        else:
12714 
          iprot.skip(ftype)
12715 
      elif fid == 2:
12716 
        if ftype == TType.I64:
12717 
          self.vendorId = iprot.readI64();
12718 
        else:
12719 
          iprot.skip(ftype)
12720 
      else:
12721 
        iprot.skip(ftype)
12722 
      iprot.readFieldEnd()
12723 
    iprot.readStructEnd()
12724 
 
12725 
  def write(self, oprot):
12726 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12727 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12728 
      return
12729 
    oprot.writeStructBegin('getOrderListForVendor_args')
12730 
    if self.order_ids is not None:
12731 
      oprot.writeFieldBegin('order_ids', TType.LIST, 1)
12732 
      oprot.writeListBegin(TType.I64, len(self.order_ids))
6188 rajveer 12733 
      for iter231 in self.order_ids:
12734 
        oprot.writeI64(iter231)
5386 phani.kuma 12735 
      oprot.writeListEnd()
12736 
      oprot.writeFieldEnd()
12737 
    if self.vendorId is not None:
12738 
      oprot.writeFieldBegin('vendorId', TType.I64, 2)
12739 
      oprot.writeI64(self.vendorId)
12740 
      oprot.writeFieldEnd()
12741 
    oprot.writeFieldStop()
12742 
    oprot.writeStructEnd()
12743 
 
12744 
  def validate(self):
12745 
    return
12746 
 
12747 
 
12748 
  def __repr__(self):
12749 
    L = ['%s=%r' % (key, value)
12750 
      for key, value in self.__dict__.iteritems()]
12751 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12752 
 
12753 
  def __eq__(self, other):
12754 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12755 
 
12756 
  def __ne__(self, other):
12757 
    return not (self == other)
12758 
 
12759 
class getOrderListForVendor_result:
12760 
  """
12761 
  Attributes:
12762 
   - success
12763 
  """
12764 
 
12765 
  thrift_spec = (
12766 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
12767 
  )
12768 
 
12769 
  def __init__(self, success=None,):
12770 
    self.success = success
12771 
 
12772 
  def read(self, iprot):
12773 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12774 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12775 
      return
12776 
    iprot.readStructBegin()
12777 
    while True:
12778 
      (fname, ftype, fid) = iprot.readFieldBegin()
12779 
      if ftype == TType.STOP:
12780 
        break
12781 
      if fid == 0:
12782 
        if ftype == TType.LIST:
12783 
          self.success = []
6188 rajveer 12784 
          (_etype235, _size232) = iprot.readListBegin()
12785 
          for _i236 in xrange(_size232):
12786 
            _elem237 = Order()
12787 
            _elem237.read(iprot)
12788 
            self.success.append(_elem237)
5386 phani.kuma 12789 
          iprot.readListEnd()
12790 
        else:
12791 
          iprot.skip(ftype)
12792 
      else:
12793 
        iprot.skip(ftype)
12794 
      iprot.readFieldEnd()
12795 
    iprot.readStructEnd()
12796 
 
12797 
  def write(self, oprot):
12798 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12799 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12800 
      return
12801 
    oprot.writeStructBegin('getOrderListForVendor_result')
12802 
    if self.success is not None:
12803 
      oprot.writeFieldBegin('success', TType.LIST, 0)
12804 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 12805 
      for iter238 in self.success:
12806 
        iter238.write(oprot)
5386 phani.kuma 12807 
      oprot.writeListEnd()
12808 
      oprot.writeFieldEnd()
12809 
    oprot.writeFieldStop()
12810 
    oprot.writeStructEnd()
12811 
 
12812 
  def validate(self):
12813 
    return
12814 
 
12815 
 
12816 
  def __repr__(self):
12817 
    L = ['%s=%r' % (key, value)
12818 
      for key, value in self.__dict__.iteritems()]
12819 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12820 
 
12821 
  def __eq__(self, other):
12822 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12823 
 
12824 
  def __ne__(self, other):
12825 
    return not (self == other)
12826 
 
3064 chandransh 12827 
class getOrderForCustomer_args:
94 ashish 12828 
  """
12829 
  Attributes:
3064 chandransh 12830 
   - orderId
483 rajveer 12831 
   - customerId
94 ashish 12832 
  """
12833 
 
12834 
  thrift_spec = (
12835 
    None, # 0
3064 chandransh 12836 
    (1, TType.I64, 'orderId', None, None, ), # 1
12837 
    (2, TType.I64, 'customerId', None, None, ), # 2
94 ashish 12838 
  )
12839 
 
3064 chandransh 12840 
  def __init__(self, orderId=None, customerId=None,):
12841 
    self.orderId = orderId
483 rajveer 12842 
    self.customerId = customerId
94 ashish 12843 
 
12844 
  def read(self, iprot):
12845 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12846 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12847 
      return
12848 
    iprot.readStructBegin()
12849 
    while True:
12850 
      (fname, ftype, fid) = iprot.readFieldBegin()
12851 
      if ftype == TType.STOP:
12852 
        break
12853 
      if fid == 1:
12854 
        if ftype == TType.I64:
3064 chandransh 12855 
          self.orderId = iprot.readI64();
94 ashish 12856 
        else:
12857 
          iprot.skip(ftype)
12858 
      elif fid == 2:
12859 
        if ftype == TType.I64:
3064 chandransh 12860 
          self.customerId = iprot.readI64();
94 ashish 12861 
        else:
12862 
          iprot.skip(ftype)
12863 
      else:
12864 
        iprot.skip(ftype)
12865 
      iprot.readFieldEnd()
12866 
    iprot.readStructEnd()
12867 
 
12868 
  def write(self, oprot):
12869 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12870 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12871 
      return
3064 chandransh 12872 
    oprot.writeStructBegin('getOrderForCustomer_args')
3431 rajveer 12873 
    if self.orderId is not None:
3064 chandransh 12874 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
12875 
      oprot.writeI64(self.orderId)
12876 
      oprot.writeFieldEnd()
3431 rajveer 12877 
    if self.customerId is not None:
3064 chandransh 12878 
      oprot.writeFieldBegin('customerId', TType.I64, 2)
483 rajveer 12879 
      oprot.writeI64(self.customerId)
94 ashish 12880 
      oprot.writeFieldEnd()
12881 
    oprot.writeFieldStop()
12882 
    oprot.writeStructEnd()
12883 
 
3431 rajveer 12884 
  def validate(self):
12885 
    return
12886 
 
12887 
 
94 ashish 12888 
  def __repr__(self):
12889 
    L = ['%s=%r' % (key, value)
12890 
      for key, value in self.__dict__.iteritems()]
12891 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12892 
 
12893 
  def __eq__(self, other):
12894 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12895 
 
12896 
  def __ne__(self, other):
12897 
    return not (self == other)
12898 
 
3064 chandransh 12899 
class getOrderForCustomer_result:
94 ashish 12900 
  """
12901 
  Attributes:
12902 
   - success
12903 
   - ex
12904 
  """
12905 
 
12906 
  thrift_spec = (
3064 chandransh 12907 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
94 ashish 12908 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
12909 
  )
12910 
 
12911 
  def __init__(self, success=None, ex=None,):
12912 
    self.success = success
12913 
    self.ex = ex
12914 
 
12915 
  def read(self, iprot):
12916 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12917 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12918 
      return
12919 
    iprot.readStructBegin()
12920 
    while True:
12921 
      (fname, ftype, fid) = iprot.readFieldBegin()
12922 
      if ftype == TType.STOP:
12923 
        break
12924 
      if fid == 0:
3064 chandransh 12925 
        if ftype == TType.STRUCT:
12926 
          self.success = Order()
12927 
          self.success.read(iprot)
94 ashish 12928 
        else:
12929 
          iprot.skip(ftype)
12930 
      elif fid == 1:
12931 
        if ftype == TType.STRUCT:
12932 
          self.ex = TransactionServiceException()
12933 
          self.ex.read(iprot)
12934 
        else:
12935 
          iprot.skip(ftype)
12936 
      else:
12937 
        iprot.skip(ftype)
12938 
      iprot.readFieldEnd()
12939 
    iprot.readStructEnd()
12940 
 
12941 
  def write(self, oprot):
12942 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12943 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12944 
      return
3064 chandransh 12945 
    oprot.writeStructBegin('getOrderForCustomer_result')
3431 rajveer 12946 
    if self.success is not None:
3064 chandransh 12947 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
12948 
      self.success.write(oprot)
94 ashish 12949 
      oprot.writeFieldEnd()
3431 rajveer 12950 
    if self.ex is not None:
94 ashish 12951 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
12952 
      self.ex.write(oprot)
12953 
      oprot.writeFieldEnd()
12954 
    oprot.writeFieldStop()
12955 
    oprot.writeStructEnd()
12956 
 
3431 rajveer 12957 
  def validate(self):
12958 
    return
12959 
 
12960 
 
94 ashish 12961 
  def __repr__(self):
12962 
    L = ['%s=%r' % (key, value)
12963 
      for key, value in self.__dict__.iteritems()]
12964 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12965 
 
12966 
  def __eq__(self, other):
12967 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12968 
 
12969 
  def __ne__(self, other):
12970 
    return not (self == other)
12971 
 
3064 chandransh 12972 
class getAlerts_args:
94 ashish 12973 
  """
12974 
  Attributes:
4394 rajveer 12975 
   - type
4444 rajveer 12976 
   - warehouseId
4394 rajveer 12977 
   - status
12978 
   - timestamp
94 ashish 12979 
  """
12980 
 
12981 
  thrift_spec = (
12982 
    None, # 0
4394 rajveer 12983 
    (1, TType.I64, 'type', None, None, ), # 1
4444 rajveer 12984 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
12985 
    (3, TType.I64, 'status', None, None, ), # 3
12986 
    (4, TType.I64, 'timestamp', None, None, ), # 4
94 ashish 12987 
  )
12988 
 
4444 rajveer 12989 
  def __init__(self, type=None, warehouseId=None, status=None, timestamp=None,):
4394 rajveer 12990 
    self.type = type
4444 rajveer 12991 
    self.warehouseId = warehouseId
4394 rajveer 12992 
    self.status = status
12993 
    self.timestamp = timestamp
94 ashish 12994 
 
12995 
  def read(self, iprot):
12996 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12997 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12998 
      return
12999 
    iprot.readStructBegin()
13000 
    while True:
13001 
      (fname, ftype, fid) = iprot.readFieldBegin()
13002 
      if ftype == TType.STOP:
13003 
        break
13004 
      if fid == 1:
3064 chandransh 13005 
        if ftype == TType.I64:
4394 rajveer 13006 
          self.type = iprot.readI64();
94 ashish 13007 
        else:
13008 
          iprot.skip(ftype)
3064 chandransh 13009 
      elif fid == 2:
4394 rajveer 13010 
        if ftype == TType.I64:
4444 rajveer 13011 
          self.warehouseId = iprot.readI64();
3064 chandransh 13012 
        else:
13013 
          iprot.skip(ftype)
4394 rajveer 13014 
      elif fid == 3:
13015 
        if ftype == TType.I64:
4444 rajveer 13016 
          self.status = iprot.readI64();
13017 
        else:
13018 
          iprot.skip(ftype)
13019 
      elif fid == 4:
13020 
        if ftype == TType.I64:
4394 rajveer 13021 
          self.timestamp = iprot.readI64();
13022 
        else:
13023 
          iprot.skip(ftype)
94 ashish 13024 
      else:
13025 
        iprot.skip(ftype)
13026 
      iprot.readFieldEnd()
13027 
    iprot.readStructEnd()
13028 
 
13029 
  def write(self, oprot):
13030 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13031 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13032 
      return
3064 chandransh 13033 
    oprot.writeStructBegin('getAlerts_args')
4394 rajveer 13034 
    if self.type is not None:
13035 
      oprot.writeFieldBegin('type', TType.I64, 1)
13036 
      oprot.writeI64(self.type)
94 ashish 13037 
      oprot.writeFieldEnd()
4444 rajveer 13038 
    if self.warehouseId is not None:
13039 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
13040 
      oprot.writeI64(self.warehouseId)
13041 
      oprot.writeFieldEnd()
4394 rajveer 13042 
    if self.status is not None:
4444 rajveer 13043 
      oprot.writeFieldBegin('status', TType.I64, 3)
4394 rajveer 13044 
      oprot.writeI64(self.status)
3064 chandransh 13045 
      oprot.writeFieldEnd()
4394 rajveer 13046 
    if self.timestamp is not None:
4444 rajveer 13047 
      oprot.writeFieldBegin('timestamp', TType.I64, 4)
4394 rajveer 13048 
      oprot.writeI64(self.timestamp)
13049 
      oprot.writeFieldEnd()
94 ashish 13050 
    oprot.writeFieldStop()
13051 
    oprot.writeStructEnd()
13052 
 
3431 rajveer 13053 
  def validate(self):
13054 
    return
13055 
 
13056 
 
94 ashish 13057 
  def __repr__(self):
13058 
    L = ['%s=%r' % (key, value)
13059 
      for key, value in self.__dict__.iteritems()]
13060 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13061 
 
13062 
  def __eq__(self, other):
13063 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13064 
 
13065 
  def __ne__(self, other):
13066 
    return not (self == other)
13067 
 
3064 chandransh 13068 
class getAlerts_result:
94 ashish 13069 
  """
13070 
  Attributes:
13071 
   - success
13072 
  """
13073 
 
13074 
  thrift_spec = (
3064 chandransh 13075 
    (0, TType.LIST, 'success', (TType.STRUCT,(Alert, Alert.thrift_spec)), None, ), # 0
94 ashish 13076 
  )
13077 
 
3064 chandransh 13078 
  def __init__(self, success=None,):
94 ashish 13079 
    self.success = success
13080 
 
13081 
  def read(self, iprot):
13082 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13083 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13084 
      return
13085 
    iprot.readStructBegin()
13086 
    while True:
13087 
      (fname, ftype, fid) = iprot.readFieldBegin()
13088 
      if ftype == TType.STOP:
13089 
        break
13090 
      if fid == 0:
3064 chandransh 13091 
        if ftype == TType.LIST:
13092 
          self.success = []
6188 rajveer 13093 
          (_etype242, _size239) = iprot.readListBegin()
13094 
          for _i243 in xrange(_size239):
13095 
            _elem244 = Alert()
13096 
            _elem244.read(iprot)
13097 
            self.success.append(_elem244)
3064 chandransh 13098 
          iprot.readListEnd()
94 ashish 13099 
        else:
13100 
          iprot.skip(ftype)
13101 
      else:
13102 
        iprot.skip(ftype)
13103 
      iprot.readFieldEnd()
13104 
    iprot.readStructEnd()
13105 
 
13106 
  def write(self, oprot):
13107 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13108 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13109 
      return
3064 chandransh 13110 
    oprot.writeStructBegin('getAlerts_result')
3431 rajveer 13111 
    if self.success is not None:
3064 chandransh 13112 
      oprot.writeFieldBegin('success', TType.LIST, 0)
13113 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 13114 
      for iter245 in self.success:
13115 
        iter245.write(oprot)
3064 chandransh 13116 
      oprot.writeListEnd()
94 ashish 13117 
      oprot.writeFieldEnd()
13118 
    oprot.writeFieldStop()
13119 
    oprot.writeStructEnd()
13120 
 
3431 rajveer 13121 
  def validate(self):
13122 
    return
13123 
 
13124 
 
94 ashish 13125 
  def __repr__(self):
13126 
    L = ['%s=%r' % (key, value)
13127 
      for key, value in self.__dict__.iteritems()]
13128 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13129 
 
13130 
  def __eq__(self, other):
13131 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13132 
 
13133 
  def __ne__(self, other):
13134 
    return not (self == other)
13135 
 
4394 rajveer 13136 
class addAlert_args:
94 ashish 13137 
  """
13138 
  Attributes:
3064 chandransh 13139 
   - type
4444 rajveer 13140 
   - warehouseId
4394 rajveer 13141 
   - description
94 ashish 13142 
  """
13143 
 
13144 
  thrift_spec = (
13145 
    None, # 0
4394 rajveer 13146 
    (1, TType.I64, 'type', None, None, ), # 1
4444 rajveer 13147 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
13148 
    (3, TType.STRING, 'description', None, None, ), # 3
94 ashish 13149 
  )
13150 
 
4444 rajveer 13151 
  def __init__(self, type=None, warehouseId=None, description=None,):
3064 chandransh 13152 
    self.type = type
4444 rajveer 13153 
    self.warehouseId = warehouseId
4394 rajveer 13154 
    self.description = description
94 ashish 13155 
 
13156 
  def read(self, iprot):
13157 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13158 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13159 
      return
13160 
    iprot.readStructBegin()
13161 
    while True:
13162 
      (fname, ftype, fid) = iprot.readFieldBegin()
13163 
      if ftype == TType.STOP:
13164 
        break
13165 
      if fid == 1:
13166 
        if ftype == TType.I64:
4394 rajveer 13167 
          self.type = iprot.readI64();
94 ashish 13168 
        else:
13169 
          iprot.skip(ftype)
3064 chandransh 13170 
      elif fid == 2:
4444 rajveer 13171 
        if ftype == TType.I64:
13172 
          self.warehouseId = iprot.readI64();
13173 
        else:
13174 
          iprot.skip(ftype)
13175 
      elif fid == 3:
3064 chandransh 13176 
        if ftype == TType.STRING:
4394 rajveer 13177 
          self.description = iprot.readString();
3064 chandransh 13178 
        else:
13179 
          iprot.skip(ftype)
94 ashish 13180 
      else:
13181 
        iprot.skip(ftype)
13182 
      iprot.readFieldEnd()
13183 
    iprot.readStructEnd()
13184 
 
13185 
  def write(self, oprot):
13186 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13187 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13188 
      return
4394 rajveer 13189 
    oprot.writeStructBegin('addAlert_args')
3431 rajveer 13190 
    if self.type is not None:
4394 rajveer 13191 
      oprot.writeFieldBegin('type', TType.I64, 1)
3064 chandransh 13192 
      oprot.writeI64(self.type)
13193 
      oprot.writeFieldEnd()
4444 rajveer 13194 
    if self.warehouseId is not None:
13195 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
13196 
      oprot.writeI64(self.warehouseId)
13197 
      oprot.writeFieldEnd()
4394 rajveer 13198 
    if self.description is not None:
4444 rajveer 13199 
      oprot.writeFieldBegin('description', TType.STRING, 3)
4394 rajveer 13200 
      oprot.writeString(self.description)
3064 chandransh 13201 
      oprot.writeFieldEnd()
94 ashish 13202 
    oprot.writeFieldStop()
13203 
    oprot.writeStructEnd()
13204 
 
3431 rajveer 13205 
  def validate(self):
13206 
    return
13207 
 
13208 
 
94 ashish 13209 
  def __repr__(self):
13210 
    L = ['%s=%r' % (key, value)
13211 
      for key, value in self.__dict__.iteritems()]
13212 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13213 
 
13214 
  def __eq__(self, other):
13215 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13216 
 
13217 
  def __ne__(self, other):
13218 
    return not (self == other)
13219 
 
4394 rajveer 13220 
class addAlert_result:
3064 chandransh 13221 
 
13222 
  thrift_spec = (
13223 
  )
13224 
 
13225 
  def read(self, iprot):
13226 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13227 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13228 
      return
13229 
    iprot.readStructBegin()
13230 
    while True:
13231 
      (fname, ftype, fid) = iprot.readFieldBegin()
13232 
      if ftype == TType.STOP:
13233 
        break
13234 
      else:
13235 
        iprot.skip(ftype)
13236 
      iprot.readFieldEnd()
13237 
    iprot.readStructEnd()
13238 
 
13239 
  def write(self, oprot):
13240 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13241 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13242 
      return
4394 rajveer 13243 
    oprot.writeStructBegin('addAlert_result')
3064 chandransh 13244 
    oprot.writeFieldStop()
13245 
    oprot.writeStructEnd()
13246 
 
3431 rajveer 13247 
  def validate(self):
13248 
    return
13249 
 
13250 
 
3064 chandransh 13251 
  def __repr__(self):
13252 
    L = ['%s=%r' % (key, value)
13253 
      for key, value in self.__dict__.iteritems()]
13254 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13255 
 
13256 
  def __eq__(self, other):
13257 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13258 
 
13259 
  def __ne__(self, other):
13260 
    return not (self == other)
13261 
 
4444 rajveer 13262 
class markAlertsAsSeen_args:
13263 
  """
13264 
  Attributes:
13265 
   - warehouseId
13266 
  """
13267 
 
13268 
  thrift_spec = (
13269 
    None, # 0
13270 
    (1, TType.I64, 'warehouseId', None, None, ), # 1
13271 
  )
13272 
 
13273 
  def __init__(self, warehouseId=None,):
13274 
    self.warehouseId = warehouseId
13275 
 
13276 
  def read(self, iprot):
13277 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13278 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13279 
      return
13280 
    iprot.readStructBegin()
13281 
    while True:
13282 
      (fname, ftype, fid) = iprot.readFieldBegin()
13283 
      if ftype == TType.STOP:
13284 
        break
13285 
      if fid == 1:
13286 
        if ftype == TType.I64:
13287 
          self.warehouseId = iprot.readI64();
13288 
        else:
13289 
          iprot.skip(ftype)
13290 
      else:
13291 
        iprot.skip(ftype)
13292 
      iprot.readFieldEnd()
13293 
    iprot.readStructEnd()
13294 
 
13295 
  def write(self, oprot):
13296 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13297 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13298 
      return
13299 
    oprot.writeStructBegin('markAlertsAsSeen_args')
13300 
    if self.warehouseId is not None:
13301 
      oprot.writeFieldBegin('warehouseId', TType.I64, 1)
13302 
      oprot.writeI64(self.warehouseId)
13303 
      oprot.writeFieldEnd()
13304 
    oprot.writeFieldStop()
13305 
    oprot.writeStructEnd()
13306 
 
13307 
  def validate(self):
13308 
    return
13309 
 
13310 
 
13311 
  def __repr__(self):
13312 
    L = ['%s=%r' % (key, value)
13313 
      for key, value in self.__dict__.iteritems()]
13314 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13315 
 
13316 
  def __eq__(self, other):
13317 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13318 
 
13319 
  def __ne__(self, other):
13320 
    return not (self == other)
13321 
 
13322 
class markAlertsAsSeen_result:
13323 
 
13324 
  thrift_spec = (
13325 
  )
13326 
 
13327 
  def read(self, iprot):
13328 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13329 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13330 
      return
13331 
    iprot.readStructBegin()
13332 
    while True:
13333 
      (fname, ftype, fid) = iprot.readFieldBegin()
13334 
      if ftype == TType.STOP:
13335 
        break
13336 
      else:
13337 
        iprot.skip(ftype)
13338 
      iprot.readFieldEnd()
13339 
    iprot.readStructEnd()
13340 
 
13341 
  def write(self, oprot):
13342 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13343 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13344 
      return
13345 
    oprot.writeStructBegin('markAlertsAsSeen_result')
13346 
    oprot.writeFieldStop()
13347 
    oprot.writeStructEnd()
13348 
 
13349 
  def validate(self):
13350 
    return
13351 
 
13352 
 
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 getValidOrderCount_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('getValidOrderCount_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 getValidOrderCount_result:
94 ashish 13407 
  """
13408 
  Attributes:
13409 
   - success
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,):
94 ashish 13417 
    self.success = success
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
13428 
      if fid == 0:
3064 chandransh 13429 
        if ftype == TType.I64:
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('getValidOrderCount_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 getNoOfCustomersWithSuccessfulTransaction_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('getNoOfCustomersWithSuccessfulTransaction_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 getNoOfCustomersWithSuccessfulTransaction_result:
94 ashish 13508 
  """
13509 
  Attributes:
3064 chandransh 13510 
   - success
94 ashish 13511 
  """
13512 
 
13513 
  thrift_spec = (
3064 chandransh 13514 
    (0, TType.I64, 'success', None, None, ), # 0
94 ashish 13515 
  )
13516 
 
3064 chandransh 13517 
  def __init__(self, success=None,):
13518 
    self.success = success
94 ashish 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
3064 chandransh 13529 
      if fid == 0:
94 ashish 13530 
        if ftype == TType.I64:
3064 chandransh 13531 
          self.success = iprot.readI64();
94 ashish 13532 
        else:
13533 
          iprot.skip(ftype)
13534 
      else:
13535 
        iprot.skip(ftype)
13536 
      iprot.readFieldEnd()
13537 
    iprot.readStructEnd()
13538 
 
13539 
  def write(self, oprot):
13540 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13541 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13542 
      return
3064 chandransh 13543 
    oprot.writeStructBegin('getNoOfCustomersWithSuccessfulTransaction_result')
3431 rajveer 13544 
    if self.success is not None:
3064 chandransh 13545 
      oprot.writeFieldBegin('success', TType.I64, 0)
13546 
      oprot.writeI64(self.success)
94 ashish 13547 
      oprot.writeFieldEnd()
13548 
    oprot.writeFieldStop()
13549 
    oprot.writeStructEnd()
13550 
 
3431 rajveer 13551 
  def validate(self):
13552 
    return
13553 
 
13554 
 
94 ashish 13555 
  def __repr__(self):
13556 
    L = ['%s=%r' % (key, value)
13557 
      for key, value in self.__dict__.iteritems()]
13558 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13559 
 
13560 
  def __eq__(self, other):
13561 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13562 
 
13563 
  def __ne__(self, other):
13564 
    return not (self == other)
13565 
 
3064 chandransh 13566 
class getValidOrdersAmountRange_args:
13567 
 
13568 
  thrift_spec = (
13569 
  )
13570 
 
13571 
  def read(self, iprot):
13572 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13573 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13574 
      return
13575 
    iprot.readStructBegin()
13576 
    while True:
13577 
      (fname, ftype, fid) = iprot.readFieldBegin()
13578 
      if ftype == TType.STOP:
13579 
        break
13580 
      else:
13581 
        iprot.skip(ftype)
13582 
      iprot.readFieldEnd()
13583 
    iprot.readStructEnd()
13584 
 
13585 
  def write(self, oprot):
13586 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13587 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13588 
      return
13589 
    oprot.writeStructBegin('getValidOrdersAmountRange_args')
13590 
    oprot.writeFieldStop()
13591 
    oprot.writeStructEnd()
13592 
 
3431 rajveer 13593 
  def validate(self):
13594 
    return
13595 
 
13596 
 
3064 chandransh 13597 
  def __repr__(self):
13598 
    L = ['%s=%r' % (key, value)
13599 
      for key, value in self.__dict__.iteritems()]
13600 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13601 
 
13602 
  def __eq__(self, other):
13603 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13604 
 
13605 
  def __ne__(self, other):
13606 
    return not (self == other)
13607 
 
13608 
class getValidOrdersAmountRange_result:
94 ashish 13609 
  """
13610 
  Attributes:
13611 
   - success
13612 
  """
13613 
 
13614 
  thrift_spec = (
3064 chandransh 13615 
    (0, TType.LIST, 'success', (TType.DOUBLE,None), None, ), # 0
94 ashish 13616 
  )
13617 
 
3064 chandransh 13618 
  def __init__(self, success=None,):
94 ashish 13619 
    self.success = success
13620 
 
13621 
  def read(self, iprot):
13622 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13623 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13624 
      return
13625 
    iprot.readStructBegin()
13626 
    while True:
13627 
      (fname, ftype, fid) = iprot.readFieldBegin()
13628 
      if ftype == TType.STOP:
13629 
        break
13630 
      if fid == 0:
483 rajveer 13631 
        if ftype == TType.LIST:
13632 
          self.success = []
6188 rajveer 13633 
          (_etype249, _size246) = iprot.readListBegin()
13634 
          for _i250 in xrange(_size246):
13635 
            _elem251 = iprot.readDouble();
13636 
            self.success.append(_elem251)
483 rajveer 13637 
          iprot.readListEnd()
94 ashish 13638 
        else:
13639 
          iprot.skip(ftype)
13640 
      else:
13641 
        iprot.skip(ftype)
13642 
      iprot.readFieldEnd()
13643 
    iprot.readStructEnd()
13644 
 
13645 
  def write(self, oprot):
13646 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13647 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13648 
      return
3064 chandransh 13649 
    oprot.writeStructBegin('getValidOrdersAmountRange_result')
3431 rajveer 13650 
    if self.success is not None:
483 rajveer 13651 
      oprot.writeFieldBegin('success', TType.LIST, 0)
3064 chandransh 13652 
      oprot.writeListBegin(TType.DOUBLE, len(self.success))
6188 rajveer 13653 
      for iter252 in self.success:
13654 
        oprot.writeDouble(iter252)
483 rajveer 13655 
      oprot.writeListEnd()
94 ashish 13656 
      oprot.writeFieldEnd()
13657 
    oprot.writeFieldStop()
13658 
    oprot.writeStructEnd()
13659 
 
3431 rajveer 13660 
  def validate(self):
13661 
    return
13662 
 
13663 
 
94 ashish 13664 
  def __repr__(self):
13665 
    L = ['%s=%r' % (key, value)
13666 
      for key, value in self.__dict__.iteritems()]
13667 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13668 
 
13669 
  def __eq__(self, other):
13670 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13671 
 
13672 
  def __ne__(self, other):
13673 
    return not (self == other)
13674 
 
3064 chandransh 13675 
class getValidOrders_args:
1528 ankur.sing 13676 
  """
13677 
  Attributes:
3064 chandransh 13678 
   - limit
5874 rajveer 13679 
   - onlyStore
1528 ankur.sing 13680 
  """
13681 
 
13682 
  thrift_spec = (
13683 
    None, # 0
3064 chandransh 13684 
    (1, TType.I64, 'limit', None, None, ), # 1
5874 rajveer 13685 
    (2, TType.BOOL, 'onlyStore', None, None, ), # 2
1528 ankur.sing 13686 
  )
13687 
 
5874 rajveer 13688 
  def __init__(self, limit=None, onlyStore=None,):
3064 chandransh 13689 
    self.limit = limit
5874 rajveer 13690 
    self.onlyStore = onlyStore
1528 ankur.sing 13691 
 
13692 
  def read(self, iprot):
13693 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13694 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13695 
      return
13696 
    iprot.readStructBegin()
13697 
    while True:
13698 
      (fname, ftype, fid) = iprot.readFieldBegin()
13699 
      if ftype == TType.STOP:
13700 
        break
13701 
      if fid == 1:
13702 
        if ftype == TType.I64:
3064 chandransh 13703 
          self.limit = iprot.readI64();
1528 ankur.sing 13704 
        else:
13705 
          iprot.skip(ftype)
5874 rajveer 13706 
      elif fid == 2:
13707 
        if ftype == TType.BOOL:
13708 
          self.onlyStore = iprot.readBool();
13709 
        else:
13710 
          iprot.skip(ftype)
1528 ankur.sing 13711 
      else:
13712 
        iprot.skip(ftype)
13713 
      iprot.readFieldEnd()
13714 
    iprot.readStructEnd()
13715 
 
13716 
  def write(self, oprot):
13717 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13718 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13719 
      return
3064 chandransh 13720 
    oprot.writeStructBegin('getValidOrders_args')
3431 rajveer 13721 
    if self.limit is not None:
3064 chandransh 13722 
      oprot.writeFieldBegin('limit', TType.I64, 1)
13723 
      oprot.writeI64(self.limit)
1528 ankur.sing 13724 
      oprot.writeFieldEnd()
5874 rajveer 13725 
    if self.onlyStore is not None:
13726 
      oprot.writeFieldBegin('onlyStore', TType.BOOL, 2)
13727 
      oprot.writeBool(self.onlyStore)
13728 
      oprot.writeFieldEnd()
1528 ankur.sing 13729 
    oprot.writeFieldStop()
13730 
    oprot.writeStructEnd()
13731 
 
3431 rajveer 13732 
  def validate(self):
13733 
    return
13734 
 
13735 
 
1528 ankur.sing 13736 
  def __repr__(self):
13737 
    L = ['%s=%r' % (key, value)
13738 
      for key, value in self.__dict__.iteritems()]
13739 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13740 
 
13741 
  def __eq__(self, other):
13742 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13743 
 
13744 
  def __ne__(self, other):
13745 
    return not (self == other)
13746 
 
3064 chandransh 13747 
class getValidOrders_result:
1528 ankur.sing 13748 
  """
13749 
  Attributes:
13750 
   - success
13751 
  """
13752 
 
13753 
  thrift_spec = (
3064 chandransh 13754 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
1528 ankur.sing 13755 
  )
13756 
 
3064 chandransh 13757 
  def __init__(self, success=None,):
1528 ankur.sing 13758 
    self.success = success
13759 
 
13760 
  def read(self, iprot):
13761 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13762 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13763 
      return
13764 
    iprot.readStructBegin()
13765 
    while True:
13766 
      (fname, ftype, fid) = iprot.readFieldBegin()
13767 
      if ftype == TType.STOP:
13768 
        break
13769 
      if fid == 0:
3064 chandransh 13770 
        if ftype == TType.LIST:
13771 
          self.success = []
6188 rajveer 13772 
          (_etype256, _size253) = iprot.readListBegin()
13773 
          for _i257 in xrange(_size253):
13774 
            _elem258 = Order()
13775 
            _elem258.read(iprot)
13776 
            self.success.append(_elem258)
3064 chandransh 13777 
          iprot.readListEnd()
1528 ankur.sing 13778 
        else:
13779 
          iprot.skip(ftype)
13780 
      else:
13781 
        iprot.skip(ftype)
13782 
      iprot.readFieldEnd()
13783 
    iprot.readStructEnd()
13784 
 
13785 
  def write(self, oprot):
13786 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13787 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13788 
      return
3064 chandransh 13789 
    oprot.writeStructBegin('getValidOrders_result')
3431 rajveer 13790 
    if self.success is not None:
3064 chandransh 13791 
      oprot.writeFieldBegin('success', TType.LIST, 0)
13792 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 13793 
      for iter259 in self.success:
13794 
        iter259.write(oprot)
3064 chandransh 13795 
      oprot.writeListEnd()
1528 ankur.sing 13796 
      oprot.writeFieldEnd()
13797 
    oprot.writeFieldStop()
13798 
    oprot.writeStructEnd()
13799 
 
3431 rajveer 13800 
  def validate(self):
13801 
    return
13802 
 
13803 
 
1528 ankur.sing 13804 
  def __repr__(self):
13805 
    L = ['%s=%r' % (key, value)
13806 
      for key, value in self.__dict__.iteritems()]
13807 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13808 
 
13809 
  def __eq__(self, other):
13810 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13811 
 
13812 
  def __ne__(self, other):
13813 
    return not (self == other)
13814 
 
1220 chandransh 13815 
class batchOrders_args:
13816 
  """
13817 
  Attributes:
13818 
   - warehouseId
13819 
  """
13820 
 
13821 
  thrift_spec = (
13822 
    None, # 0
13823 
    (1, TType.I64, 'warehouseId', None, None, ), # 1
13824 
  )
13825 
 
13826 
  def __init__(self, warehouseId=None,):
13827 
    self.warehouseId = warehouseId
13828 
 
13829 
  def read(self, iprot):
13830 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13831 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13832 
      return
13833 
    iprot.readStructBegin()
13834 
    while True:
13835 
      (fname, ftype, fid) = iprot.readFieldBegin()
13836 
      if ftype == TType.STOP:
13837 
        break
13838 
      if fid == 1:
13839 
        if ftype == TType.I64:
13840 
          self.warehouseId = iprot.readI64();
13841 
        else:
13842 
          iprot.skip(ftype)
13843 
      else:
13844 
        iprot.skip(ftype)
13845 
      iprot.readFieldEnd()
13846 
    iprot.readStructEnd()
13847 
 
13848 
  def write(self, oprot):
13849 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13850 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13851 
      return
13852 
    oprot.writeStructBegin('batchOrders_args')
3431 rajveer 13853 
    if self.warehouseId is not None:
1220 chandransh 13854 
      oprot.writeFieldBegin('warehouseId', TType.I64, 1)
13855 
      oprot.writeI64(self.warehouseId)
13856 
      oprot.writeFieldEnd()
13857 
    oprot.writeFieldStop()
13858 
    oprot.writeStructEnd()
13859 
 
3431 rajveer 13860 
  def validate(self):
13861 
    return
13862 
 
13863 
 
1220 chandransh 13864 
  def __repr__(self):
13865 
    L = ['%s=%r' % (key, value)
13866 
      for key, value in self.__dict__.iteritems()]
13867 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13868 
 
13869 
  def __eq__(self, other):
13870 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13871 
 
13872 
  def __ne__(self, other):
13873 
    return not (self == other)
13874 
 
13875 
class batchOrders_result:
13876 
  """
13877 
  Attributes:
13878 
   - success
13879 
   - ex
13880 
  """
13881 
 
13882 
  thrift_spec = (
13883 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
13884 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
13885 
  )
13886 
 
13887 
  def __init__(self, success=None, ex=None,):
13888 
    self.success = success
13889 
    self.ex = ex
13890 
 
13891 
  def read(self, iprot):
13892 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13893 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13894 
      return
13895 
    iprot.readStructBegin()
13896 
    while True:
13897 
      (fname, ftype, fid) = iprot.readFieldBegin()
13898 
      if ftype == TType.STOP:
13899 
        break
13900 
      if fid == 0:
13901 
        if ftype == TType.LIST:
13902 
          self.success = []
6188 rajveer 13903 
          (_etype263, _size260) = iprot.readListBegin()
13904 
          for _i264 in xrange(_size260):
13905 
            _elem265 = Order()
13906 
            _elem265.read(iprot)
13907 
            self.success.append(_elem265)
1220 chandransh 13908 
          iprot.readListEnd()
13909 
        else:
13910 
          iprot.skip(ftype)
13911 
      elif fid == 1:
13912 
        if ftype == TType.STRUCT:
13913 
          self.ex = TransactionServiceException()
13914 
          self.ex.read(iprot)
13915 
        else:
13916 
          iprot.skip(ftype)
13917 
      else:
13918 
        iprot.skip(ftype)
13919 
      iprot.readFieldEnd()
13920 
    iprot.readStructEnd()
13921 
 
13922 
  def write(self, oprot):
13923 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13924 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13925 
      return
13926 
    oprot.writeStructBegin('batchOrders_result')
3431 rajveer 13927 
    if self.success is not None:
1220 chandransh 13928 
      oprot.writeFieldBegin('success', TType.LIST, 0)
13929 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 13930 
      for iter266 in self.success:
13931 
        iter266.write(oprot)
1220 chandransh 13932 
      oprot.writeListEnd()
13933 
      oprot.writeFieldEnd()
3431 rajveer 13934 
    if self.ex is not None:
1220 chandransh 13935 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
13936 
      self.ex.write(oprot)
13937 
      oprot.writeFieldEnd()
13938 
    oprot.writeFieldStop()
13939 
    oprot.writeStructEnd()
13940 
 
3431 rajveer 13941 
  def validate(self):
13942 
    return
13943 
 
13944 
 
1220 chandransh 13945 
  def __repr__(self):
13946 
    L = ['%s=%r' % (key, value)
13947 
      for key, value in self.__dict__.iteritems()]
13948 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13949 
 
13950 
  def __eq__(self, other):
13951 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13952 
 
13953 
  def __ne__(self, other):
13954 
    return not (self == other)
13955 
 
1208 chandransh 13956 
class markOrderAsOutOfStock_args:
13957 
  """
13958 
  Attributes:
13959 
   - orderId
13960 
  """
13961 
 
13962 
  thrift_spec = (
13963 
    None, # 0
13964 
    (1, TType.I64, 'orderId', None, None, ), # 1
13965 
  )
13966 
 
13967 
  def __init__(self, orderId=None,):
13968 
    self.orderId = orderId
13969 
 
13970 
  def read(self, iprot):
13971 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13972 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13973 
      return
13974 
    iprot.readStructBegin()
13975 
    while True:
13976 
      (fname, ftype, fid) = iprot.readFieldBegin()
13977 
      if ftype == TType.STOP:
13978 
        break
13979 
      if fid == 1:
13980 
        if ftype == TType.I64:
13981 
          self.orderId = iprot.readI64();
13982 
        else:
13983 
          iprot.skip(ftype)
13984 
      else:
13985 
        iprot.skip(ftype)
13986 
      iprot.readFieldEnd()
13987 
    iprot.readStructEnd()
13988 
 
13989 
  def write(self, oprot):
13990 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13991 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13992 
      return
13993 
    oprot.writeStructBegin('markOrderAsOutOfStock_args')
3431 rajveer 13994 
    if self.orderId is not None:
1208 chandransh 13995 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
13996 
      oprot.writeI64(self.orderId)
13997 
      oprot.writeFieldEnd()
13998 
    oprot.writeFieldStop()
13999 
    oprot.writeStructEnd()
14000 
 
3431 rajveer 14001 
  def validate(self):
14002 
    return
14003 
 
14004 
 
1208 chandransh 14005 
  def __repr__(self):
14006 
    L = ['%s=%r' % (key, value)
14007 
      for key, value in self.__dict__.iteritems()]
14008 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14009 
 
14010 
  def __eq__(self, other):
14011 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14012 
 
14013 
  def __ne__(self, other):
14014 
    return not (self == other)
14015 
 
14016 
class markOrderAsOutOfStock_result:
14017 
  """
14018 
  Attributes:
14019 
   - success
14020 
   - ex
14021 
  """
14022 
 
14023 
  thrift_spec = (
14024 
    (0, TType.BOOL, 'success', None, None, ), # 0
14025 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
14026 
  )
14027 
 
14028 
  def __init__(self, success=None, ex=None,):
14029 
    self.success = success
14030 
    self.ex = ex
14031 
 
14032 
  def read(self, iprot):
14033 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14034 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14035 
      return
14036 
    iprot.readStructBegin()
14037 
    while True:
14038 
      (fname, ftype, fid) = iprot.readFieldBegin()
14039 
      if ftype == TType.STOP:
14040 
        break
14041 
      if fid == 0:
14042 
        if ftype == TType.BOOL:
14043 
          self.success = iprot.readBool();
14044 
        else:
14045 
          iprot.skip(ftype)
14046 
      elif fid == 1:
14047 
        if ftype == TType.STRUCT:
14048 
          self.ex = TransactionServiceException()
14049 
          self.ex.read(iprot)
14050 
        else:
14051 
          iprot.skip(ftype)
14052 
      else:
14053 
        iprot.skip(ftype)
14054 
      iprot.readFieldEnd()
14055 
    iprot.readStructEnd()
14056 
 
14057 
  def write(self, oprot):
14058 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14059 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14060 
      return
14061 
    oprot.writeStructBegin('markOrderAsOutOfStock_result')
3431 rajveer 14062 
    if self.success is not None:
1208 chandransh 14063 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
14064 
      oprot.writeBool(self.success)
14065 
      oprot.writeFieldEnd()
3431 rajveer 14066 
    if self.ex is not None:
1208 chandransh 14067 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
14068 
      self.ex.write(oprot)
14069 
      oprot.writeFieldEnd()
14070 
    oprot.writeFieldStop()
14071 
    oprot.writeStructEnd()
14072 
 
3431 rajveer 14073 
  def validate(self):
14074 
    return
14075 
 
14076 
 
1208 chandransh 14077 
  def __repr__(self):
14078 
    L = ['%s=%r' % (key, value)
14079 
      for key, value in self.__dict__.iteritems()]
14080 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14081 
 
14082 
  def __eq__(self, other):
14083 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14084 
 
14085 
  def __ne__(self, other):
14086 
    return not (self == other)
14087 
 
3064 chandransh 14088 
class verifyOrder_args:
759 chandransh 14089 
  """
14090 
  Attributes:
3064 chandransh 14091 
   - orderId
759 chandransh 14092 
  """
14093 
 
14094 
  thrift_spec = (
14095 
    None, # 0
3064 chandransh 14096 
    (1, TType.I64, 'orderId', None, None, ), # 1
759 chandransh 14097 
  )
14098 
 
3064 chandransh 14099 
  def __init__(self, orderId=None,):
14100 
    self.orderId = orderId
759 chandransh 14101 
 
14102 
  def read(self, iprot):
14103 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14104 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14105 
      return
14106 
    iprot.readStructBegin()
14107 
    while True:
14108 
      (fname, ftype, fid) = iprot.readFieldBegin()
14109 
      if ftype == TType.STOP:
14110 
        break
14111 
      if fid == 1:
14112 
        if ftype == TType.I64:
3064 chandransh 14113 
          self.orderId = iprot.readI64();
759 chandransh 14114 
        else:
14115 
          iprot.skip(ftype)
14116 
      else:
14117 
        iprot.skip(ftype)
14118 
      iprot.readFieldEnd()
14119 
    iprot.readStructEnd()
14120 
 
14121 
  def write(self, oprot):
14122 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14123 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14124 
      return
3064 chandransh 14125 
    oprot.writeStructBegin('verifyOrder_args')
3431 rajveer 14126 
    if self.orderId is not None:
3064 chandransh 14127 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
14128 
      oprot.writeI64(self.orderId)
759 chandransh 14129 
      oprot.writeFieldEnd()
14130 
    oprot.writeFieldStop()
14131 
    oprot.writeStructEnd()
14132 
 
3431 rajveer 14133 
  def validate(self):
14134 
    return
14135 
 
14136 
 
759 chandransh 14137 
  def __repr__(self):
14138 
    L = ['%s=%r' % (key, value)
14139 
      for key, value in self.__dict__.iteritems()]
14140 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14141 
 
14142 
  def __eq__(self, other):
14143 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14144 
 
14145 
  def __ne__(self, other):
14146 
    return not (self == other)
14147 
 
3064 chandransh 14148 
class verifyOrder_result:
759 chandransh 14149 
  """
14150 
  Attributes:
14151 
   - success
14152 
   - ex
14153 
  """
14154 
 
14155 
  thrift_spec = (
14156 
    (0, TType.BOOL, 'success', None, None, ), # 0
14157 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
14158 
  )
14159 
 
14160 
  def __init__(self, success=None, ex=None,):
14161 
    self.success = success
14162 
    self.ex = ex
14163 
 
14164 
  def read(self, iprot):
14165 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14166 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14167 
      return
14168 
    iprot.readStructBegin()
14169 
    while True:
14170 
      (fname, ftype, fid) = iprot.readFieldBegin()
14171 
      if ftype == TType.STOP:
14172 
        break
14173 
      if fid == 0:
14174 
        if ftype == TType.BOOL:
14175 
          self.success = iprot.readBool();
14176 
        else:
14177 
          iprot.skip(ftype)
14178 
      elif fid == 1:
14179 
        if ftype == TType.STRUCT:
14180 
          self.ex = TransactionServiceException()
14181 
          self.ex.read(iprot)
14182 
        else:
14183 
          iprot.skip(ftype)
14184 
      else:
14185 
        iprot.skip(ftype)
14186 
      iprot.readFieldEnd()
14187 
    iprot.readStructEnd()
14188 
 
14189 
  def write(self, oprot):
14190 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14191 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14192 
      return
3064 chandransh 14193 
    oprot.writeStructBegin('verifyOrder_result')
3431 rajveer 14194 
    if self.success is not None:
759 chandransh 14195 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
14196 
      oprot.writeBool(self.success)
14197 
      oprot.writeFieldEnd()
3431 rajveer 14198 
    if self.ex is not None:
759 chandransh 14199 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
14200 
      self.ex.write(oprot)
14201 
      oprot.writeFieldEnd()
14202 
    oprot.writeFieldStop()
14203 
    oprot.writeStructEnd()
14204 
 
3431 rajveer 14205 
  def validate(self):
14206 
    return
14207 
 
14208 
 
759 chandransh 14209 
  def __repr__(self):
14210 
    L = ['%s=%r' % (key, value)
14211 
      for key, value in self.__dict__.iteritems()]
14212 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14213 
 
14214 
  def __eq__(self, other):
14215 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14216 
 
14217 
  def __ne__(self, other):
14218 
    return not (self == other)
14219 
 
3064 chandransh 14220 
class acceptOrder_args:
1113 chandransh 14221 
  """
14222 
  Attributes:
3064 chandransh 14223 
   - orderId
1113 chandransh 14224 
  """
14225 
 
14226 
  thrift_spec = (
14227 
    None, # 0
3064 chandransh 14228 
    (1, TType.I64, 'orderId', None, None, ), # 1
1113 chandransh 14229 
  )
14230 
 
3064 chandransh 14231 
  def __init__(self, orderId=None,):
14232 
    self.orderId = orderId
1113 chandransh 14233 
 
14234 
  def read(self, iprot):
14235 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14236 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14237 
      return
14238 
    iprot.readStructBegin()
14239 
    while True:
14240 
      (fname, ftype, fid) = iprot.readFieldBegin()
14241 
      if ftype == TType.STOP:
14242 
        break
14243 
      if fid == 1:
14244 
        if ftype == TType.I64:
3064 chandransh 14245 
          self.orderId = iprot.readI64();
1113 chandransh 14246 
        else:
14247 
          iprot.skip(ftype)
14248 
      else:
14249 
        iprot.skip(ftype)
14250 
      iprot.readFieldEnd()
14251 
    iprot.readStructEnd()
14252 
 
14253 
  def write(self, oprot):
14254 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14255 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14256 
      return
3064 chandransh 14257 
    oprot.writeStructBegin('acceptOrder_args')
3431 rajveer 14258 
    if self.orderId is not None:
3064 chandransh 14259 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
14260 
      oprot.writeI64(self.orderId)
1113 chandransh 14261 
      oprot.writeFieldEnd()
14262 
    oprot.writeFieldStop()
14263 
    oprot.writeStructEnd()
14264 
 
3431 rajveer 14265 
  def validate(self):
14266 
    return
14267 
 
14268 
 
1113 chandransh 14269 
  def __repr__(self):
14270 
    L = ['%s=%r' % (key, value)
14271 
      for key, value in self.__dict__.iteritems()]
14272 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14273 
 
14274 
  def __eq__(self, other):
14275 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14276 
 
14277 
  def __ne__(self, other):
14278 
    return not (self == other)
14279 
 
3064 chandransh 14280 
class acceptOrder_result:
1113 chandransh 14281 
  """
14282 
  Attributes:
14283 
   - success
14284 
   - ex
14285 
  """
14286 
 
14287 
  thrift_spec = (
3064 chandransh 14288 
    (0, TType.BOOL, 'success', None, None, ), # 0
1113 chandransh 14289 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
14290 
  )
14291 
 
14292 
  def __init__(self, success=None, ex=None,):
14293 
    self.success = success
14294 
    self.ex = ex
14295 
 
14296 
  def read(self, iprot):
14297 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14298 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14299 
      return
14300 
    iprot.readStructBegin()
14301 
    while True:
14302 
      (fname, ftype, fid) = iprot.readFieldBegin()
14303 
      if ftype == TType.STOP:
14304 
        break
14305 
      if fid == 0:
3064 chandransh 14306 
        if ftype == TType.BOOL:
14307 
          self.success = iprot.readBool();
1113 chandransh 14308 
        else:
14309 
          iprot.skip(ftype)
14310 
      elif fid == 1:
14311 
        if ftype == TType.STRUCT:
14312 
          self.ex = TransactionServiceException()
14313 
          self.ex.read(iprot)
14314 
        else:
14315 
          iprot.skip(ftype)
14316 
      else:
14317 
        iprot.skip(ftype)
14318 
      iprot.readFieldEnd()
14319 
    iprot.readStructEnd()
14320 
 
14321 
  def write(self, oprot):
14322 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14323 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14324 
      return
3064 chandransh 14325 
    oprot.writeStructBegin('acceptOrder_result')
3431 rajveer 14326 
    if self.success is not None:
3064 chandransh 14327 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
14328 
      oprot.writeBool(self.success)
1113 chandransh 14329 
      oprot.writeFieldEnd()
3431 rajveer 14330 
    if self.ex is not None:
1113 chandransh 14331 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
14332 
      self.ex.write(oprot)
14333 
      oprot.writeFieldEnd()
14334 
    oprot.writeFieldStop()
14335 
    oprot.writeStructEnd()
14336 
 
3431 rajveer 14337 
  def validate(self):
14338 
    return
14339 
 
14340 
 
1113 chandransh 14341 
  def __repr__(self):
14342 
    L = ['%s=%r' % (key, value)
14343 
      for key, value in self.__dict__.iteritems()]
14344 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14345 
 
14346 
  def __eq__(self, other):
14347 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14348 
 
14349 
  def __ne__(self, other):
14350 
    return not (self == other)
14351 
 
3064 chandransh 14352 
class addBillingDetails_args:
1135 chandransh 14353 
  """
14354 
  Attributes:
3064 chandransh 14355 
   - orderId
14356 
   - invoice_number
4658 mandeep.dh 14357 
   - serialNumber
4283 anupam.sin 14358 
   - itemNumber
3064 chandransh 14359 
   - billed_by
4264 rajveer 14360 
   - jacketNumber
4283 anupam.sin 14361 
   - billingType
5110 mandeep.dh 14362 
   - fulfilmentWarehouseId
4763 rajveer 14363 
   - authorize
1135 chandransh 14364 
  """
14365 
 
14366 
  thrift_spec = (
14367 
    None, # 0
3064 chandransh 14368 
    (1, TType.I64, 'orderId', None, None, ), # 1
14369 
    (2, TType.STRING, 'invoice_number', None, None, ), # 2
5411 rajveer 14370 
    (3, TType.LIST, 'serialNumber', (TType.STRING,None), None, ), # 3
14371 
    (4, TType.LIST, 'itemNumber', (TType.STRING,None), None, ), # 4
4283 anupam.sin 14372 
    (5, TType.STRING, 'billed_by', None, None, ), # 5
14373 
    (6, TType.I64, 'jacketNumber', None, None, ), # 6
14374 
    (7, TType.I64, 'billingType', None, None, ), # 7
5110 mandeep.dh 14375 
    (8, TType.I64, 'fulfilmentWarehouseId', None, None, ), # 8
4763 rajveer 14376 
    (9, TType.BOOL, 'authorize', None, None, ), # 9
1135 chandransh 14377 
  )
14378 
 
5110 mandeep.dh 14379 
  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 14380 
    self.orderId = orderId
14381 
    self.invoice_number = invoice_number
4658 mandeep.dh 14382 
    self.serialNumber = serialNumber
4283 anupam.sin 14383 
    self.itemNumber = itemNumber
3064 chandransh 14384 
    self.billed_by = billed_by
4264 rajveer 14385 
    self.jacketNumber = jacketNumber
4283 anupam.sin 14386 
    self.billingType = billingType
5110 mandeep.dh 14387 
    self.fulfilmentWarehouseId = fulfilmentWarehouseId
4763 rajveer 14388 
    self.authorize = authorize
1135 chandransh 14389 
 
14390 
  def read(self, iprot):
14391 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14392 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14393 
      return
14394 
    iprot.readStructBegin()
14395 
    while True:
14396 
      (fname, ftype, fid) = iprot.readFieldBegin()
14397 
      if ftype == TType.STOP:
14398 
        break
14399 
      if fid == 1:
14400 
        if ftype == TType.I64:
3064 chandransh 14401 
          self.orderId = iprot.readI64();
1135 chandransh 14402 
        else:
14403 
          iprot.skip(ftype)
14404 
      elif fid == 2:
3064 chandransh 14405 
        if ftype == TType.STRING:
14406 
          self.invoice_number = iprot.readString();
1135 chandransh 14407 
        else:
14408 
          iprot.skip(ftype)
3064 chandransh 14409 
      elif fid == 3:
5411 rajveer 14410 
        if ftype == TType.LIST:
14411 
          self.serialNumber = []
6188 rajveer 14412 
          (_etype270, _size267) = iprot.readListBegin()
14413 
          for _i271 in xrange(_size267):
14414 
            _elem272 = iprot.readString();
14415 
            self.serialNumber.append(_elem272)
5411 rajveer 14416 
          iprot.readListEnd()
3064 chandransh 14417 
        else:
14418 
          iprot.skip(ftype)
14419 
      elif fid == 4:
5411 rajveer 14420 
        if ftype == TType.LIST:
14421 
          self.itemNumber = []
6188 rajveer 14422 
          (_etype276, _size273) = iprot.readListBegin()
14423 
          for _i277 in xrange(_size273):
14424 
            _elem278 = iprot.readString();
14425 
            self.itemNumber.append(_elem278)
5411 rajveer 14426 
          iprot.readListEnd()
3064 chandransh 14427 
        else:
14428 
          iprot.skip(ftype)
14429 
      elif fid == 5:
14430 
        if ftype == TType.STRING:
4283 anupam.sin 14431 
          self.billed_by = iprot.readString();
3064 chandransh 14432 
        else:
14433 
          iprot.skip(ftype)
14434 
      elif fid == 6:
14435 
        if ftype == TType.I64:
4283 anupam.sin 14436 
          self.jacketNumber = iprot.readI64();
14437 
        else:
14438 
          iprot.skip(ftype)
14439 
      elif fid == 7:
14440 
        if ftype == TType.I64:
3064 chandransh 14441 
          self.billingType = iprot.readI64();
14442 
        else:
14443 
          iprot.skip(ftype)
4283 anupam.sin 14444 
      elif fid == 8:
14445 
        if ftype == TType.I64:
5110 mandeep.dh 14446 
          self.fulfilmentWarehouseId = iprot.readI64();
4283 anupam.sin 14447 
        else:
14448 
          iprot.skip(ftype)
4763 rajveer 14449 
      elif fid == 9:
14450 
        if ftype == TType.BOOL:
14451 
          self.authorize = iprot.readBool();
14452 
        else:
14453 
          iprot.skip(ftype)
1246 chandransh 14454 
      else:
14455 
        iprot.skip(ftype)
14456 
      iprot.readFieldEnd()
14457 
    iprot.readStructEnd()
14458 
 
14459 
  def write(self, oprot):
14460 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14461 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14462 
      return
4283 anupam.sin 14463 
    oprot.writeStructBegin('addBillingDetails_args')
3431 rajveer 14464 
    if self.orderId is not None:
3064 chandransh 14465 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
14466 
      oprot.writeI64(self.orderId)
1246 chandransh 14467 
      oprot.writeFieldEnd()
4283 anupam.sin 14468 
    if self.invoice_number is not None:
14469 
      oprot.writeFieldBegin('invoice_number', TType.STRING, 2)
14470 
      oprot.writeString(self.invoice_number)
1246 chandransh 14471 
      oprot.writeFieldEnd()
4658 mandeep.dh 14472 
    if self.serialNumber is not None:
5411 rajveer 14473 
      oprot.writeFieldBegin('serialNumber', TType.LIST, 3)
14474 
      oprot.writeListBegin(TType.STRING, len(self.serialNumber))
6188 rajveer 14475 
      for iter279 in self.serialNumber:
14476 
        oprot.writeString(iter279)
5411 rajveer 14477 
      oprot.writeListEnd()
3064 chandransh 14478 
      oprot.writeFieldEnd()
3431 rajveer 14479 
    if self.itemNumber is not None:
5411 rajveer 14480 
      oprot.writeFieldBegin('itemNumber', TType.LIST, 4)
14481 
      oprot.writeListBegin(TType.STRING, len(self.itemNumber))
6188 rajveer 14482 
      for iter280 in self.itemNumber:
14483 
        oprot.writeString(iter280)
5411 rajveer 14484 
      oprot.writeListEnd()
3064 chandransh 14485 
      oprot.writeFieldEnd()
4283 anupam.sin 14486 
    if self.billed_by is not None:
14487 
      oprot.writeFieldBegin('billed_by', TType.STRING, 5)
14488 
      oprot.writeString(self.billed_by)
3064 chandransh 14489 
      oprot.writeFieldEnd()
4283 anupam.sin 14490 
    if self.jacketNumber is not None:
14491 
      oprot.writeFieldBegin('jacketNumber', TType.I64, 6)
14492 
      oprot.writeI64(self.jacketNumber)
14493 
      oprot.writeFieldEnd()
3431 rajveer 14494 
    if self.billingType is not None:
4283 anupam.sin 14495 
      oprot.writeFieldBegin('billingType', TType.I64, 7)
3064 chandransh 14496 
      oprot.writeI64(self.billingType)
14497 
      oprot.writeFieldEnd()
5110 mandeep.dh 14498 
    if self.fulfilmentWarehouseId is not None:
14499 
      oprot.writeFieldBegin('fulfilmentWarehouseId', TType.I64, 8)
14500 
      oprot.writeI64(self.fulfilmentWarehouseId)
4283 anupam.sin 14501 
      oprot.writeFieldEnd()
4763 rajveer 14502 
    if self.authorize is not None:
14503 
      oprot.writeFieldBegin('authorize', TType.BOOL, 9)
14504 
      oprot.writeBool(self.authorize)
14505 
      oprot.writeFieldEnd()
1246 chandransh 14506 
    oprot.writeFieldStop()
14507 
    oprot.writeStructEnd()
14508 
 
3431 rajveer 14509 
  def validate(self):
14510 
    return
14511 
 
14512 
 
1246 chandransh 14513 
  def __repr__(self):
14514 
    L = ['%s=%r' % (key, value)
14515 
      for key, value in self.__dict__.iteritems()]
14516 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14517 
 
14518 
  def __eq__(self, other):
14519 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14520 
 
14521 
  def __ne__(self, other):
14522 
    return not (self == other)
14523 
 
4283 anupam.sin 14524 
class addBillingDetails_result:
1246 chandransh 14525 
  """
14526 
  Attributes:
3064 chandransh 14527 
   - success
1246 chandransh 14528 
   - ex
14529 
  """
14530 
 
14531 
  thrift_spec = (
3064 chandransh 14532 
    (0, TType.BOOL, 'success', None, None, ), # 0
1246 chandransh 14533 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
14534 
  )
14535 
 
3064 chandransh 14536 
  def __init__(self, success=None, ex=None,):
14537 
    self.success = success
1246 chandransh 14538 
    self.ex = ex
14539 
 
14540 
  def read(self, iprot):
14541 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14542 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14543 
      return
14544 
    iprot.readStructBegin()
14545 
    while True:
14546 
      (fname, ftype, fid) = iprot.readFieldBegin()
14547 
      if ftype == TType.STOP:
14548 
        break
3064 chandransh 14549 
      if fid == 0:
14550 
        if ftype == TType.BOOL:
14551 
          self.success = iprot.readBool();
14552 
        else:
14553 
          iprot.skip(ftype)
14554 
      elif fid == 1:
1246 chandransh 14555 
        if ftype == TType.STRUCT:
14556 
          self.ex = TransactionServiceException()
14557 
          self.ex.read(iprot)
14558 
        else:
14559 
          iprot.skip(ftype)
14560 
      else:
14561 
        iprot.skip(ftype)
14562 
      iprot.readFieldEnd()
14563 
    iprot.readStructEnd()
14564 
 
14565 
  def write(self, oprot):
14566 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14567 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14568 
      return
4283 anupam.sin 14569 
    oprot.writeStructBegin('addBillingDetails_result')
3431 rajveer 14570 
    if self.success is not None:
3064 chandransh 14571 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
14572 
      oprot.writeBool(self.success)
14573 
      oprot.writeFieldEnd()
3431 rajveer 14574 
    if self.ex is not None:
1246 chandransh 14575 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
14576 
      self.ex.write(oprot)
14577 
      oprot.writeFieldEnd()
14578 
    oprot.writeFieldStop()
14579 
    oprot.writeStructEnd()
14580 
 
3431 rajveer 14581 
  def validate(self):
14582 
    return
14583 
 
14584 
 
1246 chandransh 14585 
  def __repr__(self):
14586 
    L = ['%s=%r' % (key, value)
14587 
      for key, value in self.__dict__.iteritems()]
14588 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14589 
 
14590 
  def __eq__(self, other):
14591 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14592 
 
14593 
  def __ne__(self, other):
14594 
    return not (self == other)
14595 
 
4579 rajveer 14596 
class addInvoiceNumber_args:
14597 
  """
14598 
  Attributes:
14599 
   - orderId
14600 
   - invoiceNumber
4763 rajveer 14601 
   - color
6756 amar.kumar 14602 
   - serialNumber
14603 
   - itemNumber
4579 rajveer 14604 
  """
14605 
 
14606 
  thrift_spec = (
14607 
    None, # 0
14608 
    (1, TType.I64, 'orderId', None, None, ), # 1
14609 
    (2, TType.STRING, 'invoiceNumber', None, None, ), # 2
4763 rajveer 14610 
    (3, TType.STRING, 'color', None, None, ), # 3
6756 amar.kumar 14611 
    (4, TType.STRING, 'serialNumber', None, None, ), # 4
14612 
    (5, TType.STRING, 'itemNumber', None, None, ), # 5
4579 rajveer 14613 
  )
14614 
 
6756 amar.kumar 14615 
  def __init__(self, orderId=None, invoiceNumber=None, color=None, serialNumber=None, itemNumber=None,):
4579 rajveer 14616 
    self.orderId = orderId
14617 
    self.invoiceNumber = invoiceNumber
4763 rajveer 14618 
    self.color = color
6756 amar.kumar 14619 
    self.serialNumber = serialNumber
14620 
    self.itemNumber = itemNumber
4579 rajveer 14621 
 
14622 
  def read(self, iprot):
14623 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14624 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14625 
      return
14626 
    iprot.readStructBegin()
14627 
    while True:
14628 
      (fname, ftype, fid) = iprot.readFieldBegin()
14629 
      if ftype == TType.STOP:
14630 
        break
14631 
      if fid == 1:
14632 
        if ftype == TType.I64:
14633 
          self.orderId = iprot.readI64();
14634 
        else:
14635 
          iprot.skip(ftype)
14636 
      elif fid == 2:
14637 
        if ftype == TType.STRING:
14638 
          self.invoiceNumber = iprot.readString();
14639 
        else:
14640 
          iprot.skip(ftype)
4763 rajveer 14641 
      elif fid == 3:
14642 
        if ftype == TType.STRING:
14643 
          self.color = iprot.readString();
14644 
        else:
14645 
          iprot.skip(ftype)
6756 amar.kumar 14646 
      elif fid == 4:
14647 
        if ftype == TType.STRING:
14648 
          self.serialNumber = iprot.readString();
14649 
        else:
14650 
          iprot.skip(ftype)
14651 
      elif fid == 5:
14652 
        if ftype == TType.STRING:
14653 
          self.itemNumber = iprot.readString();
14654 
        else:
14655 
          iprot.skip(ftype)
4579 rajveer 14656 
      else:
14657 
        iprot.skip(ftype)
14658 
      iprot.readFieldEnd()
14659 
    iprot.readStructEnd()
14660 
 
14661 
  def write(self, oprot):
14662 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14663 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14664 
      return
14665 
    oprot.writeStructBegin('addInvoiceNumber_args')
14666 
    if self.orderId is not None:
14667 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
14668 
      oprot.writeI64(self.orderId)
14669 
      oprot.writeFieldEnd()
14670 
    if self.invoiceNumber is not None:
14671 
      oprot.writeFieldBegin('invoiceNumber', TType.STRING, 2)
14672 
      oprot.writeString(self.invoiceNumber)
14673 
      oprot.writeFieldEnd()
4763 rajveer 14674 
    if self.color is not None:
14675 
      oprot.writeFieldBegin('color', TType.STRING, 3)
14676 
      oprot.writeString(self.color)
14677 
      oprot.writeFieldEnd()
6756 amar.kumar 14678 
    if self.serialNumber is not None:
14679 
      oprot.writeFieldBegin('serialNumber', TType.STRING, 4)
14680 
      oprot.writeString(self.serialNumber)
14681 
      oprot.writeFieldEnd()
14682 
    if self.itemNumber is not None:
14683 
      oprot.writeFieldBegin('itemNumber', TType.STRING, 5)
14684 
      oprot.writeString(self.itemNumber)
14685 
      oprot.writeFieldEnd()
4579 rajveer 14686 
    oprot.writeFieldStop()
14687 
    oprot.writeStructEnd()
14688 
 
14689 
  def validate(self):
14690 
    return
14691 
 
14692 
 
14693 
  def __repr__(self):
14694 
    L = ['%s=%r' % (key, value)
14695 
      for key, value in self.__dict__.iteritems()]
14696 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14697 
 
14698 
  def __eq__(self, other):
14699 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14700 
 
14701 
  def __ne__(self, other):
14702 
    return not (self == other)
14703 
 
14704 
class addInvoiceNumber_result:
14705 
  """
14706 
  Attributes:
14707 
   - ex
14708 
  """
14709 
 
14710 
  thrift_spec = (
14711 
    None, # 0
14712 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
14713 
  )
14714 
 
14715 
  def __init__(self, ex=None,):
14716 
    self.ex = ex
14717 
 
14718 
  def read(self, iprot):
14719 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14720 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14721 
      return
14722 
    iprot.readStructBegin()
14723 
    while True:
14724 
      (fname, ftype, fid) = iprot.readFieldBegin()
14725 
      if ftype == TType.STOP:
14726 
        break
14727 
      if fid == 1:
14728 
        if ftype == TType.STRUCT:
14729 
          self.ex = TransactionServiceException()
14730 
          self.ex.read(iprot)
14731 
        else:
14732 
          iprot.skip(ftype)
14733 
      else:
14734 
        iprot.skip(ftype)
14735 
      iprot.readFieldEnd()
14736 
    iprot.readStructEnd()
14737 
 
14738 
  def write(self, oprot):
14739 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14740 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14741 
      return
14742 
    oprot.writeStructBegin('addInvoiceNumber_result')
14743 
    if self.ex is not None:
14744 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
14745 
      self.ex.write(oprot)
14746 
      oprot.writeFieldEnd()
14747 
    oprot.writeFieldStop()
14748 
    oprot.writeStructEnd()
14749 
 
14750 
  def validate(self):
14751 
    return
14752 
 
14753 
 
14754 
  def __repr__(self):
14755 
    L = ['%s=%r' % (key, value)
14756 
      for key, value in self.__dict__.iteritems()]
14757 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14758 
 
14759 
  def __eq__(self, other):
14760 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14761 
 
14762 
  def __ne__(self, other):
14763 
    return not (self == other)
14764 
 
4910 phani.kuma 14765 
class markOrdersAsShippedFromWarehouse_args:
1408 ankur.sing 14766 
  """
14767 
  Attributes:
3064 chandransh 14768 
   - warehouseId
1408 ankur.sing 14769 
   - providerId
3064 chandransh 14770 
   - cod
4910 phani.kuma 14771 
   - orderIds
1408 ankur.sing 14772 
  """
14773 
 
14774 
  thrift_spec = (
14775 
    None, # 0
3064 chandransh 14776 
    (1, TType.I64, 'warehouseId', None, None, ), # 1
14777 
    (2, TType.I64, 'providerId', None, None, ), # 2
14778 
    (3, TType.BOOL, 'cod', None, None, ), # 3
4910 phani.kuma 14779 
    (4, TType.LIST, 'orderIds', (TType.I64,None), None, ), # 4
1408 ankur.sing 14780 
  )
14781 
 
4910 phani.kuma 14782 
  def __init__(self, warehouseId=None, providerId=None, cod=None, orderIds=None,):
3064 chandransh 14783 
    self.warehouseId = warehouseId
1408 ankur.sing 14784 
    self.providerId = providerId
3064 chandransh 14785 
    self.cod = cod
4910 phani.kuma 14786 
    self.orderIds = orderIds
1408 ankur.sing 14787 
 
14788 
  def read(self, iprot):
14789 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14790 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14791 
      return
14792 
    iprot.readStructBegin()
14793 
    while True:
14794 
      (fname, ftype, fid) = iprot.readFieldBegin()
14795 
      if ftype == TType.STOP:
14796 
        break
14797 
      if fid == 1:
14798 
        if ftype == TType.I64:
3064 chandransh 14799 
          self.warehouseId = iprot.readI64();
1408 ankur.sing 14800 
        else:
14801 
          iprot.skip(ftype)
14802 
      elif fid == 2:
14803 
        if ftype == TType.I64:
3064 chandransh 14804 
          self.providerId = iprot.readI64();
1408 ankur.sing 14805 
        else:
14806 
          iprot.skip(ftype)
3064 chandransh 14807 
      elif fid == 3:
14808 
        if ftype == TType.BOOL:
14809 
          self.cod = iprot.readBool();
14810 
        else:
14811 
          iprot.skip(ftype)
4910 phani.kuma 14812 
      elif fid == 4:
14813 
        if ftype == TType.LIST:
14814 
          self.orderIds = []
6188 rajveer 14815 
          (_etype284, _size281) = iprot.readListBegin()
14816 
          for _i285 in xrange(_size281):
14817 
            _elem286 = iprot.readI64();
14818 
            self.orderIds.append(_elem286)
4910 phani.kuma 14819 
          iprot.readListEnd()
14820 
        else:
14821 
          iprot.skip(ftype)
1408 ankur.sing 14822 
      else:
14823 
        iprot.skip(ftype)
14824 
      iprot.readFieldEnd()
14825 
    iprot.readStructEnd()
14826 
 
14827 
  def write(self, oprot):
14828 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14829 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14830 
      return
4910 phani.kuma 14831 
    oprot.writeStructBegin('markOrdersAsShippedFromWarehouse_args')
3431 rajveer 14832 
    if self.warehouseId is not None:
3064 chandransh 14833 
      oprot.writeFieldBegin('warehouseId', TType.I64, 1)
14834 
      oprot.writeI64(self.warehouseId)
14835 
      oprot.writeFieldEnd()
3431 rajveer 14836 
    if self.providerId is not None:
3064 chandransh 14837 
      oprot.writeFieldBegin('providerId', TType.I64, 2)
1408 ankur.sing 14838 
      oprot.writeI64(self.providerId)
14839 
      oprot.writeFieldEnd()
3431 rajveer 14840 
    if self.cod is not None:
3064 chandransh 14841 
      oprot.writeFieldBegin('cod', TType.BOOL, 3)
14842 
      oprot.writeBool(self.cod)
1408 ankur.sing 14843 
      oprot.writeFieldEnd()
4910 phani.kuma 14844 
    if self.orderIds is not None:
14845 
      oprot.writeFieldBegin('orderIds', TType.LIST, 4)
14846 
      oprot.writeListBegin(TType.I64, len(self.orderIds))
6188 rajveer 14847 
      for iter287 in self.orderIds:
14848 
        oprot.writeI64(iter287)
4910 phani.kuma 14849 
      oprot.writeListEnd()
14850 
      oprot.writeFieldEnd()
1408 ankur.sing 14851 
    oprot.writeFieldStop()
14852 
    oprot.writeStructEnd()
14853 
 
3431 rajveer 14854 
  def validate(self):
14855 
    return
14856 
 
14857 
 
1408 ankur.sing 14858 
  def __repr__(self):
14859 
    L = ['%s=%r' % (key, value)
14860 
      for key, value in self.__dict__.iteritems()]
14861 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14862 
 
14863 
  def __eq__(self, other):
14864 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14865 
 
14866 
  def __ne__(self, other):
14867 
    return not (self == other)
14868 
 
4910 phani.kuma 14869 
class markOrdersAsShippedFromWarehouse_result:
1408 ankur.sing 14870 
  """
14871 
  Attributes:
14872 
   - success
3064 chandransh 14873 
   - ex
1408 ankur.sing 14874 
  """
14875 
 
14876 
  thrift_spec = (
3064 chandransh 14877 
    (0, TType.BOOL, 'success', None, None, ), # 0
14878 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
1408 ankur.sing 14879 
  )
14880 
 
3064 chandransh 14881 
  def __init__(self, success=None, ex=None,):
1408 ankur.sing 14882 
    self.success = success
3064 chandransh 14883 
    self.ex = ex
1408 ankur.sing 14884 
 
14885 
  def read(self, iprot):
14886 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14887 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14888 
      return
14889 
    iprot.readStructBegin()
14890 
    while True:
14891 
      (fname, ftype, fid) = iprot.readFieldBegin()
14892 
      if ftype == TType.STOP:
14893 
        break
14894 
      if fid == 0:
3064 chandransh 14895 
        if ftype == TType.BOOL:
14896 
          self.success = iprot.readBool();
1408 ankur.sing 14897 
        else:
14898 
          iprot.skip(ftype)
3064 chandransh 14899 
      elif fid == 1:
14900 
        if ftype == TType.STRUCT:
14901 
          self.ex = TransactionServiceException()
14902 
          self.ex.read(iprot)
14903 
        else:
14904 
          iprot.skip(ftype)
1408 ankur.sing 14905 
      else:
14906 
        iprot.skip(ftype)
14907 
      iprot.readFieldEnd()
14908 
    iprot.readStructEnd()
14909 
 
14910 
  def write(self, oprot):
14911 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14912 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14913 
      return
4910 phani.kuma 14914 
    oprot.writeStructBegin('markOrdersAsShippedFromWarehouse_result')
3431 rajveer 14915 
    if self.success is not None:
3064 chandransh 14916 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
14917 
      oprot.writeBool(self.success)
1408 ankur.sing 14918 
      oprot.writeFieldEnd()
3431 rajveer 14919 
    if self.ex is not None:
3064 chandransh 14920 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
14921 
      self.ex.write(oprot)
14922 
      oprot.writeFieldEnd()
1408 ankur.sing 14923 
    oprot.writeFieldStop()
14924 
    oprot.writeStructEnd()
14925 
 
3431 rajveer 14926 
  def validate(self):
14927 
    return
14928 
 
14929 
 
1408 ankur.sing 14930 
  def __repr__(self):
14931 
    L = ['%s=%r' % (key, value)
14932 
      for key, value in self.__dict__.iteritems()]
14933 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14934 
 
14935 
  def __eq__(self, other):
14936 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14937 
 
14938 
  def __ne__(self, other):
14939 
    return not (self == other)
14940 
 
5676 rajveer 14941 
class markOrdersAsReturnedFromStore_args:
14942 
  """
14943 
  Attributes:
14944 
   - providerId
14945 
   - orderIds
5713 rajveer 14946 
   - awbs
5676 rajveer 14947 
  """
14948 
 
14949 
  thrift_spec = (
14950 
    None, # 0
14951 
    (1, TType.I64, 'providerId', None, None, ), # 1
14952 
    (2, TType.LIST, 'orderIds', (TType.I64,None), None, ), # 2
5713 rajveer 14953 
    (3, TType.LIST, 'awbs', (TType.STRING,None), None, ), # 3
5676 rajveer 14954 
  )
14955 
 
5713 rajveer 14956 
  def __init__(self, providerId=None, orderIds=None, awbs=None,):
5676 rajveer 14957 
    self.providerId = providerId
14958 
    self.orderIds = orderIds
5713 rajveer 14959 
    self.awbs = awbs
5676 rajveer 14960 
 
14961 
  def read(self, iprot):
14962 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14963 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14964 
      return
14965 
    iprot.readStructBegin()
14966 
    while True:
14967 
      (fname, ftype, fid) = iprot.readFieldBegin()
14968 
      if ftype == TType.STOP:
14969 
        break
14970 
      if fid == 1:
14971 
        if ftype == TType.I64:
14972 
          self.providerId = iprot.readI64();
14973 
        else:
14974 
          iprot.skip(ftype)
14975 
      elif fid == 2:
14976 
        if ftype == TType.LIST:
14977 
          self.orderIds = []
6188 rajveer 14978 
          (_etype291, _size288) = iprot.readListBegin()
14979 
          for _i292 in xrange(_size288):
14980 
            _elem293 = iprot.readI64();
14981 
            self.orderIds.append(_elem293)
5676 rajveer 14982 
          iprot.readListEnd()
14983 
        else:
14984 
          iprot.skip(ftype)
5713 rajveer 14985 
      elif fid == 3:
14986 
        if ftype == TType.LIST:
14987 
          self.awbs = []
6188 rajveer 14988 
          (_etype297, _size294) = iprot.readListBegin()
14989 
          for _i298 in xrange(_size294):
14990 
            _elem299 = iprot.readString();
14991 
            self.awbs.append(_elem299)
5713 rajveer 14992 
          iprot.readListEnd()
14993 
        else:
14994 
          iprot.skip(ftype)
5676 rajveer 14995 
      else:
14996 
        iprot.skip(ftype)
14997 
      iprot.readFieldEnd()
14998 
    iprot.readStructEnd()
14999 
 
15000 
  def write(self, oprot):
15001 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15002 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15003 
      return
15004 
    oprot.writeStructBegin('markOrdersAsReturnedFromStore_args')
15005 
    if self.providerId is not None:
15006 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
15007 
      oprot.writeI64(self.providerId)
15008 
      oprot.writeFieldEnd()
15009 
    if self.orderIds is not None:
15010 
      oprot.writeFieldBegin('orderIds', TType.LIST, 2)
15011 
      oprot.writeListBegin(TType.I64, len(self.orderIds))
6188 rajveer 15012 
      for iter300 in self.orderIds:
15013 
        oprot.writeI64(iter300)
5676 rajveer 15014 
      oprot.writeListEnd()
15015 
      oprot.writeFieldEnd()
5713 rajveer 15016 
    if self.awbs is not None:
15017 
      oprot.writeFieldBegin('awbs', TType.LIST, 3)
15018 
      oprot.writeListBegin(TType.STRING, len(self.awbs))
6188 rajveer 15019 
      for iter301 in self.awbs:
15020 
        oprot.writeString(iter301)
5713 rajveer 15021 
      oprot.writeListEnd()
15022 
      oprot.writeFieldEnd()
5676 rajveer 15023 
    oprot.writeFieldStop()
15024 
    oprot.writeStructEnd()
15025 
 
15026 
  def validate(self):
15027 
    return
15028 
 
15029 
 
15030 
  def __repr__(self):
15031 
    L = ['%s=%r' % (key, value)
15032 
      for key, value in self.__dict__.iteritems()]
15033 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15034 
 
15035 
  def __eq__(self, other):
15036 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15037 
 
15038 
  def __ne__(self, other):
15039 
    return not (self == other)
15040 
 
15041 
class markOrdersAsReturnedFromStore_result:
15042 
  """
15043 
  Attributes:
15044 
   - success
15045 
   - ex
15046 
  """
15047 
 
15048 
  thrift_spec = (
15049 
    (0, TType.BOOL, 'success', None, None, ), # 0
15050 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
15051 
  )
15052 
 
15053 
  def __init__(self, success=None, ex=None,):
15054 
    self.success = success
15055 
    self.ex = ex
15056 
 
15057 
  def read(self, iprot):
15058 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15059 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15060 
      return
15061 
    iprot.readStructBegin()
15062 
    while True:
15063 
      (fname, ftype, fid) = iprot.readFieldBegin()
15064 
      if ftype == TType.STOP:
15065 
        break
15066 
      if fid == 0:
15067 
        if ftype == TType.BOOL:
15068 
          self.success = iprot.readBool();
15069 
        else:
15070 
          iprot.skip(ftype)
15071 
      elif fid == 1:
15072 
        if ftype == TType.STRUCT:
15073 
          self.ex = TransactionServiceException()
15074 
          self.ex.read(iprot)
15075 
        else:
15076 
          iprot.skip(ftype)
15077 
      else:
15078 
        iprot.skip(ftype)
15079 
      iprot.readFieldEnd()
15080 
    iprot.readStructEnd()
15081 
 
15082 
  def write(self, oprot):
15083 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15084 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15085 
      return
15086 
    oprot.writeStructBegin('markOrdersAsReturnedFromStore_result')
15087 
    if self.success is not None:
15088 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
15089 
      oprot.writeBool(self.success)
15090 
      oprot.writeFieldEnd()
15091 
    if self.ex is not None:
15092 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
15093 
      self.ex.write(oprot)
15094 
      oprot.writeFieldEnd()
15095 
    oprot.writeFieldStop()
15096 
    oprot.writeStructEnd()
15097 
 
15098 
  def validate(self):
15099 
    return
15100 
 
15101 
 
15102 
  def __repr__(self):
15103 
    L = ['%s=%r' % (key, value)
15104 
      for key, value in self.__dict__.iteritems()]
15105 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15106 
 
15107 
  def __eq__(self, other):
15108 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15109 
 
15110 
  def __ne__(self, other):
15111 
    return not (self == other)
15112 
 
4910 phani.kuma 15113 
class markOrdersAsPickedUp_args:
4410 rajveer 15114 
  """
15115 
  Attributes:
15116 
   - providerId
4910 phani.kuma 15117 
   - pickupDetails
4410 rajveer 15118 
  """
15119 
 
15120 
  thrift_spec = (
15121 
    None, # 0
4910 phani.kuma 15122 
    (1, TType.I64, 'providerId', None, None, ), # 1
15123 
    (2, TType.MAP, 'pickupDetails', (TType.STRING,None,TType.STRING,None), None, ), # 2
4410 rajveer 15124 
  )
15125 
 
4910 phani.kuma 15126 
  def __init__(self, providerId=None, pickupDetails=None,):
4410 rajveer 15127 
    self.providerId = providerId
4910 phani.kuma 15128 
    self.pickupDetails = pickupDetails
4410 rajveer 15129 
 
15130 
  def read(self, iprot):
15131 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15132 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15133 
      return
15134 
    iprot.readStructBegin()
15135 
    while True:
15136 
      (fname, ftype, fid) = iprot.readFieldBegin()
15137 
      if ftype == TType.STOP:
15138 
        break
15139 
      if fid == 1:
15140 
        if ftype == TType.I64:
4910 phani.kuma 15141 
          self.providerId = iprot.readI64();
4410 rajveer 15142 
        else:
15143 
          iprot.skip(ftype)
15144 
      elif fid == 2:
4910 phani.kuma 15145 
        if ftype == TType.MAP:
15146 
          self.pickupDetails = {}
6188 rajveer 15147 
          (_ktype303, _vtype304, _size302 ) = iprot.readMapBegin()
15148 
          for _i306 in xrange(_size302):
15149 
            _key307 = iprot.readString();
15150 
            _val308 = iprot.readString();
15151 
            self.pickupDetails[_key307] = _val308
4910 phani.kuma 15152 
          iprot.readMapEnd()
4410 rajveer 15153 
        else:
15154 
          iprot.skip(ftype)
15155 
      else:
15156 
        iprot.skip(ftype)
15157 
      iprot.readFieldEnd()
15158 
    iprot.readStructEnd()
15159 
 
15160 
  def write(self, oprot):
15161 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15162 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15163 
      return
4910 phani.kuma 15164 
    oprot.writeStructBegin('markOrdersAsPickedUp_args')
4410 rajveer 15165 
    if self.providerId is not None:
4910 phani.kuma 15166 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
4410 rajveer 15167 
      oprot.writeI64(self.providerId)
15168 
      oprot.writeFieldEnd()
4910 phani.kuma 15169 
    if self.pickupDetails is not None:
15170 
      oprot.writeFieldBegin('pickupDetails', TType.MAP, 2)
15171 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.pickupDetails))
6188 rajveer 15172 
      for kiter309,viter310 in self.pickupDetails.items():
15173 
        oprot.writeString(kiter309)
15174 
        oprot.writeString(viter310)
4910 phani.kuma 15175 
      oprot.writeMapEnd()
4410 rajveer 15176 
      oprot.writeFieldEnd()
15177 
    oprot.writeFieldStop()
15178 
    oprot.writeStructEnd()
15179 
 
15180 
  def validate(self):
15181 
    return
15182 
 
15183 
 
15184 
  def __repr__(self):
15185 
    L = ['%s=%r' % (key, value)
15186 
      for key, value in self.__dict__.iteritems()]
15187 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15188 
 
15189 
  def __eq__(self, other):
15190 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15191 
 
15192 
  def __ne__(self, other):
15193 
    return not (self == other)
15194 
 
4910 phani.kuma 15195 
class markOrdersAsPickedUp_result:
4410 rajveer 15196 
  """
15197 
  Attributes:
15198 
   - ex
15199 
  """
15200 
 
15201 
  thrift_spec = (
4910 phani.kuma 15202 
    None, # 0
4410 rajveer 15203 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
15204 
  )
15205 
 
4910 phani.kuma 15206 
  def __init__(self, ex=None,):
4410 rajveer 15207 
    self.ex = ex
15208 
 
15209 
  def read(self, iprot):
15210 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15211 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15212 
      return
15213 
    iprot.readStructBegin()
15214 
    while True:
15215 
      (fname, ftype, fid) = iprot.readFieldBegin()
15216 
      if ftype == TType.STOP:
15217 
        break
4910 phani.kuma 15218 
      if fid == 1:
4410 rajveer 15219 
        if ftype == TType.STRUCT:
15220 
          self.ex = TransactionServiceException()
15221 
          self.ex.read(iprot)
15222 
        else:
15223 
          iprot.skip(ftype)
15224 
      else:
15225 
        iprot.skip(ftype)
15226 
      iprot.readFieldEnd()
15227 
    iprot.readStructEnd()
15228 
 
15229 
  def write(self, oprot):
15230 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15231 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15232 
      return
4910 phani.kuma 15233 
    oprot.writeStructBegin('markOrdersAsPickedUp_result')
4410 rajveer 15234 
    if self.ex is not None:
15235 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
15236 
      self.ex.write(oprot)
15237 
      oprot.writeFieldEnd()
15238 
    oprot.writeFieldStop()
15239 
    oprot.writeStructEnd()
15240 
 
15241 
  def validate(self):
15242 
    return
15243 
 
15244 
 
15245 
  def __repr__(self):
15246 
    L = ['%s=%r' % (key, value)
15247 
      for key, value in self.__dict__.iteritems()]
15248 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15249 
 
15250 
  def __eq__(self, other):
15251 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15252 
 
15253 
  def __ne__(self, other):
15254 
    return not (self == other)
15255 
 
4910 phani.kuma 15256 
class getOrdersNotPickedUp_args:
304 ashish 15257 
  """
15258 
  Attributes:
3064 chandransh 15259 
   - providerId
304 ashish 15260 
  """
94 ashish 15261 
 
304 ashish 15262 
  thrift_spec = (
15263 
    None, # 0
3064 chandransh 15264 
    (1, TType.I64, 'providerId', None, None, ), # 1
304 ashish 15265 
  )
15266 
 
4910 phani.kuma 15267 
  def __init__(self, providerId=None,):
3064 chandransh 15268 
    self.providerId = providerId
304 ashish 15269 
 
15270 
  def read(self, iprot):
15271 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15272 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15273 
      return
15274 
    iprot.readStructBegin()
15275 
    while True:
15276 
      (fname, ftype, fid) = iprot.readFieldBegin()
15277 
      if ftype == TType.STOP:
15278 
        break
15279 
      if fid == 1:
15280 
        if ftype == TType.I64:
3064 chandransh 15281 
          self.providerId = iprot.readI64();
304 ashish 15282 
        else:
15283 
          iprot.skip(ftype)
15284 
      else:
15285 
        iprot.skip(ftype)
15286 
      iprot.readFieldEnd()
15287 
    iprot.readStructEnd()
15288 
 
15289 
  def write(self, oprot):
15290 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15291 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15292 
      return
4910 phani.kuma 15293 
    oprot.writeStructBegin('getOrdersNotPickedUp_args')
3431 rajveer 15294 
    if self.providerId is not None:
3064 chandransh 15295 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
15296 
      oprot.writeI64(self.providerId)
304 ashish 15297 
      oprot.writeFieldEnd()
15298 
    oprot.writeFieldStop()
15299 
    oprot.writeStructEnd()
15300 
 
3431 rajveer 15301 
  def validate(self):
15302 
    return
15303 
 
15304 
 
304 ashish 15305 
  def __repr__(self):
15306 
    L = ['%s=%r' % (key, value)
15307 
      for key, value in self.__dict__.iteritems()]
15308 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15309 
 
15310 
  def __eq__(self, other):
15311 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15312 
 
15313 
  def __ne__(self, other):
15314 
    return not (self == other)
15315 
 
4910 phani.kuma 15316 
class getOrdersNotPickedUp_result:
304 ashish 15317 
  """
15318 
  Attributes:
15319 
   - success
15320 
  """
15321 
 
15322 
  thrift_spec = (
3064 chandransh 15323 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
304 ashish 15324 
  )
15325 
 
4910 phani.kuma 15326 
  def __init__(self, success=None,):
304 ashish 15327 
    self.success = success
15328 
 
15329 
  def read(self, iprot):
15330 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15331 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15332 
      return
15333 
    iprot.readStructBegin()
15334 
    while True:
15335 
      (fname, ftype, fid) = iprot.readFieldBegin()
15336 
      if ftype == TType.STOP:
15337 
        break
15338 
      if fid == 0:
15339 
        if ftype == TType.LIST:
15340 
          self.success = []
6188 rajveer 15341 
          (_etype314, _size311) = iprot.readListBegin()
15342 
          for _i315 in xrange(_size311):
15343 
            _elem316 = Order()
15344 
            _elem316.read(iprot)
15345 
            self.success.append(_elem316)
304 ashish 15346 
          iprot.readListEnd()
15347 
        else:
15348 
          iprot.skip(ftype)
15349 
      else:
15350 
        iprot.skip(ftype)
15351 
      iprot.readFieldEnd()
15352 
    iprot.readStructEnd()
15353 
 
15354 
  def write(self, oprot):
15355 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15356 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15357 
      return
4910 phani.kuma 15358 
    oprot.writeStructBegin('getOrdersNotPickedUp_result')
3431 rajveer 15359 
    if self.success is not None:
304 ashish 15360 
      oprot.writeFieldBegin('success', TType.LIST, 0)
15361 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 15362 
      for iter317 in self.success:
15363 
        iter317.write(oprot)
304 ashish 15364 
      oprot.writeListEnd()
15365 
      oprot.writeFieldEnd()
15366 
    oprot.writeFieldStop()
15367 
    oprot.writeStructEnd()
15368 
 
3431 rajveer 15369 
  def validate(self):
15370 
    return
15371 
 
15372 
 
304 ashish 15373 
  def __repr__(self):
15374 
    L = ['%s=%r' % (key, value)
15375 
      for key, value in self.__dict__.iteritems()]
15376 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15377 
 
15378 
  def __eq__(self, other):
15379 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15380 
 
15381 
  def __ne__(self, other):
15382 
    return not (self == other)
15383 
 
3064 chandransh 15384 
class markOrdersAsDelivered_args:
304 ashish 15385 
  """
15386 
  Attributes:
3064 chandransh 15387 
   - providerId
15388 
   - deliveredOrders
304 ashish 15389 
  """
15390 
 
15391 
  thrift_spec = (
15392 
    None, # 0
3064 chandransh 15393 
    (1, TType.I64, 'providerId', None, None, ), # 1
15394 
    (2, TType.MAP, 'deliveredOrders', (TType.STRING,None,TType.STRING,None), None, ), # 2
304 ashish 15395 
  )
15396 
 
3064 chandransh 15397 
  def __init__(self, providerId=None, deliveredOrders=None,):
15398 
    self.providerId = providerId
15399 
    self.deliveredOrders = deliveredOrders
304 ashish 15400 
 
15401 
  def read(self, iprot):
15402 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15403 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15404 
      return
15405 
    iprot.readStructBegin()
15406 
    while True:
15407 
      (fname, ftype, fid) = iprot.readFieldBegin()
15408 
      if ftype == TType.STOP:
15409 
        break
15410 
      if fid == 1:
15411 
        if ftype == TType.I64:
3064 chandransh 15412 
          self.providerId = iprot.readI64();
304 ashish 15413 
        else:
15414 
          iprot.skip(ftype)
15415 
      elif fid == 2:
3064 chandransh 15416 
        if ftype == TType.MAP:
15417 
          self.deliveredOrders = {}
6188 rajveer 15418 
          (_ktype319, _vtype320, _size318 ) = iprot.readMapBegin()
15419 
          for _i322 in xrange(_size318):
15420 
            _key323 = iprot.readString();
15421 
            _val324 = iprot.readString();
15422 
            self.deliveredOrders[_key323] = _val324
3064 chandransh 15423 
          iprot.readMapEnd()
304 ashish 15424 
        else:
15425 
          iprot.skip(ftype)
15426 
      else:
15427 
        iprot.skip(ftype)
15428 
      iprot.readFieldEnd()
15429 
    iprot.readStructEnd()
15430 
 
15431 
  def write(self, oprot):
15432 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15433 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15434 
      return
3064 chandransh 15435 
    oprot.writeStructBegin('markOrdersAsDelivered_args')
3431 rajveer 15436 
    if self.providerId is not None:
3064 chandransh 15437 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
15438 
      oprot.writeI64(self.providerId)
304 ashish 15439 
      oprot.writeFieldEnd()
3431 rajveer 15440 
    if self.deliveredOrders is not None:
3064 chandransh 15441 
      oprot.writeFieldBegin('deliveredOrders', TType.MAP, 2)
15442 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.deliveredOrders))
6188 rajveer 15443 
      for kiter325,viter326 in self.deliveredOrders.items():
15444 
        oprot.writeString(kiter325)
15445 
        oprot.writeString(viter326)
3064 chandransh 15446 
      oprot.writeMapEnd()
304 ashish 15447 
      oprot.writeFieldEnd()
15448 
    oprot.writeFieldStop()
15449 
    oprot.writeStructEnd()
15450 
 
3431 rajveer 15451 
  def validate(self):
15452 
    return
15453 
 
15454 
 
304 ashish 15455 
  def __repr__(self):
15456 
    L = ['%s=%r' % (key, value)
15457 
      for key, value in self.__dict__.iteritems()]
15458 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15459 
 
15460 
  def __eq__(self, other):
15461 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15462 
 
15463 
  def __ne__(self, other):
15464 
    return not (self == other)
15465 
 
3064 chandransh 15466 
class markOrdersAsDelivered_result:
15467 
  """
15468 
  Attributes:
15469 
   - ex
15470 
  """
304 ashish 15471 
 
15472 
  thrift_spec = (
3064 chandransh 15473 
    None, # 0
15474 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
304 ashish 15475 
  )
15476 
 
3064 chandransh 15477 
  def __init__(self, ex=None,):
15478 
    self.ex = ex
304 ashish 15479 
 
1596 ankur.sing 15480 
  def read(self, iprot):
15481 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15482 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15483 
      return
15484 
    iprot.readStructBegin()
15485 
    while True:
15486 
      (fname, ftype, fid) = iprot.readFieldBegin()
15487 
      if ftype == TType.STOP:
15488 
        break
3064 chandransh 15489 
      if fid == 1:
15490 
        if ftype == TType.STRUCT:
15491 
          self.ex = TransactionServiceException()
15492 
          self.ex.read(iprot)
15493 
        else:
15494 
          iprot.skip(ftype)
1596 ankur.sing 15495 
      else:
15496 
        iprot.skip(ftype)
15497 
      iprot.readFieldEnd()
15498 
    iprot.readStructEnd()
15499 
 
15500 
  def write(self, oprot):
15501 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15502 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15503 
      return
3064 chandransh 15504 
    oprot.writeStructBegin('markOrdersAsDelivered_result')
3431 rajveer 15505 
    if self.ex is not None:
3064 chandransh 15506 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
15507 
      self.ex.write(oprot)
15508 
      oprot.writeFieldEnd()
1596 ankur.sing 15509 
    oprot.writeFieldStop()
15510 
    oprot.writeStructEnd()
15511 
 
3431 rajveer 15512 
  def validate(self):
15513 
    return
15514 
 
15515 
 
1596 ankur.sing 15516 
  def __repr__(self):
15517 
    L = ['%s=%r' % (key, value)
15518 
      for key, value in self.__dict__.iteritems()]
15519 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15520 
 
15521 
  def __eq__(self, other):
15522 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15523 
 
15524 
  def __ne__(self, other):
15525 
    return not (self == other)
15526 
 
4910 phani.kuma 15527 
class markAsRTOrders_args:
1596 ankur.sing 15528 
  """
15529 
  Attributes:
3064 chandransh 15530 
   - providerId
15531 
   - returnedOrders
1596 ankur.sing 15532 
  """
15533 
 
15534 
  thrift_spec = (
3064 chandransh 15535 
    None, # 0
15536 
    (1, TType.I64, 'providerId', None, None, ), # 1
15537 
    (2, TType.MAP, 'returnedOrders', (TType.STRING,None,TType.STRING,None), None, ), # 2
1596 ankur.sing 15538 
  )
15539 
 
3064 chandransh 15540 
  def __init__(self, providerId=None, returnedOrders=None,):
15541 
    self.providerId = providerId
15542 
    self.returnedOrders = returnedOrders
1596 ankur.sing 15543 
 
15544 
  def read(self, iprot):
15545 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15546 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15547 
      return
15548 
    iprot.readStructBegin()
15549 
    while True:
15550 
      (fname, ftype, fid) = iprot.readFieldBegin()
15551 
      if ftype == TType.STOP:
15552 
        break
3064 chandransh 15553 
      if fid == 1:
1596 ankur.sing 15554 
        if ftype == TType.I64:
3064 chandransh 15555 
          self.providerId = iprot.readI64();
1596 ankur.sing 15556 
        else:
15557 
          iprot.skip(ftype)
3064 chandransh 15558 
      elif fid == 2:
15559 
        if ftype == TType.MAP:
15560 
          self.returnedOrders = {}
6188 rajveer 15561 
          (_ktype328, _vtype329, _size327 ) = iprot.readMapBegin()
15562 
          for _i331 in xrange(_size327):
15563 
            _key332 = iprot.readString();
15564 
            _val333 = iprot.readString();
15565 
            self.returnedOrders[_key332] = _val333
3064 chandransh 15566 
          iprot.readMapEnd()
15567 
        else:
15568 
          iprot.skip(ftype)
1596 ankur.sing 15569 
      else:
15570 
        iprot.skip(ftype)
15571 
      iprot.readFieldEnd()
15572 
    iprot.readStructEnd()
15573 
 
15574 
  def write(self, oprot):
15575 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15576 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15577 
      return
4910 phani.kuma 15578 
    oprot.writeStructBegin('markAsRTOrders_args')
3431 rajveer 15579 
    if self.providerId is not None:
3064 chandransh 15580 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
15581 
      oprot.writeI64(self.providerId)
1596 ankur.sing 15582 
      oprot.writeFieldEnd()
3431 rajveer 15583 
    if self.returnedOrders is not None:
3064 chandransh 15584 
      oprot.writeFieldBegin('returnedOrders', TType.MAP, 2)
15585 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.returnedOrders))
6188 rajveer 15586 
      for kiter334,viter335 in self.returnedOrders.items():
15587 
        oprot.writeString(kiter334)
15588 
        oprot.writeString(viter335)
3064 chandransh 15589 
      oprot.writeMapEnd()
15590 
      oprot.writeFieldEnd()
1596 ankur.sing 15591 
    oprot.writeFieldStop()
15592 
    oprot.writeStructEnd()
15593 
 
3431 rajveer 15594 
  def validate(self):
15595 
    return
15596 
 
15597 
 
1596 ankur.sing 15598 
  def __repr__(self):
15599 
    L = ['%s=%r' % (key, value)
15600 
      for key, value in self.__dict__.iteritems()]
15601 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15602 
 
15603 
  def __eq__(self, other):
15604 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15605 
 
15606 
  def __ne__(self, other):
15607 
    return not (self == other)
15608 
 
4910 phani.kuma 15609 
class markAsRTOrders_result:
3064 chandransh 15610 
  """
15611 
  Attributes:
15612 
   - ex
15613 
  """
1596 ankur.sing 15614 
 
1627 ankur.sing 15615 
  thrift_spec = (
3064 chandransh 15616 
    None, # 0
15617 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
1627 ankur.sing 15618 
  )
15619 
 
3064 chandransh 15620 
  def __init__(self, ex=None,):
15621 
    self.ex = ex
15622 
 
1627 ankur.sing 15623 
  def read(self, iprot):
15624 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15625 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15626 
      return
15627 
    iprot.readStructBegin()
15628 
    while True:
15629 
      (fname, ftype, fid) = iprot.readFieldBegin()
15630 
      if ftype == TType.STOP:
15631 
        break
3064 chandransh 15632 
      if fid == 1:
15633 
        if ftype == TType.STRUCT:
15634 
          self.ex = TransactionServiceException()
15635 
          self.ex.read(iprot)
15636 
        else:
15637 
          iprot.skip(ftype)
1627 ankur.sing 15638 
      else:
15639 
        iprot.skip(ftype)
15640 
      iprot.readFieldEnd()
15641 
    iprot.readStructEnd()
15642 
 
15643 
  def write(self, oprot):
15644 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15645 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15646 
      return
4910 phani.kuma 15647 
    oprot.writeStructBegin('markAsRTOrders_result')
3431 rajveer 15648 
    if self.ex is not None:
3064 chandransh 15649 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
15650 
      self.ex.write(oprot)
15651 
      oprot.writeFieldEnd()
1627 ankur.sing 15652 
    oprot.writeFieldStop()
15653 
    oprot.writeStructEnd()
15654 
 
3431 rajveer 15655 
  def validate(self):
15656 
    return
15657 
 
15658 
 
1627 ankur.sing 15659 
  def __repr__(self):
15660 
    L = ['%s=%r' % (key, value)
15661 
      for key, value in self.__dict__.iteritems()]
15662 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15663 
 
15664 
  def __eq__(self, other):
15665 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15666 
 
15667 
  def __ne__(self, other):
15668 
    return not (self == other)
15669 
 
4910 phani.kuma 15670 
class getRTOrders_args:
15671 
  """
15672 
  Attributes:
15673 
   - providerId
15674 
  """
15675 
 
15676 
  thrift_spec = (
15677 
    None, # 0
15678 
    (1, TType.I64, 'providerId', None, None, ), # 1
15679 
  )
15680 
 
15681 
  def __init__(self, providerId=None,):
15682 
    self.providerId = providerId
15683 
 
15684 
  def read(self, iprot):
15685 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15686 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15687 
      return
15688 
    iprot.readStructBegin()
15689 
    while True:
15690 
      (fname, ftype, fid) = iprot.readFieldBegin()
15691 
      if ftype == TType.STOP:
15692 
        break
15693 
      if fid == 1:
15694 
        if ftype == TType.I64:
15695 
          self.providerId = iprot.readI64();
15696 
        else:
15697 
          iprot.skip(ftype)
15698 
      else:
15699 
        iprot.skip(ftype)
15700 
      iprot.readFieldEnd()
15701 
    iprot.readStructEnd()
15702 
 
15703 
  def write(self, oprot):
15704 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15705 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15706 
      return
15707 
    oprot.writeStructBegin('getRTOrders_args')
15708 
    if self.providerId is not None:
15709 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
15710 
      oprot.writeI64(self.providerId)
15711 
      oprot.writeFieldEnd()
15712 
    oprot.writeFieldStop()
15713 
    oprot.writeStructEnd()
15714 
 
15715 
  def validate(self):
15716 
    return
15717 
 
15718 
 
15719 
  def __repr__(self):
15720 
    L = ['%s=%r' % (key, value)
15721 
      for key, value in self.__dict__.iteritems()]
15722 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15723 
 
15724 
  def __eq__(self, other):
15725 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15726 
 
15727 
  def __ne__(self, other):
15728 
    return not (self == other)
15729 
 
15730 
class getRTOrders_result:
15731 
  """
15732 
  Attributes:
15733 
   - success
15734 
  """
15735 
 
15736 
  thrift_spec = (
15737 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
15738 
  )
15739 
 
15740 
  def __init__(self, success=None,):
15741 
    self.success = success
15742 
 
15743 
  def read(self, iprot):
15744 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15745 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15746 
      return
15747 
    iprot.readStructBegin()
15748 
    while True:
15749 
      (fname, ftype, fid) = iprot.readFieldBegin()
15750 
      if ftype == TType.STOP:
15751 
        break
15752 
      if fid == 0:
15753 
        if ftype == TType.LIST:
15754 
          self.success = []
6188 rajveer 15755 
          (_etype339, _size336) = iprot.readListBegin()
15756 
          for _i340 in xrange(_size336):
15757 
            _elem341 = Order()
15758 
            _elem341.read(iprot)
15759 
            self.success.append(_elem341)
4910 phani.kuma 15760 
          iprot.readListEnd()
15761 
        else:
15762 
          iprot.skip(ftype)
15763 
      else:
15764 
        iprot.skip(ftype)
15765 
      iprot.readFieldEnd()
15766 
    iprot.readStructEnd()
15767 
 
15768 
  def write(self, oprot):
15769 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15770 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15771 
      return
15772 
    oprot.writeStructBegin('getRTOrders_result')
15773 
    if self.success is not None:
15774 
      oprot.writeFieldBegin('success', TType.LIST, 0)
15775 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 15776 
      for iter342 in self.success:
15777 
        iter342.write(oprot)
4910 phani.kuma 15778 
      oprot.writeListEnd()
15779 
      oprot.writeFieldEnd()
15780 
    oprot.writeFieldStop()
15781 
    oprot.writeStructEnd()
15782 
 
15783 
  def validate(self):
15784 
    return
15785 
 
15786 
 
15787 
  def __repr__(self):
15788 
    L = ['%s=%r' % (key, value)
15789 
      for key, value in self.__dict__.iteritems()]
15790 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15791 
 
15792 
  def __eq__(self, other):
15793 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15794 
 
15795 
  def __ne__(self, other):
15796 
    return not (self == other)
15797 
 
3064 chandransh 15798 
class updateNonDeliveryReason_args:
1627 ankur.sing 15799 
  """
15800 
  Attributes:
3064 chandransh 15801 
   - providerId
15802 
   - undeliveredOrders
1627 ankur.sing 15803 
  """
15804 
 
15805 
  thrift_spec = (
3064 chandransh 15806 
    None, # 0
15807 
    (1, TType.I64, 'providerId', None, None, ), # 1
15808 
    (2, TType.MAP, 'undeliveredOrders', (TType.STRING,None,TType.STRING,None), None, ), # 2
1627 ankur.sing 15809 
  )
15810 
 
3064 chandransh 15811 
  def __init__(self, providerId=None, undeliveredOrders=None,):
15812 
    self.providerId = providerId
15813 
    self.undeliveredOrders = undeliveredOrders
1627 ankur.sing 15814 
 
15815 
  def read(self, iprot):
15816 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15817 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15818 
      return
15819 
    iprot.readStructBegin()
15820 
    while True:
15821 
      (fname, ftype, fid) = iprot.readFieldBegin()
15822 
      if ftype == TType.STOP:
15823 
        break
3064 chandransh 15824 
      if fid == 1:
1627 ankur.sing 15825 
        if ftype == TType.I64:
3064 chandransh 15826 
          self.providerId = iprot.readI64();
1627 ankur.sing 15827 
        else:
15828 
          iprot.skip(ftype)
3064 chandransh 15829 
      elif fid == 2:
15830 
        if ftype == TType.MAP:
15831 
          self.undeliveredOrders = {}
6188 rajveer 15832 
          (_ktype344, _vtype345, _size343 ) = iprot.readMapBegin()
15833 
          for _i347 in xrange(_size343):
15834 
            _key348 = iprot.readString();
15835 
            _val349 = iprot.readString();
15836 
            self.undeliveredOrders[_key348] = _val349
3064 chandransh 15837 
          iprot.readMapEnd()
15838 
        else:
15839 
          iprot.skip(ftype)
1627 ankur.sing 15840 
      else:
15841 
        iprot.skip(ftype)
15842 
      iprot.readFieldEnd()
15843 
    iprot.readStructEnd()
15844 
 
15845 
  def write(self, oprot):
15846 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15847 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15848 
      return
3064 chandransh 15849 
    oprot.writeStructBegin('updateNonDeliveryReason_args')
3431 rajveer 15850 
    if self.providerId is not None:
3064 chandransh 15851 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
15852 
      oprot.writeI64(self.providerId)
1627 ankur.sing 15853 
      oprot.writeFieldEnd()
3431 rajveer 15854 
    if self.undeliveredOrders is not None:
3064 chandransh 15855 
      oprot.writeFieldBegin('undeliveredOrders', TType.MAP, 2)
15856 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.undeliveredOrders))
6188 rajveer 15857 
      for kiter350,viter351 in self.undeliveredOrders.items():
15858 
        oprot.writeString(kiter350)
15859 
        oprot.writeString(viter351)
3064 chandransh 15860 
      oprot.writeMapEnd()
15861 
      oprot.writeFieldEnd()
1627 ankur.sing 15862 
    oprot.writeFieldStop()
15863 
    oprot.writeStructEnd()
15864 
 
3431 rajveer 15865 
  def validate(self):
15866 
    return
15867 
 
15868 
 
1627 ankur.sing 15869 
  def __repr__(self):
15870 
    L = ['%s=%r' % (key, value)
15871 
      for key, value in self.__dict__.iteritems()]
15872 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15873 
 
15874 
  def __eq__(self, other):
15875 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15876 
 
15877 
  def __ne__(self, other):
15878 
    return not (self == other)
15879 
 
3064 chandransh 15880 
class updateNonDeliveryReason_result:
1627 ankur.sing 15881 
  """
15882 
  Attributes:
3064 chandransh 15883 
   - ex
1627 ankur.sing 15884 
  """
15885 
 
15886 
  thrift_spec = (
4910 phani.kuma 15887 
    None, # 0
3064 chandransh 15888 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
1627 ankur.sing 15889 
  )
15890 
 
4910 phani.kuma 15891 
  def __init__(self, ex=None,):
3064 chandransh 15892 
    self.ex = ex
1627 ankur.sing 15893 
 
15894 
  def read(self, iprot):
15895 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15896 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15897 
      return
15898 
    iprot.readStructBegin()
15899 
    while True:
15900 
      (fname, ftype, fid) = iprot.readFieldBegin()
15901 
      if ftype == TType.STOP:
15902 
        break
4910 phani.kuma 15903 
      if fid == 1:
15904 
        if ftype == TType.STRUCT:
15905 
          self.ex = TransactionServiceException()
15906 
          self.ex.read(iprot)
15907 
        else:
15908 
          iprot.skip(ftype)
15909 
      else:
15910 
        iprot.skip(ftype)
15911 
      iprot.readFieldEnd()
15912 
    iprot.readStructEnd()
15913 
 
15914 
  def write(self, oprot):
15915 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15916 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15917 
      return
15918 
    oprot.writeStructBegin('updateNonDeliveryReason_result')
15919 
    if self.ex is not None:
15920 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
15921 
      self.ex.write(oprot)
15922 
      oprot.writeFieldEnd()
15923 
    oprot.writeFieldStop()
15924 
    oprot.writeStructEnd()
15925 
 
15926 
  def validate(self):
15927 
    return
15928 
 
15929 
 
15930 
  def __repr__(self):
15931 
    L = ['%s=%r' % (key, value)
15932 
      for key, value in self.__dict__.iteritems()]
15933 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15934 
 
15935 
  def __eq__(self, other):
15936 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15937 
 
15938 
  def __ne__(self, other):
15939 
    return not (self == other)
15940 
 
15941 
class getNonDeliveredOrdersbyCourier_args:
15942 
  """
15943 
  Attributes:
15944 
   - providerId
15945 
  """
15946 
 
15947 
  thrift_spec = (
15948 
    None, # 0
15949 
    (1, TType.I64, 'providerId', None, None, ), # 1
15950 
  )
15951 
 
15952 
  def __init__(self, providerId=None,):
15953 
    self.providerId = providerId
15954 
 
15955 
  def read(self, iprot):
15956 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15957 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15958 
      return
15959 
    iprot.readStructBegin()
15960 
    while True:
15961 
      (fname, ftype, fid) = iprot.readFieldBegin()
15962 
      if ftype == TType.STOP:
15963 
        break
15964 
      if fid == 1:
15965 
        if ftype == TType.I64:
15966 
          self.providerId = iprot.readI64();
15967 
        else:
15968 
          iprot.skip(ftype)
15969 
      else:
15970 
        iprot.skip(ftype)
15971 
      iprot.readFieldEnd()
15972 
    iprot.readStructEnd()
15973 
 
15974 
  def write(self, oprot):
15975 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15976 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15977 
      return
15978 
    oprot.writeStructBegin('getNonDeliveredOrdersbyCourier_args')
15979 
    if self.providerId is not None:
15980 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
15981 
      oprot.writeI64(self.providerId)
15982 
      oprot.writeFieldEnd()
15983 
    oprot.writeFieldStop()
15984 
    oprot.writeStructEnd()
15985 
 
15986 
  def validate(self):
15987 
    return
15988 
 
15989 
 
15990 
  def __repr__(self):
15991 
    L = ['%s=%r' % (key, value)
15992 
      for key, value in self.__dict__.iteritems()]
15993 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15994 
 
15995 
  def __eq__(self, other):
15996 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15997 
 
15998 
  def __ne__(self, other):
15999 
    return not (self == other)
16000 
 
16001 
class getNonDeliveredOrdersbyCourier_result:
16002 
  """
16003 
  Attributes:
16004 
   - success
16005 
  """
16006 
 
16007 
  thrift_spec = (
16008 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
16009 
  )
16010 
 
16011 
  def __init__(self, success=None,):
16012 
    self.success = success
16013 
 
16014 
  def read(self, iprot):
16015 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16016 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16017 
      return
16018 
    iprot.readStructBegin()
16019 
    while True:
16020 
      (fname, ftype, fid) = iprot.readFieldBegin()
16021 
      if ftype == TType.STOP:
16022 
        break
4581 phani.kuma 16023 
      if fid == 0:
16024 
        if ftype == TType.LIST:
16025 
          self.success = []
6188 rajveer 16026 
          (_etype355, _size352) = iprot.readListBegin()
16027 
          for _i356 in xrange(_size352):
16028 
            _elem357 = Order()
16029 
            _elem357.read(iprot)
16030 
            self.success.append(_elem357)
4581 phani.kuma 16031 
          iprot.readListEnd()
16032 
        else:
16033 
          iprot.skip(ftype)
4910 phani.kuma 16034 
      else:
16035 
        iprot.skip(ftype)
16036 
      iprot.readFieldEnd()
16037 
    iprot.readStructEnd()
16038 
 
16039 
  def write(self, oprot):
16040 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16041 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16042 
      return
16043 
    oprot.writeStructBegin('getNonDeliveredOrdersbyCourier_result')
16044 
    if self.success is not None:
16045 
      oprot.writeFieldBegin('success', TType.LIST, 0)
16046 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 16047 
      for iter358 in self.success:
16048 
        iter358.write(oprot)
4910 phani.kuma 16049 
      oprot.writeListEnd()
16050 
      oprot.writeFieldEnd()
16051 
    oprot.writeFieldStop()
16052 
    oprot.writeStructEnd()
16053 
 
16054 
  def validate(self):
16055 
    return
16056 
 
16057 
 
16058 
  def __repr__(self):
16059 
    L = ['%s=%r' % (key, value)
16060 
      for key, value in self.__dict__.iteritems()]
16061 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16062 
 
16063 
  def __eq__(self, other):
16064 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16065 
 
16066 
  def __ne__(self, other):
16067 
    return not (self == other)
16068 
 
16069 
class markOrdersAsLocalConnected_args:
16070 
  """
16071 
  Attributes:
16072 
   - providerId
16073 
   - local_connected_orders
16074 
  """
16075 
 
16076 
  thrift_spec = (
16077 
    None, # 0
16078 
    (1, TType.I64, 'providerId', None, None, ), # 1
16079 
    (2, TType.MAP, 'local_connected_orders', (TType.STRING,None,TType.STRING,None), None, ), # 2
16080 
  )
16081 
 
16082 
  def __init__(self, providerId=None, local_connected_orders=None,):
16083 
    self.providerId = providerId
16084 
    self.local_connected_orders = local_connected_orders
16085 
 
16086 
  def read(self, iprot):
16087 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16088 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16089 
      return
16090 
    iprot.readStructBegin()
16091 
    while True:
16092 
      (fname, ftype, fid) = iprot.readFieldBegin()
16093 
      if ftype == TType.STOP:
16094 
        break
16095 
      if fid == 1:
16096 
        if ftype == TType.I64:
16097 
          self.providerId = iprot.readI64();
16098 
        else:
16099 
          iprot.skip(ftype)
16100 
      elif fid == 2:
16101 
        if ftype == TType.MAP:
16102 
          self.local_connected_orders = {}
6188 rajveer 16103 
          (_ktype360, _vtype361, _size359 ) = iprot.readMapBegin()
16104 
          for _i363 in xrange(_size359):
16105 
            _key364 = iprot.readString();
16106 
            _val365 = iprot.readString();
16107 
            self.local_connected_orders[_key364] = _val365
4910 phani.kuma 16108 
          iprot.readMapEnd()
16109 
        else:
16110 
          iprot.skip(ftype)
16111 
      else:
16112 
        iprot.skip(ftype)
16113 
      iprot.readFieldEnd()
16114 
    iprot.readStructEnd()
16115 
 
16116 
  def write(self, oprot):
16117 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16118 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16119 
      return
16120 
    oprot.writeStructBegin('markOrdersAsLocalConnected_args')
16121 
    if self.providerId is not None:
16122 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
16123 
      oprot.writeI64(self.providerId)
16124 
      oprot.writeFieldEnd()
16125 
    if self.local_connected_orders is not None:
16126 
      oprot.writeFieldBegin('local_connected_orders', TType.MAP, 2)
16127 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.local_connected_orders))
6188 rajveer 16128 
      for kiter366,viter367 in self.local_connected_orders.items():
16129 
        oprot.writeString(kiter366)
16130 
        oprot.writeString(viter367)
4910 phani.kuma 16131 
      oprot.writeMapEnd()
16132 
      oprot.writeFieldEnd()
16133 
    oprot.writeFieldStop()
16134 
    oprot.writeStructEnd()
16135 
 
16136 
  def validate(self):
16137 
    return
16138 
 
16139 
 
16140 
  def __repr__(self):
16141 
    L = ['%s=%r' % (key, value)
16142 
      for key, value in self.__dict__.iteritems()]
16143 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16144 
 
16145 
  def __eq__(self, other):
16146 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16147 
 
16148 
  def __ne__(self, other):
16149 
    return not (self == other)
16150 
 
16151 
class markOrdersAsLocalConnected_result:
16152 
  """
16153 
  Attributes:
16154 
   - ex
16155 
  """
16156 
 
16157 
  thrift_spec = (
16158 
    None, # 0
16159 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
16160 
  )
16161 
 
16162 
  def __init__(self, ex=None,):
16163 
    self.ex = ex
16164 
 
16165 
  def read(self, iprot):
16166 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16167 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16168 
      return
16169 
    iprot.readStructBegin()
16170 
    while True:
16171 
      (fname, ftype, fid) = iprot.readFieldBegin()
16172 
      if ftype == TType.STOP:
16173 
        break
16174 
      if fid == 1:
3064 chandransh 16175 
        if ftype == TType.STRUCT:
16176 
          self.ex = TransactionServiceException()
16177 
          self.ex.read(iprot)
1627 ankur.sing 16178 
        else:
16179 
          iprot.skip(ftype)
16180 
      else:
16181 
        iprot.skip(ftype)
16182 
      iprot.readFieldEnd()
16183 
    iprot.readStructEnd()
16184 
 
16185 
  def write(self, oprot):
16186 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16187 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16188 
      return
4910 phani.kuma 16189 
    oprot.writeStructBegin('markOrdersAsLocalConnected_result')
16190 
    if self.ex is not None:
16191 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
16192 
      self.ex.write(oprot)
16193 
      oprot.writeFieldEnd()
16194 
    oprot.writeFieldStop()
16195 
    oprot.writeStructEnd()
16196 
 
16197 
  def validate(self):
16198 
    return
16199 
 
16200 
 
16201 
  def __repr__(self):
16202 
    L = ['%s=%r' % (key, value)
16203 
      for key, value in self.__dict__.iteritems()]
16204 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16205 
 
16206 
  def __eq__(self, other):
16207 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16208 
 
16209 
  def __ne__(self, other):
16210 
    return not (self == other)
16211 
 
16212 
class getOrdersNotLocalConnected_args:
16213 
  """
16214 
  Attributes:
16215 
   - providerId
16216 
  """
16217 
 
16218 
  thrift_spec = (
16219 
    None, # 0
16220 
    (1, TType.I64, 'providerId', None, None, ), # 1
16221 
  )
16222 
 
16223 
  def __init__(self, providerId=None,):
16224 
    self.providerId = providerId
16225 
 
16226 
  def read(self, iprot):
16227 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16228 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16229 
      return
16230 
    iprot.readStructBegin()
16231 
    while True:
16232 
      (fname, ftype, fid) = iprot.readFieldBegin()
16233 
      if ftype == TType.STOP:
16234 
        break
16235 
      if fid == 1:
16236 
        if ftype == TType.I64:
16237 
          self.providerId = iprot.readI64();
16238 
        else:
16239 
          iprot.skip(ftype)
16240 
      else:
16241 
        iprot.skip(ftype)
16242 
      iprot.readFieldEnd()
16243 
    iprot.readStructEnd()
16244 
 
16245 
  def write(self, oprot):
16246 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16247 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16248 
      return
16249 
    oprot.writeStructBegin('getOrdersNotLocalConnected_args')
16250 
    if self.providerId is not None:
16251 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
16252 
      oprot.writeI64(self.providerId)
16253 
      oprot.writeFieldEnd()
16254 
    oprot.writeFieldStop()
16255 
    oprot.writeStructEnd()
16256 
 
16257 
  def validate(self):
16258 
    return
16259 
 
16260 
 
16261 
  def __repr__(self):
16262 
    L = ['%s=%r' % (key, value)
16263 
      for key, value in self.__dict__.iteritems()]
16264 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16265 
 
16266 
  def __eq__(self, other):
16267 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16268 
 
16269 
  def __ne__(self, other):
16270 
    return not (self == other)
16271 
 
16272 
class getOrdersNotLocalConnected_result:
16273 
  """
16274 
  Attributes:
16275 
   - success
16276 
  """
16277 
 
16278 
  thrift_spec = (
16279 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
16280 
  )
16281 
 
16282 
  def __init__(self, success=None,):
16283 
    self.success = success
16284 
 
16285 
  def read(self, iprot):
16286 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16287 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16288 
      return
16289 
    iprot.readStructBegin()
16290 
    while True:
16291 
      (fname, ftype, fid) = iprot.readFieldBegin()
16292 
      if ftype == TType.STOP:
16293 
        break
16294 
      if fid == 0:
16295 
        if ftype == TType.LIST:
16296 
          self.success = []
6188 rajveer 16297 
          (_etype371, _size368) = iprot.readListBegin()
16298 
          for _i372 in xrange(_size368):
16299 
            _elem373 = Order()
16300 
            _elem373.read(iprot)
16301 
            self.success.append(_elem373)
4910 phani.kuma 16302 
          iprot.readListEnd()
16303 
        else:
16304 
          iprot.skip(ftype)
16305 
      else:
16306 
        iprot.skip(ftype)
16307 
      iprot.readFieldEnd()
16308 
    iprot.readStructEnd()
16309 
 
16310 
  def write(self, oprot):
16311 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16312 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16313 
      return
16314 
    oprot.writeStructBegin('getOrdersNotLocalConnected_result')
4581 phani.kuma 16315 
    if self.success is not None:
16316 
      oprot.writeFieldBegin('success', TType.LIST, 0)
16317 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 16318 
      for iter374 in self.success:
16319 
        iter374.write(oprot)
4581 phani.kuma 16320 
      oprot.writeListEnd()
16321 
      oprot.writeFieldEnd()
4910 phani.kuma 16322 
    oprot.writeFieldStop()
16323 
    oprot.writeStructEnd()
16324 
 
16325 
  def validate(self):
16326 
    return
16327 
 
16328 
 
16329 
  def __repr__(self):
16330 
    L = ['%s=%r' % (key, value)
16331 
      for key, value in self.__dict__.iteritems()]
16332 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16333 
 
16334 
  def __eq__(self, other):
16335 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16336 
 
16337 
  def __ne__(self, other):
16338 
    return not (self == other)
16339 
 
16340 
class markOrdersAsDestinationCityReached_args:
16341 
  """
16342 
  Attributes:
16343 
   - providerId
16344 
   - destination_city_reached_orders
16345 
  """
16346 
 
16347 
  thrift_spec = (
16348 
    None, # 0
16349 
    (1, TType.I64, 'providerId', None, None, ), # 1
16350 
    (2, TType.MAP, 'destination_city_reached_orders', (TType.STRING,None,TType.STRING,None), None, ), # 2
16351 
  )
16352 
 
16353 
  def __init__(self, providerId=None, destination_city_reached_orders=None,):
16354 
    self.providerId = providerId
16355 
    self.destination_city_reached_orders = destination_city_reached_orders
16356 
 
16357 
  def read(self, iprot):
16358 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16359 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16360 
      return
16361 
    iprot.readStructBegin()
16362 
    while True:
16363 
      (fname, ftype, fid) = iprot.readFieldBegin()
16364 
      if ftype == TType.STOP:
16365 
        break
16366 
      if fid == 1:
16367 
        if ftype == TType.I64:
16368 
          self.providerId = iprot.readI64();
16369 
        else:
16370 
          iprot.skip(ftype)
16371 
      elif fid == 2:
16372 
        if ftype == TType.MAP:
16373 
          self.destination_city_reached_orders = {}
6188 rajveer 16374 
          (_ktype376, _vtype377, _size375 ) = iprot.readMapBegin()
16375 
          for _i379 in xrange(_size375):
16376 
            _key380 = iprot.readString();
16377 
            _val381 = iprot.readString();
16378 
            self.destination_city_reached_orders[_key380] = _val381
4910 phani.kuma 16379 
          iprot.readMapEnd()
16380 
        else:
16381 
          iprot.skip(ftype)
16382 
      else:
16383 
        iprot.skip(ftype)
16384 
      iprot.readFieldEnd()
16385 
    iprot.readStructEnd()
16386 
 
16387 
  def write(self, oprot):
16388 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16389 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16390 
      return
16391 
    oprot.writeStructBegin('markOrdersAsDestinationCityReached_args')
16392 
    if self.providerId is not None:
16393 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
16394 
      oprot.writeI64(self.providerId)
16395 
      oprot.writeFieldEnd()
16396 
    if self.destination_city_reached_orders is not None:
16397 
      oprot.writeFieldBegin('destination_city_reached_orders', TType.MAP, 2)
16398 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.destination_city_reached_orders))
6188 rajveer 16399 
      for kiter382,viter383 in self.destination_city_reached_orders.items():
16400 
        oprot.writeString(kiter382)
16401 
        oprot.writeString(viter383)
4910 phani.kuma 16402 
      oprot.writeMapEnd()
16403 
      oprot.writeFieldEnd()
16404 
    oprot.writeFieldStop()
16405 
    oprot.writeStructEnd()
16406 
 
16407 
  def validate(self):
16408 
    return
16409 
 
16410 
 
16411 
  def __repr__(self):
16412 
    L = ['%s=%r' % (key, value)
16413 
      for key, value in self.__dict__.iteritems()]
16414 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16415 
 
16416 
  def __eq__(self, other):
16417 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16418 
 
16419 
  def __ne__(self, other):
16420 
    return not (self == other)
16421 
 
16422 
class markOrdersAsDestinationCityReached_result:
16423 
  """
16424 
  Attributes:
16425 
   - ex
16426 
  """
16427 
 
16428 
  thrift_spec = (
16429 
    None, # 0
16430 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
16431 
  )
16432 
 
16433 
  def __init__(self, ex=None,):
16434 
    self.ex = ex
16435 
 
16436 
  def read(self, iprot):
16437 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16438 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16439 
      return
16440 
    iprot.readStructBegin()
16441 
    while True:
16442 
      (fname, ftype, fid) = iprot.readFieldBegin()
16443 
      if ftype == TType.STOP:
16444 
        break
16445 
      if fid == 1:
16446 
        if ftype == TType.STRUCT:
16447 
          self.ex = TransactionServiceException()
16448 
          self.ex.read(iprot)
16449 
        else:
16450 
          iprot.skip(ftype)
16451 
      else:
16452 
        iprot.skip(ftype)
16453 
      iprot.readFieldEnd()
16454 
    iprot.readStructEnd()
16455 
 
16456 
  def write(self, oprot):
16457 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16458 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16459 
      return
16460 
    oprot.writeStructBegin('markOrdersAsDestinationCityReached_result')
3431 rajveer 16461 
    if self.ex is not None:
3064 chandransh 16462 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
16463 
      self.ex.write(oprot)
1627 ankur.sing 16464 
      oprot.writeFieldEnd()
16465 
    oprot.writeFieldStop()
16466 
    oprot.writeStructEnd()
16467 
 
3431 rajveer 16468 
  def validate(self):
16469 
    return
16470 
 
16471 
 
1627 ankur.sing 16472 
  def __repr__(self):
16473 
    L = ['%s=%r' % (key, value)
16474 
      for key, value in self.__dict__.iteritems()]
16475 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16476 
 
16477 
  def __eq__(self, other):
16478 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16479 
 
16480 
  def __ne__(self, other):
16481 
    return not (self == other)
16482 
 
4910 phani.kuma 16483 
class markOrdersAsFirstDeliveryAttempted_args:
16484 
  """
16485 
  Attributes:
16486 
   - providerId
16487 
   - first_atdl_orders
16488 
  """
16489 
 
16490 
  thrift_spec = (
16491 
    None, # 0
16492 
    (1, TType.I64, 'providerId', None, None, ), # 1
16493 
    (2, TType.MAP, 'first_atdl_orders', (TType.STRING,None,TType.STRING,None), None, ), # 2
16494 
  )
16495 
 
16496 
  def __init__(self, providerId=None, first_atdl_orders=None,):
16497 
    self.providerId = providerId
16498 
    self.first_atdl_orders = first_atdl_orders
16499 
 
16500 
  def read(self, iprot):
16501 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16502 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16503 
      return
16504 
    iprot.readStructBegin()
16505 
    while True:
16506 
      (fname, ftype, fid) = iprot.readFieldBegin()
16507 
      if ftype == TType.STOP:
16508 
        break
16509 
      if fid == 1:
16510 
        if ftype == TType.I64:
16511 
          self.providerId = iprot.readI64();
16512 
        else:
16513 
          iprot.skip(ftype)
16514 
      elif fid == 2:
16515 
        if ftype == TType.MAP:
16516 
          self.first_atdl_orders = {}
6188 rajveer 16517 
          (_ktype385, _vtype386, _size384 ) = iprot.readMapBegin()
16518 
          for _i388 in xrange(_size384):
16519 
            _key389 = iprot.readString();
16520 
            _val390 = iprot.readString();
16521 
            self.first_atdl_orders[_key389] = _val390
4910 phani.kuma 16522 
          iprot.readMapEnd()
16523 
        else:
16524 
          iprot.skip(ftype)
16525 
      else:
16526 
        iprot.skip(ftype)
16527 
      iprot.readFieldEnd()
16528 
    iprot.readStructEnd()
16529 
 
16530 
  def write(self, oprot):
16531 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16532 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16533 
      return
16534 
    oprot.writeStructBegin('markOrdersAsFirstDeliveryAttempted_args')
16535 
    if self.providerId is not None:
16536 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
16537 
      oprot.writeI64(self.providerId)
16538 
      oprot.writeFieldEnd()
16539 
    if self.first_atdl_orders is not None:
16540 
      oprot.writeFieldBegin('first_atdl_orders', TType.MAP, 2)
16541 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.first_atdl_orders))
6188 rajveer 16542 
      for kiter391,viter392 in self.first_atdl_orders.items():
16543 
        oprot.writeString(kiter391)
16544 
        oprot.writeString(viter392)
4910 phani.kuma 16545 
      oprot.writeMapEnd()
16546 
      oprot.writeFieldEnd()
16547 
    oprot.writeFieldStop()
16548 
    oprot.writeStructEnd()
16549 
 
16550 
  def validate(self):
16551 
    return
16552 
 
16553 
 
16554 
  def __repr__(self):
16555 
    L = ['%s=%r' % (key, value)
16556 
      for key, value in self.__dict__.iteritems()]
16557 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16558 
 
16559 
  def __eq__(self, other):
16560 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16561 
 
16562 
  def __ne__(self, other):
16563 
    return not (self == other)
16564 
 
16565 
class markOrdersAsFirstDeliveryAttempted_result:
16566 
  """
16567 
  Attributes:
16568 
   - ex
16569 
  """
16570 
 
16571 
  thrift_spec = (
16572 
    None, # 0
16573 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
16574 
  )
16575 
 
16576 
  def __init__(self, ex=None,):
16577 
    self.ex = ex
16578 
 
16579 
  def read(self, iprot):
16580 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16581 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16582 
      return
16583 
    iprot.readStructBegin()
16584 
    while True:
16585 
      (fname, ftype, fid) = iprot.readFieldBegin()
16586 
      if ftype == TType.STOP:
16587 
        break
16588 
      if fid == 1:
16589 
        if ftype == TType.STRUCT:
16590 
          self.ex = TransactionServiceException()
16591 
          self.ex.read(iprot)
16592 
        else:
16593 
          iprot.skip(ftype)
16594 
      else:
16595 
        iprot.skip(ftype)
16596 
      iprot.readFieldEnd()
16597 
    iprot.readStructEnd()
16598 
 
16599 
  def write(self, oprot):
16600 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16601 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16602 
      return
16603 
    oprot.writeStructBegin('markOrdersAsFirstDeliveryAttempted_result')
16604 
    if self.ex is not None:
16605 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
16606 
      self.ex.write(oprot)
16607 
      oprot.writeFieldEnd()
16608 
    oprot.writeFieldStop()
16609 
    oprot.writeStructEnd()
16610 
 
16611 
  def validate(self):
16612 
    return
16613 
 
16614 
 
16615 
  def __repr__(self):
16616 
    L = ['%s=%r' % (key, value)
16617 
      for key, value in self.__dict__.iteritems()]
16618 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16619 
 
16620 
  def __eq__(self, other):
16621 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16622 
 
16623 
  def __ne__(self, other):
16624 
    return not (self == other)
16625 
 
3064 chandransh 16626 
class getUndeliveredOrders_args:
1886 ankur.sing 16627 
  """
16628 
  Attributes:
3064 chandransh 16629 
   - providerId
16630 
   - warehouseId
1886 ankur.sing 16631 
  """
1627 ankur.sing 16632 
 
1886 ankur.sing 16633 
  thrift_spec = (
16634 
    None, # 0
3064 chandransh 16635 
    (1, TType.I64, 'providerId', None, None, ), # 1
16636 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
1886 ankur.sing 16637 
  )
16638 
 
3064 chandransh 16639 
  def __init__(self, providerId=None, warehouseId=None,):
16640 
    self.providerId = providerId
16641 
    self.warehouseId = warehouseId
1886 ankur.sing 16642 
 
16643 
  def read(self, iprot):
16644 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16645 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16646 
      return
16647 
    iprot.readStructBegin()
16648 
    while True:
16649 
      (fname, ftype, fid) = iprot.readFieldBegin()
16650 
      if ftype == TType.STOP:
16651 
        break
16652 
      if fid == 1:
16653 
        if ftype == TType.I64:
3064 chandransh 16654 
          self.providerId = iprot.readI64();
1886 ankur.sing 16655 
        else:
16656 
          iprot.skip(ftype)
3064 chandransh 16657 
      elif fid == 2:
16658 
        if ftype == TType.I64:
16659 
          self.warehouseId = iprot.readI64();
16660 
        else:
16661 
          iprot.skip(ftype)
1886 ankur.sing 16662 
      else:
16663 
        iprot.skip(ftype)
16664 
      iprot.readFieldEnd()
16665 
    iprot.readStructEnd()
16666 
 
16667 
  def write(self, oprot):
16668 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16669 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16670 
      return
3064 chandransh 16671 
    oprot.writeStructBegin('getUndeliveredOrders_args')
3431 rajveer 16672 
    if self.providerId is not None:
3064 chandransh 16673 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
16674 
      oprot.writeI64(self.providerId)
1886 ankur.sing 16675 
      oprot.writeFieldEnd()
3431 rajveer 16676 
    if self.warehouseId is not None:
3064 chandransh 16677 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
16678 
      oprot.writeI64(self.warehouseId)
16679 
      oprot.writeFieldEnd()
1886 ankur.sing 16680 
    oprot.writeFieldStop()
16681 
    oprot.writeStructEnd()
16682 
 
3431 rajveer 16683 
  def validate(self):
16684 
    return
16685 
 
16686 
 
1886 ankur.sing 16687 
  def __repr__(self):
16688 
    L = ['%s=%r' % (key, value)
16689 
      for key, value in self.__dict__.iteritems()]
16690 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16691 
 
16692 
  def __eq__(self, other):
16693 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16694 
 
16695 
  def __ne__(self, other):
16696 
    return not (self == other)
16697 
 
3064 chandransh 16698 
class getUndeliveredOrders_result:
1886 ankur.sing 16699 
  """
16700 
  Attributes:
16701 
   - success
16702 
  """
16703 
 
16704 
  thrift_spec = (
16705 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
16706 
  )
16707 
 
16708 
  def __init__(self, success=None,):
16709 
    self.success = success
16710 
 
16711 
  def read(self, iprot):
16712 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16713 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16714 
      return
16715 
    iprot.readStructBegin()
16716 
    while True:
16717 
      (fname, ftype, fid) = iprot.readFieldBegin()
16718 
      if ftype == TType.STOP:
16719 
        break
16720 
      if fid == 0:
16721 
        if ftype == TType.LIST:
16722 
          self.success = []
6188 rajveer 16723 
          (_etype396, _size393) = iprot.readListBegin()
16724 
          for _i397 in xrange(_size393):
16725 
            _elem398 = Order()
16726 
            _elem398.read(iprot)
16727 
            self.success.append(_elem398)
1886 ankur.sing 16728 
          iprot.readListEnd()
16729 
        else:
16730 
          iprot.skip(ftype)
16731 
      else:
16732 
        iprot.skip(ftype)
16733 
      iprot.readFieldEnd()
16734 
    iprot.readStructEnd()
16735 
 
16736 
  def write(self, oprot):
16737 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16738 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16739 
      return
3064 chandransh 16740 
    oprot.writeStructBegin('getUndeliveredOrders_result')
3431 rajveer 16741 
    if self.success is not None:
1886 ankur.sing 16742 
      oprot.writeFieldBegin('success', TType.LIST, 0)
16743 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 16744 
      for iter399 in self.success:
16745 
        iter399.write(oprot)
1886 ankur.sing 16746 
      oprot.writeListEnd()
16747 
      oprot.writeFieldEnd()
16748 
    oprot.writeFieldStop()
16749 
    oprot.writeStructEnd()
16750 
 
3431 rajveer 16751 
  def validate(self):
16752 
    return
16753 
 
16754 
 
1886 ankur.sing 16755 
  def __repr__(self):
16756 
    L = ['%s=%r' % (key, value)
16757 
      for key, value in self.__dict__.iteritems()]
16758 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16759 
 
16760 
  def __eq__(self, other):
16761 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16762 
 
16763 
  def __ne__(self, other):
16764 
    return not (self == other)
16765 
 
4783 phani.kuma 16766 
class getUndeliveredOrdersExpectedDeliveryDateNotMet_args:
16767 
 
16768 
  thrift_spec = (
16769 
  )
16770 
 
16771 
  def read(self, iprot):
16772 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16773 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16774 
      return
16775 
    iprot.readStructBegin()
16776 
    while True:
16777 
      (fname, ftype, fid) = iprot.readFieldBegin()
16778 
      if ftype == TType.STOP:
16779 
        break
16780 
      else:
16781 
        iprot.skip(ftype)
16782 
      iprot.readFieldEnd()
16783 
    iprot.readStructEnd()
16784 
 
16785 
  def write(self, oprot):
16786 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16787 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16788 
      return
16789 
    oprot.writeStructBegin('getUndeliveredOrdersExpectedDeliveryDateNotMet_args')
16790 
    oprot.writeFieldStop()
16791 
    oprot.writeStructEnd()
16792 
 
16793 
  def validate(self):
16794 
    return
16795 
 
16796 
 
16797 
  def __repr__(self):
16798 
    L = ['%s=%r' % (key, value)
16799 
      for key, value in self.__dict__.iteritems()]
16800 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16801 
 
16802 
  def __eq__(self, other):
16803 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16804 
 
16805 
  def __ne__(self, other):
16806 
    return not (self == other)
16807 
 
16808 
class getUndeliveredOrdersExpectedDeliveryDateNotMet_result:
16809 
  """
16810 
  Attributes:
16811 
   - success
16812 
  """
16813 
 
16814 
  thrift_spec = (
16815 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
16816 
  )
16817 
 
16818 
  def __init__(self, success=None,):
16819 
    self.success = success
16820 
 
16821 
  def read(self, iprot):
16822 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16823 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16824 
      return
16825 
    iprot.readStructBegin()
16826 
    while True:
16827 
      (fname, ftype, fid) = iprot.readFieldBegin()
16828 
      if ftype == TType.STOP:
16829 
        break
16830 
      if fid == 0:
16831 
        if ftype == TType.LIST:
16832 
          self.success = []
6188 rajveer 16833 
          (_etype403, _size400) = iprot.readListBegin()
16834 
          for _i404 in xrange(_size400):
16835 
            _elem405 = Order()
16836 
            _elem405.read(iprot)
16837 
            self.success.append(_elem405)
4783 phani.kuma 16838 
          iprot.readListEnd()
16839 
        else:
16840 
          iprot.skip(ftype)
16841 
      else:
16842 
        iprot.skip(ftype)
16843 
      iprot.readFieldEnd()
16844 
    iprot.readStructEnd()
16845 
 
16846 
  def write(self, oprot):
16847 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16848 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16849 
      return
16850 
    oprot.writeStructBegin('getUndeliveredOrdersExpectedDeliveryDateNotMet_result')
16851 
    if self.success is not None:
16852 
      oprot.writeFieldBegin('success', TType.LIST, 0)
16853 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 16854 
      for iter406 in self.success:
16855 
        iter406.write(oprot)
4783 phani.kuma 16856 
      oprot.writeListEnd()
16857 
      oprot.writeFieldEnd()
16858 
    oprot.writeFieldStop()
16859 
    oprot.writeStructEnd()
16860 
 
16861 
  def validate(self):
16862 
    return
16863 
 
16864 
 
16865 
  def __repr__(self):
16866 
    L = ['%s=%r' % (key, value)
16867 
      for key, value in self.__dict__.iteritems()]
16868 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16869 
 
16870 
  def __eq__(self, other):
16871 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16872 
 
16873 
  def __ne__(self, other):
16874 
    return not (self == other)
16875 
 
2536 chandransh 16876 
class toggleDOAFlag_args:
16877 
  """
16878 
  Attributes:
16879 
   - orderId
16880 
  """
1886 ankur.sing 16881 
 
2536 chandransh 16882 
  thrift_spec = (
16883 
    None, # 0
16884 
    (1, TType.I64, 'orderId', None, None, ), # 1
16885 
  )
16886 
 
16887 
  def __init__(self, orderId=None,):
16888 
    self.orderId = orderId
16889 
 
16890 
  def read(self, iprot):
16891 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16892 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16893 
      return
16894 
    iprot.readStructBegin()
16895 
    while True:
16896 
      (fname, ftype, fid) = iprot.readFieldBegin()
16897 
      if ftype == TType.STOP:
16898 
        break
16899 
      if fid == 1:
16900 
        if ftype == TType.I64:
16901 
          self.orderId = iprot.readI64();
16902 
        else:
16903 
          iprot.skip(ftype)
16904 
      else:
16905 
        iprot.skip(ftype)
16906 
      iprot.readFieldEnd()
16907 
    iprot.readStructEnd()
16908 
 
16909 
  def write(self, oprot):
16910 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16911 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16912 
      return
16913 
    oprot.writeStructBegin('toggleDOAFlag_args')
3431 rajveer 16914 
    if self.orderId is not None:
2536 chandransh 16915 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
16916 
      oprot.writeI64(self.orderId)
16917 
      oprot.writeFieldEnd()
16918 
    oprot.writeFieldStop()
16919 
    oprot.writeStructEnd()
16920 
 
3431 rajveer 16921 
  def validate(self):
16922 
    return
16923 
 
16924 
 
2536 chandransh 16925 
  def __repr__(self):
16926 
    L = ['%s=%r' % (key, value)
16927 
      for key, value in self.__dict__.iteritems()]
16928 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16929 
 
16930 
  def __eq__(self, other):
16931 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16932 
 
16933 
  def __ne__(self, other):
16934 
    return not (self == other)
16935 
 
16936 
class toggleDOAFlag_result:
16937 
  """
16938 
  Attributes:
16939 
   - success
16940 
   - ex
16941 
  """
16942 
 
16943 
  thrift_spec = (
16944 
    (0, TType.BOOL, 'success', None, None, ), # 0
16945 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
16946 
  )
16947 
 
16948 
  def __init__(self, success=None, ex=None,):
16949 
    self.success = success
16950 
    self.ex = ex
16951 
 
16952 
  def read(self, iprot):
16953 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16954 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16955 
      return
16956 
    iprot.readStructBegin()
16957 
    while True:
16958 
      (fname, ftype, fid) = iprot.readFieldBegin()
16959 
      if ftype == TType.STOP:
16960 
        break
16961 
      if fid == 0:
16962 
        if ftype == TType.BOOL:
16963 
          self.success = iprot.readBool();
16964 
        else:
16965 
          iprot.skip(ftype)
16966 
      elif fid == 1:
16967 
        if ftype == TType.STRUCT:
16968 
          self.ex = TransactionServiceException()
16969 
          self.ex.read(iprot)
16970 
        else:
16971 
          iprot.skip(ftype)
16972 
      else:
16973 
        iprot.skip(ftype)
16974 
      iprot.readFieldEnd()
16975 
    iprot.readStructEnd()
16976 
 
16977 
  def write(self, oprot):
16978 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16979 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16980 
      return
16981 
    oprot.writeStructBegin('toggleDOAFlag_result')
3431 rajveer 16982 
    if self.success is not None:
2536 chandransh 16983 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
16984 
      oprot.writeBool(self.success)
16985 
      oprot.writeFieldEnd()
3431 rajveer 16986 
    if self.ex is not None:
2536 chandransh 16987 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
16988 
      self.ex.write(oprot)
16989 
      oprot.writeFieldEnd()
16990 
    oprot.writeFieldStop()
16991 
    oprot.writeStructEnd()
16992 
 
3431 rajveer 16993 
  def validate(self):
16994 
    return
16995 
 
16996 
 
2536 chandransh 16997 
  def __repr__(self):
16998 
    L = ['%s=%r' % (key, value)
16999 
      for key, value in self.__dict__.iteritems()]
17000 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17001 
 
17002 
  def __eq__(self, other):
17003 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17004 
 
17005 
  def __ne__(self, other):
17006 
    return not (self == other)
17007 
 
4712 rajveer 17008 
class markOrderAsDelivered_args:
17009 
  """
17010 
  Attributes:
17011 
   - orderId
17012 
   - deliveryTimestamp
17013 
   - receiver
17014 
  """
17015 
 
17016 
  thrift_spec = None
17017 
  def __init__(self, orderId=None, deliveryTimestamp=None, receiver=None,):
17018 
    self.orderId = orderId
17019 
    self.deliveryTimestamp = deliveryTimestamp
17020 
    self.receiver = receiver
17021 
 
17022 
  def read(self, iprot):
17023 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17024 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17025 
      return
17026 
    iprot.readStructBegin()
17027 
    while True:
17028 
      (fname, ftype, fid) = iprot.readFieldBegin()
17029 
      if ftype == TType.STOP:
17030 
        break
17031 
      if fid == 1:
17032 
        if ftype == TType.I64:
17033 
          self.orderId = iprot.readI64();
17034 
        else:
17035 
          iprot.skip(ftype)
17036 
      elif fid == 2:
17037 
        if ftype == TType.I64:
17038 
          self.deliveryTimestamp = iprot.readI64();
17039 
        else:
17040 
          iprot.skip(ftype)
17041 
      elif fid == -1:
17042 
        if ftype == TType.STRING:
17043 
          self.receiver = iprot.readString();
17044 
        else:
17045 
          iprot.skip(ftype)
17046 
      else:
17047 
        iprot.skip(ftype)
17048 
      iprot.readFieldEnd()
17049 
    iprot.readStructEnd()
17050 
 
17051 
  def write(self, oprot):
17052 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17053 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17054 
      return
17055 
    oprot.writeStructBegin('markOrderAsDelivered_args')
17056 
    if self.receiver is not None:
17057 
      oprot.writeFieldBegin('receiver', TType.STRING, -1)
17058 
      oprot.writeString(self.receiver)
17059 
      oprot.writeFieldEnd()
17060 
    if self.orderId is not None:
17061 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
17062 
      oprot.writeI64(self.orderId)
17063 
      oprot.writeFieldEnd()
17064 
    if self.deliveryTimestamp is not None:
17065 
      oprot.writeFieldBegin('deliveryTimestamp', TType.I64, 2)
17066 
      oprot.writeI64(self.deliveryTimestamp)
17067 
      oprot.writeFieldEnd()
17068 
    oprot.writeFieldStop()
17069 
    oprot.writeStructEnd()
17070 
 
17071 
  def validate(self):
17072 
    return
17073 
 
17074 
 
17075 
  def __repr__(self):
17076 
    L = ['%s=%r' % (key, value)
17077 
      for key, value in self.__dict__.iteritems()]
17078 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17079 
 
17080 
  def __eq__(self, other):
17081 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17082 
 
17083 
  def __ne__(self, other):
17084 
    return not (self == other)
17085 
 
17086 
class markOrderAsDelivered_result:
17087 
  """
17088 
  Attributes:
17089 
   - ex
17090 
  """
17091 
 
17092 
  thrift_spec = (
17093 
    None, # 0
17094 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
17095 
  )
17096 
 
17097 
  def __init__(self, ex=None,):
17098 
    self.ex = ex
17099 
 
17100 
  def read(self, iprot):
17101 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17102 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17103 
      return
17104 
    iprot.readStructBegin()
17105 
    while True:
17106 
      (fname, ftype, fid) = iprot.readFieldBegin()
17107 
      if ftype == TType.STOP:
17108 
        break
17109 
      if fid == 1:
17110 
        if ftype == TType.STRUCT:
17111 
          self.ex = TransactionServiceException()
17112 
          self.ex.read(iprot)
17113 
        else:
17114 
          iprot.skip(ftype)
17115 
      else:
17116 
        iprot.skip(ftype)
17117 
      iprot.readFieldEnd()
17118 
    iprot.readStructEnd()
17119 
 
17120 
  def write(self, oprot):
17121 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17122 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17123 
      return
17124 
    oprot.writeStructBegin('markOrderAsDelivered_result')
17125 
    if self.ex is not None:
17126 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
17127 
      self.ex.write(oprot)
17128 
      oprot.writeFieldEnd()
17129 
    oprot.writeFieldStop()
17130 
    oprot.writeStructEnd()
17131 
 
17132 
  def validate(self):
17133 
    return
17134 
 
17135 
 
17136 
  def __repr__(self):
17137 
    L = ['%s=%r' % (key, value)
17138 
      for key, value in self.__dict__.iteritems()]
17139 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17140 
 
17141 
  def __eq__(self, other):
17142 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17143 
 
17144 
  def __ne__(self, other):
17145 
    return not (self == other)
17146 
 
5553 rajveer 17147 
class markOrderAsReceivedAtStore_args:
17148 
  """
17149 
  Attributes:
17150 
   - orderId
17151 
   - deliveryTimestamp
17152 
  """
17153 
 
17154 
  thrift_spec = (
17155 
    None, # 0
17156 
    (1, TType.I64, 'orderId', None, None, ), # 1
17157 
    (2, TType.I64, 'deliveryTimestamp', None, None, ), # 2
17158 
  )
17159 
 
17160 
  def __init__(self, orderId=None, deliveryTimestamp=None,):
17161 
    self.orderId = orderId
17162 
    self.deliveryTimestamp = deliveryTimestamp
17163 
 
17164 
  def read(self, iprot):
17165 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17166 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17167 
      return
17168 
    iprot.readStructBegin()
17169 
    while True:
17170 
      (fname, ftype, fid) = iprot.readFieldBegin()
17171 
      if ftype == TType.STOP:
17172 
        break
17173 
      if fid == 1:
17174 
        if ftype == TType.I64:
17175 
          self.orderId = iprot.readI64();
17176 
        else:
17177 
          iprot.skip(ftype)
17178 
      elif fid == 2:
17179 
        if ftype == TType.I64:
17180 
          self.deliveryTimestamp = iprot.readI64();
17181 
        else:
17182 
          iprot.skip(ftype)
17183 
      else:
17184 
        iprot.skip(ftype)
17185 
      iprot.readFieldEnd()
17186 
    iprot.readStructEnd()
17187 
 
17188 
  def write(self, oprot):
17189 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17190 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17191 
      return
17192 
    oprot.writeStructBegin('markOrderAsReceivedAtStore_args')
17193 
    if self.orderId is not None:
17194 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
17195 
      oprot.writeI64(self.orderId)
17196 
      oprot.writeFieldEnd()
17197 
    if self.deliveryTimestamp is not None:
17198 
      oprot.writeFieldBegin('deliveryTimestamp', TType.I64, 2)
17199 
      oprot.writeI64(self.deliveryTimestamp)
17200 
      oprot.writeFieldEnd()
17201 
    oprot.writeFieldStop()
17202 
    oprot.writeStructEnd()
17203 
 
17204 
  def validate(self):
17205 
    return
17206 
 
17207 
 
17208 
  def __repr__(self):
17209 
    L = ['%s=%r' % (key, value)
17210 
      for key, value in self.__dict__.iteritems()]
17211 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17212 
 
17213 
  def __eq__(self, other):
17214 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17215 
 
17216 
  def __ne__(self, other):
17217 
    return not (self == other)
17218 
 
17219 
class markOrderAsReceivedAtStore_result:
17220 
  """
17221 
  Attributes:
17222 
   - ex
17223 
  """
17224 
 
17225 
  thrift_spec = (
17226 
    None, # 0
17227 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
17228 
  )
17229 
 
17230 
  def __init__(self, ex=None,):
17231 
    self.ex = ex
17232 
 
17233 
  def read(self, iprot):
17234 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17235 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17236 
      return
17237 
    iprot.readStructBegin()
17238 
    while True:
17239 
      (fname, ftype, fid) = iprot.readFieldBegin()
17240 
      if ftype == TType.STOP:
17241 
        break
17242 
      if fid == 1:
17243 
        if ftype == TType.STRUCT:
17244 
          self.ex = TransactionServiceException()
17245 
          self.ex.read(iprot)
17246 
        else:
17247 
          iprot.skip(ftype)
17248 
      else:
17249 
        iprot.skip(ftype)
17250 
      iprot.readFieldEnd()
17251 
    iprot.readStructEnd()
17252 
 
17253 
  def write(self, oprot):
17254 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17255 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17256 
      return
17257 
    oprot.writeStructBegin('markOrderAsReceivedAtStore_result')
17258 
    if self.ex is not None:
17259 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
17260 
      self.ex.write(oprot)
17261 
      oprot.writeFieldEnd()
17262 
    oprot.writeFieldStop()
17263 
    oprot.writeStructEnd()
17264 
 
17265 
  def validate(self):
17266 
    return
17267 
 
17268 
 
17269 
  def __repr__(self):
17270 
    L = ['%s=%r' % (key, value)
17271 
      for key, value in self.__dict__.iteritems()]
17272 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17273 
 
17274 
  def __eq__(self, other):
17275 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17276 
 
17277 
  def __ne__(self, other):
17278 
    return not (self == other)
17279 
 
4454 rajveer 17280 
class markOrderDoaRequestReceived_args:
17281 
  """
17282 
  Attributes:
17283 
   - orderId
17284 
  """
17285 
 
17286 
  thrift_spec = (
17287 
    None, # 0
17288 
    (1, TType.I64, 'orderId', None, None, ), # 1
17289 
  )
17290 
 
17291 
  def __init__(self, orderId=None,):
17292 
    self.orderId = orderId
17293 
 
17294 
  def read(self, iprot):
17295 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17296 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17297 
      return
17298 
    iprot.readStructBegin()
17299 
    while True:
17300 
      (fname, ftype, fid) = iprot.readFieldBegin()
17301 
      if ftype == TType.STOP:
17302 
        break
17303 
      if fid == 1:
17304 
        if ftype == TType.I64:
17305 
          self.orderId = iprot.readI64();
17306 
        else:
17307 
          iprot.skip(ftype)
17308 
      else:
17309 
        iprot.skip(ftype)
17310 
      iprot.readFieldEnd()
17311 
    iprot.readStructEnd()
17312 
 
17313 
  def write(self, oprot):
17314 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17315 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17316 
      return
17317 
    oprot.writeStructBegin('markOrderDoaRequestReceived_args')
17318 
    if self.orderId is not None:
17319 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
17320 
      oprot.writeI64(self.orderId)
17321 
      oprot.writeFieldEnd()
17322 
    oprot.writeFieldStop()
17323 
    oprot.writeStructEnd()
17324 
 
17325 
  def validate(self):
17326 
    return
17327 
 
17328 
 
17329 
  def __repr__(self):
17330 
    L = ['%s=%r' % (key, value)
17331 
      for key, value in self.__dict__.iteritems()]
17332 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17333 
 
17334 
  def __eq__(self, other):
17335 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17336 
 
17337 
  def __ne__(self, other):
17338 
    return not (self == other)
17339 
 
17340 
class markOrderDoaRequestReceived_result:
17341 
  """
17342 
  Attributes:
17343 
   - success
17344 
   - ex
17345 
  """
17346 
 
17347 
  thrift_spec = (
17348 
    (0, TType.BOOL, 'success', None, None, ), # 0
17349 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
17350 
  )
17351 
 
17352 
  def __init__(self, success=None, ex=None,):
17353 
    self.success = success
17354 
    self.ex = ex
17355 
 
17356 
  def read(self, iprot):
17357 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17358 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17359 
      return
17360 
    iprot.readStructBegin()
17361 
    while True:
17362 
      (fname, ftype, fid) = iprot.readFieldBegin()
17363 
      if ftype == TType.STOP:
17364 
        break
17365 
      if fid == 0:
17366 
        if ftype == TType.BOOL:
17367 
          self.success = iprot.readBool();
17368 
        else:
17369 
          iprot.skip(ftype)
17370 
      elif fid == 1:
17371 
        if ftype == TType.STRUCT:
17372 
          self.ex = TransactionServiceException()
17373 
          self.ex.read(iprot)
17374 
        else:
17375 
          iprot.skip(ftype)
17376 
      else:
17377 
        iprot.skip(ftype)
17378 
      iprot.readFieldEnd()
17379 
    iprot.readStructEnd()
17380 
 
17381 
  def write(self, oprot):
17382 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17383 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17384 
      return
17385 
    oprot.writeStructBegin('markOrderDoaRequestReceived_result')
17386 
    if self.success is not None:
17387 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
17388 
      oprot.writeBool(self.success)
17389 
      oprot.writeFieldEnd()
17390 
    if self.ex is not None:
17391 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
17392 
      self.ex.write(oprot)
17393 
      oprot.writeFieldEnd()
17394 
    oprot.writeFieldStop()
17395 
    oprot.writeStructEnd()
17396 
 
17397 
  def validate(self):
17398 
    return
17399 
 
17400 
 
17401 
  def __repr__(self):
17402 
    L = ['%s=%r' % (key, value)
17403 
      for key, value in self.__dict__.iteritems()]
17404 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17405 
 
17406 
  def __eq__(self, other):
17407 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17408 
 
17409 
  def __ne__(self, other):
17410 
    return not (self == other)
17411 
 
17412 
class markOrderDoaRequestAuthorized_args:
17413 
  """
17414 
  Attributes:
17415 
   - orderId
17416 
   - isAuthorized
17417 
  """
17418 
 
17419 
  thrift_spec = (
17420 
    None, # 0
17421 
    (1, TType.I64, 'orderId', None, None, ), # 1
17422 
    (2, TType.BOOL, 'isAuthorized', None, None, ), # 2
17423 
  )
17424 
 
17425 
  def __init__(self, orderId=None, isAuthorized=None,):
17426 
    self.orderId = orderId
17427 
    self.isAuthorized = isAuthorized
17428 
 
17429 
  def read(self, iprot):
17430 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17431 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17432 
      return
17433 
    iprot.readStructBegin()
17434 
    while True:
17435 
      (fname, ftype, fid) = iprot.readFieldBegin()
17436 
      if ftype == TType.STOP:
17437 
        break
17438 
      if fid == 1:
17439 
        if ftype == TType.I64:
17440 
          self.orderId = iprot.readI64();
17441 
        else:
17442 
          iprot.skip(ftype)
17443 
      elif fid == 2:
17444 
        if ftype == TType.BOOL:
17445 
          self.isAuthorized = iprot.readBool();
17446 
        else:
17447 
          iprot.skip(ftype)
17448 
      else:
17449 
        iprot.skip(ftype)
17450 
      iprot.readFieldEnd()
17451 
    iprot.readStructEnd()
17452 
 
17453 
  def write(self, oprot):
17454 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17455 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17456 
      return
17457 
    oprot.writeStructBegin('markOrderDoaRequestAuthorized_args')
17458 
    if self.orderId is not None:
17459 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
17460 
      oprot.writeI64(self.orderId)
17461 
      oprot.writeFieldEnd()
17462 
    if self.isAuthorized is not None:
17463 
      oprot.writeFieldBegin('isAuthorized', TType.BOOL, 2)
17464 
      oprot.writeBool(self.isAuthorized)
17465 
      oprot.writeFieldEnd()
17466 
    oprot.writeFieldStop()
17467 
    oprot.writeStructEnd()
17468 
 
17469 
  def validate(self):
17470 
    return
17471 
 
17472 
 
17473 
  def __repr__(self):
17474 
    L = ['%s=%r' % (key, value)
17475 
      for key, value in self.__dict__.iteritems()]
17476 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17477 
 
17478 
  def __eq__(self, other):
17479 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17480 
 
17481 
  def __ne__(self, other):
17482 
    return not (self == other)
17483 
 
17484 
class markOrderDoaRequestAuthorized_result:
17485 
  """
17486 
  Attributes:
17487 
   - success
17488 
   - ex
17489 
  """
17490 
 
17491 
  thrift_spec = (
17492 
    (0, TType.BOOL, 'success', None, None, ), # 0
17493 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
17494 
  )
17495 
 
17496 
  def __init__(self, success=None, ex=None,):
17497 
    self.success = success
17498 
    self.ex = ex
17499 
 
17500 
  def read(self, iprot):
17501 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17502 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17503 
      return
17504 
    iprot.readStructBegin()
17505 
    while True:
17506 
      (fname, ftype, fid) = iprot.readFieldBegin()
17507 
      if ftype == TType.STOP:
17508 
        break
17509 
      if fid == 0:
17510 
        if ftype == TType.BOOL:
17511 
          self.success = iprot.readBool();
17512 
        else:
17513 
          iprot.skip(ftype)
17514 
      elif fid == 1:
17515 
        if ftype == TType.STRUCT:
17516 
          self.ex = TransactionServiceException()
17517 
          self.ex.read(iprot)
17518 
        else:
17519 
          iprot.skip(ftype)
17520 
      else:
17521 
        iprot.skip(ftype)
17522 
      iprot.readFieldEnd()
17523 
    iprot.readStructEnd()
17524 
 
17525 
  def write(self, oprot):
17526 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17527 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17528 
      return
17529 
    oprot.writeStructBegin('markOrderDoaRequestAuthorized_result')
17530 
    if self.success is not None:
17531 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
17532 
      oprot.writeBool(self.success)
17533 
      oprot.writeFieldEnd()
17534 
    if self.ex is not None:
17535 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
17536 
      self.ex.write(oprot)
17537 
      oprot.writeFieldEnd()
17538 
    oprot.writeFieldStop()
17539 
    oprot.writeStructEnd()
17540 
 
17541 
  def validate(self):
17542 
    return
17543 
 
17544 
 
17545 
  def __repr__(self):
17546 
    L = ['%s=%r' % (key, value)
17547 
      for key, value in self.__dict__.iteritems()]
17548 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17549 
 
17550 
  def __eq__(self, other):
17551 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17552 
 
17553 
  def __ne__(self, other):
17554 
    return not (self == other)
17555 
 
4488 rajveer 17556 
class markOrderReturnRequestReceived_args:
17557 
  """
17558 
  Attributes:
17559 
   - orderId
17560 
  """
17561 
 
17562 
  thrift_spec = (
17563 
    None, # 0
17564 
    (1, TType.I64, 'orderId', None, None, ), # 1
17565 
  )
17566 
 
17567 
  def __init__(self, orderId=None,):
17568 
    self.orderId = orderId
17569 
 
17570 
  def read(self, iprot):
17571 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17572 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17573 
      return
17574 
    iprot.readStructBegin()
17575 
    while True:
17576 
      (fname, ftype, fid) = iprot.readFieldBegin()
17577 
      if ftype == TType.STOP:
17578 
        break
17579 
      if fid == 1:
17580 
        if ftype == TType.I64:
17581 
          self.orderId = iprot.readI64();
17582 
        else:
17583 
          iprot.skip(ftype)
17584 
      else:
17585 
        iprot.skip(ftype)
17586 
      iprot.readFieldEnd()
17587 
    iprot.readStructEnd()
17588 
 
17589 
  def write(self, oprot):
17590 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17591 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17592 
      return
17593 
    oprot.writeStructBegin('markOrderReturnRequestReceived_args')
17594 
    if self.orderId is not None:
17595 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
17596 
      oprot.writeI64(self.orderId)
17597 
      oprot.writeFieldEnd()
17598 
    oprot.writeFieldStop()
17599 
    oprot.writeStructEnd()
17600 
 
17601 
  def validate(self):
17602 
    return
17603 
 
17604 
 
17605 
  def __repr__(self):
17606 
    L = ['%s=%r' % (key, value)
17607 
      for key, value in self.__dict__.iteritems()]
17608 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17609 
 
17610 
  def __eq__(self, other):
17611 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17612 
 
17613 
  def __ne__(self, other):
17614 
    return not (self == other)
17615 
 
17616 
class markOrderReturnRequestReceived_result:
17617 
  """
17618 
  Attributes:
17619 
   - success
17620 
   - ex
17621 
  """
17622 
 
17623 
  thrift_spec = (
17624 
    (0, TType.BOOL, 'success', None, None, ), # 0
17625 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
17626 
  )
17627 
 
17628 
  def __init__(self, success=None, ex=None,):
17629 
    self.success = success
17630 
    self.ex = ex
17631 
 
17632 
  def read(self, iprot):
17633 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17634 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17635 
      return
17636 
    iprot.readStructBegin()
17637 
    while True:
17638 
      (fname, ftype, fid) = iprot.readFieldBegin()
17639 
      if ftype == TType.STOP:
17640 
        break
17641 
      if fid == 0:
17642 
        if ftype == TType.BOOL:
17643 
          self.success = iprot.readBool();
17644 
        else:
17645 
          iprot.skip(ftype)
17646 
      elif fid == 1:
17647 
        if ftype == TType.STRUCT:
17648 
          self.ex = TransactionServiceException()
17649 
          self.ex.read(iprot)
17650 
        else:
17651 
          iprot.skip(ftype)
17652 
      else:
17653 
        iprot.skip(ftype)
17654 
      iprot.readFieldEnd()
17655 
    iprot.readStructEnd()
17656 
 
17657 
  def write(self, oprot):
17658 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17659 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17660 
      return
17661 
    oprot.writeStructBegin('markOrderReturnRequestReceived_result')
17662 
    if self.success is not None:
17663 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
17664 
      oprot.writeBool(self.success)
17665 
      oprot.writeFieldEnd()
17666 
    if self.ex is not None:
17667 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
17668 
      self.ex.write(oprot)
17669 
      oprot.writeFieldEnd()
17670 
    oprot.writeFieldStop()
17671 
    oprot.writeStructEnd()
17672 
 
17673 
  def validate(self):
17674 
    return
17675 
 
17676 
 
17677 
  def __repr__(self):
17678 
    L = ['%s=%r' % (key, value)
17679 
      for key, value in self.__dict__.iteritems()]
17680 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17681 
 
17682 
  def __eq__(self, other):
17683 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17684 
 
17685 
  def __ne__(self, other):
17686 
    return not (self == other)
17687 
 
17688 
class markOrderReturnRequestAuthorized_args:
17689 
  """
17690 
  Attributes:
17691 
   - orderId
17692 
   - isAuthorized
17693 
  """
17694 
 
17695 
  thrift_spec = (
17696 
    None, # 0
17697 
    (1, TType.I64, 'orderId', None, None, ), # 1
17698 
    (2, TType.BOOL, 'isAuthorized', None, None, ), # 2
17699 
  )
17700 
 
17701 
  def __init__(self, orderId=None, isAuthorized=None,):
17702 
    self.orderId = orderId
17703 
    self.isAuthorized = isAuthorized
17704 
 
17705 
  def read(self, iprot):
17706 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17707 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17708 
      return
17709 
    iprot.readStructBegin()
17710 
    while True:
17711 
      (fname, ftype, fid) = iprot.readFieldBegin()
17712 
      if ftype == TType.STOP:
17713 
        break
17714 
      if fid == 1:
17715 
        if ftype == TType.I64:
17716 
          self.orderId = iprot.readI64();
17717 
        else:
17718 
          iprot.skip(ftype)
17719 
      elif fid == 2:
17720 
        if ftype == TType.BOOL:
17721 
          self.isAuthorized = iprot.readBool();
17722 
        else:
17723 
          iprot.skip(ftype)
17724 
      else:
17725 
        iprot.skip(ftype)
17726 
      iprot.readFieldEnd()
17727 
    iprot.readStructEnd()
17728 
 
17729 
  def write(self, oprot):
17730 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17731 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17732 
      return
17733 
    oprot.writeStructBegin('markOrderReturnRequestAuthorized_args')
17734 
    if self.orderId is not None:
17735 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
17736 
      oprot.writeI64(self.orderId)
17737 
      oprot.writeFieldEnd()
17738 
    if self.isAuthorized is not None:
17739 
      oprot.writeFieldBegin('isAuthorized', TType.BOOL, 2)
17740 
      oprot.writeBool(self.isAuthorized)
17741 
      oprot.writeFieldEnd()
17742 
    oprot.writeFieldStop()
17743 
    oprot.writeStructEnd()
17744 
 
17745 
  def validate(self):
17746 
    return
17747 
 
17748 
 
17749 
  def __repr__(self):
17750 
    L = ['%s=%r' % (key, value)
17751 
      for key, value in self.__dict__.iteritems()]
17752 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17753 
 
17754 
  def __eq__(self, other):
17755 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17756 
 
17757 
  def __ne__(self, other):
17758 
    return not (self == other)
17759 
 
17760 
class markOrderReturnRequestAuthorized_result:
17761 
  """
17762 
  Attributes:
17763 
   - success
17764 
   - ex
17765 
  """
17766 
 
17767 
  thrift_spec = (
17768 
    (0, TType.BOOL, 'success', None, None, ), # 0
17769 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
17770 
  )
17771 
 
17772 
  def __init__(self, success=None, ex=None,):
17773 
    self.success = success
17774 
    self.ex = ex
17775 
 
17776 
  def read(self, iprot):
17777 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17778 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17779 
      return
17780 
    iprot.readStructBegin()
17781 
    while True:
17782 
      (fname, ftype, fid) = iprot.readFieldBegin()
17783 
      if ftype == TType.STOP:
17784 
        break
17785 
      if fid == 0:
17786 
        if ftype == TType.BOOL:
17787 
          self.success = iprot.readBool();
17788 
        else:
17789 
          iprot.skip(ftype)
17790 
      elif fid == 1:
17791 
        if ftype == TType.STRUCT:
17792 
          self.ex = TransactionServiceException()
17793 
          self.ex.read(iprot)
17794 
        else:
17795 
          iprot.skip(ftype)
17796 
      else:
17797 
        iprot.skip(ftype)
17798 
      iprot.readFieldEnd()
17799 
    iprot.readStructEnd()
17800 
 
17801 
  def write(self, oprot):
17802 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17803 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17804 
      return
17805 
    oprot.writeStructBegin('markOrderReturnRequestAuthorized_result')
17806 
    if self.success is not None:
17807 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
17808 
      oprot.writeBool(self.success)
17809 
      oprot.writeFieldEnd()
17810 
    if self.ex is not None:
17811 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
17812 
      self.ex.write(oprot)
17813 
      oprot.writeFieldEnd()
17814 
    oprot.writeFieldStop()
17815 
    oprot.writeStructEnd()
17816 
 
17817 
  def validate(self):
17818 
    return
17819 
 
17820 
 
17821 
  def __repr__(self):
17822 
    L = ['%s=%r' % (key, value)
17823 
      for key, value in self.__dict__.iteritems()]
17824 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17825 
 
17826 
  def __eq__(self, other):
17827 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17828 
 
17829 
  def __ne__(self, other):
17830 
    return not (self == other)
17831 
 
2536 chandransh 17832 
class requestPickupNumber_args:
17833 
  """
17834 
  Attributes:
17835 
   - orderId
4579 rajveer 17836 
   - providerId
2536 chandransh 17837 
  """
17838 
 
17839 
  thrift_spec = (
17840 
    None, # 0
17841 
    (1, TType.I64, 'orderId', None, None, ), # 1
4579 rajveer 17842 
    (2, TType.I64, 'providerId', None, None, ), # 2
2536 chandransh 17843 
  )
17844 
 
4579 rajveer 17845 
  def __init__(self, orderId=None, providerId=None,):
2536 chandransh 17846 
    self.orderId = orderId
4579 rajveer 17847 
    self.providerId = providerId
2536 chandransh 17848 
 
17849 
  def read(self, iprot):
17850 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17851 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17852 
      return
17853 
    iprot.readStructBegin()
17854 
    while True:
17855 
      (fname, ftype, fid) = iprot.readFieldBegin()
17856 
      if ftype == TType.STOP:
17857 
        break
17858 
      if fid == 1:
17859 
        if ftype == TType.I64:
17860 
          self.orderId = iprot.readI64();
17861 
        else:
17862 
          iprot.skip(ftype)
4579 rajveer 17863 
      elif fid == 2:
17864 
        if ftype == TType.I64:
17865 
          self.providerId = iprot.readI64();
17866 
        else:
17867 
          iprot.skip(ftype)
2536 chandransh 17868 
      else:
17869 
        iprot.skip(ftype)
17870 
      iprot.readFieldEnd()
17871 
    iprot.readStructEnd()
17872 
 
17873 
  def write(self, oprot):
17874 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17875 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17876 
      return
17877 
    oprot.writeStructBegin('requestPickupNumber_args')
3431 rajveer 17878 
    if self.orderId is not None:
2536 chandransh 17879 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
17880 
      oprot.writeI64(self.orderId)
17881 
      oprot.writeFieldEnd()
4579 rajveer 17882 
    if self.providerId is not None:
17883 
      oprot.writeFieldBegin('providerId', TType.I64, 2)
17884 
      oprot.writeI64(self.providerId)
17885 
      oprot.writeFieldEnd()
2536 chandransh 17886 
    oprot.writeFieldStop()
17887 
    oprot.writeStructEnd()
17888 
 
3431 rajveer 17889 
  def validate(self):
17890 
    return
17891 
 
17892 
 
2536 chandransh 17893 
  def __repr__(self):
17894 
    L = ['%s=%r' % (key, value)
17895 
      for key, value in self.__dict__.iteritems()]
17896 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17897 
 
17898 
  def __eq__(self, other):
17899 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17900 
 
17901 
  def __ne__(self, other):
17902 
    return not (self == other)
17903 
 
17904 
class requestPickupNumber_result:
17905 
  """
17906 
  Attributes:
17907 
   - success
17908 
   - ex
17909 
  """
17910 
 
17911 
  thrift_spec = (
17912 
    (0, TType.BOOL, 'success', None, None, ), # 0
17913 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
17914 
  )
17915 
 
17916 
  def __init__(self, success=None, ex=None,):
17917 
    self.success = success
17918 
    self.ex = ex
17919 
 
17920 
  def read(self, iprot):
17921 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17922 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17923 
      return
17924 
    iprot.readStructBegin()
17925 
    while True:
17926 
      (fname, ftype, fid) = iprot.readFieldBegin()
17927 
      if ftype == TType.STOP:
17928 
        break
17929 
      if fid == 0:
17930 
        if ftype == TType.BOOL:
17931 
          self.success = iprot.readBool();
17932 
        else:
17933 
          iprot.skip(ftype)
17934 
      elif fid == 1:
17935 
        if ftype == TType.STRUCT:
17936 
          self.ex = TransactionServiceException()
17937 
          self.ex.read(iprot)
17938 
        else:
17939 
          iprot.skip(ftype)
17940 
      else:
17941 
        iprot.skip(ftype)
17942 
      iprot.readFieldEnd()
17943 
    iprot.readStructEnd()
17944 
 
17945 
  def write(self, oprot):
17946 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17947 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17948 
      return
17949 
    oprot.writeStructBegin('requestPickupNumber_result')
3431 rajveer 17950 
    if self.success is not None:
2536 chandransh 17951 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
17952 
      oprot.writeBool(self.success)
17953 
      oprot.writeFieldEnd()
3431 rajveer 17954 
    if self.ex is not None:
2536 chandransh 17955 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
17956 
      self.ex.write(oprot)
17957 
      oprot.writeFieldEnd()
17958 
    oprot.writeFieldStop()
17959 
    oprot.writeStructEnd()
17960 
 
3431 rajveer 17961 
  def validate(self):
17962 
    return
17963 
 
17964 
 
2536 chandransh 17965 
  def __repr__(self):
17966 
    L = ['%s=%r' % (key, value)
17967 
      for key, value in self.__dict__.iteritems()]
17968 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17969 
 
17970 
  def __eq__(self, other):
17971 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17972 
 
17973 
  def __ne__(self, other):
17974 
    return not (self == other)
17975 
 
17976 
class authorizePickup_args:
17977 
  """
17978 
  Attributes:
17979 
   - orderId
17980 
   - pickupNumber
4602 rajveer 17981 
   - providerId
2536 chandransh 17982 
  """
17983 
 
17984 
  thrift_spec = (
17985 
    None, # 0
17986 
    (1, TType.I64, 'orderId', None, None, ), # 1
17987 
    (2, TType.STRING, 'pickupNumber', None, None, ), # 2
4602 rajveer 17988 
    (3, TType.I64, 'providerId', None, None, ), # 3
2536 chandransh 17989 
  )
17990 
 
4602 rajveer 17991 
  def __init__(self, orderId=None, pickupNumber=None, providerId=None,):
2536 chandransh 17992 
    self.orderId = orderId
17993 
    self.pickupNumber = pickupNumber
4602 rajveer 17994 
    self.providerId = providerId
2536 chandransh 17995 
 
17996 
  def read(self, iprot):
17997 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17998 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17999 
      return
18000 
    iprot.readStructBegin()
18001 
    while True:
18002 
      (fname, ftype, fid) = iprot.readFieldBegin()
18003 
      if ftype == TType.STOP:
18004 
        break
18005 
      if fid == 1:
18006 
        if ftype == TType.I64:
18007 
          self.orderId = iprot.readI64();
18008 
        else:
18009 
          iprot.skip(ftype)
18010 
      elif fid == 2:
18011 
        if ftype == TType.STRING:
18012 
          self.pickupNumber = iprot.readString();
18013 
        else:
18014 
          iprot.skip(ftype)
4602 rajveer 18015 
      elif fid == 3:
18016 
        if ftype == TType.I64:
18017 
          self.providerId = iprot.readI64();
18018 
        else:
18019 
          iprot.skip(ftype)
2536 chandransh 18020 
      else:
18021 
        iprot.skip(ftype)
18022 
      iprot.readFieldEnd()
18023 
    iprot.readStructEnd()
18024 
 
18025 
  def write(self, oprot):
18026 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18027 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18028 
      return
18029 
    oprot.writeStructBegin('authorizePickup_args')
3431 rajveer 18030 
    if self.orderId is not None:
2536 chandransh 18031 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
18032 
      oprot.writeI64(self.orderId)
18033 
      oprot.writeFieldEnd()
3431 rajveer 18034 
    if self.pickupNumber is not None:
2536 chandransh 18035 
      oprot.writeFieldBegin('pickupNumber', TType.STRING, 2)
18036 
      oprot.writeString(self.pickupNumber)
18037 
      oprot.writeFieldEnd()
4602 rajveer 18038 
    if self.providerId is not None:
18039 
      oprot.writeFieldBegin('providerId', TType.I64, 3)
18040 
      oprot.writeI64(self.providerId)
18041 
      oprot.writeFieldEnd()
2536 chandransh 18042 
    oprot.writeFieldStop()
18043 
    oprot.writeStructEnd()
18044 
 
3431 rajveer 18045 
  def validate(self):
18046 
    return
18047 
 
18048 
 
2536 chandransh 18049 
  def __repr__(self):
18050 
    L = ['%s=%r' % (key, value)
18051 
      for key, value in self.__dict__.iteritems()]
18052 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18053 
 
18054 
  def __eq__(self, other):
18055 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18056 
 
18057 
  def __ne__(self, other):
18058 
    return not (self == other)
18059 
 
18060 
class authorizePickup_result:
18061 
  """
18062 
  Attributes:
18063 
   - success
18064 
   - ex
18065 
  """
18066 
 
18067 
  thrift_spec = (
18068 
    (0, TType.BOOL, 'success', None, None, ), # 0
18069 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
18070 
  )
18071 
 
18072 
  def __init__(self, success=None, ex=None,):
18073 
    self.success = success
18074 
    self.ex = ex
18075 
 
18076 
  def read(self, iprot):
18077 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18078 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18079 
      return
18080 
    iprot.readStructBegin()
18081 
    while True:
18082 
      (fname, ftype, fid) = iprot.readFieldBegin()
18083 
      if ftype == TType.STOP:
18084 
        break
18085 
      if fid == 0:
18086 
        if ftype == TType.BOOL:
18087 
          self.success = iprot.readBool();
18088 
        else:
18089 
          iprot.skip(ftype)
18090 
      elif fid == 1:
18091 
        if ftype == TType.STRUCT:
18092 
          self.ex = TransactionServiceException()
18093 
          self.ex.read(iprot)
18094 
        else:
18095 
          iprot.skip(ftype)
18096 
      else:
18097 
        iprot.skip(ftype)
18098 
      iprot.readFieldEnd()
18099 
    iprot.readStructEnd()
18100 
 
18101 
  def write(self, oprot):
18102 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18103 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18104 
      return
18105 
    oprot.writeStructBegin('authorizePickup_result')
3431 rajveer 18106 
    if self.success is not None:
2536 chandransh 18107 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
18108 
      oprot.writeBool(self.success)
18109 
      oprot.writeFieldEnd()
3431 rajveer 18110 
    if self.ex is not None:
2536 chandransh 18111 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
18112 
      self.ex.write(oprot)
18113 
      oprot.writeFieldEnd()
18114 
    oprot.writeFieldStop()
18115 
    oprot.writeStructEnd()
18116 
 
3431 rajveer 18117 
  def validate(self):
18118 
    return
18119 
 
18120 
 
2536 chandransh 18121 
  def __repr__(self):
18122 
    L = ['%s=%r' % (key, value)
18123 
      for key, value in self.__dict__.iteritems()]
18124 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18125 
 
18126 
  def __eq__(self, other):
18127 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18128 
 
18129 
  def __ne__(self, other):
18130 
    return not (self == other)
18131 
 
2764 chandransh 18132 
class markDoasAsPickedUp_args:
18133 
  """
18134 
  Attributes:
18135 
   - providerId
18136 
   - pickupDetails
18137 
  """
18138 
 
18139 
  thrift_spec = (
18140 
    None, # 0
18141 
    (1, TType.I64, 'providerId', None, None, ), # 1
18142 
    (2, TType.MAP, 'pickupDetails', (TType.STRING,None,TType.STRING,None), None, ), # 2
18143 
  )
18144 
 
18145 
  def __init__(self, providerId=None, pickupDetails=None,):
18146 
    self.providerId = providerId
18147 
    self.pickupDetails = pickupDetails
18148 
 
18149 
  def read(self, iprot):
18150 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18151 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18152 
      return
18153 
    iprot.readStructBegin()
18154 
    while True:
18155 
      (fname, ftype, fid) = iprot.readFieldBegin()
18156 
      if ftype == TType.STOP:
18157 
        break
18158 
      if fid == 1:
18159 
        if ftype == TType.I64:
18160 
          self.providerId = iprot.readI64();
18161 
        else:
18162 
          iprot.skip(ftype)
18163 
      elif fid == 2:
18164 
        if ftype == TType.MAP:
18165 
          self.pickupDetails = {}
6188 rajveer 18166 
          (_ktype408, _vtype409, _size407 ) = iprot.readMapBegin()
18167 
          for _i411 in xrange(_size407):
18168 
            _key412 = iprot.readString();
18169 
            _val413 = iprot.readString();
18170 
            self.pickupDetails[_key412] = _val413
2764 chandransh 18171 
          iprot.readMapEnd()
18172 
        else:
18173 
          iprot.skip(ftype)
18174 
      else:
18175 
        iprot.skip(ftype)
18176 
      iprot.readFieldEnd()
18177 
    iprot.readStructEnd()
18178 
 
18179 
  def write(self, oprot):
18180 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18181 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18182 
      return
18183 
    oprot.writeStructBegin('markDoasAsPickedUp_args')
3431 rajveer 18184 
    if self.providerId is not None:
2764 chandransh 18185 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
18186 
      oprot.writeI64(self.providerId)
18187 
      oprot.writeFieldEnd()
3431 rajveer 18188 
    if self.pickupDetails is not None:
2764 chandransh 18189 
      oprot.writeFieldBegin('pickupDetails', TType.MAP, 2)
18190 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.pickupDetails))
6188 rajveer 18191 
      for kiter414,viter415 in self.pickupDetails.items():
18192 
        oprot.writeString(kiter414)
18193 
        oprot.writeString(viter415)
2764 chandransh 18194 
      oprot.writeMapEnd()
18195 
      oprot.writeFieldEnd()
18196 
    oprot.writeFieldStop()
18197 
    oprot.writeStructEnd()
18198 
 
3431 rajveer 18199 
  def validate(self):
18200 
    return
18201 
 
18202 
 
2764 chandransh 18203 
  def __repr__(self):
18204 
    L = ['%s=%r' % (key, value)
18205 
      for key, value in self.__dict__.iteritems()]
18206 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18207 
 
18208 
  def __eq__(self, other):
18209 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18210 
 
18211 
  def __ne__(self, other):
18212 
    return not (self == other)
18213 
 
18214 
class markDoasAsPickedUp_result:
4910 phani.kuma 18215 
 
18216 
  thrift_spec = (
18217 
  )
18218 
 
18219 
  def read(self, iprot):
18220 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18221 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18222 
      return
18223 
    iprot.readStructBegin()
18224 
    while True:
18225 
      (fname, ftype, fid) = iprot.readFieldBegin()
18226 
      if ftype == TType.STOP:
18227 
        break
18228 
      else:
18229 
        iprot.skip(ftype)
18230 
      iprot.readFieldEnd()
18231 
    iprot.readStructEnd()
18232 
 
18233 
  def write(self, oprot):
18234 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18235 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18236 
      return
18237 
    oprot.writeStructBegin('markDoasAsPickedUp_result')
18238 
    oprot.writeFieldStop()
18239 
    oprot.writeStructEnd()
18240 
 
18241 
  def validate(self):
18242 
    return
18243 
 
18244 
 
18245 
  def __repr__(self):
18246 
    L = ['%s=%r' % (key, value)
18247 
      for key, value in self.__dict__.iteritems()]
18248 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18249 
 
18250 
  def __eq__(self, other):
18251 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18252 
 
18253 
  def __ne__(self, other):
18254 
    return not (self == other)
18255 
 
18256 
class getDoasNotPickedUp_args:
2764 chandransh 18257 
  """
18258 
  Attributes:
4910 phani.kuma 18259 
   - providerId
18260 
  """
18261 
 
18262 
  thrift_spec = (
18263 
    None, # 0
18264 
    (1, TType.I64, 'providerId', None, None, ), # 1
18265 
  )
18266 
 
18267 
  def __init__(self, providerId=None,):
18268 
    self.providerId = providerId
18269 
 
18270 
  def read(self, iprot):
18271 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18272 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18273 
      return
18274 
    iprot.readStructBegin()
18275 
    while True:
18276 
      (fname, ftype, fid) = iprot.readFieldBegin()
18277 
      if ftype == TType.STOP:
18278 
        break
18279 
      if fid == 1:
18280 
        if ftype == TType.I64:
18281 
          self.providerId = iprot.readI64();
18282 
        else:
18283 
          iprot.skip(ftype)
18284 
      else:
18285 
        iprot.skip(ftype)
18286 
      iprot.readFieldEnd()
18287 
    iprot.readStructEnd()
18288 
 
18289 
  def write(self, oprot):
18290 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18291 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18292 
      return
18293 
    oprot.writeStructBegin('getDoasNotPickedUp_args')
18294 
    if self.providerId is not None:
18295 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
18296 
      oprot.writeI64(self.providerId)
18297 
      oprot.writeFieldEnd()
18298 
    oprot.writeFieldStop()
18299 
    oprot.writeStructEnd()
18300 
 
18301 
  def validate(self):
18302 
    return
18303 
 
18304 
 
18305 
  def __repr__(self):
18306 
    L = ['%s=%r' % (key, value)
18307 
      for key, value in self.__dict__.iteritems()]
18308 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18309 
 
18310 
  def __eq__(self, other):
18311 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18312 
 
18313 
  def __ne__(self, other):
18314 
    return not (self == other)
18315 
 
18316 
class getDoasNotPickedUp_result:
18317 
  """
18318 
  Attributes:
2764 chandransh 18319 
   - success
18320 
  """
18321 
 
18322 
  thrift_spec = (
18323 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
18324 
  )
18325 
 
18326 
  def __init__(self, success=None,):
18327 
    self.success = success
18328 
 
18329 
  def read(self, iprot):
18330 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18331 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18332 
      return
18333 
    iprot.readStructBegin()
18334 
    while True:
18335 
      (fname, ftype, fid) = iprot.readFieldBegin()
18336 
      if ftype == TType.STOP:
18337 
        break
18338 
      if fid == 0:
18339 
        if ftype == TType.LIST:
18340 
          self.success = []
6188 rajveer 18341 
          (_etype419, _size416) = iprot.readListBegin()
18342 
          for _i420 in xrange(_size416):
18343 
            _elem421 = Order()
18344 
            _elem421.read(iprot)
18345 
            self.success.append(_elem421)
2764 chandransh 18346 
          iprot.readListEnd()
18347 
        else:
18348 
          iprot.skip(ftype)
18349 
      else:
18350 
        iprot.skip(ftype)
18351 
      iprot.readFieldEnd()
18352 
    iprot.readStructEnd()
18353 
 
18354 
  def write(self, oprot):
18355 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18356 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18357 
      return
4910 phani.kuma 18358 
    oprot.writeStructBegin('getDoasNotPickedUp_result')
3431 rajveer 18359 
    if self.success is not None:
2764 chandransh 18360 
      oprot.writeFieldBegin('success', TType.LIST, 0)
18361 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 18362 
      for iter422 in self.success:
18363 
        iter422.write(oprot)
2764 chandransh 18364 
      oprot.writeListEnd()
18365 
      oprot.writeFieldEnd()
18366 
    oprot.writeFieldStop()
18367 
    oprot.writeStructEnd()
18368 
 
3431 rajveer 18369 
  def validate(self):
18370 
    return
18371 
 
18372 
 
2764 chandransh 18373 
  def __repr__(self):
18374 
    L = ['%s=%r' % (key, value)
18375 
      for key, value in self.__dict__.iteritems()]
18376 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18377 
 
18378 
  def __eq__(self, other):
18379 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18380 
 
18381 
  def __ne__(self, other):
18382 
    return not (self == other)
18383 
 
4741 phani.kuma 18384 
class markReturnOrdersAsPickedUp_args:
18385 
  """
18386 
  Attributes:
18387 
   - providerId
18388 
   - pickupDetails
18389 
  """
18390 
 
18391 
  thrift_spec = (
18392 
    None, # 0
18393 
    (1, TType.I64, 'providerId', None, None, ), # 1
18394 
    (2, TType.MAP, 'pickupDetails', (TType.STRING,None,TType.STRING,None), None, ), # 2
18395 
  )
18396 
 
18397 
  def __init__(self, providerId=None, pickupDetails=None,):
18398 
    self.providerId = providerId
18399 
    self.pickupDetails = pickupDetails
18400 
 
18401 
  def read(self, iprot):
18402 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18403 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18404 
      return
18405 
    iprot.readStructBegin()
18406 
    while True:
18407 
      (fname, ftype, fid) = iprot.readFieldBegin()
18408 
      if ftype == TType.STOP:
18409 
        break
18410 
      if fid == 1:
18411 
        if ftype == TType.I64:
18412 
          self.providerId = iprot.readI64();
18413 
        else:
18414 
          iprot.skip(ftype)
18415 
      elif fid == 2:
18416 
        if ftype == TType.MAP:
18417 
          self.pickupDetails = {}
6188 rajveer 18418 
          (_ktype424, _vtype425, _size423 ) = iprot.readMapBegin()
18419 
          for _i427 in xrange(_size423):
18420 
            _key428 = iprot.readString();
18421 
            _val429 = iprot.readString();
18422 
            self.pickupDetails[_key428] = _val429
4741 phani.kuma 18423 
          iprot.readMapEnd()
18424 
        else:
18425 
          iprot.skip(ftype)
18426 
      else:
18427 
        iprot.skip(ftype)
18428 
      iprot.readFieldEnd()
18429 
    iprot.readStructEnd()
18430 
 
18431 
  def write(self, oprot):
18432 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18433 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18434 
      return
18435 
    oprot.writeStructBegin('markReturnOrdersAsPickedUp_args')
18436 
    if self.providerId is not None:
18437 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
18438 
      oprot.writeI64(self.providerId)
18439 
      oprot.writeFieldEnd()
18440 
    if self.pickupDetails is not None:
18441 
      oprot.writeFieldBegin('pickupDetails', TType.MAP, 2)
18442 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.pickupDetails))
6188 rajveer 18443 
      for kiter430,viter431 in self.pickupDetails.items():
18444 
        oprot.writeString(kiter430)
18445 
        oprot.writeString(viter431)
4741 phani.kuma 18446 
      oprot.writeMapEnd()
18447 
      oprot.writeFieldEnd()
18448 
    oprot.writeFieldStop()
18449 
    oprot.writeStructEnd()
18450 
 
18451 
  def validate(self):
18452 
    return
18453 
 
18454 
 
18455 
  def __repr__(self):
18456 
    L = ['%s=%r' % (key, value)
18457 
      for key, value in self.__dict__.iteritems()]
18458 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18459 
 
18460 
  def __eq__(self, other):
18461 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18462 
 
18463 
  def __ne__(self, other):
18464 
    return not (self == other)
18465 
 
18466 
class markReturnOrdersAsPickedUp_result:
4910 phani.kuma 18467 
 
18468 
  thrift_spec = (
18469 
  )
18470 
 
18471 
  def read(self, iprot):
18472 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18473 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18474 
      return
18475 
    iprot.readStructBegin()
18476 
    while True:
18477 
      (fname, ftype, fid) = iprot.readFieldBegin()
18478 
      if ftype == TType.STOP:
18479 
        break
18480 
      else:
18481 
        iprot.skip(ftype)
18482 
      iprot.readFieldEnd()
18483 
    iprot.readStructEnd()
18484 
 
18485 
  def write(self, oprot):
18486 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18487 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18488 
      return
18489 
    oprot.writeStructBegin('markReturnOrdersAsPickedUp_result')
18490 
    oprot.writeFieldStop()
18491 
    oprot.writeStructEnd()
18492 
 
18493 
  def validate(self):
18494 
    return
18495 
 
18496 
 
18497 
  def __repr__(self):
18498 
    L = ['%s=%r' % (key, value)
18499 
      for key, value in self.__dict__.iteritems()]
18500 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18501 
 
18502 
  def __eq__(self, other):
18503 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18504 
 
18505 
  def __ne__(self, other):
18506 
    return not (self == other)
18507 
 
18508 
class getReturnOrdersNotPickedUp_args:
4741 phani.kuma 18509 
  """
18510 
  Attributes:
4910 phani.kuma 18511 
   - providerId
18512 
  """
18513 
 
18514 
  thrift_spec = (
18515 
    None, # 0
18516 
    (1, TType.I64, 'providerId', None, None, ), # 1
18517 
  )
18518 
 
18519 
  def __init__(self, providerId=None,):
18520 
    self.providerId = providerId
18521 
 
18522 
  def read(self, iprot):
18523 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18524 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18525 
      return
18526 
    iprot.readStructBegin()
18527 
    while True:
18528 
      (fname, ftype, fid) = iprot.readFieldBegin()
18529 
      if ftype == TType.STOP:
18530 
        break
18531 
      if fid == 1:
18532 
        if ftype == TType.I64:
18533 
          self.providerId = iprot.readI64();
18534 
        else:
18535 
          iprot.skip(ftype)
18536 
      else:
18537 
        iprot.skip(ftype)
18538 
      iprot.readFieldEnd()
18539 
    iprot.readStructEnd()
18540 
 
18541 
  def write(self, oprot):
18542 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18543 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18544 
      return
18545 
    oprot.writeStructBegin('getReturnOrdersNotPickedUp_args')
18546 
    if self.providerId is not None:
18547 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
18548 
      oprot.writeI64(self.providerId)
18549 
      oprot.writeFieldEnd()
18550 
    oprot.writeFieldStop()
18551 
    oprot.writeStructEnd()
18552 
 
18553 
  def validate(self):
18554 
    return
18555 
 
18556 
 
18557 
  def __repr__(self):
18558 
    L = ['%s=%r' % (key, value)
18559 
      for key, value in self.__dict__.iteritems()]
18560 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18561 
 
18562 
  def __eq__(self, other):
18563 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18564 
 
18565 
  def __ne__(self, other):
18566 
    return not (self == other)
18567 
 
18568 
class getReturnOrdersNotPickedUp_result:
18569 
  """
18570 
  Attributes:
4741 phani.kuma 18571 
   - success
18572 
  """
18573 
 
18574 
  thrift_spec = (
18575 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
18576 
  )
18577 
 
18578 
  def __init__(self, success=None,):
18579 
    self.success = success
18580 
 
18581 
  def read(self, iprot):
18582 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18583 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18584 
      return
18585 
    iprot.readStructBegin()
18586 
    while True:
18587 
      (fname, ftype, fid) = iprot.readFieldBegin()
18588 
      if ftype == TType.STOP:
18589 
        break
18590 
      if fid == 0:
18591 
        if ftype == TType.LIST:
18592 
          self.success = []
6188 rajveer 18593 
          (_etype435, _size432) = iprot.readListBegin()
18594 
          for _i436 in xrange(_size432):
18595 
            _elem437 = Order()
18596 
            _elem437.read(iprot)
18597 
            self.success.append(_elem437)
4741 phani.kuma 18598 
          iprot.readListEnd()
18599 
        else:
18600 
          iprot.skip(ftype)
18601 
      else:
18602 
        iprot.skip(ftype)
18603 
      iprot.readFieldEnd()
18604 
    iprot.readStructEnd()
18605 
 
18606 
  def write(self, oprot):
18607 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18608 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18609 
      return
4910 phani.kuma 18610 
    oprot.writeStructBegin('getReturnOrdersNotPickedUp_result')
4741 phani.kuma 18611 
    if self.success is not None:
18612 
      oprot.writeFieldBegin('success', TType.LIST, 0)
18613 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 18614 
      for iter438 in self.success:
18615 
        iter438.write(oprot)
4741 phani.kuma 18616 
      oprot.writeListEnd()
18617 
      oprot.writeFieldEnd()
18618 
    oprot.writeFieldStop()
18619 
    oprot.writeStructEnd()
18620 
 
18621 
  def validate(self):
18622 
    return
18623 
 
18624 
 
18625 
  def __repr__(self):
18626 
    L = ['%s=%r' % (key, value)
18627 
      for key, value in self.__dict__.iteritems()]
18628 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18629 
 
18630 
  def __eq__(self, other):
18631 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18632 
 
18633 
  def __ne__(self, other):
18634 
    return not (self == other)
18635 
 
2616 chandransh 18636 
class receiveReturn_args:
2591 chandransh 18637 
  """
18638 
  Attributes:
18639 
   - orderId
4479 rajveer 18640 
   - receiveCondition
2591 chandransh 18641 
  """
2536 chandransh 18642 
 
2591 chandransh 18643 
  thrift_spec = (
18644 
    None, # 0
18645 
    (1, TType.I64, 'orderId', None, None, ), # 1
4479 rajveer 18646 
    (2, TType.I64, 'receiveCondition', None, None, ), # 2
2591 chandransh 18647 
  )
18648 
 
4479 rajveer 18649 
  def __init__(self, orderId=None, receiveCondition=None,):
2591 chandransh 18650 
    self.orderId = orderId
4479 rajveer 18651 
    self.receiveCondition = receiveCondition
2591 chandransh 18652 
 
18653 
  def read(self, iprot):
18654 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18655 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18656 
      return
18657 
    iprot.readStructBegin()
18658 
    while True:
18659 
      (fname, ftype, fid) = iprot.readFieldBegin()
18660 
      if ftype == TType.STOP:
18661 
        break
18662 
      if fid == 1:
18663 
        if ftype == TType.I64:
18664 
          self.orderId = iprot.readI64();
18665 
        else:
18666 
          iprot.skip(ftype)
4479 rajveer 18667 
      elif fid == 2:
18668 
        if ftype == TType.I64:
18669 
          self.receiveCondition = iprot.readI64();
18670 
        else:
18671 
          iprot.skip(ftype)
2591 chandransh 18672 
      else:
18673 
        iprot.skip(ftype)
18674 
      iprot.readFieldEnd()
18675 
    iprot.readStructEnd()
18676 
 
18677 
  def write(self, oprot):
18678 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18679 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18680 
      return
2616 chandransh 18681 
    oprot.writeStructBegin('receiveReturn_args')
3431 rajveer 18682 
    if self.orderId is not None:
2591 chandransh 18683 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
18684 
      oprot.writeI64(self.orderId)
18685 
      oprot.writeFieldEnd()
4479 rajveer 18686 
    if self.receiveCondition is not None:
18687 
      oprot.writeFieldBegin('receiveCondition', TType.I64, 2)
18688 
      oprot.writeI64(self.receiveCondition)
18689 
      oprot.writeFieldEnd()
2591 chandransh 18690 
    oprot.writeFieldStop()
18691 
    oprot.writeStructEnd()
18692 
 
3431 rajveer 18693 
  def validate(self):
18694 
    return
18695 
 
18696 
 
2591 chandransh 18697 
  def __repr__(self):
18698 
    L = ['%s=%r' % (key, value)
18699 
      for key, value in self.__dict__.iteritems()]
18700 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18701 
 
18702 
  def __eq__(self, other):
18703 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18704 
 
18705 
  def __ne__(self, other):
18706 
    return not (self == other)
18707 
 
2616 chandransh 18708 
class receiveReturn_result:
2591 chandransh 18709 
  """
18710 
  Attributes:
18711 
   - success
18712 
   - ex
18713 
  """
18714 
 
18715 
  thrift_spec = (
18716 
    (0, TType.BOOL, 'success', None, None, ), # 0
18717 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
18718 
  )
18719 
 
18720 
  def __init__(self, success=None, ex=None,):
18721 
    self.success = success
18722 
    self.ex = ex
18723 
 
18724 
  def read(self, iprot):
18725 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18726 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18727 
      return
18728 
    iprot.readStructBegin()
18729 
    while True:
18730 
      (fname, ftype, fid) = iprot.readFieldBegin()
18731 
      if ftype == TType.STOP:
18732 
        break
18733 
      if fid == 0:
18734 
        if ftype == TType.BOOL:
18735 
          self.success = iprot.readBool();
18736 
        else:
18737 
          iprot.skip(ftype)
18738 
      elif fid == 1:
18739 
        if ftype == TType.STRUCT:
18740 
          self.ex = TransactionServiceException()
18741 
          self.ex.read(iprot)
18742 
        else:
18743 
          iprot.skip(ftype)
18744 
      else:
18745 
        iprot.skip(ftype)
18746 
      iprot.readFieldEnd()
18747 
    iprot.readStructEnd()
18748 
 
18749 
  def write(self, oprot):
18750 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18751 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18752 
      return
2616 chandransh 18753 
    oprot.writeStructBegin('receiveReturn_result')
3431 rajveer 18754 
    if self.success is not None:
2591 chandransh 18755 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
18756 
      oprot.writeBool(self.success)
18757 
      oprot.writeFieldEnd()
3431 rajveer 18758 
    if self.ex is not None:
2591 chandransh 18759 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
18760 
      self.ex.write(oprot)
18761 
      oprot.writeFieldEnd()
18762 
    oprot.writeFieldStop()
18763 
    oprot.writeStructEnd()
18764 
 
3431 rajveer 18765 
  def validate(self):
18766 
    return
18767 
 
18768 
 
2591 chandransh 18769 
  def __repr__(self):
18770 
    L = ['%s=%r' % (key, value)
18771 
      for key, value in self.__dict__.iteritems()]
18772 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18773 
 
18774 
  def __eq__(self, other):
18775 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18776 
 
18777 
  def __ne__(self, other):
18778 
    return not (self == other)
18779 
 
18780 
class validateDoa_args:
18781 
  """
18782 
  Attributes:
18783 
   - orderId
18784 
   - isValid
18785 
  """
18786 
 
18787 
  thrift_spec = (
18788 
    None, # 0
18789 
    (1, TType.I64, 'orderId', None, None, ), # 1
18790 
    (2, TType.BOOL, 'isValid', None, None, ), # 2
18791 
  )
18792 
 
18793 
  def __init__(self, orderId=None, isValid=None,):
18794 
    self.orderId = orderId
18795 
    self.isValid = isValid
18796 
 
18797 
  def read(self, iprot):
18798 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18799 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18800 
      return
18801 
    iprot.readStructBegin()
18802 
    while True:
18803 
      (fname, ftype, fid) = iprot.readFieldBegin()
18804 
      if ftype == TType.STOP:
18805 
        break
18806 
      if fid == 1:
18807 
        if ftype == TType.I64:
18808 
          self.orderId = iprot.readI64();
18809 
        else:
18810 
          iprot.skip(ftype)
18811 
      elif fid == 2:
18812 
        if ftype == TType.BOOL:
18813 
          self.isValid = iprot.readBool();
18814 
        else:
18815 
          iprot.skip(ftype)
18816 
      else:
18817 
        iprot.skip(ftype)
18818 
      iprot.readFieldEnd()
18819 
    iprot.readStructEnd()
18820 
 
18821 
  def write(self, oprot):
18822 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18823 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18824 
      return
18825 
    oprot.writeStructBegin('validateDoa_args')
3431 rajveer 18826 
    if self.orderId is not None:
2591 chandransh 18827 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
18828 
      oprot.writeI64(self.orderId)
18829 
      oprot.writeFieldEnd()
3431 rajveer 18830 
    if self.isValid is not None:
2591 chandransh 18831 
      oprot.writeFieldBegin('isValid', TType.BOOL, 2)
18832 
      oprot.writeBool(self.isValid)
18833 
      oprot.writeFieldEnd()
18834 
    oprot.writeFieldStop()
18835 
    oprot.writeStructEnd()
18836 
 
3431 rajveer 18837 
  def validate(self):
18838 
    return
18839 
 
18840 
 
2591 chandransh 18841 
  def __repr__(self):
18842 
    L = ['%s=%r' % (key, value)
18843 
      for key, value in self.__dict__.iteritems()]
18844 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18845 
 
18846 
  def __eq__(self, other):
18847 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18848 
 
18849 
  def __ne__(self, other):
18850 
    return not (self == other)
18851 
 
18852 
class validateDoa_result:
18853 
  """
18854 
  Attributes:
18855 
   - success
18856 
   - ex
18857 
  """
18858 
 
18859 
  thrift_spec = (
18860 
    (0, TType.BOOL, 'success', None, None, ), # 0
18861 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
18862 
  )
18863 
 
18864 
  def __init__(self, success=None, ex=None,):
18865 
    self.success = success
18866 
    self.ex = ex
18867 
 
18868 
  def read(self, iprot):
18869 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18870 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18871 
      return
18872 
    iprot.readStructBegin()
18873 
    while True:
18874 
      (fname, ftype, fid) = iprot.readFieldBegin()
18875 
      if ftype == TType.STOP:
18876 
        break
18877 
      if fid == 0:
18878 
        if ftype == TType.BOOL:
18879 
          self.success = iprot.readBool();
18880 
        else:
18881 
          iprot.skip(ftype)
18882 
      elif fid == 1:
18883 
        if ftype == TType.STRUCT:
18884 
          self.ex = TransactionServiceException()
18885 
          self.ex.read(iprot)
18886 
        else:
18887 
          iprot.skip(ftype)
18888 
      else:
18889 
        iprot.skip(ftype)
18890 
      iprot.readFieldEnd()
18891 
    iprot.readStructEnd()
18892 
 
18893 
  def write(self, oprot):
18894 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18895 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18896 
      return
18897 
    oprot.writeStructBegin('validateDoa_result')
3431 rajveer 18898 
    if self.success is not None:
2591 chandransh 18899 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
18900 
      oprot.writeBool(self.success)
18901 
      oprot.writeFieldEnd()
3431 rajveer 18902 
    if self.ex is not None:
2591 chandransh 18903 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
18904 
      self.ex.write(oprot)
18905 
      oprot.writeFieldEnd()
18906 
    oprot.writeFieldStop()
18907 
    oprot.writeStructEnd()
18908 
 
3431 rajveer 18909 
  def validate(self):
18910 
    return
18911 
 
18912 
 
2591 chandransh 18913 
  def __repr__(self):
18914 
    L = ['%s=%r' % (key, value)
18915 
      for key, value in self.__dict__.iteritems()]
18916 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18917 
 
18918 
  def __eq__(self, other):
18919 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18920 
 
18921 
  def __ne__(self, other):
18922 
    return not (self == other)
18923 
 
4495 rajveer 18924 
class validateReturnProduct_args:
18925 
  """
18926 
  Attributes:
18927 
   - orderId
18928 
   - isUsable
18929 
  """
18930 
 
18931 
  thrift_spec = (
18932 
    None, # 0
18933 
    (1, TType.I64, 'orderId', None, None, ), # 1
18934 
    (2, TType.BOOL, 'isUsable', None, None, ), # 2
18935 
  )
18936 
 
18937 
  def __init__(self, orderId=None, isUsable=None,):
18938 
    self.orderId = orderId
18939 
    self.isUsable = isUsable
18940 
 
18941 
  def read(self, iprot):
18942 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18943 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18944 
      return
18945 
    iprot.readStructBegin()
18946 
    while True:
18947 
      (fname, ftype, fid) = iprot.readFieldBegin()
18948 
      if ftype == TType.STOP:
18949 
        break
18950 
      if fid == 1:
18951 
        if ftype == TType.I64:
18952 
          self.orderId = iprot.readI64();
18953 
        else:
18954 
          iprot.skip(ftype)
18955 
      elif fid == 2:
18956 
        if ftype == TType.BOOL:
18957 
          self.isUsable = iprot.readBool();
18958 
        else:
18959 
          iprot.skip(ftype)
18960 
      else:
18961 
        iprot.skip(ftype)
18962 
      iprot.readFieldEnd()
18963 
    iprot.readStructEnd()
18964 
 
18965 
  def write(self, oprot):
18966 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18967 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18968 
      return
18969 
    oprot.writeStructBegin('validateReturnProduct_args')
18970 
    if self.orderId is not None:
18971 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
18972 
      oprot.writeI64(self.orderId)
18973 
      oprot.writeFieldEnd()
18974 
    if self.isUsable is not None:
18975 
      oprot.writeFieldBegin('isUsable', TType.BOOL, 2)
18976 
      oprot.writeBool(self.isUsable)
18977 
      oprot.writeFieldEnd()
18978 
    oprot.writeFieldStop()
18979 
    oprot.writeStructEnd()
18980 
 
18981 
  def validate(self):
18982 
    return
18983 
 
18984 
 
18985 
  def __repr__(self):
18986 
    L = ['%s=%r' % (key, value)
18987 
      for key, value in self.__dict__.iteritems()]
18988 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18989 
 
18990 
  def __eq__(self, other):
18991 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18992 
 
18993 
  def __ne__(self, other):
18994 
    return not (self == other)
18995 
 
18996 
class validateReturnProduct_result:
18997 
  """
18998 
  Attributes:
18999 
   - success
19000 
   - ex
19001 
  """
19002 
 
19003 
  thrift_spec = (
19004 
    (0, TType.BOOL, 'success', None, None, ), # 0
19005 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
19006 
  )
19007 
 
19008 
  def __init__(self, success=None, ex=None,):
19009 
    self.success = success
19010 
    self.ex = ex
19011 
 
19012 
  def read(self, iprot):
19013 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19014 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19015 
      return
19016 
    iprot.readStructBegin()
19017 
    while True:
19018 
      (fname, ftype, fid) = iprot.readFieldBegin()
19019 
      if ftype == TType.STOP:
19020 
        break
19021 
      if fid == 0:
19022 
        if ftype == TType.BOOL:
19023 
          self.success = iprot.readBool();
19024 
        else:
19025 
          iprot.skip(ftype)
19026 
      elif fid == 1:
19027 
        if ftype == TType.STRUCT:
19028 
          self.ex = TransactionServiceException()
19029 
          self.ex.read(iprot)
19030 
        else:
19031 
          iprot.skip(ftype)
19032 
      else:
19033 
        iprot.skip(ftype)
19034 
      iprot.readFieldEnd()
19035 
    iprot.readStructEnd()
19036 
 
19037 
  def write(self, oprot):
19038 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19039 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19040 
      return
19041 
    oprot.writeStructBegin('validateReturnProduct_result')
19042 
    if self.success is not None:
19043 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
19044 
      oprot.writeBool(self.success)
19045 
      oprot.writeFieldEnd()
19046 
    if self.ex is not None:
19047 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
19048 
      self.ex.write(oprot)
19049 
      oprot.writeFieldEnd()
19050 
    oprot.writeFieldStop()
19051 
    oprot.writeStructEnd()
19052 
 
19053 
  def validate(self):
19054 
    return
19055 
 
19056 
 
19057 
  def __repr__(self):
19058 
    L = ['%s=%r' % (key, value)
19059 
      for key, value in self.__dict__.iteritems()]
19060 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19061 
 
19062 
  def __eq__(self, other):
19063 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19064 
 
19065 
  def __ne__(self, other):
19066 
    return not (self == other)
19067 
 
2616 chandransh 19068 
class reshipOrder_args:
19069 
  """
19070 
  Attributes:
19071 
   - orderId
19072 
  """
2591 chandransh 19073 
 
2616 chandransh 19074 
  thrift_spec = (
19075 
    None, # 0
19076 
    (1, TType.I64, 'orderId', None, None, ), # 1
19077 
  )
19078 
 
19079 
  def __init__(self, orderId=None,):
19080 
    self.orderId = orderId
19081 
 
19082 
  def read(self, iprot):
19083 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19084 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19085 
      return
19086 
    iprot.readStructBegin()
19087 
    while True:
19088 
      (fname, ftype, fid) = iprot.readFieldBegin()
19089 
      if ftype == TType.STOP:
19090 
        break
19091 
      if fid == 1:
19092 
        if ftype == TType.I64:
19093 
          self.orderId = iprot.readI64();
19094 
        else:
19095 
          iprot.skip(ftype)
19096 
      else:
19097 
        iprot.skip(ftype)
19098 
      iprot.readFieldEnd()
19099 
    iprot.readStructEnd()
19100 
 
19101 
  def write(self, oprot):
19102 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19103 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19104 
      return
19105 
    oprot.writeStructBegin('reshipOrder_args')
3431 rajveer 19106 
    if self.orderId is not None:
2616 chandransh 19107 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
19108 
      oprot.writeI64(self.orderId)
19109 
      oprot.writeFieldEnd()
19110 
    oprot.writeFieldStop()
19111 
    oprot.writeStructEnd()
19112 
 
3431 rajveer 19113 
  def validate(self):
19114 
    return
19115 
 
19116 
 
2616 chandransh 19117 
  def __repr__(self):
19118 
    L = ['%s=%r' % (key, value)
19119 
      for key, value in self.__dict__.iteritems()]
19120 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19121 
 
19122 
  def __eq__(self, other):
19123 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19124 
 
19125 
  def __ne__(self, other):
19126 
    return not (self == other)
19127 
 
19128 
class reshipOrder_result:
19129 
  """
19130 
  Attributes:
19131 
   - success
19132 
   - ex
19133 
  """
19134 
 
19135 
  thrift_spec = (
19136 
    (0, TType.I64, 'success', None, None, ), # 0
19137 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
19138 
  )
19139 
 
19140 
  def __init__(self, success=None, ex=None,):
19141 
    self.success = success
19142 
    self.ex = ex
19143 
 
19144 
  def read(self, iprot):
19145 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19146 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19147 
      return
19148 
    iprot.readStructBegin()
19149 
    while True:
19150 
      (fname, ftype, fid) = iprot.readFieldBegin()
19151 
      if ftype == TType.STOP:
19152 
        break
19153 
      if fid == 0:
19154 
        if ftype == TType.I64:
19155 
          self.success = iprot.readI64();
19156 
        else:
19157 
          iprot.skip(ftype)
19158 
      elif fid == 1:
19159 
        if ftype == TType.STRUCT:
19160 
          self.ex = TransactionServiceException()
19161 
          self.ex.read(iprot)
19162 
        else:
19163 
          iprot.skip(ftype)
19164 
      else:
19165 
        iprot.skip(ftype)
19166 
      iprot.readFieldEnd()
19167 
    iprot.readStructEnd()
19168 
 
19169 
  def write(self, oprot):
19170 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19171 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19172 
      return
19173 
    oprot.writeStructBegin('reshipOrder_result')
3431 rajveer 19174 
    if self.success is not None:
2616 chandransh 19175 
      oprot.writeFieldBegin('success', TType.I64, 0)
19176 
      oprot.writeI64(self.success)
19177 
      oprot.writeFieldEnd()
3431 rajveer 19178 
    if self.ex is not None:
2616 chandransh 19179 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
19180 
      self.ex.write(oprot)
19181 
      oprot.writeFieldEnd()
19182 
    oprot.writeFieldStop()
19183 
    oprot.writeStructEnd()
19184 
 
3431 rajveer 19185 
  def validate(self):
19186 
    return
19187 
 
19188 
 
2616 chandransh 19189 
  def __repr__(self):
19190 
    L = ['%s=%r' % (key, value)
19191 
      for key, value in self.__dict__.iteritems()]
19192 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19193 
 
19194 
  def __eq__(self, other):
19195 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19196 
 
19197 
  def __ne__(self, other):
19198 
    return not (self == other)
19199 
 
19200 
class refundOrder_args:
19201 
  """
19202 
  Attributes:
19203 
   - orderId
3226 chandransh 19204 
   - refundedBy
19205 
   - reason
2616 chandransh 19206 
  """
19207 
 
19208 
  thrift_spec = (
19209 
    None, # 0
19210 
    (1, TType.I64, 'orderId', None, None, ), # 1
3226 chandransh 19211 
    (2, TType.STRING, 'refundedBy', None, None, ), # 2
19212 
    (3, TType.STRING, 'reason', None, None, ), # 3
2616 chandransh 19213 
  )
19214 
 
3226 chandransh 19215 
  def __init__(self, orderId=None, refundedBy=None, reason=None,):
2616 chandransh 19216 
    self.orderId = orderId
3226 chandransh 19217 
    self.refundedBy = refundedBy
19218 
    self.reason = reason
2616 chandransh 19219 
 
19220 
  def read(self, iprot):
19221 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19222 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19223 
      return
19224 
    iprot.readStructBegin()
19225 
    while True:
19226 
      (fname, ftype, fid) = iprot.readFieldBegin()
19227 
      if ftype == TType.STOP:
19228 
        break
19229 
      if fid == 1:
19230 
        if ftype == TType.I64:
19231 
          self.orderId = iprot.readI64();
19232 
        else:
19233 
          iprot.skip(ftype)
3226 chandransh 19234 
      elif fid == 2:
19235 
        if ftype == TType.STRING:
19236 
          self.refundedBy = iprot.readString();
19237 
        else:
19238 
          iprot.skip(ftype)
19239 
      elif fid == 3:
19240 
        if ftype == TType.STRING:
19241 
          self.reason = iprot.readString();
19242 
        else:
19243 
          iprot.skip(ftype)
2616 chandransh 19244 
      else:
19245 
        iprot.skip(ftype)
19246 
      iprot.readFieldEnd()
19247 
    iprot.readStructEnd()
19248 
 
19249 
  def write(self, oprot):
19250 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19251 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19252 
      return
19253 
    oprot.writeStructBegin('refundOrder_args')
3431 rajveer 19254 
    if self.orderId is not None:
2616 chandransh 19255 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
19256 
      oprot.writeI64(self.orderId)
19257 
      oprot.writeFieldEnd()
3431 rajveer 19258 
    if self.refundedBy is not None:
3226 chandransh 19259 
      oprot.writeFieldBegin('refundedBy', TType.STRING, 2)
19260 
      oprot.writeString(self.refundedBy)
19261 
      oprot.writeFieldEnd()
3431 rajveer 19262 
    if self.reason is not None:
3226 chandransh 19263 
      oprot.writeFieldBegin('reason', TType.STRING, 3)
19264 
      oprot.writeString(self.reason)
19265 
      oprot.writeFieldEnd()
2616 chandransh 19266 
    oprot.writeFieldStop()
19267 
    oprot.writeStructEnd()
19268 
 
3431 rajveer 19269 
  def validate(self):
19270 
    return
19271 
 
19272 
 
2616 chandransh 19273 
  def __repr__(self):
19274 
    L = ['%s=%r' % (key, value)
19275 
      for key, value in self.__dict__.iteritems()]
19276 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19277 
 
19278 
  def __eq__(self, other):
19279 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19280 
 
19281 
  def __ne__(self, other):
19282 
    return not (self == other)
19283 
 
19284 
class refundOrder_result:
19285 
  """
19286 
  Attributes:
19287 
   - success
19288 
   - ex
19289 
  """
19290 
 
19291 
  thrift_spec = (
19292 
    (0, TType.BOOL, 'success', None, None, ), # 0
19293 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
19294 
  )
19295 
 
19296 
  def __init__(self, success=None, ex=None,):
19297 
    self.success = success
19298 
    self.ex = ex
19299 
 
19300 
  def read(self, iprot):
19301 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19302 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19303 
      return
19304 
    iprot.readStructBegin()
19305 
    while True:
19306 
      (fname, ftype, fid) = iprot.readFieldBegin()
19307 
      if ftype == TType.STOP:
19308 
        break
19309 
      if fid == 0:
19310 
        if ftype == TType.BOOL:
19311 
          self.success = iprot.readBool();
19312 
        else:
19313 
          iprot.skip(ftype)
19314 
      elif fid == 1:
19315 
        if ftype == TType.STRUCT:
19316 
          self.ex = TransactionServiceException()
19317 
          self.ex.read(iprot)
19318 
        else:
19319 
          iprot.skip(ftype)
19320 
      else:
19321 
        iprot.skip(ftype)
19322 
      iprot.readFieldEnd()
19323 
    iprot.readStructEnd()
19324 
 
19325 
  def write(self, oprot):
19326 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19327 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19328 
      return
19329 
    oprot.writeStructBegin('refundOrder_result')
3431 rajveer 19330 
    if self.success is not None:
2616 chandransh 19331 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
19332 
      oprot.writeBool(self.success)
19333 
      oprot.writeFieldEnd()
3431 rajveer 19334 
    if self.ex is not None:
2616 chandransh 19335 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
19336 
      self.ex.write(oprot)
19337 
      oprot.writeFieldEnd()
19338 
    oprot.writeFieldStop()
19339 
    oprot.writeStructEnd()
19340 
 
3431 rajveer 19341 
  def validate(self):
19342 
    return
19343 
 
19344 
 
2616 chandransh 19345 
  def __repr__(self):
19346 
    L = ['%s=%r' % (key, value)
19347 
      for key, value in self.__dict__.iteritems()]
19348 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19349 
 
19350 
  def __eq__(self, other):
19351 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19352 
 
19353 
  def __ne__(self, other):
19354 
    return not (self == other)
19355 
 
2690 chandransh 19356 
class getReturnOrders_args:
19357 
  """
19358 
  Attributes:
19359 
   - warehouseId
19360 
   - fromDate
19361 
   - toDate
19362 
  """
2616 chandransh 19363 
 
2690 chandransh 19364 
  thrift_spec = (
19365 
    None, # 0
19366 
    (1, TType.I64, 'warehouseId', None, None, ), # 1
19367 
    (2, TType.I64, 'fromDate', None, None, ), # 2
19368 
    (3, TType.I64, 'toDate', None, None, ), # 3
19369 
  )
19370 
 
19371 
  def __init__(self, warehouseId=None, fromDate=None, toDate=None,):
19372 
    self.warehouseId = warehouseId
19373 
    self.fromDate = fromDate
19374 
    self.toDate = toDate
19375 
 
19376 
  def read(self, iprot):
19377 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19378 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19379 
      return
19380 
    iprot.readStructBegin()
19381 
    while True:
19382 
      (fname, ftype, fid) = iprot.readFieldBegin()
19383 
      if ftype == TType.STOP:
19384 
        break
19385 
      if fid == 1:
19386 
        if ftype == TType.I64:
19387 
          self.warehouseId = iprot.readI64();
19388 
        else:
19389 
          iprot.skip(ftype)
19390 
      elif fid == 2:
19391 
        if ftype == TType.I64:
19392 
          self.fromDate = iprot.readI64();
19393 
        else:
19394 
          iprot.skip(ftype)
19395 
      elif fid == 3:
19396 
        if ftype == TType.I64:
19397 
          self.toDate = iprot.readI64();
19398 
        else:
19399 
          iprot.skip(ftype)
19400 
      else:
19401 
        iprot.skip(ftype)
19402 
      iprot.readFieldEnd()
19403 
    iprot.readStructEnd()
19404 
 
19405 
  def write(self, oprot):
19406 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19407 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19408 
      return
19409 
    oprot.writeStructBegin('getReturnOrders_args')
3431 rajveer 19410 
    if self.warehouseId is not None:
2690 chandransh 19411 
      oprot.writeFieldBegin('warehouseId', TType.I64, 1)
19412 
      oprot.writeI64(self.warehouseId)
19413 
      oprot.writeFieldEnd()
3431 rajveer 19414 
    if self.fromDate is not None:
2690 chandransh 19415 
      oprot.writeFieldBegin('fromDate', TType.I64, 2)
19416 
      oprot.writeI64(self.fromDate)
19417 
      oprot.writeFieldEnd()
3431 rajveer 19418 
    if self.toDate is not None:
2690 chandransh 19419 
      oprot.writeFieldBegin('toDate', TType.I64, 3)
19420 
      oprot.writeI64(self.toDate)
19421 
      oprot.writeFieldEnd()
19422 
    oprot.writeFieldStop()
19423 
    oprot.writeStructEnd()
19424 
 
3431 rajveer 19425 
  def validate(self):
19426 
    return
19427 
 
19428 
 
2690 chandransh 19429 
  def __repr__(self):
19430 
    L = ['%s=%r' % (key, value)
19431 
      for key, value in self.__dict__.iteritems()]
19432 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19433 
 
19434 
  def __eq__(self, other):
19435 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19436 
 
19437 
  def __ne__(self, other):
19438 
    return not (self == other)
19439 
 
19440 
class getReturnOrders_result:
19441 
  """
19442 
  Attributes:
19443 
   - success
19444 
  """
19445 
 
19446 
  thrift_spec = (
19447 
    (0, TType.LIST, 'success', (TType.STRUCT,(ReturnOrder, ReturnOrder.thrift_spec)), None, ), # 0
19448 
  )
19449 
 
19450 
  def __init__(self, success=None,):
19451 
    self.success = success
19452 
 
19453 
  def read(self, iprot):
19454 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19455 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19456 
      return
19457 
    iprot.readStructBegin()
19458 
    while True:
19459 
      (fname, ftype, fid) = iprot.readFieldBegin()
19460 
      if ftype == TType.STOP:
19461 
        break
19462 
      if fid == 0:
19463 
        if ftype == TType.LIST:
19464 
          self.success = []
6188 rajveer 19465 
          (_etype442, _size439) = iprot.readListBegin()
19466 
          for _i443 in xrange(_size439):
19467 
            _elem444 = ReturnOrder()
19468 
            _elem444.read(iprot)
19469 
            self.success.append(_elem444)
2690 chandransh 19470 
          iprot.readListEnd()
19471 
        else:
19472 
          iprot.skip(ftype)
19473 
      else:
19474 
        iprot.skip(ftype)
19475 
      iprot.readFieldEnd()
19476 
    iprot.readStructEnd()
19477 
 
19478 
  def write(self, oprot):
19479 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19480 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19481 
      return
19482 
    oprot.writeStructBegin('getReturnOrders_result')
3431 rajveer 19483 
    if self.success is not None:
2690 chandransh 19484 
      oprot.writeFieldBegin('success', TType.LIST, 0)
19485 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 19486 
      for iter445 in self.success:
19487 
        iter445.write(oprot)
2690 chandransh 19488 
      oprot.writeListEnd()
19489 
      oprot.writeFieldEnd()
19490 
    oprot.writeFieldStop()
19491 
    oprot.writeStructEnd()
19492 
 
3431 rajveer 19493 
  def validate(self):
19494 
    return
19495 
 
19496 
 
2690 chandransh 19497 
  def __repr__(self):
19498 
    L = ['%s=%r' % (key, value)
19499 
      for key, value in self.__dict__.iteritems()]
19500 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19501 
 
19502 
  def __eq__(self, other):
19503 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19504 
 
19505 
  def __ne__(self, other):
19506 
    return not (self == other)
19507 
 
5481 phani.kuma 19508 
class getAllReturnOrders_args:
19509 
  """
19510 
  Attributes:
19511 
   - onlyNotProcessed
19512 
   - fromDate
19513 
   - toDate
19514 
  """
19515 
 
19516 
  thrift_spec = (
19517 
    None, # 0
19518 
    (1, TType.BOOL, 'onlyNotProcessed', None, None, ), # 1
19519 
    (2, TType.I64, 'fromDate', None, None, ), # 2
19520 
    (3, TType.I64, 'toDate', None, None, ), # 3
19521 
  )
19522 
 
19523 
  def __init__(self, onlyNotProcessed=None, fromDate=None, toDate=None,):
19524 
    self.onlyNotProcessed = onlyNotProcessed
19525 
    self.fromDate = fromDate
19526 
    self.toDate = toDate
19527 
 
19528 
  def read(self, iprot):
19529 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19530 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19531 
      return
19532 
    iprot.readStructBegin()
19533 
    while True:
19534 
      (fname, ftype, fid) = iprot.readFieldBegin()
19535 
      if ftype == TType.STOP:
19536 
        break
19537 
      if fid == 1:
19538 
        if ftype == TType.BOOL:
19539 
          self.onlyNotProcessed = iprot.readBool();
19540 
        else:
19541 
          iprot.skip(ftype)
19542 
      elif fid == 2:
19543 
        if ftype == TType.I64:
19544 
          self.fromDate = iprot.readI64();
19545 
        else:
19546 
          iprot.skip(ftype)
19547 
      elif fid == 3:
19548 
        if ftype == TType.I64:
19549 
          self.toDate = iprot.readI64();
19550 
        else:
19551 
          iprot.skip(ftype)
19552 
      else:
19553 
        iprot.skip(ftype)
19554 
      iprot.readFieldEnd()
19555 
    iprot.readStructEnd()
19556 
 
19557 
  def write(self, oprot):
19558 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19559 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19560 
      return
19561 
    oprot.writeStructBegin('getAllReturnOrders_args')
19562 
    if self.onlyNotProcessed is not None:
19563 
      oprot.writeFieldBegin('onlyNotProcessed', TType.BOOL, 1)
19564 
      oprot.writeBool(self.onlyNotProcessed)
19565 
      oprot.writeFieldEnd()
19566 
    if self.fromDate is not None:
19567 
      oprot.writeFieldBegin('fromDate', TType.I64, 2)
19568 
      oprot.writeI64(self.fromDate)
19569 
      oprot.writeFieldEnd()
19570 
    if self.toDate is not None:
19571 
      oprot.writeFieldBegin('toDate', TType.I64, 3)
19572 
      oprot.writeI64(self.toDate)
19573 
      oprot.writeFieldEnd()
19574 
    oprot.writeFieldStop()
19575 
    oprot.writeStructEnd()
19576 
 
19577 
  def validate(self):
19578 
    return
19579 
 
19580 
 
19581 
  def __repr__(self):
19582 
    L = ['%s=%r' % (key, value)
19583 
      for key, value in self.__dict__.iteritems()]
19584 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19585 
 
19586 
  def __eq__(self, other):
19587 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19588 
 
19589 
  def __ne__(self, other):
19590 
    return not (self == other)
19591 
 
19592 
class getAllReturnOrders_result:
19593 
  """
19594 
  Attributes:
19595 
   - success
19596 
  """
19597 
 
19598 
  thrift_spec = (
19599 
    (0, TType.LIST, 'success', (TType.STRUCT,(ReturnOrder, ReturnOrder.thrift_spec)), None, ), # 0
19600 
  )
19601 
 
19602 
  def __init__(self, success=None,):
19603 
    self.success = success
19604 
 
19605 
  def read(self, iprot):
19606 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19607 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19608 
      return
19609 
    iprot.readStructBegin()
19610 
    while True:
19611 
      (fname, ftype, fid) = iprot.readFieldBegin()
19612 
      if ftype == TType.STOP:
19613 
        break
19614 
      if fid == 0:
19615 
        if ftype == TType.LIST:
19616 
          self.success = []
6188 rajveer 19617 
          (_etype449, _size446) = iprot.readListBegin()
19618 
          for _i450 in xrange(_size446):
19619 
            _elem451 = ReturnOrder()
19620 
            _elem451.read(iprot)
19621 
            self.success.append(_elem451)
5481 phani.kuma 19622 
          iprot.readListEnd()
19623 
        else:
19624 
          iprot.skip(ftype)
19625 
      else:
19626 
        iprot.skip(ftype)
19627 
      iprot.readFieldEnd()
19628 
    iprot.readStructEnd()
19629 
 
19630 
  def write(self, oprot):
19631 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19632 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19633 
      return
19634 
    oprot.writeStructBegin('getAllReturnOrders_result')
19635 
    if self.success is not None:
19636 
      oprot.writeFieldBegin('success', TType.LIST, 0)
19637 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 19638 
      for iter452 in self.success:
19639 
        iter452.write(oprot)
5481 phani.kuma 19640 
      oprot.writeListEnd()
19641 
      oprot.writeFieldEnd()
19642 
    oprot.writeFieldStop()
19643 
    oprot.writeStructEnd()
19644 
 
19645 
  def validate(self):
19646 
    return
19647 
 
19648 
 
19649 
  def __repr__(self):
19650 
    L = ['%s=%r' % (key, value)
19651 
      for key, value in self.__dict__.iteritems()]
19652 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19653 
 
19654 
  def __eq__(self, other):
19655 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19656 
 
19657 
  def __ne__(self, other):
19658 
    return not (self == other)
19659 
 
2700 chandransh 19660 
class getReturnOrder_args:
19661 
  """
19662 
  Attributes:
19663 
   - id
19664 
  """
19665 
 
19666 
  thrift_spec = (
19667 
    None, # 0
19668 
    (1, TType.I64, 'id', None, None, ), # 1
19669 
  )
19670 
 
19671 
  def __init__(self, id=None,):
19672 
    self.id = id
19673 
 
19674 
  def read(self, iprot):
19675 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19676 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19677 
      return
19678 
    iprot.readStructBegin()
19679 
    while True:
19680 
      (fname, ftype, fid) = iprot.readFieldBegin()
19681 
      if ftype == TType.STOP:
19682 
        break
19683 
      if fid == 1:
19684 
        if ftype == TType.I64:
19685 
          self.id = iprot.readI64();
19686 
        else:
19687 
          iprot.skip(ftype)
19688 
      else:
19689 
        iprot.skip(ftype)
19690 
      iprot.readFieldEnd()
19691 
    iprot.readStructEnd()
19692 
 
19693 
  def write(self, oprot):
19694 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19695 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19696 
      return
19697 
    oprot.writeStructBegin('getReturnOrder_args')
3431 rajveer 19698 
    if self.id is not None:
2700 chandransh 19699 
      oprot.writeFieldBegin('id', TType.I64, 1)
19700 
      oprot.writeI64(self.id)
19701 
      oprot.writeFieldEnd()
19702 
    oprot.writeFieldStop()
19703 
    oprot.writeStructEnd()
19704 
 
3431 rajveer 19705 
  def validate(self):
19706 
    return
19707 
 
19708 
 
2700 chandransh 19709 
  def __repr__(self):
19710 
    L = ['%s=%r' % (key, value)
19711 
      for key, value in self.__dict__.iteritems()]
19712 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19713 
 
19714 
  def __eq__(self, other):
19715 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19716 
 
19717 
  def __ne__(self, other):
19718 
    return not (self == other)
19719 
 
19720 
class getReturnOrder_result:
19721 
  """
19722 
  Attributes:
19723 
   - success
19724 
   - ex
19725 
  """
19726 
 
19727 
  thrift_spec = (
19728 
    (0, TType.STRUCT, 'success', (ReturnOrder, ReturnOrder.thrift_spec), None, ), # 0
19729 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
19730 
  )
19731 
 
19732 
  def __init__(self, success=None, ex=None,):
19733 
    self.success = success
19734 
    self.ex = ex
19735 
 
19736 
  def read(self, iprot):
19737 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19738 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19739 
      return
19740 
    iprot.readStructBegin()
19741 
    while True:
19742 
      (fname, ftype, fid) = iprot.readFieldBegin()
19743 
      if ftype == TType.STOP:
19744 
        break
19745 
      if fid == 0:
19746 
        if ftype == TType.STRUCT:
19747 
          self.success = ReturnOrder()
19748 
          self.success.read(iprot)
19749 
        else:
19750 
          iprot.skip(ftype)
19751 
      elif fid == 1:
19752 
        if ftype == TType.STRUCT:
19753 
          self.ex = TransactionServiceException()
19754 
          self.ex.read(iprot)
19755 
        else:
19756 
          iprot.skip(ftype)
19757 
      else:
19758 
        iprot.skip(ftype)
19759 
      iprot.readFieldEnd()
19760 
    iprot.readStructEnd()
19761 
 
19762 
  def write(self, oprot):
19763 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19764 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19765 
      return
19766 
    oprot.writeStructBegin('getReturnOrder_result')
3431 rajveer 19767 
    if self.success is not None:
2700 chandransh 19768 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
19769 
      self.success.write(oprot)
19770 
      oprot.writeFieldEnd()
3431 rajveer 19771 
    if self.ex is not None:
2700 chandransh 19772 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
19773 
      self.ex.write(oprot)
19774 
      oprot.writeFieldEnd()
19775 
    oprot.writeFieldStop()
19776 
    oprot.writeStructEnd()
19777 
 
3431 rajveer 19778 
  def validate(self):
19779 
    return
19780 
 
19781 
 
2700 chandransh 19782 
  def __repr__(self):
19783 
    L = ['%s=%r' % (key, value)
19784 
      for key, value in self.__dict__.iteritems()]
19785 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19786 
 
19787 
  def __eq__(self, other):
19788 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19789 
 
19790 
  def __ne__(self, other):
19791 
    return not (self == other)
19792 
 
2690 chandransh 19793 
class processReturn_args:
19794 
  """
19795 
  Attributes:
19796 
   - returnOrderId
19797 
  """
19798 
 
19799 
  thrift_spec = (
19800 
    None, # 0
19801 
    (1, TType.I64, 'returnOrderId', None, None, ), # 1
19802 
  )
19803 
 
19804 
  def __init__(self, returnOrderId=None,):
19805 
    self.returnOrderId = returnOrderId
19806 
 
19807 
  def read(self, iprot):
19808 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19809 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19810 
      return
19811 
    iprot.readStructBegin()
19812 
    while True:
19813 
      (fname, ftype, fid) = iprot.readFieldBegin()
19814 
      if ftype == TType.STOP:
19815 
        break
19816 
      if fid == 1:
19817 
        if ftype == TType.I64:
19818 
          self.returnOrderId = iprot.readI64();
19819 
        else:
19820 
          iprot.skip(ftype)
19821 
      else:
19822 
        iprot.skip(ftype)
19823 
      iprot.readFieldEnd()
19824 
    iprot.readStructEnd()
19825 
 
19826 
  def write(self, oprot):
19827 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19828 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19829 
      return
19830 
    oprot.writeStructBegin('processReturn_args')
3431 rajveer 19831 
    if self.returnOrderId is not None:
2690 chandransh 19832 
      oprot.writeFieldBegin('returnOrderId', TType.I64, 1)
19833 
      oprot.writeI64(self.returnOrderId)
19834 
      oprot.writeFieldEnd()
19835 
    oprot.writeFieldStop()
19836 
    oprot.writeStructEnd()
19837 
 
3431 rajveer 19838 
  def validate(self):
19839 
    return
19840 
 
19841 
 
2690 chandransh 19842 
  def __repr__(self):
19843 
    L = ['%s=%r' % (key, value)
19844 
      for key, value in self.__dict__.iteritems()]
19845 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19846 
 
19847 
  def __eq__(self, other):
19848 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19849 
 
19850 
  def __ne__(self, other):
19851 
    return not (self == other)
19852 
 
19853 
class processReturn_result:
19854 
  """
19855 
  Attributes:
19856 
   - ex
19857 
  """
19858 
 
19859 
  thrift_spec = (
19860 
    None, # 0
19861 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
19862 
  )
19863 
 
19864 
  def __init__(self, ex=None,):
19865 
    self.ex = ex
19866 
 
19867 
  def read(self, iprot):
19868 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19869 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19870 
      return
19871 
    iprot.readStructBegin()
19872 
    while True:
19873 
      (fname, ftype, fid) = iprot.readFieldBegin()
19874 
      if ftype == TType.STOP:
19875 
        break
19876 
      if fid == 1:
19877 
        if ftype == TType.STRUCT:
19878 
          self.ex = TransactionServiceException()
19879 
          self.ex.read(iprot)
19880 
        else:
19881 
          iprot.skip(ftype)
19882 
      else:
19883 
        iprot.skip(ftype)
19884 
      iprot.readFieldEnd()
19885 
    iprot.readStructEnd()
19886 
 
19887 
  def write(self, oprot):
19888 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19889 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19890 
      return
19891 
    oprot.writeStructBegin('processReturn_result')
3431 rajveer 19892 
    if self.ex is not None:
2690 chandransh 19893 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
19894 
      self.ex.write(oprot)
19895 
      oprot.writeFieldEnd()
19896 
    oprot.writeFieldStop()
19897 
    oprot.writeStructEnd()
19898 
 
3431 rajveer 19899 
  def validate(self):
19900 
    return
19901 
 
19902 
 
2690 chandransh 19903 
  def __repr__(self):
19904 
    L = ['%s=%r' % (key, value)
19905 
      for key, value in self.__dict__.iteritems()]
19906 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19907 
 
19908 
  def __eq__(self, other):
19909 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19910 
 
19911 
  def __ne__(self, other):
19912 
    return not (self == other)
19913 
 
3451 chandransh 19914 
class updateWeight_args:
19915 
  """
19916 
  Attributes:
19917 
   - orderId
19918 
   - weight
19919 
  """
19920 
 
19921 
  thrift_spec = (
19922 
    None, # 0
19923 
    (1, TType.I64, 'orderId', None, None, ), # 1
19924 
    (2, TType.DOUBLE, 'weight', None, None, ), # 2
19925 
  )
19926 
 
19927 
  def __init__(self, orderId=None, weight=None,):
19928 
    self.orderId = orderId
19929 
    self.weight = weight
19930 
 
19931 
  def read(self, iprot):
19932 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19933 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19934 
      return
19935 
    iprot.readStructBegin()
19936 
    while True:
19937 
      (fname, ftype, fid) = iprot.readFieldBegin()
19938 
      if ftype == TType.STOP:
19939 
        break
19940 
      if fid == 1:
19941 
        if ftype == TType.I64:
19942 
          self.orderId = iprot.readI64();
19943 
        else:
19944 
          iprot.skip(ftype)
19945 
      elif fid == 2:
19946 
        if ftype == TType.DOUBLE:
19947 
          self.weight = iprot.readDouble();
19948 
        else:
19949 
          iprot.skip(ftype)
19950 
      else:
19951 
        iprot.skip(ftype)
19952 
      iprot.readFieldEnd()
19953 
    iprot.readStructEnd()
19954 
 
19955 
  def write(self, oprot):
19956 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19957 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19958 
      return
19959 
    oprot.writeStructBegin('updateWeight_args')
19960 
    if self.orderId is not None:
19961 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
19962 
      oprot.writeI64(self.orderId)
19963 
      oprot.writeFieldEnd()
19964 
    if self.weight is not None:
19965 
      oprot.writeFieldBegin('weight', TType.DOUBLE, 2)
19966 
      oprot.writeDouble(self.weight)
19967 
      oprot.writeFieldEnd()
19968 
    oprot.writeFieldStop()
19969 
    oprot.writeStructEnd()
19970 
 
19971 
  def validate(self):
19972 
    return
19973 
 
19974 
 
19975 
  def __repr__(self):
19976 
    L = ['%s=%r' % (key, value)
19977 
      for key, value in self.__dict__.iteritems()]
19978 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19979 
 
19980 
  def __eq__(self, other):
19981 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19982 
 
19983 
  def __ne__(self, other):
19984 
    return not (self == other)
19985 
 
19986 
class updateWeight_result:
19987 
  """
19988 
  Attributes:
19989 
   - success
19990 
   - ex
19991 
  """
19992 
 
19993 
  thrift_spec = (
19994 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
19995 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
19996 
  )
19997 
 
19998 
  def __init__(self, success=None, ex=None,):
19999 
    self.success = success
20000 
    self.ex = ex
20001 
 
20002 
  def read(self, iprot):
20003 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20004 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20005 
      return
20006 
    iprot.readStructBegin()
20007 
    while True:
20008 
      (fname, ftype, fid) = iprot.readFieldBegin()
20009 
      if ftype == TType.STOP:
20010 
        break
20011 
      if fid == 0:
20012 
        if ftype == TType.STRUCT:
20013 
          self.success = Order()
20014 
          self.success.read(iprot)
20015 
        else:
20016 
          iprot.skip(ftype)
20017 
      elif fid == 1:
20018 
        if ftype == TType.STRUCT:
20019 
          self.ex = TransactionServiceException()
20020 
          self.ex.read(iprot)
20021 
        else:
20022 
          iprot.skip(ftype)
20023 
      else:
20024 
        iprot.skip(ftype)
20025 
      iprot.readFieldEnd()
20026 
    iprot.readStructEnd()
20027 
 
20028 
  def write(self, oprot):
20029 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20030 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20031 
      return
20032 
    oprot.writeStructBegin('updateWeight_result')
20033 
    if self.success is not None:
20034 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
20035 
      self.success.write(oprot)
20036 
      oprot.writeFieldEnd()
20037 
    if self.ex is not None:
20038 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
20039 
      self.ex.write(oprot)
20040 
      oprot.writeFieldEnd()
20041 
    oprot.writeFieldStop()
20042 
    oprot.writeStructEnd()
20043 
 
20044 
  def validate(self):
20045 
    return
20046 
 
20047 
 
20048 
  def __repr__(self):
20049 
    L = ['%s=%r' % (key, value)
20050 
      for key, value in self.__dict__.iteritems()]
20051 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20052 
 
20053 
  def __eq__(self, other):
20054 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20055 
 
20056 
  def __ne__(self, other):
20057 
    return not (self == other)
3469 chandransh 20058 
 
20059 
class changeItem_args:
20060 
  """
20061 
  Attributes:
20062 
   - orderId
20063 
   - itemId
20064 
  """
20065 
 
20066 
  thrift_spec = (
20067 
    None, # 0
20068 
    (1, TType.I64, 'orderId', None, None, ), # 1
20069 
    (2, TType.I64, 'itemId', None, None, ), # 2
20070 
  )
20071 
 
20072 
  def __init__(self, orderId=None, itemId=None,):
20073 
    self.orderId = orderId
20074 
    self.itemId = itemId
20075 
 
20076 
  def read(self, iprot):
20077 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20078 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20079 
      return
20080 
    iprot.readStructBegin()
20081 
    while True:
20082 
      (fname, ftype, fid) = iprot.readFieldBegin()
20083 
      if ftype == TType.STOP:
20084 
        break
20085 
      if fid == 1:
20086 
        if ftype == TType.I64:
20087 
          self.orderId = iprot.readI64();
20088 
        else:
20089 
          iprot.skip(ftype)
20090 
      elif fid == 2:
20091 
        if ftype == TType.I64:
20092 
          self.itemId = iprot.readI64();
20093 
        else:
20094 
          iprot.skip(ftype)
20095 
      else:
20096 
        iprot.skip(ftype)
20097 
      iprot.readFieldEnd()
20098 
    iprot.readStructEnd()
20099 
 
20100 
  def write(self, oprot):
20101 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20102 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20103 
      return
20104 
    oprot.writeStructBegin('changeItem_args')
20105 
    if self.orderId is not None:
20106 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
20107 
      oprot.writeI64(self.orderId)
20108 
      oprot.writeFieldEnd()
20109 
    if self.itemId is not None:
20110 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
20111 
      oprot.writeI64(self.itemId)
20112 
      oprot.writeFieldEnd()
20113 
    oprot.writeFieldStop()
20114 
    oprot.writeStructEnd()
20115 
 
20116 
  def validate(self):
20117 
    return
20118 
 
20119 
 
20120 
  def __repr__(self):
20121 
    L = ['%s=%r' % (key, value)
20122 
      for key, value in self.__dict__.iteritems()]
20123 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20124 
 
20125 
  def __eq__(self, other):
20126 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20127 
 
20128 
  def __ne__(self, other):
20129 
    return not (self == other)
20130 
 
20131 
class changeItem_result:
20132 
  """
20133 
  Attributes:
20134 
   - success
20135 
   - ex
20136 
  """
20137 
 
20138 
  thrift_spec = (
20139 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
20140 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
20141 
  )
20142 
 
20143 
  def __init__(self, success=None, ex=None,):
20144 
    self.success = success
20145 
    self.ex = ex
20146 
 
20147 
  def read(self, iprot):
20148 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20149 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20150 
      return
20151 
    iprot.readStructBegin()
20152 
    while True:
20153 
      (fname, ftype, fid) = iprot.readFieldBegin()
20154 
      if ftype == TType.STOP:
20155 
        break
20156 
      if fid == 0:
20157 
        if ftype == TType.STRUCT:
20158 
          self.success = Order()
20159 
          self.success.read(iprot)
20160 
        else:
20161 
          iprot.skip(ftype)
20162 
      elif fid == 1:
20163 
        if ftype == TType.STRUCT:
20164 
          self.ex = TransactionServiceException()
20165 
          self.ex.read(iprot)
20166 
        else:
20167 
          iprot.skip(ftype)
20168 
      else:
20169 
        iprot.skip(ftype)
20170 
      iprot.readFieldEnd()
20171 
    iprot.readStructEnd()
20172 
 
20173 
  def write(self, oprot):
20174 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20175 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20176 
      return
20177 
    oprot.writeStructBegin('changeItem_result')
20178 
    if self.success is not None:
20179 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
20180 
      self.success.write(oprot)
20181 
      oprot.writeFieldEnd()
20182 
    if self.ex is not None:
20183 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
20184 
      self.ex.write(oprot)
20185 
      oprot.writeFieldEnd()
20186 
    oprot.writeFieldStop()
20187 
    oprot.writeStructEnd()
20188 
 
20189 
  def validate(self):
20190 
    return
20191 
 
20192 
 
20193 
  def __repr__(self):
20194 
    L = ['%s=%r' % (key, value)
20195 
      for key, value in self.__dict__.iteritems()]
20196 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20197 
 
20198 
  def __eq__(self, other):
20199 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20200 
 
20201 
  def __ne__(self, other):
20202 
    return not (self == other)
20203 
 
20204 
class shiftToWarehouse_args:
20205 
  """
20206 
  Attributes:
20207 
   - orderId
20208 
   - warehouseId
20209 
  """
20210 
 
20211 
  thrift_spec = (
20212 
    None, # 0
20213 
    (1, TType.I64, 'orderId', None, None, ), # 1
20214 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
20215 
  )
20216 
 
20217 
  def __init__(self, orderId=None, warehouseId=None,):
20218 
    self.orderId = orderId
20219 
    self.warehouseId = warehouseId
20220 
 
20221 
  def read(self, iprot):
20222 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20223 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20224 
      return
20225 
    iprot.readStructBegin()
20226 
    while True:
20227 
      (fname, ftype, fid) = iprot.readFieldBegin()
20228 
      if ftype == TType.STOP:
20229 
        break
20230 
      if fid == 1:
20231 
        if ftype == TType.I64:
20232 
          self.orderId = iprot.readI64();
20233 
        else:
20234 
          iprot.skip(ftype)
20235 
      elif fid == 2:
20236 
        if ftype == TType.I64:
20237 
          self.warehouseId = iprot.readI64();
20238 
        else:
20239 
          iprot.skip(ftype)
20240 
      else:
20241 
        iprot.skip(ftype)
20242 
      iprot.readFieldEnd()
20243 
    iprot.readStructEnd()
20244 
 
20245 
  def write(self, oprot):
20246 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20247 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20248 
      return
20249 
    oprot.writeStructBegin('shiftToWarehouse_args')
20250 
    if self.orderId is not None:
20251 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
20252 
      oprot.writeI64(self.orderId)
20253 
      oprot.writeFieldEnd()
20254 
    if self.warehouseId is not None:
20255 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
20256 
      oprot.writeI64(self.warehouseId)
20257 
      oprot.writeFieldEnd()
20258 
    oprot.writeFieldStop()
20259 
    oprot.writeStructEnd()
20260 
 
20261 
  def validate(self):
20262 
    return
20263 
 
20264 
 
20265 
  def __repr__(self):
20266 
    L = ['%s=%r' % (key, value)
20267 
      for key, value in self.__dict__.iteritems()]
20268 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20269 
 
20270 
  def __eq__(self, other):
20271 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20272 
 
20273 
  def __ne__(self, other):
20274 
    return not (self == other)
20275 
 
20276 
class shiftToWarehouse_result:
20277 
  """
20278 
  Attributes:
20279 
   - success
20280 
   - ex
20281 
  """
20282 
 
20283 
  thrift_spec = (
20284 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
20285 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
20286 
  )
20287 
 
20288 
  def __init__(self, success=None, ex=None,):
20289 
    self.success = success
20290 
    self.ex = ex
20291 
 
20292 
  def read(self, iprot):
20293 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20294 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20295 
      return
20296 
    iprot.readStructBegin()
20297 
    while True:
20298 
      (fname, ftype, fid) = iprot.readFieldBegin()
20299 
      if ftype == TType.STOP:
20300 
        break
20301 
      if fid == 0:
20302 
        if ftype == TType.STRUCT:
20303 
          self.success = Order()
20304 
          self.success.read(iprot)
20305 
        else:
20306 
          iprot.skip(ftype)
20307 
      elif fid == 1:
20308 
        if ftype == TType.STRUCT:
20309 
          self.ex = TransactionServiceException()
20310 
          self.ex.read(iprot)
20311 
        else:
20312 
          iprot.skip(ftype)
20313 
      else:
20314 
        iprot.skip(ftype)
20315 
      iprot.readFieldEnd()
20316 
    iprot.readStructEnd()
20317 
 
20318 
  def write(self, oprot):
20319 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20320 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20321 
      return
20322 
    oprot.writeStructBegin('shiftToWarehouse_result')
20323 
    if self.success is not None:
20324 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
20325 
      self.success.write(oprot)
20326 
      oprot.writeFieldEnd()
20327 
    if self.ex is not None:
20328 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
20329 
      self.ex.write(oprot)
20330 
      oprot.writeFieldEnd()
20331 
    oprot.writeFieldStop()
20332 
    oprot.writeStructEnd()
20333 
 
20334 
  def validate(self):
20335 
    return
20336 
 
20337 
 
20338 
  def __repr__(self):
20339 
    L = ['%s=%r' % (key, value)
20340 
      for key, value in self.__dict__.iteritems()]
20341 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20342 
 
20343 
  def __eq__(self, other):
20344 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20345 
 
20346 
  def __ne__(self, other):
20347 
    return not (self == other)
3553 chandransh 20348 
 
20349 
class addDelayReason_args:
20350 
  """
20351 
  Attributes:
20352 
   - orderId
20353 
   - delayReason
3986 chandransh 20354 
   - furtherDelay
4647 rajveer 20355 
   - delayReasonText
3553 chandransh 20356 
  """
20357 
 
20358 
  thrift_spec = (
20359 
    None, # 0
20360 
    (1, TType.I64, 'orderId', None, None, ), # 1
20361 
    (2, TType.I32, 'delayReason', None, None, ), # 2
3986 chandransh 20362 
    (3, TType.I64, 'furtherDelay', None, None, ), # 3
4647 rajveer 20363 
    (4, TType.STRING, 'delayReasonText', None, None, ), # 4
3553 chandransh 20364 
  )
20365 
 
4647 rajveer 20366 
  def __init__(self, orderId=None, delayReason=None, furtherDelay=None, delayReasonText=None,):
3553 chandransh 20367 
    self.orderId = orderId
20368 
    self.delayReason = delayReason
3986 chandransh 20369 
    self.furtherDelay = furtherDelay
4647 rajveer 20370 
    self.delayReasonText = delayReasonText
3553 chandransh 20371 
 
20372 
  def read(self, iprot):
20373 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20374 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20375 
      return
20376 
    iprot.readStructBegin()
20377 
    while True:
20378 
      (fname, ftype, fid) = iprot.readFieldBegin()
20379 
      if ftype == TType.STOP:
20380 
        break
20381 
      if fid == 1:
20382 
        if ftype == TType.I64:
20383 
          self.orderId = iprot.readI64();
20384 
        else:
20385 
          iprot.skip(ftype)
20386 
      elif fid == 2:
20387 
        if ftype == TType.I32:
20388 
          self.delayReason = iprot.readI32();
20389 
        else:
20390 
          iprot.skip(ftype)
3986 chandransh 20391 
      elif fid == 3:
20392 
        if ftype == TType.I64:
20393 
          self.furtherDelay = iprot.readI64();
20394 
        else:
20395 
          iprot.skip(ftype)
4647 rajveer 20396 
      elif fid == 4:
20397 
        if ftype == TType.STRING:
20398 
          self.delayReasonText = iprot.readString();
20399 
        else:
20400 
          iprot.skip(ftype)
3553 chandransh 20401 
      else:
20402 
        iprot.skip(ftype)
20403 
      iprot.readFieldEnd()
20404 
    iprot.readStructEnd()
20405 
 
20406 
  def write(self, oprot):
20407 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20408 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20409 
      return
20410 
    oprot.writeStructBegin('addDelayReason_args')
20411 
    if self.orderId is not None:
20412 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
20413 
      oprot.writeI64(self.orderId)
20414 
      oprot.writeFieldEnd()
20415 
    if self.delayReason is not None:
20416 
      oprot.writeFieldBegin('delayReason', TType.I32, 2)
20417 
      oprot.writeI32(self.delayReason)
20418 
      oprot.writeFieldEnd()
3986 chandransh 20419 
    if self.furtherDelay is not None:
20420 
      oprot.writeFieldBegin('furtherDelay', TType.I64, 3)
20421 
      oprot.writeI64(self.furtherDelay)
20422 
      oprot.writeFieldEnd()
4647 rajveer 20423 
    if self.delayReasonText is not None:
20424 
      oprot.writeFieldBegin('delayReasonText', TType.STRING, 4)
20425 
      oprot.writeString(self.delayReasonText)
20426 
      oprot.writeFieldEnd()
3553 chandransh 20427 
    oprot.writeFieldStop()
20428 
    oprot.writeStructEnd()
20429 
 
20430 
  def validate(self):
20431 
    return
20432 
 
20433 
 
20434 
  def __repr__(self):
20435 
    L = ['%s=%r' % (key, value)
20436 
      for key, value in self.__dict__.iteritems()]
20437 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20438 
 
20439 
  def __eq__(self, other):
20440 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20441 
 
20442 
  def __ne__(self, other):
20443 
    return not (self == other)
20444 
 
20445 
class addDelayReason_result:
20446 
  """
20447 
  Attributes:
20448 
   - success
20449 
   - ex
20450 
  """
20451 
 
20452 
  thrift_spec = (
20453 
    (0, TType.BOOL, 'success', None, None, ), # 0
20454 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
20455 
  )
20456 
 
20457 
  def __init__(self, success=None, ex=None,):
20458 
    self.success = success
20459 
    self.ex = ex
20460 
 
20461 
  def read(self, iprot):
20462 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20463 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20464 
      return
20465 
    iprot.readStructBegin()
20466 
    while True:
20467 
      (fname, ftype, fid) = iprot.readFieldBegin()
20468 
      if ftype == TType.STOP:
20469 
        break
20470 
      if fid == 0:
20471 
        if ftype == TType.BOOL:
20472 
          self.success = iprot.readBool();
20473 
        else:
20474 
          iprot.skip(ftype)
20475 
      elif fid == 1:
20476 
        if ftype == TType.STRUCT:
20477 
          self.ex = TransactionServiceException()
20478 
          self.ex.read(iprot)
20479 
        else:
20480 
          iprot.skip(ftype)
20481 
      else:
20482 
        iprot.skip(ftype)
20483 
      iprot.readFieldEnd()
20484 
    iprot.readStructEnd()
20485 
 
20486 
  def write(self, oprot):
20487 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20488 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20489 
      return
20490 
    oprot.writeStructBegin('addDelayReason_result')
20491 
    if self.success is not None:
20492 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
20493 
      oprot.writeBool(self.success)
20494 
      oprot.writeFieldEnd()
20495 
    if self.ex is not None:
20496 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
20497 
      self.ex.write(oprot)
20498 
      oprot.writeFieldEnd()
20499 
    oprot.writeFieldStop()
20500 
    oprot.writeStructEnd()
20501 
 
20502 
  def validate(self):
20503 
    return
20504 
 
20505 
 
20506 
  def __repr__(self):
20507 
    L = ['%s=%r' % (key, value)
20508 
      for key, value in self.__dict__.iteritems()]
20509 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20510 
 
20511 
  def __eq__(self, other):
20512 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20513 
 
20514 
  def __ne__(self, other):
20515 
    return not (self == other)
3956 chandransh 20516 
 
20517 
class reconcileCodCollection_args:
20518 
  """
20519 
  Attributes:
20520 
   - collectedAmountMap
20521 
   - xferBy
20522 
   - xferTxnId
20523 
   - xferDate
20524 
  """
20525 
 
20526 
  thrift_spec = (
20527 
    None, # 0
20528 
    (1, TType.MAP, 'collectedAmountMap', (TType.STRING,None,TType.DOUBLE,None), None, ), # 1
20529 
    (2, TType.STRING, 'xferBy', None, None, ), # 2
20530 
    (3, TType.STRING, 'xferTxnId', None, None, ), # 3
20531 
    (4, TType.I64, 'xferDate', None, None, ), # 4
20532 
  )
20533 
 
20534 
  def __init__(self, collectedAmountMap=None, xferBy=None, xferTxnId=None, xferDate=None,):
20535 
    self.collectedAmountMap = collectedAmountMap
20536 
    self.xferBy = xferBy
20537 
    self.xferTxnId = xferTxnId
20538 
    self.xferDate = xferDate
20539 
 
20540 
  def read(self, iprot):
20541 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20542 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20543 
      return
20544 
    iprot.readStructBegin()
20545 
    while True:
20546 
      (fname, ftype, fid) = iprot.readFieldBegin()
20547 
      if ftype == TType.STOP:
20548 
        break
20549 
      if fid == 1:
20550 
        if ftype == TType.MAP:
20551 
          self.collectedAmountMap = {}
6188 rajveer 20552 
          (_ktype454, _vtype455, _size453 ) = iprot.readMapBegin()
20553 
          for _i457 in xrange(_size453):
20554 
            _key458 = iprot.readString();
20555 
            _val459 = iprot.readDouble();
20556 
            self.collectedAmountMap[_key458] = _val459
3956 chandransh 20557 
          iprot.readMapEnd()
20558 
        else:
20559 
          iprot.skip(ftype)
20560 
      elif fid == 2:
20561 
        if ftype == TType.STRING:
20562 
          self.xferBy = iprot.readString();
20563 
        else:
20564 
          iprot.skip(ftype)
20565 
      elif fid == 3:
20566 
        if ftype == TType.STRING:
20567 
          self.xferTxnId = iprot.readString();
20568 
        else:
20569 
          iprot.skip(ftype)
20570 
      elif fid == 4:
20571 
        if ftype == TType.I64:
20572 
          self.xferDate = iprot.readI64();
20573 
        else:
20574 
          iprot.skip(ftype)
20575 
      else:
20576 
        iprot.skip(ftype)
20577 
      iprot.readFieldEnd()
20578 
    iprot.readStructEnd()
20579 
 
20580 
  def write(self, oprot):
20581 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20582 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20583 
      return
20584 
    oprot.writeStructBegin('reconcileCodCollection_args')
20585 
    if self.collectedAmountMap is not None:
20586 
      oprot.writeFieldBegin('collectedAmountMap', TType.MAP, 1)
20587 
      oprot.writeMapBegin(TType.STRING, TType.DOUBLE, len(self.collectedAmountMap))
6188 rajveer 20588 
      for kiter460,viter461 in self.collectedAmountMap.items():
20589 
        oprot.writeString(kiter460)
20590 
        oprot.writeDouble(viter461)
3956 chandransh 20591 
      oprot.writeMapEnd()
20592 
      oprot.writeFieldEnd()
20593 
    if self.xferBy is not None:
20594 
      oprot.writeFieldBegin('xferBy', TType.STRING, 2)
20595 
      oprot.writeString(self.xferBy)
20596 
      oprot.writeFieldEnd()
20597 
    if self.xferTxnId is not None:
20598 
      oprot.writeFieldBegin('xferTxnId', TType.STRING, 3)
20599 
      oprot.writeString(self.xferTxnId)
20600 
      oprot.writeFieldEnd()
20601 
    if self.xferDate is not None:
20602 
      oprot.writeFieldBegin('xferDate', TType.I64, 4)
20603 
      oprot.writeI64(self.xferDate)
20604 
      oprot.writeFieldEnd()
20605 
    oprot.writeFieldStop()
20606 
    oprot.writeStructEnd()
20607 
 
20608 
  def validate(self):
20609 
    return
20610 
 
20611 
 
20612 
  def __repr__(self):
20613 
    L = ['%s=%r' % (key, value)
20614 
      for key, value in self.__dict__.iteritems()]
20615 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20616 
 
20617 
  def __eq__(self, other):
20618 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20619 
 
20620 
  def __ne__(self, other):
20621 
    return not (self == other)
20622 
 
20623 
class reconcileCodCollection_result:
20624 
  """
20625 
  Attributes:
20626 
   - success
20627 
   - ex
20628 
  """
20629 
 
20630 
  thrift_spec = (
20631 
    (0, TType.MAP, 'success', (TType.STRING,None,TType.STRING,None), None, ), # 0
20632 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
20633 
  )
20634 
 
20635 
  def __init__(self, success=None, ex=None,):
20636 
    self.success = success
20637 
    self.ex = ex
20638 
 
20639 
  def read(self, iprot):
20640 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20641 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20642 
      return
20643 
    iprot.readStructBegin()
20644 
    while True:
20645 
      (fname, ftype, fid) = iprot.readFieldBegin()
20646 
      if ftype == TType.STOP:
20647 
        break
20648 
      if fid == 0:
20649 
        if ftype == TType.MAP:
20650 
          self.success = {}
6188 rajveer 20651 
          (_ktype463, _vtype464, _size462 ) = iprot.readMapBegin()
20652 
          for _i466 in xrange(_size462):
20653 
            _key467 = iprot.readString();
20654 
            _val468 = iprot.readString();
20655 
            self.success[_key467] = _val468
3956 chandransh 20656 
          iprot.readMapEnd()
20657 
        else:
20658 
          iprot.skip(ftype)
20659 
      elif fid == 1:
20660 
        if ftype == TType.STRUCT:
20661 
          self.ex = TransactionServiceException()
20662 
          self.ex.read(iprot)
20663 
        else:
20664 
          iprot.skip(ftype)
20665 
      else:
20666 
        iprot.skip(ftype)
20667 
      iprot.readFieldEnd()
20668 
    iprot.readStructEnd()
20669 
 
20670 
  def write(self, oprot):
20671 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20672 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20673 
      return
20674 
    oprot.writeStructBegin('reconcileCodCollection_result')
20675 
    if self.success is not None:
20676 
      oprot.writeFieldBegin('success', TType.MAP, 0)
20677 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.success))
6188 rajveer 20678 
      for kiter469,viter470 in self.success.items():
20679 
        oprot.writeString(kiter469)
20680 
        oprot.writeString(viter470)
3956 chandransh 20681 
      oprot.writeMapEnd()
20682 
      oprot.writeFieldEnd()
20683 
    if self.ex is not None:
20684 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
20685 
      self.ex.write(oprot)
20686 
      oprot.writeFieldEnd()
20687 
    oprot.writeFieldStop()
20688 
    oprot.writeStructEnd()
20689 
 
20690 
  def validate(self):
20691 
    return
20692 
 
20693 
 
20694 
  def __repr__(self):
20695 
    L = ['%s=%r' % (key, value)
20696 
      for key, value in self.__dict__.iteritems()]
20697 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20698 
 
20699 
  def __eq__(self, other):
20700 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20701 
 
20702 
  def __ne__(self, other):
20703 
    return not (self == other)
4008 mandeep.dh 20704 
 
20705 
class getTransactionsRequiringExtraProcessing_args:
20706 
  """
20707 
  Attributes:
20708 
   - category
20709 
  """
20710 
 
20711 
  thrift_spec = (
20712 
    None, # 0
20713 
    (1, TType.I32, 'category', None, None, ), # 1
20714 
  )
20715 
 
20716 
  def __init__(self, category=None,):
20717 
    self.category = category
20718 
 
20719 
  def read(self, iprot):
20720 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20721 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20722 
      return
20723 
    iprot.readStructBegin()
20724 
    while True:
20725 
      (fname, ftype, fid) = iprot.readFieldBegin()
20726 
      if ftype == TType.STOP:
20727 
        break
20728 
      if fid == 1:
20729 
        if ftype == TType.I32:
20730 
          self.category = iprot.readI32();
20731 
        else:
20732 
          iprot.skip(ftype)
20733 
      else:
20734 
        iprot.skip(ftype)
20735 
      iprot.readFieldEnd()
20736 
    iprot.readStructEnd()
20737 
 
20738 
  def write(self, oprot):
20739 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20740 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20741 
      return
20742 
    oprot.writeStructBegin('getTransactionsRequiringExtraProcessing_args')
20743 
    if self.category is not None:
20744 
      oprot.writeFieldBegin('category', TType.I32, 1)
20745 
      oprot.writeI32(self.category)
20746 
      oprot.writeFieldEnd()
20747 
    oprot.writeFieldStop()
20748 
    oprot.writeStructEnd()
20749 
 
20750 
  def validate(self):
20751 
    return
20752 
 
20753 
 
20754 
  def __repr__(self):
20755 
    L = ['%s=%r' % (key, value)
20756 
      for key, value in self.__dict__.iteritems()]
20757 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20758 
 
20759 
  def __eq__(self, other):
20760 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20761 
 
20762 
  def __ne__(self, other):
20763 
    return not (self == other)
20764 
 
20765 
class getTransactionsRequiringExtraProcessing_result:
20766 
  """
20767 
  Attributes:
20768 
   - success
20769 
  """
20770 
 
20771 
  thrift_spec = (
20772 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
20773 
  )
20774 
 
20775 
  def __init__(self, success=None,):
20776 
    self.success = success
20777 
 
20778 
  def read(self, iprot):
20779 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20780 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20781 
      return
20782 
    iprot.readStructBegin()
20783 
    while True:
20784 
      (fname, ftype, fid) = iprot.readFieldBegin()
20785 
      if ftype == TType.STOP:
20786 
        break
20787 
      if fid == 0:
20788 
        if ftype == TType.LIST:
20789 
          self.success = []
6188 rajveer 20790 
          (_etype474, _size471) = iprot.readListBegin()
20791 
          for _i475 in xrange(_size471):
20792 
            _elem476 = iprot.readI64();
20793 
            self.success.append(_elem476)
4008 mandeep.dh 20794 
          iprot.readListEnd()
20795 
        else:
20796 
          iprot.skip(ftype)
20797 
      else:
20798 
        iprot.skip(ftype)
20799 
      iprot.readFieldEnd()
20800 
    iprot.readStructEnd()
20801 
 
20802 
  def write(self, oprot):
20803 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20804 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20805 
      return
20806 
    oprot.writeStructBegin('getTransactionsRequiringExtraProcessing_result')
20807 
    if self.success is not None:
20808 
      oprot.writeFieldBegin('success', TType.LIST, 0)
20809 
      oprot.writeListBegin(TType.I64, len(self.success))
6188 rajveer 20810 
      for iter477 in self.success:
20811 
        oprot.writeI64(iter477)
4008 mandeep.dh 20812 
      oprot.writeListEnd()
20813 
      oprot.writeFieldEnd()
20814 
    oprot.writeFieldStop()
20815 
    oprot.writeStructEnd()
20816 
 
20817 
  def validate(self):
20818 
    return
20819 
 
20820 
 
20821 
  def __repr__(self):
20822 
    L = ['%s=%r' % (key, value)
20823 
      for key, value in self.__dict__.iteritems()]
20824 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20825 
 
20826 
  def __eq__(self, other):
20827 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20828 
 
20829 
  def __ne__(self, other):
20830 
    return not (self == other)
20831 
 
20832 
class markTransactionAsProcessed_args:
20833 
  """
20834 
  Attributes:
20835 
   - transactionId
20836 
   - category
20837 
  """
20838 
 
20839 
  thrift_spec = (
20840 
    None, # 0
20841 
    (1, TType.I64, 'transactionId', None, None, ), # 1
20842 
    (2, TType.I32, 'category', None, None, ), # 2
20843 
  )
20844 
 
20845 
  def __init__(self, transactionId=None, category=None,):
20846 
    self.transactionId = transactionId
20847 
    self.category = category
20848 
 
20849 
  def read(self, iprot):
20850 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20851 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20852 
      return
20853 
    iprot.readStructBegin()
20854 
    while True:
20855 
      (fname, ftype, fid) = iprot.readFieldBegin()
20856 
      if ftype == TType.STOP:
20857 
        break
20858 
      if fid == 1:
20859 
        if ftype == TType.I64:
20860 
          self.transactionId = iprot.readI64();
20861 
        else:
20862 
          iprot.skip(ftype)
20863 
      elif fid == 2:
20864 
        if ftype == TType.I32:
20865 
          self.category = iprot.readI32();
20866 
        else:
20867 
          iprot.skip(ftype)
20868 
      else:
20869 
        iprot.skip(ftype)
20870 
      iprot.readFieldEnd()
20871 
    iprot.readStructEnd()
20872 
 
20873 
  def write(self, oprot):
20874 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20875 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20876 
      return
20877 
    oprot.writeStructBegin('markTransactionAsProcessed_args')
20878 
    if self.transactionId is not None:
20879 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
20880 
      oprot.writeI64(self.transactionId)
20881 
      oprot.writeFieldEnd()
20882 
    if self.category is not None:
20883 
      oprot.writeFieldBegin('category', TType.I32, 2)
20884 
      oprot.writeI32(self.category)
20885 
      oprot.writeFieldEnd()
20886 
    oprot.writeFieldStop()
20887 
    oprot.writeStructEnd()
20888 
 
20889 
  def validate(self):
20890 
    return
20891 
 
20892 
 
20893 
  def __repr__(self):
20894 
    L = ['%s=%r' % (key, value)
20895 
      for key, value in self.__dict__.iteritems()]
20896 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20897 
 
20898 
  def __eq__(self, other):
20899 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20900 
 
20901 
  def __ne__(self, other):
20902 
    return not (self == other)
20903 
 
20904 
class markTransactionAsProcessed_result:
20905 
 
20906 
  thrift_spec = (
20907 
  )
20908 
 
20909 
  def read(self, iprot):
20910 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20911 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20912 
      return
20913 
    iprot.readStructBegin()
20914 
    while True:
20915 
      (fname, ftype, fid) = iprot.readFieldBegin()
20916 
      if ftype == TType.STOP:
20917 
        break
20918 
      else:
20919 
        iprot.skip(ftype)
20920 
      iprot.readFieldEnd()
20921 
    iprot.readStructEnd()
20922 
 
20923 
  def write(self, oprot):
20924 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20925 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20926 
      return
20927 
    oprot.writeStructBegin('markTransactionAsProcessed_result')
20928 
    oprot.writeFieldStop()
20929 
    oprot.writeStructEnd()
20930 
 
20931 
  def validate(self):
20932 
    return
20933 
 
20934 
 
20935 
  def __repr__(self):
20936 
    L = ['%s=%r' % (key, value)
20937 
      for key, value in self.__dict__.iteritems()]
20938 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20939 
 
20940 
  def __eq__(self, other):
20941 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20942 
 
20943 
  def __ne__(self, other):
20944 
    return not (self == other)
4018 chandransh 20945 
 
20946 
class getItemWiseRiskyOrdersCount_args:
20947 
 
20948 
  thrift_spec = (
20949 
  )
20950 
 
20951 
  def read(self, iprot):
20952 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20953 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20954 
      return
20955 
    iprot.readStructBegin()
20956 
    while True:
20957 
      (fname, ftype, fid) = iprot.readFieldBegin()
20958 
      if ftype == TType.STOP:
20959 
        break
20960 
      else:
20961 
        iprot.skip(ftype)
20962 
      iprot.readFieldEnd()
20963 
    iprot.readStructEnd()
20964 
 
20965 
  def write(self, oprot):
20966 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20967 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20968 
      return
20969 
    oprot.writeStructBegin('getItemWiseRiskyOrdersCount_args')
20970 
    oprot.writeFieldStop()
20971 
    oprot.writeStructEnd()
20972 
 
20973 
  def validate(self):
20974 
    return
20975 
 
20976 
 
20977 
  def __repr__(self):
20978 
    L = ['%s=%r' % (key, value)
20979 
      for key, value in self.__dict__.iteritems()]
20980 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20981 
 
20982 
  def __eq__(self, other):
20983 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20984 
 
20985 
  def __ne__(self, other):
20986 
    return not (self == other)
20987 
 
20988 
class getItemWiseRiskyOrdersCount_result:
20989 
  """
20990 
  Attributes:
20991 
   - success
20992 
  """
20993 
 
20994 
  thrift_spec = (
20995 
    (0, TType.MAP, 'success', (TType.I64,None,TType.I64,None), None, ), # 0
20996 
  )
20997 
 
20998 
  def __init__(self, success=None,):
20999 
    self.success = success
21000 
 
21001 
  def read(self, iprot):
21002 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21003 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21004 
      return
21005 
    iprot.readStructBegin()
21006 
    while True:
21007 
      (fname, ftype, fid) = iprot.readFieldBegin()
21008 
      if ftype == TType.STOP:
21009 
        break
21010 
      if fid == 0:
21011 
        if ftype == TType.MAP:
21012 
          self.success = {}
6188 rajveer 21013 
          (_ktype479, _vtype480, _size478 ) = iprot.readMapBegin()
21014 
          for _i482 in xrange(_size478):
21015 
            _key483 = iprot.readI64();
21016 
            _val484 = iprot.readI64();
21017 
            self.success[_key483] = _val484
4018 chandransh 21018 
          iprot.readMapEnd()
21019 
        else:
21020 
          iprot.skip(ftype)
21021 
      else:
21022 
        iprot.skip(ftype)
21023 
      iprot.readFieldEnd()
21024 
    iprot.readStructEnd()
21025 
 
21026 
  def write(self, oprot):
21027 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21028 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21029 
      return
21030 
    oprot.writeStructBegin('getItemWiseRiskyOrdersCount_result')
21031 
    if self.success is not None:
21032 
      oprot.writeFieldBegin('success', TType.MAP, 0)
21033 
      oprot.writeMapBegin(TType.I64, TType.I64, len(self.success))
6188 rajveer 21034 
      for kiter485,viter486 in self.success.items():
21035 
        oprot.writeI64(kiter485)
21036 
        oprot.writeI64(viter486)
4018 chandransh 21037 
      oprot.writeMapEnd()
21038 
      oprot.writeFieldEnd()
21039 
    oprot.writeFieldStop()
21040 
    oprot.writeStructEnd()
21041 
 
21042 
  def validate(self):
21043 
    return
21044 
 
21045 
 
21046 
  def __repr__(self):
21047 
    L = ['%s=%r' % (key, value)
21048 
      for key, value in self.__dict__.iteritems()]
21049 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21050 
 
21051 
  def __eq__(self, other):
21052 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21053 
 
21054 
  def __ne__(self, other):
21055 
    return not (self == other)
4247 rajveer 21056 
 
4295 varun.gupt 21057 
class getOrdersForItemIds_args:
21058 
  """
21059 
  Attributes:
21060 
   - itemIds
21061 
  """
21062 
 
21063 
  thrift_spec = (
21064 
    None, # 0
21065 
    (1, TType.LIST, 'itemIds', (TType.I64,None), None, ), # 1
21066 
  )
21067 
 
21068 
  def __init__(self, itemIds=None,):
21069 
    self.itemIds = itemIds
21070 
 
21071 
  def read(self, iprot):
21072 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21073 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21074 
      return
21075 
    iprot.readStructBegin()
21076 
    while True:
21077 
      (fname, ftype, fid) = iprot.readFieldBegin()
21078 
      if ftype == TType.STOP:
21079 
        break
21080 
      if fid == 1:
21081 
        if ftype == TType.LIST:
21082 
          self.itemIds = []
6188 rajveer 21083 
          (_etype490, _size487) = iprot.readListBegin()
21084 
          for _i491 in xrange(_size487):
21085 
            _elem492 = iprot.readI64();
21086 
            self.itemIds.append(_elem492)
4295 varun.gupt 21087 
          iprot.readListEnd()
21088 
        else:
21089 
          iprot.skip(ftype)
21090 
      else:
21091 
        iprot.skip(ftype)
21092 
      iprot.readFieldEnd()
21093 
    iprot.readStructEnd()
21094 
 
21095 
  def write(self, oprot):
21096 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21097 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21098 
      return
21099 
    oprot.writeStructBegin('getOrdersForItemIds_args')
21100 
    if self.itemIds is not None:
21101 
      oprot.writeFieldBegin('itemIds', TType.LIST, 1)
21102 
      oprot.writeListBegin(TType.I64, len(self.itemIds))
6188 rajveer 21103 
      for iter493 in self.itemIds:
21104 
        oprot.writeI64(iter493)
4295 varun.gupt 21105 
      oprot.writeListEnd()
21106 
      oprot.writeFieldEnd()
21107 
    oprot.writeFieldStop()
21108 
    oprot.writeStructEnd()
21109 
 
21110 
  def validate(self):
21111 
    return
21112 
 
21113 
 
21114 
  def __repr__(self):
21115 
    L = ['%s=%r' % (key, value)
21116 
      for key, value in self.__dict__.iteritems()]
21117 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21118 
 
21119 
  def __eq__(self, other):
21120 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21121 
 
21122 
  def __ne__(self, other):
21123 
    return not (self == other)
21124 
 
21125 
class getOrdersForItemIds_result:
21126 
  """
21127 
  Attributes:
21128 
   - success
21129 
  """
21130 
 
21131 
  thrift_spec = (
21132 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
21133 
  )
21134 
 
21135 
  def __init__(self, success=None,):
21136 
    self.success = success
21137 
 
21138 
  def read(self, iprot):
21139 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21140 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21141 
      return
21142 
    iprot.readStructBegin()
21143 
    while True:
21144 
      (fname, ftype, fid) = iprot.readFieldBegin()
21145 
      if ftype == TType.STOP:
21146 
        break
21147 
      if fid == 0:
21148 
        if ftype == TType.LIST:
21149 
          self.success = []
6188 rajveer 21150 
          (_etype497, _size494) = iprot.readListBegin()
21151 
          for _i498 in xrange(_size494):
21152 
            _elem499 = Order()
21153 
            _elem499.read(iprot)
21154 
            self.success.append(_elem499)
4295 varun.gupt 21155 
          iprot.readListEnd()
21156 
        else:
21157 
          iprot.skip(ftype)
21158 
      else:
21159 
        iprot.skip(ftype)
21160 
      iprot.readFieldEnd()
21161 
    iprot.readStructEnd()
21162 
 
21163 
  def write(self, oprot):
21164 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21165 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21166 
      return
21167 
    oprot.writeStructBegin('getOrdersForItemIds_result')
21168 
    if self.success is not None:
21169 
      oprot.writeFieldBegin('success', TType.LIST, 0)
21170 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 21171 
      for iter500 in self.success:
21172 
        iter500.write(oprot)
4295 varun.gupt 21173 
      oprot.writeListEnd()
21174 
      oprot.writeFieldEnd()
21175 
    oprot.writeFieldStop()
21176 
    oprot.writeStructEnd()
21177 
 
21178 
  def validate(self):
21179 
    return
21180 
 
21181 
 
21182 
  def __repr__(self):
21183 
    L = ['%s=%r' % (key, value)
21184 
      for key, value in self.__dict__.iteritems()]
21185 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21186 
 
21187 
  def __eq__(self, other):
21188 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21189 
 
21190 
  def __ne__(self, other):
21191 
    return not (self == other)
21192 
 
4247 rajveer 21193 
class markOrderCancellationRequestReceived_args:
21194 
  """
21195 
  Attributes:
21196 
   - orderId
21197 
  """
21198 
 
21199 
  thrift_spec = (
21200 
    None, # 0
21201 
    (1, TType.I64, 'orderId', None, None, ), # 1
21202 
  )
21203 
 
21204 
  def __init__(self, orderId=None,):
21205 
    self.orderId = orderId
21206 
 
21207 
  def read(self, iprot):
21208 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21209 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21210 
      return
21211 
    iprot.readStructBegin()
21212 
    while True:
21213 
      (fname, ftype, fid) = iprot.readFieldBegin()
21214 
      if ftype == TType.STOP:
21215 
        break
21216 
      if fid == 1:
21217 
        if ftype == TType.I64:
21218 
          self.orderId = iprot.readI64();
21219 
        else:
21220 
          iprot.skip(ftype)
21221 
      else:
21222 
        iprot.skip(ftype)
21223 
      iprot.readFieldEnd()
21224 
    iprot.readStructEnd()
21225 
 
21226 
  def write(self, oprot):
21227 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21228 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21229 
      return
21230 
    oprot.writeStructBegin('markOrderCancellationRequestReceived_args')
21231 
    if self.orderId is not None:
21232 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
21233 
      oprot.writeI64(self.orderId)
21234 
      oprot.writeFieldEnd()
21235 
    oprot.writeFieldStop()
21236 
    oprot.writeStructEnd()
21237 
 
21238 
  def validate(self):
21239 
    return
21240 
 
21241 
 
21242 
  def __repr__(self):
21243 
    L = ['%s=%r' % (key, value)
21244 
      for key, value in self.__dict__.iteritems()]
21245 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21246 
 
21247 
  def __eq__(self, other):
21248 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21249 
 
21250 
  def __ne__(self, other):
21251 
    return not (self == other)
21252 
 
21253 
class markOrderCancellationRequestReceived_result:
21254 
  """
21255 
  Attributes:
21256 
   - ex
21257 
  """
21258 
 
21259 
  thrift_spec = (
21260 
    None, # 0
21261 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
21262 
  )
21263 
 
21264 
  def __init__(self, ex=None,):
21265 
    self.ex = ex
21266 
 
21267 
  def read(self, iprot):
21268 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21269 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21270 
      return
21271 
    iprot.readStructBegin()
21272 
    while True:
21273 
      (fname, ftype, fid) = iprot.readFieldBegin()
21274 
      if ftype == TType.STOP:
21275 
        break
21276 
      if fid == 1:
21277 
        if ftype == TType.STRUCT:
21278 
          self.ex = TransactionServiceException()
21279 
          self.ex.read(iprot)
21280 
        else:
21281 
          iprot.skip(ftype)
21282 
      else:
21283 
        iprot.skip(ftype)
21284 
      iprot.readFieldEnd()
21285 
    iprot.readStructEnd()
21286 
 
21287 
  def write(self, oprot):
21288 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21289 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21290 
      return
21291 
    oprot.writeStructBegin('markOrderCancellationRequestReceived_result')
21292 
    if self.ex is not None:
21293 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
21294 
      self.ex.write(oprot)
21295 
      oprot.writeFieldEnd()
21296 
    oprot.writeFieldStop()
21297 
    oprot.writeStructEnd()
21298 
 
21299 
  def validate(self):
21300 
    return
21301 
 
21302 
 
21303 
  def __repr__(self):
21304 
    L = ['%s=%r' % (key, value)
21305 
      for key, value in self.__dict__.iteritems()]
21306 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21307 
 
21308 
  def __eq__(self, other):
21309 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21310 
 
21311 
  def __ne__(self, other):
21312 
    return not (self == other)
21313 
 
21314 
class markOrderCancellationRequestConfirmed_args:
21315 
  """
21316 
  Attributes:
21317 
   - orderId
21318 
  """
21319 
 
21320 
  thrift_spec = (
21321 
    None, # 0
21322 
    (1, TType.I64, 'orderId', None, None, ), # 1
21323 
  )
21324 
 
21325 
  def __init__(self, orderId=None,):
21326 
    self.orderId = orderId
21327 
 
21328 
  def read(self, iprot):
21329 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21330 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21331 
      return
21332 
    iprot.readStructBegin()
21333 
    while True:
21334 
      (fname, ftype, fid) = iprot.readFieldBegin()
21335 
      if ftype == TType.STOP:
21336 
        break
21337 
      if fid == 1:
21338 
        if ftype == TType.I64:
21339 
          self.orderId = iprot.readI64();
21340 
        else:
21341 
          iprot.skip(ftype)
21342 
      else:
21343 
        iprot.skip(ftype)
21344 
      iprot.readFieldEnd()
21345 
    iprot.readStructEnd()
21346 
 
21347 
  def write(self, oprot):
21348 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21349 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21350 
      return
21351 
    oprot.writeStructBegin('markOrderCancellationRequestConfirmed_args')
21352 
    if self.orderId is not None:
21353 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
21354 
      oprot.writeI64(self.orderId)
21355 
      oprot.writeFieldEnd()
21356 
    oprot.writeFieldStop()
21357 
    oprot.writeStructEnd()
21358 
 
21359 
  def validate(self):
21360 
    return
21361 
 
21362 
 
21363 
  def __repr__(self):
21364 
    L = ['%s=%r' % (key, value)
21365 
      for key, value in self.__dict__.iteritems()]
21366 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21367 
 
21368 
  def __eq__(self, other):
21369 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21370 
 
21371 
  def __ne__(self, other):
21372 
    return not (self == other)
21373 
 
21374 
class markOrderCancellationRequestConfirmed_result:
21375 
  """
21376 
  Attributes:
21377 
   - ex
21378 
  """
21379 
 
21380 
  thrift_spec = (
21381 
    None, # 0
21382 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
21383 
  )
21384 
 
21385 
  def __init__(self, ex=None,):
21386 
    self.ex = ex
21387 
 
21388 
  def read(self, iprot):
21389 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21390 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21391 
      return
21392 
    iprot.readStructBegin()
21393 
    while True:
21394 
      (fname, ftype, fid) = iprot.readFieldBegin()
21395 
      if ftype == TType.STOP:
21396 
        break
21397 
      if fid == 1:
21398 
        if ftype == TType.STRUCT:
21399 
          self.ex = TransactionServiceException()
21400 
          self.ex.read(iprot)
21401 
        else:
21402 
          iprot.skip(ftype)
21403 
      else:
21404 
        iprot.skip(ftype)
21405 
      iprot.readFieldEnd()
21406 
    iprot.readStructEnd()
21407 
 
21408 
  def write(self, oprot):
21409 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21410 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21411 
      return
21412 
    oprot.writeStructBegin('markOrderCancellationRequestConfirmed_result')
21413 
    if self.ex is not None:
21414 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
21415 
      self.ex.write(oprot)
21416 
      oprot.writeFieldEnd()
21417 
    oprot.writeFieldStop()
21418 
    oprot.writeStructEnd()
21419 
 
21420 
  def validate(self):
21421 
    return
21422 
 
21423 
 
21424 
  def __repr__(self):
21425 
    L = ['%s=%r' % (key, value)
21426 
      for key, value in self.__dict__.iteritems()]
21427 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21428 
 
21429 
  def __eq__(self, other):
21430 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21431 
 
21432 
  def __ne__(self, other):
21433 
    return not (self == other)
21434 
 
21435 
class markOrderCancellationRequestDenied_args:
21436 
  """
21437 
  Attributes:
21438 
   - orderId
21439 
  """
21440 
 
21441 
  thrift_spec = (
21442 
    None, # 0
21443 
    (1, TType.I64, 'orderId', None, None, ), # 1
21444 
  )
21445 
 
21446 
  def __init__(self, orderId=None,):
21447 
    self.orderId = orderId
21448 
 
21449 
  def read(self, iprot):
21450 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21451 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21452 
      return
21453 
    iprot.readStructBegin()
21454 
    while True:
21455 
      (fname, ftype, fid) = iprot.readFieldBegin()
21456 
      if ftype == TType.STOP:
21457 
        break
21458 
      if fid == 1:
21459 
        if ftype == TType.I64:
21460 
          self.orderId = iprot.readI64();
21461 
        else:
21462 
          iprot.skip(ftype)
21463 
      else:
21464 
        iprot.skip(ftype)
21465 
      iprot.readFieldEnd()
21466 
    iprot.readStructEnd()
21467 
 
21468 
  def write(self, oprot):
21469 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21470 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21471 
      return
21472 
    oprot.writeStructBegin('markOrderCancellationRequestDenied_args')
21473 
    if self.orderId is not None:
21474 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
21475 
      oprot.writeI64(self.orderId)
21476 
      oprot.writeFieldEnd()
21477 
    oprot.writeFieldStop()
21478 
    oprot.writeStructEnd()
21479 
 
21480 
  def validate(self):
21481 
    return
21482 
 
21483 
 
21484 
  def __repr__(self):
21485 
    L = ['%s=%r' % (key, value)
21486 
      for key, value in self.__dict__.iteritems()]
21487 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21488 
 
21489 
  def __eq__(self, other):
21490 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21491 
 
21492 
  def __ne__(self, other):
21493 
    return not (self == other)
21494 
 
21495 
class markOrderCancellationRequestDenied_result:
21496 
  """
21497 
  Attributes:
21498 
   - ex
21499 
  """
21500 
 
21501 
  thrift_spec = (
21502 
    None, # 0
21503 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
21504 
  )
21505 
 
21506 
  def __init__(self, ex=None,):
21507 
    self.ex = ex
21508 
 
21509 
  def read(self, iprot):
21510 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21511 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21512 
      return
21513 
    iprot.readStructBegin()
21514 
    while True:
21515 
      (fname, ftype, fid) = iprot.readFieldBegin()
21516 
      if ftype == TType.STOP:
21517 
        break
21518 
      if fid == 1:
21519 
        if ftype == TType.STRUCT:
21520 
          self.ex = TransactionServiceException()
21521 
          self.ex.read(iprot)
21522 
        else:
21523 
          iprot.skip(ftype)
21524 
      else:
21525 
        iprot.skip(ftype)
21526 
      iprot.readFieldEnd()
21527 
    iprot.readStructEnd()
21528 
 
21529 
  def write(self, oprot):
21530 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21531 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21532 
      return
21533 
    oprot.writeStructBegin('markOrderCancellationRequestDenied_result')
21534 
    if self.ex is not None:
21535 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
21536 
      self.ex.write(oprot)
21537 
      oprot.writeFieldEnd()
21538 
    oprot.writeFieldStop()
21539 
    oprot.writeStructEnd()
21540 
 
21541 
  def validate(self):
21542 
    return
21543 
 
21544 
 
21545 
  def __repr__(self):
21546 
    L = ['%s=%r' % (key, value)
21547 
      for key, value in self.__dict__.iteritems()]
21548 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21549 
 
21550 
  def __eq__(self, other):
21551 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21552 
 
21553 
  def __ne__(self, other):
21554 
    return not (self == other)
21555 
 
4258 rajveer 21556 
class markTransactionAsPaymentFlagRemoved_args:
4247 rajveer 21557 
  """
21558 
  Attributes:
4258 rajveer 21559 
   - transactionId
4247 rajveer 21560 
  """
21561 
 
21562 
  thrift_spec = (
21563 
    None, # 0
4258 rajveer 21564 
    (1, TType.I64, 'transactionId', None, None, ), # 1
4247 rajveer 21565 
  )
21566 
 
4258 rajveer 21567 
  def __init__(self, transactionId=None,):
21568 
    self.transactionId = transactionId
4247 rajveer 21569 
 
21570 
  def read(self, iprot):
21571 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21572 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21573 
      return
21574 
    iprot.readStructBegin()
21575 
    while True:
21576 
      (fname, ftype, fid) = iprot.readFieldBegin()
21577 
      if ftype == TType.STOP:
21578 
        break
21579 
      if fid == 1:
21580 
        if ftype == TType.I64:
4258 rajveer 21581 
          self.transactionId = iprot.readI64();
4247 rajveer 21582 
        else:
21583 
          iprot.skip(ftype)
21584 
      else:
21585 
        iprot.skip(ftype)
21586 
      iprot.readFieldEnd()
21587 
    iprot.readStructEnd()
21588 
 
21589 
  def write(self, oprot):
21590 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21591 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21592 
      return
4258 rajveer 21593 
    oprot.writeStructBegin('markTransactionAsPaymentFlagRemoved_args')
21594 
    if self.transactionId is not None:
21595 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
21596 
      oprot.writeI64(self.transactionId)
4247 rajveer 21597 
      oprot.writeFieldEnd()
21598 
    oprot.writeFieldStop()
21599 
    oprot.writeStructEnd()
21600 
 
21601 
  def validate(self):
21602 
    return
21603 
 
21604 
 
21605 
  def __repr__(self):
21606 
    L = ['%s=%r' % (key, value)
21607 
      for key, value in self.__dict__.iteritems()]
21608 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21609 
 
21610 
  def __eq__(self, other):
21611 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21612 
 
21613 
  def __ne__(self, other):
21614 
    return not (self == other)
21615 
 
4258 rajveer 21616 
class markTransactionAsPaymentFlagRemoved_result:
4247 rajveer 21617 
  """
21618 
  Attributes:
21619 
   - ex
21620 
  """
21621 
 
21622 
  thrift_spec = (
21623 
    None, # 0
21624 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
21625 
  )
21626 
 
21627 
  def __init__(self, ex=None,):
21628 
    self.ex = ex
21629 
 
21630 
  def read(self, iprot):
21631 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21632 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21633 
      return
21634 
    iprot.readStructBegin()
21635 
    while True:
21636 
      (fname, ftype, fid) = iprot.readFieldBegin()
21637 
      if ftype == TType.STOP:
21638 
        break
21639 
      if fid == 1:
21640 
        if ftype == TType.STRUCT:
21641 
          self.ex = TransactionServiceException()
21642 
          self.ex.read(iprot)
21643 
        else:
21644 
          iprot.skip(ftype)
21645 
      else:
21646 
        iprot.skip(ftype)
21647 
      iprot.readFieldEnd()
21648 
    iprot.readStructEnd()
21649 
 
21650 
  def write(self, oprot):
21651 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21652 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21653 
      return
4258 rajveer 21654 
    oprot.writeStructBegin('markTransactionAsPaymentFlagRemoved_result')
4247 rajveer 21655 
    if self.ex is not None:
21656 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
21657 
      self.ex.write(oprot)
21658 
      oprot.writeFieldEnd()
21659 
    oprot.writeFieldStop()
21660 
    oprot.writeStructEnd()
21661 
 
21662 
  def validate(self):
21663 
    return
21664 
 
21665 
 
21666 
  def __repr__(self):
21667 
    L = ['%s=%r' % (key, value)
21668 
      for key, value in self.__dict__.iteritems()]
21669 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21670 
 
21671 
  def __eq__(self, other):
21672 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21673 
 
21674 
  def __ne__(self, other):
21675 
    return not (self == other)
4259 anupam.sin 21676 
 
21677 
class refundTransaction_args:
21678 
  """
21679 
  Attributes:
21680 
   - transactionId
21681 
   - refundedBy
21682 
   - reason
21683 
  """
21684 
 
21685 
  thrift_spec = (
21686 
    None, # 0
21687 
    (1, TType.I64, 'transactionId', None, None, ), # 1
21688 
    (2, TType.STRING, 'refundedBy', None, None, ), # 2
21689 
    (3, TType.STRING, 'reason', None, None, ), # 3
21690 
  )
21691 
 
21692 
  def __init__(self, transactionId=None, refundedBy=None, reason=None,):
21693 
    self.transactionId = transactionId
21694 
    self.refundedBy = refundedBy
21695 
    self.reason = reason
21696 
 
21697 
  def read(self, iprot):
21698 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21699 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21700 
      return
21701 
    iprot.readStructBegin()
21702 
    while True:
21703 
      (fname, ftype, fid) = iprot.readFieldBegin()
21704 
      if ftype == TType.STOP:
21705 
        break
21706 
      if fid == 1:
21707 
        if ftype == TType.I64:
21708 
          self.transactionId = iprot.readI64();
21709 
        else:
21710 
          iprot.skip(ftype)
21711 
      elif fid == 2:
21712 
        if ftype == TType.STRING:
21713 
          self.refundedBy = iprot.readString();
21714 
        else:
21715 
          iprot.skip(ftype)
21716 
      elif fid == 3:
21717 
        if ftype == TType.STRING:
21718 
          self.reason = iprot.readString();
21719 
        else:
21720 
          iprot.skip(ftype)
21721 
      else:
21722 
        iprot.skip(ftype)
21723 
      iprot.readFieldEnd()
21724 
    iprot.readStructEnd()
21725 
 
21726 
  def write(self, oprot):
21727 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21728 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21729 
      return
21730 
    oprot.writeStructBegin('refundTransaction_args')
21731 
    if self.transactionId is not None:
21732 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
21733 
      oprot.writeI64(self.transactionId)
21734 
      oprot.writeFieldEnd()
21735 
    if self.refundedBy is not None:
21736 
      oprot.writeFieldBegin('refundedBy', TType.STRING, 2)
21737 
      oprot.writeString(self.refundedBy)
21738 
      oprot.writeFieldEnd()
21739 
    if self.reason is not None:
21740 
      oprot.writeFieldBegin('reason', TType.STRING, 3)
21741 
      oprot.writeString(self.reason)
21742 
      oprot.writeFieldEnd()
21743 
    oprot.writeFieldStop()
21744 
    oprot.writeStructEnd()
21745 
 
21746 
  def validate(self):
21747 
    return
21748 
 
21749 
 
21750 
  def __repr__(self):
21751 
    L = ['%s=%r' % (key, value)
21752 
      for key, value in self.__dict__.iteritems()]
21753 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21754 
 
21755 
  def __eq__(self, other):
21756 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21757 
 
21758 
  def __ne__(self, other):
21759 
    return not (self == other)
21760 
 
21761 
class refundTransaction_result:
21762 
  """
21763 
  Attributes:
21764 
   - ex
21765 
  """
21766 
 
21767 
  thrift_spec = (
21768 
    None, # 0
21769 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
21770 
  )
21771 
 
21772 
  def __init__(self, ex=None,):
21773 
    self.ex = ex
21774 
 
21775 
  def read(self, iprot):
21776 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21777 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21778 
      return
21779 
    iprot.readStructBegin()
21780 
    while True:
21781 
      (fname, ftype, fid) = iprot.readFieldBegin()
21782 
      if ftype == TType.STOP:
21783 
        break
21784 
      if fid == 1:
21785 
        if ftype == TType.STRUCT:
21786 
          self.ex = TransactionServiceException()
21787 
          self.ex.read(iprot)
21788 
        else:
21789 
          iprot.skip(ftype)
21790 
      else:
21791 
        iprot.skip(ftype)
21792 
      iprot.readFieldEnd()
21793 
    iprot.readStructEnd()
21794 
 
21795 
  def write(self, oprot):
21796 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21797 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21798 
      return
21799 
    oprot.writeStructBegin('refundTransaction_result')
21800 
    if self.ex is not None:
21801 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
21802 
      self.ex.write(oprot)
21803 
      oprot.writeFieldEnd()
21804 
    oprot.writeFieldStop()
21805 
    oprot.writeStructEnd()
21806 
 
21807 
  def validate(self):
21808 
    return
21809 
 
21810 
 
21811 
  def __repr__(self):
21812 
    L = ['%s=%r' % (key, value)
21813 
      for key, value in self.__dict__.iteritems()]
21814 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21815 
 
21816 
  def __eq__(self, other):
21817 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21818 
 
21819 
  def __ne__(self, other):
21820 
    return not (self == other)
4285 rajveer 21821 
 
4324 mandeep.dh 21822 
class updateShipmentAddress_args:
21823 
  """
21824 
  Attributes:
21825 
   - orderId
21826 
   - addressId
21827 
  """
21828 
 
21829 
  thrift_spec = (
21830 
    None, # 0
21831 
    (1, TType.I64, 'orderId', None, None, ), # 1
21832 
    (2, TType.I64, 'addressId', None, None, ), # 2
21833 
  )
21834 
 
21835 
  def __init__(self, orderId=None, addressId=None,):
21836 
    self.orderId = orderId
21837 
    self.addressId = addressId
21838 
 
21839 
  def read(self, iprot):
21840 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21841 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21842 
      return
21843 
    iprot.readStructBegin()
21844 
    while True:
21845 
      (fname, ftype, fid) = iprot.readFieldBegin()
21846 
      if ftype == TType.STOP:
21847 
        break
21848 
      if fid == 1:
21849 
        if ftype == TType.I64:
21850 
          self.orderId = iprot.readI64();
21851 
        else:
21852 
          iprot.skip(ftype)
21853 
      elif fid == 2:
21854 
        if ftype == TType.I64:
21855 
          self.addressId = iprot.readI64();
21856 
        else:
21857 
          iprot.skip(ftype)
21858 
      else:
21859 
        iprot.skip(ftype)
21860 
      iprot.readFieldEnd()
21861 
    iprot.readStructEnd()
21862 
 
21863 
  def write(self, oprot):
21864 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21865 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21866 
      return
21867 
    oprot.writeStructBegin('updateShipmentAddress_args')
21868 
    if self.orderId is not None:
21869 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
21870 
      oprot.writeI64(self.orderId)
21871 
      oprot.writeFieldEnd()
21872 
    if self.addressId is not None:
21873 
      oprot.writeFieldBegin('addressId', TType.I64, 2)
21874 
      oprot.writeI64(self.addressId)
21875 
      oprot.writeFieldEnd()
21876 
    oprot.writeFieldStop()
21877 
    oprot.writeStructEnd()
21878 
 
21879 
  def validate(self):
21880 
    return
21881 
 
21882 
 
21883 
  def __repr__(self):
21884 
    L = ['%s=%r' % (key, value)
21885 
      for key, value in self.__dict__.iteritems()]
21886 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21887 
 
21888 
  def __eq__(self, other):
21889 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21890 
 
21891 
  def __ne__(self, other):
21892 
    return not (self == other)
21893 
 
21894 
class updateShipmentAddress_result:
21895 
  """
21896 
  Attributes:
21897 
   - ex
21898 
  """
21899 
 
21900 
  thrift_spec = (
21901 
    None, # 0
21902 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
21903 
  )
21904 
 
21905 
  def __init__(self, ex=None,):
21906 
    self.ex = ex
21907 
 
21908 
  def read(self, iprot):
21909 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21910 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21911 
      return
21912 
    iprot.readStructBegin()
21913 
    while True:
21914 
      (fname, ftype, fid) = iprot.readFieldBegin()
21915 
      if ftype == TType.STOP:
21916 
        break
21917 
      if fid == 1:
21918 
        if ftype == TType.STRUCT:
21919 
          self.ex = TransactionServiceException()
21920 
          self.ex.read(iprot)
21921 
        else:
21922 
          iprot.skip(ftype)
21923 
      else:
21924 
        iprot.skip(ftype)
21925 
      iprot.readFieldEnd()
21926 
    iprot.readStructEnd()
21927 
 
21928 
  def write(self, oprot):
21929 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21930 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21931 
      return
21932 
    oprot.writeStructBegin('updateShipmentAddress_result')
21933 
    if self.ex is not None:
21934 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
21935 
      self.ex.write(oprot)
21936 
      oprot.writeFieldEnd()
21937 
    oprot.writeFieldStop()
21938 
    oprot.writeStructEnd()
21939 
 
21940 
  def validate(self):
21941 
    return
21942 
 
21943 
 
21944 
  def __repr__(self):
21945 
    L = ['%s=%r' % (key, value)
21946 
      for key, value in self.__dict__.iteritems()]
21947 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21948 
 
21949 
  def __eq__(self, other):
21950 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21951 
 
21952 
  def __ne__(self, other):
21953 
    return not (self == other)
21954 
 
4285 rajveer 21955 
class acceptOrdersForItemId_args:
21956 
  """
21957 
  Attributes:
21958 
   - itemId
21959 
   - inventory
21960 
  """
21961 
 
21962 
  thrift_spec = (
21963 
    None, # 0
21964 
    (1, TType.I64, 'itemId', None, None, ), # 1
21965 
    (2, TType.I64, 'inventory', None, None, ), # 2
21966 
  )
21967 
 
21968 
  def __init__(self, itemId=None, inventory=None,):
21969 
    self.itemId = itemId
21970 
    self.inventory = inventory
21971 
 
21972 
  def read(self, iprot):
21973 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21974 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21975 
      return
21976 
    iprot.readStructBegin()
21977 
    while True:
21978 
      (fname, ftype, fid) = iprot.readFieldBegin()
21979 
      if ftype == TType.STOP:
21980 
        break
21981 
      if fid == 1:
21982 
        if ftype == TType.I64:
21983 
          self.itemId = iprot.readI64();
21984 
        else:
21985 
          iprot.skip(ftype)
21986 
      elif fid == 2:
21987 
        if ftype == TType.I64:
21988 
          self.inventory = iprot.readI64();
21989 
        else:
21990 
          iprot.skip(ftype)
21991 
      else:
21992 
        iprot.skip(ftype)
21993 
      iprot.readFieldEnd()
21994 
    iprot.readStructEnd()
21995 
 
21996 
  def write(self, oprot):
21997 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21998 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21999 
      return
22000 
    oprot.writeStructBegin('acceptOrdersForItemId_args')
22001 
    if self.itemId is not None:
22002 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
22003 
      oprot.writeI64(self.itemId)
22004 
      oprot.writeFieldEnd()
22005 
    if self.inventory is not None:
22006 
      oprot.writeFieldBegin('inventory', TType.I64, 2)
22007 
      oprot.writeI64(self.inventory)
22008 
      oprot.writeFieldEnd()
22009 
    oprot.writeFieldStop()
22010 
    oprot.writeStructEnd()
22011 
 
22012 
  def validate(self):
22013 
    return
22014 
 
22015 
 
22016 
  def __repr__(self):
22017 
    L = ['%s=%r' % (key, value)
22018 
      for key, value in self.__dict__.iteritems()]
22019 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22020 
 
22021 
  def __eq__(self, other):
22022 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22023 
 
22024 
  def __ne__(self, other):
22025 
    return not (self == other)
22026 
 
22027 
class acceptOrdersForItemId_result:
22028 
  """
22029 
  Attributes:
22030 
   - success
22031 
   - ex
22032 
  """
22033 
 
22034 
  thrift_spec = (
22035 
    (0, TType.BOOL, 'success', None, None, ), # 0
22036 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
22037 
  )
22038 
 
22039 
  def __init__(self, success=None, ex=None,):
22040 
    self.success = success
22041 
    self.ex = ex
22042 
 
22043 
  def read(self, iprot):
22044 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22045 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22046 
      return
22047 
    iprot.readStructBegin()
22048 
    while True:
22049 
      (fname, ftype, fid) = iprot.readFieldBegin()
22050 
      if ftype == TType.STOP:
22051 
        break
22052 
      if fid == 0:
22053 
        if ftype == TType.BOOL:
22054 
          self.success = iprot.readBool();
22055 
        else:
22056 
          iprot.skip(ftype)
22057 
      elif fid == 1:
22058 
        if ftype == TType.STRUCT:
22059 
          self.ex = TransactionServiceException()
22060 
          self.ex.read(iprot)
22061 
        else:
22062 
          iprot.skip(ftype)
22063 
      else:
22064 
        iprot.skip(ftype)
22065 
      iprot.readFieldEnd()
22066 
    iprot.readStructEnd()
22067 
 
22068 
  def write(self, oprot):
22069 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22070 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22071 
      return
22072 
    oprot.writeStructBegin('acceptOrdersForItemId_result')
22073 
    if self.success is not None:
22074 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
22075 
      oprot.writeBool(self.success)
22076 
      oprot.writeFieldEnd()
22077 
    if self.ex is not None:
22078 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
22079 
      self.ex.write(oprot)
22080 
      oprot.writeFieldEnd()
22081 
    oprot.writeFieldStop()
22082 
    oprot.writeStructEnd()
22083 
 
22084 
  def validate(self):
22085 
    return
22086 
 
22087 
 
22088 
  def __repr__(self):
22089 
    L = ['%s=%r' % (key, value)
22090 
      for key, value in self.__dict__.iteritems()]
22091 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22092 
 
22093 
  def __eq__(self, other):
22094 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22095 
 
22096 
  def __ne__(self, other):
22097 
    return not (self == other)
4303 rajveer 22098 
 
22099 
class markOrdersAsPORaised_args:
22100 
  """
22101 
  Attributes:
22102 
   - vendorId
22103 
   - itemId
22104 
   - quantity
22105 
   - estimate
4369 rajveer 22106 
   - isReminder
4303 rajveer 22107 
  """
22108 
 
22109 
  thrift_spec = (
22110 
    None, # 0
22111 
    (1, TType.I64, 'vendorId', None, None, ), # 1
22112 
    (2, TType.I64, 'itemId', None, None, ), # 2
22113 
    (3, TType.I64, 'quantity', None, None, ), # 3
22114 
    (4, TType.I64, 'estimate', None, None, ), # 4
4369 rajveer 22115 
    (5, TType.BOOL, 'isReminder', None, None, ), # 5
4303 rajveer 22116 
  )
22117 
 
4369 rajveer 22118 
  def __init__(self, vendorId=None, itemId=None, quantity=None, estimate=None, isReminder=None,):
4303 rajveer 22119 
    self.vendorId = vendorId
22120 
    self.itemId = itemId
22121 
    self.quantity = quantity
22122 
    self.estimate = estimate
4369 rajveer 22123 
    self.isReminder = isReminder
4303 rajveer 22124 
 
22125 
  def read(self, iprot):
22126 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22127 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22128 
      return
22129 
    iprot.readStructBegin()
22130 
    while True:
22131 
      (fname, ftype, fid) = iprot.readFieldBegin()
22132 
      if ftype == TType.STOP:
22133 
        break
22134 
      if fid == 1:
22135 
        if ftype == TType.I64:
22136 
          self.vendorId = iprot.readI64();
22137 
        else:
22138 
          iprot.skip(ftype)
22139 
      elif fid == 2:
22140 
        if ftype == TType.I64:
22141 
          self.itemId = iprot.readI64();
22142 
        else:
22143 
          iprot.skip(ftype)
22144 
      elif fid == 3:
22145 
        if ftype == TType.I64:
22146 
          self.quantity = iprot.readI64();
22147 
        else:
22148 
          iprot.skip(ftype)
22149 
      elif fid == 4:
22150 
        if ftype == TType.I64:
22151 
          self.estimate = iprot.readI64();
22152 
        else:
22153 
          iprot.skip(ftype)
4369 rajveer 22154 
      elif fid == 5:
22155 
        if ftype == TType.BOOL:
22156 
          self.isReminder = iprot.readBool();
22157 
        else:
22158 
          iprot.skip(ftype)
4303 rajveer 22159 
      else:
22160 
        iprot.skip(ftype)
22161 
      iprot.readFieldEnd()
22162 
    iprot.readStructEnd()
22163 
 
22164 
  def write(self, oprot):
22165 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22166 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22167 
      return
22168 
    oprot.writeStructBegin('markOrdersAsPORaised_args')
22169 
    if self.vendorId is not None:
22170 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
22171 
      oprot.writeI64(self.vendorId)
22172 
      oprot.writeFieldEnd()
22173 
    if self.itemId is not None:
22174 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
22175 
      oprot.writeI64(self.itemId)
22176 
      oprot.writeFieldEnd()
22177 
    if self.quantity is not None:
22178 
      oprot.writeFieldBegin('quantity', TType.I64, 3)
22179 
      oprot.writeI64(self.quantity)
22180 
      oprot.writeFieldEnd()
22181 
    if self.estimate is not None:
22182 
      oprot.writeFieldBegin('estimate', TType.I64, 4)
22183 
      oprot.writeI64(self.estimate)
22184 
      oprot.writeFieldEnd()
4369 rajveer 22185 
    if self.isReminder is not None:
22186 
      oprot.writeFieldBegin('isReminder', TType.BOOL, 5)
22187 
      oprot.writeBool(self.isReminder)
22188 
      oprot.writeFieldEnd()
4303 rajveer 22189 
    oprot.writeFieldStop()
22190 
    oprot.writeStructEnd()
22191 
 
22192 
  def validate(self):
22193 
    return
22194 
 
22195 
 
22196 
  def __repr__(self):
22197 
    L = ['%s=%r' % (key, value)
22198 
      for key, value in self.__dict__.iteritems()]
22199 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22200 
 
22201 
  def __eq__(self, other):
22202 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22203 
 
22204 
  def __ne__(self, other):
22205 
    return not (self == other)
22206 
 
22207 
class markOrdersAsPORaised_result:
22208 
  """
22209 
  Attributes:
22210 
   - ex
22211 
  """
22212 
 
22213 
  thrift_spec = (
22214 
    None, # 0
22215 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
22216 
  )
22217 
 
22218 
  def __init__(self, ex=None,):
22219 
    self.ex = ex
22220 
 
22221 
  def read(self, iprot):
22222 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22223 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22224 
      return
22225 
    iprot.readStructBegin()
22226 
    while True:
22227 
      (fname, ftype, fid) = iprot.readFieldBegin()
22228 
      if ftype == TType.STOP:
22229 
        break
22230 
      if fid == 1:
22231 
        if ftype == TType.STRUCT:
22232 
          self.ex = TransactionServiceException()
22233 
          self.ex.read(iprot)
22234 
        else:
22235 
          iprot.skip(ftype)
22236 
      else:
22237 
        iprot.skip(ftype)
22238 
      iprot.readFieldEnd()
22239 
    iprot.readStructEnd()
22240 
 
22241 
  def write(self, oprot):
22242 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22243 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22244 
      return
22245 
    oprot.writeStructBegin('markOrdersAsPORaised_result')
22246 
    if self.ex is not None:
22247 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
22248 
      self.ex.write(oprot)
22249 
      oprot.writeFieldEnd()
22250 
    oprot.writeFieldStop()
22251 
    oprot.writeStructEnd()
22252 
 
22253 
  def validate(self):
22254 
    return
22255 
 
22256 
 
22257 
  def __repr__(self):
22258 
    L = ['%s=%r' % (key, value)
22259 
      for key, value in self.__dict__.iteritems()]
22260 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22261 
 
22262 
  def __eq__(self, other):
22263 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22264 
 
22265 
  def __ne__(self, other):
22266 
    return not (self == other)
22267 
 
22268 
class markOrdersAsReversalInitiated_args:
22269 
  """
22270 
  Attributes:
22271 
   - vendorId
22272 
   - itemId
22273 
   - quantity
22274 
   - estimate
4369 rajveer 22275 
   - isReminder
4303 rajveer 22276 
  """
22277 
 
22278 
  thrift_spec = (
22279 
    None, # 0
22280 
    (1, TType.I64, 'vendorId', None, None, ), # 1
22281 
    (2, TType.I64, 'itemId', None, None, ), # 2
22282 
    (3, TType.I64, 'quantity', None, None, ), # 3
22283 
    (4, TType.I64, 'estimate', None, None, ), # 4
4369 rajveer 22284 
    (5, TType.BOOL, 'isReminder', None, None, ), # 5
4303 rajveer 22285 
  )
22286 
 
4369 rajveer 22287 
  def __init__(self, vendorId=None, itemId=None, quantity=None, estimate=None, isReminder=None,):
4303 rajveer 22288 
    self.vendorId = vendorId
22289 
    self.itemId = itemId
22290 
    self.quantity = quantity
22291 
    self.estimate = estimate
4369 rajveer 22292 
    self.isReminder = isReminder
4303 rajveer 22293 
 
22294 
  def read(self, iprot):
22295 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22296 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22297 
      return
22298 
    iprot.readStructBegin()
22299 
    while True:
22300 
      (fname, ftype, fid) = iprot.readFieldBegin()
22301 
      if ftype == TType.STOP:
22302 
        break
22303 
      if fid == 1:
22304 
        if ftype == TType.I64:
22305 
          self.vendorId = iprot.readI64();
22306 
        else:
22307 
          iprot.skip(ftype)
22308 
      elif fid == 2:
22309 
        if ftype == TType.I64:
22310 
          self.itemId = iprot.readI64();
22311 
        else:
22312 
          iprot.skip(ftype)
22313 
      elif fid == 3:
22314 
        if ftype == TType.I64:
22315 
          self.quantity = iprot.readI64();
22316 
        else:
22317 
          iprot.skip(ftype)
22318 
      elif fid == 4:
22319 
        if ftype == TType.I64:
22320 
          self.estimate = iprot.readI64();
22321 
        else:
22322 
          iprot.skip(ftype)
4369 rajveer 22323 
      elif fid == 5:
22324 
        if ftype == TType.BOOL:
22325 
          self.isReminder = iprot.readBool();
22326 
        else:
22327 
          iprot.skip(ftype)
4303 rajveer 22328 
      else:
22329 
        iprot.skip(ftype)
22330 
      iprot.readFieldEnd()
22331 
    iprot.readStructEnd()
22332 
 
22333 
  def write(self, oprot):
22334 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22335 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22336 
      return
22337 
    oprot.writeStructBegin('markOrdersAsReversalInitiated_args')
22338 
    if self.vendorId is not None:
22339 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
22340 
      oprot.writeI64(self.vendorId)
22341 
      oprot.writeFieldEnd()
22342 
    if self.itemId is not None:
22343 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
22344 
      oprot.writeI64(self.itemId)
22345 
      oprot.writeFieldEnd()
22346 
    if self.quantity is not None:
22347 
      oprot.writeFieldBegin('quantity', TType.I64, 3)
22348 
      oprot.writeI64(self.quantity)
22349 
      oprot.writeFieldEnd()
22350 
    if self.estimate is not None:
22351 
      oprot.writeFieldBegin('estimate', TType.I64, 4)
22352 
      oprot.writeI64(self.estimate)
22353 
      oprot.writeFieldEnd()
4369 rajveer 22354 
    if self.isReminder is not None:
22355 
      oprot.writeFieldBegin('isReminder', TType.BOOL, 5)
22356 
      oprot.writeBool(self.isReminder)
22357 
      oprot.writeFieldEnd()
4303 rajveer 22358 
    oprot.writeFieldStop()
22359 
    oprot.writeStructEnd()
22360 
 
22361 
  def validate(self):
22362 
    return
22363 
 
22364 
 
22365 
  def __repr__(self):
22366 
    L = ['%s=%r' % (key, value)
22367 
      for key, value in self.__dict__.iteritems()]
22368 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22369 
 
22370 
  def __eq__(self, other):
22371 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22372 
 
22373 
  def __ne__(self, other):
22374 
    return not (self == other)
22375 
 
22376 
class markOrdersAsReversalInitiated_result:
22377 
  """
22378 
  Attributes:
22379 
   - ex
22380 
  """
22381 
 
22382 
  thrift_spec = (
22383 
    None, # 0
22384 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
22385 
  )
22386 
 
22387 
  def __init__(self, ex=None,):
22388 
    self.ex = ex
22389 
 
22390 
  def read(self, iprot):
22391 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22392 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22393 
      return
22394 
    iprot.readStructBegin()
22395 
    while True:
22396 
      (fname, ftype, fid) = iprot.readFieldBegin()
22397 
      if ftype == TType.STOP:
22398 
        break
22399 
      if fid == 1:
22400 
        if ftype == TType.STRUCT:
22401 
          self.ex = TransactionServiceException()
22402 
          self.ex.read(iprot)
22403 
        else:
22404 
          iprot.skip(ftype)
22405 
      else:
22406 
        iprot.skip(ftype)
22407 
      iprot.readFieldEnd()
22408 
    iprot.readStructEnd()
22409 
 
22410 
  def write(self, oprot):
22411 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22412 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22413 
      return
22414 
    oprot.writeStructBegin('markOrdersAsReversalInitiated_result')
22415 
    if self.ex is not None:
22416 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
22417 
      self.ex.write(oprot)
22418 
      oprot.writeFieldEnd()
22419 
    oprot.writeFieldStop()
22420 
    oprot.writeStructEnd()
22421 
 
22422 
  def validate(self):
22423 
    return
22424 
 
22425 
 
22426 
  def __repr__(self):
22427 
    L = ['%s=%r' % (key, value)
22428 
      for key, value in self.__dict__.iteritems()]
22429 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22430 
 
22431 
  def __eq__(self, other):
22432 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22433 
 
22434 
  def __ne__(self, other):
22435 
    return not (self == other)
22436 
 
22437 
class markOrdersAsNotAvailabke_args:
22438 
  """
22439 
  Attributes:
22440 
   - vendorId
22441 
   - itemId
22442 
   - quantity
22443 
   - estimate
4369 rajveer 22444 
   - isReminder
4303 rajveer 22445 
  """
22446 
 
22447 
  thrift_spec = (
22448 
    None, # 0
22449 
    (1, TType.I64, 'vendorId', None, None, ), # 1
22450 
    (2, TType.I64, 'itemId', None, None, ), # 2
22451 
    (3, TType.I64, 'quantity', None, None, ), # 3
22452 
    (4, TType.I64, 'estimate', None, None, ), # 4
4369 rajveer 22453 
    (5, TType.BOOL, 'isReminder', None, None, ), # 5
4303 rajveer 22454 
  )
22455 
 
4369 rajveer 22456 
  def __init__(self, vendorId=None, itemId=None, quantity=None, estimate=None, isReminder=None,):
4303 rajveer 22457 
    self.vendorId = vendorId
22458 
    self.itemId = itemId
22459 
    self.quantity = quantity
22460 
    self.estimate = estimate
4369 rajveer 22461 
    self.isReminder = isReminder
4303 rajveer 22462 
 
22463 
  def read(self, iprot):
22464 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22465 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22466 
      return
22467 
    iprot.readStructBegin()
22468 
    while True:
22469 
      (fname, ftype, fid) = iprot.readFieldBegin()
22470 
      if ftype == TType.STOP:
22471 
        break
22472 
      if fid == 1:
22473 
        if ftype == TType.I64:
22474 
          self.vendorId = iprot.readI64();
22475 
        else:
22476 
          iprot.skip(ftype)
22477 
      elif fid == 2:
22478 
        if ftype == TType.I64:
22479 
          self.itemId = iprot.readI64();
22480 
        else:
22481 
          iprot.skip(ftype)
22482 
      elif fid == 3:
22483 
        if ftype == TType.I64:
22484 
          self.quantity = iprot.readI64();
22485 
        else:
22486 
          iprot.skip(ftype)
22487 
      elif fid == 4:
22488 
        if ftype == TType.I64:
22489 
          self.estimate = iprot.readI64();
22490 
        else:
22491 
          iprot.skip(ftype)
4369 rajveer 22492 
      elif fid == 5:
22493 
        if ftype == TType.BOOL:
22494 
          self.isReminder = iprot.readBool();
22495 
        else:
22496 
          iprot.skip(ftype)
4303 rajveer 22497 
      else:
22498 
        iprot.skip(ftype)
22499 
      iprot.readFieldEnd()
22500 
    iprot.readStructEnd()
22501 
 
22502 
  def write(self, oprot):
22503 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22504 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22505 
      return
22506 
    oprot.writeStructBegin('markOrdersAsNotAvailabke_args')
22507 
    if self.vendorId is not None:
22508 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
22509 
      oprot.writeI64(self.vendorId)
22510 
      oprot.writeFieldEnd()
22511 
    if self.itemId is not None:
22512 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
22513 
      oprot.writeI64(self.itemId)
22514 
      oprot.writeFieldEnd()
22515 
    if self.quantity is not None:
22516 
      oprot.writeFieldBegin('quantity', TType.I64, 3)
22517 
      oprot.writeI64(self.quantity)
22518 
      oprot.writeFieldEnd()
22519 
    if self.estimate is not None:
22520 
      oprot.writeFieldBegin('estimate', TType.I64, 4)
22521 
      oprot.writeI64(self.estimate)
22522 
      oprot.writeFieldEnd()
4369 rajveer 22523 
    if self.isReminder is not None:
22524 
      oprot.writeFieldBegin('isReminder', TType.BOOL, 5)
22525 
      oprot.writeBool(self.isReminder)
22526 
      oprot.writeFieldEnd()
4303 rajveer 22527 
    oprot.writeFieldStop()
22528 
    oprot.writeStructEnd()
22529 
 
22530 
  def validate(self):
22531 
    return
22532 
 
22533 
 
22534 
  def __repr__(self):
22535 
    L = ['%s=%r' % (key, value)
22536 
      for key, value in self.__dict__.iteritems()]
22537 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22538 
 
22539 
  def __eq__(self, other):
22540 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22541 
 
22542 
  def __ne__(self, other):
22543 
    return not (self == other)
22544 
 
22545 
class markOrdersAsNotAvailabke_result:
22546 
  """
22547 
  Attributes:
22548 
   - ex
22549 
  """
22550 
 
22551 
  thrift_spec = (
22552 
    None, # 0
22553 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
22554 
  )
22555 
 
22556 
  def __init__(self, ex=None,):
22557 
    self.ex = ex
22558 
 
22559 
  def read(self, iprot):
22560 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22561 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22562 
      return
22563 
    iprot.readStructBegin()
22564 
    while True:
22565 
      (fname, ftype, fid) = iprot.readFieldBegin()
22566 
      if ftype == TType.STOP:
22567 
        break
22568 
      if fid == 1:
22569 
        if ftype == TType.STRUCT:
22570 
          self.ex = TransactionServiceException()
22571 
          self.ex.read(iprot)
22572 
        else:
22573 
          iprot.skip(ftype)
22574 
      else:
22575 
        iprot.skip(ftype)
22576 
      iprot.readFieldEnd()
22577 
    iprot.readStructEnd()
22578 
 
22579 
  def write(self, oprot):
22580 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22581 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22582 
      return
22583 
    oprot.writeStructBegin('markOrdersAsNotAvailabke_result')
22584 
    if self.ex is not None:
22585 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
22586 
      self.ex.write(oprot)
22587 
      oprot.writeFieldEnd()
22588 
    oprot.writeFieldStop()
22589 
    oprot.writeStructEnd()
22590 
 
22591 
  def validate(self):
22592 
    return
22593 
 
22594 
 
22595 
  def __repr__(self):
22596 
    L = ['%s=%r' % (key, value)
22597 
      for key, value in self.__dict__.iteritems()]
22598 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22599 
 
22600 
  def __eq__(self, other):
22601 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22602 
 
22603 
  def __ne__(self, other):
22604 
    return not (self == other)
4369 rajveer 22605 
 
22606 
class markOrdersAsTimeout_args:
22607 
  """
22608 
  Attributes:
22609 
   - vendorId
22610 
  """
22611 
 
22612 
  thrift_spec = (
22613 
    None, # 0
22614 
    (1, TType.I64, 'vendorId', None, None, ), # 1
22615 
  )
22616 
 
22617 
  def __init__(self, vendorId=None,):
22618 
    self.vendorId = vendorId
22619 
 
22620 
  def read(self, iprot):
22621 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22622 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22623 
      return
22624 
    iprot.readStructBegin()
22625 
    while True:
22626 
      (fname, ftype, fid) = iprot.readFieldBegin()
22627 
      if ftype == TType.STOP:
22628 
        break
22629 
      if fid == 1:
22630 
        if ftype == TType.I64:
22631 
          self.vendorId = iprot.readI64();
22632 
        else:
22633 
          iprot.skip(ftype)
22634 
      else:
22635 
        iprot.skip(ftype)
22636 
      iprot.readFieldEnd()
22637 
    iprot.readStructEnd()
22638 
 
22639 
  def write(self, oprot):
22640 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22641 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22642 
      return
22643 
    oprot.writeStructBegin('markOrdersAsTimeout_args')
22644 
    if self.vendorId is not None:
22645 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
22646 
      oprot.writeI64(self.vendorId)
22647 
      oprot.writeFieldEnd()
22648 
    oprot.writeFieldStop()
22649 
    oprot.writeStructEnd()
22650 
 
22651 
  def validate(self):
22652 
    return
22653 
 
22654 
 
22655 
  def __repr__(self):
22656 
    L = ['%s=%r' % (key, value)
22657 
      for key, value in self.__dict__.iteritems()]
22658 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22659 
 
22660 
  def __eq__(self, other):
22661 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22662 
 
22663 
  def __ne__(self, other):
22664 
    return not (self == other)
22665 
 
22666 
class markOrdersAsTimeout_result:
22667 
  """
22668 
  Attributes:
22669 
   - success
22670 
   - ex
22671 
  """
22672 
 
22673 
  thrift_spec = (
22674 
    (0, TType.MAP, 'success', (TType.I32,None,TType.STRUCT,(TimeoutSummary, TimeoutSummary.thrift_spec)), None, ), # 0
22675 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
22676 
  )
22677 
 
22678 
  def __init__(self, success=None, ex=None,):
22679 
    self.success = success
22680 
    self.ex = ex
22681 
 
22682 
  def read(self, iprot):
22683 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22684 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22685 
      return
22686 
    iprot.readStructBegin()
22687 
    while True:
22688 
      (fname, ftype, fid) = iprot.readFieldBegin()
22689 
      if ftype == TType.STOP:
22690 
        break
22691 
      if fid == 0:
22692 
        if ftype == TType.MAP:
22693 
          self.success = {}
6188 rajveer 22694 
          (_ktype502, _vtype503, _size501 ) = iprot.readMapBegin()
22695 
          for _i505 in xrange(_size501):
22696 
            _key506 = iprot.readI32();
22697 
            _val507 = TimeoutSummary()
22698 
            _val507.read(iprot)
22699 
            self.success[_key506] = _val507
4369 rajveer 22700 
          iprot.readMapEnd()
22701 
        else:
22702 
          iprot.skip(ftype)
22703 
      elif fid == 1:
22704 
        if ftype == TType.STRUCT:
22705 
          self.ex = TransactionServiceException()
22706 
          self.ex.read(iprot)
22707 
        else:
22708 
          iprot.skip(ftype)
22709 
      else:
22710 
        iprot.skip(ftype)
22711 
      iprot.readFieldEnd()
22712 
    iprot.readStructEnd()
22713 
 
22714 
  def write(self, oprot):
22715 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22716 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22717 
      return
22718 
    oprot.writeStructBegin('markOrdersAsTimeout_result')
22719 
    if self.success is not None:
22720 
      oprot.writeFieldBegin('success', TType.MAP, 0)
22721 
      oprot.writeMapBegin(TType.I32, TType.STRUCT, len(self.success))
6188 rajveer 22722 
      for kiter508,viter509 in self.success.items():
22723 
        oprot.writeI32(kiter508)
22724 
        viter509.write(oprot)
4369 rajveer 22725 
      oprot.writeMapEnd()
22726 
      oprot.writeFieldEnd()
22727 
    if self.ex is not None:
22728 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
22729 
      self.ex.write(oprot)
22730 
      oprot.writeFieldEnd()
22731 
    oprot.writeFieldStop()
22732 
    oprot.writeStructEnd()
22733 
 
22734 
  def validate(self):
22735 
    return
22736 
 
22737 
 
22738 
  def __repr__(self):
22739 
    L = ['%s=%r' % (key, value)
22740 
      for key, value in self.__dict__.iteritems()]
22741 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22742 
 
22743 
  def __eq__(self, other):
22744 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22745 
 
22746 
  def __ne__(self, other):
22747 
    return not (self == other)
4386 anupam.sin 22748 
 
4662 rajveer 22749 
class markOrderAsLostInTransit_args:
22750 
  """
22751 
  Attributes:
22752 
   - orderId
22753 
  """
22754 
 
22755 
  thrift_spec = (
22756 
    None, # 0
22757 
    (1, TType.I64, 'orderId', None, None, ), # 1
22758 
  )
22759 
 
22760 
  def __init__(self, orderId=None,):
22761 
    self.orderId = orderId
22762 
 
22763 
  def read(self, iprot):
22764 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22765 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22766 
      return
22767 
    iprot.readStructBegin()
22768 
    while True:
22769 
      (fname, ftype, fid) = iprot.readFieldBegin()
22770 
      if ftype == TType.STOP:
22771 
        break
22772 
      if fid == 1:
22773 
        if ftype == TType.I64:
22774 
          self.orderId = iprot.readI64();
22775 
        else:
22776 
          iprot.skip(ftype)
22777 
      else:
22778 
        iprot.skip(ftype)
22779 
      iprot.readFieldEnd()
22780 
    iprot.readStructEnd()
22781 
 
22782 
  def write(self, oprot):
22783 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22784 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22785 
      return
22786 
    oprot.writeStructBegin('markOrderAsLostInTransit_args')
22787 
    if self.orderId is not None:
22788 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
22789 
      oprot.writeI64(self.orderId)
22790 
      oprot.writeFieldEnd()
22791 
    oprot.writeFieldStop()
22792 
    oprot.writeStructEnd()
22793 
 
22794 
  def validate(self):
22795 
    return
22796 
 
22797 
 
22798 
  def __repr__(self):
22799 
    L = ['%s=%r' % (key, value)
22800 
      for key, value in self.__dict__.iteritems()]
22801 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22802 
 
22803 
  def __eq__(self, other):
22804 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22805 
 
22806 
  def __ne__(self, other):
22807 
    return not (self == other)
22808 
 
22809 
class markOrderAsLostInTransit_result:
22810 
  """
22811 
  Attributes:
22812 
   - success
22813 
   - ex
22814 
  """
22815 
 
22816 
  thrift_spec = (
22817 
    (0, TType.BOOL, 'success', None, None, ), # 0
22818 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
22819 
  )
22820 
 
22821 
  def __init__(self, success=None, ex=None,):
22822 
    self.success = success
22823 
    self.ex = ex
22824 
 
22825 
  def read(self, iprot):
22826 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22827 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22828 
      return
22829 
    iprot.readStructBegin()
22830 
    while True:
22831 
      (fname, ftype, fid) = iprot.readFieldBegin()
22832 
      if ftype == TType.STOP:
22833 
        break
22834 
      if fid == 0:
22835 
        if ftype == TType.BOOL:
22836 
          self.success = iprot.readBool();
22837 
        else:
22838 
          iprot.skip(ftype)
22839 
      elif fid == 1:
22840 
        if ftype == TType.STRUCT:
22841 
          self.ex = TransactionServiceException()
22842 
          self.ex.read(iprot)
22843 
        else:
22844 
          iprot.skip(ftype)
22845 
      else:
22846 
        iprot.skip(ftype)
22847 
      iprot.readFieldEnd()
22848 
    iprot.readStructEnd()
22849 
 
22850 
  def write(self, oprot):
22851 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22852 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22853 
      return
22854 
    oprot.writeStructBegin('markOrderAsLostInTransit_result')
22855 
    if self.success is not None:
22856 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
22857 
      oprot.writeBool(self.success)
22858 
      oprot.writeFieldEnd()
22859 
    if self.ex is not None:
22860 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
22861 
      self.ex.write(oprot)
22862 
      oprot.writeFieldEnd()
22863 
    oprot.writeFieldStop()
22864 
    oprot.writeStructEnd()
22865 
 
22866 
  def validate(self):
22867 
    return
22868 
 
22869 
 
22870 
  def __repr__(self):
22871 
    L = ['%s=%r' % (key, value)
22872 
      for key, value in self.__dict__.iteritems()]
22873 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22874 
 
22875 
  def __eq__(self, other):
22876 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22877 
 
22878 
  def __ne__(self, other):
22879 
    return not (self == other)
22880 
 
4386 anupam.sin 22881 
class getOrderForAwb_args:
22882 
  """
22883 
  Attributes:
22884 
   - awb
22885 
  """
22886 
 
22887 
  thrift_spec = (
22888 
    None, # 0
22889 
    (1, TType.STRING, 'awb', None, None, ), # 1
22890 
  )
22891 
 
22892 
  def __init__(self, awb=None,):
22893 
    self.awb = awb
22894 
 
22895 
  def read(self, iprot):
22896 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22897 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22898 
      return
22899 
    iprot.readStructBegin()
22900 
    while True:
22901 
      (fname, ftype, fid) = iprot.readFieldBegin()
22902 
      if ftype == TType.STOP:
22903 
        break
22904 
      if fid == 1:
22905 
        if ftype == TType.STRING:
22906 
          self.awb = iprot.readString();
22907 
        else:
22908 
          iprot.skip(ftype)
22909 
      else:
22910 
        iprot.skip(ftype)
22911 
      iprot.readFieldEnd()
22912 
    iprot.readStructEnd()
22913 
 
22914 
  def write(self, oprot):
22915 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22916 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22917 
      return
22918 
    oprot.writeStructBegin('getOrderForAwb_args')
22919 
    if self.awb is not None:
22920 
      oprot.writeFieldBegin('awb', TType.STRING, 1)
22921 
      oprot.writeString(self.awb)
22922 
      oprot.writeFieldEnd()
22923 
    oprot.writeFieldStop()
22924 
    oprot.writeStructEnd()
22925 
 
22926 
  def validate(self):
22927 
    return
22928 
 
22929 
 
22930 
  def __repr__(self):
22931 
    L = ['%s=%r' % (key, value)
22932 
      for key, value in self.__dict__.iteritems()]
22933 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22934 
 
22935 
  def __eq__(self, other):
22936 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22937 
 
22938 
  def __ne__(self, other):
22939 
    return not (self == other)
22940 
 
22941 
class getOrderForAwb_result:
22942 
  """
22943 
  Attributes:
22944 
   - success
22945 
   - ex
22946 
  """
22947 
 
22948 
  thrift_spec = (
22949 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
22950 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
22951 
  )
22952 
 
22953 
  def __init__(self, success=None, ex=None,):
22954 
    self.success = success
22955 
    self.ex = ex
22956 
 
22957 
  def read(self, iprot):
22958 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22959 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22960 
      return
22961 
    iprot.readStructBegin()
22962 
    while True:
22963 
      (fname, ftype, fid) = iprot.readFieldBegin()
22964 
      if ftype == TType.STOP:
22965 
        break
22966 
      if fid == 0:
22967 
        if ftype == TType.STRUCT:
22968 
          self.success = Order()
22969 
          self.success.read(iprot)
22970 
        else:
22971 
          iprot.skip(ftype)
22972 
      elif fid == 1:
22973 
        if ftype == TType.STRUCT:
22974 
          self.ex = TransactionServiceException()
22975 
          self.ex.read(iprot)
22976 
        else:
22977 
          iprot.skip(ftype)
22978 
      else:
22979 
        iprot.skip(ftype)
22980 
      iprot.readFieldEnd()
22981 
    iprot.readStructEnd()
22982 
 
22983 
  def write(self, oprot):
22984 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22985 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22986 
      return
22987 
    oprot.writeStructBegin('getOrderForAwb_result')
22988 
    if self.success is not None:
22989 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
22990 
      self.success.write(oprot)
22991 
      oprot.writeFieldEnd()
22992 
    if self.ex is not None:
22993 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
22994 
      self.ex.write(oprot)
22995 
      oprot.writeFieldEnd()
22996 
    oprot.writeFieldStop()
22997 
    oprot.writeStructEnd()
22998 
 
22999 
  def validate(self):
23000 
    return
23001 
 
23002 
 
23003 
  def __repr__(self):
23004 
    L = ['%s=%r' % (key, value)
23005 
      for key, value in self.__dict__.iteritems()]
23006 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23007 
 
23008 
  def __eq__(self, other):
23009 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23010 
 
23011 
  def __ne__(self, other):
23012 
    return not (self == other)
4506 phani.kuma 23013 
 
23014 
class getOrdersForProviderForStatus_args:
23015 
  """
23016 
  Attributes:
23017 
   - logistics_provider_id
4910 phani.kuma 23018 
   - order_status_list
4506 phani.kuma 23019 
  """
23020 
 
23021 
  thrift_spec = (
23022 
    None, # 0
23023 
    (1, TType.I64, 'logistics_provider_id', None, None, ), # 1
4910 phani.kuma 23024 
    (2, TType.LIST, 'order_status_list', (TType.I32,None), None, ), # 2
4506 phani.kuma 23025 
  )
23026 
 
4910 phani.kuma 23027 
  def __init__(self, logistics_provider_id=None, order_status_list=None,):
4506 phani.kuma 23028 
    self.logistics_provider_id = logistics_provider_id
4910 phani.kuma 23029 
    self.order_status_list = order_status_list
4506 phani.kuma 23030 
 
23031 
  def read(self, iprot):
23032 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23033 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23034 
      return
23035 
    iprot.readStructBegin()
23036 
    while True:
23037 
      (fname, ftype, fid) = iprot.readFieldBegin()
23038 
      if ftype == TType.STOP:
23039 
        break
23040 
      if fid == 1:
23041 
        if ftype == TType.I64:
23042 
          self.logistics_provider_id = iprot.readI64();
23043 
        else:
23044 
          iprot.skip(ftype)
23045 
      elif fid == 2:
4910 phani.kuma 23046 
        if ftype == TType.LIST:
23047 
          self.order_status_list = []
6188 rajveer 23048 
          (_etype513, _size510) = iprot.readListBegin()
23049 
          for _i514 in xrange(_size510):
23050 
            _elem515 = iprot.readI32();
23051 
            self.order_status_list.append(_elem515)
4910 phani.kuma 23052 
          iprot.readListEnd()
4506 phani.kuma 23053 
        else:
23054 
          iprot.skip(ftype)
23055 
      else:
23056 
        iprot.skip(ftype)
23057 
      iprot.readFieldEnd()
23058 
    iprot.readStructEnd()
23059 
 
23060 
  def write(self, oprot):
23061 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23062 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23063 
      return
23064 
    oprot.writeStructBegin('getOrdersForProviderForStatus_args')
23065 
    if self.logistics_provider_id is not None:
23066 
      oprot.writeFieldBegin('logistics_provider_id', TType.I64, 1)
23067 
      oprot.writeI64(self.logistics_provider_id)
23068 
      oprot.writeFieldEnd()
4910 phani.kuma 23069 
    if self.order_status_list is not None:
23070 
      oprot.writeFieldBegin('order_status_list', TType.LIST, 2)
23071 
      oprot.writeListBegin(TType.I32, len(self.order_status_list))
6188 rajveer 23072 
      for iter516 in self.order_status_list:
23073 
        oprot.writeI32(iter516)
4910 phani.kuma 23074 
      oprot.writeListEnd()
4506 phani.kuma 23075 
      oprot.writeFieldEnd()
23076 
    oprot.writeFieldStop()
23077 
    oprot.writeStructEnd()
23078 
 
23079 
  def validate(self):
23080 
    return
23081 
 
23082 
 
23083 
  def __repr__(self):
23084 
    L = ['%s=%r' % (key, value)
23085 
      for key, value in self.__dict__.iteritems()]
23086 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23087 
 
23088 
  def __eq__(self, other):
23089 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23090 
 
23091 
  def __ne__(self, other):
23092 
    return not (self == other)
23093 
 
23094 
class getOrdersForProviderForStatus_result:
23095 
  """
23096 
  Attributes:
23097 
   - success
23098 
   - ex
23099 
  """
23100 
 
23101 
  thrift_spec = (
23102 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
23103 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
23104 
  )
23105 
 
23106 
  def __init__(self, success=None, ex=None,):
23107 
    self.success = success
23108 
    self.ex = ex
23109 
 
23110 
  def read(self, iprot):
23111 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23112 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23113 
      return
23114 
    iprot.readStructBegin()
23115 
    while True:
23116 
      (fname, ftype, fid) = iprot.readFieldBegin()
23117 
      if ftype == TType.STOP:
23118 
        break
23119 
      if fid == 0:
23120 
        if ftype == TType.LIST:
23121 
          self.success = []
6188 rajveer 23122 
          (_etype520, _size517) = iprot.readListBegin()
23123 
          for _i521 in xrange(_size517):
23124 
            _elem522 = Order()
23125 
            _elem522.read(iprot)
23126 
            self.success.append(_elem522)
4506 phani.kuma 23127 
          iprot.readListEnd()
23128 
        else:
23129 
          iprot.skip(ftype)
23130 
      elif fid == 1:
23131 
        if ftype == TType.STRUCT:
23132 
          self.ex = TransactionServiceException()
23133 
          self.ex.read(iprot)
23134 
        else:
23135 
          iprot.skip(ftype)
23136 
      else:
23137 
        iprot.skip(ftype)
23138 
      iprot.readFieldEnd()
23139 
    iprot.readStructEnd()
23140 
 
23141 
  def write(self, oprot):
23142 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23143 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23144 
      return
23145 
    oprot.writeStructBegin('getOrdersForProviderForStatus_result')
23146 
    if self.success is not None:
23147 
      oprot.writeFieldBegin('success', TType.LIST, 0)
23148 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 23149 
      for iter523 in self.success:
23150 
        iter523.write(oprot)
4506 phani.kuma 23151 
      oprot.writeListEnd()
23152 
      oprot.writeFieldEnd()
23153 
    if self.ex is not None:
23154 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
23155 
      self.ex.write(oprot)
23156 
      oprot.writeFieldEnd()
23157 
    oprot.writeFieldStop()
23158 
    oprot.writeStructEnd()
23159 
 
23160 
  def validate(self):
23161 
    return
23162 
 
23163 
 
23164 
  def __repr__(self):
23165 
    L = ['%s=%r' % (key, value)
23166 
      for key, value in self.__dict__.iteritems()]
23167 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23168 
 
23169 
  def __eq__(self, other):
23170 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23171 
 
23172 
  def __ne__(self, other):
23173 
    return not (self == other)
4600 varun.gupt 23174 
 
23175 
class getBilledOrdersForVendor_args:
23176 
  """
23177 
  Attributes:
23178 
   - vendorId
23179 
   - billingDateFrom
23180 
   - billingDateTo
23181 
  """
23182 
 
23183 
  thrift_spec = (
23184 
    None, # 0
23185 
    (1, TType.I64, 'vendorId', None, None, ), # 1
23186 
    (2, TType.I64, 'billingDateFrom', None, None, ), # 2
23187 
    (3, TType.I64, 'billingDateTo', None, None, ), # 3
23188 
  )
23189 
 
23190 
  def __init__(self, vendorId=None, billingDateFrom=None, billingDateTo=None,):
23191 
    self.vendorId = vendorId
23192 
    self.billingDateFrom = billingDateFrom
23193 
    self.billingDateTo = billingDateTo
23194 
 
23195 
  def read(self, iprot):
23196 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23197 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23198 
      return
23199 
    iprot.readStructBegin()
23200 
    while True:
23201 
      (fname, ftype, fid) = iprot.readFieldBegin()
23202 
      if ftype == TType.STOP:
23203 
        break
23204 
      if fid == 1:
23205 
        if ftype == TType.I64:
23206 
          self.vendorId = iprot.readI64();
23207 
        else:
23208 
          iprot.skip(ftype)
23209 
      elif fid == 2:
23210 
        if ftype == TType.I64:
23211 
          self.billingDateFrom = iprot.readI64();
23212 
        else:
23213 
          iprot.skip(ftype)
23214 
      elif fid == 3:
23215 
        if ftype == TType.I64:
23216 
          self.billingDateTo = iprot.readI64();
23217 
        else:
23218 
          iprot.skip(ftype)
23219 
      else:
23220 
        iprot.skip(ftype)
23221 
      iprot.readFieldEnd()
23222 
    iprot.readStructEnd()
23223 
 
23224 
  def write(self, oprot):
23225 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23226 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23227 
      return
23228 
    oprot.writeStructBegin('getBilledOrdersForVendor_args')
23229 
    if self.vendorId is not None:
23230 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
23231 
      oprot.writeI64(self.vendorId)
23232 
      oprot.writeFieldEnd()
23233 
    if self.billingDateFrom is not None:
23234 
      oprot.writeFieldBegin('billingDateFrom', TType.I64, 2)
23235 
      oprot.writeI64(self.billingDateFrom)
23236 
      oprot.writeFieldEnd()
23237 
    if self.billingDateTo is not None:
23238 
      oprot.writeFieldBegin('billingDateTo', TType.I64, 3)
23239 
      oprot.writeI64(self.billingDateTo)
23240 
      oprot.writeFieldEnd()
23241 
    oprot.writeFieldStop()
23242 
    oprot.writeStructEnd()
23243 
 
23244 
  def validate(self):
23245 
    return
23246 
 
23247 
 
23248 
  def __repr__(self):
23249 
    L = ['%s=%r' % (key, value)
23250 
      for key, value in self.__dict__.iteritems()]
23251 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23252 
 
23253 
  def __eq__(self, other):
23254 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23255 
 
23256 
  def __ne__(self, other):
23257 
    return not (self == other)
23258 
 
23259 
class getBilledOrdersForVendor_result:
23260 
  """
23261 
  Attributes:
23262 
   - success
23263 
   - ex
23264 
  """
23265 
 
23266 
  thrift_spec = (
23267 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
23268 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
23269 
  )
23270 
 
23271 
  def __init__(self, success=None, ex=None,):
23272 
    self.success = success
23273 
    self.ex = ex
23274 
 
23275 
  def read(self, iprot):
23276 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23277 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23278 
      return
23279 
    iprot.readStructBegin()
23280 
    while True:
23281 
      (fname, ftype, fid) = iprot.readFieldBegin()
23282 
      if ftype == TType.STOP:
23283 
        break
23284 
      if fid == 0:
23285 
        if ftype == TType.LIST:
23286 
          self.success = []
6188 rajveer 23287 
          (_etype527, _size524) = iprot.readListBegin()
23288 
          for _i528 in xrange(_size524):
23289 
            _elem529 = Order()
23290 
            _elem529.read(iprot)
23291 
            self.success.append(_elem529)
4600 varun.gupt 23292 
          iprot.readListEnd()
23293 
        else:
23294 
          iprot.skip(ftype)
23295 
      elif fid == 1:
23296 
        if ftype == TType.STRUCT:
23297 
          self.ex = TransactionServiceException()
23298 
          self.ex.read(iprot)
23299 
        else:
23300 
          iprot.skip(ftype)
23301 
      else:
23302 
        iprot.skip(ftype)
23303 
      iprot.readFieldEnd()
23304 
    iprot.readStructEnd()
23305 
 
23306 
  def write(self, oprot):
23307 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23308 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23309 
      return
23310 
    oprot.writeStructBegin('getBilledOrdersForVendor_result')
23311 
    if self.success is not None:
23312 
      oprot.writeFieldBegin('success', TType.LIST, 0)
23313 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 23314 
      for iter530 in self.success:
23315 
        iter530.write(oprot)
4600 varun.gupt 23316 
      oprot.writeListEnd()
23317 
      oprot.writeFieldEnd()
23318 
    if self.ex is not None:
23319 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
23320 
      self.ex.write(oprot)
23321 
      oprot.writeFieldEnd()
23322 
    oprot.writeFieldStop()
23323 
    oprot.writeStructEnd()
23324 
 
23325 
  def validate(self):
23326 
    return
23327 
 
23328 
 
23329 
  def __repr__(self):
23330 
    L = ['%s=%r' % (key, value)
23331 
      for key, value in self.__dict__.iteritems()]
23332 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23333 
 
23334 
  def __eq__(self, other):
23335 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23336 
 
23337 
  def __ne__(self, other):
23338 
    return not (self == other)
23339 
 
4607 rajveer 23340 
class getSlippedSippingDateOrders_args:
23341 
 
23342 
  thrift_spec = (
23343 
  )
23344 
 
23345 
  def read(self, iprot):
23346 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23347 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23348 
      return
23349 
    iprot.readStructBegin()
23350 
    while True:
23351 
      (fname, ftype, fid) = iprot.readFieldBegin()
23352 
      if ftype == TType.STOP:
23353 
        break
23354 
      else:
23355 
        iprot.skip(ftype)
23356 
      iprot.readFieldEnd()
23357 
    iprot.readStructEnd()
23358 
 
23359 
  def write(self, oprot):
23360 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23361 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23362 
      return
23363 
    oprot.writeStructBegin('getSlippedSippingDateOrders_args')
23364 
    oprot.writeFieldStop()
23365 
    oprot.writeStructEnd()
23366 
 
23367 
  def validate(self):
23368 
    return
23369 
 
23370 
 
23371 
  def __repr__(self):
23372 
    L = ['%s=%r' % (key, value)
23373 
      for key, value in self.__dict__.iteritems()]
23374 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23375 
 
23376 
  def __eq__(self, other):
23377 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23378 
 
23379 
  def __ne__(self, other):
23380 
    return not (self == other)
23381 
 
23382 
class getSlippedSippingDateOrders_result:
23383 
  """
23384 
  Attributes:
23385 
   - success
23386 
   - ex
23387 
  """
23388 
 
23389 
  thrift_spec = (
23390 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
23391 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
23392 
  )
23393 
 
23394 
  def __init__(self, success=None, ex=None,):
23395 
    self.success = success
23396 
    self.ex = ex
23397 
 
23398 
  def read(self, iprot):
23399 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23400 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23401 
      return
23402 
    iprot.readStructBegin()
23403 
    while True:
23404 
      (fname, ftype, fid) = iprot.readFieldBegin()
23405 
      if ftype == TType.STOP:
23406 
        break
23407 
      if fid == 0:
23408 
        if ftype == TType.LIST:
23409 
          self.success = []
6188 rajveer 23410 
          (_etype534, _size531) = iprot.readListBegin()
23411 
          for _i535 in xrange(_size531):
23412 
            _elem536 = Order()
23413 
            _elem536.read(iprot)
23414 
            self.success.append(_elem536)
4607 rajveer 23415 
          iprot.readListEnd()
23416 
        else:
23417 
          iprot.skip(ftype)
23418 
      elif fid == 1:
23419 
        if ftype == TType.STRUCT:
23420 
          self.ex = TransactionServiceException()
23421 
          self.ex.read(iprot)
23422 
        else:
23423 
          iprot.skip(ftype)
23424 
      else:
23425 
        iprot.skip(ftype)
23426 
      iprot.readFieldEnd()
23427 
    iprot.readStructEnd()
23428 
 
23429 
  def write(self, oprot):
23430 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23431 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23432 
      return
23433 
    oprot.writeStructBegin('getSlippedSippingDateOrders_result')
23434 
    if self.success is not None:
23435 
      oprot.writeFieldBegin('success', TType.LIST, 0)
23436 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 23437 
      for iter537 in self.success:
23438 
        iter537.write(oprot)
4607 rajveer 23439 
      oprot.writeListEnd()
23440 
      oprot.writeFieldEnd()
23441 
    if self.ex is not None:
23442 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
23443 
      self.ex.write(oprot)
23444 
      oprot.writeFieldEnd()
23445 
    oprot.writeFieldStop()
23446 
    oprot.writeStructEnd()
23447 
 
23448 
  def validate(self):
23449 
    return
23450 
 
23451 
 
23452 
  def __repr__(self):
23453 
    L = ['%s=%r' % (key, value)
23454 
      for key, value in self.__dict__.iteritems()]
23455 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23456 
 
23457 
  def __eq__(self, other):
23458 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23459 
 
23460 
  def __ne__(self, other):
23461 
    return not (self == other)
23462 
 
4709 rajveer 23463 
class getCancelledOrders_args:
23464 
  """
23465 
  Attributes:
23466 
   - cancelDateFrom
23467 
   - cancelDateTo
23468 
  """
23469 
 
23470 
  thrift_spec = (
23471 
    None, # 0
23472 
    (1, TType.I64, 'cancelDateFrom', None, None, ), # 1
23473 
    (2, TType.I64, 'cancelDateTo', None, None, ), # 2
23474 
  )
23475 
 
23476 
  def __init__(self, cancelDateFrom=None, cancelDateTo=None,):
23477 
    self.cancelDateFrom = cancelDateFrom
23478 
    self.cancelDateTo = cancelDateTo
23479 
 
23480 
  def read(self, iprot):
23481 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23482 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23483 
      return
23484 
    iprot.readStructBegin()
23485 
    while True:
23486 
      (fname, ftype, fid) = iprot.readFieldBegin()
23487 
      if ftype == TType.STOP:
23488 
        break
23489 
      if fid == 1:
23490 
        if ftype == TType.I64:
23491 
          self.cancelDateFrom = iprot.readI64();
23492 
        else:
23493 
          iprot.skip(ftype)
23494 
      elif fid == 2:
23495 
        if ftype == TType.I64:
23496 
          self.cancelDateTo = iprot.readI64();
23497 
        else:
23498 
          iprot.skip(ftype)
23499 
      else:
23500 
        iprot.skip(ftype)
23501 
      iprot.readFieldEnd()
23502 
    iprot.readStructEnd()
23503 
 
23504 
  def write(self, oprot):
23505 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23506 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23507 
      return
23508 
    oprot.writeStructBegin('getCancelledOrders_args')
23509 
    if self.cancelDateFrom is not None:
23510 
      oprot.writeFieldBegin('cancelDateFrom', TType.I64, 1)
23511 
      oprot.writeI64(self.cancelDateFrom)
23512 
      oprot.writeFieldEnd()
23513 
    if self.cancelDateTo is not None:
23514 
      oprot.writeFieldBegin('cancelDateTo', TType.I64, 2)
23515 
      oprot.writeI64(self.cancelDateTo)
23516 
      oprot.writeFieldEnd()
23517 
    oprot.writeFieldStop()
23518 
    oprot.writeStructEnd()
23519 
 
23520 
  def validate(self):
23521 
    return
23522 
 
23523 
 
23524 
  def __repr__(self):
23525 
    L = ['%s=%r' % (key, value)
23526 
      for key, value in self.__dict__.iteritems()]
23527 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23528 
 
23529 
  def __eq__(self, other):
23530 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23531 
 
23532 
  def __ne__(self, other):
23533 
    return not (self == other)
23534 
 
23535 
class getCancelledOrders_result:
23536 
  """
23537 
  Attributes:
23538 
   - success
23539 
   - ex
23540 
  """
23541 
 
23542 
  thrift_spec = (
23543 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
23544 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
23545 
  )
23546 
 
23547 
  def __init__(self, success=None, ex=None,):
23548 
    self.success = success
23549 
    self.ex = ex
23550 
 
23551 
  def read(self, iprot):
23552 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23553 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23554 
      return
23555 
    iprot.readStructBegin()
23556 
    while True:
23557 
      (fname, ftype, fid) = iprot.readFieldBegin()
23558 
      if ftype == TType.STOP:
23559 
        break
23560 
      if fid == 0:
23561 
        if ftype == TType.LIST:
23562 
          self.success = []
6188 rajveer 23563 
          (_etype541, _size538) = iprot.readListBegin()
23564 
          for _i542 in xrange(_size538):
23565 
            _elem543 = Order()
23566 
            _elem543.read(iprot)
23567 
            self.success.append(_elem543)
4709 rajveer 23568 
          iprot.readListEnd()
23569 
        else:
23570 
          iprot.skip(ftype)
23571 
      elif fid == 1:
23572 
        if ftype == TType.STRUCT:
23573 
          self.ex = TransactionServiceException()
23574 
          self.ex.read(iprot)
23575 
        else:
23576 
          iprot.skip(ftype)
23577 
      else:
23578 
        iprot.skip(ftype)
23579 
      iprot.readFieldEnd()
23580 
    iprot.readStructEnd()
23581 
 
23582 
  def write(self, oprot):
23583 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23584 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23585 
      return
23586 
    oprot.writeStructBegin('getCancelledOrders_result')
23587 
    if self.success is not None:
23588 
      oprot.writeFieldBegin('success', TType.LIST, 0)
23589 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 23590 
      for iter544 in self.success:
23591 
        iter544.write(oprot)
4709 rajveer 23592 
      oprot.writeListEnd()
23593 
      oprot.writeFieldEnd()
23594 
    if self.ex is not None:
23595 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
23596 
      self.ex.write(oprot)
23597 
      oprot.writeFieldEnd()
23598 
    oprot.writeFieldStop()
23599 
    oprot.writeStructEnd()
23600 
 
23601 
  def validate(self):
23602 
    return
23603 
 
23604 
 
23605 
  def __repr__(self):
23606 
    L = ['%s=%r' % (key, value)
23607 
      for key, value in self.__dict__.iteritems()]
23608 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23609 
 
23610 
  def __eq__(self, other):
23611 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23612 
 
23613 
  def __ne__(self, other):
23614 
    return not (self == other)
23615 
 
4600 varun.gupt 23616 
class saveBluedartSettlements_args:
23617 
  """
23618 
  Attributes:
23619 
   - mapAWBAndAmount
23620 
  """
23621 
 
23622 
  thrift_spec = (
23623 
    None, # 0
23624 
    (1, TType.MAP, 'mapAWBAndAmount', (TType.I64,None,TType.DOUBLE,None), None, ), # 1
23625 
  )
23626 
 
23627 
  def __init__(self, mapAWBAndAmount=None,):
23628 
    self.mapAWBAndAmount = mapAWBAndAmount
23629 
 
23630 
  def read(self, iprot):
23631 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23632 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23633 
      return
23634 
    iprot.readStructBegin()
23635 
    while True:
23636 
      (fname, ftype, fid) = iprot.readFieldBegin()
23637 
      if ftype == TType.STOP:
23638 
        break
23639 
      if fid == 1:
23640 
        if ftype == TType.MAP:
23641 
          self.mapAWBAndAmount = {}
6188 rajveer 23642 
          (_ktype546, _vtype547, _size545 ) = iprot.readMapBegin()
23643 
          for _i549 in xrange(_size545):
23644 
            _key550 = iprot.readI64();
23645 
            _val551 = iprot.readDouble();
23646 
            self.mapAWBAndAmount[_key550] = _val551
4600 varun.gupt 23647 
          iprot.readMapEnd()
23648 
        else:
23649 
          iprot.skip(ftype)
23650 
      else:
23651 
        iprot.skip(ftype)
23652 
      iprot.readFieldEnd()
23653 
    iprot.readStructEnd()
23654 
 
23655 
  def write(self, oprot):
23656 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23657 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23658 
      return
23659 
    oprot.writeStructBegin('saveBluedartSettlements_args')
23660 
    if self.mapAWBAndAmount is not None:
23661 
      oprot.writeFieldBegin('mapAWBAndAmount', TType.MAP, 1)
23662 
      oprot.writeMapBegin(TType.I64, TType.DOUBLE, len(self.mapAWBAndAmount))
6188 rajveer 23663 
      for kiter552,viter553 in self.mapAWBAndAmount.items():
23664 
        oprot.writeI64(kiter552)
23665 
        oprot.writeDouble(viter553)
4600 varun.gupt 23666 
      oprot.writeMapEnd()
23667 
      oprot.writeFieldEnd()
23668 
    oprot.writeFieldStop()
23669 
    oprot.writeStructEnd()
23670 
 
23671 
  def validate(self):
23672 
    return
23673 
 
23674 
 
23675 
  def __repr__(self):
23676 
    L = ['%s=%r' % (key, value)
23677 
      for key, value in self.__dict__.iteritems()]
23678 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23679 
 
23680 
  def __eq__(self, other):
23681 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23682 
 
23683 
  def __ne__(self, other):
23684 
    return not (self == other)
23685 
 
23686 
class saveBluedartSettlements_result:
23687 
  """
23688 
  Attributes:
23689 
   - ex
23690 
  """
23691 
 
23692 
  thrift_spec = (
23693 
    None, # 0
23694 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
23695 
  )
23696 
 
23697 
  def __init__(self, ex=None,):
23698 
    self.ex = ex
23699 
 
23700 
  def read(self, iprot):
23701 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23702 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23703 
      return
23704 
    iprot.readStructBegin()
23705 
    while True:
23706 
      (fname, ftype, fid) = iprot.readFieldBegin()
23707 
      if ftype == TType.STOP:
23708 
        break
23709 
      if fid == 1:
23710 
        if ftype == TType.STRUCT:
23711 
          self.ex = TransactionServiceException()
23712 
          self.ex.read(iprot)
23713 
        else:
23714 
          iprot.skip(ftype)
23715 
      else:
23716 
        iprot.skip(ftype)
23717 
      iprot.readFieldEnd()
23718 
    iprot.readStructEnd()
23719 
 
23720 
  def write(self, oprot):
23721 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23722 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23723 
      return
23724 
    oprot.writeStructBegin('saveBluedartSettlements_result')
23725 
    if self.ex is not None:
23726 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
23727 
      self.ex.write(oprot)
23728 
      oprot.writeFieldEnd()
23729 
    oprot.writeFieldStop()
23730 
    oprot.writeStructEnd()
23731 
 
23732 
  def validate(self):
23733 
    return
23734 
 
23735 
 
23736 
  def __repr__(self):
23737 
    L = ['%s=%r' % (key, value)
23738 
      for key, value in self.__dict__.iteritems()]
23739 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23740 
 
23741 
  def __eq__(self, other):
23742 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23743 
 
23744 
  def __ne__(self, other):
23745 
    return not (self == other)
23746 
 
23747 
class savePaymentSettlements_args:
23748 
  """
23749 
  Attributes:
23750 
   - settlementDate
23751 
   - paymentGatewayId
4905 varun.gupt 23752 
   - referenceId
4600 varun.gupt 23753 
   - serviceTax
23754 
   - otherCharges
23755 
   - netCollection
23756 
  """
23757 
 
23758 
  thrift_spec = (
23759 
    None, # 0
23760 
    (1, TType.I64, 'settlementDate', None, None, ), # 1
23761 
    (2, TType.I64, 'paymentGatewayId', None, None, ), # 2
4905 varun.gupt 23762 
    (3, TType.I64, 'referenceId', None, None, ), # 3
4600 varun.gupt 23763 
    (4, TType.DOUBLE, 'serviceTax', None, None, ), # 4
23764 
    (5, TType.DOUBLE, 'otherCharges', None, None, ), # 5
23765 
    (6, TType.DOUBLE, 'netCollection', None, None, ), # 6
23766 
  )
23767 
 
4905 varun.gupt 23768 
  def __init__(self, settlementDate=None, paymentGatewayId=None, referenceId=None, serviceTax=None, otherCharges=None, netCollection=None,):
4600 varun.gupt 23769 
    self.settlementDate = settlementDate
23770 
    self.paymentGatewayId = paymentGatewayId
4905 varun.gupt 23771 
    self.referenceId = referenceId
4600 varun.gupt 23772 
    self.serviceTax = serviceTax
23773 
    self.otherCharges = otherCharges
23774 
    self.netCollection = netCollection
23775 
 
23776 
  def read(self, iprot):
23777 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23778 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23779 
      return
23780 
    iprot.readStructBegin()
23781 
    while True:
23782 
      (fname, ftype, fid) = iprot.readFieldBegin()
23783 
      if ftype == TType.STOP:
23784 
        break
23785 
      if fid == 1:
23786 
        if ftype == TType.I64:
23787 
          self.settlementDate = iprot.readI64();
23788 
        else:
23789 
          iprot.skip(ftype)
23790 
      elif fid == 2:
23791 
        if ftype == TType.I64:
23792 
          self.paymentGatewayId = iprot.readI64();
23793 
        else:
23794 
          iprot.skip(ftype)
23795 
      elif fid == 3:
23796 
        if ftype == TType.I64:
4905 varun.gupt 23797 
          self.referenceId = iprot.readI64();
4600 varun.gupt 23798 
        else:
23799 
          iprot.skip(ftype)
23800 
      elif fid == 4:
23801 
        if ftype == TType.DOUBLE:
23802 
          self.serviceTax = iprot.readDouble();
23803 
        else:
23804 
          iprot.skip(ftype)
23805 
      elif fid == 5:
23806 
        if ftype == TType.DOUBLE:
23807 
          self.otherCharges = iprot.readDouble();
23808 
        else:
23809 
          iprot.skip(ftype)
23810 
      elif fid == 6:
23811 
        if ftype == TType.DOUBLE:
23812 
          self.netCollection = iprot.readDouble();
23813 
        else:
23814 
          iprot.skip(ftype)
23815 
      else:
23816 
        iprot.skip(ftype)
23817 
      iprot.readFieldEnd()
23818 
    iprot.readStructEnd()
23819 
 
23820 
  def write(self, oprot):
23821 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23822 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23823 
      return
23824 
    oprot.writeStructBegin('savePaymentSettlements_args')
23825 
    if self.settlementDate is not None:
23826 
      oprot.writeFieldBegin('settlementDate', TType.I64, 1)
23827 
      oprot.writeI64(self.settlementDate)
23828 
      oprot.writeFieldEnd()
23829 
    if self.paymentGatewayId is not None:
23830 
      oprot.writeFieldBegin('paymentGatewayId', TType.I64, 2)
23831 
      oprot.writeI64(self.paymentGatewayId)
23832 
      oprot.writeFieldEnd()
4905 varun.gupt 23833 
    if self.referenceId is not None:
23834 
      oprot.writeFieldBegin('referenceId', TType.I64, 3)
23835 
      oprot.writeI64(self.referenceId)
4600 varun.gupt 23836 
      oprot.writeFieldEnd()
23837 
    if self.serviceTax is not None:
23838 
      oprot.writeFieldBegin('serviceTax', TType.DOUBLE, 4)
23839 
      oprot.writeDouble(self.serviceTax)
23840 
      oprot.writeFieldEnd()
23841 
    if self.otherCharges is not None:
23842 
      oprot.writeFieldBegin('otherCharges', TType.DOUBLE, 5)
23843 
      oprot.writeDouble(self.otherCharges)
23844 
      oprot.writeFieldEnd()
23845 
    if self.netCollection is not None:
23846 
      oprot.writeFieldBegin('netCollection', TType.DOUBLE, 6)
23847 
      oprot.writeDouble(self.netCollection)
23848 
      oprot.writeFieldEnd()
23849 
    oprot.writeFieldStop()
23850 
    oprot.writeStructEnd()
23851 
 
23852 
  def validate(self):
23853 
    return
23854 
 
23855 
 
23856 
  def __repr__(self):
23857 
    L = ['%s=%r' % (key, value)
23858 
      for key, value in self.__dict__.iteritems()]
23859 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23860 
 
23861 
  def __eq__(self, other):
23862 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23863 
 
23864 
  def __ne__(self, other):
23865 
    return not (self == other)
23866 
 
23867 
class savePaymentSettlements_result:
23868 
  """
23869 
  Attributes:
23870 
   - ex
23871 
  """
23872 
 
23873 
  thrift_spec = (
23874 
    None, # 0
23875 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
23876 
  )
23877 
 
23878 
  def __init__(self, ex=None,):
23879 
    self.ex = ex
23880 
 
23881 
  def read(self, iprot):
23882 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23883 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23884 
      return
23885 
    iprot.readStructBegin()
23886 
    while True:
23887 
      (fname, ftype, fid) = iprot.readFieldBegin()
23888 
      if ftype == TType.STOP:
23889 
        break
23890 
      if fid == 1:
23891 
        if ftype == TType.STRUCT:
23892 
          self.ex = TransactionServiceException()
23893 
          self.ex.read(iprot)
23894 
        else:
23895 
          iprot.skip(ftype)
23896 
      else:
23897 
        iprot.skip(ftype)
23898 
      iprot.readFieldEnd()
23899 
    iprot.readStructEnd()
23900 
 
23901 
  def write(self, oprot):
23902 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23903 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23904 
      return
23905 
    oprot.writeStructBegin('savePaymentSettlements_result')
23906 
    if self.ex is not None:
23907 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
23908 
      self.ex.write(oprot)
23909 
      oprot.writeFieldEnd()
23910 
    oprot.writeFieldStop()
23911 
    oprot.writeStructEnd()
23912 
 
23913 
  def validate(self):
23914 
    return
23915 
 
23916 
 
23917 
  def __repr__(self):
23918 
    L = ['%s=%r' % (key, value)
23919 
      for key, value in self.__dict__.iteritems()]
23920 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23921 
 
23922 
  def __eq__(self, other):
23923 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23924 
 
23925 
  def __ne__(self, other):
23926 
    return not (self == other)
23927 
 
23928 
class saveEBSSettlementSummary_args:
23929 
  """
23930 
  Attributes:
23931 
   - settlementId
23932 
   - settlementDate
23933 
   - transactionDateFrom
23934 
   - transactionDateTo
23935 
   - amount
23936 
  """
23937 
 
23938 
  thrift_spec = (
23939 
    None, # 0
23940 
    (1, TType.I64, 'settlementId', None, None, ), # 1
23941 
    (2, TType.I64, 'settlementDate', None, None, ), # 2
23942 
    (3, TType.I64, 'transactionDateFrom', None, None, ), # 3
23943 
    (4, TType.I64, 'transactionDateTo', None, None, ), # 4
23944 
    (5, TType.DOUBLE, 'amount', None, None, ), # 5
23945 
  )
23946 
 
23947 
  def __init__(self, settlementId=None, settlementDate=None, transactionDateFrom=None, transactionDateTo=None, amount=None,):
23948 
    self.settlementId = settlementId
23949 
    self.settlementDate = settlementDate
23950 
    self.transactionDateFrom = transactionDateFrom
23951 
    self.transactionDateTo = transactionDateTo
23952 
    self.amount = amount
23953 
 
23954 
  def read(self, iprot):
23955 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23956 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23957 
      return
23958 
    iprot.readStructBegin()
23959 
    while True:
23960 
      (fname, ftype, fid) = iprot.readFieldBegin()
23961 
      if ftype == TType.STOP:
23962 
        break
23963 
      if fid == 1:
23964 
        if ftype == TType.I64:
23965 
          self.settlementId = iprot.readI64();
23966 
        else:
23967 
          iprot.skip(ftype)
23968 
      elif fid == 2:
23969 
        if ftype == TType.I64:
23970 
          self.settlementDate = iprot.readI64();
23971 
        else:
23972 
          iprot.skip(ftype)
23973 
      elif fid == 3:
23974 
        if ftype == TType.I64:
23975 
          self.transactionDateFrom = iprot.readI64();
23976 
        else:
23977 
          iprot.skip(ftype)
23978 
      elif fid == 4:
23979 
        if ftype == TType.I64:
23980 
          self.transactionDateTo = iprot.readI64();
23981 
        else:
23982 
          iprot.skip(ftype)
23983 
      elif fid == 5:
23984 
        if ftype == TType.DOUBLE:
23985 
          self.amount = iprot.readDouble();
23986 
        else:
23987 
          iprot.skip(ftype)
23988 
      else:
23989 
        iprot.skip(ftype)
23990 
      iprot.readFieldEnd()
23991 
    iprot.readStructEnd()
23992 
 
23993 
  def write(self, oprot):
23994 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23995 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23996 
      return
23997 
    oprot.writeStructBegin('saveEBSSettlementSummary_args')
23998 
    if self.settlementId is not None:
23999 
      oprot.writeFieldBegin('settlementId', TType.I64, 1)
24000 
      oprot.writeI64(self.settlementId)
24001 
      oprot.writeFieldEnd()
24002 
    if self.settlementDate is not None:
24003 
      oprot.writeFieldBegin('settlementDate', TType.I64, 2)
24004 
      oprot.writeI64(self.settlementDate)
24005 
      oprot.writeFieldEnd()
24006 
    if self.transactionDateFrom is not None:
24007 
      oprot.writeFieldBegin('transactionDateFrom', TType.I64, 3)
24008 
      oprot.writeI64(self.transactionDateFrom)
24009 
      oprot.writeFieldEnd()
24010 
    if self.transactionDateTo is not None:
24011 
      oprot.writeFieldBegin('transactionDateTo', TType.I64, 4)
24012 
      oprot.writeI64(self.transactionDateTo)
24013 
      oprot.writeFieldEnd()
24014 
    if self.amount is not None:
24015 
      oprot.writeFieldBegin('amount', TType.DOUBLE, 5)
24016 
      oprot.writeDouble(self.amount)
24017 
      oprot.writeFieldEnd()
24018 
    oprot.writeFieldStop()
24019 
    oprot.writeStructEnd()
24020 
 
24021 
  def validate(self):
24022 
    return
24023 
 
24024 
 
24025 
  def __repr__(self):
24026 
    L = ['%s=%r' % (key, value)
24027 
      for key, value in self.__dict__.iteritems()]
24028 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24029 
 
24030 
  def __eq__(self, other):
24031 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24032 
 
24033 
  def __ne__(self, other):
24034 
    return not (self == other)
24035 
 
24036 
class saveEBSSettlementSummary_result:
24037 
  """
24038 
  Attributes:
24039 
   - ex
24040 
  """
24041 
 
24042 
  thrift_spec = (
24043 
    None, # 0
24044 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
24045 
  )
24046 
 
24047 
  def __init__(self, ex=None,):
24048 
    self.ex = ex
24049 
 
24050 
  def read(self, iprot):
24051 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24052 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24053 
      return
24054 
    iprot.readStructBegin()
24055 
    while True:
24056 
      (fname, ftype, fid) = iprot.readFieldBegin()
24057 
      if ftype == TType.STOP:
24058 
        break
24059 
      if fid == 1:
24060 
        if ftype == TType.STRUCT:
24061 
          self.ex = TransactionServiceException()
24062 
          self.ex.read(iprot)
24063 
        else:
24064 
          iprot.skip(ftype)
24065 
      else:
24066 
        iprot.skip(ftype)
24067 
      iprot.readFieldEnd()
24068 
    iprot.readStructEnd()
24069 
 
24070 
  def write(self, oprot):
24071 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24072 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24073 
      return
24074 
    oprot.writeStructBegin('saveEBSSettlementSummary_result')
24075 
    if self.ex is not None:
24076 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
24077 
      self.ex.write(oprot)
24078 
      oprot.writeFieldEnd()
24079 
    oprot.writeFieldStop()
24080 
    oprot.writeStructEnd()
24081 
 
24082 
  def validate(self):
24083 
    return
24084 
 
24085 
 
24086 
  def __repr__(self):
24087 
    L = ['%s=%r' % (key, value)
24088 
      for key, value in self.__dict__.iteritems()]
24089 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24090 
 
24091 
  def __eq__(self, other):
24092 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24093 
 
24094 
  def __ne__(self, other):
24095 
    return not (self == other)
24096 
 
5386 phani.kuma 24097 
class getSettlementForPrepaid_args:
4600 varun.gupt 24098 
  """
24099 
  Attributes:
5189 varun.gupt 24100 
   - referenceId
24101 
   - isRefund
4600 varun.gupt 24102 
  """
24103 
 
24104 
  thrift_spec = (
24105 
    None, # 0
5189 varun.gupt 24106 
    (1, TType.I64, 'referenceId', None, None, ), # 1
5386 phani.kuma 24107 
    (2, TType.BOOL, 'isRefund', None, None, ), # 2
4600 varun.gupt 24108 
  )
24109 
 
5386 phani.kuma 24110 
  def __init__(self, referenceId=None, isRefund=None,):
5189 varun.gupt 24111 
    self.referenceId = referenceId
24112 
    self.isRefund = isRefund
4600 varun.gupt 24113 
 
24114 
  def read(self, iprot):
24115 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24116 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24117 
      return
24118 
    iprot.readStructBegin()
24119 
    while True:
24120 
      (fname, ftype, fid) = iprot.readFieldBegin()
24121 
      if ftype == TType.STOP:
24122 
        break
24123 
      if fid == 1:
24124 
        if ftype == TType.I64:
5189 varun.gupt 24125 
          self.referenceId = iprot.readI64();
4600 varun.gupt 24126 
        else:
24127 
          iprot.skip(ftype)
5189 varun.gupt 24128 
      elif fid == 2:
24129 
        if ftype == TType.BOOL:
24130 
          self.isRefund = iprot.readBool();
24131 
        else:
24132 
          iprot.skip(ftype)
4600 varun.gupt 24133 
      else:
24134 
        iprot.skip(ftype)
24135 
      iprot.readFieldEnd()
24136 
    iprot.readStructEnd()
24137 
 
24138 
  def write(self, oprot):
24139 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24140 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24141 
      return
5386 phani.kuma 24142 
    oprot.writeStructBegin('getSettlementForPrepaid_args')
5189 varun.gupt 24143 
    if self.referenceId is not None:
24144 
      oprot.writeFieldBegin('referenceId', TType.I64, 1)
24145 
      oprot.writeI64(self.referenceId)
4600 varun.gupt 24146 
      oprot.writeFieldEnd()
5386 phani.kuma 24147 
    if self.isRefund is not None:
24148 
      oprot.writeFieldBegin('isRefund', TType.BOOL, 2)
24149 
      oprot.writeBool(self.isRefund)
5382 varun.gupt 24150 
      oprot.writeFieldEnd()
5386 phani.kuma 24151 
    oprot.writeFieldStop()
24152 
    oprot.writeStructEnd()
24153 
 
24154 
  def validate(self):
24155 
    return
24156 
 
24157 
 
24158 
  def __repr__(self):
24159 
    L = ['%s=%r' % (key, value)
24160 
      for key, value in self.__dict__.iteritems()]
24161 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24162 
 
24163 
  def __eq__(self, other):
24164 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24165 
 
24166 
  def __ne__(self, other):
24167 
    return not (self == other)
24168 
 
24169 
class getSettlementForPrepaid_result:
24170 
  """
24171 
  Attributes:
24172 
   - success
24173 
   - ex
24174 
  """
24175 
 
24176 
  thrift_spec = (
24177 
    (0, TType.STRUCT, 'success', (PaymentSettlement, PaymentSettlement.thrift_spec), None, ), # 0
24178 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
24179 
  )
24180 
 
24181 
  def __init__(self, success=None, ex=None,):
24182 
    self.success = success
24183 
    self.ex = ex
24184 
 
24185 
  def read(self, iprot):
24186 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24187 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24188 
      return
24189 
    iprot.readStructBegin()
24190 
    while True:
24191 
      (fname, ftype, fid) = iprot.readFieldBegin()
24192 
      if ftype == TType.STOP:
24193 
        break
24194 
      if fid == 0:
24195 
        if ftype == TType.STRUCT:
24196 
          self.success = PaymentSettlement()
24197 
          self.success.read(iprot)
24198 
        else:
24199 
          iprot.skip(ftype)
24200 
      elif fid == 1:
24201 
        if ftype == TType.STRUCT:
24202 
          self.ex = TransactionServiceException()
24203 
          self.ex.read(iprot)
24204 
        else:
24205 
          iprot.skip(ftype)
24206 
      else:
24207 
        iprot.skip(ftype)
24208 
      iprot.readFieldEnd()
24209 
    iprot.readStructEnd()
24210 
 
24211 
  def write(self, oprot):
24212 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24213 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24214 
      return
24215 
    oprot.writeStructBegin('getSettlementForPrepaid_result')
24216 
    if self.success is not None:
24217 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
24218 
      self.success.write(oprot)
24219 
      oprot.writeFieldEnd()
24220 
    if self.ex is not None:
24221 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
24222 
      self.ex.write(oprot)
24223 
      oprot.writeFieldEnd()
24224 
    oprot.writeFieldStop()
24225 
    oprot.writeStructEnd()
24226 
 
24227 
  def validate(self):
24228 
    return
24229 
 
24230 
 
24231 
  def __repr__(self):
24232 
    L = ['%s=%r' % (key, value)
24233 
      for key, value in self.__dict__.iteritems()]
24234 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24235 
 
24236 
  def __eq__(self, other):
24237 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24238 
 
24239 
  def __ne__(self, other):
24240 
    return not (self == other)
24241 
 
24242 
class getSettlementForCod_args:
24243 
  """
24244 
  Attributes:
24245 
   - orderId
24246 
   - isRefund
24247 
  """
24248 
 
24249 
  thrift_spec = (
24250 
    None, # 0
24251 
    (1, TType.I64, 'orderId', None, None, ), # 1
24252 
    (2, TType.BOOL, 'isRefund', None, None, ), # 2
24253 
  )
24254 
 
24255 
  def __init__(self, orderId=None, isRefund=None,):
24256 
    self.orderId = orderId
24257 
    self.isRefund = isRefund
24258 
 
24259 
  def read(self, iprot):
24260 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24261 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24262 
      return
24263 
    iprot.readStructBegin()
24264 
    while True:
24265 
      (fname, ftype, fid) = iprot.readFieldBegin()
24266 
      if ftype == TType.STOP:
24267 
        break
24268 
      if fid == 1:
24269 
        if ftype == TType.I64:
24270 
          self.orderId = iprot.readI64();
24271 
        else:
24272 
          iprot.skip(ftype)
24273 
      elif fid == 2:
24274 
        if ftype == TType.BOOL:
24275 
          self.isRefund = iprot.readBool();
24276 
        else:
24277 
          iprot.skip(ftype)
24278 
      else:
24279 
        iprot.skip(ftype)
24280 
      iprot.readFieldEnd()
24281 
    iprot.readStructEnd()
24282 
 
24283 
  def write(self, oprot):
24284 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24285 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24286 
      return
24287 
    oprot.writeStructBegin('getSettlementForCod_args')
24288 
    if self.orderId is not None:
24289 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
24290 
      oprot.writeI64(self.orderId)
24291 
      oprot.writeFieldEnd()
5189 varun.gupt 24292 
    if self.isRefund is not None:
5386 phani.kuma 24293 
      oprot.writeFieldBegin('isRefund', TType.BOOL, 2)
5189 varun.gupt 24294 
      oprot.writeBool(self.isRefund)
24295 
      oprot.writeFieldEnd()
4600 varun.gupt 24296 
    oprot.writeFieldStop()
24297 
    oprot.writeStructEnd()
24298 
 
24299 
  def validate(self):
24300 
    return
24301 
 
24302 
 
24303 
  def __repr__(self):
24304 
    L = ['%s=%r' % (key, value)
24305 
      for key, value in self.__dict__.iteritems()]
24306 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24307 
 
24308 
  def __eq__(self, other):
24309 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24310 
 
24311 
  def __ne__(self, other):
24312 
    return not (self == other)
24313 
 
5386 phani.kuma 24314 
class getSettlementForCod_result:
4600 varun.gupt 24315 
  """
24316 
  Attributes:
24317 
   - success
24318 
   - ex
24319 
  """
24320 
 
24321 
  thrift_spec = (
24322 
    (0, TType.STRUCT, 'success', (PaymentSettlement, PaymentSettlement.thrift_spec), None, ), # 0
24323 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
24324 
  )
24325 
 
24326 
  def __init__(self, success=None, ex=None,):
24327 
    self.success = success
24328 
    self.ex = ex
24329 
 
24330 
  def read(self, iprot):
24331 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24332 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24333 
      return
24334 
    iprot.readStructBegin()
24335 
    while True:
24336 
      (fname, ftype, fid) = iprot.readFieldBegin()
24337 
      if ftype == TType.STOP:
24338 
        break
24339 
      if fid == 0:
24340 
        if ftype == TType.STRUCT:
24341 
          self.success = PaymentSettlement()
24342 
          self.success.read(iprot)
24343 
        else:
24344 
          iprot.skip(ftype)
24345 
      elif fid == 1:
24346 
        if ftype == TType.STRUCT:
24347 
          self.ex = TransactionServiceException()
24348 
          self.ex.read(iprot)
24349 
        else:
24350 
          iprot.skip(ftype)
24351 
      else:
24352 
        iprot.skip(ftype)
24353 
      iprot.readFieldEnd()
24354 
    iprot.readStructEnd()
24355 
 
24356 
  def write(self, oprot):
24357 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24358 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24359 
      return
5386 phani.kuma 24360 
    oprot.writeStructBegin('getSettlementForCod_result')
4600 varun.gupt 24361 
    if self.success is not None:
24362 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
24363 
      self.success.write(oprot)
24364 
      oprot.writeFieldEnd()
24365 
    if self.ex is not None:
24366 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
24367 
      self.ex.write(oprot)
24368 
      oprot.writeFieldEnd()
24369 
    oprot.writeFieldStop()
24370 
    oprot.writeStructEnd()
24371 
 
24372 
  def validate(self):
24373 
    return
24374 
 
24375 
 
24376 
  def __repr__(self):
24377 
    L = ['%s=%r' % (key, value)
24378 
      for key, value in self.__dict__.iteritems()]
24379 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24380 
 
24381 
  def __eq__(self, other):
24382 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24383 
 
24384 
  def __ne__(self, other):
24385 
    return not (self == other)
24386 
 
24387 
class getEBSSettlementSummaries_args:
24388 
 
24389 
  thrift_spec = (
24390 
  )
24391 
 
24392 
  def read(self, iprot):
24393 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24394 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24395 
      return
24396 
    iprot.readStructBegin()
24397 
    while True:
24398 
      (fname, ftype, fid) = iprot.readFieldBegin()
24399 
      if ftype == TType.STOP:
24400 
        break
24401 
      else:
24402 
        iprot.skip(ftype)
24403 
      iprot.readFieldEnd()
24404 
    iprot.readStructEnd()
24405 
 
24406 
  def write(self, oprot):
24407 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24408 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24409 
      return
24410 
    oprot.writeStructBegin('getEBSSettlementSummaries_args')
24411 
    oprot.writeFieldStop()
24412 
    oprot.writeStructEnd()
24413 
 
24414 
  def validate(self):
24415 
    return
24416 
 
24417 
 
24418 
  def __repr__(self):
24419 
    L = ['%s=%r' % (key, value)
24420 
      for key, value in self.__dict__.iteritems()]
24421 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24422 
 
24423 
  def __eq__(self, other):
24424 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24425 
 
24426 
  def __ne__(self, other):
24427 
    return not (self == other)
24428 
 
24429 
class getEBSSettlementSummaries_result:
24430 
  """
24431 
  Attributes:
24432 
   - success
24433 
   - ex
24434 
  """
24435 
 
24436 
  thrift_spec = (
24437 
    (0, TType.MAP, 'success', (TType.I64,None,TType.STRING,None), None, ), # 0
24438 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
24439 
  )
24440 
 
24441 
  def __init__(self, success=None, ex=None,):
24442 
    self.success = success
24443 
    self.ex = ex
24444 
 
24445 
  def read(self, iprot):
24446 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24447 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24448 
      return
24449 
    iprot.readStructBegin()
24450 
    while True:
24451 
      (fname, ftype, fid) = iprot.readFieldBegin()
24452 
      if ftype == TType.STOP:
24453 
        break
24454 
      if fid == 0:
24455 
        if ftype == TType.MAP:
24456 
          self.success = {}
6188 rajveer 24457 
          (_ktype555, _vtype556, _size554 ) = iprot.readMapBegin()
24458 
          for _i558 in xrange(_size554):
24459 
            _key559 = iprot.readI64();
24460 
            _val560 = iprot.readString();
24461 
            self.success[_key559] = _val560
4600 varun.gupt 24462 
          iprot.readMapEnd()
24463 
        else:
24464 
          iprot.skip(ftype)
24465 
      elif fid == 1:
24466 
        if ftype == TType.STRUCT:
24467 
          self.ex = TransactionServiceException()
24468 
          self.ex.read(iprot)
24469 
        else:
24470 
          iprot.skip(ftype)
24471 
      else:
24472 
        iprot.skip(ftype)
24473 
      iprot.readFieldEnd()
24474 
    iprot.readStructEnd()
24475 
 
24476 
  def write(self, oprot):
24477 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24478 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24479 
      return
24480 
    oprot.writeStructBegin('getEBSSettlementSummaries_result')
24481 
    if self.success is not None:
24482 
      oprot.writeFieldBegin('success', TType.MAP, 0)
24483 
      oprot.writeMapBegin(TType.I64, TType.STRING, len(self.success))
6188 rajveer 24484 
      for kiter561,viter562 in self.success.items():
24485 
        oprot.writeI64(kiter561)
24486 
        oprot.writeString(viter562)
4600 varun.gupt 24487 
      oprot.writeMapEnd()
24488 
      oprot.writeFieldEnd()
24489 
    if self.ex is not None:
24490 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
24491 
      self.ex.write(oprot)
24492 
      oprot.writeFieldEnd()
24493 
    oprot.writeFieldStop()
24494 
    oprot.writeStructEnd()
24495 
 
24496 
  def validate(self):
24497 
    return
24498 
 
24499 
 
24500 
  def __repr__(self):
24501 
    L = ['%s=%r' % (key, value)
24502 
      for key, value in self.__dict__.iteritems()]
24503 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24504 
 
24505 
  def __eq__(self, other):
24506 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24507 
 
24508 
  def __ne__(self, other):
24509 
    return not (self == other)
24510 
 
24511 
class markEBSSettlementUploaded_args:
24512 
  """
24513 
  Attributes:
24514 
   - settlementId
24515 
  """
24516 
 
24517 
  thrift_spec = (
24518 
    None, # 0
24519 
    (1, TType.I64, 'settlementId', None, None, ), # 1
24520 
  )
24521 
 
24522 
  def __init__(self, settlementId=None,):
24523 
    self.settlementId = settlementId
24524 
 
24525 
  def read(self, iprot):
24526 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24527 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24528 
      return
24529 
    iprot.readStructBegin()
24530 
    while True:
24531 
      (fname, ftype, fid) = iprot.readFieldBegin()
24532 
      if ftype == TType.STOP:
24533 
        break
24534 
      if fid == 1:
24535 
        if ftype == TType.I64:
24536 
          self.settlementId = iprot.readI64();
24537 
        else:
24538 
          iprot.skip(ftype)
24539 
      else:
24540 
        iprot.skip(ftype)
24541 
      iprot.readFieldEnd()
24542 
    iprot.readStructEnd()
24543 
 
24544 
  def write(self, oprot):
24545 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24546 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24547 
      return
24548 
    oprot.writeStructBegin('markEBSSettlementUploaded_args')
24549 
    if self.settlementId is not None:
24550 
      oprot.writeFieldBegin('settlementId', TType.I64, 1)
24551 
      oprot.writeI64(self.settlementId)
24552 
      oprot.writeFieldEnd()
24553 
    oprot.writeFieldStop()
24554 
    oprot.writeStructEnd()
24555 
 
24556 
  def validate(self):
24557 
    return
24558 
 
24559 
 
24560 
  def __repr__(self):
24561 
    L = ['%s=%r' % (key, value)
24562 
      for key, value in self.__dict__.iteritems()]
24563 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24564 
 
24565 
  def __eq__(self, other):
24566 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24567 
 
24568 
  def __ne__(self, other):
24569 
    return not (self == other)
24570 
 
24571 
class markEBSSettlementUploaded_result:
24572 
  """
24573 
  Attributes:
24574 
   - ex
24575 
  """
24576 
 
24577 
  thrift_spec = (
24578 
    None, # 0
24579 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
24580 
  )
24581 
 
24582 
  def __init__(self, ex=None,):
24583 
    self.ex = ex
24584 
 
24585 
  def read(self, iprot):
24586 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24587 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24588 
      return
24589 
    iprot.readStructBegin()
24590 
    while True:
24591 
      (fname, ftype, fid) = iprot.readFieldBegin()
24592 
      if ftype == TType.STOP:
24593 
        break
24594 
      if fid == 1:
24595 
        if ftype == TType.STRUCT:
24596 
          self.ex = TransactionServiceException()
24597 
          self.ex.read(iprot)
24598 
        else:
24599 
          iprot.skip(ftype)
24600 
      else:
24601 
        iprot.skip(ftype)
24602 
      iprot.readFieldEnd()
24603 
    iprot.readStructEnd()
24604 
 
24605 
  def write(self, oprot):
24606 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24607 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24608 
      return
24609 
    oprot.writeStructBegin('markEBSSettlementUploaded_result')
24610 
    if self.ex is not None:
24611 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
24612 
      self.ex.write(oprot)
24613 
      oprot.writeFieldEnd()
24614 
    oprot.writeFieldStop()
24615 
    oprot.writeStructEnd()
24616 
 
24617 
  def validate(self):
24618 
    return
24619 
 
24620 
 
24621 
  def __repr__(self):
24622 
    L = ['%s=%r' % (key, value)
24623 
      for key, value in self.__dict__.iteritems()]
24624 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24625 
 
24626 
  def __eq__(self, other):
24627 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24628 
 
24629 
  def __ne__(self, other):
24630 
    return not (self == other)
24631 
 
24632 
class getEBSSettlementDate_args:
24633 
  """
24634 
  Attributes:
24635 
   - settlementId
24636 
  """
24637 
 
24638 
  thrift_spec = (
24639 
    None, # 0
24640 
    (1, TType.I64, 'settlementId', None, None, ), # 1
24641 
  )
24642 
 
24643 
  def __init__(self, settlementId=None,):
24644 
    self.settlementId = settlementId
24645 
 
24646 
  def read(self, iprot):
24647 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24648 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24649 
      return
24650 
    iprot.readStructBegin()
24651 
    while True:
24652 
      (fname, ftype, fid) = iprot.readFieldBegin()
24653 
      if ftype == TType.STOP:
24654 
        break
24655 
      if fid == 1:
24656 
        if ftype == TType.I64:
24657 
          self.settlementId = iprot.readI64();
24658 
        else:
24659 
          iprot.skip(ftype)
24660 
      else:
24661 
        iprot.skip(ftype)
24662 
      iprot.readFieldEnd()
24663 
    iprot.readStructEnd()
24664 
 
24665 
  def write(self, oprot):
24666 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24667 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24668 
      return
24669 
    oprot.writeStructBegin('getEBSSettlementDate_args')
24670 
    if self.settlementId is not None:
24671 
      oprot.writeFieldBegin('settlementId', TType.I64, 1)
24672 
      oprot.writeI64(self.settlementId)
24673 
      oprot.writeFieldEnd()
24674 
    oprot.writeFieldStop()
24675 
    oprot.writeStructEnd()
24676 
 
24677 
  def validate(self):
24678 
    return
24679 
 
24680 
 
24681 
  def __repr__(self):
24682 
    L = ['%s=%r' % (key, value)
24683 
      for key, value in self.__dict__.iteritems()]
24684 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24685 
 
24686 
  def __eq__(self, other):
24687 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24688 
 
24689 
  def __ne__(self, other):
24690 
    return not (self == other)
24691 
 
24692 
class getEBSSettlementDate_result:
24693 
  """
24694 
  Attributes:
24695 
   - success
24696 
   - ex
24697 
  """
24698 
 
24699 
  thrift_spec = (
24700 
    (0, TType.I64, 'success', None, None, ), # 0
24701 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
24702 
  )
24703 
 
24704 
  def __init__(self, success=None, ex=None,):
24705 
    self.success = success
24706 
    self.ex = ex
24707 
 
24708 
  def read(self, iprot):
24709 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24710 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24711 
      return
24712 
    iprot.readStructBegin()
24713 
    while True:
24714 
      (fname, ftype, fid) = iprot.readFieldBegin()
24715 
      if ftype == TType.STOP:
24716 
        break
24717 
      if fid == 0:
24718 
        if ftype == TType.I64:
24719 
          self.success = iprot.readI64();
24720 
        else:
24721 
          iprot.skip(ftype)
24722 
      elif fid == 1:
24723 
        if ftype == TType.STRUCT:
24724 
          self.ex = TransactionServiceException()
24725 
          self.ex.read(iprot)
24726 
        else:
24727 
          iprot.skip(ftype)
24728 
      else:
24729 
        iprot.skip(ftype)
24730 
      iprot.readFieldEnd()
24731 
    iprot.readStructEnd()
24732 
 
24733 
  def write(self, oprot):
24734 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24735 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24736 
      return
24737 
    oprot.writeStructBegin('getEBSSettlementDate_result')
24738 
    if self.success is not None:
24739 
      oprot.writeFieldBegin('success', TType.I64, 0)
24740 
      oprot.writeI64(self.success)
24741 
      oprot.writeFieldEnd()
24742 
    if self.ex is not None:
24743 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
24744 
      self.ex.write(oprot)
24745 
      oprot.writeFieldEnd()
24746 
    oprot.writeFieldStop()
24747 
    oprot.writeStructEnd()
24748 
 
24749 
  def validate(self):
24750 
    return
24751 
 
24752 
 
24753 
  def __repr__(self):
24754 
    L = ['%s=%r' % (key, value)
24755 
      for key, value in self.__dict__.iteritems()]
24756 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24757 
 
24758 
  def __eq__(self, other):
24759 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24760 
 
24761 
  def __ne__(self, other):
24762 
    return not (self == other)
4715 varun.gupt 24763 
 
24764 
class getSettlementsByDate_args:
24765 
  """
24766 
  Attributes:
24767 
   - settlementDateFrom
24768 
   - settlementDateTo
24769 
   - isRefund
24770 
  """
24771 
 
24772 
  thrift_spec = (
24773 
    None, # 0
24774 
    (1, TType.I64, 'settlementDateFrom', None, None, ), # 1
24775 
    (2, TType.I64, 'settlementDateTo', None, None, ), # 2
24776 
    (3, TType.BOOL, 'isRefund', None, None, ), # 3
24777 
  )
24778 
 
24779 
  def __init__(self, settlementDateFrom=None, settlementDateTo=None, isRefund=None,):
24780 
    self.settlementDateFrom = settlementDateFrom
24781 
    self.settlementDateTo = settlementDateTo
24782 
    self.isRefund = isRefund
24783 
 
24784 
  def read(self, iprot):
24785 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24786 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24787 
      return
24788 
    iprot.readStructBegin()
24789 
    while True:
24790 
      (fname, ftype, fid) = iprot.readFieldBegin()
24791 
      if ftype == TType.STOP:
24792 
        break
24793 
      if fid == 1:
24794 
        if ftype == TType.I64:
24795 
          self.settlementDateFrom = iprot.readI64();
24796 
        else:
24797 
          iprot.skip(ftype)
24798 
      elif fid == 2:
24799 
        if ftype == TType.I64:
24800 
          self.settlementDateTo = iprot.readI64();
24801 
        else:
24802 
          iprot.skip(ftype)
24803 
      elif fid == 3:
24804 
        if ftype == TType.BOOL:
24805 
          self.isRefund = iprot.readBool();
24806 
        else:
24807 
          iprot.skip(ftype)
24808 
      else:
24809 
        iprot.skip(ftype)
24810 
      iprot.readFieldEnd()
24811 
    iprot.readStructEnd()
24812 
 
24813 
  def write(self, oprot):
24814 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24815 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24816 
      return
24817 
    oprot.writeStructBegin('getSettlementsByDate_args')
24818 
    if self.settlementDateFrom is not None:
24819 
      oprot.writeFieldBegin('settlementDateFrom', TType.I64, 1)
24820 
      oprot.writeI64(self.settlementDateFrom)
24821 
      oprot.writeFieldEnd()
24822 
    if self.settlementDateTo is not None:
24823 
      oprot.writeFieldBegin('settlementDateTo', TType.I64, 2)
24824 
      oprot.writeI64(self.settlementDateTo)
24825 
      oprot.writeFieldEnd()
24826 
    if self.isRefund is not None:
24827 
      oprot.writeFieldBegin('isRefund', TType.BOOL, 3)
24828 
      oprot.writeBool(self.isRefund)
24829 
      oprot.writeFieldEnd()
24830 
    oprot.writeFieldStop()
24831 
    oprot.writeStructEnd()
24832 
 
24833 
  def validate(self):
24834 
    return
24835 
 
24836 
 
24837 
  def __repr__(self):
24838 
    L = ['%s=%r' % (key, value)
24839 
      for key, value in self.__dict__.iteritems()]
24840 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24841 
 
24842 
  def __eq__(self, other):
24843 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24844 
 
24845 
  def __ne__(self, other):
24846 
    return not (self == other)
24847 
 
24848 
class getSettlementsByDate_result:
24849 
  """
24850 
  Attributes:
24851 
   - success
24852 
   - ex
24853 
  """
24854 
 
24855 
  thrift_spec = (
24856 
    (0, TType.LIST, 'success', (TType.STRUCT,(PaymentSettlement, PaymentSettlement.thrift_spec)), None, ), # 0
24857 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
24858 
  )
24859 
 
24860 
  def __init__(self, success=None, ex=None,):
24861 
    self.success = success
24862 
    self.ex = ex
24863 
 
24864 
  def read(self, iprot):
24865 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24866 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24867 
      return
24868 
    iprot.readStructBegin()
24869 
    while True:
24870 
      (fname, ftype, fid) = iprot.readFieldBegin()
24871 
      if ftype == TType.STOP:
24872 
        break
24873 
      if fid == 0:
24874 
        if ftype == TType.LIST:
24875 
          self.success = []
6188 rajveer 24876 
          (_etype566, _size563) = iprot.readListBegin()
24877 
          for _i567 in xrange(_size563):
24878 
            _elem568 = PaymentSettlement()
24879 
            _elem568.read(iprot)
24880 
            self.success.append(_elem568)
4715 varun.gupt 24881 
          iprot.readListEnd()
24882 
        else:
24883 
          iprot.skip(ftype)
24884 
      elif fid == 1:
24885 
        if ftype == TType.STRUCT:
24886 
          self.ex = TransactionServiceException()
24887 
          self.ex.read(iprot)
24888 
        else:
24889 
          iprot.skip(ftype)
24890 
      else:
24891 
        iprot.skip(ftype)
24892 
      iprot.readFieldEnd()
24893 
    iprot.readStructEnd()
24894 
 
24895 
  def write(self, oprot):
24896 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24897 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24898 
      return
24899 
    oprot.writeStructBegin('getSettlementsByDate_result')
24900 
    if self.success is not None:
24901 
      oprot.writeFieldBegin('success', TType.LIST, 0)
24902 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 24903 
      for iter569 in self.success:
24904 
        iter569.write(oprot)
4715 varun.gupt 24905 
      oprot.writeListEnd()
24906 
      oprot.writeFieldEnd()
24907 
    if self.ex is not None:
24908 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
24909 
      self.ex.write(oprot)
24910 
      oprot.writeFieldEnd()
24911 
    oprot.writeFieldStop()
24912 
    oprot.writeStructEnd()
24913 
 
24914 
  def validate(self):
24915 
    return
24916 
 
24917 
 
24918 
  def __repr__(self):
24919 
    L = ['%s=%r' % (key, value)
24920 
      for key, value in self.__dict__.iteritems()]
24921 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24922 
 
24923 
  def __eq__(self, other):
24924 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24925 
 
24926 
  def __ne__(self, other):
24927 
    return not (self == other)
24928 
 
24929 
class getReshippedOrderIds_args:
24930 
  """
24931 
  Attributes:
24932 
   - orderIds
24933 
  """
24934 
 
24935 
  thrift_spec = (
24936 
    None, # 0
24937 
    (1, TType.LIST, 'orderIds', (TType.I64,None), None, ), # 1
24938 
  )
24939 
 
24940 
  def __init__(self, orderIds=None,):
24941 
    self.orderIds = orderIds
24942 
 
24943 
  def read(self, iprot):
24944 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24945 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24946 
      return
24947 
    iprot.readStructBegin()
24948 
    while True:
24949 
      (fname, ftype, fid) = iprot.readFieldBegin()
24950 
      if ftype == TType.STOP:
24951 
        break
24952 
      if fid == 1:
24953 
        if ftype == TType.LIST:
24954 
          self.orderIds = []
6188 rajveer 24955 
          (_etype573, _size570) = iprot.readListBegin()
24956 
          for _i574 in xrange(_size570):
24957 
            _elem575 = iprot.readI64();
24958 
            self.orderIds.append(_elem575)
4715 varun.gupt 24959 
          iprot.readListEnd()
24960 
        else:
24961 
          iprot.skip(ftype)
24962 
      else:
24963 
        iprot.skip(ftype)
24964 
      iprot.readFieldEnd()
24965 
    iprot.readStructEnd()
24966 
 
24967 
  def write(self, oprot):
24968 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24969 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24970 
      return
24971 
    oprot.writeStructBegin('getReshippedOrderIds_args')
24972 
    if self.orderIds is not None:
24973 
      oprot.writeFieldBegin('orderIds', TType.LIST, 1)
24974 
      oprot.writeListBegin(TType.I64, len(self.orderIds))
6188 rajveer 24975 
      for iter576 in self.orderIds:
24976 
        oprot.writeI64(iter576)
4715 varun.gupt 24977 
      oprot.writeListEnd()
24978 
      oprot.writeFieldEnd()
24979 
    oprot.writeFieldStop()
24980 
    oprot.writeStructEnd()
24981 
 
24982 
  def validate(self):
24983 
    return
24984 
 
24985 
 
24986 
  def __repr__(self):
24987 
    L = ['%s=%r' % (key, value)
24988 
      for key, value in self.__dict__.iteritems()]
24989 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24990 
 
24991 
  def __eq__(self, other):
24992 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24993 
 
24994 
  def __ne__(self, other):
24995 
    return not (self == other)
24996 
 
24997 
class getReshippedOrderIds_result:
24998 
  """
24999 
  Attributes:
25000 
   - success
25001 
   - ex
25002 
  """
25003 
 
25004 
  thrift_spec = (
25005 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
25006 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
25007 
  )
25008 
 
25009 
  def __init__(self, success=None, ex=None,):
25010 
    self.success = success
25011 
    self.ex = ex
25012 
 
25013 
  def read(self, iprot):
25014 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25015 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25016 
      return
25017 
    iprot.readStructBegin()
25018 
    while True:
25019 
      (fname, ftype, fid) = iprot.readFieldBegin()
25020 
      if ftype == TType.STOP:
25021 
        break
25022 
      if fid == 0:
25023 
        if ftype == TType.LIST:
25024 
          self.success = []
6188 rajveer 25025 
          (_etype580, _size577) = iprot.readListBegin()
25026 
          for _i581 in xrange(_size577):
25027 
            _elem582 = iprot.readI64();
25028 
            self.success.append(_elem582)
4715 varun.gupt 25029 
          iprot.readListEnd()
25030 
        else:
25031 
          iprot.skip(ftype)
25032 
      elif fid == 1:
25033 
        if ftype == TType.STRUCT:
25034 
          self.ex = TransactionServiceException()
25035 
          self.ex.read(iprot)
25036 
        else:
25037 
          iprot.skip(ftype)
25038 
      else:
25039 
        iprot.skip(ftype)
25040 
      iprot.readFieldEnd()
25041 
    iprot.readStructEnd()
25042 
 
25043 
  def write(self, oprot):
25044 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25045 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25046 
      return
25047 
    oprot.writeStructBegin('getReshippedOrderIds_result')
25048 
    if self.success is not None:
25049 
      oprot.writeFieldBegin('success', TType.LIST, 0)
25050 
      oprot.writeListBegin(TType.I64, len(self.success))
6188 rajveer 25051 
      for iter583 in self.success:
25052 
        oprot.writeI64(iter583)
4715 varun.gupt 25053 
      oprot.writeListEnd()
25054 
      oprot.writeFieldEnd()
25055 
    if self.ex is not None:
25056 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
25057 
      self.ex.write(oprot)
25058 
      oprot.writeFieldEnd()
25059 
    oprot.writeFieldStop()
25060 
    oprot.writeStructEnd()
25061 
 
25062 
  def validate(self):
25063 
    return
25064 
 
25065 
 
25066 
  def __repr__(self):
25067 
    L = ['%s=%r' % (key, value)
25068 
      for key, value in self.__dict__.iteritems()]
25069 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25070 
 
25071 
  def __eq__(self, other):
25072 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25073 
 
25074 
  def __ne__(self, other):
25075 
    return not (self == other)
4757 mandeep.dh 25076 
 
5481 phani.kuma 25077 
class getBilledOrders_args:
4875 varun.gupt 25078 
  """
25079 
  Attributes:
25080 
   - vendorId
5481 phani.kuma 25081 
   - onlyVendorNotPaid
25082 
   - billingDateFrom
25083 
   - billingDateTo
4875 varun.gupt 25084 
  """
25085 
 
25086 
  thrift_spec = (
25087 
    None, # 0
25088 
    (1, TType.I64, 'vendorId', None, None, ), # 1
5481 phani.kuma 25089 
    (2, TType.BOOL, 'onlyVendorNotPaid', None, None, ), # 2
25090 
    (3, TType.I64, 'billingDateFrom', None, None, ), # 3
25091 
    (4, TType.I64, 'billingDateTo', None, None, ), # 4
4875 varun.gupt 25092 
  )
25093 
 
5481 phani.kuma 25094 
  def __init__(self, vendorId=None, onlyVendorNotPaid=None, billingDateFrom=None, billingDateTo=None,):
4875 varun.gupt 25095 
    self.vendorId = vendorId
5481 phani.kuma 25096 
    self.onlyVendorNotPaid = onlyVendorNotPaid
25097 
    self.billingDateFrom = billingDateFrom
25098 
    self.billingDateTo = billingDateTo
4875 varun.gupt 25099 
 
25100 
  def read(self, iprot):
25101 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25102 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25103 
      return
25104 
    iprot.readStructBegin()
25105 
    while True:
25106 
      (fname, ftype, fid) = iprot.readFieldBegin()
25107 
      if ftype == TType.STOP:
25108 
        break
25109 
      if fid == 1:
25110 
        if ftype == TType.I64:
25111 
          self.vendorId = iprot.readI64();
25112 
        else:
25113 
          iprot.skip(ftype)
5481 phani.kuma 25114 
      elif fid == 2:
25115 
        if ftype == TType.BOOL:
25116 
          self.onlyVendorNotPaid = iprot.readBool();
25117 
        else:
25118 
          iprot.skip(ftype)
25119 
      elif fid == 3:
25120 
        if ftype == TType.I64:
25121 
          self.billingDateFrom = iprot.readI64();
25122 
        else:
25123 
          iprot.skip(ftype)
25124 
      elif fid == 4:
25125 
        if ftype == TType.I64:
25126 
          self.billingDateTo = iprot.readI64();
25127 
        else:
25128 
          iprot.skip(ftype)
4875 varun.gupt 25129 
      else:
25130 
        iprot.skip(ftype)
25131 
      iprot.readFieldEnd()
25132 
    iprot.readStructEnd()
25133 
 
25134 
  def write(self, oprot):
25135 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25136 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25137 
      return
5481 phani.kuma 25138 
    oprot.writeStructBegin('getBilledOrders_args')
4875 varun.gupt 25139 
    if self.vendorId is not None:
25140 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
25141 
      oprot.writeI64(self.vendorId)
25142 
      oprot.writeFieldEnd()
5481 phani.kuma 25143 
    if self.onlyVendorNotPaid is not None:
25144 
      oprot.writeFieldBegin('onlyVendorNotPaid', TType.BOOL, 2)
25145 
      oprot.writeBool(self.onlyVendorNotPaid)
25146 
      oprot.writeFieldEnd()
25147 
    if self.billingDateFrom is not None:
25148 
      oprot.writeFieldBegin('billingDateFrom', TType.I64, 3)
25149 
      oprot.writeI64(self.billingDateFrom)
25150 
      oprot.writeFieldEnd()
25151 
    if self.billingDateTo is not None:
25152 
      oprot.writeFieldBegin('billingDateTo', TType.I64, 4)
25153 
      oprot.writeI64(self.billingDateTo)
25154 
      oprot.writeFieldEnd()
4875 varun.gupt 25155 
    oprot.writeFieldStop()
25156 
    oprot.writeStructEnd()
25157 
 
25158 
  def validate(self):
25159 
    return
25160 
 
25161 
 
25162 
  def __repr__(self):
25163 
    L = ['%s=%r' % (key, value)
25164 
      for key, value in self.__dict__.iteritems()]
25165 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25166 
 
25167 
  def __eq__(self, other):
25168 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25169 
 
25170 
  def __ne__(self, other):
25171 
    return not (self == other)
25172 
 
5481 phani.kuma 25173 
class getBilledOrders_result:
4875 varun.gupt 25174 
  """
25175 
  Attributes:
25176 
   - success
25177 
   - ex
25178 
  """
25179 
 
25180 
  thrift_spec = (
25181 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
25182 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
25183 
  )
25184 
 
25185 
  def __init__(self, success=None, ex=None,):
25186 
    self.success = success
25187 
    self.ex = ex
25188 
 
25189 
  def read(self, iprot):
25190 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25191 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25192 
      return
25193 
    iprot.readStructBegin()
25194 
    while True:
25195 
      (fname, ftype, fid) = iprot.readFieldBegin()
25196 
      if ftype == TType.STOP:
25197 
        break
25198 
      if fid == 0:
25199 
        if ftype == TType.LIST:
25200 
          self.success = []
6188 rajveer 25201 
          (_etype587, _size584) = iprot.readListBegin()
25202 
          for _i588 in xrange(_size584):
25203 
            _elem589 = Order()
25204 
            _elem589.read(iprot)
25205 
            self.success.append(_elem589)
4875 varun.gupt 25206 
          iprot.readListEnd()
25207 
        else:
25208 
          iprot.skip(ftype)
25209 
      elif fid == 1:
25210 
        if ftype == TType.STRUCT:
25211 
          self.ex = TransactionServiceException()
25212 
          self.ex.read(iprot)
25213 
        else:
25214 
          iprot.skip(ftype)
25215 
      else:
25216 
        iprot.skip(ftype)
25217 
      iprot.readFieldEnd()
25218 
    iprot.readStructEnd()
25219 
 
25220 
  def write(self, oprot):
25221 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25222 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25223 
      return
5481 phani.kuma 25224 
    oprot.writeStructBegin('getBilledOrders_result')
4875 varun.gupt 25225 
    if self.success is not None:
25226 
      oprot.writeFieldBegin('success', TType.LIST, 0)
25227 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 25228 
      for iter590 in self.success:
25229 
        iter590.write(oprot)
4875 varun.gupt 25230 
      oprot.writeListEnd()
25231 
      oprot.writeFieldEnd()
25232 
    if self.ex is not None:
25233 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
25234 
      self.ex.write(oprot)
25235 
      oprot.writeFieldEnd()
25236 
    oprot.writeFieldStop()
25237 
    oprot.writeStructEnd()
25238 
 
25239 
  def validate(self):
25240 
    return
25241 
 
25242 
 
25243 
  def __repr__(self):
25244 
    L = ['%s=%r' % (key, value)
25245 
      for key, value in self.__dict__.iteritems()]
25246 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25247 
 
25248 
  def __eq__(self, other):
25249 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25250 
 
25251 
  def __ne__(self, other):
25252 
    return not (self == other)
5031 varun.gupt 25253 
 
25254 
class getStatusDistributionOfOrders_args:
25255 
  """
25256 
  Attributes:
25257 
   - startDate
25258 
   - endDate
25259 
  """
25260 
 
25261 
  thrift_spec = (
25262 
    None, # 0
25263 
    (1, TType.I64, 'startDate', None, None, ), # 1
25264 
    (2, TType.I64, 'endDate', None, None, ), # 2
25265 
  )
25266 
 
25267 
  def __init__(self, startDate=None, endDate=None,):
25268 
    self.startDate = startDate
25269 
    self.endDate = endDate
25270 
 
25271 
  def read(self, iprot):
25272 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25273 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25274 
      return
25275 
    iprot.readStructBegin()
25276 
    while True:
25277 
      (fname, ftype, fid) = iprot.readFieldBegin()
25278 
      if ftype == TType.STOP:
25279 
        break
25280 
      if fid == 1:
25281 
        if ftype == TType.I64:
25282 
          self.startDate = iprot.readI64();
25283 
        else:
25284 
          iprot.skip(ftype)
25285 
      elif fid == 2:
25286 
        if ftype == TType.I64:
25287 
          self.endDate = iprot.readI64();
25288 
        else:
25289 
          iprot.skip(ftype)
25290 
      else:
25291 
        iprot.skip(ftype)
25292 
      iprot.readFieldEnd()
25293 
    iprot.readStructEnd()
25294 
 
25295 
  def write(self, oprot):
25296 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25297 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25298 
      return
25299 
    oprot.writeStructBegin('getStatusDistributionOfOrders_args')
25300 
    if self.startDate is not None:
25301 
      oprot.writeFieldBegin('startDate', TType.I64, 1)
25302 
      oprot.writeI64(self.startDate)
25303 
      oprot.writeFieldEnd()
25304 
    if self.endDate is not None:
25305 
      oprot.writeFieldBegin('endDate', TType.I64, 2)
25306 
      oprot.writeI64(self.endDate)
25307 
      oprot.writeFieldEnd()
25308 
    oprot.writeFieldStop()
25309 
    oprot.writeStructEnd()
25310 
 
25311 
  def validate(self):
25312 
    return
25313 
 
25314 
 
25315 
  def __repr__(self):
25316 
    L = ['%s=%r' % (key, value)
25317 
      for key, value in self.__dict__.iteritems()]
25318 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25319 
 
25320 
  def __eq__(self, other):
25321 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25322 
 
25323 
  def __ne__(self, other):
25324 
    return not (self == other)
25325 
 
25326 
class getStatusDistributionOfOrders_result:
25327 
  """
25328 
  Attributes:
25329 
   - success
25330 
   - ex
25331 
  """
25332 
 
25333 
  thrift_spec = (
25334 
    (0, TType.MAP, 'success', (TType.I64,None,TType.I64,None), None, ), # 0
25335 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
25336 
  )
25337 
 
25338 
  def __init__(self, success=None, ex=None,):
25339 
    self.success = success
25340 
    self.ex = ex
25341 
 
25342 
  def read(self, iprot):
25343 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25344 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25345 
      return
25346 
    iprot.readStructBegin()
25347 
    while True:
25348 
      (fname, ftype, fid) = iprot.readFieldBegin()
25349 
      if ftype == TType.STOP:
25350 
        break
25351 
      if fid == 0:
25352 
        if ftype == TType.MAP:
25353 
          self.success = {}
6188 rajveer 25354 
          (_ktype592, _vtype593, _size591 ) = iprot.readMapBegin()
25355 
          for _i595 in xrange(_size591):
25356 
            _key596 = iprot.readI64();
25357 
            _val597 = iprot.readI64();
25358 
            self.success[_key596] = _val597
5031 varun.gupt 25359 
          iprot.readMapEnd()
25360 
        else:
25361 
          iprot.skip(ftype)
25362 
      elif fid == 1:
25363 
        if ftype == TType.STRUCT:
25364 
          self.ex = TransactionServiceException()
25365 
          self.ex.read(iprot)
25366 
        else:
25367 
          iprot.skip(ftype)
25368 
      else:
25369 
        iprot.skip(ftype)
25370 
      iprot.readFieldEnd()
25371 
    iprot.readStructEnd()
25372 
 
25373 
  def write(self, oprot):
25374 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25375 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25376 
      return
25377 
    oprot.writeStructBegin('getStatusDistributionOfOrders_result')
25378 
    if self.success is not None:
25379 
      oprot.writeFieldBegin('success', TType.MAP, 0)
25380 
      oprot.writeMapBegin(TType.I64, TType.I64, len(self.success))
6188 rajveer 25381 
      for kiter598,viter599 in self.success.items():
25382 
        oprot.writeI64(kiter598)
25383 
        oprot.writeI64(viter599)
5031 varun.gupt 25384 
      oprot.writeMapEnd()
25385 
      oprot.writeFieldEnd()
25386 
    if self.ex is not None:
25387 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
25388 
      self.ex.write(oprot)
25389 
      oprot.writeFieldEnd()
25390 
    oprot.writeFieldStop()
25391 
    oprot.writeStructEnd()
25392 
 
25393 
  def validate(self):
25394 
    return
25395 
 
25396 
 
25397 
  def __repr__(self):
25398 
    L = ['%s=%r' % (key, value)
25399 
      for key, value in self.__dict__.iteritems()]
25400 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25401 
 
25402 
  def __eq__(self, other):
25403 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25404 
 
25405 
  def __ne__(self, other):
25406 
    return not (self == other)
5067 varun.gupt 25407 
 
25408 
class getOrderIdsForStatus_args:
25409 
  """
25410 
  Attributes:
25411 
   - status
25412 
   - startDatetime
25413 
   - endDatetime
25414 
  """
25415 
 
25416 
  thrift_spec = (
25417 
    None, # 0
25418 
    (1, TType.I64, 'status', None, None, ), # 1
25419 
    (2, TType.I64, 'startDatetime', None, None, ), # 2
25420 
    (3, TType.I64, 'endDatetime', None, None, ), # 3
25421 
  )
25422 
 
25423 
  def __init__(self, status=None, startDatetime=None, endDatetime=None,):
25424 
    self.status = status
25425 
    self.startDatetime = startDatetime
25426 
    self.endDatetime = endDatetime
25427 
 
25428 
  def read(self, iprot):
25429 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25430 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25431 
      return
25432 
    iprot.readStructBegin()
25433 
    while True:
25434 
      (fname, ftype, fid) = iprot.readFieldBegin()
25435 
      if ftype == TType.STOP:
25436 
        break
25437 
      if fid == 1:
25438 
        if ftype == TType.I64:
25439 
          self.status = iprot.readI64();
25440 
        else:
25441 
          iprot.skip(ftype)
25442 
      elif fid == 2:
25443 
        if ftype == TType.I64:
25444 
          self.startDatetime = iprot.readI64();
25445 
        else:
25446 
          iprot.skip(ftype)
25447 
      elif fid == 3:
25448 
        if ftype == TType.I64:
25449 
          self.endDatetime = iprot.readI64();
25450 
        else:
25451 
          iprot.skip(ftype)
25452 
      else:
25453 
        iprot.skip(ftype)
25454 
      iprot.readFieldEnd()
25455 
    iprot.readStructEnd()
25456 
 
25457 
  def write(self, oprot):
25458 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25459 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25460 
      return
25461 
    oprot.writeStructBegin('getOrderIdsForStatus_args')
25462 
    if self.status is not None:
25463 
      oprot.writeFieldBegin('status', TType.I64, 1)
25464 
      oprot.writeI64(self.status)
25465 
      oprot.writeFieldEnd()
25466 
    if self.startDatetime is not None:
25467 
      oprot.writeFieldBegin('startDatetime', TType.I64, 2)
25468 
      oprot.writeI64(self.startDatetime)
25469 
      oprot.writeFieldEnd()
25470 
    if self.endDatetime is not None:
25471 
      oprot.writeFieldBegin('endDatetime', TType.I64, 3)
25472 
      oprot.writeI64(self.endDatetime)
25473 
      oprot.writeFieldEnd()
25474 
    oprot.writeFieldStop()
25475 
    oprot.writeStructEnd()
25476 
 
25477 
  def validate(self):
25478 
    return
25479 
 
25480 
 
25481 
  def __repr__(self):
25482 
    L = ['%s=%r' % (key, value)
25483 
      for key, value in self.__dict__.iteritems()]
25484 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25485 
 
25486 
  def __eq__(self, other):
25487 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25488 
 
25489 
  def __ne__(self, other):
25490 
    return not (self == other)
25491 
 
25492 
class getOrderIdsForStatus_result:
25493 
  """
25494 
  Attributes:
25495 
   - success
25496 
   - ex
25497 
  """
25498 
 
25499 
  thrift_spec = (
25500 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
25501 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
25502 
  )
25503 
 
25504 
  def __init__(self, success=None, ex=None,):
25505 
    self.success = success
25506 
    self.ex = ex
25507 
 
25508 
  def read(self, iprot):
25509 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25510 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25511 
      return
25512 
    iprot.readStructBegin()
25513 
    while True:
25514 
      (fname, ftype, fid) = iprot.readFieldBegin()
25515 
      if ftype == TType.STOP:
25516 
        break
25517 
      if fid == 0:
25518 
        if ftype == TType.LIST:
25519 
          self.success = []
6188 rajveer 25520 
          (_etype603, _size600) = iprot.readListBegin()
25521 
          for _i604 in xrange(_size600):
25522 
            _elem605 = iprot.readI64();
25523 
            self.success.append(_elem605)
5067 varun.gupt 25524 
          iprot.readListEnd()
25525 
        else:
25526 
          iprot.skip(ftype)
25527 
      elif fid == 1:
25528 
        if ftype == TType.STRUCT:
25529 
          self.ex = TransactionServiceException()
25530 
          self.ex.read(iprot)
25531 
        else:
25532 
          iprot.skip(ftype)
25533 
      else:
25534 
        iprot.skip(ftype)
25535 
      iprot.readFieldEnd()
25536 
    iprot.readStructEnd()
25537 
 
25538 
  def write(self, oprot):
25539 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25540 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25541 
      return
25542 
    oprot.writeStructBegin('getOrderIdsForStatus_result')
25543 
    if self.success is not None:
25544 
      oprot.writeFieldBegin('success', TType.LIST, 0)
25545 
      oprot.writeListBegin(TType.I64, len(self.success))
6188 rajveer 25546 
      for iter606 in self.success:
25547 
        oprot.writeI64(iter606)
5067 varun.gupt 25548 
      oprot.writeListEnd()
25549 
      oprot.writeFieldEnd()
25550 
    if self.ex is not None:
25551 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
25552 
      self.ex.write(oprot)
25553 
      oprot.writeFieldEnd()
25554 
    oprot.writeFieldStop()
25555 
    oprot.writeStructEnd()
25556 
 
25557 
  def validate(self):
25558 
    return
25559 
 
25560 
 
25561 
  def __repr__(self):
25562 
    L = ['%s=%r' % (key, value)
25563 
      for key, value in self.__dict__.iteritems()]
25564 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25565 
 
25566 
  def __eq__(self, other):
25567 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25568 
 
25569 
  def __ne__(self, other):
25570 
    return not (self == other)
5099 varun.gupt 25571 
 
5348 anupam.sin 25572 
class updateCODAgent_args:
25573 
  """
25574 
  Attributes:
25575 
   - agent
25576 
   - orderId
25577 
  """
25578 
 
25579 
  thrift_spec = (
25580 
    None, # 0
25581 
    (1, TType.STRING, 'agent', None, None, ), # 1
25582 
    (2, TType.I64, 'orderId', None, None, ), # 2
25583 
  )
25584 
 
25585 
  def __init__(self, agent=None, orderId=None,):
25586 
    self.agent = agent
25587 
    self.orderId = orderId
25588 
 
25589 
  def read(self, iprot):
25590 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25591 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25592 
      return
25593 
    iprot.readStructBegin()
25594 
    while True:
25595 
      (fname, ftype, fid) = iprot.readFieldBegin()
25596 
      if ftype == TType.STOP:
25597 
        break
25598 
      if fid == 1:
25599 
        if ftype == TType.STRING:
25600 
          self.agent = iprot.readString();
25601 
        else:
25602 
          iprot.skip(ftype)
25603 
      elif fid == 2:
25604 
        if ftype == TType.I64:
25605 
          self.orderId = iprot.readI64();
25606 
        else:
25607 
          iprot.skip(ftype)
25608 
      else:
25609 
        iprot.skip(ftype)
25610 
      iprot.readFieldEnd()
25611 
    iprot.readStructEnd()
25612 
 
25613 
  def write(self, oprot):
25614 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25615 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25616 
      return
25617 
    oprot.writeStructBegin('updateCODAgent_args')
25618 
    if self.agent is not None:
25619 
      oprot.writeFieldBegin('agent', TType.STRING, 1)
25620 
      oprot.writeString(self.agent)
25621 
      oprot.writeFieldEnd()
25622 
    if self.orderId is not None:
25623 
      oprot.writeFieldBegin('orderId', TType.I64, 2)
25624 
      oprot.writeI64(self.orderId)
25625 
      oprot.writeFieldEnd()
25626 
    oprot.writeFieldStop()
25627 
    oprot.writeStructEnd()
25628 
 
25629 
  def validate(self):
25630 
    return
25631 
 
25632 
 
25633 
  def __repr__(self):
25634 
    L = ['%s=%r' % (key, value)
25635 
      for key, value in self.__dict__.iteritems()]
25636 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25637 
 
25638 
  def __eq__(self, other):
25639 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25640 
 
25641 
  def __ne__(self, other):
25642 
    return not (self == other)
25643 
 
25644 
class updateCODAgent_result:
25645 
  """
25646 
  Attributes:
25647 
   - ex
25648 
  """
25649 
 
25650 
  thrift_spec = (
25651 
    None, # 0
25652 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
25653 
  )
25654 
 
25655 
  def __init__(self, ex=None,):
25656 
    self.ex = ex
25657 
 
25658 
  def read(self, iprot):
25659 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25660 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25661 
      return
25662 
    iprot.readStructBegin()
25663 
    while True:
25664 
      (fname, ftype, fid) = iprot.readFieldBegin()
25665 
      if ftype == TType.STOP:
25666 
        break
25667 
      if fid == 1:
25668 
        if ftype == TType.STRUCT:
25669 
          self.ex = TransactionServiceException()
25670 
          self.ex.read(iprot)
25671 
        else:
25672 
          iprot.skip(ftype)
25673 
      else:
25674 
        iprot.skip(ftype)
25675 
      iprot.readFieldEnd()
25676 
    iprot.readStructEnd()
25677 
 
25678 
  def write(self, oprot):
25679 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25680 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25681 
      return
25682 
    oprot.writeStructBegin('updateCODAgent_result')
25683 
    if self.ex is not None:
25684 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
25685 
      self.ex.write(oprot)
25686 
      oprot.writeFieldEnd()
25687 
    oprot.writeFieldStop()
25688 
    oprot.writeStructEnd()
25689 
 
25690 
  def validate(self):
25691 
    return
25692 
 
25693 
 
25694 
  def __repr__(self):
25695 
    L = ['%s=%r' % (key, value)
25696 
      for key, value in self.__dict__.iteritems()]
25697 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25698 
 
25699 
  def __eq__(self, other):
25700 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25701 
 
25702 
  def __ne__(self, other):
25703 
    return not (self == other)
25704 
 
5099 varun.gupt 25705 
class updateOrderAsPaidToVendor_args:
25706 
  """
25707 
  Attributes:
25708 
   - orderId
25709 
  """
25710 
 
25711 
  thrift_spec = (
25712 
    None, # 0
25713 
    (1, TType.I64, 'orderId', None, None, ), # 1
25714 
  )
25715 
 
25716 
  def __init__(self, orderId=None,):
25717 
    self.orderId = orderId
25718 
 
25719 
  def read(self, iprot):
25720 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25721 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25722 
      return
25723 
    iprot.readStructBegin()
25724 
    while True:
25725 
      (fname, ftype, fid) = iprot.readFieldBegin()
25726 
      if ftype == TType.STOP:
25727 
        break
25728 
      if fid == 1:
25729 
        if ftype == TType.I64:
25730 
          self.orderId = iprot.readI64();
25731 
        else:
25732 
          iprot.skip(ftype)
25733 
      else:
25734 
        iprot.skip(ftype)
25735 
      iprot.readFieldEnd()
25736 
    iprot.readStructEnd()
25737 
 
25738 
  def write(self, oprot):
25739 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25740 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25741 
      return
25742 
    oprot.writeStructBegin('updateOrderAsPaidToVendor_args')
25743 
    if self.orderId is not None:
25744 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
25745 
      oprot.writeI64(self.orderId)
25746 
      oprot.writeFieldEnd()
25747 
    oprot.writeFieldStop()
25748 
    oprot.writeStructEnd()
25749 
 
25750 
  def validate(self):
25751 
    return
25752 
 
25753 
 
25754 
  def __repr__(self):
25755 
    L = ['%s=%r' % (key, value)
25756 
      for key, value in self.__dict__.iteritems()]
25757 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25758 
 
25759 
  def __eq__(self, other):
25760 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25761 
 
25762 
  def __ne__(self, other):
25763 
    return not (self == other)
25764 
 
25765 
class updateOrderAsPaidToVendor_result:
25766 
  """
25767 
  Attributes:
25768 
   - ex
25769 
  """
25770 
 
25771 
  thrift_spec = (
25772 
    None, # 0
25773 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
25774 
  )
25775 
 
25776 
  def __init__(self, ex=None,):
25777 
    self.ex = ex
25778 
 
25779 
  def read(self, iprot):
25780 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25781 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25782 
      return
25783 
    iprot.readStructBegin()
25784 
    while True:
25785 
      (fname, ftype, fid) = iprot.readFieldBegin()
25786 
      if ftype == TType.STOP:
25787 
        break
25788 
      if fid == 1:
25789 
        if ftype == TType.STRUCT:
25790 
          self.ex = TransactionServiceException()
25791 
          self.ex.read(iprot)
25792 
        else:
25793 
          iprot.skip(ftype)
25794 
      else:
25795 
        iprot.skip(ftype)
25796 
      iprot.readFieldEnd()
25797 
    iprot.readStructEnd()
25798 
 
25799 
  def write(self, oprot):
25800 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25801 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25802 
      return
25803 
    oprot.writeStructBegin('updateOrderAsPaidToVendor_result')
25804 
    if self.ex is not None:
25805 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
25806 
      self.ex.write(oprot)
25807 
      oprot.writeFieldEnd()
25808 
    oprot.writeFieldStop()
25809 
    oprot.writeStructEnd()
25810 
 
25811 
  def validate(self):
25812 
    return
25813 
 
25814 
 
25815 
  def __repr__(self):
25816 
    L = ['%s=%r' % (key, value)
25817 
      for key, value in self.__dict__.iteritems()]
25818 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25819 
 
25820 
  def __eq__(self, other):
25821 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25822 
 
25823 
  def __ne__(self, other):
25824 
    return not (self == other)
5208 varun.gupt 25825 
 
5386 phani.kuma 25826 
class updateOrderOnlyAsPaidToVendor_args:
25827 
  """
25828 
  Attributes:
25829 
   - orderId
25830 
  """
25831 
 
25832 
  thrift_spec = (
25833 
    None, # 0
25834 
    (1, TType.I64, 'orderId', None, None, ), # 1
25835 
  )
25836 
 
25837 
  def __init__(self, orderId=None,):
25838 
    self.orderId = orderId
25839 
 
25840 
  def read(self, iprot):
25841 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25842 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25843 
      return
25844 
    iprot.readStructBegin()
25845 
    while True:
25846 
      (fname, ftype, fid) = iprot.readFieldBegin()
25847 
      if ftype == TType.STOP:
25848 
        break
25849 
      if fid == 1:
25850 
        if ftype == TType.I64:
25851 
          self.orderId = iprot.readI64();
25852 
        else:
25853 
          iprot.skip(ftype)
25854 
      else:
25855 
        iprot.skip(ftype)
25856 
      iprot.readFieldEnd()
25857 
    iprot.readStructEnd()
25858 
 
25859 
  def write(self, oprot):
25860 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25861 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25862 
      return
25863 
    oprot.writeStructBegin('updateOrderOnlyAsPaidToVendor_args')
25864 
    if self.orderId is not None:
25865 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
25866 
      oprot.writeI64(self.orderId)
25867 
      oprot.writeFieldEnd()
25868 
    oprot.writeFieldStop()
25869 
    oprot.writeStructEnd()
25870 
 
25871 
  def validate(self):
25872 
    return
25873 
 
25874 
 
25875 
  def __repr__(self):
25876 
    L = ['%s=%r' % (key, value)
25877 
      for key, value in self.__dict__.iteritems()]
25878 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25879 
 
25880 
  def __eq__(self, other):
25881 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25882 
 
25883 
  def __ne__(self, other):
25884 
    return not (self == other)
25885 
 
25886 
class updateOrderOnlyAsPaidToVendor_result:
25887 
  """
25888 
  Attributes:
25889 
   - ex
25890 
  """
25891 
 
25892 
  thrift_spec = (
25893 
    None, # 0
25894 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
25895 
  )
25896 
 
25897 
  def __init__(self, ex=None,):
25898 
    self.ex = ex
25899 
 
25900 
  def read(self, iprot):
25901 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25902 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25903 
      return
25904 
    iprot.readStructBegin()
25905 
    while True:
25906 
      (fname, ftype, fid) = iprot.readFieldBegin()
25907 
      if ftype == TType.STOP:
25908 
        break
25909 
      if fid == 1:
25910 
        if ftype == TType.STRUCT:
25911 
          self.ex = TransactionServiceException()
25912 
          self.ex.read(iprot)
25913 
        else:
25914 
          iprot.skip(ftype)
25915 
      else:
25916 
        iprot.skip(ftype)
25917 
      iprot.readFieldEnd()
25918 
    iprot.readStructEnd()
25919 
 
25920 
  def write(self, oprot):
25921 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25922 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25923 
      return
25924 
    oprot.writeStructBegin('updateOrderOnlyAsPaidToVendor_result')
25925 
    if self.ex is not None:
25926 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
25927 
      self.ex.write(oprot)
25928 
      oprot.writeFieldEnd()
25929 
    oprot.writeFieldStop()
25930 
    oprot.writeStructEnd()
25931 
 
25932 
  def validate(self):
25933 
    return
25934 
 
25935 
 
25936 
  def __repr__(self):
25937 
    L = ['%s=%r' % (key, value)
25938 
      for key, value in self.__dict__.iteritems()]
25939 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25940 
 
25941 
  def __eq__(self, other):
25942 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25943 
 
25944 
  def __ne__(self, other):
25945 
    return not (self == other)
25946 
 
5208 varun.gupt 25947 
class getRefundedOrdersMarkedPaid_args:
25948 
 
25949 
  thrift_spec = (
25950 
  )
25951 
 
25952 
  def read(self, iprot):
25953 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25954 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25955 
      return
25956 
    iprot.readStructBegin()
25957 
    while True:
25958 
      (fname, ftype, fid) = iprot.readFieldBegin()
25959 
      if ftype == TType.STOP:
25960 
        break
25961 
      else:
25962 
        iprot.skip(ftype)
25963 
      iprot.readFieldEnd()
25964 
    iprot.readStructEnd()
25965 
 
25966 
  def write(self, oprot):
25967 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25968 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25969 
      return
25970 
    oprot.writeStructBegin('getRefundedOrdersMarkedPaid_args')
25971 
    oprot.writeFieldStop()
25972 
    oprot.writeStructEnd()
25973 
 
25974 
  def validate(self):
25975 
    return
25976 
 
25977 
 
25978 
  def __repr__(self):
25979 
    L = ['%s=%r' % (key, value)
25980 
      for key, value in self.__dict__.iteritems()]
25981 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25982 
 
25983 
  def __eq__(self, other):
25984 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25985 
 
25986 
  def __ne__(self, other):
25987 
    return not (self == other)
25988 
 
25989 
class getRefundedOrdersMarkedPaid_result:
25990 
  """
25991 
  Attributes:
25992 
   - success
25993 
   - ex
25994 
  """
25995 
 
25996 
  thrift_spec = (
25997 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
25998 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
25999 
  )
26000 
 
26001 
  def __init__(self, success=None, ex=None,):
26002 
    self.success = success
26003 
    self.ex = ex
26004 
 
26005 
  def read(self, iprot):
26006 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26007 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26008 
      return
26009 
    iprot.readStructBegin()
26010 
    while True:
26011 
      (fname, ftype, fid) = iprot.readFieldBegin()
26012 
      if ftype == TType.STOP:
26013 
        break
26014 
      if fid == 0:
26015 
        if ftype == TType.LIST:
26016 
          self.success = []
6188 rajveer 26017 
          (_etype610, _size607) = iprot.readListBegin()
26018 
          for _i611 in xrange(_size607):
26019 
            _elem612 = Order()
26020 
            _elem612.read(iprot)
26021 
            self.success.append(_elem612)
5208 varun.gupt 26022 
          iprot.readListEnd()
26023 
        else:
26024 
          iprot.skip(ftype)
26025 
      elif fid == 1:
26026 
        if ftype == TType.STRUCT:
26027 
          self.ex = TransactionServiceException()
26028 
          self.ex.read(iprot)
26029 
        else:
26030 
          iprot.skip(ftype)
26031 
      else:
26032 
        iprot.skip(ftype)
26033 
      iprot.readFieldEnd()
26034 
    iprot.readStructEnd()
26035 
 
26036 
  def write(self, oprot):
26037 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26038 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26039 
      return
26040 
    oprot.writeStructBegin('getRefundedOrdersMarkedPaid_result')
26041 
    if self.success is not None:
26042 
      oprot.writeFieldBegin('success', TType.LIST, 0)
26043 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 26044 
      for iter613 in self.success:
26045 
        iter613.write(oprot)
5208 varun.gupt 26046 
      oprot.writeListEnd()
26047 
      oprot.writeFieldEnd()
26048 
    if self.ex is not None:
26049 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
26050 
      self.ex.write(oprot)
26051 
      oprot.writeFieldEnd()
26052 
    oprot.writeFieldStop()
26053 
    oprot.writeStructEnd()
26054 
 
26055 
  def validate(self):
26056 
    return
26057 
 
26058 
 
26059 
  def __repr__(self):
26060 
    L = ['%s=%r' % (key, value)
26061 
      for key, value in self.__dict__.iteritems()]
26062 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26063 
 
26064 
  def __eq__(self, other):
26065 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26066 
 
26067 
  def __ne__(self, other):
26068 
    return not (self == other)
5447 anupam.sin 26069 
 
26070 
class getAllVerificationAgents_args:
26071 
  """
26072 
  Attributes:
26073 
   - minOrderId
26074 
   - maxOrderId
26075 
  """
26076 
 
26077 
  thrift_spec = (
26078 
    None, # 0
26079 
    (1, TType.I64, 'minOrderId', None, None, ), # 1
26080 
    (2, TType.I64, 'maxOrderId', None, None, ), # 2
26081 
  )
26082 
 
26083 
  def __init__(self, minOrderId=None, maxOrderId=None,):
26084 
    self.minOrderId = minOrderId
26085 
    self.maxOrderId = maxOrderId
26086 
 
26087 
  def read(self, iprot):
26088 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26089 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26090 
      return
26091 
    iprot.readStructBegin()
26092 
    while True:
26093 
      (fname, ftype, fid) = iprot.readFieldBegin()
26094 
      if ftype == TType.STOP:
26095 
        break
26096 
      if fid == 1:
26097 
        if ftype == TType.I64:
26098 
          self.minOrderId = iprot.readI64();
26099 
        else:
26100 
          iprot.skip(ftype)
26101 
      elif fid == 2:
26102 
        if ftype == TType.I64:
26103 
          self.maxOrderId = iprot.readI64();
26104 
        else:
26105 
          iprot.skip(ftype)
26106 
      else:
26107 
        iprot.skip(ftype)
26108 
      iprot.readFieldEnd()
26109 
    iprot.readStructEnd()
26110 
 
26111 
  def write(self, oprot):
26112 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26113 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26114 
      return
26115 
    oprot.writeStructBegin('getAllVerificationAgents_args')
26116 
    if self.minOrderId is not None:
26117 
      oprot.writeFieldBegin('minOrderId', TType.I64, 1)
26118 
      oprot.writeI64(self.minOrderId)
26119 
      oprot.writeFieldEnd()
26120 
    if self.maxOrderId is not None:
26121 
      oprot.writeFieldBegin('maxOrderId', TType.I64, 2)
26122 
      oprot.writeI64(self.maxOrderId)
26123 
      oprot.writeFieldEnd()
26124 
    oprot.writeFieldStop()
26125 
    oprot.writeStructEnd()
26126 
 
26127 
  def validate(self):
26128 
    return
26129 
 
26130 
 
26131 
  def __repr__(self):
26132 
    L = ['%s=%r' % (key, value)
26133 
      for key, value in self.__dict__.iteritems()]
26134 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26135 
 
26136 
  def __eq__(self, other):
26137 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26138 
 
26139 
  def __ne__(self, other):
26140 
    return not (self == other)
26141 
 
26142 
class getAllVerificationAgents_result:
26143 
  """
26144 
  Attributes:
26145 
   - success
26146 
  """
26147 
 
26148 
  thrift_spec = (
26149 
    (0, TType.LIST, 'success', (TType.STRUCT,(CODVerificationAgent, CODVerificationAgent.thrift_spec)), None, ), # 0
26150 
  )
26151 
 
26152 
  def __init__(self, success=None,):
26153 
    self.success = success
26154 
 
26155 
  def read(self, iprot):
26156 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26157 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26158 
      return
26159 
    iprot.readStructBegin()
26160 
    while True:
26161 
      (fname, ftype, fid) = iprot.readFieldBegin()
26162 
      if ftype == TType.STOP:
26163 
        break
26164 
      if fid == 0:
26165 
        if ftype == TType.LIST:
26166 
          self.success = []
6188 rajveer 26167 
          (_etype617, _size614) = iprot.readListBegin()
26168 
          for _i618 in xrange(_size614):
26169 
            _elem619 = CODVerificationAgent()
26170 
            _elem619.read(iprot)
26171 
            self.success.append(_elem619)
5447 anupam.sin 26172 
          iprot.readListEnd()
26173 
        else:
26174 
          iprot.skip(ftype)
26175 
      else:
26176 
        iprot.skip(ftype)
26177 
      iprot.readFieldEnd()
26178 
    iprot.readStructEnd()
26179 
 
26180 
  def write(self, oprot):
26181 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26182 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26183 
      return
26184 
    oprot.writeStructBegin('getAllVerificationAgents_result')
26185 
    if self.success is not None:
26186 
      oprot.writeFieldBegin('success', TType.LIST, 0)
26187 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 26188 
      for iter620 in self.success:
26189 
        iter620.write(oprot)
5447 anupam.sin 26190 
      oprot.writeListEnd()
26191 
      oprot.writeFieldEnd()
26192 
    oprot.writeFieldStop()
26193 
    oprot.writeStructEnd()
26194 
 
26195 
  def validate(self):
26196 
    return
26197 
 
26198 
 
26199 
  def __repr__(self):
26200 
    L = ['%s=%r' % (key, value)
26201 
      for key, value in self.__dict__.iteritems()]
26202 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26203 
 
26204 
  def __eq__(self, other):
26205 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26206 
 
26207 
  def __ne__(self, other):
26208 
    return not (self == other)
5527 anupam.sin 26209 
 
26210 
class getAllAttributesForOrderId_args:
26211 
  """
26212 
  Attributes:
26213 
   - orderId
26214 
  """
26215 
 
26216 
  thrift_spec = (
26217 
    None, # 0
26218 
    (1, TType.I64, 'orderId', None, None, ), # 1
26219 
  )
26220 
 
26221 
  def __init__(self, orderId=None,):
26222 
    self.orderId = orderId
26223 
 
26224 
  def read(self, iprot):
26225 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26226 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26227 
      return
26228 
    iprot.readStructBegin()
26229 
    while True:
26230 
      (fname, ftype, fid) = iprot.readFieldBegin()
26231 
      if ftype == TType.STOP:
26232 
        break
26233 
      if fid == 1:
26234 
        if ftype == TType.I64:
26235 
          self.orderId = iprot.readI64();
26236 
        else:
26237 
          iprot.skip(ftype)
26238 
      else:
26239 
        iprot.skip(ftype)
26240 
      iprot.readFieldEnd()
26241 
    iprot.readStructEnd()
26242 
 
26243 
  def write(self, oprot):
26244 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26245 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26246 
      return
26247 
    oprot.writeStructBegin('getAllAttributesForOrderId_args')
26248 
    if self.orderId is not None:
26249 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
26250 
      oprot.writeI64(self.orderId)
26251 
      oprot.writeFieldEnd()
26252 
    oprot.writeFieldStop()
26253 
    oprot.writeStructEnd()
26254 
 
26255 
  def validate(self):
26256 
    return
26257 
 
26258 
 
26259 
  def __repr__(self):
26260 
    L = ['%s=%r' % (key, value)
26261 
      for key, value in self.__dict__.iteritems()]
26262 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26263 
 
26264 
  def __eq__(self, other):
26265 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26266 
 
26267 
  def __ne__(self, other):
26268 
    return not (self == other)
26269 
 
26270 
class getAllAttributesForOrderId_result:
26271 
  """
26272 
  Attributes:
26273 
   - success
26274 
  """
26275 
 
26276 
  thrift_spec = (
26277 
    (0, TType.LIST, 'success', (TType.STRUCT,(Attribute, Attribute.thrift_spec)), None, ), # 0
26278 
  )
26279 
 
26280 
  def __init__(self, success=None,):
26281 
    self.success = success
26282 
 
26283 
  def read(self, iprot):
26284 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26285 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26286 
      return
26287 
    iprot.readStructBegin()
26288 
    while True:
26289 
      (fname, ftype, fid) = iprot.readFieldBegin()
26290 
      if ftype == TType.STOP:
26291 
        break
26292 
      if fid == 0:
26293 
        if ftype == TType.LIST:
26294 
          self.success = []
6188 rajveer 26295 
          (_etype624, _size621) = iprot.readListBegin()
26296 
          for _i625 in xrange(_size621):
26297 
            _elem626 = Attribute()
26298 
            _elem626.read(iprot)
26299 
            self.success.append(_elem626)
5527 anupam.sin 26300 
          iprot.readListEnd()
26301 
        else:
26302 
          iprot.skip(ftype)
26303 
      else:
26304 
        iprot.skip(ftype)
26305 
      iprot.readFieldEnd()
26306 
    iprot.readStructEnd()
26307 
 
26308 
  def write(self, oprot):
26309 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26310 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26311 
      return
26312 
    oprot.writeStructBegin('getAllAttributesForOrderId_result')
26313 
    if self.success is not None:
26314 
      oprot.writeFieldBegin('success', TType.LIST, 0)
26315 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 26316 
      for iter627 in self.success:
26317 
        iter627.write(oprot)
5527 anupam.sin 26318 
      oprot.writeListEnd()
26319 
      oprot.writeFieldEnd()
26320 
    oprot.writeFieldStop()
26321 
    oprot.writeStructEnd()
26322 
 
26323 
  def validate(self):
26324 
    return
26325 
 
26326 
 
26327 
  def __repr__(self):
26328 
    L = ['%s=%r' % (key, value)
26329 
      for key, value in self.__dict__.iteritems()]
26330 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26331 
 
26332 
  def __eq__(self, other):
26333 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26334 
 
26335 
  def __ne__(self, other):
26336 
    return not (self == other)
26337 
 
5676 rajveer 26338 
class setOrderAttributes_args:
26339 
  """
26340 
  Attributes:
26341 
   - orderId
26342 
   - attributes
26343 
  """
26344 
 
26345 
  thrift_spec = None
26346 
  def __init__(self, orderId=None, attributes=None,):
26347 
    self.orderId = orderId
26348 
    self.attributes = attributes
26349 
 
26350 
  def read(self, iprot):
26351 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26352 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26353 
      return
26354 
    iprot.readStructBegin()
26355 
    while True:
26356 
      (fname, ftype, fid) = iprot.readFieldBegin()
26357 
      if ftype == TType.STOP:
26358 
        break
26359 
      if fid == 1:
26360 
        if ftype == TType.I64:
26361 
          self.orderId = iprot.readI64();
26362 
        else:
26363 
          iprot.skip(ftype)
26364 
      elif fid == -1:
26365 
        if ftype == TType.LIST:
26366 
          self.attributes = []
6188 rajveer 26367 
          (_etype631, _size628) = iprot.readListBegin()
26368 
          for _i632 in xrange(_size628):
26369 
            _elem633 = Attribute()
26370 
            _elem633.read(iprot)
26371 
            self.attributes.append(_elem633)
5676 rajveer 26372 
          iprot.readListEnd()
26373 
        else:
26374 
          iprot.skip(ftype)
26375 
      else:
26376 
        iprot.skip(ftype)
26377 
      iprot.readFieldEnd()
26378 
    iprot.readStructEnd()
26379 
 
26380 
  def write(self, oprot):
26381 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26382 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26383 
      return
26384 
    oprot.writeStructBegin('setOrderAttributes_args')
26385 
    if self.attributes is not None:
26386 
      oprot.writeFieldBegin('attributes', TType.LIST, -1)
26387 
      oprot.writeListBegin(TType.STRUCT, len(self.attributes))
6188 rajveer 26388 
      for iter634 in self.attributes:
26389 
        iter634.write(oprot)
5676 rajveer 26390 
      oprot.writeListEnd()
26391 
      oprot.writeFieldEnd()
26392 
    if self.orderId is not None:
26393 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
26394 
      oprot.writeI64(self.orderId)
26395 
      oprot.writeFieldEnd()
26396 
    oprot.writeFieldStop()
26397 
    oprot.writeStructEnd()
26398 
 
26399 
  def validate(self):
26400 
    return
26401 
 
26402 
 
26403 
  def __repr__(self):
26404 
    L = ['%s=%r' % (key, value)
26405 
      for key, value in self.__dict__.iteritems()]
26406 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26407 
 
26408 
  def __eq__(self, other):
26409 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26410 
 
26411 
  def __ne__(self, other):
26412 
    return not (self == other)
26413 
 
26414 
class setOrderAttributes_result:
26415 
 
26416 
  thrift_spec = (
26417 
  )
26418 
 
26419 
  def read(self, iprot):
26420 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26421 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26422 
      return
26423 
    iprot.readStructBegin()
26424 
    while True:
26425 
      (fname, ftype, fid) = iprot.readFieldBegin()
26426 
      if ftype == TType.STOP:
26427 
        break
26428 
      else:
26429 
        iprot.skip(ftype)
26430 
      iprot.readFieldEnd()
26431 
    iprot.readStructEnd()
26432 
 
26433 
  def write(self, oprot):
26434 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26435 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26436 
      return
26437 
    oprot.writeStructBegin('setOrderAttributes_result')
26438 
    oprot.writeFieldStop()
26439 
    oprot.writeStructEnd()
26440 
 
26441 
  def validate(self):
26442 
    return
26443 
 
26444 
 
26445 
  def __repr__(self):
26446 
    L = ['%s=%r' % (key, value)
26447 
      for key, value in self.__dict__.iteritems()]
26448 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26449 
 
26450 
  def __eq__(self, other):
26451 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26452 
 
26453 
  def __ne__(self, other):
26454 
    return not (self == other)
26455 
 
5527 anupam.sin 26456 
class setOrderAttributeForTransaction_args:
26457 
  """
26458 
  Attributes:
26459 
   - transactionId
26460 
   - attribute
26461 
  """
26462 
 
26463 
  thrift_spec = None
26464 
  def __init__(self, transactionId=None, attribute=None,):
26465 
    self.transactionId = transactionId
26466 
    self.attribute = attribute
26467 
 
26468 
  def read(self, iprot):
26469 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26470 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26471 
      return
26472 
    iprot.readStructBegin()
26473 
    while True:
26474 
      (fname, ftype, fid) = iprot.readFieldBegin()
26475 
      if ftype == TType.STOP:
26476 
        break
26477 
      if fid == 1:
26478 
        if ftype == TType.I64:
26479 
          self.transactionId = iprot.readI64();
26480 
        else:
26481 
          iprot.skip(ftype)
26482 
      elif fid == -1:
26483 
        if ftype == TType.STRUCT:
26484 
          self.attribute = Attribute()
26485 
          self.attribute.read(iprot)
26486 
        else:
26487 
          iprot.skip(ftype)
26488 
      else:
26489 
        iprot.skip(ftype)
26490 
      iprot.readFieldEnd()
26491 
    iprot.readStructEnd()
26492 
 
26493 
  def write(self, oprot):
26494 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26495 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26496 
      return
26497 
    oprot.writeStructBegin('setOrderAttributeForTransaction_args')
26498 
    if self.attribute is not None:
26499 
      oprot.writeFieldBegin('attribute', TType.STRUCT, -1)
26500 
      self.attribute.write(oprot)
26501 
      oprot.writeFieldEnd()
26502 
    if self.transactionId is not None:
26503 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
26504 
      oprot.writeI64(self.transactionId)
26505 
      oprot.writeFieldEnd()
26506 
    oprot.writeFieldStop()
26507 
    oprot.writeStructEnd()
26508 
 
26509 
  def validate(self):
26510 
    return
26511 
 
26512 
 
26513 
  def __repr__(self):
26514 
    L = ['%s=%r' % (key, value)
26515 
      for key, value in self.__dict__.iteritems()]
26516 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26517 
 
26518 
  def __eq__(self, other):
26519 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26520 
 
26521 
  def __ne__(self, other):
26522 
    return not (self == other)
26523 
 
26524 
class setOrderAttributeForTransaction_result:
26525 
 
26526 
  thrift_spec = (
26527 
  )
26528 
 
26529 
  def read(self, iprot):
26530 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26531 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26532 
      return
26533 
    iprot.readStructBegin()
26534 
    while True:
26535 
      (fname, ftype, fid) = iprot.readFieldBegin()
26536 
      if ftype == TType.STOP:
26537 
        break
26538 
      else:
26539 
        iprot.skip(ftype)
26540 
      iprot.readFieldEnd()
26541 
    iprot.readStructEnd()
26542 
 
26543 
  def write(self, oprot):
26544 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26545 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26546 
      return
26547 
    oprot.writeStructBegin('setOrderAttributeForTransaction_result')
26548 
    oprot.writeFieldStop()
26549 
    oprot.writeStructEnd()
26550 
 
26551 
  def validate(self):
26552 
    return
26553 
 
26554 
 
26555 
  def __repr__(self):
26556 
    L = ['%s=%r' % (key, value)
26557 
      for key, value in self.__dict__.iteritems()]
26558 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26559 
 
26560 
  def __eq__(self, other):
26561 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26562 
 
26563 
  def __ne__(self, other):
26564 
    return not (self == other)
5553 rajveer 26565 
 
26566 
class getReceivePendingOrders_args:
26567 
  """
26568 
  Attributes:
26569 
   - storeId
26570 
  """
26571 
 
26572 
  thrift_spec = (
26573 
    None, # 0
26574 
    (1, TType.I64, 'storeId', None, None, ), # 1
26575 
  )
26576 
 
26577 
  def __init__(self, storeId=None,):
26578 
    self.storeId = storeId
26579 
 
26580 
  def read(self, iprot):
26581 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26582 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26583 
      return
26584 
    iprot.readStructBegin()
26585 
    while True:
26586 
      (fname, ftype, fid) = iprot.readFieldBegin()
26587 
      if ftype == TType.STOP:
26588 
        break
26589 
      if fid == 1:
26590 
        if ftype == TType.I64:
26591 
          self.storeId = iprot.readI64();
26592 
        else:
26593 
          iprot.skip(ftype)
26594 
      else:
26595 
        iprot.skip(ftype)
26596 
      iprot.readFieldEnd()
26597 
    iprot.readStructEnd()
26598 
 
26599 
  def write(self, oprot):
26600 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26601 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26602 
      return
26603 
    oprot.writeStructBegin('getReceivePendingOrders_args')
26604 
    if self.storeId is not None:
26605 
      oprot.writeFieldBegin('storeId', TType.I64, 1)
26606 
      oprot.writeI64(self.storeId)
26607 
      oprot.writeFieldEnd()
26608 
    oprot.writeFieldStop()
26609 
    oprot.writeStructEnd()
26610 
 
26611 
  def validate(self):
26612 
    return
26613 
 
26614 
 
26615 
  def __repr__(self):
26616 
    L = ['%s=%r' % (key, value)
26617 
      for key, value in self.__dict__.iteritems()]
26618 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26619 
 
26620 
  def __eq__(self, other):
26621 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26622 
 
26623 
  def __ne__(self, other):
26624 
    return not (self == other)
26625 
 
26626 
class getReceivePendingOrders_result:
26627 
  """
26628 
  Attributes:
26629 
   - success
26630 
  """
26631 
 
26632 
  thrift_spec = (
26633 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
26634 
  )
26635 
 
26636 
  def __init__(self, success=None,):
26637 
    self.success = success
26638 
 
26639 
  def read(self, iprot):
26640 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26641 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26642 
      return
26643 
    iprot.readStructBegin()
26644 
    while True:
26645 
      (fname, ftype, fid) = iprot.readFieldBegin()
26646 
      if ftype == TType.STOP:
26647 
        break
26648 
      if fid == 0:
26649 
        if ftype == TType.LIST:
26650 
          self.success = []
6188 rajveer 26651 
          (_etype638, _size635) = iprot.readListBegin()
26652 
          for _i639 in xrange(_size635):
26653 
            _elem640 = Order()
26654 
            _elem640.read(iprot)
26655 
            self.success.append(_elem640)
5553 rajveer 26656 
          iprot.readListEnd()
26657 
        else:
26658 
          iprot.skip(ftype)
26659 
      else:
26660 
        iprot.skip(ftype)
26661 
      iprot.readFieldEnd()
26662 
    iprot.readStructEnd()
26663 
 
26664 
  def write(self, oprot):
26665 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26666 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26667 
      return
26668 
    oprot.writeStructBegin('getReceivePendingOrders_result')
26669 
    if self.success is not None:
26670 
      oprot.writeFieldBegin('success', TType.LIST, 0)
26671 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 26672 
      for iter641 in self.success:
26673 
        iter641.write(oprot)
5553 rajveer 26674 
      oprot.writeListEnd()
26675 
      oprot.writeFieldEnd()
26676 
    oprot.writeFieldStop()
26677 
    oprot.writeStructEnd()
26678 
 
26679 
  def validate(self):
26680 
    return
26681 
 
26682 
 
26683 
  def __repr__(self):
26684 
    L = ['%s=%r' % (key, value)
26685 
      for key, value in self.__dict__.iteritems()]
26686 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26687 
 
26688 
  def __eq__(self, other):
26689 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26690 
 
26691 
  def __ne__(self, other):
26692 
    return not (self == other)
26693 
 
26694 
class getReceivedAtStoreOrders_args:
26695 
  """
26696 
  Attributes:
26697 
   - storeId
26698 
  """
26699 
 
26700 
  thrift_spec = (
26701 
    None, # 0
26702 
    (1, TType.I64, 'storeId', None, None, ), # 1
26703 
  )
26704 
 
26705 
  def __init__(self, storeId=None,):
26706 
    self.storeId = storeId
26707 
 
26708 
  def read(self, iprot):
26709 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26710 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26711 
      return
26712 
    iprot.readStructBegin()
26713 
    while True:
26714 
      (fname, ftype, fid) = iprot.readFieldBegin()
26715 
      if ftype == TType.STOP:
26716 
        break
26717 
      if fid == 1:
26718 
        if ftype == TType.I64:
26719 
          self.storeId = iprot.readI64();
26720 
        else:
26721 
          iprot.skip(ftype)
26722 
      else:
26723 
        iprot.skip(ftype)
26724 
      iprot.readFieldEnd()
26725 
    iprot.readStructEnd()
26726 
 
26727 
  def write(self, oprot):
26728 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26729 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26730 
      return
26731 
    oprot.writeStructBegin('getReceivedAtStoreOrders_args')
26732 
    if self.storeId is not None:
26733 
      oprot.writeFieldBegin('storeId', TType.I64, 1)
26734 
      oprot.writeI64(self.storeId)
26735 
      oprot.writeFieldEnd()
26736 
    oprot.writeFieldStop()
26737 
    oprot.writeStructEnd()
26738 
 
26739 
  def validate(self):
26740 
    return
26741 
 
26742 
 
26743 
  def __repr__(self):
26744 
    L = ['%s=%r' % (key, value)
26745 
      for key, value in self.__dict__.iteritems()]
26746 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26747 
 
26748 
  def __eq__(self, other):
26749 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26750 
 
26751 
  def __ne__(self, other):
26752 
    return not (self == other)
26753 
 
26754 
class getReceivedAtStoreOrders_result:
26755 
  """
26756 
  Attributes:
26757 
   - success
26758 
  """
26759 
 
26760 
  thrift_spec = (
26761 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
26762 
  )
26763 
 
26764 
  def __init__(self, success=None,):
26765 
    self.success = success
26766 
 
26767 
  def read(self, iprot):
26768 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26769 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26770 
      return
26771 
    iprot.readStructBegin()
26772 
    while True:
26773 
      (fname, ftype, fid) = iprot.readFieldBegin()
26774 
      if ftype == TType.STOP:
26775 
        break
26776 
      if fid == 0:
26777 
        if ftype == TType.LIST:
26778 
          self.success = []
6188 rajveer 26779 
          (_etype645, _size642) = iprot.readListBegin()
26780 
          for _i646 in xrange(_size642):
26781 
            _elem647 = Order()
26782 
            _elem647.read(iprot)
26783 
            self.success.append(_elem647)
5553 rajveer 26784 
          iprot.readListEnd()
26785 
        else:
26786 
          iprot.skip(ftype)
26787 
      else:
26788 
        iprot.skip(ftype)
26789 
      iprot.readFieldEnd()
26790 
    iprot.readStructEnd()
26791 
 
26792 
  def write(self, oprot):
26793 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26794 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26795 
      return
26796 
    oprot.writeStructBegin('getReceivedAtStoreOrders_result')
26797 
    if self.success is not None:
26798 
      oprot.writeFieldBegin('success', TType.LIST, 0)
26799 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 26800 
      for iter648 in self.success:
26801 
        iter648.write(oprot)
5553 rajveer 26802 
      oprot.writeListEnd()
26803 
      oprot.writeFieldEnd()
26804 
    oprot.writeFieldStop()
26805 
    oprot.writeStructEnd()
26806 
 
26807 
  def validate(self):
26808 
    return
26809 
 
26810 
 
26811 
  def __repr__(self):
26812 
    L = ['%s=%r' % (key, value)
26813 
      for key, value in self.__dict__.iteritems()]
26814 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26815 
 
26816 
  def __eq__(self, other):
26817 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26818 
 
26819 
  def __ne__(self, other):
26820 
    return not (self == other)
5593 mandeep.dh 26821 
 
5713 rajveer 26822 
class getOrdersCollectionAtStore_args:
26823 
  """
26824 
  Attributes:
26825 
   - storeId
26826 
   - fromDate
26827 
   - toDate
26828 
   - onlyCod
26829 
  """
26830 
 
26831 
  thrift_spec = (
26832 
    None, # 0
26833 
    (1, TType.I64, 'storeId', None, None, ), # 1
26834 
    (2, TType.I64, 'fromDate', None, None, ), # 2
26835 
    (3, TType.I64, 'toDate', None, None, ), # 3
26836 
    (4, TType.BOOL, 'onlyCod', None, None, ), # 4
26837 
  )
26838 
 
26839 
  def __init__(self, storeId=None, fromDate=None, toDate=None, onlyCod=None,):
26840 
    self.storeId = storeId
26841 
    self.fromDate = fromDate
26842 
    self.toDate = toDate
26843 
    self.onlyCod = onlyCod
26844 
 
26845 
  def read(self, iprot):
26846 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26847 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26848 
      return
26849 
    iprot.readStructBegin()
26850 
    while True:
26851 
      (fname, ftype, fid) = iprot.readFieldBegin()
26852 
      if ftype == TType.STOP:
26853 
        break
26854 
      if fid == 1:
26855 
        if ftype == TType.I64:
26856 
          self.storeId = iprot.readI64();
26857 
        else:
26858 
          iprot.skip(ftype)
26859 
      elif fid == 2:
26860 
        if ftype == TType.I64:
26861 
          self.fromDate = iprot.readI64();
26862 
        else:
26863 
          iprot.skip(ftype)
26864 
      elif fid == 3:
26865 
        if ftype == TType.I64:
26866 
          self.toDate = iprot.readI64();
26867 
        else:
26868 
          iprot.skip(ftype)
26869 
      elif fid == 4:
26870 
        if ftype == TType.BOOL:
26871 
          self.onlyCod = iprot.readBool();
26872 
        else:
26873 
          iprot.skip(ftype)
26874 
      else:
26875 
        iprot.skip(ftype)
26876 
      iprot.readFieldEnd()
26877 
    iprot.readStructEnd()
26878 
 
26879 
  def write(self, oprot):
26880 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26881 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26882 
      return
26883 
    oprot.writeStructBegin('getOrdersCollectionAtStore_args')
26884 
    if self.storeId is not None:
26885 
      oprot.writeFieldBegin('storeId', TType.I64, 1)
26886 
      oprot.writeI64(self.storeId)
26887 
      oprot.writeFieldEnd()
26888 
    if self.fromDate is not None:
26889 
      oprot.writeFieldBegin('fromDate', TType.I64, 2)
26890 
      oprot.writeI64(self.fromDate)
26891 
      oprot.writeFieldEnd()
26892 
    if self.toDate is not None:
26893 
      oprot.writeFieldBegin('toDate', TType.I64, 3)
26894 
      oprot.writeI64(self.toDate)
26895 
      oprot.writeFieldEnd()
26896 
    if self.onlyCod is not None:
26897 
      oprot.writeFieldBegin('onlyCod', TType.BOOL, 4)
26898 
      oprot.writeBool(self.onlyCod)
26899 
      oprot.writeFieldEnd()
26900 
    oprot.writeFieldStop()
26901 
    oprot.writeStructEnd()
26902 
 
26903 
  def validate(self):
26904 
    return
26905 
 
26906 
 
26907 
  def __repr__(self):
26908 
    L = ['%s=%r' % (key, value)
26909 
      for key, value in self.__dict__.iteritems()]
26910 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26911 
 
26912 
  def __eq__(self, other):
26913 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26914 
 
26915 
  def __ne__(self, other):
26916 
    return not (self == other)
26917 
 
26918 
class getOrdersCollectionAtStore_result:
26919 
  """
26920 
  Attributes:
26921 
   - success
26922 
  """
26923 
 
26924 
  thrift_spec = (
26925 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
26926 
  )
26927 
 
26928 
  def __init__(self, success=None,):
26929 
    self.success = success
26930 
 
26931 
  def read(self, iprot):
26932 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26933 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26934 
      return
26935 
    iprot.readStructBegin()
26936 
    while True:
26937 
      (fname, ftype, fid) = iprot.readFieldBegin()
26938 
      if ftype == TType.STOP:
26939 
        break
26940 
      if fid == 0:
26941 
        if ftype == TType.LIST:
26942 
          self.success = []
6188 rajveer 26943 
          (_etype652, _size649) = iprot.readListBegin()
26944 
          for _i653 in xrange(_size649):
26945 
            _elem654 = Order()
26946 
            _elem654.read(iprot)
26947 
            self.success.append(_elem654)
5713 rajveer 26948 
          iprot.readListEnd()
26949 
        else:
26950 
          iprot.skip(ftype)
26951 
      else:
26952 
        iprot.skip(ftype)
26953 
      iprot.readFieldEnd()
26954 
    iprot.readStructEnd()
26955 
 
26956 
  def write(self, oprot):
26957 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26958 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26959 
      return
26960 
    oprot.writeStructBegin('getOrdersCollectionAtStore_result')
26961 
    if self.success is not None:
26962 
      oprot.writeFieldBegin('success', TType.LIST, 0)
26963 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 26964 
      for iter655 in self.success:
26965 
        iter655.write(oprot)
5713 rajveer 26966 
      oprot.writeListEnd()
26967 
      oprot.writeFieldEnd()
26968 
    oprot.writeFieldStop()
26969 
    oprot.writeStructEnd()
26970 
 
26971 
  def validate(self):
26972 
    return
26973 
 
26974 
 
26975 
  def __repr__(self):
26976 
    L = ['%s=%r' % (key, value)
26977 
      for key, value in self.__dict__.iteritems()]
26978 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26979 
 
26980 
  def __eq__(self, other):
26981 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26982 
 
26983 
  def __ne__(self, other):
26984 
    return not (self == other)
26985 
 
5833 rajveer 26986 
class getOrderAttributeValue_args:
26987 
  """
26988 
  Attributes:
26989 
   - orderId
26990 
   - attributeName
26991 
  """
26992 
 
26993 
  thrift_spec = None
26994 
  def __init__(self, orderId=None, attributeName=None,):
26995 
    self.orderId = orderId
26996 
    self.attributeName = attributeName
26997 
 
26998 
  def read(self, iprot):
26999 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27000 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27001 
      return
27002 
    iprot.readStructBegin()
27003 
    while True:
27004 
      (fname, ftype, fid) = iprot.readFieldBegin()
27005 
      if ftype == TType.STOP:
27006 
        break
27007 
      if fid == 1:
27008 
        if ftype == TType.I64:
27009 
          self.orderId = iprot.readI64();
27010 
        else:
27011 
          iprot.skip(ftype)
27012 
      elif fid == -1:
27013 
        if ftype == TType.STRING:
27014 
          self.attributeName = iprot.readString();
27015 
        else:
27016 
          iprot.skip(ftype)
27017 
      else:
27018 
        iprot.skip(ftype)
27019 
      iprot.readFieldEnd()
27020 
    iprot.readStructEnd()
27021 
 
27022 
  def write(self, oprot):
27023 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27024 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27025 
      return
27026 
    oprot.writeStructBegin('getOrderAttributeValue_args')
27027 
    if self.attributeName is not None:
27028 
      oprot.writeFieldBegin('attributeName', TType.STRING, -1)
27029 
      oprot.writeString(self.attributeName)
27030 
      oprot.writeFieldEnd()
27031 
    if self.orderId is not None:
27032 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
27033 
      oprot.writeI64(self.orderId)
27034 
      oprot.writeFieldEnd()
27035 
    oprot.writeFieldStop()
27036 
    oprot.writeStructEnd()
27037 
 
27038 
  def validate(self):
27039 
    return
27040 
 
27041 
 
27042 
  def __repr__(self):
27043 
    L = ['%s=%r' % (key, value)
27044 
      for key, value in self.__dict__.iteritems()]
27045 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27046 
 
27047 
  def __eq__(self, other):
27048 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27049 
 
27050 
  def __ne__(self, other):
27051 
    return not (self == other)
27052 
 
27053 
class getOrderAttributeValue_result:
27054 
  """
27055 
  Attributes:
27056 
   - success
27057 
  """
27058 
 
27059 
  thrift_spec = (
27060 
    (0, TType.STRING, 'success', None, None, ), # 0
27061 
  )
27062 
 
27063 
  def __init__(self, success=None,):
27064 
    self.success = success
27065 
 
27066 
  def read(self, iprot):
27067 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27068 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27069 
      return
27070 
    iprot.readStructBegin()
27071 
    while True:
27072 
      (fname, ftype, fid) = iprot.readFieldBegin()
27073 
      if ftype == TType.STOP:
27074 
        break
27075 
      if fid == 0:
27076 
        if ftype == TType.STRING:
27077 
          self.success = iprot.readString();
27078 
        else:
27079 
          iprot.skip(ftype)
27080 
      else:
27081 
        iprot.skip(ftype)
27082 
      iprot.readFieldEnd()
27083 
    iprot.readStructEnd()
27084 
 
27085 
  def write(self, oprot):
27086 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27087 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27088 
      return
27089 
    oprot.writeStructBegin('getOrderAttributeValue_result')
27090 
    if self.success is not None:
27091 
      oprot.writeFieldBegin('success', TType.STRING, 0)
27092 
      oprot.writeString(self.success)
27093 
      oprot.writeFieldEnd()
27094 
    oprot.writeFieldStop()
27095 
    oprot.writeStructEnd()
27096 
 
27097 
  def validate(self):
27098 
    return
27099 
 
27100 
 
27101 
  def __repr__(self):
27102 
    L = ['%s=%r' % (key, value)
27103 
      for key, value in self.__dict__.iteritems()]
27104 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27105 
 
27106 
  def __eq__(self, other):
27107 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27108 
 
27109 
  def __ne__(self, other):
27110 
    return not (self == other)
27111 
 
6019 rajveer 27112 
class changeJacketNumber_args:
27113 
  """
27114 
  Attributes:
27115 
   - orderId
27116 
   - jacketNumber
27117 
  """
27118 
 
27119 
  thrift_spec = (
27120 
    None, # 0
27121 
    (1, TType.I64, 'orderId', None, None, ), # 1
27122 
    (2, TType.I64, 'jacketNumber', None, None, ), # 2
27123 
  )
27124 
 
27125 
  def __init__(self, orderId=None, jacketNumber=None,):
27126 
    self.orderId = orderId
27127 
    self.jacketNumber = jacketNumber
27128 
 
27129 
  def read(self, iprot):
27130 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27131 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27132 
      return
27133 
    iprot.readStructBegin()
27134 
    while True:
27135 
      (fname, ftype, fid) = iprot.readFieldBegin()
27136 
      if ftype == TType.STOP:
27137 
        break
27138 
      if fid == 1:
27139 
        if ftype == TType.I64:
27140 
          self.orderId = iprot.readI64();
27141 
        else:
27142 
          iprot.skip(ftype)
27143 
      elif fid == 2:
27144 
        if ftype == TType.I64:
27145 
          self.jacketNumber = iprot.readI64();
27146 
        else:
27147 
          iprot.skip(ftype)
27148 
      else:
27149 
        iprot.skip(ftype)
27150 
      iprot.readFieldEnd()
27151 
    iprot.readStructEnd()
27152 
 
27153 
  def write(self, oprot):
27154 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27155 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27156 
      return
27157 
    oprot.writeStructBegin('changeJacketNumber_args')
27158 
    if self.orderId is not None:
27159 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
27160 
      oprot.writeI64(self.orderId)
27161 
      oprot.writeFieldEnd()
27162 
    if self.jacketNumber is not None:
27163 
      oprot.writeFieldBegin('jacketNumber', TType.I64, 2)
27164 
      oprot.writeI64(self.jacketNumber)
27165 
      oprot.writeFieldEnd()
27166 
    oprot.writeFieldStop()
27167 
    oprot.writeStructEnd()
27168 
 
27169 
  def validate(self):
27170 
    return
27171 
 
27172 
 
27173 
  def __repr__(self):
27174 
    L = ['%s=%r' % (key, value)
27175 
      for key, value in self.__dict__.iteritems()]
27176 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27177 
 
27178 
  def __eq__(self, other):
27179 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27180 
 
27181 
  def __ne__(self, other):
27182 
    return not (self == other)
27183 
 
27184 
class changeJacketNumber_result:
27185 
  """
27186 
  Attributes:
27187 
   - success
27188 
  """
27189 
 
27190 
  thrift_spec = (
27191 
    (0, TType.BOOL, 'success', None, None, ), # 0
27192 
  )
27193 
 
27194 
  def __init__(self, success=None,):
27195 
    self.success = success
27196 
 
27197 
  def read(self, iprot):
27198 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27199 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27200 
      return
27201 
    iprot.readStructBegin()
27202 
    while True:
27203 
      (fname, ftype, fid) = iprot.readFieldBegin()
27204 
      if ftype == TType.STOP:
27205 
        break
27206 
      if fid == 0:
27207 
        if ftype == TType.BOOL:
27208 
          self.success = iprot.readBool();
27209 
        else:
27210 
          iprot.skip(ftype)
27211 
      else:
27212 
        iprot.skip(ftype)
27213 
      iprot.readFieldEnd()
27214 
    iprot.readStructEnd()
27215 
 
27216 
  def write(self, oprot):
27217 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27218 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27219 
      return
27220 
    oprot.writeStructBegin('changeJacketNumber_result')
27221 
    if self.success is not None:
27222 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
27223 
      oprot.writeBool(self.success)
27224 
      oprot.writeFieldEnd()
27225 
    oprot.writeFieldStop()
27226 
    oprot.writeStructEnd()
27227 
 
27228 
  def validate(self):
27229 
    return
27230 
 
27231 
 
27232 
  def __repr__(self):
27233 
    L = ['%s=%r' % (key, value)
27234 
      for key, value in self.__dict__.iteritems()]
27235 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27236 
 
27237 
  def __eq__(self, other):
27238 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27239 
 
27240 
  def __ne__(self, other):
27241 
    return not (self == other)
27242 
 
27243 
class markOrderAsRtoInTransit_args:
27244 
  """
27245 
  Attributes:
27246 
   - orderId
27247 
  """
27248 
 
27249 
  thrift_spec = (
27250 
    None, # 0
27251 
    (1, TType.I64, 'orderId', None, None, ), # 1
27252 
  )
27253 
 
27254 
  def __init__(self, orderId=None,):
27255 
    self.orderId = orderId
27256 
 
27257 
  def read(self, iprot):
27258 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27259 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27260 
      return
27261 
    iprot.readStructBegin()
27262 
    while True:
27263 
      (fname, ftype, fid) = iprot.readFieldBegin()
27264 
      if ftype == TType.STOP:
27265 
        break
27266 
      if fid == 1:
27267 
        if ftype == TType.I64:
27268 
          self.orderId = iprot.readI64();
27269 
        else:
27270 
          iprot.skip(ftype)
27271 
      else:
27272 
        iprot.skip(ftype)
27273 
      iprot.readFieldEnd()
27274 
    iprot.readStructEnd()
27275 
 
27276 
  def write(self, oprot):
27277 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27278 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27279 
      return
27280 
    oprot.writeStructBegin('markOrderAsRtoInTransit_args')
27281 
    if self.orderId is not None:
27282 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
27283 
      oprot.writeI64(self.orderId)
27284 
      oprot.writeFieldEnd()
27285 
    oprot.writeFieldStop()
27286 
    oprot.writeStructEnd()
27287 
 
27288 
  def validate(self):
27289 
    return
27290 
 
27291 
 
27292 
  def __repr__(self):
27293 
    L = ['%s=%r' % (key, value)
27294 
      for key, value in self.__dict__.iteritems()]
27295 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27296 
 
27297 
  def __eq__(self, other):
27298 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27299 
 
27300 
  def __ne__(self, other):
27301 
    return not (self == other)
27302 
 
27303 
class markOrderAsRtoInTransit_result:
27304 
  """
27305 
  Attributes:
27306 
   - success
27307 
  """
27308 
 
27309 
  thrift_spec = (
27310 
    (0, TType.BOOL, 'success', None, None, ), # 0
27311 
  )
27312 
 
27313 
  def __init__(self, success=None,):
27314 
    self.success = success
27315 
 
27316 
  def read(self, iprot):
27317 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27318 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27319 
      return
27320 
    iprot.readStructBegin()
27321 
    while True:
27322 
      (fname, ftype, fid) = iprot.readFieldBegin()
27323 
      if ftype == TType.STOP:
27324 
        break
27325 
      if fid == 0:
27326 
        if ftype == TType.BOOL:
27327 
          self.success = iprot.readBool();
27328 
        else:
27329 
          iprot.skip(ftype)
27330 
      else:
27331 
        iprot.skip(ftype)
27332 
      iprot.readFieldEnd()
27333 
    iprot.readStructEnd()
27334 
 
27335 
  def write(self, oprot):
27336 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27337 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27338 
      return
27339 
    oprot.writeStructBegin('markOrderAsRtoInTransit_result')
27340 
    if self.success is not None:
27341 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
27342 
      oprot.writeBool(self.success)
27343 
      oprot.writeFieldEnd()
27344 
    oprot.writeFieldStop()
27345 
    oprot.writeStructEnd()
27346 
 
27347 
  def validate(self):
27348 
    return
27349 
 
27350 
 
27351 
  def __repr__(self):
27352 
    L = ['%s=%r' % (key, value)
27353 
      for key, value in self.__dict__.iteritems()]
27354 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27355 
 
27356 
  def __eq__(self, other):
27357 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27358 
 
27359 
  def __ne__(self, other):
27360 
    return not (self == other)
27361 
 
5593 mandeep.dh 27362 
class acceptOrderForItem_args:
27363 
  """
27364 
  Attributes:
27365 
   - itemId
27366 
   - quantity
27367 
   - fulfilmentWarehouseId
27368 
   - billingWarehouseId
27369 
  """
27370 
 
27371 
  thrift_spec = (
27372 
    None, # 0
27373 
    (1, TType.I64, 'itemId', None, None, ), # 1
27374 
    (2, TType.I64, 'quantity', None, None, ), # 2
27375 
    (3, TType.I64, 'fulfilmentWarehouseId', None, None, ), # 3
27376 
    (4, TType.I64, 'billingWarehouseId', None, None, ), # 4
27377 
  )
27378 
 
27379 
  def __init__(self, itemId=None, quantity=None, fulfilmentWarehouseId=None, billingWarehouseId=None,):
27380 
    self.itemId = itemId
27381 
    self.quantity = quantity
27382 
    self.fulfilmentWarehouseId = fulfilmentWarehouseId
27383 
    self.billingWarehouseId = billingWarehouseId
27384 
 
27385 
  def read(self, iprot):
27386 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27387 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27388 
      return
27389 
    iprot.readStructBegin()
27390 
    while True:
27391 
      (fname, ftype, fid) = iprot.readFieldBegin()
27392 
      if ftype == TType.STOP:
27393 
        break
27394 
      if fid == 1:
27395 
        if ftype == TType.I64:
27396 
          self.itemId = iprot.readI64();
27397 
        else:
27398 
          iprot.skip(ftype)
27399 
      elif fid == 2:
27400 
        if ftype == TType.I64:
27401 
          self.quantity = iprot.readI64();
27402 
        else:
27403 
          iprot.skip(ftype)
27404 
      elif fid == 3:
27405 
        if ftype == TType.I64:
27406 
          self.fulfilmentWarehouseId = iprot.readI64();
27407 
        else:
27408 
          iprot.skip(ftype)
27409 
      elif fid == 4:
27410 
        if ftype == TType.I64:
27411 
          self.billingWarehouseId = iprot.readI64();
27412 
        else:
27413 
          iprot.skip(ftype)
27414 
      else:
27415 
        iprot.skip(ftype)
27416 
      iprot.readFieldEnd()
27417 
    iprot.readStructEnd()
27418 
 
27419 
  def write(self, oprot):
27420 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27421 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27422 
      return
27423 
    oprot.writeStructBegin('acceptOrderForItem_args')
27424 
    if self.itemId is not None:
27425 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
27426 
      oprot.writeI64(self.itemId)
27427 
      oprot.writeFieldEnd()
27428 
    if self.quantity is not None:
27429 
      oprot.writeFieldBegin('quantity', TType.I64, 2)
27430 
      oprot.writeI64(self.quantity)
27431 
      oprot.writeFieldEnd()
27432 
    if self.fulfilmentWarehouseId is not None:
27433 
      oprot.writeFieldBegin('fulfilmentWarehouseId', TType.I64, 3)
27434 
      oprot.writeI64(self.fulfilmentWarehouseId)
27435 
      oprot.writeFieldEnd()
27436 
    if self.billingWarehouseId is not None:
27437 
      oprot.writeFieldBegin('billingWarehouseId', TType.I64, 4)
27438 
      oprot.writeI64(self.billingWarehouseId)
27439 
      oprot.writeFieldEnd()
27440 
    oprot.writeFieldStop()
27441 
    oprot.writeStructEnd()
27442 
 
27443 
  def validate(self):
27444 
    return
27445 
 
27446 
 
27447 
  def __repr__(self):
27448 
    L = ['%s=%r' % (key, value)
27449 
      for key, value in self.__dict__.iteritems()]
27450 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27451 
 
27452 
  def __eq__(self, other):
27453 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27454 
 
27455 
  def __ne__(self, other):
27456 
    return not (self == other)
27457 
 
27458 
class acceptOrderForItem_result:
27459 
 
27460 
  thrift_spec = (
27461 
  )
27462 
 
27463 
  def read(self, iprot):
27464 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27465 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27466 
      return
27467 
    iprot.readStructBegin()
27468 
    while True:
27469 
      (fname, ftype, fid) = iprot.readFieldBegin()
27470 
      if ftype == TType.STOP:
27471 
        break
27472 
      else:
27473 
        iprot.skip(ftype)
27474 
      iprot.readFieldEnd()
27475 
    iprot.readStructEnd()
27476 
 
27477 
  def write(self, oprot):
27478 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27479 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27480 
      return
27481 
    oprot.writeStructBegin('acceptOrderForItem_result')
27482 
    oprot.writeFieldStop()
27483 
    oprot.writeStructEnd()
27484 
 
27485 
  def validate(self):
27486 
    return
27487 
 
27488 
 
27489 
  def __repr__(self):
27490 
    L = ['%s=%r' % (key, value)
27491 
      for key, value in self.__dict__.iteritems()]
27492 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27493 
 
27494 
  def __eq__(self, other):
27495 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27496 
 
27497 
  def __ne__(self, other):
27498 
    return not (self == other)
6000 mandeep.dh 27499 
 
27500 
class createRechargeOrder_args:
27501 
  """
27502 
  Attributes:
27503 
   - rechargeOrder
27504 
  """
27505 
 
27506 
  thrift_spec = (
27507 
    None, # 0
27508 
    (1, TType.STRUCT, 'rechargeOrder', (RechargeOrder, RechargeOrder.thrift_spec), None, ), # 1
27509 
  )
27510 
 
27511 
  def __init__(self, rechargeOrder=None,):
27512 
    self.rechargeOrder = rechargeOrder
27513 
 
27514 
  def read(self, iprot):
27515 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27516 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27517 
      return
27518 
    iprot.readStructBegin()
27519 
    while True:
27520 
      (fname, ftype, fid) = iprot.readFieldBegin()
27521 
      if ftype == TType.STOP:
27522 
        break
27523 
      if fid == 1:
27524 
        if ftype == TType.STRUCT:
27525 
          self.rechargeOrder = RechargeOrder()
27526 
          self.rechargeOrder.read(iprot)
27527 
        else:
27528 
          iprot.skip(ftype)
27529 
      else:
27530 
        iprot.skip(ftype)
27531 
      iprot.readFieldEnd()
27532 
    iprot.readStructEnd()
27533 
 
27534 
  def write(self, oprot):
27535 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27536 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27537 
      return
27538 
    oprot.writeStructBegin('createRechargeOrder_args')
27539 
    if self.rechargeOrder is not None:
27540 
      oprot.writeFieldBegin('rechargeOrder', TType.STRUCT, 1)
27541 
      self.rechargeOrder.write(oprot)
27542 
      oprot.writeFieldEnd()
27543 
    oprot.writeFieldStop()
27544 
    oprot.writeStructEnd()
27545 
 
27546 
  def validate(self):
27547 
    return
27548 
 
27549 
 
27550 
  def __repr__(self):
27551 
    L = ['%s=%r' % (key, value)
27552 
      for key, value in self.__dict__.iteritems()]
27553 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27554 
 
27555 
  def __eq__(self, other):
27556 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27557 
 
27558 
  def __ne__(self, other):
27559 
    return not (self == other)
27560 
 
27561 
class createRechargeOrder_result:
27562 
  """
27563 
  Attributes:
27564 
   - success
27565 
   - ex
27566 
  """
27567 
 
27568 
  thrift_spec = (
27569 
    (0, TType.STRUCT, 'success', (RechargeOrder, RechargeOrder.thrift_spec), None, ), # 0
27570 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
27571 
  )
27572 
 
27573 
  def __init__(self, success=None, ex=None,):
27574 
    self.success = success
27575 
    self.ex = ex
27576 
 
27577 
  def read(self, iprot):
27578 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27579 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27580 
      return
27581 
    iprot.readStructBegin()
27582 
    while True:
27583 
      (fname, ftype, fid) = iprot.readFieldBegin()
27584 
      if ftype == TType.STOP:
27585 
        break
27586 
      if fid == 0:
27587 
        if ftype == TType.STRUCT:
27588 
          self.success = RechargeOrder()
27589 
          self.success.read(iprot)
27590 
        else:
27591 
          iprot.skip(ftype)
27592 
      elif fid == 1:
27593 
        if ftype == TType.STRUCT:
27594 
          self.ex = TransactionServiceException()
27595 
          self.ex.read(iprot)
27596 
        else:
27597 
          iprot.skip(ftype)
27598 
      else:
27599 
        iprot.skip(ftype)
27600 
      iprot.readFieldEnd()
27601 
    iprot.readStructEnd()
27602 
 
27603 
  def write(self, oprot):
27604 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27605 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27606 
      return
27607 
    oprot.writeStructBegin('createRechargeOrder_result')
27608 
    if self.success is not None:
27609 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
27610 
      self.success.write(oprot)
27611 
      oprot.writeFieldEnd()
27612 
    if self.ex is not None:
27613 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
27614 
      self.ex.write(oprot)
27615 
      oprot.writeFieldEnd()
27616 
    oprot.writeFieldStop()
27617 
    oprot.writeStructEnd()
27618 
 
27619 
  def validate(self):
27620 
    return
27621 
 
27622 
 
27623 
  def __repr__(self):
27624 
    L = ['%s=%r' % (key, value)
27625 
      for key, value in self.__dict__.iteritems()]
27626 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27627 
 
27628 
  def __eq__(self, other):
27629 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27630 
 
27631 
  def __ne__(self, other):
27632 
    return not (self == other)
27633 
 
6031 rajveer 27634 
class getRechargeOrder_args:
27635 
  """
27636 
  Attributes:
27637 
   - rechargeRrderId
27638 
  """
27639 
 
27640 
  thrift_spec = (
27641 
    None, # 0
27642 
    (1, TType.I64, 'rechargeRrderId', None, None, ), # 1
27643 
  )
27644 
 
27645 
  def __init__(self, rechargeRrderId=None,):
27646 
    self.rechargeRrderId = rechargeRrderId
27647 
 
27648 
  def read(self, iprot):
27649 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27650 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27651 
      return
27652 
    iprot.readStructBegin()
27653 
    while True:
27654 
      (fname, ftype, fid) = iprot.readFieldBegin()
27655 
      if ftype == TType.STOP:
27656 
        break
27657 
      if fid == 1:
27658 
        if ftype == TType.I64:
27659 
          self.rechargeRrderId = iprot.readI64();
27660 
        else:
27661 
          iprot.skip(ftype)
27662 
      else:
27663 
        iprot.skip(ftype)
27664 
      iprot.readFieldEnd()
27665 
    iprot.readStructEnd()
27666 
 
27667 
  def write(self, oprot):
27668 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27669 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27670 
      return
27671 
    oprot.writeStructBegin('getRechargeOrder_args')
27672 
    if self.rechargeRrderId is not None:
27673 
      oprot.writeFieldBegin('rechargeRrderId', TType.I64, 1)
27674 
      oprot.writeI64(self.rechargeRrderId)
27675 
      oprot.writeFieldEnd()
27676 
    oprot.writeFieldStop()
27677 
    oprot.writeStructEnd()
27678 
 
27679 
  def validate(self):
27680 
    return
27681 
 
27682 
 
27683 
  def __repr__(self):
27684 
    L = ['%s=%r' % (key, value)
27685 
      for key, value in self.__dict__.iteritems()]
27686 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27687 
 
27688 
  def __eq__(self, other):
27689 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27690 
 
27691 
  def __ne__(self, other):
27692 
    return not (self == other)
27693 
 
27694 
class getRechargeOrder_result:
27695 
  """
27696 
  Attributes:
27697 
   - success
27698 
   - ex
27699 
  """
27700 
 
27701 
  thrift_spec = (
27702 
    (0, TType.STRUCT, 'success', (RechargeOrder, RechargeOrder.thrift_spec), None, ), # 0
27703 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
27704 
  )
27705 
 
27706 
  def __init__(self, success=None, ex=None,):
27707 
    self.success = success
27708 
    self.ex = ex
27709 
 
27710 
  def read(self, iprot):
27711 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27712 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27713 
      return
27714 
    iprot.readStructBegin()
27715 
    while True:
27716 
      (fname, ftype, fid) = iprot.readFieldBegin()
27717 
      if ftype == TType.STOP:
27718 
        break
27719 
      if fid == 0:
27720 
        if ftype == TType.STRUCT:
27721 
          self.success = RechargeOrder()
27722 
          self.success.read(iprot)
27723 
        else:
27724 
          iprot.skip(ftype)
27725 
      elif fid == 1:
27726 
        if ftype == TType.STRUCT:
27727 
          self.ex = TransactionServiceException()
27728 
          self.ex.read(iprot)
27729 
        else:
27730 
          iprot.skip(ftype)
27731 
      else:
27732 
        iprot.skip(ftype)
27733 
      iprot.readFieldEnd()
27734 
    iprot.readStructEnd()
27735 
 
27736 
  def write(self, oprot):
27737 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27738 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27739 
      return
27740 
    oprot.writeStructBegin('getRechargeOrder_result')
27741 
    if self.success is not None:
27742 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
27743 
      self.success.write(oprot)
27744 
      oprot.writeFieldEnd()
27745 
    if self.ex is not None:
27746 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
27747 
      self.ex.write(oprot)
27748 
      oprot.writeFieldEnd()
27749 
    oprot.writeFieldStop()
27750 
    oprot.writeStructEnd()
27751 
 
27752 
  def validate(self):
27753 
    return
27754 
 
27755 
 
27756 
  def __repr__(self):
27757 
    L = ['%s=%r' % (key, value)
27758 
      for key, value in self.__dict__.iteritems()]
27759 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27760 
 
27761 
  def __eq__(self, other):
27762 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27763 
 
27764 
  def __ne__(self, other):
27765 
    return not (self == other)
27766 
 
27767 
class getRechargeOrders_args:
27768 
  """
27769 
  Attributes:
27770 
   - userId
27771 
  """
27772 
 
27773 
  thrift_spec = (
27774 
    None, # 0
27775 
    (1, TType.I64, 'userId', None, None, ), # 1
27776 
  )
27777 
 
27778 
  def __init__(self, userId=None,):
27779 
    self.userId = userId
27780 
 
27781 
  def read(self, iprot):
27782 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27783 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27784 
      return
27785 
    iprot.readStructBegin()
27786 
    while True:
27787 
      (fname, ftype, fid) = iprot.readFieldBegin()
27788 
      if ftype == TType.STOP:
27789 
        break
27790 
      if fid == 1:
27791 
        if ftype == TType.I64:
27792 
          self.userId = iprot.readI64();
27793 
        else:
27794 
          iprot.skip(ftype)
27795 
      else:
27796 
        iprot.skip(ftype)
27797 
      iprot.readFieldEnd()
27798 
    iprot.readStructEnd()
27799 
 
27800 
  def write(self, oprot):
27801 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27802 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27803 
      return
27804 
    oprot.writeStructBegin('getRechargeOrders_args')
27805 
    if self.userId is not None:
27806 
      oprot.writeFieldBegin('userId', TType.I64, 1)
27807 
      oprot.writeI64(self.userId)
27808 
      oprot.writeFieldEnd()
27809 
    oprot.writeFieldStop()
27810 
    oprot.writeStructEnd()
27811 
 
27812 
  def validate(self):
27813 
    return
27814 
 
27815 
 
27816 
  def __repr__(self):
27817 
    L = ['%s=%r' % (key, value)
27818 
      for key, value in self.__dict__.iteritems()]
27819 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27820 
 
27821 
  def __eq__(self, other):
27822 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27823 
 
27824 
  def __ne__(self, other):
27825 
    return not (self == other)
27826 
 
27827 
class getRechargeOrders_result:
27828 
  """
27829 
  Attributes:
27830 
   - success
27831 
  """
27832 
 
27833 
  thrift_spec = (
27834 
    (0, TType.LIST, 'success', (TType.STRUCT,(RechargeOrder, RechargeOrder.thrift_spec)), None, ), # 0
27835 
  )
27836 
 
27837 
  def __init__(self, success=None,):
27838 
    self.success = success
27839 
 
27840 
  def read(self, iprot):
27841 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27842 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27843 
      return
27844 
    iprot.readStructBegin()
27845 
    while True:
27846 
      (fname, ftype, fid) = iprot.readFieldBegin()
27847 
      if ftype == TType.STOP:
27848 
        break
27849 
      if fid == 0:
27850 
        if ftype == TType.LIST:
27851 
          self.success = []
6188 rajveer 27852 
          (_etype659, _size656) = iprot.readListBegin()
27853 
          for _i660 in xrange(_size656):
27854 
            _elem661 = RechargeOrder()
27855 
            _elem661.read(iprot)
27856 
            self.success.append(_elem661)
6031 rajveer 27857 
          iprot.readListEnd()
27858 
        else:
27859 
          iprot.skip(ftype)
27860 
      else:
27861 
        iprot.skip(ftype)
27862 
      iprot.readFieldEnd()
27863 
    iprot.readStructEnd()
27864 
 
27865 
  def write(self, oprot):
27866 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27867 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27868 
      return
27869 
    oprot.writeStructBegin('getRechargeOrders_result')
27870 
    if self.success is not None:
27871 
      oprot.writeFieldBegin('success', TType.LIST, 0)
27872 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 27873 
      for iter662 in self.success:
27874 
        iter662.write(oprot)
6031 rajveer 27875 
      oprot.writeListEnd()
27876 
      oprot.writeFieldEnd()
27877 
    oprot.writeFieldStop()
27878 
    oprot.writeStructEnd()
27879 
 
27880 
  def validate(self):
27881 
    return
27882 
 
27883 
 
27884 
  def __repr__(self):
27885 
    L = ['%s=%r' % (key, value)
27886 
      for key, value in self.__dict__.iteritems()]
27887 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27888 
 
27889 
  def __eq__(self, other):
27890 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27891 
 
27892 
  def __ne__(self, other):
27893 
    return not (self == other)
27894 
 
6000 mandeep.dh 27895 
class updateRechargeOrderStatus_args:
27896 
  """
27897 
  Attributes:
27898 
   - rechargeOrderId
27899 
   - rechargeOrderStatus
27900 
  """
27901 
 
27902 
  thrift_spec = (
27903 
    None, # 0
27904 
    (1, TType.I64, 'rechargeOrderId', None, None, ), # 1
27905 
    (2, TType.I32, 'rechargeOrderStatus', None, None, ), # 2
27906 
  )
27907 
 
27908 
  def __init__(self, rechargeOrderId=None, rechargeOrderStatus=None,):
27909 
    self.rechargeOrderId = rechargeOrderId
27910 
    self.rechargeOrderStatus = rechargeOrderStatus
27911 
 
27912 
  def read(self, iprot):
27913 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27914 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27915 
      return
27916 
    iprot.readStructBegin()
27917 
    while True:
27918 
      (fname, ftype, fid) = iprot.readFieldBegin()
27919 
      if ftype == TType.STOP:
27920 
        break
27921 
      if fid == 1:
27922 
        if ftype == TType.I64:
27923 
          self.rechargeOrderId = iprot.readI64();
27924 
        else:
27925 
          iprot.skip(ftype)
27926 
      elif fid == 2:
27927 
        if ftype == TType.I32:
27928 
          self.rechargeOrderStatus = iprot.readI32();
27929 
        else:
27930 
          iprot.skip(ftype)
27931 
      else:
27932 
        iprot.skip(ftype)
27933 
      iprot.readFieldEnd()
27934 
    iprot.readStructEnd()
27935 
 
27936 
  def write(self, oprot):
27937 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27938 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27939 
      return
27940 
    oprot.writeStructBegin('updateRechargeOrderStatus_args')
27941 
    if self.rechargeOrderId is not None:
27942 
      oprot.writeFieldBegin('rechargeOrderId', TType.I64, 1)
27943 
      oprot.writeI64(self.rechargeOrderId)
27944 
      oprot.writeFieldEnd()
27945 
    if self.rechargeOrderStatus is not None:
27946 
      oprot.writeFieldBegin('rechargeOrderStatus', TType.I32, 2)
27947 
      oprot.writeI32(self.rechargeOrderStatus)
27948 
      oprot.writeFieldEnd()
27949 
    oprot.writeFieldStop()
27950 
    oprot.writeStructEnd()
27951 
 
27952 
  def validate(self):
27953 
    return
27954 
 
27955 
 
27956 
  def __repr__(self):
27957 
    L = ['%s=%r' % (key, value)
27958 
      for key, value in self.__dict__.iteritems()]
27959 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27960 
 
27961 
  def __eq__(self, other):
27962 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27963 
 
27964 
  def __ne__(self, other):
27965 
    return not (self == other)
27966 
 
27967 
class updateRechargeOrderStatus_result:
27968 
  """
27969 
  Attributes:
6031 rajveer 27970 
   - success
6000 mandeep.dh 27971 
   - ex
27972 
  """
27973 
 
27974 
  thrift_spec = (
6031 rajveer 27975 
    (0, TType.BOOL, 'success', None, None, ), # 0
6000 mandeep.dh 27976 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
27977 
  )
27978 
 
6031 rajveer 27979 
  def __init__(self, success=None, ex=None,):
27980 
    self.success = success
6000 mandeep.dh 27981 
    self.ex = ex
27982 
 
27983 
  def read(self, iprot):
27984 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27985 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27986 
      return
27987 
    iprot.readStructBegin()
27988 
    while True:
27989 
      (fname, ftype, fid) = iprot.readFieldBegin()
27990 
      if ftype == TType.STOP:
27991 
        break
6031 rajveer 27992 
      if fid == 0:
27993 
        if ftype == TType.BOOL:
27994 
          self.success = iprot.readBool();
27995 
        else:
27996 
          iprot.skip(ftype)
27997 
      elif fid == 1:
6000 mandeep.dh 27998 
        if ftype == TType.STRUCT:
27999 
          self.ex = TransactionServiceException()
28000 
          self.ex.read(iprot)
28001 
        else:
28002 
          iprot.skip(ftype)
28003 
      else:
28004 
        iprot.skip(ftype)
28005 
      iprot.readFieldEnd()
28006 
    iprot.readStructEnd()
28007 
 
28008 
  def write(self, oprot):
28009 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28010 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28011 
      return
28012 
    oprot.writeStructBegin('updateRechargeOrderStatus_result')
6031 rajveer 28013 
    if self.success is not None:
28014 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
28015 
      oprot.writeBool(self.success)
28016 
      oprot.writeFieldEnd()
6000 mandeep.dh 28017 
    if self.ex is not None:
28018 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
28019 
      self.ex.write(oprot)
28020 
      oprot.writeFieldEnd()
28021 
    oprot.writeFieldStop()
28022 
    oprot.writeStructEnd()
28023 
 
28024 
  def validate(self):
28025 
    return
28026 
 
28027 
 
28028 
  def __repr__(self):
28029 
    L = ['%s=%r' % (key, value)
28030 
      for key, value in self.__dict__.iteritems()]
28031 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28032 
 
28033 
  def __eq__(self, other):
28034 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28035 
 
28036 
  def __ne__(self, other):
28037 
    return not (self == other)
28038 
 
28039 
class activateRechargeTxn_args:
28040 
  """
28041 
  Attributes:
6031 rajveer 28042 
   - rechargeOrderId
6000 mandeep.dh 28043 
  """
28044 
 
28045 
  thrift_spec = (
28046 
    None, # 0
6031 rajveer 28047 
    (1, TType.I64, 'rechargeOrderId', None, None, ), # 1
6000 mandeep.dh 28048 
  )
28049 
 
6031 rajveer 28050 
  def __init__(self, rechargeOrderId=None,):
28051 
    self.rechargeOrderId = rechargeOrderId
6000 mandeep.dh 28052 
 
28053 
  def read(self, iprot):
28054 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28055 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28056 
      return
28057 
    iprot.readStructBegin()
28058 
    while True:
28059 
      (fname, ftype, fid) = iprot.readFieldBegin()
28060 
      if ftype == TType.STOP:
28061 
        break
28062 
      if fid == 1:
6031 rajveer 28063 
        if ftype == TType.I64:
28064 
          self.rechargeOrderId = iprot.readI64();
6000 mandeep.dh 28065 
        else:
28066 
          iprot.skip(ftype)
28067 
      else:
28068 
        iprot.skip(ftype)
28069 
      iprot.readFieldEnd()
28070 
    iprot.readStructEnd()
28071 
 
28072 
  def write(self, oprot):
28073 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28074 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28075 
      return
28076 
    oprot.writeStructBegin('activateRechargeTxn_args')
6031 rajveer 28077 
    if self.rechargeOrderId is not None:
28078 
      oprot.writeFieldBegin('rechargeOrderId', TType.I64, 1)
28079 
      oprot.writeI64(self.rechargeOrderId)
6000 mandeep.dh 28080 
      oprot.writeFieldEnd()
28081 
    oprot.writeFieldStop()
28082 
    oprot.writeStructEnd()
28083 
 
28084 
  def validate(self):
28085 
    return
28086 
 
28087 
 
28088 
  def __repr__(self):
28089 
    L = ['%s=%r' % (key, value)
28090 
      for key, value in self.__dict__.iteritems()]
28091 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28092 
 
28093 
  def __eq__(self, other):
28094 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28095 
 
28096 
  def __ne__(self, other):
28097 
    return not (self == other)
28098 
 
28099 
class activateRechargeTxn_result:
28100 
  """
28101 
  Attributes:
28102 
   - success
28103 
   - ex
28104 
  """
28105 
 
28106 
  thrift_spec = (
6031 rajveer 28107 
    (0, TType.BOOL, 'success', None, None, ), # 0
6000 mandeep.dh 28108 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
28109 
  )
28110 
 
28111 
  def __init__(self, success=None, ex=None,):
28112 
    self.success = success
28113 
    self.ex = ex
28114 
 
28115 
  def read(self, iprot):
28116 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28117 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28118 
      return
28119 
    iprot.readStructBegin()
28120 
    while True:
28121 
      (fname, ftype, fid) = iprot.readFieldBegin()
28122 
      if ftype == TType.STOP:
28123 
        break
28124 
      if fid == 0:
6031 rajveer 28125 
        if ftype == TType.BOOL:
28126 
          self.success = iprot.readBool();
6000 mandeep.dh 28127 
        else:
28128 
          iprot.skip(ftype)
28129 
      elif fid == 1:
28130 
        if ftype == TType.STRUCT:
28131 
          self.ex = TransactionServiceException()
28132 
          self.ex.read(iprot)
28133 
        else:
28134 
          iprot.skip(ftype)
28135 
      else:
28136 
        iprot.skip(ftype)
28137 
      iprot.readFieldEnd()
28138 
    iprot.readStructEnd()
28139 
 
28140 
  def write(self, oprot):
28141 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28142 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28143 
      return
28144 
    oprot.writeStructBegin('activateRechargeTxn_result')
28145 
    if self.success is not None:
6031 rajveer 28146 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
28147 
      oprot.writeBool(self.success)
6000 mandeep.dh 28148 
      oprot.writeFieldEnd()
28149 
    if self.ex is not None:
28150 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
28151 
      self.ex.write(oprot)
28152 
      oprot.writeFieldEnd()
28153 
    oprot.writeFieldStop()
28154 
    oprot.writeStructEnd()
28155 
 
28156 
  def validate(self):
28157 
    return
28158 
 
28159 
 
28160 
  def __repr__(self):
28161 
    L = ['%s=%r' % (key, value)
28162 
      for key, value in self.__dict__.iteritems()]
28163 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28164 
 
28165 
  def __eq__(self, other):
28166 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28167 
 
28168 
  def __ne__(self, other):
28169 
    return not (self == other)
28170 
 
6031 rajveer 28171 
class getUserWallet_args:
6000 mandeep.dh 28172 
  """
28173 
  Attributes:
6031 rajveer 28174 
   - userId
6000 mandeep.dh 28175 
  """
28176 
 
28177 
  thrift_spec = (
28178 
    None, # 0
6031 rajveer 28179 
    (1, TType.I64, 'userId', None, None, ), # 1
6000 mandeep.dh 28180 
  )
28181 
 
6031 rajveer 28182 
  def __init__(self, userId=None,):
28183 
    self.userId = userId
6000 mandeep.dh 28184 
 
28185 
  def read(self, iprot):
28186 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28187 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28188 
      return
28189 
    iprot.readStructBegin()
28190 
    while True:
28191 
      (fname, ftype, fid) = iprot.readFieldBegin()
28192 
      if ftype == TType.STOP:
28193 
        break
28194 
      if fid == 1:
28195 
        if ftype == TType.I64:
6031 rajveer 28196 
          self.userId = iprot.readI64();
6000 mandeep.dh 28197 
        else:
28198 
          iprot.skip(ftype)
28199 
      else:
28200 
        iprot.skip(ftype)
28201 
      iprot.readFieldEnd()
28202 
    iprot.readStructEnd()
28203 
 
28204 
  def write(self, oprot):
28205 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28206 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28207 
      return
6031 rajveer 28208 
    oprot.writeStructBegin('getUserWallet_args')
28209 
    if self.userId is not None:
28210 
      oprot.writeFieldBegin('userId', TType.I64, 1)
28211 
      oprot.writeI64(self.userId)
6000 mandeep.dh 28212 
      oprot.writeFieldEnd()
28213 
    oprot.writeFieldStop()
28214 
    oprot.writeStructEnd()
28215 
 
28216 
  def validate(self):
28217 
    return
28218 
 
28219 
 
28220 
  def __repr__(self):
28221 
    L = ['%s=%r' % (key, value)
28222 
      for key, value in self.__dict__.iteritems()]
28223 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28224 
 
28225 
  def __eq__(self, other):
28226 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28227 
 
28228 
  def __ne__(self, other):
28229 
    return not (self == other)
28230 
 
6031 rajveer 28231 
class getUserWallet_result:
6000 mandeep.dh 28232 
  """
28233 
  Attributes:
28234 
   - success
28235 
  """
28236 
 
28237 
  thrift_spec = (
6031 rajveer 28238 
    (0, TType.STRUCT, 'success', (UserWallet, UserWallet.thrift_spec), None, ), # 0
6000 mandeep.dh 28239 
  )
28240 
 
28241 
  def __init__(self, success=None,):
28242 
    self.success = success
28243 
 
28244 
  def read(self, iprot):
28245 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28246 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28247 
      return
28248 
    iprot.readStructBegin()
28249 
    while True:
28250 
      (fname, ftype, fid) = iprot.readFieldBegin()
28251 
      if ftype == TType.STOP:
28252 
        break
28253 
      if fid == 0:
6031 rajveer 28254 
        if ftype == TType.STRUCT:
28255 
          self.success = UserWallet()
28256 
          self.success.read(iprot)
6000 mandeep.dh 28257 
        else:
28258 
          iprot.skip(ftype)
28259 
      else:
28260 
        iprot.skip(ftype)
28261 
      iprot.readFieldEnd()
28262 
    iprot.readStructEnd()
28263 
 
28264 
  def write(self, oprot):
28265 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28266 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28267 
      return
6031 rajveer 28268 
    oprot.writeStructBegin('getUserWallet_result')
6000 mandeep.dh 28269 
    if self.success is not None:
6031 rajveer 28270 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
28271 
      self.success.write(oprot)
6000 mandeep.dh 28272 
      oprot.writeFieldEnd()
28273 
    oprot.writeFieldStop()
28274 
    oprot.writeStructEnd()
28275 
 
28276 
  def validate(self):
28277 
    return
28278 
 
28279 
 
28280 
  def __repr__(self):
28281 
    L = ['%s=%r' % (key, value)
28282 
      for key, value in self.__dict__.iteritems()]
28283 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28284 
 
28285 
  def __eq__(self, other):
28286 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28287 
 
28288 
  def __ne__(self, other):
28289 
    return not (self == other)
28290 
 
6031 rajveer 28291 
class getUserWalletHistory_args:
6000 mandeep.dh 28292 
  """
28293 
  Attributes:
6031 rajveer 28294 
   - userId
6000 mandeep.dh 28295 
  """
28296 
 
28297 
  thrift_spec = (
28298 
    None, # 0
6031 rajveer 28299 
    (1, TType.I64, 'userId', None, None, ), # 1
6000 mandeep.dh 28300 
  )
28301 
 
6031 rajveer 28302 
  def __init__(self, userId=None,):
28303 
    self.userId = userId
6000 mandeep.dh 28304 
 
28305 
  def read(self, iprot):
28306 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28307 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28308 
      return
28309 
    iprot.readStructBegin()
28310 
    while True:
28311 
      (fname, ftype, fid) = iprot.readFieldBegin()
28312 
      if ftype == TType.STOP:
28313 
        break
28314 
      if fid == 1:
28315 
        if ftype == TType.I64:
6031 rajveer 28316 
          self.userId = iprot.readI64();
6000 mandeep.dh 28317 
        else:
28318 
          iprot.skip(ftype)
28319 
      else:
28320 
        iprot.skip(ftype)
28321 
      iprot.readFieldEnd()
28322 
    iprot.readStructEnd()
28323 
 
28324 
  def write(self, oprot):
28325 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28326 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28327 
      return
6031 rajveer 28328 
    oprot.writeStructBegin('getUserWalletHistory_args')
28329 
    if self.userId is not None:
28330 
      oprot.writeFieldBegin('userId', TType.I64, 1)
28331 
      oprot.writeI64(self.userId)
6000 mandeep.dh 28332 
      oprot.writeFieldEnd()
28333 
    oprot.writeFieldStop()
28334 
    oprot.writeStructEnd()
28335 
 
28336 
  def validate(self):
28337 
    return
28338 
 
28339 
 
28340 
  def __repr__(self):
28341 
    L = ['%s=%r' % (key, value)
28342 
      for key, value in self.__dict__.iteritems()]
28343 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28344 
 
28345 
  def __eq__(self, other):
28346 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28347 
 
28348 
  def __ne__(self, other):
28349 
    return not (self == other)
28350 
 
6031 rajveer 28351 
class getUserWalletHistory_result:
6000 mandeep.dh 28352 
  """
28353 
  Attributes:
28354 
   - success
28355 
  """
28356 
 
28357 
  thrift_spec = (
6031 rajveer 28358 
    (0, TType.LIST, 'success', (TType.STRUCT,(UserWalletHistory, UserWalletHistory.thrift_spec)), None, ), # 0
6000 mandeep.dh 28359 
  )
28360 
 
28361 
  def __init__(self, success=None,):
28362 
    self.success = success
28363 
 
28364 
  def read(self, iprot):
28365 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28366 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28367 
      return
28368 
    iprot.readStructBegin()
28369 
    while True:
28370 
      (fname, ftype, fid) = iprot.readFieldBegin()
28371 
      if ftype == TType.STOP:
28372 
        break
28373 
      if fid == 0:
28374 
        if ftype == TType.LIST:
28375 
          self.success = []
6188 rajveer 28376 
          (_etype666, _size663) = iprot.readListBegin()
28377 
          for _i667 in xrange(_size663):
28378 
            _elem668 = UserWalletHistory()
28379 
            _elem668.read(iprot)
28380 
            self.success.append(_elem668)
6000 mandeep.dh 28381 
          iprot.readListEnd()
28382 
        else:
28383 
          iprot.skip(ftype)
28384 
      else:
28385 
        iprot.skip(ftype)
28386 
      iprot.readFieldEnd()
28387 
    iprot.readStructEnd()
28388 
 
28389 
  def write(self, oprot):
28390 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28391 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28392 
      return
6031 rajveer 28393 
    oprot.writeStructBegin('getUserWalletHistory_result')
6000 mandeep.dh 28394 
    if self.success is not None:
28395 
      oprot.writeFieldBegin('success', TType.LIST, 0)
28396 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 28397 
      for iter669 in self.success:
28398 
        iter669.write(oprot)
6000 mandeep.dh 28399 
      oprot.writeListEnd()
28400 
      oprot.writeFieldEnd()
28401 
    oprot.writeFieldStop()
28402 
    oprot.writeStructEnd()
28403 
 
28404 
  def validate(self):
28405 
    return
28406 
 
28407 
 
28408 
  def __repr__(self):
28409 
    L = ['%s=%r' % (key, value)
28410 
      for key, value in self.__dict__.iteritems()]
28411 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28412 
 
28413 
  def __eq__(self, other):
28414 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28415 
 
28416 
  def __ne__(self, other):
28417 
    return not (self == other)
6048 rajveer 28418 
 
6050 anupam.sin 28419 
class getRechargeOrdersForTransaction_args:
28420 
  """
28421 
  Attributes:
28422 
   - txnId
28423 
  """
28424 
 
28425 
  thrift_spec = (
28426 
    None, # 0
28427 
    (1, TType.I64, 'txnId', None, None, ), # 1
28428 
  )
28429 
 
28430 
  def __init__(self, txnId=None,):
28431 
    self.txnId = txnId
28432 
 
28433 
  def read(self, iprot):
28434 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28435 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28436 
      return
28437 
    iprot.readStructBegin()
28438 
    while True:
28439 
      (fname, ftype, fid) = iprot.readFieldBegin()
28440 
      if ftype == TType.STOP:
28441 
        break
28442 
      if fid == 1:
28443 
        if ftype == TType.I64:
28444 
          self.txnId = iprot.readI64();
28445 
        else:
28446 
          iprot.skip(ftype)
28447 
      else:
28448 
        iprot.skip(ftype)
28449 
      iprot.readFieldEnd()
28450 
    iprot.readStructEnd()
28451 
 
28452 
  def write(self, oprot):
28453 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28454 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28455 
      return
28456 
    oprot.writeStructBegin('getRechargeOrdersForTransaction_args')
28457 
    if self.txnId is not None:
28458 
      oprot.writeFieldBegin('txnId', TType.I64, 1)
28459 
      oprot.writeI64(self.txnId)
28460 
      oprot.writeFieldEnd()
28461 
    oprot.writeFieldStop()
28462 
    oprot.writeStructEnd()
28463 
 
28464 
  def validate(self):
28465 
    return
28466 
 
28467 
 
28468 
  def __repr__(self):
28469 
    L = ['%s=%r' % (key, value)
28470 
      for key, value in self.__dict__.iteritems()]
28471 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28472 
 
28473 
  def __eq__(self, other):
28474 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28475 
 
28476 
  def __ne__(self, other):
28477 
    return not (self == other)
28478 
 
28479 
class getRechargeOrdersForTransaction_result:
28480 
  """
28481 
  Attributes:
28482 
   - success
28483 
   - ex
28484 
  """
28485 
 
28486 
  thrift_spec = (
28487 
    (0, TType.STRUCT, 'success', (RechargeOrder, RechargeOrder.thrift_spec), None, ), # 0
28488 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
28489 
  )
28490 
 
28491 
  def __init__(self, success=None, ex=None,):
28492 
    self.success = success
28493 
    self.ex = ex
28494 
 
28495 
  def read(self, iprot):
28496 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28497 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28498 
      return
28499 
    iprot.readStructBegin()
28500 
    while True:
28501 
      (fname, ftype, fid) = iprot.readFieldBegin()
28502 
      if ftype == TType.STOP:
28503 
        break
28504 
      if fid == 0:
28505 
        if ftype == TType.STRUCT:
28506 
          self.success = RechargeOrder()
28507 
          self.success.read(iprot)
28508 
        else:
28509 
          iprot.skip(ftype)
28510 
      elif fid == 1:
28511 
        if ftype == TType.STRUCT:
28512 
          self.ex = TransactionServiceException()
28513 
          self.ex.read(iprot)
28514 
        else:
28515 
          iprot.skip(ftype)
28516 
      else:
28517 
        iprot.skip(ftype)
28518 
      iprot.readFieldEnd()
28519 
    iprot.readStructEnd()
28520 
 
28521 
  def write(self, oprot):
28522 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28523 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28524 
      return
28525 
    oprot.writeStructBegin('getRechargeOrdersForTransaction_result')
28526 
    if self.success is not None:
28527 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
28528 
      self.success.write(oprot)
28529 
      oprot.writeFieldEnd()
28530 
    if self.ex is not None:
28531 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
28532 
      self.ex.write(oprot)
28533 
      oprot.writeFieldEnd()
28534 
    oprot.writeFieldStop()
28535 
    oprot.writeStructEnd()
28536 
 
28537 
  def validate(self):
28538 
    return
28539 
 
28540 
 
28541 
  def __repr__(self):
28542 
    L = ['%s=%r' % (key, value)
28543 
      for key, value in self.__dict__.iteritems()]
28544 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28545 
 
28546 
  def __eq__(self, other):
28547 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28548 
 
28549 
  def __ne__(self, other):
28550 
    return not (self == other)
28551 
 
6048 rajveer 28552 
class getServiceProviders_args:
28553 
  """
28554 
  Attributes:
28555 
   - rechargeType
6206 rajveer 28556 
   - onlyActive
6048 rajveer 28557 
  """
28558 
 
28559 
  thrift_spec = (
28560 
    None, # 0
28561 
    (1, TType.I32, 'rechargeType', None, None, ), # 1
6206 rajveer 28562 
    (2, TType.BOOL, 'onlyActive', None, None, ), # 2
6048 rajveer 28563 
  )
28564 
 
6206 rajveer 28565 
  def __init__(self, rechargeType=None, onlyActive=None,):
6048 rajveer 28566 
    self.rechargeType = rechargeType
6206 rajveer 28567 
    self.onlyActive = onlyActive
6048 rajveer 28568 
 
28569 
  def read(self, iprot):
28570 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28571 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28572 
      return
28573 
    iprot.readStructBegin()
28574 
    while True:
28575 
      (fname, ftype, fid) = iprot.readFieldBegin()
28576 
      if ftype == TType.STOP:
28577 
        break
28578 
      if fid == 1:
28579 
        if ftype == TType.I32:
28580 
          self.rechargeType = iprot.readI32();
28581 
        else:
28582 
          iprot.skip(ftype)
6206 rajveer 28583 
      elif fid == 2:
28584 
        if ftype == TType.BOOL:
28585 
          self.onlyActive = iprot.readBool();
28586 
        else:
28587 
          iprot.skip(ftype)
6048 rajveer 28588 
      else:
28589 
        iprot.skip(ftype)
28590 
      iprot.readFieldEnd()
28591 
    iprot.readStructEnd()
28592 
 
28593 
  def write(self, oprot):
28594 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28595 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28596 
      return
28597 
    oprot.writeStructBegin('getServiceProviders_args')
28598 
    if self.rechargeType is not None:
28599 
      oprot.writeFieldBegin('rechargeType', TType.I32, 1)
28600 
      oprot.writeI32(self.rechargeType)
28601 
      oprot.writeFieldEnd()
6206 rajveer 28602 
    if self.onlyActive is not None:
28603 
      oprot.writeFieldBegin('onlyActive', TType.BOOL, 2)
28604 
      oprot.writeBool(self.onlyActive)
28605 
      oprot.writeFieldEnd()
6048 rajveer 28606 
    oprot.writeFieldStop()
28607 
    oprot.writeStructEnd()
28608 
 
28609 
  def validate(self):
28610 
    return
28611 
 
28612 
 
28613 
  def __repr__(self):
28614 
    L = ['%s=%r' % (key, value)
28615 
      for key, value in self.__dict__.iteritems()]
28616 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28617 
 
28618 
  def __eq__(self, other):
28619 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28620 
 
28621 
  def __ne__(self, other):
28622 
    return not (self == other)
28623 
 
28624 
class getServiceProviders_result:
28625 
  """
28626 
  Attributes:
28627 
   - success
28628 
  """
28629 
 
28630 
  thrift_spec = (
28631 
    (0, TType.MAP, 'success', (TType.I64,None,TType.STRING,None), None, ), # 0
28632 
  )
28633 
 
28634 
  def __init__(self, success=None,):
28635 
    self.success = success
28636 
 
28637 
  def read(self, iprot):
28638 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28639 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28640 
      return
28641 
    iprot.readStructBegin()
28642 
    while True:
28643 
      (fname, ftype, fid) = iprot.readFieldBegin()
28644 
      if ftype == TType.STOP:
28645 
        break
28646 
      if fid == 0:
28647 
        if ftype == TType.MAP:
28648 
          self.success = {}
6188 rajveer 28649 
          (_ktype671, _vtype672, _size670 ) = iprot.readMapBegin()
28650 
          for _i674 in xrange(_size670):
28651 
            _key675 = iprot.readI64();
28652 
            _val676 = iprot.readString();
28653 
            self.success[_key675] = _val676
6048 rajveer 28654 
          iprot.readMapEnd()
28655 
        else:
28656 
          iprot.skip(ftype)
28657 
      else:
28658 
        iprot.skip(ftype)
28659 
      iprot.readFieldEnd()
28660 
    iprot.readStructEnd()
28661 
 
28662 
  def write(self, oprot):
28663 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28664 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28665 
      return
28666 
    oprot.writeStructBegin('getServiceProviders_result')
28667 
    if self.success is not None:
28668 
      oprot.writeFieldBegin('success', TType.MAP, 0)
28669 
      oprot.writeMapBegin(TType.I64, TType.STRING, len(self.success))
6188 rajveer 28670 
      for kiter677,viter678 in self.success.items():
28671 
        oprot.writeI64(kiter677)
28672 
        oprot.writeString(viter678)
6048 rajveer 28673 
      oprot.writeMapEnd()
28674 
      oprot.writeFieldEnd()
28675 
    oprot.writeFieldStop()
28676 
    oprot.writeStructEnd()
28677 
 
28678 
  def validate(self):
28679 
    return
28680 
 
28681 
 
28682 
  def __repr__(self):
28683 
    L = ['%s=%r' % (key, value)
28684 
      for key, value in self.__dict__.iteritems()]
28685 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28686 
 
28687 
  def __eq__(self, other):
28688 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28689 
 
28690 
  def __ne__(self, other):
28691 
    return not (self == other)
28692 
 
28693 
class getServiceProviderForDevice_args:
28694 
  """
28695 
  Attributes:
6049 rajveer 28696 
   - rechargeType
6048 rajveer 28697 
   - deviceNumber
28698 
  """
28699 
 
28700 
  thrift_spec = (
28701 
    None, # 0
6049 rajveer 28702 
    (1, TType.I32, 'rechargeType', None, None, ), # 1
28703 
    (2, TType.STRING, 'deviceNumber', None, None, ), # 2
6048 rajveer 28704 
  )
28705 
 
6049 rajveer 28706 
  def __init__(self, rechargeType=None, deviceNumber=None,):
28707 
    self.rechargeType = rechargeType
6048 rajveer 28708 
    self.deviceNumber = deviceNumber
28709 
 
28710 
  def read(self, iprot):
28711 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28712 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28713 
      return
28714 
    iprot.readStructBegin()
28715 
    while True:
28716 
      (fname, ftype, fid) = iprot.readFieldBegin()
28717 
      if ftype == TType.STOP:
28718 
        break
28719 
      if fid == 1:
6049 rajveer 28720 
        if ftype == TType.I32:
28721 
          self.rechargeType = iprot.readI32();
28722 
        else:
28723 
          iprot.skip(ftype)
28724 
      elif fid == 2:
6048 rajveer 28725 
        if ftype == TType.STRING:
28726 
          self.deviceNumber = iprot.readString();
28727 
        else:
28728 
          iprot.skip(ftype)
28729 
      else:
28730 
        iprot.skip(ftype)
28731 
      iprot.readFieldEnd()
28732 
    iprot.readStructEnd()
28733 
 
28734 
  def write(self, oprot):
28735 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28736 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28737 
      return
28738 
    oprot.writeStructBegin('getServiceProviderForDevice_args')
6049 rajveer 28739 
    if self.rechargeType is not None:
28740 
      oprot.writeFieldBegin('rechargeType', TType.I32, 1)
28741 
      oprot.writeI32(self.rechargeType)
28742 
      oprot.writeFieldEnd()
6048 rajveer 28743 
    if self.deviceNumber is not None:
6049 rajveer 28744 
      oprot.writeFieldBegin('deviceNumber', TType.STRING, 2)
6048 rajveer 28745 
      oprot.writeString(self.deviceNumber)
28746 
      oprot.writeFieldEnd()
28747 
    oprot.writeFieldStop()
28748 
    oprot.writeStructEnd()
28749 
 
28750 
  def validate(self):
28751 
    return
28752 
 
28753 
 
28754 
  def __repr__(self):
28755 
    L = ['%s=%r' % (key, value)
28756 
      for key, value in self.__dict__.iteritems()]
28757 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28758 
 
28759 
  def __eq__(self, other):
28760 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28761 
 
28762 
  def __ne__(self, other):
28763 
    return not (self == other)
28764 
 
28765 
class getServiceProviderForDevice_result:
28766 
  """
28767 
  Attributes:
28768 
   - success
28769 
  """
28770 
 
28771 
  thrift_spec = (
6289 anupam.sin 28772 
    (0, TType.STRUCT, 'success', (DeviceNumberInfo, DeviceNumberInfo.thrift_spec), None, ), # 0
6048 rajveer 28773 
  )
28774 
 
28775 
  def __init__(self, success=None,):
28776 
    self.success = success
28777 
 
28778 
  def read(self, iprot):
28779 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28780 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28781 
      return
28782 
    iprot.readStructBegin()
28783 
    while True:
28784 
      (fname, ftype, fid) = iprot.readFieldBegin()
28785 
      if ftype == TType.STOP:
28786 
        break
28787 
      if fid == 0:
6289 anupam.sin 28788 
        if ftype == TType.STRUCT:
28789 
          self.success = DeviceNumberInfo()
28790 
          self.success.read(iprot)
6048 rajveer 28791 
        else:
28792 
          iprot.skip(ftype)
28793 
      else:
28794 
        iprot.skip(ftype)
28795 
      iprot.readFieldEnd()
28796 
    iprot.readStructEnd()
28797 
 
28798 
  def write(self, oprot):
28799 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28800 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28801 
      return
28802 
    oprot.writeStructBegin('getServiceProviderForDevice_result')
28803 
    if self.success is not None:
6289 anupam.sin 28804 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
28805 
      self.success.write(oprot)
6048 rajveer 28806 
      oprot.writeFieldEnd()
28807 
    oprot.writeFieldStop()
28808 
    oprot.writeStructEnd()
28809 
 
28810 
  def validate(self):
28811 
    return
28812 
 
28813 
 
28814 
  def __repr__(self):
28815 
    L = ['%s=%r' % (key, value)
28816 
      for key, value in self.__dict__.iteritems()]
28817 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28818 
 
28819 
  def __eq__(self, other):
28820 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28821 
 
28822 
  def __ne__(self, other):
28823 
    return not (self == other)
6094 rajveer 28824 
 
6269 rajveer 28825 
class validateRecharge_args:
28826 
  """
28827 
  Attributes:
28828 
   - rechargeType
28829 
   - deviceNumber
6307 anupam.sin 28830 
   - userSelectedProviderId
6591 anupam.sin 28831 
   - clientAddress
6269 rajveer 28832 
  """
28833 
 
28834 
  thrift_spec = (
28835 
    None, # 0
28836 
    (1, TType.I32, 'rechargeType', None, None, ), # 1
28837 
    (2, TType.STRING, 'deviceNumber', None, None, ), # 2
6336 anupam.sin 28838 
    (3, TType.I64, 'userSelectedProviderId', None, None, ), # 3
6591 anupam.sin 28839 
    (4, TType.STRING, 'clientAddress', None, None, ), # 4
6269 rajveer 28840 
  )
28841 
 
6591 anupam.sin 28842 
  def __init__(self, rechargeType=None, deviceNumber=None, userSelectedProviderId=None, clientAddress=None,):
6269 rajveer 28843 
    self.rechargeType = rechargeType
28844 
    self.deviceNumber = deviceNumber
6307 anupam.sin 28845 
    self.userSelectedProviderId = userSelectedProviderId
6591 anupam.sin 28846 
    self.clientAddress = clientAddress
6269 rajveer 28847 
 
28848 
  def read(self, iprot):
28849 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28850 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28851 
      return
28852 
    iprot.readStructBegin()
28853 
    while True:
28854 
      (fname, ftype, fid) = iprot.readFieldBegin()
28855 
      if ftype == TType.STOP:
28856 
        break
28857 
      if fid == 1:
28858 
        if ftype == TType.I32:
28859 
          self.rechargeType = iprot.readI32();
28860 
        else:
28861 
          iprot.skip(ftype)
28862 
      elif fid == 2:
28863 
        if ftype == TType.STRING:
28864 
          self.deviceNumber = iprot.readString();
28865 
        else:
28866 
          iprot.skip(ftype)
6307 anupam.sin 28867 
      elif fid == 3:
28868 
        if ftype == TType.I64:
28869 
          self.userSelectedProviderId = iprot.readI64();
28870 
        else:
28871 
          iprot.skip(ftype)
6591 anupam.sin 28872 
      elif fid == 4:
28873 
        if ftype == TType.STRING:
28874 
          self.clientAddress = iprot.readString();
28875 
        else:
28876 
          iprot.skip(ftype)
6269 rajveer 28877 
      else:
28878 
        iprot.skip(ftype)
28879 
      iprot.readFieldEnd()
28880 
    iprot.readStructEnd()
28881 
 
28882 
  def write(self, oprot):
28883 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28884 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28885 
      return
28886 
    oprot.writeStructBegin('validateRecharge_args')
28887 
    if self.rechargeType is not None:
28888 
      oprot.writeFieldBegin('rechargeType', TType.I32, 1)
28889 
      oprot.writeI32(self.rechargeType)
28890 
      oprot.writeFieldEnd()
28891 
    if self.deviceNumber is not None:
28892 
      oprot.writeFieldBegin('deviceNumber', TType.STRING, 2)
28893 
      oprot.writeString(self.deviceNumber)
28894 
      oprot.writeFieldEnd()
6307 anupam.sin 28895 
    if self.userSelectedProviderId is not None:
6336 anupam.sin 28896 
      oprot.writeFieldBegin('userSelectedProviderId', TType.I64, 3)
6307 anupam.sin 28897 
      oprot.writeI64(self.userSelectedProviderId)
28898 
      oprot.writeFieldEnd()
6591 anupam.sin 28899 
    if self.clientAddress is not None:
28900 
      oprot.writeFieldBegin('clientAddress', TType.STRING, 4)
28901 
      oprot.writeString(self.clientAddress)
28902 
      oprot.writeFieldEnd()
6269 rajveer 28903 
    oprot.writeFieldStop()
28904 
    oprot.writeStructEnd()
28905 
 
28906 
  def validate(self):
28907 
    return
28908 
 
28909 
 
28910 
  def __repr__(self):
28911 
    L = ['%s=%r' % (key, value)
28912 
      for key, value in self.__dict__.iteritems()]
28913 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28914 
 
28915 
  def __eq__(self, other):
28916 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28917 
 
28918 
  def __ne__(self, other):
28919 
    return not (self == other)
28920 
 
28921 
class validateRecharge_result:
28922 
  """
28923 
  Attributes:
28924 
   - success
28925 
  """
28926 
 
28927 
  thrift_spec = (
28928 
    (0, TType.STRING, 'success', None, None, ), # 0
28929 
  )
28930 
 
28931 
  def __init__(self, success=None,):
28932 
    self.success = success
28933 
 
28934 
  def read(self, iprot):
28935 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28936 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28937 
      return
28938 
    iprot.readStructBegin()
28939 
    while True:
28940 
      (fname, ftype, fid) = iprot.readFieldBegin()
28941 
      if ftype == TType.STOP:
28942 
        break
28943 
      if fid == 0:
28944 
        if ftype == TType.STRING:
28945 
          self.success = iprot.readString();
28946 
        else:
28947 
          iprot.skip(ftype)
28948 
      else:
28949 
        iprot.skip(ftype)
28950 
      iprot.readFieldEnd()
28951 
    iprot.readStructEnd()
28952 
 
28953 
  def write(self, oprot):
28954 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28955 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28956 
      return
28957 
    oprot.writeStructBegin('validateRecharge_result')
28958 
    if self.success is not None:
28959 
      oprot.writeFieldBegin('success', TType.STRING, 0)
28960 
      oprot.writeString(self.success)
28961 
      oprot.writeFieldEnd()
28962 
    oprot.writeFieldStop()
28963 
    oprot.writeStructEnd()
28964 
 
28965 
  def validate(self):
28966 
    return
28967 
 
28968 
 
28969 
  def __repr__(self):
28970 
    L = ['%s=%r' % (key, value)
28971 
      for key, value in self.__dict__.iteritems()]
28972 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28973 
 
28974 
  def __eq__(self, other):
28975 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28976 
 
28977 
  def __ne__(self, other):
28978 
    return not (self == other)
28979 
 
6094 rajveer 28980 
class getRechargeOrdersForDevice_args:
28981 
  """
28982 
  Attributes:
28983 
   - deviceNumber
28984 
  """
28985 
 
28986 
  thrift_spec = (
28987 
    None, # 0
28988 
    (1, TType.STRING, 'deviceNumber', None, None, ), # 1
28989 
  )
28990 
 
28991 
  def __init__(self, deviceNumber=None,):
28992 
    self.deviceNumber = deviceNumber
28993 
 
28994 
  def read(self, iprot):
28995 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28996 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28997 
      return
28998 
    iprot.readStructBegin()
28999 
    while True:
29000 
      (fname, ftype, fid) = iprot.readFieldBegin()
29001 
      if ftype == TType.STOP:
29002 
        break
29003 
      if fid == 1:
29004 
        if ftype == TType.STRING:
29005 
          self.deviceNumber = iprot.readString();
29006 
        else:
29007 
          iprot.skip(ftype)
29008 
      else:
29009 
        iprot.skip(ftype)
29010 
      iprot.readFieldEnd()
29011 
    iprot.readStructEnd()
29012 
 
29013 
  def write(self, oprot):
29014 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
29015 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
29016 
      return
29017 
    oprot.writeStructBegin('getRechargeOrdersForDevice_args')
29018 
    if self.deviceNumber is not None:
29019 
      oprot.writeFieldBegin('deviceNumber', TType.STRING, 1)
29020 
      oprot.writeString(self.deviceNumber)
29021 
      oprot.writeFieldEnd()
29022 
    oprot.writeFieldStop()
29023 
    oprot.writeStructEnd()
29024 
 
29025 
  def validate(self):
29026 
    return
29027 
 
29028 
 
29029 
  def __repr__(self):
29030 
    L = ['%s=%r' % (key, value)
29031 
      for key, value in self.__dict__.iteritems()]
29032 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
29033 
 
29034 
  def __eq__(self, other):
29035 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
29036 
 
29037 
  def __ne__(self, other):
29038 
    return not (self == other)
29039 
 
29040 
class getRechargeOrdersForDevice_result:
29041 
  """
29042 
  Attributes:
29043 
   - success
29044 
  """
29045 
 
29046 
  thrift_spec = (
29047 
    (0, TType.LIST, 'success', (TType.STRUCT,(RechargeOrder, RechargeOrder.thrift_spec)), None, ), # 0
29048 
  )
29049 
 
29050 
  def __init__(self, success=None,):
29051 
    self.success = success
29052 
 
29053 
  def read(self, iprot):
29054 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
29055 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
29056 
      return
29057 
    iprot.readStructBegin()
29058 
    while True:
29059 
      (fname, ftype, fid) = iprot.readFieldBegin()
29060 
      if ftype == TType.STOP:
29061 
        break
29062 
      if fid == 0:
29063 
        if ftype == TType.LIST:
29064 
          self.success = []
6188 rajveer 29065 
          (_etype682, _size679) = iprot.readListBegin()
29066 
          for _i683 in xrange(_size679):
29067 
            _elem684 = RechargeOrder()
29068 
            _elem684.read(iprot)
29069 
            self.success.append(_elem684)
6094 rajveer 29070 
          iprot.readListEnd()
29071 
        else:
29072 
          iprot.skip(ftype)
29073 
      else:
29074 
        iprot.skip(ftype)
29075 
      iprot.readFieldEnd()
29076 
    iprot.readStructEnd()
29077 
 
29078 
  def write(self, oprot):
29079 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
29080 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
29081 
      return
29082 
    oprot.writeStructBegin('getRechargeOrdersForDevice_result')
29083 
    if self.success is not None:
29084 
      oprot.writeFieldBegin('success', TType.LIST, 0)
29085 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 29086 
      for iter685 in self.success:
29087 
        iter685.write(oprot)
6094 rajveer 29088 
      oprot.writeListEnd()
29089 
      oprot.writeFieldEnd()
29090 
    oprot.writeFieldStop()
29091 
    oprot.writeStructEnd()
29092 
 
29093 
  def validate(self):
29094 
    return
29095 
 
29096 
 
29097 
  def __repr__(self):
29098 
    L = ['%s=%r' % (key, value)
29099 
      for key, value in self.__dict__.iteritems()]
29100 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
29101 
 
29102 
  def __eq__(self, other):
29103 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
29104 
 
29105 
  def __ne__(self, other):
29106 
    return not (self == other)
29107 
 
29108 
class addAmountToWallet_args:
29109 
  """
29110 
  Attributes:
29111 
   - userId
29112 
   - orderId
29113 
   - amount
29114 
  """
29115 
 
29116 
  thrift_spec = (
29117 
    None, # 0
29118 
    (1, TType.I64, 'userId', None, None, ), # 1
29119 
    (2, TType.I64, 'orderId', None, None, ), # 2
29120 
    (3, TType.I64, 'amount', None, None, ), # 3
29121 
  )
29122 
 
29123 
  def __init__(self, userId=None, orderId=None, amount=None,):
29124 
    self.userId = userId
29125 
    self.orderId = orderId
29126 
    self.amount = amount
29127 
 
29128 
  def read(self, iprot):
29129 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
29130 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
29131 
      return
29132 
    iprot.readStructBegin()
29133 
    while True:
29134 
      (fname, ftype, fid) = iprot.readFieldBegin()
29135 
      if ftype == TType.STOP:
29136 
        break
29137 
      if fid == 1:
29138 
        if ftype == TType.I64:
29139 
          self.userId = iprot.readI64();
29140 
        else:
29141 
          iprot.skip(ftype)
29142 
      elif fid == 2:
29143 
        if ftype == TType.I64:
29144 
          self.orderId = iprot.readI64();
29145 
        else:
29146 
          iprot.skip(ftype)
29147 
      elif fid == 3:
29148 
        if ftype == TType.I64:
29149 
          self.amount = iprot.readI64();
29150 
        else:
29151 
          iprot.skip(ftype)
29152 
      else:
29153 
        iprot.skip(ftype)
29154 
      iprot.readFieldEnd()
29155 
    iprot.readStructEnd()
29156 
 
29157 
  def write(self, oprot):
29158 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
29159 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
29160 
      return
29161 
    oprot.writeStructBegin('addAmountToWallet_args')
29162 
    if self.userId is not None:
29163 
      oprot.writeFieldBegin('userId', TType.I64, 1)
29164 
      oprot.writeI64(self.userId)
29165 
      oprot.writeFieldEnd()
29166 
    if self.orderId is not None:
29167 
      oprot.writeFieldBegin('orderId', TType.I64, 2)
29168 
      oprot.writeI64(self.orderId)
29169 
      oprot.writeFieldEnd()
29170 
    if self.amount is not None:
29171 
      oprot.writeFieldBegin('amount', TType.I64, 3)
29172 
      oprot.writeI64(self.amount)
29173 
      oprot.writeFieldEnd()
29174 
    oprot.writeFieldStop()
29175 
    oprot.writeStructEnd()
29176 
 
29177 
  def validate(self):
29178 
    return
29179 
 
29180 
 
29181 
  def __repr__(self):
29182 
    L = ['%s=%r' % (key, value)
29183 
      for key, value in self.__dict__.iteritems()]
29184 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
29185 
 
29186 
  def __eq__(self, other):
29187 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
29188 
 
29189 
  def __ne__(self, other):
29190 
    return not (self == other)
29191 
 
29192 
class addAmountToWallet_result:
29193 
 
29194 
  thrift_spec = (
29195 
  )
29196 
 
29197 
  def read(self, iprot):
29198 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
29199 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
29200 
      return
29201 
    iprot.readStructBegin()
29202 
    while True:
29203 
      (fname, ftype, fid) = iprot.readFieldBegin()
29204 
      if ftype == TType.STOP:
29205 
        break
29206 
      else:
29207 
        iprot.skip(ftype)
29208 
      iprot.readFieldEnd()
29209 
    iprot.readStructEnd()
29210 
 
29211 
  def write(self, oprot):
29212 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
29213 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
29214 
      return
29215 
    oprot.writeStructBegin('addAmountToWallet_result')
29216 
    oprot.writeFieldStop()
29217 
    oprot.writeStructEnd()
29218 
 
29219 
  def validate(self):
29220 
    return
29221 
 
29222 
 
29223 
  def __repr__(self):
29224 
    L = ['%s=%r' % (key, value)
29225 
      for key, value in self.__dict__.iteritems()]
29226 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
29227 
 
29228 
  def __eq__(self, other):
29229 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
29230 
 
29231 
  def __ne__(self, other):
29232 
    return not (self == other)
6154 rajveer 29233 
 
6188 rajveer 29234 
class getRechargeStatistics_args:
29235 
 
29236 
  thrift_spec = (
29237 
  )
29238 
 
29239 
  def read(self, iprot):
29240 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
29241 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
29242 
      return
29243 
    iprot.readStructBegin()
29244 
    while True:
29245 
      (fname, ftype, fid) = iprot.readFieldBegin()
29246 
      if ftype == TType.STOP:
29247 
        break
29248 
      else:
29249 
        iprot.skip(ftype)
29250 
      iprot.readFieldEnd()
29251 
    iprot.readStructEnd()
29252 
 
29253 
  def write(self, oprot):
29254 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
29255 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
29256 
      return
29257 
    oprot.writeStructBegin('getRechargeStatistics_args')
29258 
    oprot.writeFieldStop()
29259 
    oprot.writeStructEnd()
29260 
 
29261 
  def validate(self):
29262 
    return
29263 
 
29264 
 
29265 
  def __repr__(self):
29266 
    L = ['%s=%r' % (key, value)
29267 
      for key, value in self.__dict__.iteritems()]
29268 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
29269 
 
29270 
  def __eq__(self, other):
29271 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
29272 
 
29273 
  def __ne__(self, other):
29274 
    return not (self == other)
29275 
 
29276 
class getRechargeStatistics_result:
29277 
  """
29278 
  Attributes:
29279 
   - success
29280 
  """
29281 
 
29282 
  thrift_spec = (
29283 
    (0, TType.STRUCT, 'success', (RechargeStatistics, RechargeStatistics.thrift_spec), None, ), # 0
29284 
  )
29285 
 
29286 
  def __init__(self, success=None,):
29287 
    self.success = success
29288 
 
29289 
  def read(self, iprot):
29290 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
29291 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
29292 
      return
29293 
    iprot.readStructBegin()
29294 
    while True:
29295 
      (fname, ftype, fid) = iprot.readFieldBegin()
29296 
      if ftype == TType.STOP:
29297 
        break
29298 
      if fid == 0:
29299 
        if ftype == TType.STRUCT:
29300 
          self.success = RechargeStatistics()
29301 
          self.success.read(iprot)
29302 
        else:
29303 
          iprot.skip(ftype)
29304 
      else:
29305 
        iprot.skip(ftype)
29306 
      iprot.readFieldEnd()
29307 
    iprot.readStructEnd()
29308 
 
29309 
  def write(self, oprot):
29310 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
29311 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
29312 
      return
29313 
    oprot.writeStructBegin('getRechargeStatistics_result')
29314 
    if self.success is not None:
29315 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
29316 
      self.success.write(oprot)
29317 
      oprot.writeFieldEnd()
29318 
    oprot.writeFieldStop()
29319 
    oprot.writeStructEnd()
29320 
 
29321 
  def validate(self):
29322 
    return
29323 
 
29324 
 
29325 
  def __repr__(self):
29326 
    L = ['%s=%r' % (key, value)
29327 
      for key, value in self.__dict__.iteritems()]
29328 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
29329 
 
29330 
  def __eq__(self, other):
29331 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
29332 
 
29333 
  def __ne__(self, other):
29334 
    return not (self == other)
29335 
 
6154 rajveer 29336 
class getRechargeOrdersForStatus_args:
29337 
  """
29338 
  Attributes:
29339 
   - status
29340 
  """
29341 
 
29342 
  thrift_spec = (
29343 
    None, # 0
29344 
    (1, TType.I64, 'status', None, None, ), # 1
29345 
  )
29346 
 
29347 
  def __init__(self, status=None,):
29348 
    self.status = status
29349 
 
29350 
  def read(self, iprot):
29351 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
29352 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
29353 
      return
29354 
    iprot.readStructBegin()
29355 
    while True:
29356 
      (fname, ftype, fid) = iprot.readFieldBegin()
29357 
      if ftype == TType.STOP:
29358 
        break
29359 
      if fid == 1:
29360 
        if ftype == TType.I64:
29361 
          self.status = iprot.readI64();
29362 
        else:
29363 
          iprot.skip(ftype)
29364 
      else:
29365 
        iprot.skip(ftype)
29366 
      iprot.readFieldEnd()
29367 
    iprot.readStructEnd()
29368 
 
29369 
  def write(self, oprot):
29370 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
29371 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
29372 
      return
29373 
    oprot.writeStructBegin('getRechargeOrdersForStatus_args')
29374 
    if self.status is not None:
29375 
      oprot.writeFieldBegin('status', TType.I64, 1)
29376 
      oprot.writeI64(self.status)
29377 
      oprot.writeFieldEnd()
29378 
    oprot.writeFieldStop()
29379 
    oprot.writeStructEnd()
29380 
 
29381 
  def validate(self):
29382 
    return
29383 
 
29384 
 
29385 
  def __repr__(self):
29386 
    L = ['%s=%r' % (key, value)
29387 
      for key, value in self.__dict__.iteritems()]
29388 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
29389 
 
29390 
  def __eq__(self, other):
29391 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
29392 
 
29393 
  def __ne__(self, other):
29394 
    return not (self == other)
29395 
 
29396 
class getRechargeOrdersForStatus_result:
29397 
  """
29398 
  Attributes:
29399 
   - success
29400 
  """
29401 
 
29402 
  thrift_spec = (
29403 
    (0, TType.LIST, 'success', (TType.STRUCT,(RechargeOrder, RechargeOrder.thrift_spec)), None, ), # 0
29404 
  )
29405 
 
29406 
  def __init__(self, success=None,):
29407 
    self.success = success
29408 
 
29409 
  def read(self, iprot):
29410 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
29411 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
29412 
      return
29413 
    iprot.readStructBegin()
29414 
    while True:
29415 
      (fname, ftype, fid) = iprot.readFieldBegin()
29416 
      if ftype == TType.STOP:
29417 
        break
29418 
      if fid == 0:
29419 
        if ftype == TType.LIST:
29420 
          self.success = []
6188 rajveer 29421 
          (_etype689, _size686) = iprot.readListBegin()
29422 
          for _i690 in xrange(_size686):
29423 
            _elem691 = RechargeOrder()
29424 
            _elem691.read(iprot)
29425 
            self.success.append(_elem691)
6154 rajveer 29426 
          iprot.readListEnd()
29427 
        else:
29428 
          iprot.skip(ftype)
29429 
      else:
29430 
        iprot.skip(ftype)
29431 
      iprot.readFieldEnd()
29432 
    iprot.readStructEnd()
29433 
 
29434 
  def write(self, oprot):
29435 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
29436 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
29437 
      return
29438 
    oprot.writeStructBegin('getRechargeOrdersForStatus_result')
29439 
    if self.success is not None:
29440 
      oprot.writeFieldBegin('success', TType.LIST, 0)
29441 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 29442 
      for iter692 in self.success:
29443 
        iter692.write(oprot)
6154 rajveer 29444 
      oprot.writeListEnd()
29445 
      oprot.writeFieldEnd()
29446 
    oprot.writeFieldStop()
29447 
    oprot.writeStructEnd()
29448 
 
29449 
  def validate(self):
29450 
    return
29451 
 
29452 
 
29453 
  def __repr__(self):
29454 
    L = ['%s=%r' % (key, value)
29455 
      for key, value in self.__dict__.iteritems()]
29456 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
29457 
 
29458 
  def __eq__(self, other):
29459 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
29460 
 
29461 
  def __ne__(self, other):
29462 
    return not (self == other)
6159 rajveer 29463 
 
29464 
class getPlansForOperator_args:
29465 
  """
29466 
  Attributes:
29467 
   - operatorId
29468 
  """
29469 
 
29470 
  thrift_spec = (
29471 
    None, # 0
29472 
    (1, TType.I64, 'operatorId', None, None, ), # 1
29473 
  )
29474 
 
29475 
  def __init__(self, operatorId=None,):
29476 
    self.operatorId = operatorId
29477 
 
29478 
  def read(self, iprot):
29479 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
29480 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
29481 
      return
29482 
    iprot.readStructBegin()
29483 
    while True:
29484 
      (fname, ftype, fid) = iprot.readFieldBegin()
29485 
      if ftype == TType.STOP:
29486 
        break
29487 
      if fid == 1:
29488 
        if ftype == TType.I64:
29489 
          self.operatorId = iprot.readI64();
29490 
        else:
29491 
          iprot.skip(ftype)
29492 
      else:
29493 
        iprot.skip(ftype)
29494 
      iprot.readFieldEnd()
29495 
    iprot.readStructEnd()
29496 
 
29497 
  def write(self, oprot):
29498 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
29499 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
29500 
      return
29501 
    oprot.writeStructBegin('getPlansForOperator_args')
29502 
    if self.operatorId is not None:
29503 
      oprot.writeFieldBegin('operatorId', TType.I64, 1)
29504 
      oprot.writeI64(self.operatorId)
29505 
      oprot.writeFieldEnd()
29506 
    oprot.writeFieldStop()
29507 
    oprot.writeStructEnd()
29508 
 
29509 
  def validate(self):
29510 
    return
29511 
 
29512 
 
29513 
  def __repr__(self):
29514 
    L = ['%s=%r' % (key, value)
29515 
      for key, value in self.__dict__.iteritems()]
29516 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
29517 
 
29518 
  def __eq__(self, other):
29519 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
29520 
 
29521 
  def __ne__(self, other):
29522 
    return not (self == other)
29523 
 
29524 
class getPlansForOperator_result:
29525 
  """
29526 
  Attributes:
29527 
   - success
29528 
  """
29529 
 
29530 
  thrift_spec = (
29531 
    (0, TType.LIST, 'success', (TType.STRUCT,(RechargePlan, RechargePlan.thrift_spec)), None, ), # 0
29532 
  )
29533 
 
29534 
  def __init__(self, success=None,):
29535 
    self.success = success
29536 
 
29537 
  def read(self, iprot):
29538 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
29539 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
29540 
      return
29541 
    iprot.readStructBegin()
29542 
    while True:
29543 
      (fname, ftype, fid) = iprot.readFieldBegin()
29544 
      if ftype == TType.STOP:
29545 
        break
29546 
      if fid == 0:
29547 
        if ftype == TType.LIST:
29548 
          self.success = []
6188 rajveer 29549 
          (_etype696, _size693) = iprot.readListBegin()
29550 
          for _i697 in xrange(_size693):
29551 
            _elem698 = RechargePlan()
29552 
            _elem698.read(iprot)
29553 
            self.success.append(_elem698)
6159 rajveer 29554 
          iprot.readListEnd()
29555 
        else:
29556 
          iprot.skip(ftype)
29557 
      else:
29558 
        iprot.skip(ftype)
29559 
      iprot.readFieldEnd()
29560 
    iprot.readStructEnd()
29561 
 
29562 
  def write(self, oprot):
29563 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
29564 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
29565 
      return
29566 
    oprot.writeStructBegin('getPlansForOperator_result')
29567 
    if self.success is not None:
29568 
      oprot.writeFieldBegin('success', TType.LIST, 0)
29569 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 29570 
      for iter699 in self.success:
29571 
        iter699.write(oprot)
6159 rajveer 29572 
      oprot.writeListEnd()
29573 
      oprot.writeFieldEnd()
29574 
    oprot.writeFieldStop()
29575 
    oprot.writeStructEnd()
29576 
 
29577 
  def validate(self):
29578 
    return
29579 
 
29580 
 
29581 
  def __repr__(self):
29582 
    L = ['%s=%r' % (key, value)
29583 
      for key, value in self.__dict__.iteritems()]
29584 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
29585 
 
29586 
  def __eq__(self, other):
29587 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
29588 
 
29589 
  def __ne__(self, other):
29590 
    return not (self == other)
6289 anupam.sin 29591 
 
29592 
class getRechargeDenominations_args:
29593 
  """
29594 
  Attributes:
29595 
   - operatorId
6307 anupam.sin 29596 
   - circleCode
6289 anupam.sin 29597 
   - denominationType
29598 
  """
29599 
 
29600 
  thrift_spec = (
29601 
    None, # 0
29602 
    (1, TType.I64, 'operatorId', None, None, ), # 1
6307 anupam.sin 29603 
    (2, TType.STRING, 'circleCode', None, None, ), # 2
6289 anupam.sin 29604 
    (3, TType.I32, 'denominationType', None, None, ), # 3
29605 
  )
29606 
 
6307 anupam.sin 29607 
  def __init__(self, operatorId=None, circleCode=None, denominationType=None,):
6289 anupam.sin 29608 
    self.operatorId = operatorId
6307 anupam.sin 29609 
    self.circleCode = circleCode
6289 anupam.sin 29610 
    self.denominationType = denominationType
29611 
 
29612 
  def read(self, iprot):
29613 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
29614 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
29615 
      return
29616 
    iprot.readStructBegin()
29617 
    while True:
29618 
      (fname, ftype, fid) = iprot.readFieldBegin()
29619 
      if ftype == TType.STOP:
29620 
        break
29621 
      if fid == 1:
29622 
        if ftype == TType.I64:
29623 
          self.operatorId = iprot.readI64();
29624 
        else:
29625 
          iprot.skip(ftype)
29626 
      elif fid == 2:
29627 
        if ftype == TType.STRING:
6307 anupam.sin 29628 
          self.circleCode = iprot.readString();
6289 anupam.sin 29629 
        else:
29630 
          iprot.skip(ftype)
29631 
      elif fid == 3:
29632 
        if ftype == TType.I32:
29633 
          self.denominationType = iprot.readI32();
29634 
        else:
29635 
          iprot.skip(ftype)
29636 
      else:
29637 
        iprot.skip(ftype)
29638 
      iprot.readFieldEnd()
29639 
    iprot.readStructEnd()
29640 
 
29641 
  def write(self, oprot):
29642 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
29643 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
29644 
      return
29645 
    oprot.writeStructBegin('getRechargeDenominations_args')
29646 
    if self.operatorId is not None:
29647 
      oprot.writeFieldBegin('operatorId', TType.I64, 1)
29648 
      oprot.writeI64(self.operatorId)
29649 
      oprot.writeFieldEnd()
6307 anupam.sin 29650 
    if self.circleCode is not None:
29651 
      oprot.writeFieldBegin('circleCode', TType.STRING, 2)
29652 
      oprot.writeString(self.circleCode)
6289 anupam.sin 29653 
      oprot.writeFieldEnd()
29654 
    if self.denominationType is not None:
29655 
      oprot.writeFieldBegin('denominationType', TType.I32, 3)
29656 
      oprot.writeI32(self.denominationType)
29657 
      oprot.writeFieldEnd()
29658 
    oprot.writeFieldStop()
29659 
    oprot.writeStructEnd()
29660 
 
29661 
  def validate(self):
29662 
    return
29663 
 
29664 
 
29665 
  def __repr__(self):
29666 
    L = ['%s=%r' % (key, value)
29667 
      for key, value in self.__dict__.iteritems()]
29668 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
29669 
 
29670 
  def __eq__(self, other):
29671 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
29672 
 
29673 
  def __ne__(self, other):
29674 
    return not (self == other)
29675 
 
29676 
class getRechargeDenominations_result:
29677 
  """
29678 
  Attributes:
29679 
   - success
29680 
   - ex
29681 
  """
29682 
 
29683 
  thrift_spec = (
29684 
    (0, TType.LIST, 'success', (TType.STRUCT,(RechargeDenomination, RechargeDenomination.thrift_spec)), None, ), # 0
29685 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
29686 
  )
29687 
 
29688 
  def __init__(self, success=None, ex=None,):
29689 
    self.success = success
29690 
    self.ex = ex
29691 
 
29692 
  def read(self, iprot):
29693 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
29694 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
29695 
      return
29696 
    iprot.readStructBegin()
29697 
    while True:
29698 
      (fname, ftype, fid) = iprot.readFieldBegin()
29699 
      if ftype == TType.STOP:
29700 
        break
29701 
      if fid == 0:
29702 
        if ftype == TType.LIST:
29703 
          self.success = []
29704 
          (_etype703, _size700) = iprot.readListBegin()
29705 
          for _i704 in xrange(_size700):
29706 
            _elem705 = RechargeDenomination()
29707 
            _elem705.read(iprot)
29708 
            self.success.append(_elem705)
29709 
          iprot.readListEnd()
29710 
        else:
29711 
          iprot.skip(ftype)
29712 
      elif fid == 1:
29713 
        if ftype == TType.STRUCT:
29714 
          self.ex = TransactionServiceException()
29715 
          self.ex.read(iprot)
29716 
        else:
29717 
          iprot.skip(ftype)
29718 
      else:
29719 
        iprot.skip(ftype)
29720 
      iprot.readFieldEnd()
29721 
    iprot.readStructEnd()
29722 
 
29723 
  def write(self, oprot):
29724 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
29725 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
29726 
      return
29727 
    oprot.writeStructBegin('getRechargeDenominations_result')
29728 
    if self.success is not None:
29729 
      oprot.writeFieldBegin('success', TType.LIST, 0)
29730 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
29731 
      for iter706 in self.success:
29732 
        iter706.write(oprot)
29733 
      oprot.writeListEnd()
29734 
      oprot.writeFieldEnd()
29735 
    if self.ex is not None:
29736 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
29737 
      self.ex.write(oprot)
29738 
      oprot.writeFieldEnd()
29739 
    oprot.writeFieldStop()
29740 
    oprot.writeStructEnd()
29741 
 
29742 
  def validate(self):
29743 
    return
29744 
 
29745 
 
29746 
  def __repr__(self):
29747 
    L = ['%s=%r' % (key, value)
29748 
      for key, value in self.__dict__.iteritems()]
29749 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
29750 
 
29751 
  def __eq__(self, other):
29752 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
29753 
 
29754 
  def __ne__(self, other):
29755 
    return not (self == other)
6371 rajveer 29756 
 
29757 
class updateAvailabilityStatus_args:
29758 
  """
29759 
  Attributes:
29760 
   - operatorId
29761 
   - circleId
29762 
   - isAvailable
29763 
  """
29764 
 
29765 
  thrift_spec = (
29766 
    None, # 0
29767 
    (1, TType.I64, 'operatorId', None, None, ), # 1
29768 
    (2, TType.I64, 'circleId', None, None, ), # 2
29769 
    (3, TType.BOOL, 'isAvailable', None, None, ), # 3
29770 
  )
29771 
 
29772 
  def __init__(self, operatorId=None, circleId=None, isAvailable=None,):
29773 
    self.operatorId = operatorId
29774 
    self.circleId = circleId
29775 
    self.isAvailable = isAvailable
29776 
 
29777 
  def read(self, iprot):
29778 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
29779 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
29780 
      return
29781 
    iprot.readStructBegin()
29782 
    while True:
29783 
      (fname, ftype, fid) = iprot.readFieldBegin()
29784 
      if ftype == TType.STOP:
29785 
        break
29786 
      if fid == 1:
29787 
        if ftype == TType.I64:
29788 
          self.operatorId = iprot.readI64();
29789 
        else:
29790 
          iprot.skip(ftype)
29791 
      elif fid == 2:
29792 
        if ftype == TType.I64:
29793 
          self.circleId = iprot.readI64();
29794 
        else:
29795 
          iprot.skip(ftype)
29796 
      elif fid == 3:
29797 
        if ftype == TType.BOOL:
29798 
          self.isAvailable = iprot.readBool();
29799 
        else:
29800 
          iprot.skip(ftype)
29801 
      else:
29802 
        iprot.skip(ftype)
29803 
      iprot.readFieldEnd()
29804 
    iprot.readStructEnd()
29805 
 
29806 
  def write(self, oprot):
29807 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
29808 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
29809 
      return
29810 
    oprot.writeStructBegin('updateAvailabilityStatus_args')
29811 
    if self.operatorId is not None:
29812 
      oprot.writeFieldBegin('operatorId', TType.I64, 1)
29813 
      oprot.writeI64(self.operatorId)
29814 
      oprot.writeFieldEnd()
29815 
    if self.circleId is not None:
29816 
      oprot.writeFieldBegin('circleId', TType.I64, 2)
29817 
      oprot.writeI64(self.circleId)
29818 
      oprot.writeFieldEnd()
29819 
    if self.isAvailable is not None:
29820 
      oprot.writeFieldBegin('isAvailable', TType.BOOL, 3)
29821 
      oprot.writeBool(self.isAvailable)
29822 
      oprot.writeFieldEnd()
29823 
    oprot.writeFieldStop()
29824 
    oprot.writeStructEnd()
29825 
 
29826 
  def validate(self):
29827 
    return
29828 
 
29829 
 
29830 
  def __repr__(self):
29831 
    L = ['%s=%r' % (key, value)
29832 
      for key, value in self.__dict__.iteritems()]
29833 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
29834 
 
29835 
  def __eq__(self, other):
29836 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
29837 
 
29838 
  def __ne__(self, other):
29839 
    return not (self == other)
29840 
 
29841 
class updateAvailabilityStatus_result:
29842 
 
29843 
  thrift_spec = (
29844 
  )
29845 
 
29846 
  def read(self, iprot):
29847 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
29848 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
29849 
      return
29850 
    iprot.readStructBegin()
29851 
    while True:
29852 
      (fname, ftype, fid) = iprot.readFieldBegin()
29853 
      if ftype == TType.STOP:
29854 
        break
29855 
      else:
29856 
        iprot.skip(ftype)
29857 
      iprot.readFieldEnd()
29858 
    iprot.readStructEnd()
29859 
 
29860 
  def write(self, oprot):
29861 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
29862 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
29863 
      return
29864 
    oprot.writeStructBegin('updateAvailabilityStatus_result')
29865 
    oprot.writeFieldStop()
29866 
    oprot.writeStructEnd()
29867 
 
29868 
  def validate(self):
29869 
    return
29870 
 
29871 
 
29872 
  def __repr__(self):
29873 
    L = ['%s=%r' % (key, value)
29874 
      for key, value in self.__dict__.iteritems()]
29875 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
29876 
 
29877 
  def __eq__(self, other):
29878 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
29879 
 
29880 
  def __ne__(self, other):
29881 
    return not (self == other)
6389 rajveer 29882 
 
29883 
class getAvailableEmiSchemes_args:
29884 
 
29885 
  thrift_spec = (
29886 
  )
29887 
 
29888 
  def read(self, iprot):
29889 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
29890 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
29891 
      return
29892 
    iprot.readStructBegin()
29893 
    while True:
29894 
      (fname, ftype, fid) = iprot.readFieldBegin()
29895 
      if ftype == TType.STOP:
29896 
        break
29897 
      else:
29898 
        iprot.skip(ftype)
29899 
      iprot.readFieldEnd()
29900 
    iprot.readStructEnd()
29901 
 
29902 
  def write(self, oprot):
29903 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
29904 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
29905 
      return
29906 
    oprot.writeStructBegin('getAvailableEmiSchemes_args')
29907 
    oprot.writeFieldStop()
29908 
    oprot.writeStructEnd()
29909 
 
29910 
  def validate(self):
29911 
    return
29912 
 
29913 
 
29914 
  def __repr__(self):
29915 
    L = ['%s=%r' % (key, value)
29916 
      for key, value in self.__dict__.iteritems()]
29917 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
29918 
 
29919 
  def __eq__(self, other):
29920 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
29921 
 
29922 
  def __ne__(self, other):
29923 
    return not (self == other)
29924 
 
29925 
class getAvailableEmiSchemes_result:
29926 
  """
29927 
  Attributes:
29928 
   - success
29929 
  """
29930 
 
29931 
  thrift_spec = (
29932 
    (0, TType.LIST, 'success', (TType.STRUCT,(EmiScheme, EmiScheme.thrift_spec)), None, ), # 0
29933 
  )
29934 
 
29935 
  def __init__(self, success=None,):
29936 
    self.success = success
29937 
 
29938 
  def read(self, iprot):
29939 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
29940 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
29941 
      return
29942 
    iprot.readStructBegin()
29943 
    while True:
29944 
      (fname, ftype, fid) = iprot.readFieldBegin()
29945 
      if ftype == TType.STOP:
29946 
        break
29947 
      if fid == 0:
29948 
        if ftype == TType.LIST:
29949 
          self.success = []
29950 
          (_etype710, _size707) = iprot.readListBegin()
29951 
          for _i711 in xrange(_size707):
29952 
            _elem712 = EmiScheme()
29953 
            _elem712.read(iprot)
29954 
            self.success.append(_elem712)
29955 
          iprot.readListEnd()
29956 
        else:
29957 
          iprot.skip(ftype)
29958 
      else:
29959 
        iprot.skip(ftype)
29960 
      iprot.readFieldEnd()
29961 
    iprot.readStructEnd()
29962 
 
29963 
  def write(self, oprot):
29964 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
29965 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
29966 
      return
29967 
    oprot.writeStructBegin('getAvailableEmiSchemes_result')
29968 
    if self.success is not None:
29969 
      oprot.writeFieldBegin('success', TType.LIST, 0)
29970 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
29971 
      for iter713 in self.success:
29972 
        iter713.write(oprot)
29973 
      oprot.writeListEnd()
29974 
      oprot.writeFieldEnd()
29975 
    oprot.writeFieldStop()
29976 
    oprot.writeStructEnd()
29977 
 
29978 
  def validate(self):
29979 
    return
29980 
 
29981 
 
29982 
  def __repr__(self):
29983 
    L = ['%s=%r' % (key, value)
29984 
      for key, value in self.__dict__.iteritems()]
29985 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
29986 
 
29987 
  def __eq__(self, other):
29988 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
29989 
 
29990 
  def __ne__(self, other):
29991 
    return not (self == other)
29992 
 
29993 
class getMiscCharges_args:
29994 
  """
29995 
  Attributes:
29996 
   - transactionId
29997 
  """
29998 
 
29999 
  thrift_spec = (
30000 
    None, # 0
30001 
    (1, TType.I64, 'transactionId', None, None, ), # 1
30002 
  )
30003 
 
30004 
  def __init__(self, transactionId=None,):
30005 
    self.transactionId = transactionId
30006 
 
30007 
  def read(self, iprot):
30008 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
30009 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
30010 
      return
30011 
    iprot.readStructBegin()
30012 
    while True:
30013 
      (fname, ftype, fid) = iprot.readFieldBegin()
30014 
      if ftype == TType.STOP:
30015 
        break
30016 
      if fid == 1:
30017 
        if ftype == TType.I64:
30018 
          self.transactionId = iprot.readI64();
30019 
        else:
30020 
          iprot.skip(ftype)
30021 
      else:
30022 
        iprot.skip(ftype)
30023 
      iprot.readFieldEnd()
30024 
    iprot.readStructEnd()
30025 
 
30026 
  def write(self, oprot):
30027 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
30028 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
30029 
      return
30030 
    oprot.writeStructBegin('getMiscCharges_args')
30031 
    if self.transactionId is not None:
30032 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
30033 
      oprot.writeI64(self.transactionId)
30034 
      oprot.writeFieldEnd()
30035 
    oprot.writeFieldStop()
30036 
    oprot.writeStructEnd()
30037 
 
30038 
  def validate(self):
30039 
    return
30040 
 
30041 
 
30042 
  def __repr__(self):
30043 
    L = ['%s=%r' % (key, value)
30044 
      for key, value in self.__dict__.iteritems()]
30045 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
30046 
 
30047 
  def __eq__(self, other):
30048 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
30049 
 
30050 
  def __ne__(self, other):
30051 
    return not (self == other)
30052 
 
30053 
class getMiscCharges_result:
30054 
  """
30055 
  Attributes:
30056 
   - success
30057 
  """
30058 
 
30059 
  thrift_spec = (
6412 rajveer 30060 
    (0, TType.MAP, 'success', (TType.I64,None,TType.DOUBLE,None), None, ), # 0
6389 rajveer 30061 
  )
30062 
 
30063 
  def __init__(self, success=None,):
30064 
    self.success = success
30065 
 
30066 
  def read(self, iprot):
30067 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
30068 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
30069 
      return
30070 
    iprot.readStructBegin()
30071 
    while True:
30072 
      (fname, ftype, fid) = iprot.readFieldBegin()
30073 
      if ftype == TType.STOP:
30074 
        break
30075 
      if fid == 0:
30076 
        if ftype == TType.MAP:
30077 
          self.success = {}
30078 
          (_ktype715, _vtype716, _size714 ) = iprot.readMapBegin()
30079 
          for _i718 in xrange(_size714):
30080 
            _key719 = iprot.readI64();
6412 rajveer 30081 
            _val720 = iprot.readDouble();
6389 rajveer 30082 
            self.success[_key719] = _val720
30083 
          iprot.readMapEnd()
30084 
        else:
30085 
          iprot.skip(ftype)
30086 
      else:
30087 
        iprot.skip(ftype)
30088 
      iprot.readFieldEnd()
30089 
    iprot.readStructEnd()
30090 
 
30091 
  def write(self, oprot):
30092 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
30093 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
30094 
      return
30095 
    oprot.writeStructBegin('getMiscCharges_result')
30096 
    if self.success is not None:
30097 
      oprot.writeFieldBegin('success', TType.MAP, 0)
6412 rajveer 30098 
      oprot.writeMapBegin(TType.I64, TType.DOUBLE, len(self.success))
6389 rajveer 30099 
      for kiter721,viter722 in self.success.items():
30100 
        oprot.writeI64(kiter721)
6412 rajveer 30101 
        oprot.writeDouble(viter722)
6389 rajveer 30102 
      oprot.writeMapEnd()
30103 
      oprot.writeFieldEnd()
30104 
    oprot.writeFieldStop()
30105 
    oprot.writeStructEnd()
30106 
 
30107 
  def validate(self):
30108 
    return
30109 
 
30110 
 
30111 
  def __repr__(self):
30112 
    L = ['%s=%r' % (key, value)
30113 
      for key, value in self.__dict__.iteritems()]
30114 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
30115 
 
30116 
  def __eq__(self, other):
30117 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
30118 
 
30119 
  def __ne__(self, other):
30120 
    return not (self == other)
6507 anupam.sin 30121 
 
30122 
class refundRechargeOrder_args:
30123 
  """
30124 
  Attributes:
30125 
   - rechargeOrderId
30126 
  """
30127 
 
30128 
  thrift_spec = (
30129 
    None, # 0
30130 
    (1, TType.I64, 'rechargeOrderId', None, None, ), # 1
30131 
  )
30132 
 
30133 
  def __init__(self, rechargeOrderId=None,):
30134 
    self.rechargeOrderId = rechargeOrderId
30135 
 
30136 
  def read(self, iprot):
30137 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
30138 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
30139 
      return
30140 
    iprot.readStructBegin()
30141 
    while True:
30142 
      (fname, ftype, fid) = iprot.readFieldBegin()
30143 
      if ftype == TType.STOP:
30144 
        break
30145 
      if fid == 1:
30146 
        if ftype == TType.I64:
30147 
          self.rechargeOrderId = iprot.readI64();
30148 
        else:
30149 
          iprot.skip(ftype)
30150 
      else:
30151 
        iprot.skip(ftype)
30152 
      iprot.readFieldEnd()
30153 
    iprot.readStructEnd()
30154 
 
30155 
  def write(self, oprot):
30156 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
30157 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
30158 
      return
30159 
    oprot.writeStructBegin('refundRechargeOrder_args')
30160 
    if self.rechargeOrderId is not None:
30161 
      oprot.writeFieldBegin('rechargeOrderId', TType.I64, 1)
30162 
      oprot.writeI64(self.rechargeOrderId)
30163 
      oprot.writeFieldEnd()
30164 
    oprot.writeFieldStop()
30165 
    oprot.writeStructEnd()
30166 
 
30167 
  def validate(self):
30168 
    return
30169 
 
30170 
 
30171 
  def __repr__(self):
30172 
    L = ['%s=%r' % (key, value)
30173 
      for key, value in self.__dict__.iteritems()]
30174 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
30175 
 
30176 
  def __eq__(self, other):
30177 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
30178 
 
30179 
  def __ne__(self, other):
30180 
    return not (self == other)
30181 
 
30182 
class refundRechargeOrder_result:
30183 
  """
30184 
  Attributes:
30185 
   - success
30186 
   - ex
30187 
  """
30188 
 
30189 
  thrift_spec = (
30190 
    (0, TType.BOOL, 'success', None, None, ), # 0
30191 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
30192 
  )
30193 
 
30194 
  def __init__(self, success=None, ex=None,):
30195 
    self.success = success
30196 
    self.ex = ex
30197 
 
30198 
  def read(self, iprot):
30199 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
30200 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
30201 
      return
30202 
    iprot.readStructBegin()
30203 
    while True:
30204 
      (fname, ftype, fid) = iprot.readFieldBegin()
30205 
      if ftype == TType.STOP:
30206 
        break
30207 
      if fid == 0:
30208 
        if ftype == TType.BOOL:
30209 
          self.success = iprot.readBool();
30210 
        else:
30211 
          iprot.skip(ftype)
30212 
      elif fid == 1:
30213 
        if ftype == TType.STRUCT:
30214 
          self.ex = TransactionServiceException()
30215 
          self.ex.read(iprot)
30216 
        else:
30217 
          iprot.skip(ftype)
30218 
      else:
30219 
        iprot.skip(ftype)
30220 
      iprot.readFieldEnd()
30221 
    iprot.readStructEnd()
30222 
 
30223 
  def write(self, oprot):
30224 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
30225 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
30226 
      return
30227 
    oprot.writeStructBegin('refundRechargeOrder_result')
30228 
    if self.success is not None:
30229 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
30230 
      oprot.writeBool(self.success)
30231 
      oprot.writeFieldEnd()
30232 
    if self.ex is not None:
30233 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
30234 
      self.ex.write(oprot)
30235 
      oprot.writeFieldEnd()
30236 
    oprot.writeFieldStop()
30237 
    oprot.writeStructEnd()
30238 
 
30239 
  def validate(self):
30240 
    return
30241 
 
30242 
 
30243 
  def __repr__(self):
30244 
    L = ['%s=%r' % (key, value)
30245 
      for key, value in self.__dict__.iteritems()]
30246 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
30247 
 
30248 
  def __eq__(self, other):
30249 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
30250 
 
30251 
  def __ne__(self, other):
30252 
    return not (self == other)
6821 amar.kumar 30253 
 
30254 
class getPhysicalOrders_args:
30255 
  """
30256 
  Attributes:
30257 
   - fromDate
30258 
   - toDate
30259 
  """
30260 
 
30261 
  thrift_spec = (
30262 
    None, # 0
30263 
    (1, TType.I64, 'fromDate', None, None, ), # 1
30264 
    (2, TType.I64, 'toDate', None, None, ), # 2
30265 
  )
30266 
 
30267 
  def __init__(self, fromDate=None, toDate=None,):
30268 
    self.fromDate = fromDate
30269 
    self.toDate = toDate
30270 
 
30271 
  def read(self, iprot):
30272 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
30273 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
30274 
      return
30275 
    iprot.readStructBegin()
30276 
    while True:
30277 
      (fname, ftype, fid) = iprot.readFieldBegin()
30278 
      if ftype == TType.STOP:
30279 
        break
30280 
      if fid == 1:
30281 
        if ftype == TType.I64:
30282 
          self.fromDate = iprot.readI64();
30283 
        else:
30284 
          iprot.skip(ftype)
30285 
      elif fid == 2:
30286 
        if ftype == TType.I64:
30287 
          self.toDate = iprot.readI64();
30288 
        else:
30289 
          iprot.skip(ftype)
30290 
      else:
30291 
        iprot.skip(ftype)
30292 
      iprot.readFieldEnd()
30293 
    iprot.readStructEnd()
30294 
 
30295 
  def write(self, oprot):
30296 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
30297 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
30298 
      return
30299 
    oprot.writeStructBegin('getPhysicalOrders_args')
30300 
    if self.fromDate is not None:
30301 
      oprot.writeFieldBegin('fromDate', TType.I64, 1)
30302 
      oprot.writeI64(self.fromDate)
30303 
      oprot.writeFieldEnd()
30304 
    if self.toDate is not None:
30305 
      oprot.writeFieldBegin('toDate', TType.I64, 2)
30306 
      oprot.writeI64(self.toDate)
30307 
      oprot.writeFieldEnd()
30308 
    oprot.writeFieldStop()
30309 
    oprot.writeStructEnd()
30310 
 
30311 
  def validate(self):
30312 
    return
30313 
 
30314 
 
30315 
  def __repr__(self):
30316 
    L = ['%s=%r' % (key, value)
30317 
      for key, value in self.__dict__.iteritems()]
30318 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
30319 
 
30320 
  def __eq__(self, other):
30321 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
30322 
 
30323 
  def __ne__(self, other):
30324 
    return not (self == other)
30325 
 
30326 
class getPhysicalOrders_result:
30327 
  """
30328 
  Attributes:
30329 
   - success
30330 
  """
30331 
 
30332 
  thrift_spec = (
30333 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
30334 
  )
30335 
 
30336 
  def __init__(self, success=None,):
30337 
    self.success = success
30338 
 
30339 
  def read(self, iprot):
30340 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
30341 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
30342 
      return
30343 
    iprot.readStructBegin()
30344 
    while True:
30345 
      (fname, ftype, fid) = iprot.readFieldBegin()
30346 
      if ftype == TType.STOP:
30347 
        break
30348 
      if fid == 0:
30349 
        if ftype == TType.LIST:
30350 
          self.success = []
30351 
          (_etype726, _size723) = iprot.readListBegin()
30352 
          for _i727 in xrange(_size723):
30353 
            _elem728 = Order()
30354 
            _elem728.read(iprot)
30355 
            self.success.append(_elem728)
30356 
          iprot.readListEnd()
30357 
        else:
30358 
          iprot.skip(ftype)
30359 
      else:
30360 
        iprot.skip(ftype)
30361 
      iprot.readFieldEnd()
30362 
    iprot.readStructEnd()
30363 
 
30364 
  def write(self, oprot):
30365 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
30366 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
30367 
      return
30368 
    oprot.writeStructBegin('getPhysicalOrders_result')
30369 
    if self.success is not None:
30370 
      oprot.writeFieldBegin('success', TType.LIST, 0)
30371 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
30372 
      for iter729 in self.success:
30373 
        iter729.write(oprot)
30374 
      oprot.writeListEnd()
30375 
      oprot.writeFieldEnd()
30376 
    oprot.writeFieldStop()
30377 
    oprot.writeStructEnd()
30378 
 
30379 
  def validate(self):
30380 
    return
30381 
 
30382 
 
30383 
  def __repr__(self):
30384 
    L = ['%s=%r' % (key, value)
30385 
      for key, value in self.__dict__.iteritems()]
30386 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
30387 
 
30388 
  def __eq__(self, other):
30389 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
30390 
 
30391 
  def __ne__(self, other):
30392 
    return not (self == other)
6906 rajveer 30393 
 
30394 
class getDocument_args:
30395 
  """
30396 
  Attributes:
30397 
   - docType
30398 
   - docSource
30399 
  """
30400 
 
30401 
  thrift_spec = (
30402 
    None, # 0
30403 
    (1, TType.I64, 'docType', None, None, ), # 1
30404 
    (2, TType.I64, 'docSource', None, None, ), # 2
30405 
  )
30406 
 
30407 
  def __init__(self, docType=None, docSource=None,):
30408 
    self.docType = docType
30409 
    self.docSource = docSource
30410 
 
30411 
  def read(self, iprot):
30412 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
30413 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
30414 
      return
30415 
    iprot.readStructBegin()
30416 
    while True:
30417 
      (fname, ftype, fid) = iprot.readFieldBegin()
30418 
      if ftype == TType.STOP:
30419 
        break
30420 
      if fid == 1:
30421 
        if ftype == TType.I64:
30422 
          self.docType = iprot.readI64();
30423 
        else:
30424 
          iprot.skip(ftype)
30425 
      elif fid == 2:
30426 
        if ftype == TType.I64:
30427 
          self.docSource = iprot.readI64();
30428 
        else:
30429 
          iprot.skip(ftype)
30430 
      else:
30431 
        iprot.skip(ftype)
30432 
      iprot.readFieldEnd()
30433 
    iprot.readStructEnd()
30434 
 
30435 
  def write(self, oprot):
30436 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
30437 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
30438 
      return
30439 
    oprot.writeStructBegin('getDocument_args')
30440 
    if self.docType is not None:
30441 
      oprot.writeFieldBegin('docType', TType.I64, 1)
30442 
      oprot.writeI64(self.docType)
30443 
      oprot.writeFieldEnd()
30444 
    if self.docSource is not None:
30445 
      oprot.writeFieldBegin('docSource', TType.I64, 2)
30446 
      oprot.writeI64(self.docSource)
30447 
      oprot.writeFieldEnd()
30448 
    oprot.writeFieldStop()
30449 
    oprot.writeStructEnd()
30450 
 
30451 
  def validate(self):
30452 
    return
30453 
 
30454 
 
30455 
  def __repr__(self):
30456 
    L = ['%s=%r' % (key, value)
30457 
      for key, value in self.__dict__.iteritems()]
30458 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
30459 
 
30460 
  def __eq__(self, other):
30461 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
30462 
 
30463 
  def __ne__(self, other):
30464 
    return not (self == other)
30465 
 
30466 
class getDocument_result:
30467 
  """
30468 
  Attributes:
30469 
   - success
30470 
  """
30471 
 
30472 
  thrift_spec = (
30473 
    (0, TType.STRING, 'success', None, None, ), # 0
30474 
  )
30475 
 
30476 
  def __init__(self, success=None,):
30477 
    self.success = success
30478 
 
30479 
  def read(self, iprot):
30480 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
30481 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
30482 
      return
30483 
    iprot.readStructBegin()
30484 
    while True:
30485 
      (fname, ftype, fid) = iprot.readFieldBegin()
30486 
      if ftype == TType.STOP:
30487 
        break
30488 
      if fid == 0:
30489 
        if ftype == TType.STRING:
30490 
          self.success = iprot.readString();
30491 
        else:
30492 
          iprot.skip(ftype)
30493 
      else:
30494 
        iprot.skip(ftype)
30495 
      iprot.readFieldEnd()
30496 
    iprot.readStructEnd()
30497 
 
30498 
  def write(self, oprot):
30499 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
30500 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
30501 
      return
30502 
    oprot.writeStructBegin('getDocument_result')
30503 
    if self.success is not None:
30504 
      oprot.writeFieldBegin('success', TType.STRING, 0)
30505 
      oprot.writeString(self.success)
30506 
      oprot.writeFieldEnd()
30507 
    oprot.writeFieldStop()
30508 
    oprot.writeStructEnd()
30509 
 
30510 
  def validate(self):
30511 
    return
30512 
 
30513 
 
30514 
  def __repr__(self):
30515 
    L = ['%s=%r' % (key, value)
30516 
      for key, value in self.__dict__.iteritems()]
30517 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
30518 
 
30519 
  def __eq__(self, other):
30520 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
30521 
 
30522 
  def __ne__(self, other):
30523 
    return not (self == other)
6985 anupam.sin 30524 
 
30525 
class changeShippingAddress_args:
30526 
  """
30527 
  Attributes:
30528 
   - orderId
30529 
   - line1
30530 
   - line2
30531 
   - city
30532 
   - state
30533 
   - pin
30534 
  """
30535 
 
30536 
  thrift_spec = (
30537 
    None, # 0
30538 
    (1, TType.I64, 'orderId', None, None, ), # 1
30539 
    (2, TType.STRING, 'line1', None, None, ), # 2
30540 
    (3, TType.STRING, 'line2', None, None, ), # 3
30541 
    (4, TType.STRING, 'city', None, None, ), # 4
30542 
    (5, TType.STRING, 'state', None, None, ), # 5
30543 
    (6, TType.STRING, 'pin', None, None, ), # 6
30544 
  )
30545 
 
30546 
  def __init__(self, orderId=None, line1=None, line2=None, city=None, state=None, pin=None,):
30547 
    self.orderId = orderId
30548 
    self.line1 = line1
30549 
    self.line2 = line2
30550 
    self.city = city
30551 
    self.state = state
30552 
    self.pin = pin
30553 
 
30554 
  def read(self, iprot):
30555 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
30556 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
30557 
      return
30558 
    iprot.readStructBegin()
30559 
    while True:
30560 
      (fname, ftype, fid) = iprot.readFieldBegin()
30561 
      if ftype == TType.STOP:
30562 
        break
30563 
      if fid == 1:
30564 
        if ftype == TType.I64:
30565 
          self.orderId = iprot.readI64();
30566 
        else:
30567 
          iprot.skip(ftype)
30568 
      elif fid == 2:
30569 
        if ftype == TType.STRING:
30570 
          self.line1 = iprot.readString();
30571 
        else:
30572 
          iprot.skip(ftype)
30573 
      elif fid == 3:
30574 
        if ftype == TType.STRING:
30575 
          self.line2 = iprot.readString();
30576 
        else:
30577 
          iprot.skip(ftype)
30578 
      elif fid == 4:
30579 
        if ftype == TType.STRING:
30580 
          self.city = iprot.readString();
30581 
        else:
30582 
          iprot.skip(ftype)
30583 
      elif fid == 5:
30584 
        if ftype == TType.STRING:
30585 
          self.state = iprot.readString();
30586 
        else:
30587 
          iprot.skip(ftype)
30588 
      elif fid == 6:
30589 
        if ftype == TType.STRING:
30590 
          self.pin = iprot.readString();
30591 
        else:
30592 
          iprot.skip(ftype)
30593 
      else:
30594 
        iprot.skip(ftype)
30595 
      iprot.readFieldEnd()
30596 
    iprot.readStructEnd()
30597 
 
30598 
  def write(self, oprot):
30599 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
30600 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
30601 
      return
30602 
    oprot.writeStructBegin('changeShippingAddress_args')
30603 
    if self.orderId is not None:
30604 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
30605 
      oprot.writeI64(self.orderId)
30606 
      oprot.writeFieldEnd()
30607 
    if self.line1 is not None:
30608 
      oprot.writeFieldBegin('line1', TType.STRING, 2)
30609 
      oprot.writeString(self.line1)
30610 
      oprot.writeFieldEnd()
30611 
    if self.line2 is not None:
30612 
      oprot.writeFieldBegin('line2', TType.STRING, 3)
30613 
      oprot.writeString(self.line2)
30614 
      oprot.writeFieldEnd()
30615 
    if self.city is not None:
30616 
      oprot.writeFieldBegin('city', TType.STRING, 4)
30617 
      oprot.writeString(self.city)
30618 
      oprot.writeFieldEnd()
30619 
    if self.state is not None:
30620 
      oprot.writeFieldBegin('state', TType.STRING, 5)
30621 
      oprot.writeString(self.state)
30622 
      oprot.writeFieldEnd()
30623 
    if self.pin is not None:
30624 
      oprot.writeFieldBegin('pin', TType.STRING, 6)
30625 
      oprot.writeString(self.pin)
30626 
      oprot.writeFieldEnd()
30627 
    oprot.writeFieldStop()
30628 
    oprot.writeStructEnd()
30629 
 
30630 
  def validate(self):
30631 
    return
30632 
 
30633 
 
30634 
  def __repr__(self):
30635 
    L = ['%s=%r' % (key, value)
30636 
      for key, value in self.__dict__.iteritems()]
30637 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
30638 
 
30639 
  def __eq__(self, other):
30640 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
30641 
 
30642 
  def __ne__(self, other):
30643 
    return not (self == other)
30644 
 
30645 
class changeShippingAddress_result:
30646 
  """
30647 
  Attributes:
30648 
   - success
30649 
  """
30650 
 
30651 
  thrift_spec = (
30652 
    (0, TType.BOOL, 'success', None, None, ), # 0
30653 
  )
30654 
 
30655 
  def __init__(self, success=None,):
30656 
    self.success = success
30657 
 
30658 
  def read(self, iprot):
30659 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
30660 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
30661 
      return
30662 
    iprot.readStructBegin()
30663 
    while True:
30664 
      (fname, ftype, fid) = iprot.readFieldBegin()
30665 
      if ftype == TType.STOP:
30666 
        break
30667 
      if fid == 0:
30668 
        if ftype == TType.BOOL:
30669 
          self.success = iprot.readBool();
30670 
        else:
30671 
          iprot.skip(ftype)
30672 
      else:
30673 
        iprot.skip(ftype)
30674 
      iprot.readFieldEnd()
30675 
    iprot.readStructEnd()
30676 
 
30677 
  def write(self, oprot):
30678 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
30679 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
30680 
      return
30681 
    oprot.writeStructBegin('changeShippingAddress_result')
30682 
    if self.success is not None:
30683 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
30684 
      oprot.writeBool(self.success)
30685 
      oprot.writeFieldEnd()
30686 
    oprot.writeFieldStop()
30687 
    oprot.writeStructEnd()
30688 
 
30689 
  def validate(self):
30690 
    return
30691 
 
30692 
 
30693 
  def __repr__(self):
30694 
    L = ['%s=%r' % (key, value)
30695 
      for key, value in self.__dict__.iteritems()]
30696 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
30697 
 
30698 
  def __eq__(self, other):
30699 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
30700 
 
30701 
  def __ne__(self, other):
30702 
    return not (self == other)
6988 rajveer 30703 
 
30704 
class retrieveInvoice_args:
30705 
  """
30706 
  Attributes:
30707 
   - orderId
7075 rajveer 30708 
   - userId
6988 rajveer 30709 
  """
30710 
 
30711 
  thrift_spec = (
30712 
    None, # 0
30713 
    (1, TType.I64, 'orderId', None, None, ), # 1
7075 rajveer 30714 
    (2, TType.I64, 'userId', None, None, ), # 2
6988 rajveer 30715 
  )
30716 
 
7075 rajveer 30717 
  def __init__(self, orderId=None, userId=None,):
6988 rajveer 30718 
    self.orderId = orderId
7075 rajveer 30719 
    self.userId = userId
6988 rajveer 30720 
 
30721 
  def read(self, iprot):
30722 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
30723 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
30724 
      return
30725 
    iprot.readStructBegin()
30726 
    while True:
30727 
      (fname, ftype, fid) = iprot.readFieldBegin()
30728 
      if ftype == TType.STOP:
30729 
        break
30730 
      if fid == 1:
30731 
        if ftype == TType.I64:
30732 
          self.orderId = iprot.readI64();
30733 
        else:
30734 
          iprot.skip(ftype)
7075 rajveer 30735 
      elif fid == 2:
30736 
        if ftype == TType.I64:
30737 
          self.userId = iprot.readI64();
30738 
        else:
30739 
          iprot.skip(ftype)
6988 rajveer 30740 
      else:
30741 
        iprot.skip(ftype)
30742 
      iprot.readFieldEnd()
30743 
    iprot.readStructEnd()
30744 
 
30745 
  def write(self, oprot):
30746 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
30747 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
30748 
      return
30749 
    oprot.writeStructBegin('retrieveInvoice_args')
30750 
    if self.orderId is not None:
30751 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
30752 
      oprot.writeI64(self.orderId)
30753 
      oprot.writeFieldEnd()
7075 rajveer 30754 
    if self.userId is not None:
30755 
      oprot.writeFieldBegin('userId', TType.I64, 2)
30756 
      oprot.writeI64(self.userId)
30757 
      oprot.writeFieldEnd()
6988 rajveer 30758 
    oprot.writeFieldStop()
30759 
    oprot.writeStructEnd()
30760 
 
30761 
  def validate(self):
30762 
    return
30763 
 
30764 
 
30765 
  def __repr__(self):
30766 
    L = ['%s=%r' % (key, value)
30767 
      for key, value in self.__dict__.iteritems()]
30768 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
30769 
 
30770 
  def __eq__(self, other):
30771 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
30772 
 
30773 
  def __ne__(self, other):
30774 
    return not (self == other)
30775 
 
30776 
class retrieveInvoice_result:
30777 
  """
30778 
  Attributes:
30779 
   - success
30780 
  """
30781 
 
30782 
  thrift_spec = (
30783 
    (0, TType.STRING, 'success', None, None, ), # 0
30784 
  )
30785 
 
30786 
  def __init__(self, success=None,):
30787 
    self.success = success
30788 
 
30789 
  def read(self, iprot):
30790 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
30791 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
30792 
      return
30793 
    iprot.readStructBegin()
30794 
    while True:
30795 
      (fname, ftype, fid) = iprot.readFieldBegin()
30796 
      if ftype == TType.STOP:
30797 
        break
30798 
      if fid == 0:
30799 
        if ftype == TType.STRING:
30800 
          self.success = iprot.readString();
30801 
        else:
30802 
          iprot.skip(ftype)
30803 
      else:
30804 
        iprot.skip(ftype)
30805 
      iprot.readFieldEnd()
30806 
    iprot.readStructEnd()
30807 
 
30808 
  def write(self, oprot):
30809 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
30810 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
30811 
      return
30812 
    oprot.writeStructBegin('retrieveInvoice_result')
30813 
    if self.success is not None:
30814 
      oprot.writeFieldBegin('success', TType.STRING, 0)
30815 
      oprot.writeString(self.success)
30816 
      oprot.writeFieldEnd()
30817 
    oprot.writeFieldStop()
30818 
    oprot.writeStructEnd()
30819 
 
30820 
  def validate(self):
30821 
    return
30822 
 
30823 
 
30824 
  def __repr__(self):
30825 
    L = ['%s=%r' % (key, value)
30826 
      for key, value in self.__dict__.iteritems()]
30827 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
30828 
 
30829 
  def __eq__(self, other):
30830 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
30831 
 
30832 
  def __ne__(self, other):
30833 
    return not (self == other)
7026 rajveer 30834 
 
30835 
class receiveUpdatesForRedExpress_args:
30836 
  """
30837 
  Attributes:
30838 
   - awbNumber
30839 
  """
30840 
 
30841 
  thrift_spec = (
30842 
    None, # 0
30843 
    (1, TType.STRING, 'awbNumber', None, None, ), # 1
30844 
  )
30845 
 
30846 
  def __init__(self, awbNumber=None,):
30847 
    self.awbNumber = awbNumber
30848 
 
30849 
  def read(self, iprot):
30850 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
30851 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
30852 
      return
30853 
    iprot.readStructBegin()
30854 
    while True:
30855 
      (fname, ftype, fid) = iprot.readFieldBegin()
30856 
      if ftype == TType.STOP:
30857 
        break
30858 
      if fid == 1:
30859 
        if ftype == TType.STRING:
30860 
          self.awbNumber = iprot.readString();
30861 
        else:
30862 
          iprot.skip(ftype)
30863 
      else:
30864 
        iprot.skip(ftype)
30865 
      iprot.readFieldEnd()
30866 
    iprot.readStructEnd()
30867 
 
30868 
  def write(self, oprot):
30869 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
30870 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
30871 
      return
30872 
    oprot.writeStructBegin('receiveUpdatesForRedExpress_args')
30873 
    if self.awbNumber is not None:
30874 
      oprot.writeFieldBegin('awbNumber', TType.STRING, 1)
30875 
      oprot.writeString(self.awbNumber)
30876 
      oprot.writeFieldEnd()
30877 
    oprot.writeFieldStop()
30878 
    oprot.writeStructEnd()
30879 
 
30880 
  def validate(self):
30881 
    return
30882 
 
30883 
 
30884 
  def __repr__(self):
30885 
    L = ['%s=%r' % (key, value)
30886 
      for key, value in self.__dict__.iteritems()]
30887 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
30888 
 
30889 
  def __eq__(self, other):
30890 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
30891 
 
30892 
  def __ne__(self, other):
30893 
    return not (self == other)
30894 
 
30895 
class receiveUpdatesForRedExpress_result:
30896 
  """
30897 
  Attributes:
30898 
   - success
30899 
  """
30900 
 
30901 
  thrift_spec = (
30902 
    (0, TType.LIST, 'success', (TType.STRING,None), None, ), # 0
30903 
  )
30904 
 
30905 
  def __init__(self, success=None,):
30906 
    self.success = success
30907 
 
30908 
  def read(self, iprot):
30909 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
30910 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
30911 
      return
30912 
    iprot.readStructBegin()
30913 
    while True:
30914 
      (fname, ftype, fid) = iprot.readFieldBegin()
30915 
      if ftype == TType.STOP:
30916 
        break
30917 
      if fid == 0:
30918 
        if ftype == TType.LIST:
30919 
          self.success = []
30920 
          (_etype733, _size730) = iprot.readListBegin()
30921 
          for _i734 in xrange(_size730):
30922 
            _elem735 = iprot.readString();
30923 
            self.success.append(_elem735)
30924 
          iprot.readListEnd()
30925 
        else:
30926 
          iprot.skip(ftype)
30927 
      else:
30928 
        iprot.skip(ftype)
30929 
      iprot.readFieldEnd()
30930 
    iprot.readStructEnd()
30931 
 
30932 
  def write(self, oprot):
30933 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
30934 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
30935 
      return
30936 
    oprot.writeStructBegin('receiveUpdatesForRedExpress_result')
30937 
    if self.success is not None:
30938 
      oprot.writeFieldBegin('success', TType.LIST, 0)
30939 
      oprot.writeListBegin(TType.STRING, len(self.success))
30940 
      for iter736 in self.success:
30941 
        oprot.writeString(iter736)
30942 
      oprot.writeListEnd()
30943 
      oprot.writeFieldEnd()
30944 
    oprot.writeFieldStop()
30945 
    oprot.writeStructEnd()
30946 
 
30947 
  def validate(self):
30948 
    return
30949 
 
30950 
 
30951 
  def __repr__(self):
30952 
    L = ['%s=%r' % (key, value)
30953 
      for key, value in self.__dict__.iteritems()]
30954 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
30955 
 
30956 
  def __eq__(self, other):
30957 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
30958 
 
30959 
  def __ne__(self, other):
30960 
    return not (self == other)
7073 anupam.sin 30961 
 
30962 
class createRechargeTransaction_args:
30963 
  """
30964 
  Attributes:
30965 
   - thriftRechargeTransaction
30966 
  """
30967 
 
30968 
  thrift_spec = (
30969 
    None, # 0
30970 
    (1, TType.STRUCT, 'thriftRechargeTransaction', (RechargeTransaction, RechargeTransaction.thrift_spec), None, ), # 1
30971 
  )
30972 
 
30973 
  def __init__(self, thriftRechargeTransaction=None,):
30974 
    self.thriftRechargeTransaction = thriftRechargeTransaction
30975 
 
30976 
  def read(self, iprot):
30977 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
30978 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
30979 
      return
30980 
    iprot.readStructBegin()
30981 
    while True:
30982 
      (fname, ftype, fid) = iprot.readFieldBegin()
30983 
      if ftype == TType.STOP:
30984 
        break
30985 
      if fid == 1:
30986 
        if ftype == TType.STRUCT:
30987 
          self.thriftRechargeTransaction = RechargeTransaction()
30988 
          self.thriftRechargeTransaction.read(iprot)
30989 
        else:
30990 
          iprot.skip(ftype)
30991 
      else:
30992 
        iprot.skip(ftype)
30993 
      iprot.readFieldEnd()
30994 
    iprot.readStructEnd()
30995 
 
30996 
  def write(self, oprot):
30997 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
30998 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
30999 
      return
31000 
    oprot.writeStructBegin('createRechargeTransaction_args')
31001 
    if self.thriftRechargeTransaction is not None:
31002 
      oprot.writeFieldBegin('thriftRechargeTransaction', TType.STRUCT, 1)
31003 
      self.thriftRechargeTransaction.write(oprot)
31004 
      oprot.writeFieldEnd()
31005 
    oprot.writeFieldStop()
31006 
    oprot.writeStructEnd()
31007 
 
31008 
  def validate(self):
31009 
    return
31010 
 
31011 
 
31012 
  def __repr__(self):
31013 
    L = ['%s=%r' % (key, value)
31014 
      for key, value in self.__dict__.iteritems()]
31015 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
31016 
 
31017 
  def __eq__(self, other):
31018 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
31019 
 
31020 
  def __ne__(self, other):
31021 
    return not (self == other)
31022 
 
31023 
class createRechargeTransaction_result:
31024 
  """
31025 
  Attributes:
31026 
   - success
31027 
  """
31028 
 
31029 
  thrift_spec = (
31030 
    (0, TType.STRUCT, 'success', (RechargeTransaction, RechargeTransaction.thrift_spec), None, ), # 0
31031 
  )
31032 
 
31033 
  def __init__(self, success=None,):
31034 
    self.success = success
31035 
 
31036 
  def read(self, iprot):
31037 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
31038 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
31039 
      return
31040 
    iprot.readStructBegin()
31041 
    while True:
31042 
      (fname, ftype, fid) = iprot.readFieldBegin()
31043 
      if ftype == TType.STOP:
31044 
        break
31045 
      if fid == 0:
31046 
        if ftype == TType.STRUCT:
31047 
          self.success = RechargeTransaction()
31048 
          self.success.read(iprot)
31049 
        else:
31050 
          iprot.skip(ftype)
31051 
      else:
31052 
        iprot.skip(ftype)
31053 
      iprot.readFieldEnd()
31054 
    iprot.readStructEnd()
31055 
 
31056 
  def write(self, oprot):
31057 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
31058 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
31059 
      return
31060 
    oprot.writeStructBegin('createRechargeTransaction_result')
31061 
    if self.success is not None:
31062 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
31063 
      self.success.write(oprot)
31064 
      oprot.writeFieldEnd()
31065 
    oprot.writeFieldStop()
31066 
    oprot.writeStructEnd()
31067 
 
31068 
  def validate(self):
31069 
    return
31070 
 
31071 
 
31072 
  def __repr__(self):
31073 
    L = ['%s=%r' % (key, value)
31074 
      for key, value in self.__dict__.iteritems()]
31075 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
31076 
 
31077 
  def __eq__(self, other):
31078 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
31079 
 
31080 
  def __ne__(self, other):
31081 
    return not (self == other)
7080 anupam.sin 31082 
 
7085 rajveer 31083 
class getRechargeTransactions_args:
31084 
  """
31085 
  Attributes:
31086 
   - storeId
31087 
  """
31088 
 
31089 
  thrift_spec = (
31090 
    None, # 0
31091 
    (1, TType.I64, 'storeId', None, None, ), # 1
31092 
  )
31093 
 
31094 
  def __init__(self, storeId=None,):
31095 
    self.storeId = storeId
31096 
 
31097 
  def read(self, iprot):
31098 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
31099 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
31100 
      return
31101 
    iprot.readStructBegin()
31102 
    while True:
31103 
      (fname, ftype, fid) = iprot.readFieldBegin()
31104 
      if ftype == TType.STOP:
31105 
        break
31106 
      if fid == 1:
31107 
        if ftype == TType.I64:
31108 
          self.storeId = iprot.readI64();
31109 
        else:
31110 
          iprot.skip(ftype)
31111 
      else:
31112 
        iprot.skip(ftype)
31113 
      iprot.readFieldEnd()
31114 
    iprot.readStructEnd()
31115 
 
31116 
  def write(self, oprot):
31117 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
31118 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
31119 
      return
31120 
    oprot.writeStructBegin('getRechargeTransactions_args')
31121 
    if self.storeId is not None:
31122 
      oprot.writeFieldBegin('storeId', TType.I64, 1)
31123 
      oprot.writeI64(self.storeId)
31124 
      oprot.writeFieldEnd()
31125 
    oprot.writeFieldStop()
31126 
    oprot.writeStructEnd()
31127 
 
31128 
  def validate(self):
31129 
    return
31130 
 
31131 
 
31132 
  def __repr__(self):
31133 
    L = ['%s=%r' % (key, value)
31134 
      for key, value in self.__dict__.iteritems()]
31135 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
31136 
 
31137 
  def __eq__(self, other):
31138 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
31139 
 
31140 
  def __ne__(self, other):
31141 
    return not (self == other)
31142 
 
31143 
class getRechargeTransactions_result:
31144 
  """
31145 
  Attributes:
31146 
   - success
31147 
  """
31148 
 
31149 
  thrift_spec = (
31150 
    (0, TType.LIST, 'success', (TType.STRUCT,(RechargeTransaction, RechargeTransaction.thrift_spec)), None, ), # 0
31151 
  )
31152 
 
31153 
  def __init__(self, success=None,):
31154 
    self.success = success
31155 
 
31156 
  def read(self, iprot):
31157 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
31158 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
31159 
      return
31160 
    iprot.readStructBegin()
31161 
    while True:
31162 
      (fname, ftype, fid) = iprot.readFieldBegin()
31163 
      if ftype == TType.STOP:
31164 
        break
31165 
      if fid == 0:
31166 
        if ftype == TType.LIST:
31167 
          self.success = []
31168 
          (_etype740, _size737) = iprot.readListBegin()
31169 
          for _i741 in xrange(_size737):
31170 
            _elem742 = RechargeTransaction()
31171 
            _elem742.read(iprot)
31172 
            self.success.append(_elem742)
31173 
          iprot.readListEnd()
31174 
        else:
31175 
          iprot.skip(ftype)
31176 
      else:
31177 
        iprot.skip(ftype)
31178 
      iprot.readFieldEnd()
31179 
    iprot.readStructEnd()
31180 
 
31181 
  def write(self, oprot):
31182 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
31183 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
31184 
      return
31185 
    oprot.writeStructBegin('getRechargeTransactions_result')
31186 
    if self.success is not None:
31187 
      oprot.writeFieldBegin('success', TType.LIST, 0)
31188 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
31189 
      for iter743 in self.success:
31190 
        iter743.write(oprot)
31191 
      oprot.writeListEnd()
31192 
      oprot.writeFieldEnd()
31193 
    oprot.writeFieldStop()
31194 
    oprot.writeStructEnd()
31195 
 
31196 
  def validate(self):
31197 
    return
31198 
 
31199 
 
31200 
  def __repr__(self):
31201 
    L = ['%s=%r' % (key, value)
31202 
      for key, value in self.__dict__.iteritems()]
31203 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
31204 
 
31205 
  def __eq__(self, other):
31206 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
31207 
 
31208 
  def __ne__(self, other):
31209 
    return not (self == other)
31210 
 
7151 amit.gupta 31211 
class getRechargeTrans_args:
31212 
  """
31213 
  Attributes:
31214 
   - storeId
31215 
   - startDate
31216 
   - endDate
31217 
   - status
31218 
  """
31219 
 
31220 
  thrift_spec = (
31221 
    None, # 0
31222 
    (1, TType.I64, 'storeId', None, None, ), # 1
31223 
    (2, TType.I64, 'startDate', None, None, ), # 2
31224 
    (3, TType.I64, 'endDate', None, None, ), # 3
31225 
    (4, TType.I32, 'status', None, None, ), # 4
31226 
  )
31227 
 
31228 
  def __init__(self, storeId=None, startDate=None, endDate=None, status=None,):
31229 
    self.storeId = storeId
31230 
    self.startDate = startDate
31231 
    self.endDate = endDate
31232 
    self.status = status
31233 
 
31234 
  def read(self, iprot):
31235 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
31236 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
31237 
      return
31238 
    iprot.readStructBegin()
31239 
    while True:
31240 
      (fname, ftype, fid) = iprot.readFieldBegin()
31241 
      if ftype == TType.STOP:
31242 
        break
31243 
      if fid == 1:
31244 
        if ftype == TType.I64:
31245 
          self.storeId = iprot.readI64();
31246 
        else:
31247 
          iprot.skip(ftype)
31248 
      elif fid == 2:
31249 
        if ftype == TType.I64:
31250 
          self.startDate = iprot.readI64();
31251 
        else:
31252 
          iprot.skip(ftype)
31253 
      elif fid == 3:
31254 
        if ftype == TType.I64:
31255 
          self.endDate = iprot.readI64();
31256 
        else:
31257 
          iprot.skip(ftype)
31258 
      elif fid == 4:
31259 
        if ftype == TType.I32:
31260 
          self.status = iprot.readI32();
31261 
        else:
31262 
          iprot.skip(ftype)
31263 
      else:
31264 
        iprot.skip(ftype)
31265 
      iprot.readFieldEnd()
31266 
    iprot.readStructEnd()
31267 
 
31268 
  def write(self, oprot):
31269 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
31270 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
31271 
      return
31272 
    oprot.writeStructBegin('getRechargeTrans_args')
31273 
    if self.storeId is not None:
31274 
      oprot.writeFieldBegin('storeId', TType.I64, 1)
31275 
      oprot.writeI64(self.storeId)
31276 
      oprot.writeFieldEnd()
31277 
    if self.startDate is not None:
31278 
      oprot.writeFieldBegin('startDate', TType.I64, 2)
31279 
      oprot.writeI64(self.startDate)
31280 
      oprot.writeFieldEnd()
31281 
    if self.endDate is not None:
31282 
      oprot.writeFieldBegin('endDate', TType.I64, 3)
31283 
      oprot.writeI64(self.endDate)
31284 
      oprot.writeFieldEnd()
31285 
    if self.status is not None:
31286 
      oprot.writeFieldBegin('status', TType.I32, 4)
31287 
      oprot.writeI32(self.status)
31288 
      oprot.writeFieldEnd()
31289 
    oprot.writeFieldStop()
31290 
    oprot.writeStructEnd()
31291 
 
31292 
  def validate(self):
31293 
    return
31294 
 
31295 
 
31296 
  def __repr__(self):
31297 
    L = ['%s=%r' % (key, value)
31298 
      for key, value in self.__dict__.iteritems()]
31299 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
31300 
 
31301 
  def __eq__(self, other):
31302 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
31303 
 
31304 
  def __ne__(self, other):
31305 
    return not (self == other)
31306 
 
31307 
class getRechargeTrans_result:
31308 
  """
31309 
  Attributes:
31310 
   - success
31311 
  """
31312 
 
31313 
  thrift_spec = (
31314 
    (0, TType.LIST, 'success', (TType.STRUCT,(RechargeTransaction, RechargeTransaction.thrift_spec)), None, ), # 0
31315 
  )
31316 
 
31317 
  def __init__(self, success=None,):
31318 
    self.success = success
31319 
 
31320 
  def read(self, iprot):
31321 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
31322 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
31323 
      return
31324 
    iprot.readStructBegin()
31325 
    while True:
31326 
      (fname, ftype, fid) = iprot.readFieldBegin()
31327 
      if ftype == TType.STOP:
31328 
        break
31329 
      if fid == 0:
31330 
        if ftype == TType.LIST:
31331 
          self.success = []
31332 
          (_etype747, _size744) = iprot.readListBegin()
31333 
          for _i748 in xrange(_size744):
31334 
            _elem749 = RechargeTransaction()
31335 
            _elem749.read(iprot)
31336 
            self.success.append(_elem749)
31337 
          iprot.readListEnd()
31338 
        else:
31339 
          iprot.skip(ftype)
31340 
      else:
31341 
        iprot.skip(ftype)
31342 
      iprot.readFieldEnd()
31343 
    iprot.readStructEnd()
31344 
 
31345 
  def write(self, oprot):
31346 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
31347 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
31348 
      return
31349 
    oprot.writeStructBegin('getRechargeTrans_result')
31350 
    if self.success is not None:
31351 
      oprot.writeFieldBegin('success', TType.LIST, 0)
31352 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
31353 
      for iter750 in self.success:
31354 
        iter750.write(oprot)
31355 
      oprot.writeListEnd()
31356 
      oprot.writeFieldEnd()
31357 
    oprot.writeFieldStop()
31358 
    oprot.writeStructEnd()
31359 
 
31360 
  def validate(self):
31361 
    return
31362 
 
31363 
 
31364 
  def __repr__(self):
31365 
    L = ['%s=%r' % (key, value)
31366 
      for key, value in self.__dict__.iteritems()]
31367 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
31368 
 
31369 
  def __eq__(self, other):
31370 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
31371 
 
31372 
  def __ne__(self, other):
31373 
    return not (self == other)
31374 
 
7080 anupam.sin 31375 
class getRechargeTransaction_args:
31376 
  """
31377 
  Attributes:
31378 
   - rechargeId
31379 
  """
31380 
 
31381 
  thrift_spec = (
31382 
    None, # 0
31383 
    (1, TType.I64, 'rechargeId', None, None, ), # 1
31384 
  )
31385 
 
31386 
  def __init__(self, rechargeId=None,):
31387 
    self.rechargeId = rechargeId
31388 
 
31389 
  def read(self, iprot):
31390 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
31391 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
31392 
      return
31393 
    iprot.readStructBegin()
31394 
    while True:
31395 
      (fname, ftype, fid) = iprot.readFieldBegin()
31396 
      if ftype == TType.STOP:
31397 
        break
31398 
      if fid == 1:
31399 
        if ftype == TType.I64:
31400 
          self.rechargeId = iprot.readI64();
31401 
        else:
31402 
          iprot.skip(ftype)
31403 
      else:
31404 
        iprot.skip(ftype)
31405 
      iprot.readFieldEnd()
31406 
    iprot.readStructEnd()
31407 
 
31408 
  def write(self, oprot):
31409 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
31410 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
31411 
      return
31412 
    oprot.writeStructBegin('getRechargeTransaction_args')
31413 
    if self.rechargeId is not None:
31414 
      oprot.writeFieldBegin('rechargeId', TType.I64, 1)
31415 
      oprot.writeI64(self.rechargeId)
31416 
      oprot.writeFieldEnd()
31417 
    oprot.writeFieldStop()
31418 
    oprot.writeStructEnd()
31419 
 
31420 
  def validate(self):
31421 
    return
31422 
 
31423 
 
31424 
  def __repr__(self):
31425 
    L = ['%s=%r' % (key, value)
31426 
      for key, value in self.__dict__.iteritems()]
31427 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
31428 
 
31429 
  def __eq__(self, other):
31430 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
31431 
 
31432 
  def __ne__(self, other):
31433 
    return not (self == other)
31434 
 
31435 
class getRechargeTransaction_result:
31436 
  """
31437 
  Attributes:
31438 
   - success
31439 
  """
31440 
 
31441 
  thrift_spec = (
31442 
    (0, TType.STRUCT, 'success', (RechargeTransaction, RechargeTransaction.thrift_spec), None, ), # 0
31443 
  )
31444 
 
31445 
  def __init__(self, success=None,):
31446 
    self.success = success
31447 
 
31448 
  def read(self, iprot):
31449 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
31450 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
31451 
      return
31452 
    iprot.readStructBegin()
31453 
    while True:
31454 
      (fname, ftype, fid) = iprot.readFieldBegin()
31455 
      if ftype == TType.STOP:
31456 
        break
31457 
      if fid == 0:
31458 
        if ftype == TType.STRUCT:
31459 
          self.success = RechargeTransaction()
31460 
          self.success.read(iprot)
31461 
        else:
31462 
          iprot.skip(ftype)
31463 
      else:
31464 
        iprot.skip(ftype)
31465 
      iprot.readFieldEnd()
31466 
    iprot.readStructEnd()
31467 
 
31468 
  def write(self, oprot):
31469 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
31470 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
31471 
      return
31472 
    oprot.writeStructBegin('getRechargeTransaction_result')
31473 
    if self.success is not None:
31474 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
31475 
      self.success.write(oprot)
31476 
      oprot.writeFieldEnd()
31477 
    oprot.writeFieldStop()
31478 
    oprot.writeStructEnd()
31479 
 
31480 
  def validate(self):
31481 
    return
31482 
 
31483 
 
31484 
  def __repr__(self):
31485 
    L = ['%s=%r' % (key, value)
31486 
      for key, value in self.__dict__.iteritems()]
31487 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
31488 
 
31489 
  def __eq__(self, other):
31490 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
31491 
 
31492 
  def __ne__(self, other):
31493 
    return not (self == other)
31494 
 
31495 
class getFRCs_args:
31496 
  """
31497 
  Attributes:
31498 
   - circleId
31499 
   - operatorId
31500 
  """
31501 
 
31502 
  thrift_spec = (
31503 
    None, # 0
31504 
    (1, TType.I64, 'circleId', None, None, ), # 1
31505 
    (2, TType.I64, 'operatorId', None, None, ), # 2
31506 
  )
31507 
 
31508 
  def __init__(self, circleId=None, operatorId=None,):
31509 
    self.circleId = circleId
31510 
    self.operatorId = operatorId
31511 
 
31512 
  def read(self, iprot):
31513 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
31514 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
31515 
      return
31516 
    iprot.readStructBegin()
31517 
    while True:
31518 
      (fname, ftype, fid) = iprot.readFieldBegin()
31519 
      if ftype == TType.STOP:
31520 
        break
31521 
      if fid == 1:
31522 
        if ftype == TType.I64:
31523 
          self.circleId = iprot.readI64();
31524 
        else:
31525 
          iprot.skip(ftype)
31526 
      elif fid == 2:
31527 
        if ftype == TType.I64:
31528 
          self.operatorId = iprot.readI64();
31529 
        else:
31530 
          iprot.skip(ftype)
31531 
      else:
31532 
        iprot.skip(ftype)
31533 
      iprot.readFieldEnd()
31534 
    iprot.readStructEnd()
31535 
 
31536 
  def write(self, oprot):
31537 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
31538 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
31539 
      return
31540 
    oprot.writeStructBegin('getFRCs_args')
31541 
    if self.circleId is not None:
31542 
      oprot.writeFieldBegin('circleId', TType.I64, 1)
31543 
      oprot.writeI64(self.circleId)
31544 
      oprot.writeFieldEnd()
31545 
    if self.operatorId is not None:
31546 
      oprot.writeFieldBegin('operatorId', TType.I64, 2)
31547 
      oprot.writeI64(self.operatorId)
31548 
      oprot.writeFieldEnd()
31549 
    oprot.writeFieldStop()
31550 
    oprot.writeStructEnd()
31551 
 
31552 
  def validate(self):
31553 
    return
31554 
 
31555 
 
31556 
  def __repr__(self):
31557 
    L = ['%s=%r' % (key, value)
31558 
      for key, value in self.__dict__.iteritems()]
31559 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
31560 
 
31561 
  def __eq__(self, other):
31562 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
31563 
 
31564 
  def __ne__(self, other):
31565 
    return not (self == other)
31566 
 
31567 
class getFRCs_result:
31568 
  """
31569 
  Attributes:
31570 
   - success
31571 
  """
31572 
 
31573 
  thrift_spec = (
31574 
    (0, TType.LIST, 'success', (TType.STRUCT,(FRC, FRC.thrift_spec)), None, ), # 0
31575 
  )
31576 
 
31577 
  def __init__(self, success=None,):
31578 
    self.success = success
31579 
 
31580 
  def read(self, iprot):
31581 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
31582 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
31583 
      return
31584 
    iprot.readStructBegin()
31585 
    while True:
31586 
      (fname, ftype, fid) = iprot.readFieldBegin()
31587 
      if ftype == TType.STOP:
31588 
        break
31589 
      if fid == 0:
31590 
        if ftype == TType.LIST:
31591 
          self.success = []
7151 amit.gupta 31592 
          (_etype754, _size751) = iprot.readListBegin()
31593 
          for _i755 in xrange(_size751):
31594 
            _elem756 = FRC()
31595 
            _elem756.read(iprot)
31596 
            self.success.append(_elem756)
7080 anupam.sin 31597 
          iprot.readListEnd()
31598 
        else:
31599 
          iprot.skip(ftype)
31600 
      else:
31601 
        iprot.skip(ftype)
31602 
      iprot.readFieldEnd()
31603 
    iprot.readStructEnd()
31604 
 
31605 
  def write(self, oprot):
31606 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
31607 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
31608 
      return
31609 
    oprot.writeStructBegin('getFRCs_result')
31610 
    if self.success is not None:
31611 
      oprot.writeFieldBegin('success', TType.LIST, 0)
31612 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
7151 amit.gupta 31613 
      for iter757 in self.success:
31614 
        iter757.write(oprot)
7080 anupam.sin 31615 
      oprot.writeListEnd()
31616 
      oprot.writeFieldEnd()
31617 
    oprot.writeFieldStop()
31618 
    oprot.writeStructEnd()
31619 
 
31620 
  def validate(self):
31621 
    return
31622 
 
31623 
 
31624 
  def __repr__(self):
31625 
    L = ['%s=%r' % (key, value)
31626 
      for key, value in self.__dict__.iteritems()]
31627 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
31628 
 
31629 
  def __eq__(self, other):
31630 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
31631 
 
31632 
  def __ne__(self, other):
31633 
    return not (self == other)
7096 anupam.sin 31634 
 
31635 
class getHotspotStore_args:
31636 
  """
31637 
  Attributes:
31638 
   - id
31639 
   - hotspotid
31640 
  """
31641 
 
31642 
  thrift_spec = (
31643 
    None, # 0
31644 
    (1, TType.I64, 'id', None, None, ), # 1
31645 
    (2, TType.STRING, 'hotspotid', None, None, ), # 2
31646 
  )
31647 
 
31648 
  def __init__(self, id=None, hotspotid=None,):
31649 
    self.id = id
31650 
    self.hotspotid = hotspotid
31651 
 
31652 
  def read(self, iprot):
31653 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
31654 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
31655 
      return
31656 
    iprot.readStructBegin()
31657 
    while True:
31658 
      (fname, ftype, fid) = iprot.readFieldBegin()
31659 
      if ftype == TType.STOP:
31660 
        break
31661 
      if fid == 1:
31662 
        if ftype == TType.I64:
31663 
          self.id = iprot.readI64();
31664 
        else:
31665 
          iprot.skip(ftype)
31666 
      elif fid == 2:
31667 
        if ftype == TType.STRING:
31668 
          self.hotspotid = iprot.readString();
31669 
        else:
31670 
          iprot.skip(ftype)
31671 
      else:
31672 
        iprot.skip(ftype)
31673 
      iprot.readFieldEnd()
31674 
    iprot.readStructEnd()
31675 
 
31676 
  def write(self, oprot):
31677 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
31678 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
31679 
      return
31680 
    oprot.writeStructBegin('getHotspotStore_args')
31681 
    if self.id is not None:
31682 
      oprot.writeFieldBegin('id', TType.I64, 1)
31683 
      oprot.writeI64(self.id)
31684 
      oprot.writeFieldEnd()
31685 
    if self.hotspotid is not None:
31686 
      oprot.writeFieldBegin('hotspotid', TType.STRING, 2)
31687 
      oprot.writeString(self.hotspotid)
31688 
      oprot.writeFieldEnd()
31689 
    oprot.writeFieldStop()
31690 
    oprot.writeStructEnd()
31691 
 
31692 
  def validate(self):
31693 
    return
31694 
 
31695 
 
31696 
  def __repr__(self):
31697 
    L = ['%s=%r' % (key, value)
31698 
      for key, value in self.__dict__.iteritems()]
31699 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
31700 
 
31701 
  def __eq__(self, other):
31702 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
31703 
 
31704 
  def __ne__(self, other):
31705 
    return not (self == other)
31706 
 
31707 
class getHotspotStore_result:
31708 
  """
31709 
  Attributes:
31710 
   - success
31711 
  """
31712 
 
31713 
  thrift_spec = (
31714 
    (0, TType.STRUCT, 'success', (HotspotStore, HotspotStore.thrift_spec), None, ), # 0
31715 
  )
31716 
 
31717 
  def __init__(self, success=None,):
31718 
    self.success = success
31719 
 
31720 
  def read(self, iprot):
31721 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
31722 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
31723 
      return
31724 
    iprot.readStructBegin()
31725 
    while True:
31726 
      (fname, ftype, fid) = iprot.readFieldBegin()
31727 
      if ftype == TType.STOP:
31728 
        break
31729 
      if fid == 0:
31730 
        if ftype == TType.STRUCT:
31731 
          self.success = HotspotStore()
31732 
          self.success.read(iprot)
31733 
        else:
31734 
          iprot.skip(ftype)
31735 
      else:
31736 
        iprot.skip(ftype)
31737 
      iprot.readFieldEnd()
31738 
    iprot.readStructEnd()
31739 
 
31740 
  def write(self, oprot):
31741 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
31742 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
31743 
      return
31744 
    oprot.writeStructBegin('getHotspotStore_result')
31745 
    if self.success is not None:
31746 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
31747 
      self.success.write(oprot)
31748 
      oprot.writeFieldEnd()
31749 
    oprot.writeFieldStop()
31750 
    oprot.writeStructEnd()
31751 
 
31752 
  def validate(self):
31753 
    return
31754 
 
31755 
 
31756 
  def __repr__(self):
31757 
    L = ['%s=%r' % (key, value)
31758 
      for key, value in self.__dict__.iteritems()]
31759 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
31760 
 
31761 
  def __eq__(self, other):
31762 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
31763 
 
31764 
  def __ne__(self, other):
31765 
    return not (self == other)
31766 
 
31767 
class getTelecomCircle_args:
31768 
  """
31769 
  Attributes:
31770 
   - id
31771 
   - code
31772 
  """
31773 
 
31774 
  thrift_spec = (
31775 
    None, # 0
31776 
    (1, TType.I64, 'id', None, None, ), # 1
31777 
    (2, TType.STRING, 'code', None, None, ), # 2
31778 
  )
31779 
 
31780 
  def __init__(self, id=None, code=None,):
31781 
    self.id = id
31782 
    self.code = code
31783 
 
31784 
  def read(self, iprot):
31785 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
31786 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
31787 
      return
31788 
    iprot.readStructBegin()
31789 
    while True:
31790 
      (fname, ftype, fid) = iprot.readFieldBegin()
31791 
      if ftype == TType.STOP:
31792 
        break
31793 
      if fid == 1:
31794 
        if ftype == TType.I64:
31795 
          self.id = iprot.readI64();
31796 
        else:
31797 
          iprot.skip(ftype)
31798 
      elif fid == 2:
31799 
        if ftype == TType.STRING:
31800 
          self.code = iprot.readString();
31801 
        else:
31802 
          iprot.skip(ftype)
31803 
      else:
31804 
        iprot.skip(ftype)
31805 
      iprot.readFieldEnd()
31806 
    iprot.readStructEnd()
31807 
 
31808 
  def write(self, oprot):
31809 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
31810 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
31811 
      return
31812 
    oprot.writeStructBegin('getTelecomCircle_args')
31813 
    if self.id is not None:
31814 
      oprot.writeFieldBegin('id', TType.I64, 1)
31815 
      oprot.writeI64(self.id)
31816 
      oprot.writeFieldEnd()
31817 
    if self.code is not None:
31818 
      oprot.writeFieldBegin('code', TType.STRING, 2)
31819 
      oprot.writeString(self.code)
31820 
      oprot.writeFieldEnd()
31821 
    oprot.writeFieldStop()
31822 
    oprot.writeStructEnd()
31823 
 
31824 
  def validate(self):
31825 
    return
31826 
 
31827 
 
31828 
  def __repr__(self):
31829 
    L = ['%s=%r' % (key, value)
31830 
      for key, value in self.__dict__.iteritems()]
31831 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
31832 
 
31833 
  def __eq__(self, other):
31834 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
31835 
 
31836 
  def __ne__(self, other):
31837 
    return not (self == other)
31838 
 
31839 
class getTelecomCircle_result:
31840 
  """
31841 
  Attributes:
31842 
   - success
31843 
  """
31844 
 
31845 
  thrift_spec = (
31846 
    (0, TType.STRUCT, 'success', (TelecomCircle, TelecomCircle.thrift_spec), None, ), # 0
31847 
  )
31848 
 
31849 
  def __init__(self, success=None,):
31850 
    self.success = success
31851 
 
31852 
  def read(self, iprot):
31853 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
31854 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
31855 
      return
31856 
    iprot.readStructBegin()
31857 
    while True:
31858 
      (fname, ftype, fid) = iprot.readFieldBegin()
31859 
      if ftype == TType.STOP:
31860 
        break
31861 
      if fid == 0:
31862 
        if ftype == TType.STRUCT:
31863 
          self.success = TelecomCircle()
31864 
          self.success.read(iprot)
31865 
        else:
31866 
          iprot.skip(ftype)
31867 
      else:
31868 
        iprot.skip(ftype)
31869 
      iprot.readFieldEnd()
31870 
    iprot.readStructEnd()
31871 
 
31872 
  def write(self, oprot):
31873 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
31874 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
31875 
      return
31876 
    oprot.writeStructBegin('getTelecomCircle_result')
31877 
    if self.success is not None:
31878 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
31879 
      self.success.write(oprot)
31880 
      oprot.writeFieldEnd()
31881 
    oprot.writeFieldStop()
31882 
    oprot.writeStructEnd()
31883 
 
31884 
  def validate(self):
31885 
    return
31886 
 
31887 
 
31888 
  def __repr__(self):
31889 
    L = ['%s=%r' % (key, value)
31890 
      for key, value in self.__dict__.iteritems()]
31891 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
31892 
 
31893 
  def __eq__(self, other):
31894 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
31895 
 
31896 
  def __ne__(self, other):
31897 
    return not (self == other)
7109 anupam.sin 31898 
 
31899 
class retrieveHotspotRechargeInvoice_args:
31900 
  """
31901 
  Attributes:
31902 
   - rechargeId
31903 
  """
31904 
 
31905 
  thrift_spec = (
31906 
    None, # 0
31907 
    (1, TType.I64, 'rechargeId', None, None, ), # 1
31908 
  )
31909 
 
31910 
  def __init__(self, rechargeId=None,):
31911 
    self.rechargeId = rechargeId
31912 
 
31913 
  def read(self, iprot):
31914 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
31915 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
31916 
      return
31917 
    iprot.readStructBegin()
31918 
    while True:
31919 
      (fname, ftype, fid) = iprot.readFieldBegin()
31920 
      if ftype == TType.STOP:
31921 
        break
31922 
      if fid == 1:
31923 
        if ftype == TType.I64:
31924 
          self.rechargeId = iprot.readI64();
31925 
        else:
31926 
          iprot.skip(ftype)
31927 
      else:
31928 
        iprot.skip(ftype)
31929 
      iprot.readFieldEnd()
31930 
    iprot.readStructEnd()
31931 
 
31932 
  def write(self, oprot):
31933 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
31934 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
31935 
      return
31936 
    oprot.writeStructBegin('retrieveHotspotRechargeInvoice_args')
31937 
    if self.rechargeId is not None:
31938 
      oprot.writeFieldBegin('rechargeId', TType.I64, 1)
31939 
      oprot.writeI64(self.rechargeId)
31940 
      oprot.writeFieldEnd()
31941 
    oprot.writeFieldStop()
31942 
    oprot.writeStructEnd()
31943 
 
31944 
  def validate(self):
31945 
    return
31946 
 
31947 
 
31948 
  def __repr__(self):
31949 
    L = ['%s=%r' % (key, value)
31950 
      for key, value in self.__dict__.iteritems()]
31951 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
31952 
 
31953 
  def __eq__(self, other):
31954 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
31955 
 
31956 
  def __ne__(self, other):
31957 
    return not (self == other)
31958 
 
31959 
class retrieveHotspotRechargeInvoice_result:
31960 
  """
31961 
  Attributes:
31962 
   - success
31963 
  """
31964 
 
31965 
  thrift_spec = (
31966 
    (0, TType.STRING, 'success', None, None, ), # 0
31967 
  )
31968 
 
31969 
  def __init__(self, success=None,):
31970 
    self.success = success
31971 
 
31972 
  def read(self, iprot):
31973 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
31974 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
31975 
      return
31976 
    iprot.readStructBegin()
31977 
    while True:
31978 
      (fname, ftype, fid) = iprot.readFieldBegin()
31979 
      if ftype == TType.STOP:
31980 
        break
31981 
      if fid == 0:
31982 
        if ftype == TType.STRING:
31983 
          self.success = iprot.readString();
31984 
        else:
31985 
          iprot.skip(ftype)
31986 
      else:
31987 
        iprot.skip(ftype)
31988 
      iprot.readFieldEnd()
31989 
    iprot.readStructEnd()
31990 
 
31991 
  def write(self, oprot):
31992 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
31993 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
31994 
      return
31995 
    oprot.writeStructBegin('retrieveHotspotRechargeInvoice_result')
31996 
    if self.success is not None:
31997 
      oprot.writeFieldBegin('success', TType.STRING, 0)
31998 
      oprot.writeString(self.success)
31999 
      oprot.writeFieldEnd()
32000 
    oprot.writeFieldStop()
32001 
    oprot.writeStructEnd()
32002 
 
32003 
  def validate(self):
32004 
    return
32005 
 
32006 
 
32007 
  def __repr__(self):
32008 
    L = ['%s=%r' % (key, value)
32009 
      for key, value in self.__dict__.iteritems()]
32010 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
32011 
 
32012 
  def __eq__(self, other):
32013 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
32014 
 
32015 
  def __ne__(self, other):
32016 
    return not (self == other)
7169 anupam.sin 32017 
 
32018 
class getRechargeTransactionsByNumber_args:
32019 
  """
32020 
  Attributes:
32021 
   - number
32022 
  """
32023 
 
32024 
  thrift_spec = (
32025 
    None, # 0
32026 
    (1, TType.STRING, 'number', None, None, ), # 1
32027 
  )
32028 
 
32029 
  def __init__(self, number=None,):
32030 
    self.number = number
32031 
 
32032 
  def read(self, iprot):
32033 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
32034 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
32035 
      return
32036 
    iprot.readStructBegin()
32037 
    while True:
32038 
      (fname, ftype, fid) = iprot.readFieldBegin()
32039 
      if ftype == TType.STOP:
32040 
        break
32041 
      if fid == 1:
32042 
        if ftype == TType.STRING:
32043 
          self.number = iprot.readString();
32044 
        else:
32045 
          iprot.skip(ftype)
32046 
      else:
32047 
        iprot.skip(ftype)
32048 
      iprot.readFieldEnd()
32049 
    iprot.readStructEnd()
32050 
 
32051 
  def write(self, oprot):
32052 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
32053 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
32054 
      return
32055 
    oprot.writeStructBegin('getRechargeTransactionsByNumber_args')
32056 
    if self.number is not None:
32057 
      oprot.writeFieldBegin('number', TType.STRING, 1)
32058 
      oprot.writeString(self.number)
32059 
      oprot.writeFieldEnd()
32060 
    oprot.writeFieldStop()
32061 
    oprot.writeStructEnd()
32062 
 
32063 
  def validate(self):
32064 
    return
32065 
 
32066 
 
32067 
  def __repr__(self):
32068 
    L = ['%s=%r' % (key, value)
32069 
      for key, value in self.__dict__.iteritems()]
32070 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
32071 
 
32072 
  def __eq__(self, other):
32073 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
32074 
 
32075 
  def __ne__(self, other):
32076 
    return not (self == other)
32077 
 
32078 
class getRechargeTransactionsByNumber_result:
32079 
  """
32080 
  Attributes:
32081 
   - success
32082 
  """
32083 
 
32084 
  thrift_spec = (
32085 
    (0, TType.LIST, 'success', (TType.STRUCT,(RechargeTransaction, RechargeTransaction.thrift_spec)), None, ), # 0
32086 
  )
32087 
 
32088 
  def __init__(self, success=None,):
32089 
    self.success = success
32090 
 
32091 
  def read(self, iprot):
32092 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
32093 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
32094 
      return
32095 
    iprot.readStructBegin()
32096 
    while True:
32097 
      (fname, ftype, fid) = iprot.readFieldBegin()
32098 
      if ftype == TType.STOP:
32099 
        break
32100 
      if fid == 0:
32101 
        if ftype == TType.LIST:
32102 
          self.success = []
32103 
          (_etype761, _size758) = iprot.readListBegin()
32104 
          for _i762 in xrange(_size758):
32105 
            _elem763 = RechargeTransaction()
32106 
            _elem763.read(iprot)
32107 
            self.success.append(_elem763)
32108 
          iprot.readListEnd()
32109 
        else:
32110 
          iprot.skip(ftype)
32111 
      else:
32112 
        iprot.skip(ftype)
32113 
      iprot.readFieldEnd()
32114 
    iprot.readStructEnd()
32115 
 
32116 
  def write(self, oprot):
32117 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
32118 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
32119 
      return
32120 
    oprot.writeStructBegin('getRechargeTransactionsByNumber_result')
32121 
    if self.success is not None:
32122 
      oprot.writeFieldBegin('success', TType.LIST, 0)
32123 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
32124 
      for iter764 in self.success:
32125 
        iter764.write(oprot)
32126 
      oprot.writeListEnd()
32127 
      oprot.writeFieldEnd()
32128 
    oprot.writeFieldStop()
32129 
    oprot.writeStructEnd()
32130 
 
32131 
  def validate(self):
32132 
    return
32133 
 
32134 
 
32135 
  def __repr__(self):
32136 
    L = ['%s=%r' % (key, value)
32137 
      for key, value in self.__dict__.iteritems()]
32138 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
32139 
 
32140 
  def __eq__(self, other):
32141 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
32142 
 
32143 
  def __ne__(self, other):
32144 
    return not (self == other)
32145 
 
32146 
class updateHotspotStorePassword_args:
32147 
  """
32148 
  Attributes:
32149 
   - storeId
32150 
   - password
32151 
  """
32152 
 
32153 
  thrift_spec = (
32154 
    None, # 0
32155 
    (1, TType.I64, 'storeId', None, None, ), # 1
32156 
    (2, TType.STRING, 'password', None, None, ), # 2
32157 
  )
32158 
 
32159 
  def __init__(self, storeId=None, password=None,):
32160 
    self.storeId = storeId
32161 
    self.password = password
32162 
 
32163 
  def read(self, iprot):
32164 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
32165 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
32166 
      return
32167 
    iprot.readStructBegin()
32168 
    while True:
32169 
      (fname, ftype, fid) = iprot.readFieldBegin()
32170 
      if ftype == TType.STOP:
32171 
        break
32172 
      if fid == 1:
32173 
        if ftype == TType.I64:
32174 
          self.storeId = iprot.readI64();
32175 
        else:
32176 
          iprot.skip(ftype)
32177 
      elif fid == 2:
32178 
        if ftype == TType.STRING:
32179 
          self.password = iprot.readString();
32180 
        else:
32181 
          iprot.skip(ftype)
32182 
      else:
32183 
        iprot.skip(ftype)
32184 
      iprot.readFieldEnd()
32185 
    iprot.readStructEnd()
32186 
 
32187 
  def write(self, oprot):
32188 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
32189 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
32190 
      return
32191 
    oprot.writeStructBegin('updateHotspotStorePassword_args')
32192 
    if self.storeId is not None:
32193 
      oprot.writeFieldBegin('storeId', TType.I64, 1)
32194 
      oprot.writeI64(self.storeId)
32195 
      oprot.writeFieldEnd()
32196 
    if self.password is not None:
32197 
      oprot.writeFieldBegin('password', TType.STRING, 2)
32198 
      oprot.writeString(self.password)
32199 
      oprot.writeFieldEnd()
32200 
    oprot.writeFieldStop()
32201 
    oprot.writeStructEnd()
32202 
 
32203 
  def validate(self):
32204 
    return
32205 
 
32206 
 
32207 
  def __repr__(self):
32208 
    L = ['%s=%r' % (key, value)
32209 
      for key, value in self.__dict__.iteritems()]
32210 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
32211 
 
32212 
  def __eq__(self, other):
32213 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
32214 
 
32215 
  def __ne__(self, other):
32216 
    return not (self == other)
32217 
 
32218 
class updateHotspotStorePassword_result:
32219 
  """
32220 
  Attributes:
32221 
   - success
32222 
  """
32223 
 
32224 
  thrift_spec = (
32225 
    (0, TType.BOOL, 'success', None, None, ), # 0
32226 
  )
32227 
 
32228 
  def __init__(self, success=None,):
32229 
    self.success = success
32230 
 
32231 
  def read(self, iprot):
32232 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
32233 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
32234 
      return
32235 
    iprot.readStructBegin()
32236 
    while True:
32237 
      (fname, ftype, fid) = iprot.readFieldBegin()
32238 
      if ftype == TType.STOP:
32239 
        break
32240 
      if fid == 0:
32241 
        if ftype == TType.BOOL:
32242 
          self.success = iprot.readBool();
32243 
        else:
32244 
          iprot.skip(ftype)
32245 
      else:
32246 
        iprot.skip(ftype)
32247 
      iprot.readFieldEnd()
32248 
    iprot.readStructEnd()
32249 
 
32250 
  def write(self, oprot):
32251 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
32252 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
32253 
      return
32254 
    oprot.writeStructBegin('updateHotspotStorePassword_result')
32255 
    if self.success is not None:
32256 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
32257 
      oprot.writeBool(self.success)
32258 
      oprot.writeFieldEnd()
32259 
    oprot.writeFieldStop()
32260 
    oprot.writeStructEnd()
32261 
 
32262 
  def validate(self):
32263 
    return
32264 
 
32265 
 
32266 
  def __repr__(self):
32267 
    L = ['%s=%r' % (key, value)
32268 
      for key, value in self.__dict__.iteritems()]
32269 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
32270 
 
32271 
  def __eq__(self, other):
32272 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
32273 
 
32274 
  def __ne__(self, other):
32275 
    return not (self == other)