Subversion Repositories SmartDukaan

Rev

Rev 7096 | Rev 7151 | 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 
 
7080 anupam.sin 1504 
  def getRechargeTransaction(self, rechargeId):
1505 
    """
1506 
    Parameters:
1507 
     - rechargeId
1508 
    """
1509 
    pass
7073 anupam.sin 1510 
 
7080 anupam.sin 1511 
  def getFRCs(self, circleId, operatorId):
1512 
    """
1513 
    Parameters:
1514 
     - circleId
1515 
     - operatorId
1516 
    """
1517 
    pass
1518 
 
7096 anupam.sin 1519 
  def getHotspotStore(self, id, hotspotid):
1520 
    """
1521 
    Parameters:
1522 
     - id
1523 
     - hotspotid
1524 
    """
1525 
    pass
7080 anupam.sin 1526 
 
7096 anupam.sin 1527 
  def getTelecomCircle(self, id, code):
1528 
    """
1529 
    Parameters:
1530 
     - id
1531 
     - code
1532 
    """
1533 
    pass
1534 
 
7109 anupam.sin 1535 
  def retrieveHotspotRechargeInvoice(self, rechargeId):
1536 
    """
1537 
    Parameters:
1538 
     - rechargeId
1539 
    """
1540 
    pass
7096 anupam.sin 1541 
 
7109 anupam.sin 1542 
 
3376 rajveer 1543 
class Client(shop2020.thriftpy.generic.GenericService.Client, Iface):
94 ashish 1544 
  def __init__(self, iprot, oprot=None):
3376 rajveer 1545 
    shop2020.thriftpy.generic.GenericService.Client.__init__(self, iprot, oprot)
94 ashish 1546 
 
1547 
  def createTransaction(self, transaction):
1548 
    """
1549 
    Parameters:
1550 
     - transaction
1551 
    """
1552 
    self.send_createTransaction(transaction)
132 ashish 1553 
    return self.recv_createTransaction()
94 ashish 1554 
 
1555 
  def send_createTransaction(self, transaction):
1556 
    self._oprot.writeMessageBegin('createTransaction', TMessageType.CALL, self._seqid)
1557 
    args = createTransaction_args()
1558 
    args.transaction = transaction
1559 
    args.write(self._oprot)
1560 
    self._oprot.writeMessageEnd()
1561 
    self._oprot.trans.flush()
1562 
 
1563 
  def recv_createTransaction(self, ):
1564 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1565 
    if mtype == TMessageType.EXCEPTION:
1566 
      x = TApplicationException()
1567 
      x.read(self._iprot)
1568 
      self._iprot.readMessageEnd()
1569 
      raise x
1570 
    result = createTransaction_result()
1571 
    result.read(self._iprot)
1572 
    self._iprot.readMessageEnd()
3431 rajveer 1573 
    if result.success is not None:
132 ashish 1574 
      return result.success
3431 rajveer 1575 
    if result.ex is not None:
94 ashish 1576 
      raise result.ex
132 ashish 1577 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createTransaction failed: unknown result");
94 ashish 1578 
 
1579 
  def getTransaction(self, id):
1580 
    """
1581 
    Parameters:
1582 
     - id
1583 
    """
1584 
    self.send_getTransaction(id)
1585 
    return self.recv_getTransaction()
1586 
 
1587 
  def send_getTransaction(self, id):
1588 
    self._oprot.writeMessageBegin('getTransaction', TMessageType.CALL, self._seqid)
1589 
    args = getTransaction_args()
1590 
    args.id = id
1591 
    args.write(self._oprot)
1592 
    self._oprot.writeMessageEnd()
1593 
    self._oprot.trans.flush()
1594 
 
1595 
  def recv_getTransaction(self, ):
1596 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1597 
    if mtype == TMessageType.EXCEPTION:
1598 
      x = TApplicationException()
1599 
      x.read(self._iprot)
1600 
      self._iprot.readMessageEnd()
1601 
      raise x
1602 
    result = getTransaction_result()
1603 
    result.read(self._iprot)
1604 
    self._iprot.readMessageEnd()
3431 rajveer 1605 
    if result.success is not None:
94 ashish 1606 
      return result.success
3431 rajveer 1607 
    if result.ex is not None:
94 ashish 1608 
      raise result.ex
1609 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransaction failed: unknown result");
1610 
 
1611 
  def getTransactionsForCustomer(self, customerId, from_date, to_date, status):
1612 
    """
1613 
    Parameters:
1614 
     - customerId
1615 
     - from_date
1616 
     - to_date
1617 
     - status
1618 
    """
1619 
    self.send_getTransactionsForCustomer(customerId, from_date, to_date, status)
1620 
    return self.recv_getTransactionsForCustomer()
1621 
 
1622 
  def send_getTransactionsForCustomer(self, customerId, from_date, to_date, status):
1623 
    self._oprot.writeMessageBegin('getTransactionsForCustomer', TMessageType.CALL, self._seqid)
1624 
    args = getTransactionsForCustomer_args()
1625 
    args.customerId = customerId
1626 
    args.from_date = from_date
1627 
    args.to_date = to_date
1628 
    args.status = status
1629 
    args.write(self._oprot)
1630 
    self._oprot.writeMessageEnd()
1631 
    self._oprot.trans.flush()
1632 
 
1633 
  def recv_getTransactionsForCustomer(self, ):
1634 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1635 
    if mtype == TMessageType.EXCEPTION:
1636 
      x = TApplicationException()
1637 
      x.read(self._iprot)
1638 
      self._iprot.readMessageEnd()
1639 
      raise x
1640 
    result = getTransactionsForCustomer_result()
1641 
    result.read(self._iprot)
1642 
    self._iprot.readMessageEnd()
3431 rajveer 1643 
    if result.success is not None:
94 ashish 1644 
      return result.success
3431 rajveer 1645 
    if result.ex is not None:
94 ashish 1646 
      raise result.ex
1647 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransactionsForCustomer failed: unknown result");
1648 
 
132 ashish 1649 
  def getTransactionsForShoppingCartId(self, shoppingCartId):
1650 
    """
1651 
    Parameters:
1652 
     - shoppingCartId
1653 
    """
1654 
    self.send_getTransactionsForShoppingCartId(shoppingCartId)
1655 
    return self.recv_getTransactionsForShoppingCartId()
1656 
 
1657 
  def send_getTransactionsForShoppingCartId(self, shoppingCartId):
1658 
    self._oprot.writeMessageBegin('getTransactionsForShoppingCartId', TMessageType.CALL, self._seqid)
1659 
    args = getTransactionsForShoppingCartId_args()
1660 
    args.shoppingCartId = shoppingCartId
1661 
    args.write(self._oprot)
1662 
    self._oprot.writeMessageEnd()
1663 
    self._oprot.trans.flush()
1664 
 
1665 
  def recv_getTransactionsForShoppingCartId(self, ):
1666 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1667 
    if mtype == TMessageType.EXCEPTION:
1668 
      x = TApplicationException()
1669 
      x.read(self._iprot)
1670 
      self._iprot.readMessageEnd()
1671 
      raise x
1672 
    result = getTransactionsForShoppingCartId_result()
1673 
    result.read(self._iprot)
1674 
    self._iprot.readMessageEnd()
3431 rajveer 1675 
    if result.success is not None:
132 ashish 1676 
      return result.success
3431 rajveer 1677 
    if result.ex is not None:
132 ashish 1678 
      raise result.ex
1679 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransactionsForShoppingCartId failed: unknown result");
1680 
 
94 ashish 1681 
  def getTransactionStatus(self, transactionId):
1682 
    """
1683 
    Parameters:
1684 
     - transactionId
1685 
    """
1686 
    self.send_getTransactionStatus(transactionId)
1687 
    return self.recv_getTransactionStatus()
1688 
 
1689 
  def send_getTransactionStatus(self, transactionId):
1690 
    self._oprot.writeMessageBegin('getTransactionStatus', TMessageType.CALL, self._seqid)
1691 
    args = getTransactionStatus_args()
1692 
    args.transactionId = transactionId
1693 
    args.write(self._oprot)
1694 
    self._oprot.writeMessageEnd()
1695 
    self._oprot.trans.flush()
1696 
 
1697 
  def recv_getTransactionStatus(self, ):
1698 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1699 
    if mtype == TMessageType.EXCEPTION:
1700 
      x = TApplicationException()
1701 
      x.read(self._iprot)
1702 
      self._iprot.readMessageEnd()
1703 
      raise x
1704 
    result = getTransactionStatus_result()
1705 
    result.read(self._iprot)
1706 
    self._iprot.readMessageEnd()
3431 rajveer 1707 
    if result.success is not None:
94 ashish 1708 
      return result.success
3431 rajveer 1709 
    if result.ex is not None:
94 ashish 1710 
      raise result.ex
1711 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransactionStatus failed: unknown result");
1712 
 
5527 anupam.sin 1713 
  def changeTransactionStatus(self, transactionId, status, description, pickUp, orderType):
94 ashish 1714 
    """
1715 
    Parameters:
1716 
     - transactionId
1717 
     - status
1718 
     - description
5527 anupam.sin 1719 
     - pickUp
1720 
     - orderType
94 ashish 1721 
    """
5527 anupam.sin 1722 
    self.send_changeTransactionStatus(transactionId, status, description, pickUp, orderType)
94 ashish 1723 
    return self.recv_changeTransactionStatus()
1724 
 
5527 anupam.sin 1725 
  def send_changeTransactionStatus(self, transactionId, status, description, pickUp, orderType):
94 ashish 1726 
    self._oprot.writeMessageBegin('changeTransactionStatus', TMessageType.CALL, self._seqid)
1727 
    args = changeTransactionStatus_args()
1728 
    args.transactionId = transactionId
1729 
    args.status = status
1730 
    args.description = description
5527 anupam.sin 1731 
    args.pickUp = pickUp
1732 
    args.orderType = orderType
94 ashish 1733 
    args.write(self._oprot)
1734 
    self._oprot.writeMessageEnd()
1735 
    self._oprot.trans.flush()
1736 
 
1737 
  def recv_changeTransactionStatus(self, ):
1738 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1739 
    if mtype == TMessageType.EXCEPTION:
1740 
      x = TApplicationException()
1741 
      x.read(self._iprot)
1742 
      self._iprot.readMessageEnd()
1743 
      raise x
1744 
    result = changeTransactionStatus_result()
1745 
    result.read(self._iprot)
1746 
    self._iprot.readMessageEnd()
3431 rajveer 1747 
    if result.success is not None:
94 ashish 1748 
      return result.success
3431 rajveer 1749 
    if result.ex is not None:
94 ashish 1750 
      raise result.ex
1751 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "changeTransactionStatus failed: unknown result");
1752 
 
1398 varun.gupt 1753 
  def enqueueTransactionInfoEmail(self, transactionId):
1382 varun.gupt 1754 
    """
1755 
    Parameters:
1756 
     - transactionId
1757 
    """
1398 varun.gupt 1758 
    self.send_enqueueTransactionInfoEmail(transactionId)
1759 
    return self.recv_enqueueTransactionInfoEmail()
1382 varun.gupt 1760 
 
1398 varun.gupt 1761 
  def send_enqueueTransactionInfoEmail(self, transactionId):
1762 
    self._oprot.writeMessageBegin('enqueueTransactionInfoEmail', TMessageType.CALL, self._seqid)
1763 
    args = enqueueTransactionInfoEmail_args()
1382 varun.gupt 1764 
    args.transactionId = transactionId
1765 
    args.write(self._oprot)
1766 
    self._oprot.writeMessageEnd()
1767 
    self._oprot.trans.flush()
1768 
 
1398 varun.gupt 1769 
  def recv_enqueueTransactionInfoEmail(self, ):
1382 varun.gupt 1770 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1771 
    if mtype == TMessageType.EXCEPTION:
1772 
      x = TApplicationException()
1773 
      x.read(self._iprot)
1774 
      self._iprot.readMessageEnd()
1775 
      raise x
1398 varun.gupt 1776 
    result = enqueueTransactionInfoEmail_result()
1382 varun.gupt 1777 
    result.read(self._iprot)
1778 
    self._iprot.readMessageEnd()
3431 rajveer 1779 
    if result.success is not None:
1382 varun.gupt 1780 
      return result.success
3431 rajveer 1781 
    if result.ex is not None:
1382 varun.gupt 1782 
      raise result.ex
1398 varun.gupt 1783 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "enqueueTransactionInfoEmail failed: unknown result");
1382 varun.gupt 1784 
 
4801 anupam.sin 1785 
  def getAllOrders(self, statuses, from_date, to_date, warehouse_id):
94 ashish 1786 
    """
1787 
    Parameters:
4801 anupam.sin 1788 
     - statuses
483 rajveer 1789 
     - from_date
1790 
     - to_date
1791 
     - warehouse_id
94 ashish 1792 
    """
4801 anupam.sin 1793 
    self.send_getAllOrders(statuses, from_date, to_date, warehouse_id)
483 rajveer 1794 
    return self.recv_getAllOrders()
94 ashish 1795 
 
4801 anupam.sin 1796 
  def send_getAllOrders(self, statuses, from_date, to_date, warehouse_id):
483 rajveer 1797 
    self._oprot.writeMessageBegin('getAllOrders', TMessageType.CALL, self._seqid)
1798 
    args = getAllOrders_args()
4801 anupam.sin 1799 
    args.statuses = statuses
483 rajveer 1800 
    args.from_date = from_date
1801 
    args.to_date = to_date
1802 
    args.warehouse_id = warehouse_id
94 ashish 1803 
    args.write(self._oprot)
1804 
    self._oprot.writeMessageEnd()
1805 
    self._oprot.trans.flush()
1806 
 
483 rajveer 1807 
  def recv_getAllOrders(self, ):
94 ashish 1808 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1809 
    if mtype == TMessageType.EXCEPTION:
1810 
      x = TApplicationException()
1811 
      x.read(self._iprot)
1812 
      self._iprot.readMessageEnd()
1813 
      raise x
483 rajveer 1814 
    result = getAllOrders_result()
94 ashish 1815 
    result.read(self._iprot)
1816 
    self._iprot.readMessageEnd()
3431 rajveer 1817 
    if result.success is not None:
94 ashish 1818 
      return result.success
3431 rajveer 1819 
    if result.ex is not None:
94 ashish 1820 
      raise result.ex
483 rajveer 1821 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllOrders failed: unknown result");
94 ashish 1822 
 
4133 chandransh 1823 
  def getOrdersInBatch(self, statuses, offset, limit, warehouse_id):
1824 
    """
1825 
    Returns at most 'limit' orders with the given statuses for the given warehouse starting from the given offset.
1826 
    Pass the status as null and the limit as 0 to ignore them.
1827 
 
1828 
    Parameters:
1829 
     - statuses
1830 
     - offset
1831 
     - limit
1832 
     - warehouse_id
1833 
    """
1834 
    self.send_getOrdersInBatch(statuses, offset, limit, warehouse_id)
1835 
    return self.recv_getOrdersInBatch()
1836 
 
1837 
  def send_getOrdersInBatch(self, statuses, offset, limit, warehouse_id):
1838 
    self._oprot.writeMessageBegin('getOrdersInBatch', TMessageType.CALL, self._seqid)
1839 
    args = getOrdersInBatch_args()
1840 
    args.statuses = statuses
1841 
    args.offset = offset
1842 
    args.limit = limit
1843 
    args.warehouse_id = warehouse_id
1844 
    args.write(self._oprot)
1845 
    self._oprot.writeMessageEnd()
1846 
    self._oprot.trans.flush()
1847 
 
1848 
  def recv_getOrdersInBatch(self, ):
1849 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1850 
    if mtype == TMessageType.EXCEPTION:
1851 
      x = TApplicationException()
1852 
      x.read(self._iprot)
1853 
      self._iprot.readMessageEnd()
1854 
      raise x
1855 
    result = getOrdersInBatch_result()
1856 
    result.read(self._iprot)
1857 
    self._iprot.readMessageEnd()
1858 
    if result.success is not None:
1859 
      return result.success
1860 
    if result.ex is not None:
1861 
      raise result.ex
1862 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersInBatch failed: unknown result");
1863 
 
1864 
  def getOrderCount(self, statuses, warehouseId):
1865 
    """
1866 
    Returns the count of orders with the given statuses assigned to the given warehouse.
1867 
 
1868 
    Parameters:
1869 
     - statuses
1870 
     - warehouseId
1871 
    """
1872 
    self.send_getOrderCount(statuses, warehouseId)
1873 
    return self.recv_getOrderCount()
1874 
 
1875 
  def send_getOrderCount(self, statuses, warehouseId):
1876 
    self._oprot.writeMessageBegin('getOrderCount', TMessageType.CALL, self._seqid)
1877 
    args = getOrderCount_args()
1878 
    args.statuses = statuses
1879 
    args.warehouseId = warehouseId
1880 
    args.write(self._oprot)
1881 
    self._oprot.writeMessageEnd()
1882 
    self._oprot.trans.flush()
1883 
 
1884 
  def recv_getOrderCount(self, ):
1885 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1886 
    if mtype == TMessageType.EXCEPTION:
1887 
      x = TApplicationException()
1888 
      x.read(self._iprot)
1889 
      self._iprot.readMessageEnd()
1890 
      raise x
1891 
    result = getOrderCount_result()
1892 
    result.read(self._iprot)
1893 
    self._iprot.readMessageEnd()
1894 
    if result.success is not None:
1895 
      return result.success
1896 
    if result.ex is not None:
1897 
      raise result.ex
1898 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderCount failed: unknown result");
1899 
 
999 varun.gupt 1900 
  def getOrdersByBillingDate(self, status, start_billing_date, end_billing_date, warehouse_id):
1901 
    """
1132 chandransh 1902 
    Returns orders within a range of their billing dates
3431 rajveer 1903 
 
999 varun.gupt 1904 
    Parameters:
1905 
     - status
1906 
     - start_billing_date
1907 
     - end_billing_date
1908 
     - warehouse_id
1909 
    """
1910 
    self.send_getOrdersByBillingDate(status, start_billing_date, end_billing_date, warehouse_id)
1911 
    return self.recv_getOrdersByBillingDate()
1912 
 
1913 
  def send_getOrdersByBillingDate(self, status, start_billing_date, end_billing_date, warehouse_id):
1914 
    self._oprot.writeMessageBegin('getOrdersByBillingDate', TMessageType.CALL, self._seqid)
1915 
    args = getOrdersByBillingDate_args()
1916 
    args.status = status
1917 
    args.start_billing_date = start_billing_date
1918 
    args.end_billing_date = end_billing_date
1919 
    args.warehouse_id = warehouse_id
1920 
    args.write(self._oprot)
1921 
    self._oprot.writeMessageEnd()
1922 
    self._oprot.trans.flush()
1923 
 
1924 
  def recv_getOrdersByBillingDate(self, ):
1925 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1926 
    if mtype == TMessageType.EXCEPTION:
1927 
      x = TApplicationException()
1928 
      x.read(self._iprot)
1929 
      self._iprot.readMessageEnd()
1930 
      raise x
1931 
    result = getOrdersByBillingDate_result()
1932 
    result.read(self._iprot)
1933 
    self._iprot.readMessageEnd()
3431 rajveer 1934 
    if result.success is not None:
999 varun.gupt 1935 
      return result.success
3431 rajveer 1936 
    if result.ex is not None:
999 varun.gupt 1937 
      raise result.ex
1938 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersByBillingDate failed: unknown result");
1939 
 
3451 chandransh 1940 
  def getOrdersByShippingDate(self, fromShippingDate, toShippingDate, providerId, warehouseId, cod):
3427 chandransh 1941 
    """
1942 
    Returns orders for a particular provider and warehouse which were shipped between the given dates.
3451 chandransh 1943 
    Returned orders comprise of COD orders if cod parameter is true. It comprises of prepaid orders otherwise.
1944 
    Pass providerId and warehouseId as -1 to ignore both these parameters.
3431 rajveer 1945 
 
3427 chandransh 1946 
    Parameters:
1947 
     - fromShippingDate
1948 
     - toShippingDate
1949 
     - providerId
1950 
     - warehouseId
3451 chandransh 1951 
     - cod
3427 chandransh 1952 
    """
3451 chandransh 1953 
    self.send_getOrdersByShippingDate(fromShippingDate, toShippingDate, providerId, warehouseId, cod)
3427 chandransh 1954 
    return self.recv_getOrdersByShippingDate()
1955 
 
3451 chandransh 1956 
  def send_getOrdersByShippingDate(self, fromShippingDate, toShippingDate, providerId, warehouseId, cod):
3427 chandransh 1957 
    self._oprot.writeMessageBegin('getOrdersByShippingDate', TMessageType.CALL, self._seqid)
1958 
    args = getOrdersByShippingDate_args()
1959 
    args.fromShippingDate = fromShippingDate
1960 
    args.toShippingDate = toShippingDate
1961 
    args.providerId = providerId
1962 
    args.warehouseId = warehouseId
3451 chandransh 1963 
    args.cod = cod
3427 chandransh 1964 
    args.write(self._oprot)
1965 
    self._oprot.writeMessageEnd()
1966 
    self._oprot.trans.flush()
1967 
 
1968 
  def recv_getOrdersByShippingDate(self, ):
1969 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1970 
    if mtype == TMessageType.EXCEPTION:
1971 
      x = TApplicationException()
1972 
      x.read(self._iprot)
1973 
      self._iprot.readMessageEnd()
1974 
      raise x
1975 
    result = getOrdersByShippingDate_result()
1976 
    result.read(self._iprot)
1977 
    self._iprot.readMessageEnd()
3431 rajveer 1978 
    if result.success is not None:
3427 chandransh 1979 
      return result.success
3431 rajveer 1980 
    if result.ex is not None:
3427 chandransh 1981 
      raise result.ex
1982 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersByShippingDate failed: unknown result");
1983 
 
1382 varun.gupt 1984 
  def getReturnableOrdersForCustomer(self, customer_id, limit):
1985 
    """
1986 
    Returns order ids for orders which can be returned
3431 rajveer 1987 
 
1382 varun.gupt 1988 
    Parameters:
1989 
     - customer_id
1990 
     - limit
1991 
    """
1992 
    self.send_getReturnableOrdersForCustomer(customer_id, limit)
1993 
    return self.recv_getReturnableOrdersForCustomer()
1994 
 
1995 
  def send_getReturnableOrdersForCustomer(self, customer_id, limit):
1996 
    self._oprot.writeMessageBegin('getReturnableOrdersForCustomer', TMessageType.CALL, self._seqid)
1997 
    args = getReturnableOrdersForCustomer_args()
1998 
    args.customer_id = customer_id
1999 
    args.limit = limit
2000 
    args.write(self._oprot)
2001 
    self._oprot.writeMessageEnd()
2002 
    self._oprot.trans.flush()
2003 
 
2004 
  def recv_getReturnableOrdersForCustomer(self, ):
2005 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2006 
    if mtype == TMessageType.EXCEPTION:
2007 
      x = TApplicationException()
2008 
      x.read(self._iprot)
2009 
      self._iprot.readMessageEnd()
2010 
      raise x
2011 
    result = getReturnableOrdersForCustomer_result()
2012 
    result.read(self._iprot)
2013 
    self._iprot.readMessageEnd()
3431 rajveer 2014 
    if result.success is not None:
1382 varun.gupt 2015 
      return result.success
3431 rajveer 2016 
    if result.ex is not None:
1382 varun.gupt 2017 
      raise result.ex
2018 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReturnableOrdersForCustomer failed: unknown result");
2019 
 
2020 
  def getCancellableOrdersForCustomer(self, customer_id, limit):
2021 
    """
2022 
    Returns order ids for orders which can be cancelled
3431 rajveer 2023 
 
1382 varun.gupt 2024 
    Parameters:
2025 
     - customer_id
2026 
     - limit
2027 
    """
2028 
    self.send_getCancellableOrdersForCustomer(customer_id, limit)
2029 
    return self.recv_getCancellableOrdersForCustomer()
2030 
 
2031 
  def send_getCancellableOrdersForCustomer(self, customer_id, limit):
2032 
    self._oprot.writeMessageBegin('getCancellableOrdersForCustomer', TMessageType.CALL, self._seqid)
2033 
    args = getCancellableOrdersForCustomer_args()
2034 
    args.customer_id = customer_id
2035 
    args.limit = limit
2036 
    args.write(self._oprot)
2037 
    self._oprot.writeMessageEnd()
2038 
    self._oprot.trans.flush()
2039 
 
2040 
  def recv_getCancellableOrdersForCustomer(self, ):
2041 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2042 
    if mtype == TMessageType.EXCEPTION:
2043 
      x = TApplicationException()
2044 
      x.read(self._iprot)
2045 
      self._iprot.readMessageEnd()
2046 
      raise x
2047 
    result = getCancellableOrdersForCustomer_result()
2048 
    result.read(self._iprot)
2049 
    self._iprot.readMessageEnd()
3431 rajveer 2050 
    if result.success is not None:
1382 varun.gupt 2051 
      return result.success
3431 rajveer 2052 
    if result.ex is not None:
1382 varun.gupt 2053 
      raise result.ex
2054 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCancellableOrdersForCustomer failed: unknown result");
2055 
 
483 rajveer 2056 
  def changeOrderStatus(self, orderId, status, description):
94 ashish 2057 
    """
2058 
    Parameters:
483 rajveer 2059 
     - orderId
2060 
     - status
2061 
     - description
94 ashish 2062 
    """
483 rajveer 2063 
    self.send_changeOrderStatus(orderId, status, description)
2064 
    return self.recv_changeOrderStatus()
94 ashish 2065 
 
483 rajveer 2066 
  def send_changeOrderStatus(self, orderId, status, description):
2067 
    self._oprot.writeMessageBegin('changeOrderStatus', TMessageType.CALL, self._seqid)
2068 
    args = changeOrderStatus_args()
2069 
    args.orderId = orderId
2070 
    args.status = status
2071 
    args.description = description
94 ashish 2072 
    args.write(self._oprot)
2073 
    self._oprot.writeMessageEnd()
2074 
    self._oprot.trans.flush()
2075 
 
483 rajveer 2076 
  def recv_changeOrderStatus(self, ):
94 ashish 2077 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2078 
    if mtype == TMessageType.EXCEPTION:
2079 
      x = TApplicationException()
2080 
      x.read(self._iprot)
2081 
      self._iprot.readMessageEnd()
2082 
      raise x
483 rajveer 2083 
    result = changeOrderStatus_result()
94 ashish 2084 
    result.read(self._iprot)
2085 
    self._iprot.readMessageEnd()
3431 rajveer 2086 
    if result.success is not None:
94 ashish 2087 
      return result.success
3431 rajveer 2088 
    if result.ex is not None:
94 ashish 2089 
      raise result.ex
483 rajveer 2090 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "changeOrderStatus failed: unknown result");
94 ashish 2091 
 
1528 ankur.sing 2092 
  def getOrdersForTransaction(self, transactionId, customerId):
94 ashish 2093 
    """
1528 ankur.sing 2094 
    Returns list of orders for given transaction Id. Also filters based on customer Id so that
2095 
    only user who owns the transaction can view its order details.
3431 rajveer 2096 
 
94 ashish 2097 
    Parameters:
2098 
     - transactionId
1528 ankur.sing 2099 
     - customerId
94 ashish 2100 
    """
1528 ankur.sing 2101 
    self.send_getOrdersForTransaction(transactionId, customerId)
483 rajveer 2102 
    return self.recv_getOrdersForTransaction()
94 ashish 2103 
 
1528 ankur.sing 2104 
  def send_getOrdersForTransaction(self, transactionId, customerId):
483 rajveer 2105 
    self._oprot.writeMessageBegin('getOrdersForTransaction', TMessageType.CALL, self._seqid)
2106 
    args = getOrdersForTransaction_args()
94 ashish 2107 
    args.transactionId = transactionId
1528 ankur.sing 2108 
    args.customerId = customerId
94 ashish 2109 
    args.write(self._oprot)
2110 
    self._oprot.writeMessageEnd()
2111 
    self._oprot.trans.flush()
2112 
 
483 rajveer 2113 
  def recv_getOrdersForTransaction(self, ):
94 ashish 2114 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2115 
    if mtype == TMessageType.EXCEPTION:
2116 
      x = TApplicationException()
2117 
      x.read(self._iprot)
2118 
      self._iprot.readMessageEnd()
2119 
      raise x
483 rajveer 2120 
    result = getOrdersForTransaction_result()
94 ashish 2121 
    result.read(self._iprot)
2122 
    self._iprot.readMessageEnd()
3431 rajveer 2123 
    if result.success is not None:
94 ashish 2124 
      return result.success
3431 rajveer 2125 
    if result.ex is not None:
94 ashish 2126 
      raise result.ex
483 rajveer 2127 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersForTransaction failed: unknown result");
94 ashish 2128 
 
3014 chandransh 2129 
  def getOrdersForCustomer(self, customerId, from_date, to_date, statuses):
94 ashish 2130 
    """
3014 chandransh 2131 
    Returns list of orders for the given customer created between the given dates and having the given statuses.
2132 
    Pass and empty list to ignore filtering on statuses.
3431 rajveer 2133 
 
94 ashish 2134 
    Parameters:
483 rajveer 2135 
     - customerId
2136 
     - from_date
2137 
     - to_date
3014 chandransh 2138 
     - statuses
94 ashish 2139 
    """
3014 chandransh 2140 
    self.send_getOrdersForCustomer(customerId, from_date, to_date, statuses)
483 rajveer 2141 
    return self.recv_getOrdersForCustomer()
94 ashish 2142 
 
3014 chandransh 2143 
  def send_getOrdersForCustomer(self, customerId, from_date, to_date, statuses):
483 rajveer 2144 
    self._oprot.writeMessageBegin('getOrdersForCustomer', TMessageType.CALL, self._seqid)
2145 
    args = getOrdersForCustomer_args()
2146 
    args.customerId = customerId
2147 
    args.from_date = from_date
2148 
    args.to_date = to_date
3014 chandransh 2149 
    args.statuses = statuses
94 ashish 2150 
    args.write(self._oprot)
2151 
    self._oprot.writeMessageEnd()
2152 
    self._oprot.trans.flush()
2153 
 
483 rajveer 2154 
  def recv_getOrdersForCustomer(self, ):
94 ashish 2155 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2156 
    if mtype == TMessageType.EXCEPTION:
2157 
      x = TApplicationException()
2158 
      x.read(self._iprot)
2159 
      self._iprot.readMessageEnd()
2160 
      raise x
483 rajveer 2161 
    result = getOrdersForCustomer_result()
94 ashish 2162 
    result.read(self._iprot)
2163 
    self._iprot.readMessageEnd()
3431 rajveer 2164 
    if result.success is not None:
94 ashish 2165 
      return result.success
3431 rajveer 2166 
    if result.ex is not None:
94 ashish 2167 
      raise result.ex
483 rajveer 2168 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersForCustomer failed: unknown result");
94 ashish 2169 
 
483 rajveer 2170 
  def createOrder(self, order):
94 ashish 2171 
    """
2172 
    Parameters:
483 rajveer 2173 
     - order
94 ashish 2174 
    """
483 rajveer 2175 
    self.send_createOrder(order)
2176 
    return self.recv_createOrder()
94 ashish 2177 
 
483 rajveer 2178 
  def send_createOrder(self, order):
2179 
    self._oprot.writeMessageBegin('createOrder', TMessageType.CALL, self._seqid)
2180 
    args = createOrder_args()
2181 
    args.order = order
94 ashish 2182 
    args.write(self._oprot)
2183 
    self._oprot.writeMessageEnd()
2184 
    self._oprot.trans.flush()
2185 
 
483 rajveer 2186 
  def recv_createOrder(self, ):
94 ashish 2187 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2188 
    if mtype == TMessageType.EXCEPTION:
2189 
      x = TApplicationException()
2190 
      x.read(self._iprot)
2191 
      self._iprot.readMessageEnd()
2192 
      raise x
483 rajveer 2193 
    result = createOrder_result()
94 ashish 2194 
    result.read(self._iprot)
2195 
    self._iprot.readMessageEnd()
3431 rajveer 2196 
    if result.success is not None:
94 ashish 2197 
      return result.success
3431 rajveer 2198 
    if result.ex is not None:
94 ashish 2199 
      raise result.ex
483 rajveer 2200 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createOrder failed: unknown result");
94 ashish 2201 
 
483 rajveer 2202 
  def getOrder(self, id):
94 ashish 2203 
    """
2204 
    Parameters:
483 rajveer 2205 
     - id
94 ashish 2206 
    """
483 rajveer 2207 
    self.send_getOrder(id)
2208 
    return self.recv_getOrder()
94 ashish 2209 
 
483 rajveer 2210 
  def send_getOrder(self, id):
2211 
    self._oprot.writeMessageBegin('getOrder', TMessageType.CALL, self._seqid)
2212 
    args = getOrder_args()
2213 
    args.id = id
94 ashish 2214 
    args.write(self._oprot)
2215 
    self._oprot.writeMessageEnd()
2216 
    self._oprot.trans.flush()
2217 
 
483 rajveer 2218 
  def recv_getOrder(self, ):
94 ashish 2219 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2220 
    if mtype == TMessageType.EXCEPTION:
2221 
      x = TApplicationException()
2222 
      x.read(self._iprot)
2223 
      self._iprot.readMessageEnd()
2224 
      raise x
483 rajveer 2225 
    result = getOrder_result()
94 ashish 2226 
    result.read(self._iprot)
2227 
    self._iprot.readMessageEnd()
3431 rajveer 2228 
    if result.success is not None:
94 ashish 2229 
      return result.success
3431 rajveer 2230 
    if result.ex is not None:
94 ashish 2231 
      raise result.ex
483 rajveer 2232 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrder failed: unknown result");
94 ashish 2233 
 
483 rajveer 2234 
  def getLineItemsForOrder(self, orderId):
94 ashish 2235 
    """
2236 
    Parameters:
483 rajveer 2237 
     - orderId
94 ashish 2238 
    """
483 rajveer 2239 
    self.send_getLineItemsForOrder(orderId)
2240 
    return self.recv_getLineItemsForOrder()
94 ashish 2241 
 
483 rajveer 2242 
  def send_getLineItemsForOrder(self, orderId):
2243 
    self._oprot.writeMessageBegin('getLineItemsForOrder', TMessageType.CALL, self._seqid)
2244 
    args = getLineItemsForOrder_args()
2245 
    args.orderId = orderId
94 ashish 2246 
    args.write(self._oprot)
2247 
    self._oprot.writeMessageEnd()
2248 
    self._oprot.trans.flush()
2249 
 
483 rajveer 2250 
  def recv_getLineItemsForOrder(self, ):
94 ashish 2251 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2252 
    if mtype == TMessageType.EXCEPTION:
2253 
      x = TApplicationException()
2254 
      x.read(self._iprot)
2255 
      self._iprot.readMessageEnd()
2256 
      raise x
483 rajveer 2257 
    result = getLineItemsForOrder_result()
94 ashish 2258 
    result.read(self._iprot)
2259 
    self._iprot.readMessageEnd()
3431 rajveer 2260 
    if result.success is not None:
94 ashish 2261 
      return result.success
3431 rajveer 2262 
    if result.ex is not None:
94 ashish 2263 
      raise result.ex
483 rajveer 2264 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getLineItemsForOrder failed: unknown result");
94 ashish 2265 
 
4999 phani.kuma 2266 
  def getOrderList(self, order_ids):
2267 
    """
2268 
    Parameters:
2269 
     - order_ids
2270 
    """
2271 
    self.send_getOrderList(order_ids)
2272 
    return self.recv_getOrderList()
2273 
 
2274 
  def send_getOrderList(self, order_ids):
2275 
    self._oprot.writeMessageBegin('getOrderList', TMessageType.CALL, self._seqid)
2276 
    args = getOrderList_args()
2277 
    args.order_ids = order_ids
2278 
    args.write(self._oprot)
2279 
    self._oprot.writeMessageEnd()
2280 
    self._oprot.trans.flush()
2281 
 
2282 
  def recv_getOrderList(self, ):
2283 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2284 
    if mtype == TMessageType.EXCEPTION:
2285 
      x = TApplicationException()
2286 
      x.read(self._iprot)
2287 
      self._iprot.readMessageEnd()
2288 
      raise x
2289 
    result = getOrderList_result()
2290 
    result.read(self._iprot)
2291 
    self._iprot.readMessageEnd()
2292 
    if result.success is not None:
2293 
      return result.success
2294 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderList failed: unknown result");
2295 
 
5386 phani.kuma 2296 
  def getOrderListForVendor(self, order_ids, vendorId):
2297 
    """
2298 
    Parameters:
2299 
     - order_ids
2300 
     - vendorId
2301 
    """
2302 
    self.send_getOrderListForVendor(order_ids, vendorId)
2303 
    return self.recv_getOrderListForVendor()
2304 
 
2305 
  def send_getOrderListForVendor(self, order_ids, vendorId):
2306 
    self._oprot.writeMessageBegin('getOrderListForVendor', TMessageType.CALL, self._seqid)
2307 
    args = getOrderListForVendor_args()
2308 
    args.order_ids = order_ids
2309 
    args.vendorId = vendorId
2310 
    args.write(self._oprot)
2311 
    self._oprot.writeMessageEnd()
2312 
    self._oprot.trans.flush()
2313 
 
2314 
  def recv_getOrderListForVendor(self, ):
2315 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2316 
    if mtype == TMessageType.EXCEPTION:
2317 
      x = TApplicationException()
2318 
      x.read(self._iprot)
2319 
      self._iprot.readMessageEnd()
2320 
      raise x
2321 
    result = getOrderListForVendor_result()
2322 
    result.read(self._iprot)
2323 
    self._iprot.readMessageEnd()
2324 
    if result.success is not None:
2325 
      return result.success
2326 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderListForVendor failed: unknown result");
2327 
 
1528 ankur.sing 2328 
  def getOrderForCustomer(self, orderId, customerId):
2329 
    """
2330 
    Returns an order for the order Id. Also checks if the order belongs to the customer whose Id is passed.
2331 
    Throws exception if either order Id is invalid or order does not below to the customer whose Id is passed.
3431 rajveer 2332 
 
1528 ankur.sing 2333 
    Parameters:
2334 
     - orderId
2335 
     - customerId
2336 
    """
2337 
    self.send_getOrderForCustomer(orderId, customerId)
2338 
    return self.recv_getOrderForCustomer()
2339 
 
2340 
  def send_getOrderForCustomer(self, orderId, customerId):
2341 
    self._oprot.writeMessageBegin('getOrderForCustomer', TMessageType.CALL, self._seqid)
2342 
    args = getOrderForCustomer_args()
2343 
    args.orderId = orderId
2344 
    args.customerId = customerId
2345 
    args.write(self._oprot)
2346 
    self._oprot.writeMessageEnd()
2347 
    self._oprot.trans.flush()
2348 
 
2349 
  def recv_getOrderForCustomer(self, ):
2350 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2351 
    if mtype == TMessageType.EXCEPTION:
2352 
      x = TApplicationException()
2353 
      x.read(self._iprot)
2354 
      self._iprot.readMessageEnd()
2355 
      raise x
2356 
    result = getOrderForCustomer_result()
2357 
    result.read(self._iprot)
2358 
    self._iprot.readMessageEnd()
3431 rajveer 2359 
    if result.success is not None:
1528 ankur.sing 2360 
      return result.success
3431 rajveer 2361 
    if result.ex is not None:
1528 ankur.sing 2362 
      raise result.ex
2363 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderForCustomer failed: unknown result");
2364 
 
4444 rajveer 2365 
  def getAlerts(self, type, warehouseId, status, timestamp):
3064 chandransh 2366 
    """
2367 
    Parameters:
4394 rajveer 2368 
     - type
4444 rajveer 2369 
     - warehouseId
4394 rajveer 2370 
     - status
2371 
     - timestamp
3064 chandransh 2372 
    """
4444 rajveer 2373 
    self.send_getAlerts(type, warehouseId, status, timestamp)
3064 chandransh 2374 
    return self.recv_getAlerts()
2375 
 
4444 rajveer 2376 
  def send_getAlerts(self, type, warehouseId, status, timestamp):
3064 chandransh 2377 
    self._oprot.writeMessageBegin('getAlerts', TMessageType.CALL, self._seqid)
2378 
    args = getAlerts_args()
4394 rajveer 2379 
    args.type = type
4444 rajveer 2380 
    args.warehouseId = warehouseId
4394 rajveer 2381 
    args.status = status
2382 
    args.timestamp = timestamp
3064 chandransh 2383 
    args.write(self._oprot)
2384 
    self._oprot.writeMessageEnd()
2385 
    self._oprot.trans.flush()
2386 
 
2387 
  def recv_getAlerts(self, ):
2388 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2389 
    if mtype == TMessageType.EXCEPTION:
2390 
      x = TApplicationException()
2391 
      x.read(self._iprot)
2392 
      self._iprot.readMessageEnd()
2393 
      raise x
2394 
    result = getAlerts_result()
2395 
    result.read(self._iprot)
2396 
    self._iprot.readMessageEnd()
3431 rajveer 2397 
    if result.success is not None:
3064 chandransh 2398 
      return result.success
2399 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAlerts failed: unknown result");
2400 
 
4444 rajveer 2401 
  def addAlert(self, type, warehouseId, description):
3064 chandransh 2402 
    """
2403 
    Parameters:
2404 
     - type
4444 rajveer 2405 
     - warehouseId
4394 rajveer 2406 
     - description
3064 chandransh 2407 
    """
4444 rajveer 2408 
    self.send_addAlert(type, warehouseId, description)
4394 rajveer 2409 
    self.recv_addAlert()
3064 chandransh 2410 
 
4444 rajveer 2411 
  def send_addAlert(self, type, warehouseId, description):
4394 rajveer 2412 
    self._oprot.writeMessageBegin('addAlert', TMessageType.CALL, self._seqid)
2413 
    args = addAlert_args()
3064 chandransh 2414 
    args.type = type
4444 rajveer 2415 
    args.warehouseId = warehouseId
4394 rajveer 2416 
    args.description = description
3064 chandransh 2417 
    args.write(self._oprot)
2418 
    self._oprot.writeMessageEnd()
2419 
    self._oprot.trans.flush()
2420 
 
4394 rajveer 2421 
  def recv_addAlert(self, ):
3064 chandransh 2422 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2423 
    if mtype == TMessageType.EXCEPTION:
2424 
      x = TApplicationException()
2425 
      x.read(self._iprot)
2426 
      self._iprot.readMessageEnd()
2427 
      raise x
4394 rajveer 2428 
    result = addAlert_result()
3064 chandransh 2429 
    result.read(self._iprot)
2430 
    self._iprot.readMessageEnd()
2431 
    return
2432 
 
4444 rajveer 2433 
  def markAlertsAsSeen(self, warehouseId):
2434 
    """
2435 
    Parameters:
2436 
     - warehouseId
2437 
    """
2438 
    self.send_markAlertsAsSeen(warehouseId)
2439 
    self.recv_markAlertsAsSeen()
2440 
 
2441 
  def send_markAlertsAsSeen(self, warehouseId):
2442 
    self._oprot.writeMessageBegin('markAlertsAsSeen', TMessageType.CALL, self._seqid)
2443 
    args = markAlertsAsSeen_args()
2444 
    args.warehouseId = warehouseId
2445 
    args.write(self._oprot)
2446 
    self._oprot.writeMessageEnd()
2447 
    self._oprot.trans.flush()
2448 
 
2449 
  def recv_markAlertsAsSeen(self, ):
2450 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2451 
    if mtype == TMessageType.EXCEPTION:
2452 
      x = TApplicationException()
2453 
      x.read(self._iprot)
2454 
      self._iprot.readMessageEnd()
2455 
      raise x
2456 
    result = markAlertsAsSeen_result()
2457 
    result.read(self._iprot)
2458 
    self._iprot.readMessageEnd()
2459 
    return
2460 
 
3064 chandransh 2461 
  def getValidOrderCount(self, ):
2462 
    """
2463 
    Return the number of valid orders. (OrderStatus >= OrderStatus.SUBMITTED_FOR_PROCESSING)
2464 
    """
2465 
    self.send_getValidOrderCount()
2466 
    return self.recv_getValidOrderCount()
2467 
 
2468 
  def send_getValidOrderCount(self, ):
2469 
    self._oprot.writeMessageBegin('getValidOrderCount', TMessageType.CALL, self._seqid)
2470 
    args = getValidOrderCount_args()
2471 
    args.write(self._oprot)
2472 
    self._oprot.writeMessageEnd()
2473 
    self._oprot.trans.flush()
2474 
 
2475 
  def recv_getValidOrderCount(self, ):
2476 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2477 
    if mtype == TMessageType.EXCEPTION:
2478 
      x = TApplicationException()
2479 
      x.read(self._iprot)
2480 
      self._iprot.readMessageEnd()
2481 
      raise x
2482 
    result = getValidOrderCount_result()
2483 
    result.read(self._iprot)
2484 
    self._iprot.readMessageEnd()
3431 rajveer 2485 
    if result.success is not None:
3064 chandransh 2486 
      return result.success
2487 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getValidOrderCount failed: unknown result");
2488 
 
2489 
  def getNoOfCustomersWithSuccessfulTransaction(self, ):
2490 
    """
2491 
    Returns the number of distinct customers who have done successful transactions
2492 
    """
2493 
    self.send_getNoOfCustomersWithSuccessfulTransaction()
2494 
    return self.recv_getNoOfCustomersWithSuccessfulTransaction()
2495 
 
2496 
  def send_getNoOfCustomersWithSuccessfulTransaction(self, ):
2497 
    self._oprot.writeMessageBegin('getNoOfCustomersWithSuccessfulTransaction', TMessageType.CALL, self._seqid)
2498 
    args = getNoOfCustomersWithSuccessfulTransaction_args()
2499 
    args.write(self._oprot)
2500 
    self._oprot.writeMessageEnd()
2501 
    self._oprot.trans.flush()
2502 
 
2503 
  def recv_getNoOfCustomersWithSuccessfulTransaction(self, ):
2504 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2505 
    if mtype == TMessageType.EXCEPTION:
2506 
      x = TApplicationException()
2507 
      x.read(self._iprot)
2508 
      self._iprot.readMessageEnd()
2509 
      raise x
2510 
    result = getNoOfCustomersWithSuccessfulTransaction_result()
2511 
    result.read(self._iprot)
2512 
    self._iprot.readMessageEnd()
3431 rajveer 2513 
    if result.success is not None:
3064 chandransh 2514 
      return result.success
2515 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getNoOfCustomersWithSuccessfulTransaction failed: unknown result");
2516 
 
2517 
  def getValidOrdersAmountRange(self, ):
2518 
    """
2519 
    Returns the minimum and maximum amounts of a valid order. (OrderStatus >= OrderStatus.SUBMITTED_FOR_PROCESSING)
2520 
    List contains two values, first minimum amount and second maximum amount.
2521 
    """
2522 
    self.send_getValidOrdersAmountRange()
2523 
    return self.recv_getValidOrdersAmountRange()
2524 
 
2525 
  def send_getValidOrdersAmountRange(self, ):
2526 
    self._oprot.writeMessageBegin('getValidOrdersAmountRange', TMessageType.CALL, self._seqid)
2527 
    args = getValidOrdersAmountRange_args()
2528 
    args.write(self._oprot)
2529 
    self._oprot.writeMessageEnd()
2530 
    self._oprot.trans.flush()
2531 
 
2532 
  def recv_getValidOrdersAmountRange(self, ):
2533 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2534 
    if mtype == TMessageType.EXCEPTION:
2535 
      x = TApplicationException()
2536 
      x.read(self._iprot)
2537 
      self._iprot.readMessageEnd()
2538 
      raise x
2539 
    result = getValidOrdersAmountRange_result()
2540 
    result.read(self._iprot)
2541 
    self._iprot.readMessageEnd()
3431 rajveer 2542 
    if result.success is not None:
3064 chandransh 2543 
      return result.success
2544 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getValidOrdersAmountRange failed: unknown result");
2545 
 
5874 rajveer 2546 
  def getValidOrders(self, limit, onlyStore):
3064 chandransh 2547 
    """
2548 
    Returns list of Orders in descending order by Order creation date. List is restricted to limit Orders.
2549 
    If limit is passed as 0, then all valid Orders are returned.
3431 rajveer 2550 
 
3064 chandransh 2551 
    Parameters:
2552 
     - limit
5874 rajveer 2553 
     - onlyStore
3064 chandransh 2554 
    """
5874 rajveer 2555 
    self.send_getValidOrders(limit, onlyStore)
3064 chandransh 2556 
    return self.recv_getValidOrders()
2557 
 
5874 rajveer 2558 
  def send_getValidOrders(self, limit, onlyStore):
3064 chandransh 2559 
    self._oprot.writeMessageBegin('getValidOrders', TMessageType.CALL, self._seqid)
2560 
    args = getValidOrders_args()
2561 
    args.limit = limit
5874 rajveer 2562 
    args.onlyStore = onlyStore
3064 chandransh 2563 
    args.write(self._oprot)
2564 
    self._oprot.writeMessageEnd()
2565 
    self._oprot.trans.flush()
2566 
 
2567 
  def recv_getValidOrders(self, ):
2568 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2569 
    if mtype == TMessageType.EXCEPTION:
2570 
      x = TApplicationException()
2571 
      x.read(self._iprot)
2572 
      self._iprot.readMessageEnd()
2573 
      raise x
2574 
    result = getValidOrders_result()
2575 
    result.read(self._iprot)
2576 
    self._iprot.readMessageEnd()
3431 rajveer 2577 
    if result.success is not None:
3064 chandransh 2578 
      return result.success
2579 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getValidOrders failed: unknown result");
2580 
 
1220 chandransh 2581 
  def batchOrders(self, warehouseId):
2582 
    """
2583 
    Create a batch of all the pending orders for the given warehouse.
2584 
    The returned list is orderd by created_timestamp.
2585 
    If there are no pending orders, an empty list is returned.
3431 rajveer 2586 
 
1220 chandransh 2587 
    Parameters:
2588 
     - warehouseId
2589 
    """
2590 
    self.send_batchOrders(warehouseId)
2591 
    return self.recv_batchOrders()
2592 
 
2593 
  def send_batchOrders(self, warehouseId):
2594 
    self._oprot.writeMessageBegin('batchOrders', TMessageType.CALL, self._seqid)
2595 
    args = batchOrders_args()
2596 
    args.warehouseId = warehouseId
2597 
    args.write(self._oprot)
2598 
    self._oprot.writeMessageEnd()
2599 
    self._oprot.trans.flush()
2600 
 
2601 
  def recv_batchOrders(self, ):
2602 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2603 
    if mtype == TMessageType.EXCEPTION:
2604 
      x = TApplicationException()
2605 
      x.read(self._iprot)
2606 
      self._iprot.readMessageEnd()
2607 
      raise x
2608 
    result = batchOrders_result()
2609 
    result.read(self._iprot)
2610 
    self._iprot.readMessageEnd()
3431 rajveer 2611 
    if result.success is not None:
1220 chandransh 2612 
      return result.success
3431 rajveer 2613 
    if result.ex is not None:
1220 chandransh 2614 
      raise result.ex
2615 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "batchOrders failed: unknown result");
2616 
 
1208 chandransh 2617 
  def markOrderAsOutOfStock(self, orderId):
2618 
    """
2619 
    Mark the given order as out of stock. Throws an exception if the order with the given Id couldn't be found.
3431 rajveer 2620 
 
1208 chandransh 2621 
    Parameters:
2622 
     - orderId
2623 
    """
2624 
    self.send_markOrderAsOutOfStock(orderId)
2625 
    return self.recv_markOrderAsOutOfStock()
2626 
 
2627 
  def send_markOrderAsOutOfStock(self, orderId):
2628 
    self._oprot.writeMessageBegin('markOrderAsOutOfStock', TMessageType.CALL, self._seqid)
2629 
    args = markOrderAsOutOfStock_args()
2630 
    args.orderId = orderId
2631 
    args.write(self._oprot)
2632 
    self._oprot.writeMessageEnd()
2633 
    self._oprot.trans.flush()
2634 
 
2635 
  def recv_markOrderAsOutOfStock(self, ):
2636 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2637 
    if mtype == TMessageType.EXCEPTION:
2638 
      x = TApplicationException()
2639 
      x.read(self._iprot)
2640 
      self._iprot.readMessageEnd()
2641 
      raise x
2642 
    result = markOrderAsOutOfStock_result()
2643 
    result.read(self._iprot)
2644 
    self._iprot.readMessageEnd()
3431 rajveer 2645 
    if result.success is not None:
1208 chandransh 2646 
      return result.success
3431 rajveer 2647 
    if result.ex is not None:
1208 chandransh 2648 
      raise result.ex
2649 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderAsOutOfStock failed: unknown result");
2650 
 
3064 chandransh 2651 
  def verifyOrder(self, orderId):
759 chandransh 2652 
    """
3064 chandransh 2653 
    Marks the given order as SUBMITTED_FOR_PROCESSING and updates the verified
2654 
    timestamp. It is intended to be used for COD orders but can be harmlessly
2655 
    used for all other orders as well.
2656 
    Throws an exception if no such order exists.
3431 rajveer 2657 
 
759 chandransh 2658 
    Parameters:
3064 chandransh 2659 
     - orderId
759 chandransh 2660 
    """
3064 chandransh 2661 
    self.send_verifyOrder(orderId)
2662 
    return self.recv_verifyOrder()
759 chandransh 2663 
 
3064 chandransh 2664 
  def send_verifyOrder(self, orderId):
2665 
    self._oprot.writeMessageBegin('verifyOrder', TMessageType.CALL, self._seqid)
2666 
    args = verifyOrder_args()
2667 
    args.orderId = orderId
759 chandransh 2668 
    args.write(self._oprot)
2669 
    self._oprot.writeMessageEnd()
2670 
    self._oprot.trans.flush()
2671 
 
3064 chandransh 2672 
  def recv_verifyOrder(self, ):
759 chandransh 2673 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2674 
    if mtype == TMessageType.EXCEPTION:
2675 
      x = TApplicationException()
2676 
      x.read(self._iprot)
2677 
      self._iprot.readMessageEnd()
2678 
      raise x
3064 chandransh 2679 
    result = verifyOrder_result()
759 chandransh 2680 
    result.read(self._iprot)
2681 
    self._iprot.readMessageEnd()
3431 rajveer 2682 
    if result.success is not None:
759 chandransh 2683 
      return result.success
3431 rajveer 2684 
    if result.ex is not None:
759 chandransh 2685 
      raise result.ex
3064 chandransh 2686 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "verifyOrder failed: unknown result");
759 chandransh 2687 
 
3064 chandransh 2688 
  def acceptOrder(self, orderId):
1113 chandransh 2689 
    """
3064 chandransh 2690 
    Marks the given order as ACCEPTED and updates the accepted timestamp. If the
2691 
    given order is not a COD order, it also captures the payment if the same has
2692 
    not been captured.
2693 
    Throws an exception if no such order exists.
3431 rajveer 2694 
 
1113 chandransh 2695 
    Parameters:
3064 chandransh 2696 
     - orderId
1113 chandransh 2697 
    """
3064 chandransh 2698 
    self.send_acceptOrder(orderId)
2699 
    return self.recv_acceptOrder()
1113 chandransh 2700 
 
3064 chandransh 2701 
  def send_acceptOrder(self, orderId):
2702 
    self._oprot.writeMessageBegin('acceptOrder', TMessageType.CALL, self._seqid)
2703 
    args = acceptOrder_args()
2704 
    args.orderId = orderId
1113 chandransh 2705 
    args.write(self._oprot)
2706 
    self._oprot.writeMessageEnd()
2707 
    self._oprot.trans.flush()
2708 
 
3064 chandransh 2709 
  def recv_acceptOrder(self, ):
1113 chandransh 2710 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2711 
    if mtype == TMessageType.EXCEPTION:
2712 
      x = TApplicationException()
2713 
      x.read(self._iprot)
2714 
      self._iprot.readMessageEnd()
2715 
      raise x
3064 chandransh 2716 
    result = acceptOrder_result()
1113 chandransh 2717 
    result.read(self._iprot)
2718 
    self._iprot.readMessageEnd()
3431 rajveer 2719 
    if result.success is not None:
1113 chandransh 2720 
      return result.success
3431 rajveer 2721 
    if result.ex is not None:
1113 chandransh 2722 
      raise result.ex
3064 chandransh 2723 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "acceptOrder failed: unknown result");
1113 chandransh 2724 
 
5110 mandeep.dh 2725 
  def addBillingDetails(self, orderId, invoice_number, serialNumber, itemNumber, billed_by, jacketNumber, billingType, fulfilmentWarehouseId, authorize):
1132 chandransh 2726 
    """
3064 chandransh 2727 
    Add billing details such as the bill number and the biller to the Order.
4658 mandeep.dh 2728 
    Adds jacket number, item number and Serial no. to the order. Doesn't update
4283 anupam.sin 2729 
    the IMEI no. if a -1 is supplied.
2730 
    Also, it generates an invoice number for the order, marks the order as
2731 
    BILLED and sets the billing timestamp.
2732 
    Returns false if it doesn't find the order with the given ID.
3431 rajveer 2733 
 
1135 chandransh 2734 
    Parameters:
3064 chandransh 2735 
     - orderId
2736 
     - invoice_number
4658 mandeep.dh 2737 
     - serialNumber
4283 anupam.sin 2738 
     - itemNumber
3064 chandransh 2739 
     - billed_by
4264 rajveer 2740 
     - jacketNumber
4283 anupam.sin 2741 
     - billingType
5110 mandeep.dh 2742 
     - fulfilmentWarehouseId
4763 rajveer 2743 
     - authorize
1135 chandransh 2744 
    """
5110 mandeep.dh 2745 
    self.send_addBillingDetails(orderId, invoice_number, serialNumber, itemNumber, billed_by, jacketNumber, billingType, fulfilmentWarehouseId, authorize)
3064 chandransh 2746 
    return self.recv_addBillingDetails()
1135 chandransh 2747 
 
5110 mandeep.dh 2748 
  def send_addBillingDetails(self, orderId, invoice_number, serialNumber, itemNumber, billed_by, jacketNumber, billingType, fulfilmentWarehouseId, authorize):
3064 chandransh 2749 
    self._oprot.writeMessageBegin('addBillingDetails', TMessageType.CALL, self._seqid)
2750 
    args = addBillingDetails_args()
2751 
    args.orderId = orderId
2752 
    args.invoice_number = invoice_number
4658 mandeep.dh 2753 
    args.serialNumber = serialNumber
4283 anupam.sin 2754 
    args.itemNumber = itemNumber
3064 chandransh 2755 
    args.billed_by = billed_by
4264 rajveer 2756 
    args.jacketNumber = jacketNumber
4283 anupam.sin 2757 
    args.billingType = billingType
5110 mandeep.dh 2758 
    args.fulfilmentWarehouseId = fulfilmentWarehouseId
4763 rajveer 2759 
    args.authorize = authorize
1135 chandransh 2760 
    args.write(self._oprot)
2761 
    self._oprot.writeMessageEnd()
2762 
    self._oprot.trans.flush()
2763 
 
3064 chandransh 2764 
  def recv_addBillingDetails(self, ):
1135 chandransh 2765 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2766 
    if mtype == TMessageType.EXCEPTION:
2767 
      x = TApplicationException()
2768 
      x.read(self._iprot)
2769 
      self._iprot.readMessageEnd()
2770 
      raise x
3064 chandransh 2771 
    result = addBillingDetails_result()
1135 chandransh 2772 
    result.read(self._iprot)
2773 
    self._iprot.readMessageEnd()
3431 rajveer 2774 
    if result.success is not None:
3064 chandransh 2775 
      return result.success
3431 rajveer 2776 
    if result.ex is not None:
1135 chandransh 2777 
      raise result.ex
3064 chandransh 2778 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addBillingDetails failed: unknown result");
1135 chandransh 2779 
 
6756 amar.kumar 2780 
  def addInvoiceNumber(self, orderId, invoiceNumber, color, serialNumber, itemNumber):
4579 rajveer 2781 
    """
2782 
    Add the invoice number to the order.
2783 
 
2784 
    Parameters:
2785 
     - orderId
2786 
     - invoiceNumber
4763 rajveer 2787 
     - color
6756 amar.kumar 2788 
     - serialNumber
2789 
     - itemNumber
4579 rajveer 2790 
    """
6756 amar.kumar 2791 
    self.send_addInvoiceNumber(orderId, invoiceNumber, color, serialNumber, itemNumber)
4579 rajveer 2792 
    self.recv_addInvoiceNumber()
2793 
 
6756 amar.kumar 2794 
  def send_addInvoiceNumber(self, orderId, invoiceNumber, color, serialNumber, itemNumber):
4579 rajveer 2795 
    self._oprot.writeMessageBegin('addInvoiceNumber', TMessageType.CALL, self._seqid)
2796 
    args = addInvoiceNumber_args()
2797 
    args.orderId = orderId
2798 
    args.invoiceNumber = invoiceNumber
4763 rajveer 2799 
    args.color = color
6756 amar.kumar 2800 
    args.serialNumber = serialNumber
2801 
    args.itemNumber = itemNumber
4579 rajveer 2802 
    args.write(self._oprot)
2803 
    self._oprot.writeMessageEnd()
2804 
    self._oprot.trans.flush()
2805 
 
2806 
  def recv_addInvoiceNumber(self, ):
2807 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2808 
    if mtype == TMessageType.EXCEPTION:
2809 
      x = TApplicationException()
2810 
      x.read(self._iprot)
2811 
      self._iprot.readMessageEnd()
2812 
      raise x
2813 
    result = addInvoiceNumber_result()
2814 
    result.read(self._iprot)
2815 
    self._iprot.readMessageEnd()
2816 
    if result.ex is not None:
2817 
      raise result.ex
2818 
    return
2819 
 
4910 phani.kuma 2820 
  def markOrdersAsShippedFromWarehouse(self, warehouseId, providerId, cod, orderIds):
1408 ankur.sing 2821 
    """
3064 chandransh 2822 
    Depending on the third parameter, marks either all prepaid or all cod orders BILLED by the
4910 phani.kuma 2823 
    given warehouse and were picked up by the given provider as SHIPPED_FROM_WH.
3431 rajveer 2824 
 
1408 ankur.sing 2825 
    Parameters:
3064 chandransh 2826 
     - warehouseId
1408 ankur.sing 2827 
     - providerId
3064 chandransh 2828 
     - cod
4910 phani.kuma 2829 
     - orderIds
1408 ankur.sing 2830 
    """
4910 phani.kuma 2831 
    self.send_markOrdersAsShippedFromWarehouse(warehouseId, providerId, cod, orderIds)
2832 
    return self.recv_markOrdersAsShippedFromWarehouse()
1408 ankur.sing 2833 
 
4910 phani.kuma 2834 
  def send_markOrdersAsShippedFromWarehouse(self, warehouseId, providerId, cod, orderIds):
2835 
    self._oprot.writeMessageBegin('markOrdersAsShippedFromWarehouse', TMessageType.CALL, self._seqid)
2836 
    args = markOrdersAsShippedFromWarehouse_args()
3064 chandransh 2837 
    args.warehouseId = warehouseId
1408 ankur.sing 2838 
    args.providerId = providerId
3064 chandransh 2839 
    args.cod = cod
4910 phani.kuma 2840 
    args.orderIds = orderIds
1408 ankur.sing 2841 
    args.write(self._oprot)
2842 
    self._oprot.writeMessageEnd()
2843 
    self._oprot.trans.flush()
2844 
 
4910 phani.kuma 2845 
  def recv_markOrdersAsShippedFromWarehouse(self, ):
1408 ankur.sing 2846 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2847 
    if mtype == TMessageType.EXCEPTION:
2848 
      x = TApplicationException()
2849 
      x.read(self._iprot)
2850 
      self._iprot.readMessageEnd()
2851 
      raise x
4910 phani.kuma 2852 
    result = markOrdersAsShippedFromWarehouse_result()
1408 ankur.sing 2853 
    result.read(self._iprot)
2854 
    self._iprot.readMessageEnd()
3431 rajveer 2855 
    if result.success is not None:
1408 ankur.sing 2856 
      return result.success
3431 rajveer 2857 
    if result.ex is not None:
3064 chandransh 2858 
      raise result.ex
4910 phani.kuma 2859 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrdersAsShippedFromWarehouse failed: unknown result");
1408 ankur.sing 2860 
 
5713 rajveer 2861 
  def markOrdersAsReturnedFromStore(self, providerId, orderIds, awbs):
5676 rajveer 2862 
    """
2863 
    Parameters:
2864 
     - providerId
2865 
     - orderIds
5713 rajveer 2866 
     - awbs
5676 rajveer 2867 
    """
5713 rajveer 2868 
    self.send_markOrdersAsReturnedFromStore(providerId, orderIds, awbs)
5676 rajveer 2869 
    return self.recv_markOrdersAsReturnedFromStore()
2870 
 
5713 rajveer 2871 
  def send_markOrdersAsReturnedFromStore(self, providerId, orderIds, awbs):
5676 rajveer 2872 
    self._oprot.writeMessageBegin('markOrdersAsReturnedFromStore', TMessageType.CALL, self._seqid)
2873 
    args = markOrdersAsReturnedFromStore_args()
2874 
    args.providerId = providerId
2875 
    args.orderIds = orderIds
5713 rajveer 2876 
    args.awbs = awbs
5676 rajveer 2877 
    args.write(self._oprot)
2878 
    self._oprot.writeMessageEnd()
2879 
    self._oprot.trans.flush()
2880 
 
2881 
  def recv_markOrdersAsReturnedFromStore(self, ):
2882 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2883 
    if mtype == TMessageType.EXCEPTION:
2884 
      x = TApplicationException()
2885 
      x.read(self._iprot)
2886 
      self._iprot.readMessageEnd()
2887 
      raise x
2888 
    result = markOrdersAsReturnedFromStore_result()
2889 
    result.read(self._iprot)
2890 
    self._iprot.readMessageEnd()
2891 
    if result.success is not None:
2892 
      return result.success
2893 
    if result.ex is not None:
2894 
      raise result.ex
2895 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrdersAsReturnedFromStore failed: unknown result");
2896 
 
4910 phani.kuma 2897 
  def markOrdersAsPickedUp(self, providerId, pickupDetails):
4410 rajveer 2898 
    """
4910 phani.kuma 2899 
    Marks all SHIPPED_FROM_WH orders of the previous day for a provider as SHIPPED_TO_LOGISTICS.
2900 
    Raises an exception if we encounter report for an AWB number that we did not ship.
4410 rajveer 2901 
 
2902 
    Parameters:
2903 
     - providerId
4910 phani.kuma 2904 
     - pickupDetails
4410 rajveer 2905 
    """
4910 phani.kuma 2906 
    self.send_markOrdersAsPickedUp(providerId, pickupDetails)
2907 
    self.recv_markOrdersAsPickedUp()
4410 rajveer 2908 
 
4910 phani.kuma 2909 
  def send_markOrdersAsPickedUp(self, providerId, pickupDetails):
2910 
    self._oprot.writeMessageBegin('markOrdersAsPickedUp', TMessageType.CALL, self._seqid)
2911 
    args = markOrdersAsPickedUp_args()
4410 rajveer 2912 
    args.providerId = providerId
4910 phani.kuma 2913 
    args.pickupDetails = pickupDetails
4410 rajveer 2914 
    args.write(self._oprot)
2915 
    self._oprot.writeMessageEnd()
2916 
    self._oprot.trans.flush()
2917 
 
4910 phani.kuma 2918 
  def recv_markOrdersAsPickedUp(self, ):
4410 rajveer 2919 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2920 
    if mtype == TMessageType.EXCEPTION:
2921 
      x = TApplicationException()
2922 
      x.read(self._iprot)
2923 
      self._iprot.readMessageEnd()
2924 
      raise x
4910 phani.kuma 2925 
    result = markOrdersAsPickedUp_result()
4410 rajveer 2926 
    result.read(self._iprot)
2927 
    self._iprot.readMessageEnd()
2928 
    if result.ex is not None:
2929 
      raise result.ex
4910 phani.kuma 2930 
    return
4410 rajveer 2931 
 
4910 phani.kuma 2932 
  def getOrdersNotPickedUp(self, providerId):
94 ashish 2933 
    """
3064 chandransh 2934 
    Returns a list of orders that were shipped from warehouse but did not appear in the pick-up report.
3431 rajveer 2935 
 
94 ashish 2936 
    Parameters:
3064 chandransh 2937 
     - providerId
304 ashish 2938 
    """
4910 phani.kuma 2939 
    self.send_getOrdersNotPickedUp(providerId)
2940 
    return self.recv_getOrdersNotPickedUp()
94 ashish 2941 
 
4910 phani.kuma 2942 
  def send_getOrdersNotPickedUp(self, providerId):
2943 
    self._oprot.writeMessageBegin('getOrdersNotPickedUp', TMessageType.CALL, self._seqid)
2944 
    args = getOrdersNotPickedUp_args()
3064 chandransh 2945 
    args.providerId = providerId
304 ashish 2946 
    args.write(self._oprot)
2947 
    self._oprot.writeMessageEnd()
2948 
    self._oprot.trans.flush()
2949 
 
4910 phani.kuma 2950 
  def recv_getOrdersNotPickedUp(self, ):
304 ashish 2951 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2952 
    if mtype == TMessageType.EXCEPTION:
2953 
      x = TApplicationException()
2954 
      x.read(self._iprot)
2955 
      self._iprot.readMessageEnd()
2956 
      raise x
4910 phani.kuma 2957 
    result = getOrdersNotPickedUp_result()
304 ashish 2958 
    result.read(self._iprot)
2959 
    self._iprot.readMessageEnd()
3431 rajveer 2960 
    if result.success is not None:
304 ashish 2961 
      return result.success
4910 phani.kuma 2962 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersNotPickedUp failed: unknown result");
304 ashish 2963 
 
3064 chandransh 2964 
  def markOrdersAsDelivered(self, providerId, deliveredOrders):
304 ashish 2965 
    """
3064 chandransh 2966 
    Marks all orders with AWBs in the given map as delivered. Also sets the delivery timestamp and
2967 
    the name of the receiver.
2968 
    Raises an exception if we encounter report for an AWB number that we did not ship.
3431 rajveer 2969 
 
304 ashish 2970 
    Parameters:
3064 chandransh 2971 
     - providerId
2972 
     - deliveredOrders
304 ashish 2973 
    """
3064 chandransh 2974 
    self.send_markOrdersAsDelivered(providerId, deliveredOrders)
2975 
    self.recv_markOrdersAsDelivered()
304 ashish 2976 
 
3064 chandransh 2977 
  def send_markOrdersAsDelivered(self, providerId, deliveredOrders):
2978 
    self._oprot.writeMessageBegin('markOrdersAsDelivered', TMessageType.CALL, self._seqid)
2979 
    args = markOrdersAsDelivered_args()
2980 
    args.providerId = providerId
2981 
    args.deliveredOrders = deliveredOrders
304 ashish 2982 
    args.write(self._oprot)
2983 
    self._oprot.writeMessageEnd()
2984 
    self._oprot.trans.flush()
2985 
 
3064 chandransh 2986 
  def recv_markOrdersAsDelivered(self, ):
304 ashish 2987 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2988 
    if mtype == TMessageType.EXCEPTION:
2989 
      x = TApplicationException()
2990 
      x.read(self._iprot)
2991 
      self._iprot.readMessageEnd()
2992 
      raise x
3064 chandransh 2993 
    result = markOrdersAsDelivered_result()
304 ashish 2994 
    result.read(self._iprot)
2995 
    self._iprot.readMessageEnd()
3431 rajveer 2996 
    if result.ex is not None:
3064 chandransh 2997 
      raise result.ex
304 ashish 2998 
    return
2999 
 
4910 phani.kuma 3000 
  def markAsRTOrders(self, providerId, returnedOrders):
1596 ankur.sing 3001 
    """
4910 phani.kuma 3002 
    Mark all orders with AWBs in the given map as RTO. Also sets the delivery timestamp.
3064 chandransh 3003 
    Raises an exception if we encounter report for an AWB number that we did not ship.
3431 rajveer 3004 
 
3064 chandransh 3005 
    Parameters:
3006 
     - providerId
3007 
     - returnedOrders
1596 ankur.sing 3008 
    """
4910 phani.kuma 3009 
    self.send_markAsRTOrders(providerId, returnedOrders)
3010 
    self.recv_markAsRTOrders()
304 ashish 3011 
 
4910 phani.kuma 3012 
  def send_markAsRTOrders(self, providerId, returnedOrders):
3013 
    self._oprot.writeMessageBegin('markAsRTOrders', TMessageType.CALL, self._seqid)
3014 
    args = markAsRTOrders_args()
3064 chandransh 3015 
    args.providerId = providerId
3016 
    args.returnedOrders = returnedOrders
1596 ankur.sing 3017 
    args.write(self._oprot)
3018 
    self._oprot.writeMessageEnd()
3019 
    self._oprot.trans.flush()
3020 
 
4910 phani.kuma 3021 
  def recv_markAsRTOrders(self, ):
1596 ankur.sing 3022 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3023 
    if mtype == TMessageType.EXCEPTION:
3024 
      x = TApplicationException()
3025 
      x.read(self._iprot)
3026 
      self._iprot.readMessageEnd()
3027 
      raise x
4910 phani.kuma 3028 
    result = markAsRTOrders_result()
1596 ankur.sing 3029 
    result.read(self._iprot)
3030 
    self._iprot.readMessageEnd()
3431 rajveer 3031 
    if result.ex is not None:
3064 chandransh 3032 
      raise result.ex
3033 
    return
1596 ankur.sing 3034 
 
4910 phani.kuma 3035 
  def getRTOrders(self, providerId):
3036 
    """
3037 
    Returns a list of orders that were returned by courier.
3038 
 
3039 
    Parameters:
3040 
     - providerId
3041 
    """
3042 
    self.send_getRTOrders(providerId)
3043 
    return self.recv_getRTOrders()
3044 
 
3045 
  def send_getRTOrders(self, providerId):
3046 
    self._oprot.writeMessageBegin('getRTOrders', TMessageType.CALL, self._seqid)
3047 
    args = getRTOrders_args()
3048 
    args.providerId = providerId
3049 
    args.write(self._oprot)
3050 
    self._oprot.writeMessageEnd()
3051 
    self._oprot.trans.flush()
3052 
 
3053 
  def recv_getRTOrders(self, ):
3054 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3055 
    if mtype == TMessageType.EXCEPTION:
3056 
      x = TApplicationException()
3057 
      x.read(self._iprot)
3058 
      self._iprot.readMessageEnd()
3059 
      raise x
3060 
    result = getRTOrders_result()
3061 
    result.read(self._iprot)
3062 
    self._iprot.readMessageEnd()
3063 
    if result.success is not None:
3064 
      return result.success
3065 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getRTOrders failed: unknown result");
3066 
 
3064 chandransh 3067 
  def updateNonDeliveryReason(self, providerId, undeliveredOrders):
1627 ankur.sing 3068 
    """
3064 chandransh 3069 
    Update the status description of orders whose AWB numbers are keys of the Map.
3431 rajveer 3070 
 
3064 chandransh 3071 
    Parameters:
3072 
     - providerId
3073 
     - undeliveredOrders
1627 ankur.sing 3074 
    """
3064 chandransh 3075 
    self.send_updateNonDeliveryReason(providerId, undeliveredOrders)
4910 phani.kuma 3076 
    self.recv_updateNonDeliveryReason()
1596 ankur.sing 3077 
 
3064 chandransh 3078 
  def send_updateNonDeliveryReason(self, providerId, undeliveredOrders):
3079 
    self._oprot.writeMessageBegin('updateNonDeliveryReason', TMessageType.CALL, self._seqid)
3080 
    args = updateNonDeliveryReason_args()
3081 
    args.providerId = providerId
3082 
    args.undeliveredOrders = undeliveredOrders
1627 ankur.sing 3083 
    args.write(self._oprot)
3084 
    self._oprot.writeMessageEnd()
3085 
    self._oprot.trans.flush()
3086 
 
3064 chandransh 3087 
  def recv_updateNonDeliveryReason(self, ):
1627 ankur.sing 3088 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3089 
    if mtype == TMessageType.EXCEPTION:
3090 
      x = TApplicationException()
3091 
      x.read(self._iprot)
3092 
      self._iprot.readMessageEnd()
3093 
      raise x
3064 chandransh 3094 
    result = updateNonDeliveryReason_result()
1627 ankur.sing 3095 
    result.read(self._iprot)
3096 
    self._iprot.readMessageEnd()
4910 phani.kuma 3097 
    if result.ex is not None:
3098 
      raise result.ex
3099 
    return
3100 
 
3101 
  def getNonDeliveredOrdersbyCourier(self, providerId):
3102 
    """
3103 
    Returns a list of orders that were picked up or shipped four days ago but did not get delivered.
3104 
 
3105 
    Parameters:
3106 
     - providerId
3107 
    """
3108 
    self.send_getNonDeliveredOrdersbyCourier(providerId)
3109 
    return self.recv_getNonDeliveredOrdersbyCourier()
3110 
 
3111 
  def send_getNonDeliveredOrdersbyCourier(self, providerId):
3112 
    self._oprot.writeMessageBegin('getNonDeliveredOrdersbyCourier', TMessageType.CALL, self._seqid)
3113 
    args = getNonDeliveredOrdersbyCourier_args()
3114 
    args.providerId = providerId
3115 
    args.write(self._oprot)
3116 
    self._oprot.writeMessageEnd()
3117 
    self._oprot.trans.flush()
3118 
 
3119 
  def recv_getNonDeliveredOrdersbyCourier(self, ):
3120 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3121 
    if mtype == TMessageType.EXCEPTION:
3122 
      x = TApplicationException()
3123 
      x.read(self._iprot)
3124 
      self._iprot.readMessageEnd()
3125 
      raise x
3126 
    result = getNonDeliveredOrdersbyCourier_result()
3127 
    result.read(self._iprot)
3128 
    self._iprot.readMessageEnd()
4581 phani.kuma 3129 
    if result.success is not None:
3130 
      return result.success
4910 phani.kuma 3131 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getNonDeliveredOrdersbyCourier failed: unknown result");
3132 
 
3133 
  def markOrdersAsLocalConnected(self, providerId, local_connected_orders):
3134 
    """
3135 
    Mark all orders with AWBs in the given map as local connected. Also sets the local connected timestamp.
3136 
 
3137 
    Parameters:
3138 
     - providerId
3139 
     - local_connected_orders
3140 
    """
3141 
    self.send_markOrdersAsLocalConnected(providerId, local_connected_orders)
3142 
    self.recv_markOrdersAsLocalConnected()
3143 
 
3144 
  def send_markOrdersAsLocalConnected(self, providerId, local_connected_orders):
3145 
    self._oprot.writeMessageBegin('markOrdersAsLocalConnected', TMessageType.CALL, self._seqid)
3146 
    args = markOrdersAsLocalConnected_args()
3147 
    args.providerId = providerId
3148 
    args.local_connected_orders = local_connected_orders
3149 
    args.write(self._oprot)
3150 
    self._oprot.writeMessageEnd()
3151 
    self._oprot.trans.flush()
3152 
 
3153 
  def recv_markOrdersAsLocalConnected(self, ):
3154 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3155 
    if mtype == TMessageType.EXCEPTION:
3156 
      x = TApplicationException()
3157 
      x.read(self._iprot)
3158 
      self._iprot.readMessageEnd()
3159 
      raise x
3160 
    result = markOrdersAsLocalConnected_result()
3161 
    result.read(self._iprot)
3162 
    self._iprot.readMessageEnd()
3431 rajveer 3163 
    if result.ex is not None:
3064 chandransh 3164 
      raise result.ex
4910 phani.kuma 3165 
    return
1627 ankur.sing 3166 
 
4910 phani.kuma 3167 
  def getOrdersNotLocalConnected(self, providerId):
3168 
    """
3169 
    Returns a list of orders that were picked up or shipped but pending local connection.
3170 
 
3171 
    Parameters:
3172 
     - providerId
3173 
    """
3174 
    self.send_getOrdersNotLocalConnected(providerId)
3175 
    return self.recv_getOrdersNotLocalConnected()
3176 
 
3177 
  def send_getOrdersNotLocalConnected(self, providerId):
3178 
    self._oprot.writeMessageBegin('getOrdersNotLocalConnected', TMessageType.CALL, self._seqid)
3179 
    args = getOrdersNotLocalConnected_args()
3180 
    args.providerId = providerId
3181 
    args.write(self._oprot)
3182 
    self._oprot.writeMessageEnd()
3183 
    self._oprot.trans.flush()
3184 
 
3185 
  def recv_getOrdersNotLocalConnected(self, ):
3186 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3187 
    if mtype == TMessageType.EXCEPTION:
3188 
      x = TApplicationException()
3189 
      x.read(self._iprot)
3190 
      self._iprot.readMessageEnd()
3191 
      raise x
3192 
    result = getOrdersNotLocalConnected_result()
3193 
    result.read(self._iprot)
3194 
    self._iprot.readMessageEnd()
3195 
    if result.success is not None:
3196 
      return result.success
3197 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersNotLocalConnected failed: unknown result");
3198 
 
3199 
  def markOrdersAsDestinationCityReached(self, providerId, destination_city_reached_orders):
3200 
    """
3201 
    Mark all orders with AWBs in the given map as reached destination city. Also sets the reached destination timestamp.
3202 
 
3203 
    Parameters:
3204 
     - providerId
3205 
     - destination_city_reached_orders
3206 
    """
3207 
    self.send_markOrdersAsDestinationCityReached(providerId, destination_city_reached_orders)
3208 
    self.recv_markOrdersAsDestinationCityReached()
3209 
 
3210 
  def send_markOrdersAsDestinationCityReached(self, providerId, destination_city_reached_orders):
3211 
    self._oprot.writeMessageBegin('markOrdersAsDestinationCityReached', TMessageType.CALL, self._seqid)
3212 
    args = markOrdersAsDestinationCityReached_args()
3213 
    args.providerId = providerId
3214 
    args.destination_city_reached_orders = destination_city_reached_orders
3215 
    args.write(self._oprot)
3216 
    self._oprot.writeMessageEnd()
3217 
    self._oprot.trans.flush()
3218 
 
3219 
  def recv_markOrdersAsDestinationCityReached(self, ):
3220 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3221 
    if mtype == TMessageType.EXCEPTION:
3222 
      x = TApplicationException()
3223 
      x.read(self._iprot)
3224 
      self._iprot.readMessageEnd()
3225 
      raise x
3226 
    result = markOrdersAsDestinationCityReached_result()
3227 
    result.read(self._iprot)
3228 
    self._iprot.readMessageEnd()
3229 
    if result.ex is not None:
3230 
      raise result.ex
3231 
    return
3232 
 
3233 
  def markOrdersAsFirstDeliveryAttempted(self, providerId, first_atdl_orders):
3234 
    """
3235 
    Mark all orders with AWBs in the given map as first delivery attempt made. Also sets the first delivery attempted timestamp.
3236 
 
3237 
    Parameters:
3238 
     - providerId
3239 
     - first_atdl_orders
3240 
    """
3241 
    self.send_markOrdersAsFirstDeliveryAttempted(providerId, first_atdl_orders)
3242 
    self.recv_markOrdersAsFirstDeliveryAttempted()
3243 
 
3244 
  def send_markOrdersAsFirstDeliveryAttempted(self, providerId, first_atdl_orders):
3245 
    self._oprot.writeMessageBegin('markOrdersAsFirstDeliveryAttempted', TMessageType.CALL, self._seqid)
3246 
    args = markOrdersAsFirstDeliveryAttempted_args()
3247 
    args.providerId = providerId
3248 
    args.first_atdl_orders = first_atdl_orders
3249 
    args.write(self._oprot)
3250 
    self._oprot.writeMessageEnd()
3251 
    self._oprot.trans.flush()
3252 
 
3253 
  def recv_markOrdersAsFirstDeliveryAttempted(self, ):
3254 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3255 
    if mtype == TMessageType.EXCEPTION:
3256 
      x = TApplicationException()
3257 
      x.read(self._iprot)
3258 
      self._iprot.readMessageEnd()
3259 
      raise x
3260 
    result = markOrdersAsFirstDeliveryAttempted_result()
3261 
    result.read(self._iprot)
3262 
    self._iprot.readMessageEnd()
3263 
    if result.ex is not None:
3264 
      raise result.ex
3265 
    return
3266 
 
3064 chandransh 3267 
  def getUndeliveredOrders(self, providerId, warehouseId):
1627 ankur.sing 3268 
    """
3064 chandransh 3269 
    Returns the list of orders whose delivery time has passed but have not been
3270 
    delivered yet for the given provider and warehouse. To get a complete list of
3271 
    undelivered orders, pass them as -1.
3272 
    Returns an empty list if no such orders exist.
3431 rajveer 3273 
 
1886 ankur.sing 3274 
    Parameters:
3064 chandransh 3275 
     - providerId
3276 
     - warehouseId
1886 ankur.sing 3277 
    """
3064 chandransh 3278 
    self.send_getUndeliveredOrders(providerId, warehouseId)
3279 
    return self.recv_getUndeliveredOrders()
1627 ankur.sing 3280 
 
3064 chandransh 3281 
  def send_getUndeliveredOrders(self, providerId, warehouseId):
3282 
    self._oprot.writeMessageBegin('getUndeliveredOrders', TMessageType.CALL, self._seqid)
3283 
    args = getUndeliveredOrders_args()
3284 
    args.providerId = providerId
3285 
    args.warehouseId = warehouseId
1886 ankur.sing 3286 
    args.write(self._oprot)
3287 
    self._oprot.writeMessageEnd()
3288 
    self._oprot.trans.flush()
3289 
 
3064 chandransh 3290 
  def recv_getUndeliveredOrders(self, ):
1886 ankur.sing 3291 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3292 
    if mtype == TMessageType.EXCEPTION:
3293 
      x = TApplicationException()
3294 
      x.read(self._iprot)
3295 
      self._iprot.readMessageEnd()
3296 
      raise x
3064 chandransh 3297 
    result = getUndeliveredOrders_result()
1886 ankur.sing 3298 
    result.read(self._iprot)
3299 
    self._iprot.readMessageEnd()
3431 rajveer 3300 
    if result.success is not None:
1886 ankur.sing 3301 
      return result.success
3064 chandransh 3302 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUndeliveredOrders failed: unknown result");
1886 ankur.sing 3303 
 
4783 phani.kuma 3304 
  def getUndeliveredOrdersExpectedDeliveryDateNotMet(self, ):
3305 
    """
3306 
    Returns the list of orders whose expected delivery date has passed but have not been
3307 
    delivered yet.
3308 
    Returns an empty list if no such orders exist.
3309 
    """
3310 
    self.send_getUndeliveredOrdersExpectedDeliveryDateNotMet()
3311 
    return self.recv_getUndeliveredOrdersExpectedDeliveryDateNotMet()
3312 
 
3313 
  def send_getUndeliveredOrdersExpectedDeliveryDateNotMet(self, ):
3314 
    self._oprot.writeMessageBegin('getUndeliveredOrdersExpectedDeliveryDateNotMet', TMessageType.CALL, self._seqid)
3315 
    args = getUndeliveredOrdersExpectedDeliveryDateNotMet_args()
3316 
    args.write(self._oprot)
3317 
    self._oprot.writeMessageEnd()
3318 
    self._oprot.trans.flush()
3319 
 
3320 
  def recv_getUndeliveredOrdersExpectedDeliveryDateNotMet(self, ):
3321 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3322 
    if mtype == TMessageType.EXCEPTION:
3323 
      x = TApplicationException()
3324 
      x.read(self._iprot)
3325 
      self._iprot.readMessageEnd()
3326 
      raise x
3327 
    result = getUndeliveredOrdersExpectedDeliveryDateNotMet_result()
3328 
    result.read(self._iprot)
3329 
    self._iprot.readMessageEnd()
3330 
    if result.success is not None:
3331 
      return result.success
3332 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUndeliveredOrdersExpectedDeliveryDateNotMet failed: unknown result");
3333 
 
2536 chandransh 3334 
  def toggleDOAFlag(self, orderId):
3335 
    """
3336 
    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.
3337 
    Returns the final flag status.
3338 
    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 3339 
 
2536 chandransh 3340 
    Parameters:
3341 
     - orderId
3342 
    """
3343 
    self.send_toggleDOAFlag(orderId)
3344 
    return self.recv_toggleDOAFlag()
1886 ankur.sing 3345 
 
2536 chandransh 3346 
  def send_toggleDOAFlag(self, orderId):
3347 
    self._oprot.writeMessageBegin('toggleDOAFlag', TMessageType.CALL, self._seqid)
3348 
    args = toggleDOAFlag_args()
3349 
    args.orderId = orderId
3350 
    args.write(self._oprot)
3351 
    self._oprot.writeMessageEnd()
3352 
    self._oprot.trans.flush()
3353 
 
3354 
  def recv_toggleDOAFlag(self, ):
3355 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3356 
    if mtype == TMessageType.EXCEPTION:
3357 
      x = TApplicationException()
3358 
      x.read(self._iprot)
3359 
      self._iprot.readMessageEnd()
3360 
      raise x
3361 
    result = toggleDOAFlag_result()
3362 
    result.read(self._iprot)
3363 
    self._iprot.readMessageEnd()
3431 rajveer 3364 
    if result.success is not None:
2536 chandransh 3365 
      return result.success
3431 rajveer 3366 
    if result.ex is not None:
2536 chandransh 3367 
      raise result.ex
3368 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "toggleDOAFlag failed: unknown result");
3369 
 
4712 rajveer 3370 
  def markOrderAsDelivered(self, orderId, deliveryTimestamp, receiver):
3371 
    """
3372 
    Parameters:
3373 
     - orderId
3374 
     - deliveryTimestamp
3375 
     - receiver
3376 
    """
3377 
    self.send_markOrderAsDelivered(orderId, deliveryTimestamp, receiver)
3378 
    self.recv_markOrderAsDelivered()
3379 
 
3380 
  def send_markOrderAsDelivered(self, orderId, deliveryTimestamp, receiver):
3381 
    self._oprot.writeMessageBegin('markOrderAsDelivered', TMessageType.CALL, self._seqid)
3382 
    args = markOrderAsDelivered_args()
3383 
    args.orderId = orderId
3384 
    args.deliveryTimestamp = deliveryTimestamp
3385 
    args.receiver = receiver
3386 
    args.write(self._oprot)
3387 
    self._oprot.writeMessageEnd()
3388 
    self._oprot.trans.flush()
3389 
 
3390 
  def recv_markOrderAsDelivered(self, ):
3391 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3392 
    if mtype == TMessageType.EXCEPTION:
3393 
      x = TApplicationException()
3394 
      x.read(self._iprot)
3395 
      self._iprot.readMessageEnd()
3396 
      raise x
3397 
    result = markOrderAsDelivered_result()
3398 
    result.read(self._iprot)
3399 
    self._iprot.readMessageEnd()
3400 
    if result.ex is not None:
3401 
      raise result.ex
3402 
    return
3403 
 
5553 rajveer 3404 
  def markOrderAsReceivedAtStore(self, orderId, deliveryTimestamp):
3405 
    """
3406 
    Parameters:
3407 
     - orderId
3408 
     - deliveryTimestamp
3409 
    """
3410 
    self.send_markOrderAsReceivedAtStore(orderId, deliveryTimestamp)
3411 
    self.recv_markOrderAsReceivedAtStore()
3412 
 
3413 
  def send_markOrderAsReceivedAtStore(self, orderId, deliveryTimestamp):
3414 
    self._oprot.writeMessageBegin('markOrderAsReceivedAtStore', TMessageType.CALL, self._seqid)
3415 
    args = markOrderAsReceivedAtStore_args()
3416 
    args.orderId = orderId
3417 
    args.deliveryTimestamp = deliveryTimestamp
3418 
    args.write(self._oprot)
3419 
    self._oprot.writeMessageEnd()
3420 
    self._oprot.trans.flush()
3421 
 
3422 
  def recv_markOrderAsReceivedAtStore(self, ):
3423 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3424 
    if mtype == TMessageType.EXCEPTION:
3425 
      x = TApplicationException()
3426 
      x.read(self._iprot)
3427 
      self._iprot.readMessageEnd()
3428 
      raise x
3429 
    result = markOrderAsReceivedAtStore_result()
3430 
    result.read(self._iprot)
3431 
    self._iprot.readMessageEnd()
3432 
    if result.ex is not None:
3433 
      raise result.ex
3434 
    return
3435 
 
4454 rajveer 3436 
  def markOrderDoaRequestReceived(self, orderId):
3437 
    """
3438 
    Once user raise the request for a DOA, order status will be changed from DELVIERY_SUCCESS to DOA_REQUEST_RECEIVED
3439 
 
3440 
    Parameters:
3441 
     - orderId
3442 
    """
3443 
    self.send_markOrderDoaRequestReceived(orderId)
3444 
    return self.recv_markOrderDoaRequestReceived()
3445 
 
3446 
  def send_markOrderDoaRequestReceived(self, orderId):
3447 
    self._oprot.writeMessageBegin('markOrderDoaRequestReceived', TMessageType.CALL, self._seqid)
3448 
    args = markOrderDoaRequestReceived_args()
3449 
    args.orderId = orderId
3450 
    args.write(self._oprot)
3451 
    self._oprot.writeMessageEnd()
3452 
    self._oprot.trans.flush()
3453 
 
3454 
  def recv_markOrderDoaRequestReceived(self, ):
3455 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3456 
    if mtype == TMessageType.EXCEPTION:
3457 
      x = TApplicationException()
3458 
      x.read(self._iprot)
3459 
      self._iprot.readMessageEnd()
3460 
      raise x
3461 
    result = markOrderDoaRequestReceived_result()
3462 
    result.read(self._iprot)
3463 
    self._iprot.readMessageEnd()
3464 
    if result.success is not None:
3465 
      return result.success
3466 
    if result.ex is not None:
3467 
      raise result.ex
3468 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderDoaRequestReceived failed: unknown result");
3469 
 
3470 
  def markOrderDoaRequestAuthorized(self, orderId, isAuthorized):
3471 
    """
3472 
    CRM person can authorize or deny the request reised by customer. If he authorizes order will change from DOA_REQUEST_RECEIVED
3473 
    to DOA_REQUEST_AUTHORIZED. If he denies, status will be changed back to DELVIERY_SUCCESS.
3474 
 
3475 
    Parameters:
3476 
     - orderId
3477 
     - isAuthorized
3478 
    """
3479 
    self.send_markOrderDoaRequestAuthorized(orderId, isAuthorized)
3480 
    return self.recv_markOrderDoaRequestAuthorized()
3481 
 
3482 
  def send_markOrderDoaRequestAuthorized(self, orderId, isAuthorized):
3483 
    self._oprot.writeMessageBegin('markOrderDoaRequestAuthorized', TMessageType.CALL, self._seqid)
3484 
    args = markOrderDoaRequestAuthorized_args()
3485 
    args.orderId = orderId
3486 
    args.isAuthorized = isAuthorized
3487 
    args.write(self._oprot)
3488 
    self._oprot.writeMessageEnd()
3489 
    self._oprot.trans.flush()
3490 
 
3491 
  def recv_markOrderDoaRequestAuthorized(self, ):
3492 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3493 
    if mtype == TMessageType.EXCEPTION:
3494 
      x = TApplicationException()
3495 
      x.read(self._iprot)
3496 
      self._iprot.readMessageEnd()
3497 
      raise x
3498 
    result = markOrderDoaRequestAuthorized_result()
3499 
    result.read(self._iprot)
3500 
    self._iprot.readMessageEnd()
3501 
    if result.success is not None:
3502 
      return result.success
3503 
    if result.ex is not None:
3504 
      raise result.ex
3505 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderDoaRequestAuthorized failed: unknown result");
3506 
 
4488 rajveer 3507 
  def markOrderReturnRequestReceived(self, orderId):
3508 
    """
3509 
    Once user raise the request for a RET, order status will be changed from DELVIERY_SUCCESS to RET_REQUEST_RECEIVED
3510 
 
3511 
    Parameters:
3512 
     - orderId
3513 
    """
3514 
    self.send_markOrderReturnRequestReceived(orderId)
3515 
    return self.recv_markOrderReturnRequestReceived()
3516 
 
3517 
  def send_markOrderReturnRequestReceived(self, orderId):
3518 
    self._oprot.writeMessageBegin('markOrderReturnRequestReceived', TMessageType.CALL, self._seqid)
3519 
    args = markOrderReturnRequestReceived_args()
3520 
    args.orderId = orderId
3521 
    args.write(self._oprot)
3522 
    self._oprot.writeMessageEnd()
3523 
    self._oprot.trans.flush()
3524 
 
3525 
  def recv_markOrderReturnRequestReceived(self, ):
3526 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3527 
    if mtype == TMessageType.EXCEPTION:
3528 
      x = TApplicationException()
3529 
      x.read(self._iprot)
3530 
      self._iprot.readMessageEnd()
3531 
      raise x
3532 
    result = markOrderReturnRequestReceived_result()
3533 
    result.read(self._iprot)
3534 
    self._iprot.readMessageEnd()
3535 
    if result.success is not None:
3536 
      return result.success
3537 
    if result.ex is not None:
3538 
      raise result.ex
3539 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderReturnRequestReceived failed: unknown result");
3540 
 
3541 
  def markOrderReturnRequestAuthorized(self, orderId, isAuthorized):
3542 
    """
3543 
    CRM person can authorize or deny the request reised by customer. If he authorizes order will change from RET_REQUEST_RECEIVED
3544 
    to RET_REQUEST_AUTHORIZED. If he denies, status will be changed back to DELVIERY_SUCCESS.
3545 
 
3546 
    Parameters:
3547 
     - orderId
3548 
     - isAuthorized
3549 
    """
3550 
    self.send_markOrderReturnRequestAuthorized(orderId, isAuthorized)
3551 
    return self.recv_markOrderReturnRequestAuthorized()
3552 
 
3553 
  def send_markOrderReturnRequestAuthorized(self, orderId, isAuthorized):
3554 
    self._oprot.writeMessageBegin('markOrderReturnRequestAuthorized', TMessageType.CALL, self._seqid)
3555 
    args = markOrderReturnRequestAuthorized_args()
3556 
    args.orderId = orderId
3557 
    args.isAuthorized = isAuthorized
3558 
    args.write(self._oprot)
3559 
    self._oprot.writeMessageEnd()
3560 
    self._oprot.trans.flush()
3561 
 
3562 
  def recv_markOrderReturnRequestAuthorized(self, ):
3563 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3564 
    if mtype == TMessageType.EXCEPTION:
3565 
      x = TApplicationException()
3566 
      x.read(self._iprot)
3567 
      self._iprot.readMessageEnd()
3568 
      raise x
3569 
    result = markOrderReturnRequestAuthorized_result()
3570 
    result.read(self._iprot)
3571 
    self._iprot.readMessageEnd()
3572 
    if result.success is not None:
3573 
      return result.success
3574 
    if result.ex is not None:
3575 
      raise result.ex
3576 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderReturnRequestAuthorized failed: unknown result");
3577 
 
4579 rajveer 3578 
  def requestPickupNumber(self, orderId, providerId):
2536 chandransh 3579 
    """
3580 
    Sends out an email to the account manager of the original courier provider used to ship the order.
4452 rajveer 3581 
    If the order status was DELIVERY_SUCCESS, it is changed to be DOA_PICKUP_REQUEST_RAISED.
3582 
    If the order status was DOA_PICKUP_REQUEST_RAISED, it is left unchanged.
2536 chandransh 3583 
    For any other status, it returns false.
3584 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 3585 
 
2536 chandransh 3586 
    Parameters:
3587 
     - orderId
4579 rajveer 3588 
     - providerId
2536 chandransh 3589 
    """
4579 rajveer 3590 
    self.send_requestPickupNumber(orderId, providerId)
2536 chandransh 3591 
    return self.recv_requestPickupNumber()
3592 
 
4579 rajveer 3593 
  def send_requestPickupNumber(self, orderId, providerId):
2536 chandransh 3594 
    self._oprot.writeMessageBegin('requestPickupNumber', TMessageType.CALL, self._seqid)
3595 
    args = requestPickupNumber_args()
3596 
    args.orderId = orderId
4579 rajveer 3597 
    args.providerId = providerId
2536 chandransh 3598 
    args.write(self._oprot)
3599 
    self._oprot.writeMessageEnd()
3600 
    self._oprot.trans.flush()
3601 
 
3602 
  def recv_requestPickupNumber(self, ):
3603 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3604 
    if mtype == TMessageType.EXCEPTION:
3605 
      x = TApplicationException()
3606 
      x.read(self._iprot)
3607 
      self._iprot.readMessageEnd()
3608 
      raise x
3609 
    result = requestPickupNumber_result()
3610 
    result.read(self._iprot)
3611 
    self._iprot.readMessageEnd()
3431 rajveer 3612 
    if result.success is not None:
2536 chandransh 3613 
      return result.success
3431 rajveer 3614 
    if result.ex is not None:
2536 chandransh 3615 
      raise result.ex
3616 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "requestPickupNumber failed: unknown result");
3617 
 
4602 rajveer 3618 
  def authorizePickup(self, orderId, pickupNumber, providerId):
2536 chandransh 3619 
    """
4452 rajveer 3620 
    If the order status is DOA_PICKUP_REQUEST_RAISED, it does the following
2536 chandransh 3621 
    	1. Sends out an email to the customer with the dispatch advice that he has to print as an attachment.
3622 
    	2. Changes order status to be DOA_PICKUP_AUTHORIZED.
3623 
    	3. Returns true
2591 chandransh 3624 
    If the order is in any other status, it returns false.
2536 chandransh 3625 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 3626 
 
2536 chandransh 3627 
    Parameters:
3628 
     - orderId
3629 
     - pickupNumber
4602 rajveer 3630 
     - providerId
2536 chandransh 3631 
    """
4602 rajveer 3632 
    self.send_authorizePickup(orderId, pickupNumber, providerId)
2536 chandransh 3633 
    return self.recv_authorizePickup()
3634 
 
4602 rajveer 3635 
  def send_authorizePickup(self, orderId, pickupNumber, providerId):
2536 chandransh 3636 
    self._oprot.writeMessageBegin('authorizePickup', TMessageType.CALL, self._seqid)
3637 
    args = authorizePickup_args()
3638 
    args.orderId = orderId
3639 
    args.pickupNumber = pickupNumber
4602 rajveer 3640 
    args.providerId = providerId
2536 chandransh 3641 
    args.write(self._oprot)
3642 
    self._oprot.writeMessageEnd()
3643 
    self._oprot.trans.flush()
3644 
 
3645 
  def recv_authorizePickup(self, ):
3646 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3647 
    if mtype == TMessageType.EXCEPTION:
3648 
      x = TApplicationException()
3649 
      x.read(self._iprot)
3650 
      self._iprot.readMessageEnd()
3651 
      raise x
3652 
    result = authorizePickup_result()
3653 
    result.read(self._iprot)
3654 
    self._iprot.readMessageEnd()
3431 rajveer 3655 
    if result.success is not None:
2536 chandransh 3656 
      return result.success
3431 rajveer 3657 
    if result.ex is not None:
2536 chandransh 3658 
      raise result.ex
3659 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "authorizePickup failed: unknown result");
3660 
 
2764 chandransh 3661 
  def markDoasAsPickedUp(self, providerId, pickupDetails):
3662 
    """
3663 
    Marks all DOA_PICKUP_AUTHORIZED orders of the previous day for a provider as DOA_RETURN_IN_TRANSIT.
3431 rajveer 3664 
 
2764 chandransh 3665 
    Parameters:
3666 
     - providerId
3667 
     - pickupDetails
3668 
    """
3669 
    self.send_markDoasAsPickedUp(providerId, pickupDetails)
4910 phani.kuma 3670 
    self.recv_markDoasAsPickedUp()
2764 chandransh 3671 
 
3672 
  def send_markDoasAsPickedUp(self, providerId, pickupDetails):
3673 
    self._oprot.writeMessageBegin('markDoasAsPickedUp', TMessageType.CALL, self._seqid)
3674 
    args = markDoasAsPickedUp_args()
3675 
    args.providerId = providerId
3676 
    args.pickupDetails = pickupDetails
3677 
    args.write(self._oprot)
3678 
    self._oprot.writeMessageEnd()
3679 
    self._oprot.trans.flush()
3680 
 
3681 
  def recv_markDoasAsPickedUp(self, ):
3682 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3683 
    if mtype == TMessageType.EXCEPTION:
3684 
      x = TApplicationException()
3685 
      x.read(self._iprot)
3686 
      self._iprot.readMessageEnd()
3687 
      raise x
3688 
    result = markDoasAsPickedUp_result()
3689 
    result.read(self._iprot)
3690 
    self._iprot.readMessageEnd()
4910 phani.kuma 3691 
    return
3692 
 
3693 
  def getDoasNotPickedUp(self, providerId):
3694 
    """
3695 
    Returns a list of orders that were authorized for pickup but did not appear in the pick-up report.
3696 
 
3697 
    Parameters:
3698 
     - providerId
3699 
    """
3700 
    self.send_getDoasNotPickedUp(providerId)
3701 
    return self.recv_getDoasNotPickedUp()
3702 
 
3703 
  def send_getDoasNotPickedUp(self, providerId):
3704 
    self._oprot.writeMessageBegin('getDoasNotPickedUp', TMessageType.CALL, self._seqid)
3705 
    args = getDoasNotPickedUp_args()
3706 
    args.providerId = providerId
3707 
    args.write(self._oprot)
3708 
    self._oprot.writeMessageEnd()
3709 
    self._oprot.trans.flush()
3710 
 
3711 
  def recv_getDoasNotPickedUp(self, ):
3712 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3713 
    if mtype == TMessageType.EXCEPTION:
3714 
      x = TApplicationException()
3715 
      x.read(self._iprot)
3716 
      self._iprot.readMessageEnd()
3717 
      raise x
3718 
    result = getDoasNotPickedUp_result()
3719 
    result.read(self._iprot)
3720 
    self._iprot.readMessageEnd()
3431 rajveer 3721 
    if result.success is not None:
2764 chandransh 3722 
      return result.success
4910 phani.kuma 3723 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getDoasNotPickedUp failed: unknown result");
2764 chandransh 3724 
 
4741 phani.kuma 3725 
  def markReturnOrdersAsPickedUp(self, providerId, pickupDetails):
3726 
    """
3727 
    Marks all RET_PICKUP_CONFIRMED orders of the previous day for a provider as RET_RETURN_IN_TRANSIT.
3728 
 
3729 
    Parameters:
3730 
     - providerId
3731 
     - pickupDetails
3732 
    """
3733 
    self.send_markReturnOrdersAsPickedUp(providerId, pickupDetails)
4910 phani.kuma 3734 
    self.recv_markReturnOrdersAsPickedUp()
4741 phani.kuma 3735 
 
3736 
  def send_markReturnOrdersAsPickedUp(self, providerId, pickupDetails):
3737 
    self._oprot.writeMessageBegin('markReturnOrdersAsPickedUp', TMessageType.CALL, self._seqid)
3738 
    args = markReturnOrdersAsPickedUp_args()
3739 
    args.providerId = providerId
3740 
    args.pickupDetails = pickupDetails
3741 
    args.write(self._oprot)
3742 
    self._oprot.writeMessageEnd()
3743 
    self._oprot.trans.flush()
3744 
 
3745 
  def recv_markReturnOrdersAsPickedUp(self, ):
3746 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3747 
    if mtype == TMessageType.EXCEPTION:
3748 
      x = TApplicationException()
3749 
      x.read(self._iprot)
3750 
      self._iprot.readMessageEnd()
3751 
      raise x
3752 
    result = markReturnOrdersAsPickedUp_result()
3753 
    result.read(self._iprot)
3754 
    self._iprot.readMessageEnd()
4910 phani.kuma 3755 
    return
3756 
 
3757 
  def getReturnOrdersNotPickedUp(self, providerId):
3758 
    """
3759 
    Returns a list of orders that were authorized for pickup but did not appear in the pick-up report.
3760 
 
3761 
    Parameters:
3762 
     - providerId
3763 
    """
3764 
    self.send_getReturnOrdersNotPickedUp(providerId)
3765 
    return self.recv_getReturnOrdersNotPickedUp()
3766 
 
3767 
  def send_getReturnOrdersNotPickedUp(self, providerId):
3768 
    self._oprot.writeMessageBegin('getReturnOrdersNotPickedUp', TMessageType.CALL, self._seqid)
3769 
    args = getReturnOrdersNotPickedUp_args()
3770 
    args.providerId = providerId
3771 
    args.write(self._oprot)
3772 
    self._oprot.writeMessageEnd()
3773 
    self._oprot.trans.flush()
3774 
 
3775 
  def recv_getReturnOrdersNotPickedUp(self, ):
3776 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3777 
    if mtype == TMessageType.EXCEPTION:
3778 
      x = TApplicationException()
3779 
      x.read(self._iprot)
3780 
      self._iprot.readMessageEnd()
3781 
      raise x
3782 
    result = getReturnOrdersNotPickedUp_result()
3783 
    result.read(self._iprot)
3784 
    self._iprot.readMessageEnd()
4741 phani.kuma 3785 
    if result.success is not None:
3786 
      return result.success
4910 phani.kuma 3787 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReturnOrdersNotPickedUp failed: unknown result");
4741 phani.kuma 3788 
 
4479 rajveer 3789 
  def receiveReturn(self, orderId, receiveCondition):
2591 chandransh 3790 
    """
4452 rajveer 3791 
    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 3792 
    If the order status is RTO_IN_TRANSIT, marks the order status as RTO_RECEIVED_PRESTINE and returns true.
2591 chandransh 3793 
    If the order is in any other state, it returns false.
3794 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 3795 
 
2591 chandransh 3796 
    Parameters:
3797 
     - orderId
4479 rajveer 3798 
     - receiveCondition
2591 chandransh 3799 
    """
4479 rajveer 3800 
    self.send_receiveReturn(orderId, receiveCondition)
2616 chandransh 3801 
    return self.recv_receiveReturn()
2536 chandransh 3802 
 
4479 rajveer 3803 
  def send_receiveReturn(self, orderId, receiveCondition):
2616 chandransh 3804 
    self._oprot.writeMessageBegin('receiveReturn', TMessageType.CALL, self._seqid)
3805 
    args = receiveReturn_args()
2591 chandransh 3806 
    args.orderId = orderId
4479 rajveer 3807 
    args.receiveCondition = receiveCondition
2591 chandransh 3808 
    args.write(self._oprot)
3809 
    self._oprot.writeMessageEnd()
3810 
    self._oprot.trans.flush()
3811 
 
2616 chandransh 3812 
  def recv_receiveReturn(self, ):
2591 chandransh 3813 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3814 
    if mtype == TMessageType.EXCEPTION:
3815 
      x = TApplicationException()
3816 
      x.read(self._iprot)
3817 
      self._iprot.readMessageEnd()
3818 
      raise x
2616 chandransh 3819 
    result = receiveReturn_result()
2591 chandransh 3820 
    result.read(self._iprot)
3821 
    self._iprot.readMessageEnd()
3431 rajveer 3822 
    if result.success is not None:
2591 chandransh 3823 
      return result.success
3431 rajveer 3824 
    if result.ex is not None:
2591 chandransh 3825 
      raise result.ex
2616 chandransh 3826 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "receiveReturn failed: unknown result");
2591 chandransh 3827 
 
3828 
  def validateDoa(self, orderId, isValid):
3829 
    """
4452 rajveer 3830 
    Used to validate the DOA certificate for an order in the DOA_RECEIVED_PRESTINE state. If the certificate is valid,
2616 chandransh 3831 
    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 3832 
    If the order is in any other state, it returns false.
3833 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 3834 
 
2591 chandransh 3835 
    Parameters:
3836 
     - orderId
3837 
     - isValid
3838 
    """
3839 
    self.send_validateDoa(orderId, isValid)
3840 
    return self.recv_validateDoa()
3841 
 
3842 
  def send_validateDoa(self, orderId, isValid):
3843 
    self._oprot.writeMessageBegin('validateDoa', TMessageType.CALL, self._seqid)
3844 
    args = validateDoa_args()
3845 
    args.orderId = orderId
3846 
    args.isValid = isValid
3847 
    args.write(self._oprot)
3848 
    self._oprot.writeMessageEnd()
3849 
    self._oprot.trans.flush()
3850 
 
3851 
  def recv_validateDoa(self, ):
3852 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3853 
    if mtype == TMessageType.EXCEPTION:
3854 
      x = TApplicationException()
3855 
      x.read(self._iprot)
3856 
      self._iprot.readMessageEnd()
3857 
      raise x
3858 
    result = validateDoa_result()
3859 
    result.read(self._iprot)
3860 
    self._iprot.readMessageEnd()
3431 rajveer 3861 
    if result.success is not None:
2591 chandransh 3862 
      return result.success
3431 rajveer 3863 
    if result.ex is not None:
2591 chandransh 3864 
      raise result.ex
3865 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "validateDoa failed: unknown result");
3866 
 
4495 rajveer 3867 
  def validateReturnProduct(self, orderId, isUsable):
3868 
    """
3869 
    Parameters:
3870 
     - orderId
3871 
     - isUsable
3872 
    """
3873 
    self.send_validateReturnProduct(orderId, isUsable)
3874 
    return self.recv_validateReturnProduct()
3875 
 
3876 
  def send_validateReturnProduct(self, orderId, isUsable):
3877 
    self._oprot.writeMessageBegin('validateReturnProduct', TMessageType.CALL, self._seqid)
3878 
    args = validateReturnProduct_args()
3879 
    args.orderId = orderId
3880 
    args.isUsable = isUsable
3881 
    args.write(self._oprot)
3882 
    self._oprot.writeMessageEnd()
3883 
    self._oprot.trans.flush()
3884 
 
3885 
  def recv_validateReturnProduct(self, ):
3886 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3887 
    if mtype == TMessageType.EXCEPTION:
3888 
      x = TApplicationException()
3889 
      x.read(self._iprot)
3890 
      self._iprot.readMessageEnd()
3891 
      raise x
3892 
    result = validateReturnProduct_result()
3893 
    result.read(self._iprot)
3894 
    self._iprot.readMessageEnd()
3895 
    if result.success is not None:
3896 
      return result.success
3897 
    if result.ex is not None:
3898 
      raise result.ex
3899 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "validateReturnProduct failed: unknown result");
3900 
 
2616 chandransh 3901 
  def reshipOrder(self, orderId):
3902 
    """
4484 rajveer 3903 
    If the order is in RTO_RECEIVED_PRESTINE or DOA_CERT_INVALID state, it does the following:
2616 chandransh 3904 
    	1. Creates a new order for processing in the BILLED state. All billing information is saved.
4484 rajveer 3905 
    	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 3906 
 
3907 
    If the order is in DOA_CERT_VALID state, it does the following:
3908 
    	1. Creates a new order for processing in the SUBMITTED_FOR_PROCESSING state.
3909 
    	2. Creates a return order for the warehouse executive to return the DOA material.
4452 rajveer 3910 
    	3. Marks the current order as the final DOA_VALID_RESHIPPED state.
3431 rajveer 3911 
 
2616 chandransh 3912 
    Returns the id of the newly created order.
3431 rajveer 3913 
 
2616 chandransh 3914 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 3915 
 
2616 chandransh 3916 
    Parameters:
3917 
     - orderId
3918 
    """
3919 
    self.send_reshipOrder(orderId)
3920 
    return self.recv_reshipOrder()
2591 chandransh 3921 
 
2616 chandransh 3922 
  def send_reshipOrder(self, orderId):
3923 
    self._oprot.writeMessageBegin('reshipOrder', TMessageType.CALL, self._seqid)
3924 
    args = reshipOrder_args()
3925 
    args.orderId = orderId
3926 
    args.write(self._oprot)
3927 
    self._oprot.writeMessageEnd()
3928 
    self._oprot.trans.flush()
3929 
 
3930 
  def recv_reshipOrder(self, ):
3931 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3932 
    if mtype == TMessageType.EXCEPTION:
3933 
      x = TApplicationException()
3934 
      x.read(self._iprot)
3935 
      self._iprot.readMessageEnd()
3936 
      raise x
3937 
    result = reshipOrder_result()
3938 
    result.read(self._iprot)
3939 
    self._iprot.readMessageEnd()
3431 rajveer 3940 
    if result.success is not None:
2616 chandransh 3941 
      return result.success
3431 rajveer 3942 
    if result.ex is not None:
2616 chandransh 3943 
      raise result.ex
3944 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "reshipOrder failed: unknown result");
3945 
 
3226 chandransh 3946 
  def refundOrder(self, orderId, refundedBy, reason):
2616 chandransh 3947 
    """
4484 rajveer 3948 
    If the order is in RTO_RECEIVED_PRESTINE, DOA_CERT_VALID or DOA_CERT_INVALID state, it does the following:
2616 chandransh 3949 
    	1. Creates a refund request for batch processing.
3950 
    	2. Creates a return order for the warehouse executive to return the shipped material.
4484 rajveer 3951 
    	3. Marks the current order as RTO_REFUNDED, DOA_VALID_REFUNDED or DOA_INVALID_REFUNDED final states.
3431 rajveer 3952 
 
2616 chandransh 3953 
    If the order is in SUBMITTED_FOR_PROCESSING or INVENTORY_LOW state, it does the following:
3954 
    	1. Creates a refund request for batch processing.
3226 chandransh 3955 
    	2. Cancels the reservation of the item in the warehouse.
3956 
    	3. Marks the current order as the REFUNDED final state.
3431 rajveer 3957 
 
3226 chandransh 3958 
    For all COD orders, if the order is in INIT, SUBMITTED_FOR_PROCESSING or INVENTORY_LOW state, it does the following:
3959 
    	1. Cancels the reservation of the item in the warehouse.
3960 
    	2. Marks the current order as CANCELED.
3961 
 
3962 
    In all cases, it updates the reason for cancellation or refund and the person who performed the action.
3963 
 
2616 chandransh 3964 
    Returns True if it is successful, False otherwise.
3431 rajveer 3965 
 
2616 chandransh 3966 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 3967 
 
2616 chandransh 3968 
    Parameters:
3969 
     - orderId
3226 chandransh 3970 
     - refundedBy
3971 
     - reason
2616 chandransh 3972 
    """
3226 chandransh 3973 
    self.send_refundOrder(orderId, refundedBy, reason)
2616 chandransh 3974 
    return self.recv_refundOrder()
3975 
 
3226 chandransh 3976 
  def send_refundOrder(self, orderId, refundedBy, reason):
2616 chandransh 3977 
    self._oprot.writeMessageBegin('refundOrder', TMessageType.CALL, self._seqid)
3978 
    args = refundOrder_args()
3979 
    args.orderId = orderId
3226 chandransh 3980 
    args.refundedBy = refundedBy
3981 
    args.reason = reason
2616 chandransh 3982 
    args.write(self._oprot)
3983 
    self._oprot.writeMessageEnd()
3984 
    self._oprot.trans.flush()
3985 
 
3986 
  def recv_refundOrder(self, ):
3987 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3988 
    if mtype == TMessageType.EXCEPTION:
3989 
      x = TApplicationException()
3990 
      x.read(self._iprot)
3991 
      self._iprot.readMessageEnd()
3992 
      raise x
3993 
    result = refundOrder_result()
3994 
    result.read(self._iprot)
3995 
    self._iprot.readMessageEnd()
3431 rajveer 3996 
    if result.success is not None:
2616 chandransh 3997 
      return result.success
3431 rajveer 3998 
    if result.ex is not None:
2616 chandransh 3999 
      raise result.ex
4000 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "refundOrder failed: unknown result");
4001 
 
2690 chandransh 4002 
  def getReturnOrders(self, warehouseId, fromDate, toDate):
4003 
    """
4004 
    Get all return orders created between the from and to dates for the given warehouse.
4005 
    Ignores the warehouse if it is passed as -1.
3431 rajveer 4006 
 
2690 chandransh 4007 
    Parameters:
4008 
     - warehouseId
4009 
     - fromDate
4010 
     - toDate
4011 
    """
4012 
    self.send_getReturnOrders(warehouseId, fromDate, toDate)
4013 
    return self.recv_getReturnOrders()
2616 chandransh 4014 
 
2690 chandransh 4015 
  def send_getReturnOrders(self, warehouseId, fromDate, toDate):
4016 
    self._oprot.writeMessageBegin('getReturnOrders', TMessageType.CALL, self._seqid)
4017 
    args = getReturnOrders_args()
4018 
    args.warehouseId = warehouseId
4019 
    args.fromDate = fromDate
4020 
    args.toDate = toDate
4021 
    args.write(self._oprot)
4022 
    self._oprot.writeMessageEnd()
4023 
    self._oprot.trans.flush()
4024 
 
4025 
  def recv_getReturnOrders(self, ):
4026 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4027 
    if mtype == TMessageType.EXCEPTION:
4028 
      x = TApplicationException()
4029 
      x.read(self._iprot)
4030 
      self._iprot.readMessageEnd()
4031 
      raise x
4032 
    result = getReturnOrders_result()
4033 
    result.read(self._iprot)
4034 
    self._iprot.readMessageEnd()
3431 rajveer 4035 
    if result.success is not None:
2690 chandransh 4036 
      return result.success
4037 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReturnOrders failed: unknown result");
4038 
 
5481 phani.kuma 4039 
  def getAllReturnOrders(self, onlyNotProcessed, fromDate, toDate):
4040 
    """
4041 
    Get all return orders created between the from and to dates.
4042 
 
4043 
    Parameters:
4044 
     - onlyNotProcessed
4045 
     - fromDate
4046 
     - toDate
4047 
    """
4048 
    self.send_getAllReturnOrders(onlyNotProcessed, fromDate, toDate)
4049 
    return self.recv_getAllReturnOrders()
4050 
 
4051 
  def send_getAllReturnOrders(self, onlyNotProcessed, fromDate, toDate):
4052 
    self._oprot.writeMessageBegin('getAllReturnOrders', TMessageType.CALL, self._seqid)
4053 
    args = getAllReturnOrders_args()
4054 
    args.onlyNotProcessed = onlyNotProcessed
4055 
    args.fromDate = fromDate
4056 
    args.toDate = toDate
4057 
    args.write(self._oprot)
4058 
    self._oprot.writeMessageEnd()
4059 
    self._oprot.trans.flush()
4060 
 
4061 
  def recv_getAllReturnOrders(self, ):
4062 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4063 
    if mtype == TMessageType.EXCEPTION:
4064 
      x = TApplicationException()
4065 
      x.read(self._iprot)
4066 
      self._iprot.readMessageEnd()
4067 
      raise x
4068 
    result = getAllReturnOrders_result()
4069 
    result.read(self._iprot)
4070 
    self._iprot.readMessageEnd()
4071 
    if result.success is not None:
4072 
      return result.success
4073 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllReturnOrders failed: unknown result");
4074 
 
2700 chandransh 4075 
  def getReturnOrder(self, id):
4076 
    """
4077 
    Returns the ReturnOrder corresponding to the given id.
4078 
    Throws an exception if the return order with the given id couldn't be found.
3431 rajveer 4079 
 
2700 chandransh 4080 
    Parameters:
4081 
     - id
4082 
    """
4083 
    self.send_getReturnOrder(id)
4084 
    return self.recv_getReturnOrder()
4085 
 
4086 
  def send_getReturnOrder(self, id):
4087 
    self._oprot.writeMessageBegin('getReturnOrder', TMessageType.CALL, self._seqid)
4088 
    args = getReturnOrder_args()
4089 
    args.id = id
4090 
    args.write(self._oprot)
4091 
    self._oprot.writeMessageEnd()
4092 
    self._oprot.trans.flush()
4093 
 
4094 
  def recv_getReturnOrder(self, ):
4095 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4096 
    if mtype == TMessageType.EXCEPTION:
4097 
      x = TApplicationException()
4098 
      x.read(self._iprot)
4099 
      self._iprot.readMessageEnd()
4100 
      raise x
4101 
    result = getReturnOrder_result()
4102 
    result.read(self._iprot)
4103 
    self._iprot.readMessageEnd()
3431 rajveer 4104 
    if result.success is not None:
2700 chandransh 4105 
      return result.success
3431 rajveer 4106 
    if result.ex is not None:
2700 chandransh 4107 
      raise result.ex
4108 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReturnOrder failed: unknown result");
4109 
 
2690 chandransh 4110 
  def processReturn(self, returnOrderId):
4111 
    """
4112 
    Marks the return order with the given id as processed. Raises an exception if no such return order exists.
3431 rajveer 4113 
 
2690 chandransh 4114 
    Parameters:
4115 
     - returnOrderId
4116 
    """
4117 
    self.send_processReturn(returnOrderId)
4118 
    self.recv_processReturn()
4119 
 
4120 
  def send_processReturn(self, returnOrderId):
4121 
    self._oprot.writeMessageBegin('processReturn', TMessageType.CALL, self._seqid)
4122 
    args = processReturn_args()
4123 
    args.returnOrderId = returnOrderId
4124 
    args.write(self._oprot)
4125 
    self._oprot.writeMessageEnd()
4126 
    self._oprot.trans.flush()
4127 
 
4128 
  def recv_processReturn(self, ):
4129 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4130 
    if mtype == TMessageType.EXCEPTION:
4131 
      x = TApplicationException()
4132 
      x.read(self._iprot)
4133 
      self._iprot.readMessageEnd()
4134 
      raise x
4135 
    result = processReturn_result()
4136 
    result.read(self._iprot)
4137 
    self._iprot.readMessageEnd()
3431 rajveer 4138 
    if result.ex is not None:
2690 chandransh 4139 
      raise result.ex
4140 
    return
4141 
 
3451 chandransh 4142 
  def updateWeight(self, orderId, weight):
4143 
    """
4144 
    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 4145 
 
3451 chandransh 4146 
    Parameters:
4147 
     - orderId
4148 
     - weight
4149 
    """
4150 
    self.send_updateWeight(orderId, weight)
4151 
    return self.recv_updateWeight()
4152 
 
4153 
  def send_updateWeight(self, orderId, weight):
4154 
    self._oprot.writeMessageBegin('updateWeight', TMessageType.CALL, self._seqid)
4155 
    args = updateWeight_args()
4156 
    args.orderId = orderId
4157 
    args.weight = weight
4158 
    args.write(self._oprot)
4159 
    self._oprot.writeMessageEnd()
4160 
    self._oprot.trans.flush()
4161 
 
4162 
  def recv_updateWeight(self, ):
4163 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4164 
    if mtype == TMessageType.EXCEPTION:
4165 
      x = TApplicationException()
4166 
      x.read(self._iprot)
4167 
      self._iprot.readMessageEnd()
4168 
      raise x
4169 
    result = updateWeight_result()
4170 
    result.read(self._iprot)
4171 
    self._iprot.readMessageEnd()
4172 
    if result.success is not None:
4173 
      return result.success
4174 
    if result.ex is not None:
4175 
      raise result.ex
4176 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updateWeight failed: unknown result");
4177 
 
3469 chandransh 4178 
  def changeItem(self, orderId, itemId):
4179 
    """
4180 
    Change the item to be shipped for this order. Also adjusts the reservation in the inventory accordingly.
4181 
    Currently, it also ensures that only a different color of the given item is shipped.
3451 chandransh 4182 
 
3469 chandransh 4183 
    Parameters:
4184 
     - orderId
4185 
     - itemId
4186 
    """
4187 
    self.send_changeItem(orderId, itemId)
4188 
    return self.recv_changeItem()
4189 
 
4190 
  def send_changeItem(self, orderId, itemId):
4191 
    self._oprot.writeMessageBegin('changeItem', TMessageType.CALL, self._seqid)
4192 
    args = changeItem_args()
4193 
    args.orderId = orderId
4194 
    args.itemId = itemId
4195 
    args.write(self._oprot)
4196 
    self._oprot.writeMessageEnd()
4197 
    self._oprot.trans.flush()
4198 
 
4199 
  def recv_changeItem(self, ):
4200 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4201 
    if mtype == TMessageType.EXCEPTION:
4202 
      x = TApplicationException()
4203 
      x.read(self._iprot)
4204 
      self._iprot.readMessageEnd()
4205 
      raise x
4206 
    result = changeItem_result()
4207 
    result.read(self._iprot)
4208 
    self._iprot.readMessageEnd()
4209 
    if result.success is not None:
4210 
      return result.success
4211 
    if result.ex is not None:
4212 
      raise result.ex
4213 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "changeItem failed: unknown result");
4214 
 
4215 
  def shiftToWarehouse(self, orderId, warehouseId):
4216 
    """
4217 
    Moves the given order to the given warehouse. Also adjusts the inventory reservations accordingly.
4218 
 
4219 
    Parameters:
4220 
     - orderId
4221 
     - warehouseId
4222 
    """
4223 
    self.send_shiftToWarehouse(orderId, warehouseId)
4224 
    return self.recv_shiftToWarehouse()
4225 
 
4226 
  def send_shiftToWarehouse(self, orderId, warehouseId):
4227 
    self._oprot.writeMessageBegin('shiftToWarehouse', TMessageType.CALL, self._seqid)
4228 
    args = shiftToWarehouse_args()
4229 
    args.orderId = orderId
4230 
    args.warehouseId = warehouseId
4231 
    args.write(self._oprot)
4232 
    self._oprot.writeMessageEnd()
4233 
    self._oprot.trans.flush()
4234 
 
4235 
  def recv_shiftToWarehouse(self, ):
4236 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4237 
    if mtype == TMessageType.EXCEPTION:
4238 
      x = TApplicationException()
4239 
      x.read(self._iprot)
4240 
      self._iprot.readMessageEnd()
4241 
      raise x
4242 
    result = shiftToWarehouse_result()
4243 
    result.read(self._iprot)
4244 
    self._iprot.readMessageEnd()
4245 
    if result.success is not None:
4246 
      return result.success
4247 
    if result.ex is not None:
4248 
      raise result.ex
4249 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "shiftToWarehouse failed: unknown result");
4250 
 
4647 rajveer 4251 
  def addDelayReason(self, orderId, delayReason, furtherDelay, delayReasonText):
3553 chandransh 4252 
    """
4253 
    Adds the given delay reason to the given order.
3986 chandransh 4254 
    Increases the expected delivery time of the given order by the given no. of days.
3553 chandransh 4255 
    Raises an exception if no order with the given id can be found.
3469 chandransh 4256 
 
3553 chandransh 4257 
    Parameters:
4258 
     - orderId
4259 
     - delayReason
3986 chandransh 4260 
     - furtherDelay
4647 rajveer 4261 
     - delayReasonText
3553 chandransh 4262 
    """
4647 rajveer 4263 
    self.send_addDelayReason(orderId, delayReason, furtherDelay, delayReasonText)
3553 chandransh 4264 
    return self.recv_addDelayReason()
4265 
 
4647 rajveer 4266 
  def send_addDelayReason(self, orderId, delayReason, furtherDelay, delayReasonText):
3553 chandransh 4267 
    self._oprot.writeMessageBegin('addDelayReason', TMessageType.CALL, self._seqid)
4268 
    args = addDelayReason_args()
4269 
    args.orderId = orderId
4270 
    args.delayReason = delayReason
3986 chandransh 4271 
    args.furtherDelay = furtherDelay
4647 rajveer 4272 
    args.delayReasonText = delayReasonText
3553 chandransh 4273 
    args.write(self._oprot)
4274 
    self._oprot.writeMessageEnd()
4275 
    self._oprot.trans.flush()
4276 
 
4277 
  def recv_addDelayReason(self, ):
4278 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4279 
    if mtype == TMessageType.EXCEPTION:
4280 
      x = TApplicationException()
4281 
      x.read(self._iprot)
4282 
      self._iprot.readMessageEnd()
4283 
      raise x
4284 
    result = addDelayReason_result()
4285 
    result.read(self._iprot)
4286 
    self._iprot.readMessageEnd()
4287 
    if result.success is not None:
4288 
      return result.success
4289 
    if result.ex is not None:
4290 
      raise result.ex
4291 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addDelayReason failed: unknown result");
4292 
 
3956 chandransh 4293 
  def reconcileCodCollection(self, collectedAmountMap, xferBy, xferTxnId, xferDate):
4294 
    """
4295 
    Marks the COD orders with given AWB nos. as having been processed.
4296 
    Updates the captured amount for the corresponding payment.
3553 chandransh 4297 
 
3956 chandransh 4298 
    Returns a map of AWBs which were not processed and the associated reason. An AWB is not processed if:
4299 
    1. There is no order corresponding to an AWB number.
4300 
    2. The captured amount for a payment exceeds the total payment.
4301 
    3. The order corresponding to an AWB no. is in a state prior to DELIVERY_SUCCESS.
4302 
 
4303 
    Parameters:
4304 
     - collectedAmountMap
4305 
     - xferBy
4306 
     - xferTxnId
4307 
     - xferDate
4308 
    """
4309 
    self.send_reconcileCodCollection(collectedAmountMap, xferBy, xferTxnId, xferDate)
4310 
    return self.recv_reconcileCodCollection()
4311 
 
4312 
  def send_reconcileCodCollection(self, collectedAmountMap, xferBy, xferTxnId, xferDate):
4313 
    self._oprot.writeMessageBegin('reconcileCodCollection', TMessageType.CALL, self._seqid)
4314 
    args = reconcileCodCollection_args()
4315 
    args.collectedAmountMap = collectedAmountMap
4316 
    args.xferBy = xferBy
4317 
    args.xferTxnId = xferTxnId
4318 
    args.xferDate = xferDate
4319 
    args.write(self._oprot)
4320 
    self._oprot.writeMessageEnd()
4321 
    self._oprot.trans.flush()
4322 
 
4323 
  def recv_reconcileCodCollection(self, ):
4324 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4325 
    if mtype == TMessageType.EXCEPTION:
4326 
      x = TApplicationException()
4327 
      x.read(self._iprot)
4328 
      self._iprot.readMessageEnd()
4329 
      raise x
4330 
    result = reconcileCodCollection_result()
4331 
    result.read(self._iprot)
4332 
    self._iprot.readMessageEnd()
4333 
    if result.success is not None:
4334 
      return result.success
4335 
    if result.ex is not None:
4336 
      raise result.ex
4337 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "reconcileCodCollection failed: unknown result");
4338 
 
4008 mandeep.dh 4339 
  def getTransactionsRequiringExtraProcessing(self, category):
4340 
    """
4065 mandeep.dh 4341 
    Returns the list of transaction ids that require some extra processing and
4008 mandeep.dh 4342 
    which belong to a particular category. This is currently used by CRM
4065 mandeep.dh 4343 
    application. If no such transaction ids are present, it returns an empty list.
3956 chandransh 4344 
 
4008 mandeep.dh 4345 
    Parameters:
4346 
     - category
4347 
    """
4348 
    self.send_getTransactionsRequiringExtraProcessing(category)
4349 
    return self.recv_getTransactionsRequiringExtraProcessing()
4350 
 
4351 
  def send_getTransactionsRequiringExtraProcessing(self, category):
4352 
    self._oprot.writeMessageBegin('getTransactionsRequiringExtraProcessing', TMessageType.CALL, self._seqid)
4353 
    args = getTransactionsRequiringExtraProcessing_args()
4354 
    args.category = category
4355 
    args.write(self._oprot)
4356 
    self._oprot.writeMessageEnd()
4357 
    self._oprot.trans.flush()
4358 
 
4359 
  def recv_getTransactionsRequiringExtraProcessing(self, ):
4360 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4361 
    if mtype == TMessageType.EXCEPTION:
4362 
      x = TApplicationException()
4363 
      x.read(self._iprot)
4364 
      self._iprot.readMessageEnd()
4365 
      raise x
4366 
    result = getTransactionsRequiringExtraProcessing_result()
4367 
    result.read(self._iprot)
4368 
    self._iprot.readMessageEnd()
4369 
    if result.success is not None:
4370 
      return result.success
4371 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransactionsRequiringExtraProcessing failed: unknown result");
4372 
 
4373 
  def markTransactionAsProcessed(self, transactionId, category):
4374 
    """
4375 
    Marks a particular transaction as processed for a particular cateogory.
4065 mandeep.dh 4376 
    It essentially deletes the transaction id record for a particular
4377 
    processing type category (if present) from DB.
4378 
    This is currently used by CRM application.
4008 mandeep.dh 4379 
 
4380 
    Parameters:
4381 
     - transactionId
4382 
     - category
4383 
    """
4384 
    self.send_markTransactionAsProcessed(transactionId, category)
4385 
    self.recv_markTransactionAsProcessed()
4386 
 
4387 
  def send_markTransactionAsProcessed(self, transactionId, category):
4388 
    self._oprot.writeMessageBegin('markTransactionAsProcessed', TMessageType.CALL, self._seqid)
4389 
    args = markTransactionAsProcessed_args()
4390 
    args.transactionId = transactionId
4391 
    args.category = category
4392 
    args.write(self._oprot)
4393 
    self._oprot.writeMessageEnd()
4394 
    self._oprot.trans.flush()
4395 
 
4396 
  def recv_markTransactionAsProcessed(self, ):
4397 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4398 
    if mtype == TMessageType.EXCEPTION:
4399 
      x = TApplicationException()
4400 
      x.read(self._iprot)
4401 
      self._iprot.readMessageEnd()
4402 
      raise x
4403 
    result = markTransactionAsProcessed_result()
4404 
    result.read(self._iprot)
4405 
    self._iprot.readMessageEnd()
4406 
    return
4407 
 
4018 chandransh 4408 
  def getItemWiseRiskyOrdersCount(self, ):
4409 
    """
4410 
    Returns a map containing the number of risky orders keyed by item id. A risky order
4411 
    is defined as one whose shipping date is about to expire.
4412 
    """
4413 
    self.send_getItemWiseRiskyOrdersCount()
4414 
    return self.recv_getItemWiseRiskyOrdersCount()
4008 mandeep.dh 4415 
 
4018 chandransh 4416 
  def send_getItemWiseRiskyOrdersCount(self, ):
4417 
    self._oprot.writeMessageBegin('getItemWiseRiskyOrdersCount', TMessageType.CALL, self._seqid)
4418 
    args = getItemWiseRiskyOrdersCount_args()
4419 
    args.write(self._oprot)
4420 
    self._oprot.writeMessageEnd()
4421 
    self._oprot.trans.flush()
4422 
 
4423 
  def recv_getItemWiseRiskyOrdersCount(self, ):
4424 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4425 
    if mtype == TMessageType.EXCEPTION:
4426 
      x = TApplicationException()
4427 
      x.read(self._iprot)
4428 
      self._iprot.readMessageEnd()
4429 
      raise x
4430 
    result = getItemWiseRiskyOrdersCount_result()
4431 
    result.read(self._iprot)
4432 
    self._iprot.readMessageEnd()
4433 
    if result.success is not None:
4434 
      return result.success
4435 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItemWiseRiskyOrdersCount failed: unknown result");
4436 
 
4295 varun.gupt 4437 
  def getOrdersForItemIds(self, itemIds):
4438 
    """
4439 
    Returns a list of all orders which have items with given id
4440 
 
4441 
    Parameters:
4442 
     - itemIds
4443 
    """
4444 
    self.send_getOrdersForItemIds(itemIds)
4445 
    return self.recv_getOrdersForItemIds()
4446 
 
4447 
  def send_getOrdersForItemIds(self, itemIds):
4448 
    self._oprot.writeMessageBegin('getOrdersForItemIds', TMessageType.CALL, self._seqid)
4449 
    args = getOrdersForItemIds_args()
4450 
    args.itemIds = itemIds
4451 
    args.write(self._oprot)
4452 
    self._oprot.writeMessageEnd()
4453 
    self._oprot.trans.flush()
4454 
 
4455 
  def recv_getOrdersForItemIds(self, ):
4456 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4457 
    if mtype == TMessageType.EXCEPTION:
4458 
      x = TApplicationException()
4459 
      x.read(self._iprot)
4460 
      self._iprot.readMessageEnd()
4461 
      raise x
4462 
    result = getOrdersForItemIds_result()
4463 
    result.read(self._iprot)
4464 
    self._iprot.readMessageEnd()
4465 
    if result.success is not None:
4466 
      return result.success
4467 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersForItemIds failed: unknown result");
4468 
 
4247 rajveer 4469 
  def markOrderCancellationRequestReceived(self, orderId):
4470 
    """
4471 
    Mark order as cancellation request received. If customer sends request of cancellation of
4472 
    a particular order, this method will be called. It will just change status of the order
4473 
    depending on its current status. It also records the previous status, so that we can move
4474 
    back to that status if cancellation request is denied.
4018 chandransh 4475 
 
4247 rajveer 4476 
    Parameters:
4477 
     - orderId
4478 
    """
4479 
    self.send_markOrderCancellationRequestReceived(orderId)
4480 
    self.recv_markOrderCancellationRequestReceived()
4481 
 
4482 
  def send_markOrderCancellationRequestReceived(self, orderId):
4483 
    self._oprot.writeMessageBegin('markOrderCancellationRequestReceived', TMessageType.CALL, self._seqid)
4484 
    args = markOrderCancellationRequestReceived_args()
4485 
    args.orderId = orderId
4486 
    args.write(self._oprot)
4487 
    self._oprot.writeMessageEnd()
4488 
    self._oprot.trans.flush()
4489 
 
4490 
  def recv_markOrderCancellationRequestReceived(self, ):
4491 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4492 
    if mtype == TMessageType.EXCEPTION:
4493 
      x = TApplicationException()
4494 
      x.read(self._iprot)
4495 
      self._iprot.readMessageEnd()
4496 
      raise x
4497 
    result = markOrderCancellationRequestReceived_result()
4498 
    result.read(self._iprot)
4499 
    self._iprot.readMessageEnd()
4500 
    if result.ex is not None:
4501 
      raise result.ex
4502 
    return
4503 
 
4504 
  def markOrderCancellationRequestConfirmed(self, orderId):
4505 
    """
4506 
    If we decide to to cancel order, CRM will call this method to move the status of order to
4507 
    cancellation request confirmed. After this OM will be able to cancel the order.
4508 
 
4509 
    Parameters:
4510 
     - orderId
4511 
    """
4512 
    self.send_markOrderCancellationRequestConfirmed(orderId)
4513 
    self.recv_markOrderCancellationRequestConfirmed()
4514 
 
4515 
  def send_markOrderCancellationRequestConfirmed(self, orderId):
4516 
    self._oprot.writeMessageBegin('markOrderCancellationRequestConfirmed', TMessageType.CALL, self._seqid)
4517 
    args = markOrderCancellationRequestConfirmed_args()
4518 
    args.orderId = orderId
4519 
    args.write(self._oprot)
4520 
    self._oprot.writeMessageEnd()
4521 
    self._oprot.trans.flush()
4522 
 
4523 
  def recv_markOrderCancellationRequestConfirmed(self, ):
4524 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4525 
    if mtype == TMessageType.EXCEPTION:
4526 
      x = TApplicationException()
4527 
      x.read(self._iprot)
4528 
      self._iprot.readMessageEnd()
4529 
      raise x
4530 
    result = markOrderCancellationRequestConfirmed_result()
4531 
    result.read(self._iprot)
4532 
    self._iprot.readMessageEnd()
4533 
    if result.ex is not None:
4534 
      raise result.ex
4535 
    return
4536 
 
4537 
  def markOrderCancellationRequestDenied(self, orderId):
4538 
    """
4539 
    If we decide to not to cancel order, we will move the order ro previous status.
4540 
 
4541 
    Parameters:
4542 
     - orderId
4543 
    """
4544 
    self.send_markOrderCancellationRequestDenied(orderId)
4545 
    self.recv_markOrderCancellationRequestDenied()
4546 
 
4547 
  def send_markOrderCancellationRequestDenied(self, orderId):
4548 
    self._oprot.writeMessageBegin('markOrderCancellationRequestDenied', TMessageType.CALL, self._seqid)
4549 
    args = markOrderCancellationRequestDenied_args()
4550 
    args.orderId = orderId
4551 
    args.write(self._oprot)
4552 
    self._oprot.writeMessageEnd()
4553 
    self._oprot.trans.flush()
4554 
 
4555 
  def recv_markOrderCancellationRequestDenied(self, ):
4556 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4557 
    if mtype == TMessageType.EXCEPTION:
4558 
      x = TApplicationException()
4559 
      x.read(self._iprot)
4560 
      self._iprot.readMessageEnd()
4561 
      raise x
4562 
    result = markOrderCancellationRequestDenied_result()
4563 
    result.read(self._iprot)
4564 
    self._iprot.readMessageEnd()
4565 
    if result.ex is not None:
4566 
      raise result.ex
4567 
    return
4568 
 
4258 rajveer 4569 
  def markTransactionAsPaymentFlagRemoved(self, transactionId):
4247 rajveer 4570 
    """
4258 rajveer 4571 
    If we and/or payment gateway has decided to accept the payment, this method needs to be called.
4572 
    Changed transaction and all orders status to payment accepted.
4247 rajveer 4573 
 
4574 
    Parameters:
4258 rajveer 4575 
     - transactionId
4247 rajveer 4576 
    """
4258 rajveer 4577 
    self.send_markTransactionAsPaymentFlagRemoved(transactionId)
4578 
    self.recv_markTransactionAsPaymentFlagRemoved()
4247 rajveer 4579 
 
4258 rajveer 4580 
  def send_markTransactionAsPaymentFlagRemoved(self, transactionId):
4581 
    self._oprot.writeMessageBegin('markTransactionAsPaymentFlagRemoved', TMessageType.CALL, self._seqid)
4582 
    args = markTransactionAsPaymentFlagRemoved_args()
4583 
    args.transactionId = transactionId
4247 rajveer 4584 
    args.write(self._oprot)
4585 
    self._oprot.writeMessageEnd()
4586 
    self._oprot.trans.flush()
4587 
 
4258 rajveer 4588 
  def recv_markTransactionAsPaymentFlagRemoved(self, ):
4247 rajveer 4589 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4590 
    if mtype == TMessageType.EXCEPTION:
4591 
      x = TApplicationException()
4592 
      x.read(self._iprot)
4593 
      self._iprot.readMessageEnd()
4594 
      raise x
4258 rajveer 4595 
    result = markTransactionAsPaymentFlagRemoved_result()
4247 rajveer 4596 
    result.read(self._iprot)
4597 
    self._iprot.readMessageEnd()
4598 
    if result.ex is not None:
4599 
      raise result.ex
4600 
    return
4601 
 
4259 anupam.sin 4602 
  def refundTransaction(self, transactionId, refundedBy, reason):
4603 
    """
4604 
    This method is called when a flagged payment is deemed unserviceable and the corresponding orders
4605 
    need to be cancelled
4247 rajveer 4606 
 
4259 anupam.sin 4607 
    Parameters:
4608 
     - transactionId
4609 
     - refundedBy
4610 
     - reason
4611 
    """
4612 
    self.send_refundTransaction(transactionId, refundedBy, reason)
4613 
    self.recv_refundTransaction()
4614 
 
4615 
  def send_refundTransaction(self, transactionId, refundedBy, reason):
4616 
    self._oprot.writeMessageBegin('refundTransaction', TMessageType.CALL, self._seqid)
4617 
    args = refundTransaction_args()
4618 
    args.transactionId = transactionId
4619 
    args.refundedBy = refundedBy
4620 
    args.reason = reason
4621 
    args.write(self._oprot)
4622 
    self._oprot.writeMessageEnd()
4623 
    self._oprot.trans.flush()
4624 
 
4625 
  def recv_refundTransaction(self, ):
4626 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4627 
    if mtype == TMessageType.EXCEPTION:
4628 
      x = TApplicationException()
4629 
      x.read(self._iprot)
4630 
      self._iprot.readMessageEnd()
4631 
      raise x
4632 
    result = refundTransaction_result()
4633 
    result.read(self._iprot)
4634 
    self._iprot.readMessageEnd()
4635 
    if result.ex is not None:
4636 
      raise result.ex
4637 
    return
4638 
 
4324 mandeep.dh 4639 
  def updateShipmentAddress(self, orderId, addressId):
4640 
    """
4641 
    Updates shipment address of an order. Delivery and shipping date estimates
4642 
    etc. are also updated here.
4643 
 
4644 
    Throws TransactionServiceException in case address change is not
4645 
    possible due to certain reasons such as new pincode in address is
4646 
    not serviceable etc.
4647 
 
4648 
    Parameters:
4649 
     - orderId
4650 
     - addressId
4651 
    """
4652 
    self.send_updateShipmentAddress(orderId, addressId)
4653 
    self.recv_updateShipmentAddress()
4654 
 
4655 
  def send_updateShipmentAddress(self, orderId, addressId):
4656 
    self._oprot.writeMessageBegin('updateShipmentAddress', TMessageType.CALL, self._seqid)
4657 
    args = updateShipmentAddress_args()
4658 
    args.orderId = orderId
4659 
    args.addressId = addressId
4660 
    args.write(self._oprot)
4661 
    self._oprot.writeMessageEnd()
4662 
    self._oprot.trans.flush()
4663 
 
4664 
  def recv_updateShipmentAddress(self, ):
4665 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4666 
    if mtype == TMessageType.EXCEPTION:
4667 
      x = TApplicationException()
4668 
      x.read(self._iprot)
4669 
      self._iprot.readMessageEnd()
4670 
      raise x
4671 
    result = updateShipmentAddress_result()
4672 
    result.read(self._iprot)
4673 
    self._iprot.readMessageEnd()
4674 
    if result.ex is not None:
4675 
      raise result.ex
4676 
    return
4677 
 
4285 rajveer 4678 
  def acceptOrdersForItemId(self, itemId, inventory):
4679 
    """
4680 
    Marks the orders as ACCEPTED for the given itemId and inventory. It also updates the accepted timestamp. If the
4681 
    given order is not a COD order, it also captures the payment if the same has not been captured.
4259 anupam.sin 4682 
 
4285 rajveer 4683 
    Parameters:
4684 
     - itemId
4685 
     - inventory
4686 
    """
4687 
    self.send_acceptOrdersForItemId(itemId, inventory)
4688 
    return self.recv_acceptOrdersForItemId()
4689 
 
4690 
  def send_acceptOrdersForItemId(self, itemId, inventory):
4691 
    self._oprot.writeMessageBegin('acceptOrdersForItemId', TMessageType.CALL, self._seqid)
4692 
    args = acceptOrdersForItemId_args()
4693 
    args.itemId = itemId
4694 
    args.inventory = inventory
4695 
    args.write(self._oprot)
4696 
    self._oprot.writeMessageEnd()
4697 
    self._oprot.trans.flush()
4698 
 
4699 
  def recv_acceptOrdersForItemId(self, ):
4700 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4701 
    if mtype == TMessageType.EXCEPTION:
4702 
      x = TApplicationException()
4703 
      x.read(self._iprot)
4704 
      self._iprot.readMessageEnd()
4705 
      raise x
4706 
    result = acceptOrdersForItemId_result()
4707 
    result.read(self._iprot)
4708 
    self._iprot.readMessageEnd()
4709 
    if result.success is not None:
4710 
      return result.success
4711 
    if result.ex is not None:
4712 
      raise result.ex
4713 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "acceptOrdersForItemId failed: unknown result");
4714 
 
4369 rajveer 4715 
  def markOrdersAsPORaised(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 4716 
    """
4717 
    Parameters:
4718 
     - vendorId
4719 
     - itemId
4720 
     - quantity
4721 
     - estimate
4369 rajveer 4722 
     - isReminder
4303 rajveer 4723 
    """
4369 rajveer 4724 
    self.send_markOrdersAsPORaised(vendorId, itemId, quantity, estimate, isReminder)
4303 rajveer 4725 
    self.recv_markOrdersAsPORaised()
4285 rajveer 4726 
 
4369 rajveer 4727 
  def send_markOrdersAsPORaised(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 4728 
    self._oprot.writeMessageBegin('markOrdersAsPORaised', TMessageType.CALL, self._seqid)
4729 
    args = markOrdersAsPORaised_args()
4730 
    args.vendorId = vendorId
4731 
    args.itemId = itemId
4732 
    args.quantity = quantity
4733 
    args.estimate = estimate
4369 rajveer 4734 
    args.isReminder = isReminder
4303 rajveer 4735 
    args.write(self._oprot)
4736 
    self._oprot.writeMessageEnd()
4737 
    self._oprot.trans.flush()
4738 
 
4739 
  def recv_markOrdersAsPORaised(self, ):
4740 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4741 
    if mtype == TMessageType.EXCEPTION:
4742 
      x = TApplicationException()
4743 
      x.read(self._iprot)
4744 
      self._iprot.readMessageEnd()
4745 
      raise x
4746 
    result = markOrdersAsPORaised_result()
4747 
    result.read(self._iprot)
4748 
    self._iprot.readMessageEnd()
4749 
    if result.ex is not None:
4750 
      raise result.ex
4751 
    return
4752 
 
4369 rajveer 4753 
  def markOrdersAsReversalInitiated(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 4754 
    """
4755 
    Parameters:
4756 
     - vendorId
4757 
     - itemId
4758 
     - quantity
4759 
     - estimate
4369 rajveer 4760 
     - isReminder
4303 rajveer 4761 
    """
4369 rajveer 4762 
    self.send_markOrdersAsReversalInitiated(vendorId, itemId, quantity, estimate, isReminder)
4303 rajveer 4763 
    self.recv_markOrdersAsReversalInitiated()
4764 
 
4369 rajveer 4765 
  def send_markOrdersAsReversalInitiated(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 4766 
    self._oprot.writeMessageBegin('markOrdersAsReversalInitiated', TMessageType.CALL, self._seqid)
4767 
    args = markOrdersAsReversalInitiated_args()
4768 
    args.vendorId = vendorId
4769 
    args.itemId = itemId
4770 
    args.quantity = quantity
4771 
    args.estimate = estimate
4369 rajveer 4772 
    args.isReminder = isReminder
4303 rajveer 4773 
    args.write(self._oprot)
4774 
    self._oprot.writeMessageEnd()
4775 
    self._oprot.trans.flush()
4776 
 
4777 
  def recv_markOrdersAsReversalInitiated(self, ):
4778 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4779 
    if mtype == TMessageType.EXCEPTION:
4780 
      x = TApplicationException()
4781 
      x.read(self._iprot)
4782 
      self._iprot.readMessageEnd()
4783 
      raise x
4784 
    result = markOrdersAsReversalInitiated_result()
4785 
    result.read(self._iprot)
4786 
    self._iprot.readMessageEnd()
4787 
    if result.ex is not None:
4788 
      raise result.ex
4789 
    return
4790 
 
4369 rajveer 4791 
  def markOrdersAsNotAvailabke(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 4792 
    """
4793 
    Parameters:
4794 
     - vendorId
4795 
     - itemId
4796 
     - quantity
4797 
     - estimate
4369 rajveer 4798 
     - isReminder
4303 rajveer 4799 
    """
4369 rajveer 4800 
    self.send_markOrdersAsNotAvailabke(vendorId, itemId, quantity, estimate, isReminder)
4303 rajveer 4801 
    self.recv_markOrdersAsNotAvailabke()
4802 
 
4369 rajveer 4803 
  def send_markOrdersAsNotAvailabke(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 4804 
    self._oprot.writeMessageBegin('markOrdersAsNotAvailabke', TMessageType.CALL, self._seqid)
4805 
    args = markOrdersAsNotAvailabke_args()
4806 
    args.vendorId = vendorId
4807 
    args.itemId = itemId
4808 
    args.quantity = quantity
4809 
    args.estimate = estimate
4369 rajveer 4810 
    args.isReminder = isReminder
4303 rajveer 4811 
    args.write(self._oprot)
4812 
    self._oprot.writeMessageEnd()
4813 
    self._oprot.trans.flush()
4814 
 
4815 
  def recv_markOrdersAsNotAvailabke(self, ):
4816 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4817 
    if mtype == TMessageType.EXCEPTION:
4818 
      x = TApplicationException()
4819 
      x.read(self._iprot)
4820 
      self._iprot.readMessageEnd()
4821 
      raise x
4822 
    result = markOrdersAsNotAvailabke_result()
4823 
    result.read(self._iprot)
4824 
    self._iprot.readMessageEnd()
4825 
    if result.ex is not None:
4826 
      raise result.ex
4827 
    return
4828 
 
4369 rajveer 4829 
  def markOrdersAsTimeout(self, vendorId):
4830 
    """
4831 
    Parameters:
4832 
     - vendorId
4833 
    """
4834 
    self.send_markOrdersAsTimeout(vendorId)
4835 
    return self.recv_markOrdersAsTimeout()
4303 rajveer 4836 
 
4369 rajveer 4837 
  def send_markOrdersAsTimeout(self, vendorId):
4838 
    self._oprot.writeMessageBegin('markOrdersAsTimeout', TMessageType.CALL, self._seqid)
4839 
    args = markOrdersAsTimeout_args()
4840 
    args.vendorId = vendorId
4841 
    args.write(self._oprot)
4842 
    self._oprot.writeMessageEnd()
4843 
    self._oprot.trans.flush()
4844 
 
4845 
  def recv_markOrdersAsTimeout(self, ):
4846 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4847 
    if mtype == TMessageType.EXCEPTION:
4848 
      x = TApplicationException()
4849 
      x.read(self._iprot)
4850 
      self._iprot.readMessageEnd()
4851 
      raise x
4852 
    result = markOrdersAsTimeout_result()
4853 
    result.read(self._iprot)
4854 
    self._iprot.readMessageEnd()
4855 
    if result.success is not None:
4856 
      return result.success
4857 
    if result.ex is not None:
4858 
      raise result.ex
4859 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrdersAsTimeout failed: unknown result");
4860 
 
4662 rajveer 4861 
  def markOrderAsLostInTransit(self, orderId):
4862 
    """
4863 
    Mark order as LOST_IN_TRANSIT
4864 
 
4865 
    Parameters:
4866 
     - orderId
4867 
    """
4868 
    self.send_markOrderAsLostInTransit(orderId)
4869 
    return self.recv_markOrderAsLostInTransit()
4870 
 
4871 
  def send_markOrderAsLostInTransit(self, orderId):
4872 
    self._oprot.writeMessageBegin('markOrderAsLostInTransit', TMessageType.CALL, self._seqid)
4873 
    args = markOrderAsLostInTransit_args()
4874 
    args.orderId = orderId
4875 
    args.write(self._oprot)
4876 
    self._oprot.writeMessageEnd()
4877 
    self._oprot.trans.flush()
4878 
 
4879 
  def recv_markOrderAsLostInTransit(self, ):
4880 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4881 
    if mtype == TMessageType.EXCEPTION:
4882 
      x = TApplicationException()
4883 
      x.read(self._iprot)
4884 
      self._iprot.readMessageEnd()
4885 
      raise x
4886 
    result = markOrderAsLostInTransit_result()
4887 
    result.read(self._iprot)
4888 
    self._iprot.readMessageEnd()
4889 
    if result.success is not None:
4890 
      return result.success
4891 
    if result.ex is not None:
4892 
      raise result.ex
4893 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderAsLostInTransit failed: unknown result");
4894 
 
4386 anupam.sin 4895 
  def getOrderForAwb(self, awb):
4896 
    """
4897 
    Returns the order corresponding to an AWB number
4369 rajveer 4898 
 
4386 anupam.sin 4899 
    Parameters:
4900 
     - awb
4901 
    """
4902 
    self.send_getOrderForAwb(awb)
4903 
    return self.recv_getOrderForAwb()
4904 
 
4905 
  def send_getOrderForAwb(self, awb):
4906 
    self._oprot.writeMessageBegin('getOrderForAwb', TMessageType.CALL, self._seqid)
4907 
    args = getOrderForAwb_args()
4908 
    args.awb = awb
4909 
    args.write(self._oprot)
4910 
    self._oprot.writeMessageEnd()
4911 
    self._oprot.trans.flush()
4912 
 
4913 
  def recv_getOrderForAwb(self, ):
4914 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4915 
    if mtype == TMessageType.EXCEPTION:
4916 
      x = TApplicationException()
4917 
      x.read(self._iprot)
4918 
      self._iprot.readMessageEnd()
4919 
      raise x
4920 
    result = getOrderForAwb_result()
4921 
    result.read(self._iprot)
4922 
    self._iprot.readMessageEnd()
4923 
    if result.success is not None:
4924 
      return result.success
4925 
    if result.ex is not None:
4926 
      raise result.ex
4927 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderForAwb failed: unknown result");
4928 
 
4910 phani.kuma 4929 
  def getOrdersForProviderForStatus(self, logistics_provider_id, order_status_list):
4506 phani.kuma 4930 
    """
4910 phani.kuma 4931 
    Returns the order corresponding to a logistics provider id for a given list of order status
4386 anupam.sin 4932 
 
4506 phani.kuma 4933 
    Parameters:
4934 
     - logistics_provider_id
4910 phani.kuma 4935 
     - order_status_list
4506 phani.kuma 4936 
    """
4910 phani.kuma 4937 
    self.send_getOrdersForProviderForStatus(logistics_provider_id, order_status_list)
4506 phani.kuma 4938 
    return self.recv_getOrdersForProviderForStatus()
4939 
 
4910 phani.kuma 4940 
  def send_getOrdersForProviderForStatus(self, logistics_provider_id, order_status_list):
4506 phani.kuma 4941 
    self._oprot.writeMessageBegin('getOrdersForProviderForStatus', TMessageType.CALL, self._seqid)
4942 
    args = getOrdersForProviderForStatus_args()
4943 
    args.logistics_provider_id = logistics_provider_id
4910 phani.kuma 4944 
    args.order_status_list = order_status_list
4506 phani.kuma 4945 
    args.write(self._oprot)
4946 
    self._oprot.writeMessageEnd()
4947 
    self._oprot.trans.flush()
4948 
 
4949 
  def recv_getOrdersForProviderForStatus(self, ):
4950 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4951 
    if mtype == TMessageType.EXCEPTION:
4952 
      x = TApplicationException()
4953 
      x.read(self._iprot)
4954 
      self._iprot.readMessageEnd()
4955 
      raise x
4956 
    result = getOrdersForProviderForStatus_result()
4957 
    result.read(self._iprot)
4958 
    self._iprot.readMessageEnd()
4959 
    if result.success is not None:
4960 
      return result.success
4961 
    if result.ex is not None:
4962 
      raise result.ex
4963 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersForProviderForStatus failed: unknown result");
4964 
 
4600 varun.gupt 4965 
  def getBilledOrdersForVendor(self, vendorId, billingDateFrom, billingDateTo):
4966 
    """
4967 
    Returns list of orders fullfiled from a certain vendor and billed in a given date range
4506 phani.kuma 4968 
 
4600 varun.gupt 4969 
    Parameters:
4970 
     - vendorId
4971 
     - billingDateFrom
4972 
     - billingDateTo
4973 
    """
4974 
    self.send_getBilledOrdersForVendor(vendorId, billingDateFrom, billingDateTo)
4975 
    return self.recv_getBilledOrdersForVendor()
4976 
 
4977 
  def send_getBilledOrdersForVendor(self, vendorId, billingDateFrom, billingDateTo):
4978 
    self._oprot.writeMessageBegin('getBilledOrdersForVendor', TMessageType.CALL, self._seqid)
4979 
    args = getBilledOrdersForVendor_args()
4980 
    args.vendorId = vendorId
4981 
    args.billingDateFrom = billingDateFrom
4982 
    args.billingDateTo = billingDateTo
4983 
    args.write(self._oprot)
4984 
    self._oprot.writeMessageEnd()
4985 
    self._oprot.trans.flush()
4986 
 
4987 
  def recv_getBilledOrdersForVendor(self, ):
4988 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4989 
    if mtype == TMessageType.EXCEPTION:
4990 
      x = TApplicationException()
4991 
      x.read(self._iprot)
4992 
      self._iprot.readMessageEnd()
4993 
      raise x
4994 
    result = getBilledOrdersForVendor_result()
4995 
    result.read(self._iprot)
4996 
    self._iprot.readMessageEnd()
4997 
    if result.success is not None:
4998 
      return result.success
4999 
    if result.ex is not None:
5000 
      raise result.ex
5001 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBilledOrdersForVendor failed: unknown result");
5002 
 
4607 rajveer 5003 
  def getSlippedSippingDateOrders(self, ):
5004 
    self.send_getSlippedSippingDateOrders()
5005 
    return self.recv_getSlippedSippingDateOrders()
5006 
 
5007 
  def send_getSlippedSippingDateOrders(self, ):
5008 
    self._oprot.writeMessageBegin('getSlippedSippingDateOrders', TMessageType.CALL, self._seqid)
5009 
    args = getSlippedSippingDateOrders_args()
5010 
    args.write(self._oprot)
5011 
    self._oprot.writeMessageEnd()
5012 
    self._oprot.trans.flush()
5013 
 
5014 
  def recv_getSlippedSippingDateOrders(self, ):
5015 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5016 
    if mtype == TMessageType.EXCEPTION:
5017 
      x = TApplicationException()
5018 
      x.read(self._iprot)
5019 
      self._iprot.readMessageEnd()
5020 
      raise x
5021 
    result = getSlippedSippingDateOrders_result()
5022 
    result.read(self._iprot)
5023 
    self._iprot.readMessageEnd()
5024 
    if result.success is not None:
5025 
      return result.success
5026 
    if result.ex is not None:
5027 
      raise result.ex
5028 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getSlippedSippingDateOrders failed: unknown result");
5029 
 
4709 rajveer 5030 
  def getCancelledOrders(self, cancelDateFrom, cancelDateTo):
5031 
    """
5032 
    Parameters:
5033 
     - cancelDateFrom
5034 
     - cancelDateTo
5035 
    """
5036 
    self.send_getCancelledOrders(cancelDateFrom, cancelDateTo)
5037 
    return self.recv_getCancelledOrders()
5038 
 
5039 
  def send_getCancelledOrders(self, cancelDateFrom, cancelDateTo):
5040 
    self._oprot.writeMessageBegin('getCancelledOrders', TMessageType.CALL, self._seqid)
5041 
    args = getCancelledOrders_args()
5042 
    args.cancelDateFrom = cancelDateFrom
5043 
    args.cancelDateTo = cancelDateTo
5044 
    args.write(self._oprot)
5045 
    self._oprot.writeMessageEnd()
5046 
    self._oprot.trans.flush()
5047 
 
5048 
  def recv_getCancelledOrders(self, ):
5049 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5050 
    if mtype == TMessageType.EXCEPTION:
5051 
      x = TApplicationException()
5052 
      x.read(self._iprot)
5053 
      self._iprot.readMessageEnd()
5054 
      raise x
5055 
    result = getCancelledOrders_result()
5056 
    result.read(self._iprot)
5057 
    self._iprot.readMessageEnd()
5058 
    if result.success is not None:
5059 
      return result.success
5060 
    if result.ex is not None:
5061 
      raise result.ex
5062 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCancelledOrders failed: unknown result");
5063 
 
4600 varun.gupt 5064 
  def saveBluedartSettlements(self, mapAWBAndAmount):
5065 
    """
5066 
    Parameters:
5067 
     - mapAWBAndAmount
5068 
    """
5069 
    self.send_saveBluedartSettlements(mapAWBAndAmount)
5070 
    self.recv_saveBluedartSettlements()
5071 
 
5072 
  def send_saveBluedartSettlements(self, mapAWBAndAmount):
5073 
    self._oprot.writeMessageBegin('saveBluedartSettlements', TMessageType.CALL, self._seqid)
5074 
    args = saveBluedartSettlements_args()
5075 
    args.mapAWBAndAmount = mapAWBAndAmount
5076 
    args.write(self._oprot)
5077 
    self._oprot.writeMessageEnd()
5078 
    self._oprot.trans.flush()
5079 
 
5080 
  def recv_saveBluedartSettlements(self, ):
5081 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5082 
    if mtype == TMessageType.EXCEPTION:
5083 
      x = TApplicationException()
5084 
      x.read(self._iprot)
5085 
      self._iprot.readMessageEnd()
5086 
      raise x
5087 
    result = saveBluedartSettlements_result()
5088 
    result.read(self._iprot)
5089 
    self._iprot.readMessageEnd()
5090 
    if result.ex is not None:
5091 
      raise result.ex
5092 
    return
5093 
 
4905 varun.gupt 5094 
  def savePaymentSettlements(self, settlementDate, paymentGatewayId, referenceId, serviceTax, otherCharges, netCollection):
4600 varun.gupt 5095 
    """
5096 
    Parameters:
5097 
     - settlementDate
5098 
     - paymentGatewayId
4905 varun.gupt 5099 
     - referenceId
4600 varun.gupt 5100 
     - serviceTax
5101 
     - otherCharges
5102 
     - netCollection
5103 
    """
4905 varun.gupt 5104 
    self.send_savePaymentSettlements(settlementDate, paymentGatewayId, referenceId, serviceTax, otherCharges, netCollection)
4600 varun.gupt 5105 
    self.recv_savePaymentSettlements()
5106 
 
4905 varun.gupt 5107 
  def send_savePaymentSettlements(self, settlementDate, paymentGatewayId, referenceId, serviceTax, otherCharges, netCollection):
4600 varun.gupt 5108 
    self._oprot.writeMessageBegin('savePaymentSettlements', TMessageType.CALL, self._seqid)
5109 
    args = savePaymentSettlements_args()
5110 
    args.settlementDate = settlementDate
5111 
    args.paymentGatewayId = paymentGatewayId
4905 varun.gupt 5112 
    args.referenceId = referenceId
4600 varun.gupt 5113 
    args.serviceTax = serviceTax
5114 
    args.otherCharges = otherCharges
5115 
    args.netCollection = netCollection
5116 
    args.write(self._oprot)
5117 
    self._oprot.writeMessageEnd()
5118 
    self._oprot.trans.flush()
5119 
 
5120 
  def recv_savePaymentSettlements(self, ):
5121 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5122 
    if mtype == TMessageType.EXCEPTION:
5123 
      x = TApplicationException()
5124 
      x.read(self._iprot)
5125 
      self._iprot.readMessageEnd()
5126 
      raise x
5127 
    result = savePaymentSettlements_result()
5128 
    result.read(self._iprot)
5129 
    self._iprot.readMessageEnd()
5130 
    if result.ex is not None:
5131 
      raise result.ex
5132 
    return
5133 
 
5134 
  def saveEBSSettlementSummary(self, settlementId, settlementDate, transactionDateFrom, transactionDateTo, amount):
5135 
    """
5136 
    Parameters:
5137 
     - settlementId
5138 
     - settlementDate
5139 
     - transactionDateFrom
5140 
     - transactionDateTo
5141 
     - amount
5142 
    """
5143 
    self.send_saveEBSSettlementSummary(settlementId, settlementDate, transactionDateFrom, transactionDateTo, amount)
5144 
    self.recv_saveEBSSettlementSummary()
5145 
 
5146 
  def send_saveEBSSettlementSummary(self, settlementId, settlementDate, transactionDateFrom, transactionDateTo, amount):
5147 
    self._oprot.writeMessageBegin('saveEBSSettlementSummary', TMessageType.CALL, self._seqid)
5148 
    args = saveEBSSettlementSummary_args()
5149 
    args.settlementId = settlementId
5150 
    args.settlementDate = settlementDate
5151 
    args.transactionDateFrom = transactionDateFrom
5152 
    args.transactionDateTo = transactionDateTo
5153 
    args.amount = amount
5154 
    args.write(self._oprot)
5155 
    self._oprot.writeMessageEnd()
5156 
    self._oprot.trans.flush()
5157 
 
5158 
  def recv_saveEBSSettlementSummary(self, ):
5159 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5160 
    if mtype == TMessageType.EXCEPTION:
5161 
      x = TApplicationException()
5162 
      x.read(self._iprot)
5163 
      self._iprot.readMessageEnd()
5164 
      raise x
5165 
    result = saveEBSSettlementSummary_result()
5166 
    result.read(self._iprot)
5167 
    self._iprot.readMessageEnd()
5168 
    if result.ex is not None:
5169 
      raise result.ex
5170 
    return
5171 
 
5386 phani.kuma 5172 
  def getSettlementForPrepaid(self, referenceId, isRefund):
4600 varun.gupt 5173 
    """
5174 
    Parameters:
5189 varun.gupt 5175 
     - referenceId
5176 
     - isRefund
4600 varun.gupt 5177 
    """
5386 phani.kuma 5178 
    self.send_getSettlementForPrepaid(referenceId, isRefund)
5179 
    return self.recv_getSettlementForPrepaid()
4600 varun.gupt 5180 
 
5386 phani.kuma 5181 
  def send_getSettlementForPrepaid(self, referenceId, isRefund):
5182 
    self._oprot.writeMessageBegin('getSettlementForPrepaid', TMessageType.CALL, self._seqid)
5183 
    args = getSettlementForPrepaid_args()
5189 varun.gupt 5184 
    args.referenceId = referenceId
5185 
    args.isRefund = isRefund
4600 varun.gupt 5186 
    args.write(self._oprot)
5187 
    self._oprot.writeMessageEnd()
5188 
    self._oprot.trans.flush()
5189 
 
5386 phani.kuma 5190 
  def recv_getSettlementForPrepaid(self, ):
4600 varun.gupt 5191 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5192 
    if mtype == TMessageType.EXCEPTION:
5193 
      x = TApplicationException()
5194 
      x.read(self._iprot)
5195 
      self._iprot.readMessageEnd()
5196 
      raise x
5386 phani.kuma 5197 
    result = getSettlementForPrepaid_result()
4600 varun.gupt 5198 
    result.read(self._iprot)
5199 
    self._iprot.readMessageEnd()
5200 
    if result.success is not None:
5201 
      return result.success
5202 
    if result.ex is not None:
5203 
      raise result.ex
5386 phani.kuma 5204 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getSettlementForPrepaid failed: unknown result");
4600 varun.gupt 5205 
 
5386 phani.kuma 5206 
  def getSettlementForCod(self, orderId, isRefund):
5207 
    """
5208 
    Parameters:
5209 
     - orderId
5210 
     - isRefund
5211 
    """
5212 
    self.send_getSettlementForCod(orderId, isRefund)
5213 
    return self.recv_getSettlementForCod()
5214 
 
5215 
  def send_getSettlementForCod(self, orderId, isRefund):
5216 
    self._oprot.writeMessageBegin('getSettlementForCod', TMessageType.CALL, self._seqid)
5217 
    args = getSettlementForCod_args()
5218 
    args.orderId = orderId
5219 
    args.isRefund = isRefund
5220 
    args.write(self._oprot)
5221 
    self._oprot.writeMessageEnd()
5222 
    self._oprot.trans.flush()
5223 
 
5224 
  def recv_getSettlementForCod(self, ):
5225 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5226 
    if mtype == TMessageType.EXCEPTION:
5227 
      x = TApplicationException()
5228 
      x.read(self._iprot)
5229 
      self._iprot.readMessageEnd()
5230 
      raise x
5231 
    result = getSettlementForCod_result()
5232 
    result.read(self._iprot)
5233 
    self._iprot.readMessageEnd()
5234 
    if result.success is not None:
5235 
      return result.success
5236 
    if result.ex is not None:
5237 
      raise result.ex
5238 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getSettlementForCod failed: unknown result");
5239 
 
4600 varun.gupt 5240 
  def getEBSSettlementSummaries(self, ):
5241 
    self.send_getEBSSettlementSummaries()
5242 
    return self.recv_getEBSSettlementSummaries()
5243 
 
5244 
  def send_getEBSSettlementSummaries(self, ):
5245 
    self._oprot.writeMessageBegin('getEBSSettlementSummaries', TMessageType.CALL, self._seqid)
5246 
    args = getEBSSettlementSummaries_args()
5247 
    args.write(self._oprot)
5248 
    self._oprot.writeMessageEnd()
5249 
    self._oprot.trans.flush()
5250 
 
5251 
  def recv_getEBSSettlementSummaries(self, ):
5252 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5253 
    if mtype == TMessageType.EXCEPTION:
5254 
      x = TApplicationException()
5255 
      x.read(self._iprot)
5256 
      self._iprot.readMessageEnd()
5257 
      raise x
5258 
    result = getEBSSettlementSummaries_result()
5259 
    result.read(self._iprot)
5260 
    self._iprot.readMessageEnd()
5261 
    if result.success is not None:
5262 
      return result.success
5263 
    if result.ex is not None:
5264 
      raise result.ex
5265 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getEBSSettlementSummaries failed: unknown result");
5266 
 
5267 
  def markEBSSettlementUploaded(self, settlementId):
5268 
    """
5269 
    Parameters:
5270 
     - settlementId
5271 
    """
5272 
    self.send_markEBSSettlementUploaded(settlementId)
5273 
    self.recv_markEBSSettlementUploaded()
5274 
 
5275 
  def send_markEBSSettlementUploaded(self, settlementId):
5276 
    self._oprot.writeMessageBegin('markEBSSettlementUploaded', TMessageType.CALL, self._seqid)
5277 
    args = markEBSSettlementUploaded_args()
5278 
    args.settlementId = settlementId
5279 
    args.write(self._oprot)
5280 
    self._oprot.writeMessageEnd()
5281 
    self._oprot.trans.flush()
5282 
 
5283 
  def recv_markEBSSettlementUploaded(self, ):
5284 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5285 
    if mtype == TMessageType.EXCEPTION:
5286 
      x = TApplicationException()
5287 
      x.read(self._iprot)
5288 
      self._iprot.readMessageEnd()
5289 
      raise x
5290 
    result = markEBSSettlementUploaded_result()
5291 
    result.read(self._iprot)
5292 
    self._iprot.readMessageEnd()
5293 
    if result.ex is not None:
5294 
      raise result.ex
5295 
    return
5296 
 
5297 
  def getEBSSettlementDate(self, settlementId):
5298 
    """
5299 
    Parameters:
5300 
     - settlementId
5301 
    """
5302 
    self.send_getEBSSettlementDate(settlementId)
5303 
    return self.recv_getEBSSettlementDate()
5304 
 
5305 
  def send_getEBSSettlementDate(self, settlementId):
5306 
    self._oprot.writeMessageBegin('getEBSSettlementDate', TMessageType.CALL, self._seqid)
5307 
    args = getEBSSettlementDate_args()
5308 
    args.settlementId = settlementId
5309 
    args.write(self._oprot)
5310 
    self._oprot.writeMessageEnd()
5311 
    self._oprot.trans.flush()
5312 
 
5313 
  def recv_getEBSSettlementDate(self, ):
5314 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5315 
    if mtype == TMessageType.EXCEPTION:
5316 
      x = TApplicationException()
5317 
      x.read(self._iprot)
5318 
      self._iprot.readMessageEnd()
5319 
      raise x
5320 
    result = getEBSSettlementDate_result()
5321 
    result.read(self._iprot)
5322 
    self._iprot.readMessageEnd()
5323 
    if result.success is not None:
5324 
      return result.success
5325 
    if result.ex is not None:
5326 
      raise result.ex
5327 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getEBSSettlementDate failed: unknown result");
5328 
 
4715 varun.gupt 5329 
  def getSettlementsByDate(self, settlementDateFrom, settlementDateTo, isRefund):
5330 
    """
5331 
    Parameters:
5332 
     - settlementDateFrom
5333 
     - settlementDateTo
5334 
     - isRefund
5335 
    """
5336 
    self.send_getSettlementsByDate(settlementDateFrom, settlementDateTo, isRefund)
5337 
    return self.recv_getSettlementsByDate()
4600 varun.gupt 5338 
 
4715 varun.gupt 5339 
  def send_getSettlementsByDate(self, settlementDateFrom, settlementDateTo, isRefund):
5340 
    self._oprot.writeMessageBegin('getSettlementsByDate', TMessageType.CALL, self._seqid)
5341 
    args = getSettlementsByDate_args()
5342 
    args.settlementDateFrom = settlementDateFrom
5343 
    args.settlementDateTo = settlementDateTo
5344 
    args.isRefund = isRefund
5345 
    args.write(self._oprot)
5346 
    self._oprot.writeMessageEnd()
5347 
    self._oprot.trans.flush()
5348 
 
5349 
  def recv_getSettlementsByDate(self, ):
5350 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5351 
    if mtype == TMessageType.EXCEPTION:
5352 
      x = TApplicationException()
5353 
      x.read(self._iprot)
5354 
      self._iprot.readMessageEnd()
5355 
      raise x
5356 
    result = getSettlementsByDate_result()
5357 
    result.read(self._iprot)
5358 
    self._iprot.readMessageEnd()
5359 
    if result.success is not None:
5360 
      return result.success
5361 
    if result.ex is not None:
5362 
      raise result.ex
5363 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getSettlementsByDate failed: unknown result");
5364 
 
5365 
  def getReshippedOrderIds(self, orderIds):
5366 
    """
5367 
    Returns list of Order Ids, which belong to reshiped orders, shortlisted from a given list of Order Ids
5368 
 
5369 
    Parameters:
5370 
     - orderIds
5371 
    """
5372 
    self.send_getReshippedOrderIds(orderIds)
5373 
    return self.recv_getReshippedOrderIds()
5374 
 
5375 
  def send_getReshippedOrderIds(self, orderIds):
5376 
    self._oprot.writeMessageBegin('getReshippedOrderIds', TMessageType.CALL, self._seqid)
5377 
    args = getReshippedOrderIds_args()
5378 
    args.orderIds = orderIds
5379 
    args.write(self._oprot)
5380 
    self._oprot.writeMessageEnd()
5381 
    self._oprot.trans.flush()
5382 
 
5383 
  def recv_getReshippedOrderIds(self, ):
5384 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5385 
    if mtype == TMessageType.EXCEPTION:
5386 
      x = TApplicationException()
5387 
      x.read(self._iprot)
5388 
      self._iprot.readMessageEnd()
5389 
      raise x
5390 
    result = getReshippedOrderIds_result()
5391 
    result.read(self._iprot)
5392 
    self._iprot.readMessageEnd()
5393 
    if result.success is not None:
5394 
      return result.success
5395 
    if result.ex is not None:
5396 
      raise result.ex
5397 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReshippedOrderIds failed: unknown result");
5398 
 
5481 phani.kuma 5399 
  def getBilledOrders(self, vendorId, onlyVendorNotPaid, billingDateFrom, billingDateTo):
4875 varun.gupt 5400 
    """
5401 
    Parameters:
5402 
     - vendorId
5481 phani.kuma 5403 
     - onlyVendorNotPaid
5404 
     - billingDateFrom
5405 
     - billingDateTo
4875 varun.gupt 5406 
    """
5481 phani.kuma 5407 
    self.send_getBilledOrders(vendorId, onlyVendorNotPaid, billingDateFrom, billingDateTo)
5408 
    return self.recv_getBilledOrders()
4757 mandeep.dh 5409 
 
5481 phani.kuma 5410 
  def send_getBilledOrders(self, vendorId, onlyVendorNotPaid, billingDateFrom, billingDateTo):
5411 
    self._oprot.writeMessageBegin('getBilledOrders', TMessageType.CALL, self._seqid)
5412 
    args = getBilledOrders_args()
4875 varun.gupt 5413 
    args.vendorId = vendorId
5481 phani.kuma 5414 
    args.onlyVendorNotPaid = onlyVendorNotPaid
5415 
    args.billingDateFrom = billingDateFrom
5416 
    args.billingDateTo = billingDateTo
4875 varun.gupt 5417 
    args.write(self._oprot)
5418 
    self._oprot.writeMessageEnd()
5419 
    self._oprot.trans.flush()
5420 
 
5481 phani.kuma 5421 
  def recv_getBilledOrders(self, ):
4875 varun.gupt 5422 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5423 
    if mtype == TMessageType.EXCEPTION:
5424 
      x = TApplicationException()
5425 
      x.read(self._iprot)
5426 
      self._iprot.readMessageEnd()
5427 
      raise x
5481 phani.kuma 5428 
    result = getBilledOrders_result()
4875 varun.gupt 5429 
    result.read(self._iprot)
5430 
    self._iprot.readMessageEnd()
5431 
    if result.success is not None:
5432 
      return result.success
5433 
    if result.ex is not None:
5434 
      raise result.ex
5481 phani.kuma 5435 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBilledOrders failed: unknown result");
4875 varun.gupt 5436 
 
5031 varun.gupt 5437 
  def getStatusDistributionOfOrders(self, startDate, endDate):
5438 
    """
5439 
    Parameters:
5440 
     - startDate
5441 
     - endDate
5442 
    """
5443 
    self.send_getStatusDistributionOfOrders(startDate, endDate)
5444 
    return self.recv_getStatusDistributionOfOrders()
4875 varun.gupt 5445 
 
5031 varun.gupt 5446 
  def send_getStatusDistributionOfOrders(self, startDate, endDate):
5447 
    self._oprot.writeMessageBegin('getStatusDistributionOfOrders', TMessageType.CALL, self._seqid)
5448 
    args = getStatusDistributionOfOrders_args()
5449 
    args.startDate = startDate
5450 
    args.endDate = endDate
5451 
    args.write(self._oprot)
5452 
    self._oprot.writeMessageEnd()
5453 
    self._oprot.trans.flush()
5454 
 
5455 
  def recv_getStatusDistributionOfOrders(self, ):
5456 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5457 
    if mtype == TMessageType.EXCEPTION:
5458 
      x = TApplicationException()
5459 
      x.read(self._iprot)
5460 
      self._iprot.readMessageEnd()
5461 
      raise x
5462 
    result = getStatusDistributionOfOrders_result()
5463 
    result.read(self._iprot)
5464 
    self._iprot.readMessageEnd()
5465 
    if result.success is not None:
5466 
      return result.success
5467 
    if result.ex is not None:
5468 
      raise result.ex
5469 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getStatusDistributionOfOrders failed: unknown result");
5470 
 
5067 varun.gupt 5471 
  def getOrderIdsForStatus(self, status, startDatetime, endDatetime):
5472 
    """
5473 
    Parameters:
5474 
     - status
5475 
     - startDatetime
5476 
     - endDatetime
5477 
    """
5478 
    self.send_getOrderIdsForStatus(status, startDatetime, endDatetime)
5479 
    return self.recv_getOrderIdsForStatus()
5031 varun.gupt 5480 
 
5067 varun.gupt 5481 
  def send_getOrderIdsForStatus(self, status, startDatetime, endDatetime):
5482 
    self._oprot.writeMessageBegin('getOrderIdsForStatus', TMessageType.CALL, self._seqid)
5483 
    args = getOrderIdsForStatus_args()
5484 
    args.status = status
5485 
    args.startDatetime = startDatetime
5486 
    args.endDatetime = endDatetime
5487 
    args.write(self._oprot)
5488 
    self._oprot.writeMessageEnd()
5489 
    self._oprot.trans.flush()
5490 
 
5491 
  def recv_getOrderIdsForStatus(self, ):
5492 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5493 
    if mtype == TMessageType.EXCEPTION:
5494 
      x = TApplicationException()
5495 
      x.read(self._iprot)
5496 
      self._iprot.readMessageEnd()
5497 
      raise x
5498 
    result = getOrderIdsForStatus_result()
5499 
    result.read(self._iprot)
5500 
    self._iprot.readMessageEnd()
5501 
    if result.success is not None:
5502 
      return result.success
5503 
    if result.ex is not None:
5504 
      raise result.ex
5505 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderIdsForStatus failed: unknown result");
5506 
 
5348 anupam.sin 5507 
  def updateCODAgent(self, agent, orderId):
5508 
    """
5509 
    Updates the agent who handled the COD verification call
5510 
 
5511 
    Parameters:
5512 
     - agent
5513 
     - orderId
5514 
    """
5515 
    self.send_updateCODAgent(agent, orderId)
5516 
    self.recv_updateCODAgent()
5517 
 
5518 
  def send_updateCODAgent(self, agent, orderId):
5519 
    self._oprot.writeMessageBegin('updateCODAgent', TMessageType.CALL, self._seqid)
5520 
    args = updateCODAgent_args()
5521 
    args.agent = agent
5522 
    args.orderId = orderId
5523 
    args.write(self._oprot)
5524 
    self._oprot.writeMessageEnd()
5525 
    self._oprot.trans.flush()
5526 
 
5527 
  def recv_updateCODAgent(self, ):
5528 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5529 
    if mtype == TMessageType.EXCEPTION:
5530 
      x = TApplicationException()
5531 
      x.read(self._iprot)
5532 
      self._iprot.readMessageEnd()
5533 
      raise x
5534 
    result = updateCODAgent_result()
5535 
    result.read(self._iprot)
5536 
    self._iprot.readMessageEnd()
5537 
    if result.ex is not None:
5538 
      raise result.ex
5539 
    return
5540 
 
5099 varun.gupt 5541 
  def updateOrderAsPaidToVendor(self, orderId):
5542 
    """
5543 
    Parameters:
5544 
     - orderId
5545 
    """
5546 
    self.send_updateOrderAsPaidToVendor(orderId)
5547 
    self.recv_updateOrderAsPaidToVendor()
5067 varun.gupt 5548 
 
5099 varun.gupt 5549 
  def send_updateOrderAsPaidToVendor(self, orderId):
5550 
    self._oprot.writeMessageBegin('updateOrderAsPaidToVendor', TMessageType.CALL, self._seqid)
5551 
    args = updateOrderAsPaidToVendor_args()
5552 
    args.orderId = orderId
5553 
    args.write(self._oprot)
5554 
    self._oprot.writeMessageEnd()
5555 
    self._oprot.trans.flush()
5556 
 
5557 
  def recv_updateOrderAsPaidToVendor(self, ):
5558 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5559 
    if mtype == TMessageType.EXCEPTION:
5560 
      x = TApplicationException()
5561 
      x.read(self._iprot)
5562 
      self._iprot.readMessageEnd()
5563 
      raise x
5564 
    result = updateOrderAsPaidToVendor_result()
5565 
    result.read(self._iprot)
5566 
    self._iprot.readMessageEnd()
5567 
    if result.ex is not None:
5568 
      raise result.ex
5569 
    return
5570 
 
5386 phani.kuma 5571 
  def updateOrderOnlyAsPaidToVendor(self, orderId):
5572 
    """
5573 
    Parameters:
5574 
     - orderId
5575 
    """
5576 
    self.send_updateOrderOnlyAsPaidToVendor(orderId)
5577 
    self.recv_updateOrderOnlyAsPaidToVendor()
5578 
 
5579 
  def send_updateOrderOnlyAsPaidToVendor(self, orderId):
5580 
    self._oprot.writeMessageBegin('updateOrderOnlyAsPaidToVendor', TMessageType.CALL, self._seqid)
5581 
    args = updateOrderOnlyAsPaidToVendor_args()
5582 
    args.orderId = orderId
5583 
    args.write(self._oprot)
5584 
    self._oprot.writeMessageEnd()
5585 
    self._oprot.trans.flush()
5586 
 
5587 
  def recv_updateOrderOnlyAsPaidToVendor(self, ):
5588 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5589 
    if mtype == TMessageType.EXCEPTION:
5590 
      x = TApplicationException()
5591 
      x.read(self._iprot)
5592 
      self._iprot.readMessageEnd()
5593 
      raise x
5594 
    result = updateOrderOnlyAsPaidToVendor_result()
5595 
    result.read(self._iprot)
5596 
    self._iprot.readMessageEnd()
5597 
    if result.ex is not None:
5598 
      raise result.ex
5599 
    return
5600 
 
5208 varun.gupt 5601 
  def getRefundedOrdersMarkedPaid(self, ):
5602 
    self.send_getRefundedOrdersMarkedPaid()
5603 
    return self.recv_getRefundedOrdersMarkedPaid()
5099 varun.gupt 5604 
 
5208 varun.gupt 5605 
  def send_getRefundedOrdersMarkedPaid(self, ):
5606 
    self._oprot.writeMessageBegin('getRefundedOrdersMarkedPaid', TMessageType.CALL, self._seqid)
5607 
    args = getRefundedOrdersMarkedPaid_args()
5608 
    args.write(self._oprot)
5609 
    self._oprot.writeMessageEnd()
5610 
    self._oprot.trans.flush()
5611 
 
5612 
  def recv_getRefundedOrdersMarkedPaid(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 = getRefundedOrdersMarkedPaid_result()
5620 
    result.read(self._iprot)
5621 
    self._iprot.readMessageEnd()
5622 
    if result.success is not None:
5623 
      return result.success
5624 
    if result.ex is not None:
5625 
      raise result.ex
5626 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getRefundedOrdersMarkedPaid failed: unknown result");
5627 
 
5447 anupam.sin 5628 
  def getAllVerificationAgents(self, minOrderId, maxOrderId):
5629 
    """
5630 
    gets all COD Verification Agents for all orderIds from a minId to maxId
5208 varun.gupt 5631 
 
5447 anupam.sin 5632 
 
5633 
    Parameters:
5634 
     - minOrderId
5635 
     - maxOrderId
5636 
    """
5637 
    self.send_getAllVerificationAgents(minOrderId, maxOrderId)
5638 
    return self.recv_getAllVerificationAgents()
5639 
 
5640 
  def send_getAllVerificationAgents(self, minOrderId, maxOrderId):
5641 
    self._oprot.writeMessageBegin('getAllVerificationAgents', TMessageType.CALL, self._seqid)
5642 
    args = getAllVerificationAgents_args()
5643 
    args.minOrderId = minOrderId
5644 
    args.maxOrderId = maxOrderId
5645 
    args.write(self._oprot)
5646 
    self._oprot.writeMessageEnd()
5647 
    self._oprot.trans.flush()
5648 
 
5649 
  def recv_getAllVerificationAgents(self, ):
5650 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5651 
    if mtype == TMessageType.EXCEPTION:
5652 
      x = TApplicationException()
5653 
      x.read(self._iprot)
5654 
      self._iprot.readMessageEnd()
5655 
      raise x
5656 
    result = getAllVerificationAgents_result()
5657 
    result.read(self._iprot)
5658 
    self._iprot.readMessageEnd()
5659 
    if result.success is not None:
5660 
      return result.success
5661 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllVerificationAgents failed: unknown result");
5662 
 
5527 anupam.sin 5663 
  def getAllAttributesForOrderId(self, orderId):
5664 
    """
5665 
    gets all attributes for a given orderId
5447 anupam.sin 5666 
 
5527 anupam.sin 5667 
    Parameters:
5668 
     - orderId
5669 
    """
5670 
    self.send_getAllAttributesForOrderId(orderId)
5671 
    return self.recv_getAllAttributesForOrderId()
5672 
 
5673 
  def send_getAllAttributesForOrderId(self, orderId):
5674 
    self._oprot.writeMessageBegin('getAllAttributesForOrderId', TMessageType.CALL, self._seqid)
5675 
    args = getAllAttributesForOrderId_args()
5676 
    args.orderId = orderId
5677 
    args.write(self._oprot)
5678 
    self._oprot.writeMessageEnd()
5679 
    self._oprot.trans.flush()
5680 
 
5681 
  def recv_getAllAttributesForOrderId(self, ):
5682 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5683 
    if mtype == TMessageType.EXCEPTION:
5684 
      x = TApplicationException()
5685 
      x.read(self._iprot)
5686 
      self._iprot.readMessageEnd()
5687 
      raise x
5688 
    result = getAllAttributesForOrderId_result()
5689 
    result.read(self._iprot)
5690 
    self._iprot.readMessageEnd()
5691 
    if result.success is not None:
5692 
      return result.success
5693 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllAttributesForOrderId failed: unknown result");
5694 
 
5676 rajveer 5695 
  def setOrderAttributes(self, orderId, attributes):
5696 
    """
5697 
    sets attributes for an order
5698 
 
5699 
    Parameters:
5700 
     - orderId
5701 
     - attributes
5702 
    """
5703 
    self.send_setOrderAttributes(orderId, attributes)
5704 
    self.recv_setOrderAttributes()
5705 
 
5706 
  def send_setOrderAttributes(self, orderId, attributes):
5707 
    self._oprot.writeMessageBegin('setOrderAttributes', TMessageType.CALL, self._seqid)
5708 
    args = setOrderAttributes_args()
5709 
    args.orderId = orderId
5710 
    args.attributes = attributes
5711 
    args.write(self._oprot)
5712 
    self._oprot.writeMessageEnd()
5713 
    self._oprot.trans.flush()
5714 
 
5715 
  def recv_setOrderAttributes(self, ):
5716 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5717 
    if mtype == TMessageType.EXCEPTION:
5718 
      x = TApplicationException()
5719 
      x.read(self._iprot)
5720 
      self._iprot.readMessageEnd()
5721 
      raise x
5722 
    result = setOrderAttributes_result()
5723 
    result.read(self._iprot)
5724 
    self._iprot.readMessageEnd()
5725 
    return
5726 
 
5527 anupam.sin 5727 
  def setOrderAttributeForTransaction(self, transactionId, attribute):
5728 
    """
5729 
    sets attributes for all orders in a transaction
5730 
 
5731 
    Parameters:
5732 
     - transactionId
5733 
     - attribute
5734 
    """
5735 
    self.send_setOrderAttributeForTransaction(transactionId, attribute)
5736 
    self.recv_setOrderAttributeForTransaction()
5737 
 
5738 
  def send_setOrderAttributeForTransaction(self, transactionId, attribute):
5739 
    self._oprot.writeMessageBegin('setOrderAttributeForTransaction', TMessageType.CALL, self._seqid)
5740 
    args = setOrderAttributeForTransaction_args()
5741 
    args.transactionId = transactionId
5742 
    args.attribute = attribute
5743 
    args.write(self._oprot)
5744 
    self._oprot.writeMessageEnd()
5745 
    self._oprot.trans.flush()
5746 
 
5747 
  def recv_setOrderAttributeForTransaction(self, ):
5748 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5749 
    if mtype == TMessageType.EXCEPTION:
5750 
      x = TApplicationException()
5751 
      x.read(self._iprot)
5752 
      self._iprot.readMessageEnd()
5753 
      raise x
5754 
    result = setOrderAttributeForTransaction_result()
5755 
    result.read(self._iprot)
5756 
    self._iprot.readMessageEnd()
5757 
    return
5758 
 
5553 rajveer 5759 
  def getReceivePendingOrders(self, storeId):
5760 
    """
5761 
    Parameters:
5762 
     - storeId
5763 
    """
5764 
    self.send_getReceivePendingOrders(storeId)
5765 
    return self.recv_getReceivePendingOrders()
5527 anupam.sin 5766 
 
5553 rajveer 5767 
  def send_getReceivePendingOrders(self, storeId):
5768 
    self._oprot.writeMessageBegin('getReceivePendingOrders', TMessageType.CALL, self._seqid)
5769 
    args = getReceivePendingOrders_args()
5770 
    args.storeId = storeId
5771 
    args.write(self._oprot)
5772 
    self._oprot.writeMessageEnd()
5773 
    self._oprot.trans.flush()
5774 
 
5775 
  def recv_getReceivePendingOrders(self, ):
5776 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5777 
    if mtype == TMessageType.EXCEPTION:
5778 
      x = TApplicationException()
5779 
      x.read(self._iprot)
5780 
      self._iprot.readMessageEnd()
5781 
      raise x
5782 
    result = getReceivePendingOrders_result()
5783 
    result.read(self._iprot)
5784 
    self._iprot.readMessageEnd()
5785 
    if result.success is not None:
5786 
      return result.success
5787 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReceivePendingOrders failed: unknown result");
5788 
 
5789 
  def getReceivedAtStoreOrders(self, storeId):
5790 
    """
5791 
    Parameters:
5792 
     - storeId
5793 
    """
5794 
    self.send_getReceivedAtStoreOrders(storeId)
5795 
    return self.recv_getReceivedAtStoreOrders()
5796 
 
5797 
  def send_getReceivedAtStoreOrders(self, storeId):
5798 
    self._oprot.writeMessageBegin('getReceivedAtStoreOrders', TMessageType.CALL, self._seqid)
5799 
    args = getReceivedAtStoreOrders_args()
5800 
    args.storeId = storeId
5801 
    args.write(self._oprot)
5802 
    self._oprot.writeMessageEnd()
5803 
    self._oprot.trans.flush()
5804 
 
5805 
  def recv_getReceivedAtStoreOrders(self, ):
5806 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5807 
    if mtype == TMessageType.EXCEPTION:
5808 
      x = TApplicationException()
5809 
      x.read(self._iprot)
5810 
      self._iprot.readMessageEnd()
5811 
      raise x
5812 
    result = getReceivedAtStoreOrders_result()
5813 
    result.read(self._iprot)
5814 
    self._iprot.readMessageEnd()
5815 
    if result.success is not None:
5816 
      return result.success
5817 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReceivedAtStoreOrders failed: unknown result");
5818 
 
5713 rajveer 5819 
  def getOrdersCollectionAtStore(self, storeId, fromDate, toDate, onlyCod):
5820 
    """
5821 
    Parameters:
5822 
     - storeId
5823 
     - fromDate
5824 
     - toDate
5825 
     - onlyCod
5826 
    """
5827 
    self.send_getOrdersCollectionAtStore(storeId, fromDate, toDate, onlyCod)
5828 
    return self.recv_getOrdersCollectionAtStore()
5829 
 
5830 
  def send_getOrdersCollectionAtStore(self, storeId, fromDate, toDate, onlyCod):
5831 
    self._oprot.writeMessageBegin('getOrdersCollectionAtStore', TMessageType.CALL, self._seqid)
5832 
    args = getOrdersCollectionAtStore_args()
5833 
    args.storeId = storeId
5834 
    args.fromDate = fromDate
5835 
    args.toDate = toDate
5836 
    args.onlyCod = onlyCod
5837 
    args.write(self._oprot)
5838 
    self._oprot.writeMessageEnd()
5839 
    self._oprot.trans.flush()
5840 
 
5841 
  def recv_getOrdersCollectionAtStore(self, ):
5842 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5843 
    if mtype == TMessageType.EXCEPTION:
5844 
      x = TApplicationException()
5845 
      x.read(self._iprot)
5846 
      self._iprot.readMessageEnd()
5847 
      raise x
5848 
    result = getOrdersCollectionAtStore_result()
5849 
    result.read(self._iprot)
5850 
    self._iprot.readMessageEnd()
5851 
    if result.success is not None:
5852 
      return result.success
5853 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersCollectionAtStore failed: unknown result");
5854 
 
5833 rajveer 5855 
  def getOrderAttributeValue(self, orderId, attributeName):
5856 
    """
5857 
    Parameters:
5858 
     - orderId
5859 
     - attributeName
5860 
    """
5861 
    self.send_getOrderAttributeValue(orderId, attributeName)
5862 
    return self.recv_getOrderAttributeValue()
5863 
 
5864 
  def send_getOrderAttributeValue(self, orderId, attributeName):
5865 
    self._oprot.writeMessageBegin('getOrderAttributeValue', TMessageType.CALL, self._seqid)
5866 
    args = getOrderAttributeValue_args()
5867 
    args.orderId = orderId
5868 
    args.attributeName = attributeName
5869 
    args.write(self._oprot)
5870 
    self._oprot.writeMessageEnd()
5871 
    self._oprot.trans.flush()
5872 
 
5873 
  def recv_getOrderAttributeValue(self, ):
5874 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5875 
    if mtype == TMessageType.EXCEPTION:
5876 
      x = TApplicationException()
5877 
      x.read(self._iprot)
5878 
      self._iprot.readMessageEnd()
5879 
      raise x
5880 
    result = getOrderAttributeValue_result()
5881 
    result.read(self._iprot)
5882 
    self._iprot.readMessageEnd()
5883 
    if result.success is not None:
5884 
      return result.success
5885 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderAttributeValue failed: unknown result");
5886 
 
6019 rajveer 5887 
  def changeJacketNumber(self, orderId, jacketNumber):
5888 
    """
5889 
    Parameters:
5890 
     - orderId
5891 
     - jacketNumber
5892 
    """
5893 
    self.send_changeJacketNumber(orderId, jacketNumber)
5894 
    return self.recv_changeJacketNumber()
5895 
 
5896 
  def send_changeJacketNumber(self, orderId, jacketNumber):
5897 
    self._oprot.writeMessageBegin('changeJacketNumber', TMessageType.CALL, self._seqid)
5898 
    args = changeJacketNumber_args()
5899 
    args.orderId = orderId
5900 
    args.jacketNumber = jacketNumber
5901 
    args.write(self._oprot)
5902 
    self._oprot.writeMessageEnd()
5903 
    self._oprot.trans.flush()
5904 
 
5905 
  def recv_changeJacketNumber(self, ):
5906 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5907 
    if mtype == TMessageType.EXCEPTION:
5908 
      x = TApplicationException()
5909 
      x.read(self._iprot)
5910 
      self._iprot.readMessageEnd()
5911 
      raise x
5912 
    result = changeJacketNumber_result()
5913 
    result.read(self._iprot)
5914 
    self._iprot.readMessageEnd()
5915 
    if result.success is not None:
5916 
      return result.success
5917 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "changeJacketNumber failed: unknown result");
5918 
 
5919 
  def markOrderAsRtoInTransit(self, orderId):
5920 
    """
5921 
    Parameters:
5922 
     - orderId
5923 
    """
5924 
    self.send_markOrderAsRtoInTransit(orderId)
5925 
    return self.recv_markOrderAsRtoInTransit()
5926 
 
5927 
  def send_markOrderAsRtoInTransit(self, orderId):
5928 
    self._oprot.writeMessageBegin('markOrderAsRtoInTransit', TMessageType.CALL, self._seqid)
5929 
    args = markOrderAsRtoInTransit_args()
5930 
    args.orderId = orderId
5931 
    args.write(self._oprot)
5932 
    self._oprot.writeMessageEnd()
5933 
    self._oprot.trans.flush()
5934 
 
5935 
  def recv_markOrderAsRtoInTransit(self, ):
5936 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5937 
    if mtype == TMessageType.EXCEPTION:
5938 
      x = TApplicationException()
5939 
      x.read(self._iprot)
5940 
      self._iprot.readMessageEnd()
5941 
      raise x
5942 
    result = markOrderAsRtoInTransit_result()
5943 
    result.read(self._iprot)
5944 
    self._iprot.readMessageEnd()
5945 
    if result.success is not None:
5946 
      return result.success
5947 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderAsRtoInTransit failed: unknown result");
5948 
 
5593 mandeep.dh 5949 
  def acceptOrderForItem(self, itemId, quantity, fulfilmentWarehouseId, billingWarehouseId):
5950 
    """
5951 
    Accepts appropriate order for an item in a given billingWarehouse. Usually
5952 
    invoked while scanning IN of items.
5553 rajveer 5953 
 
5593 mandeep.dh 5954 
    Parameters:
5955 
     - itemId
5956 
     - quantity
5957 
     - fulfilmentWarehouseId
5958 
     - billingWarehouseId
5959 
    """
5960 
    self.send_acceptOrderForItem(itemId, quantity, fulfilmentWarehouseId, billingWarehouseId)
5961 
    self.recv_acceptOrderForItem()
5962 
 
5963 
  def send_acceptOrderForItem(self, itemId, quantity, fulfilmentWarehouseId, billingWarehouseId):
5964 
    self._oprot.writeMessageBegin('acceptOrderForItem', TMessageType.CALL, self._seqid)
5965 
    args = acceptOrderForItem_args()
5966 
    args.itemId = itemId
5967 
    args.quantity = quantity
5968 
    args.fulfilmentWarehouseId = fulfilmentWarehouseId
5969 
    args.billingWarehouseId = billingWarehouseId
5970 
    args.write(self._oprot)
5971 
    self._oprot.writeMessageEnd()
5972 
    self._oprot.trans.flush()
5973 
 
5974 
  def recv_acceptOrderForItem(self, ):
5975 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5976 
    if mtype == TMessageType.EXCEPTION:
5977 
      x = TApplicationException()
5978 
      x.read(self._iprot)
5979 
      self._iprot.readMessageEnd()
5980 
      raise x
5981 
    result = acceptOrderForItem_result()
5982 
    result.read(self._iprot)
5983 
    self._iprot.readMessageEnd()
5984 
    return
5985 
 
6000 mandeep.dh 5986 
  def createRechargeOrder(self, rechargeOrder):
5987 
    """
5988 
    Parameters:
5989 
     - rechargeOrder
5990 
    """
5991 
    self.send_createRechargeOrder(rechargeOrder)
5992 
    return self.recv_createRechargeOrder()
5593 mandeep.dh 5993 
 
6000 mandeep.dh 5994 
  def send_createRechargeOrder(self, rechargeOrder):
5995 
    self._oprot.writeMessageBegin('createRechargeOrder', TMessageType.CALL, self._seqid)
5996 
    args = createRechargeOrder_args()
5997 
    args.rechargeOrder = rechargeOrder
5998 
    args.write(self._oprot)
5999 
    self._oprot.writeMessageEnd()
6000 
    self._oprot.trans.flush()
6001 
 
6002 
  def recv_createRechargeOrder(self, ):
6003 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6004 
    if mtype == TMessageType.EXCEPTION:
6005 
      x = TApplicationException()
6006 
      x.read(self._iprot)
6007 
      self._iprot.readMessageEnd()
6008 
      raise x
6009 
    result = createRechargeOrder_result()
6010 
    result.read(self._iprot)
6011 
    self._iprot.readMessageEnd()
6012 
    if result.success is not None:
6013 
      return result.success
6014 
    if result.ex is not None:
6015 
      raise result.ex
6016 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createRechargeOrder failed: unknown result");
6017 
 
6031 rajveer 6018 
  def getRechargeOrder(self, rechargeRrderId):
6019 
    """
6020 
    Parameters:
6021 
     - rechargeRrderId
6022 
    """
6023 
    self.send_getRechargeOrder(rechargeRrderId)
6024 
    return self.recv_getRechargeOrder()
6025 
 
6026 
  def send_getRechargeOrder(self, rechargeRrderId):
6027 
    self._oprot.writeMessageBegin('getRechargeOrder', TMessageType.CALL, self._seqid)
6028 
    args = getRechargeOrder_args()
6029 
    args.rechargeRrderId = rechargeRrderId
6030 
    args.write(self._oprot)
6031 
    self._oprot.writeMessageEnd()
6032 
    self._oprot.trans.flush()
6033 
 
6034 
  def recv_getRechargeOrder(self, ):
6035 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6036 
    if mtype == TMessageType.EXCEPTION:
6037 
      x = TApplicationException()
6038 
      x.read(self._iprot)
6039 
      self._iprot.readMessageEnd()
6040 
      raise x
6041 
    result = getRechargeOrder_result()
6042 
    result.read(self._iprot)
6043 
    self._iprot.readMessageEnd()
6044 
    if result.success is not None:
6045 
      return result.success
6046 
    if result.ex is not None:
6047 
      raise result.ex
6048 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getRechargeOrder failed: unknown result");
6049 
 
6050 
  def getRechargeOrders(self, userId):
6051 
    """
6052 
    Parameters:
6053 
     - userId
6054 
    """
6055 
    self.send_getRechargeOrders(userId)
6056 
    return self.recv_getRechargeOrders()
6057 
 
6058 
  def send_getRechargeOrders(self, userId):
6059 
    self._oprot.writeMessageBegin('getRechargeOrders', TMessageType.CALL, self._seqid)
6060 
    args = getRechargeOrders_args()
6061 
    args.userId = userId
6062 
    args.write(self._oprot)
6063 
    self._oprot.writeMessageEnd()
6064 
    self._oprot.trans.flush()
6065 
 
6066 
  def recv_getRechargeOrders(self, ):
6067 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6068 
    if mtype == TMessageType.EXCEPTION:
6069 
      x = TApplicationException()
6070 
      x.read(self._iprot)
6071 
      self._iprot.readMessageEnd()
6072 
      raise x
6073 
    result = getRechargeOrders_result()
6074 
    result.read(self._iprot)
6075 
    self._iprot.readMessageEnd()
6076 
    if result.success is not None:
6077 
      return result.success
6078 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getRechargeOrders failed: unknown result");
6079 
 
6000 mandeep.dh 6080 
  def updateRechargeOrderStatus(self, rechargeOrderId, rechargeOrderStatus):
6081 
    """
6082 
    Parameters:
6083 
     - rechargeOrderId
6084 
     - rechargeOrderStatus
6085 
    """
6086 
    self.send_updateRechargeOrderStatus(rechargeOrderId, rechargeOrderStatus)
6031 rajveer 6087 
    return self.recv_updateRechargeOrderStatus()
6000 mandeep.dh 6088 
 
6089 
  def send_updateRechargeOrderStatus(self, rechargeOrderId, rechargeOrderStatus):
6090 
    self._oprot.writeMessageBegin('updateRechargeOrderStatus', TMessageType.CALL, self._seqid)
6091 
    args = updateRechargeOrderStatus_args()
6092 
    args.rechargeOrderId = rechargeOrderId
6093 
    args.rechargeOrderStatus = rechargeOrderStatus
6094 
    args.write(self._oprot)
6095 
    self._oprot.writeMessageEnd()
6096 
    self._oprot.trans.flush()
6097 
 
6098 
  def recv_updateRechargeOrderStatus(self, ):
6099 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6100 
    if mtype == TMessageType.EXCEPTION:
6101 
      x = TApplicationException()
6102 
      x.read(self._iprot)
6103 
      self._iprot.readMessageEnd()
6104 
      raise x
6105 
    result = updateRechargeOrderStatus_result()
6106 
    result.read(self._iprot)
6107 
    self._iprot.readMessageEnd()
6031 rajveer 6108 
    if result.success is not None:
6109 
      return result.success
6000 mandeep.dh 6110 
    if result.ex is not None:
6111 
      raise result.ex
6031 rajveer 6112 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updateRechargeOrderStatus failed: unknown result");
6000 mandeep.dh 6113 
 
6031 rajveer 6114 
  def activateRechargeTxn(self, rechargeOrderId):
6000 mandeep.dh 6115 
    """
6116 
    Parameters:
6031 rajveer 6117 
     - rechargeOrderId
6000 mandeep.dh 6118 
    """
6031 rajveer 6119 
    self.send_activateRechargeTxn(rechargeOrderId)
6000 mandeep.dh 6120 
    return self.recv_activateRechargeTxn()
6121 
 
6031 rajveer 6122 
  def send_activateRechargeTxn(self, rechargeOrderId):
6000 mandeep.dh 6123 
    self._oprot.writeMessageBegin('activateRechargeTxn', TMessageType.CALL, self._seqid)
6124 
    args = activateRechargeTxn_args()
6031 rajveer 6125 
    args.rechargeOrderId = rechargeOrderId
6000 mandeep.dh 6126 
    args.write(self._oprot)
6127 
    self._oprot.writeMessageEnd()
6128 
    self._oprot.trans.flush()
6129 
 
6130 
  def recv_activateRechargeTxn(self, ):
6131 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6132 
    if mtype == TMessageType.EXCEPTION:
6133 
      x = TApplicationException()
6134 
      x.read(self._iprot)
6135 
      self._iprot.readMessageEnd()
6136 
      raise x
6137 
    result = activateRechargeTxn_result()
6138 
    result.read(self._iprot)
6139 
    self._iprot.readMessageEnd()
6140 
    if result.success is not None:
6141 
      return result.success
6142 
    if result.ex is not None:
6143 
      raise result.ex
6144 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "activateRechargeTxn failed: unknown result");
6145 
 
6031 rajveer 6146 
  def getUserWallet(self, userId):
6000 mandeep.dh 6147 
    """
6148 
    Parameters:
6031 rajveer 6149 
     - userId
6000 mandeep.dh 6150 
    """
6031 rajveer 6151 
    self.send_getUserWallet(userId)
6152 
    return self.recv_getUserWallet()
6000 mandeep.dh 6153 
 
6031 rajveer 6154 
  def send_getUserWallet(self, userId):
6155 
    self._oprot.writeMessageBegin('getUserWallet', TMessageType.CALL, self._seqid)
6156 
    args = getUserWallet_args()
6157 
    args.userId = userId
6000 mandeep.dh 6158 
    args.write(self._oprot)
6159 
    self._oprot.writeMessageEnd()
6160 
    self._oprot.trans.flush()
6161 
 
6031 rajveer 6162 
  def recv_getUserWallet(self, ):
6000 mandeep.dh 6163 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6164 
    if mtype == TMessageType.EXCEPTION:
6165 
      x = TApplicationException()
6166 
      x.read(self._iprot)
6167 
      self._iprot.readMessageEnd()
6168 
      raise x
6031 rajveer 6169 
    result = getUserWallet_result()
6000 mandeep.dh 6170 
    result.read(self._iprot)
6171 
    self._iprot.readMessageEnd()
6172 
    if result.success is not None:
6173 
      return result.success
6031 rajveer 6174 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUserWallet failed: unknown result");
6000 mandeep.dh 6175 
 
6031 rajveer 6176 
  def getUserWalletHistory(self, userId):
6000 mandeep.dh 6177 
    """
6178 
    Parameters:
6031 rajveer 6179 
     - userId
6000 mandeep.dh 6180 
    """
6031 rajveer 6181 
    self.send_getUserWalletHistory(userId)
6182 
    return self.recv_getUserWalletHistory()
6000 mandeep.dh 6183 
 
6031 rajveer 6184 
  def send_getUserWalletHistory(self, userId):
6185 
    self._oprot.writeMessageBegin('getUserWalletHistory', TMessageType.CALL, self._seqid)
6186 
    args = getUserWalletHistory_args()
6187 
    args.userId = userId
6000 mandeep.dh 6188 
    args.write(self._oprot)
6189 
    self._oprot.writeMessageEnd()
6190 
    self._oprot.trans.flush()
6191 
 
6031 rajveer 6192 
  def recv_getUserWalletHistory(self, ):
6000 mandeep.dh 6193 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6194 
    if mtype == TMessageType.EXCEPTION:
6195 
      x = TApplicationException()
6196 
      x.read(self._iprot)
6197 
      self._iprot.readMessageEnd()
6198 
      raise x
6031 rajveer 6199 
    result = getUserWalletHistory_result()
6000 mandeep.dh 6200 
    result.read(self._iprot)
6201 
    self._iprot.readMessageEnd()
6202 
    if result.success is not None:
6203 
      return result.success
6031 rajveer 6204 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUserWalletHistory failed: unknown result");
6000 mandeep.dh 6205 
 
6050 anupam.sin 6206 
  def getRechargeOrdersForTransaction(self, txnId):
6207 
    """
6208 
    Returns a recharge order for a given transactionId
6209 
 
6210 
    Parameters:
6211 
     - txnId
6212 
    """
6213 
    self.send_getRechargeOrdersForTransaction(txnId)
6214 
    return self.recv_getRechargeOrdersForTransaction()
6215 
 
6216 
  def send_getRechargeOrdersForTransaction(self, txnId):
6217 
    self._oprot.writeMessageBegin('getRechargeOrdersForTransaction', TMessageType.CALL, self._seqid)
6218 
    args = getRechargeOrdersForTransaction_args()
6219 
    args.txnId = txnId
6220 
    args.write(self._oprot)
6221 
    self._oprot.writeMessageEnd()
6222 
    self._oprot.trans.flush()
6223 
 
6224 
  def recv_getRechargeOrdersForTransaction(self, ):
6225 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6226 
    if mtype == TMessageType.EXCEPTION:
6227 
      x = TApplicationException()
6228 
      x.read(self._iprot)
6229 
      self._iprot.readMessageEnd()
6230 
      raise x
6231 
    result = getRechargeOrdersForTransaction_result()
6232 
    result.read(self._iprot)
6233 
    self._iprot.readMessageEnd()
6234 
    if result.success is not None:
6235 
      return result.success
6236 
    if result.ex is not None:
6237 
      raise result.ex
6238 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getRechargeOrdersForTransaction failed: unknown result");
6239 
 
6206 rajveer 6240 
  def getServiceProviders(self, rechargeType, onlyActive):
6048 rajveer 6241 
    """
6242 
    Parameters:
6243 
     - rechargeType
6206 rajveer 6244 
     - onlyActive
6048 rajveer 6245 
    """
6206 rajveer 6246 
    self.send_getServiceProviders(rechargeType, onlyActive)
6048 rajveer 6247 
    return self.recv_getServiceProviders()
6000 mandeep.dh 6248 
 
6206 rajveer 6249 
  def send_getServiceProviders(self, rechargeType, onlyActive):
6048 rajveer 6250 
    self._oprot.writeMessageBegin('getServiceProviders', TMessageType.CALL, self._seqid)
6251 
    args = getServiceProviders_args()
6252 
    args.rechargeType = rechargeType
6206 rajveer 6253 
    args.onlyActive = onlyActive
6048 rajveer 6254 
    args.write(self._oprot)
6255 
    self._oprot.writeMessageEnd()
6256 
    self._oprot.trans.flush()
6257 
 
6258 
  def recv_getServiceProviders(self, ):
6259 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6260 
    if mtype == TMessageType.EXCEPTION:
6261 
      x = TApplicationException()
6262 
      x.read(self._iprot)
6263 
      self._iprot.readMessageEnd()
6264 
      raise x
6265 
    result = getServiceProviders_result()
6266 
    result.read(self._iprot)
6267 
    self._iprot.readMessageEnd()
6268 
    if result.success is not None:
6269 
      return result.success
6270 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getServiceProviders failed: unknown result");
6271 
 
6049 rajveer 6272 
  def getServiceProviderForDevice(self, rechargeType, deviceNumber):
6048 rajveer 6273 
    """
6274 
    Parameters:
6049 rajveer 6275 
     - rechargeType
6048 rajveer 6276 
     - deviceNumber
6277 
    """
6049 rajveer 6278 
    self.send_getServiceProviderForDevice(rechargeType, deviceNumber)
6048 rajveer 6279 
    return self.recv_getServiceProviderForDevice()
6280 
 
6049 rajveer 6281 
  def send_getServiceProviderForDevice(self, rechargeType, deviceNumber):
6048 rajveer 6282 
    self._oprot.writeMessageBegin('getServiceProviderForDevice', TMessageType.CALL, self._seqid)
6283 
    args = getServiceProviderForDevice_args()
6049 rajveer 6284 
    args.rechargeType = rechargeType
6048 rajveer 6285 
    args.deviceNumber = deviceNumber
6286 
    args.write(self._oprot)
6287 
    self._oprot.writeMessageEnd()
6288 
    self._oprot.trans.flush()
6289 
 
6290 
  def recv_getServiceProviderForDevice(self, ):
6291 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6292 
    if mtype == TMessageType.EXCEPTION:
6293 
      x = TApplicationException()
6294 
      x.read(self._iprot)
6295 
      self._iprot.readMessageEnd()
6296 
      raise x
6297 
    result = getServiceProviderForDevice_result()
6298 
    result.read(self._iprot)
6299 
    self._iprot.readMessageEnd()
6300 
    if result.success is not None:
6301 
      return result.success
6302 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getServiceProviderForDevice failed: unknown result");
6303 
 
6591 anupam.sin 6304 
  def validateRecharge(self, rechargeType, deviceNumber, userSelectedProviderId, clientAddress):
6269 rajveer 6305 
    """
6306 
    Parameters:
6307 
     - rechargeType
6308 
     - deviceNumber
6307 anupam.sin 6309 
     - userSelectedProviderId
6591 anupam.sin 6310 
     - clientAddress
6269 rajveer 6311 
    """
6591 anupam.sin 6312 
    self.send_validateRecharge(rechargeType, deviceNumber, userSelectedProviderId, clientAddress)
6269 rajveer 6313 
    return self.recv_validateRecharge()
6314 
 
6591 anupam.sin 6315 
  def send_validateRecharge(self, rechargeType, deviceNumber, userSelectedProviderId, clientAddress):
6269 rajveer 6316 
    self._oprot.writeMessageBegin('validateRecharge', TMessageType.CALL, self._seqid)
6317 
    args = validateRecharge_args()
6318 
    args.rechargeType = rechargeType
6319 
    args.deviceNumber = deviceNumber
6307 anupam.sin 6320 
    args.userSelectedProviderId = userSelectedProviderId
6591 anupam.sin 6321 
    args.clientAddress = clientAddress
6269 rajveer 6322 
    args.write(self._oprot)
6323 
    self._oprot.writeMessageEnd()
6324 
    self._oprot.trans.flush()
6325 
 
6326 
  def recv_validateRecharge(self, ):
6327 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6328 
    if mtype == TMessageType.EXCEPTION:
6329 
      x = TApplicationException()
6330 
      x.read(self._iprot)
6331 
      self._iprot.readMessageEnd()
6332 
      raise x
6333 
    result = validateRecharge_result()
6334 
    result.read(self._iprot)
6335 
    self._iprot.readMessageEnd()
6336 
    if result.success is not None:
6337 
      return result.success
6338 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "validateRecharge failed: unknown result");
6339 
 
6094 rajveer 6340 
  def getRechargeOrdersForDevice(self, deviceNumber):
6341 
    """
6342 
    Parameters:
6343 
     - deviceNumber
6344 
    """
6345 
    self.send_getRechargeOrdersForDevice(deviceNumber)
6346 
    return self.recv_getRechargeOrdersForDevice()
6048 rajveer 6347 
 
6094 rajveer 6348 
  def send_getRechargeOrdersForDevice(self, deviceNumber):
6349 
    self._oprot.writeMessageBegin('getRechargeOrdersForDevice', TMessageType.CALL, self._seqid)
6350 
    args = getRechargeOrdersForDevice_args()
6351 
    args.deviceNumber = deviceNumber
6352 
    args.write(self._oprot)
6353 
    self._oprot.writeMessageEnd()
6354 
    self._oprot.trans.flush()
6355 
 
6356 
  def recv_getRechargeOrdersForDevice(self, ):
6357 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6358 
    if mtype == TMessageType.EXCEPTION:
6359 
      x = TApplicationException()
6360 
      x.read(self._iprot)
6361 
      self._iprot.readMessageEnd()
6362 
      raise x
6363 
    result = getRechargeOrdersForDevice_result()
6364 
    result.read(self._iprot)
6365 
    self._iprot.readMessageEnd()
6366 
    if result.success is not None:
6367 
      return result.success
6368 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getRechargeOrdersForDevice failed: unknown result");
6369 
 
6370 
  def addAmountToWallet(self, userId, orderId, amount):
6371 
    """
6372 
    Parameters:
6373 
     - userId
6374 
     - orderId
6375 
     - amount
6376 
    """
6377 
    self.send_addAmountToWallet(userId, orderId, amount)
6378 
    self.recv_addAmountToWallet()
6379 
 
6380 
  def send_addAmountToWallet(self, userId, orderId, amount):
6381 
    self._oprot.writeMessageBegin('addAmountToWallet', TMessageType.CALL, self._seqid)
6382 
    args = addAmountToWallet_args()
6383 
    args.userId = userId
6384 
    args.orderId = orderId
6385 
    args.amount = amount
6386 
    args.write(self._oprot)
6387 
    self._oprot.writeMessageEnd()
6388 
    self._oprot.trans.flush()
6389 
 
6390 
  def recv_addAmountToWallet(self, ):
6391 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6392 
    if mtype == TMessageType.EXCEPTION:
6393 
      x = TApplicationException()
6394 
      x.read(self._iprot)
6395 
      self._iprot.readMessageEnd()
6396 
      raise x
6397 
    result = addAmountToWallet_result()
6398 
    result.read(self._iprot)
6399 
    self._iprot.readMessageEnd()
6400 
    return
6401 
 
6188 rajveer 6402 
  def getRechargeStatistics(self, ):
6403 
    self.send_getRechargeStatistics()
6404 
    return self.recv_getRechargeStatistics()
6405 
 
6406 
  def send_getRechargeStatistics(self, ):
6407 
    self._oprot.writeMessageBegin('getRechargeStatistics', TMessageType.CALL, self._seqid)
6408 
    args = getRechargeStatistics_args()
6409 
    args.write(self._oprot)
6410 
    self._oprot.writeMessageEnd()
6411 
    self._oprot.trans.flush()
6412 
 
6413 
  def recv_getRechargeStatistics(self, ):
6414 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6415 
    if mtype == TMessageType.EXCEPTION:
6416 
      x = TApplicationException()
6417 
      x.read(self._iprot)
6418 
      self._iprot.readMessageEnd()
6419 
      raise x
6420 
    result = getRechargeStatistics_result()
6421 
    result.read(self._iprot)
6422 
    self._iprot.readMessageEnd()
6423 
    if result.success is not None:
6424 
      return result.success
6425 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getRechargeStatistics failed: unknown result");
6426 
 
6154 rajveer 6427 
  def getRechargeOrdersForStatus(self, status):
6428 
    """
6429 
    Parameters:
6430 
     - status
6431 
    """
6432 
    self.send_getRechargeOrdersForStatus(status)
6433 
    return self.recv_getRechargeOrdersForStatus()
6094 rajveer 6434 
 
6154 rajveer 6435 
  def send_getRechargeOrdersForStatus(self, status):
6436 
    self._oprot.writeMessageBegin('getRechargeOrdersForStatus', TMessageType.CALL, self._seqid)
6437 
    args = getRechargeOrdersForStatus_args()
6438 
    args.status = status
6439 
    args.write(self._oprot)
6440 
    self._oprot.writeMessageEnd()
6441 
    self._oprot.trans.flush()
6442 
 
6443 
  def recv_getRechargeOrdersForStatus(self, ):
6444 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6445 
    if mtype == TMessageType.EXCEPTION:
6446 
      x = TApplicationException()
6447 
      x.read(self._iprot)
6448 
      self._iprot.readMessageEnd()
6449 
      raise x
6450 
    result = getRechargeOrdersForStatus_result()
6451 
    result.read(self._iprot)
6452 
    self._iprot.readMessageEnd()
6453 
    if result.success is not None:
6454 
      return result.success
6455 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getRechargeOrdersForStatus failed: unknown result");
6456 
 
6159 rajveer 6457 
  def getPlansForOperator(self, operatorId):
6458 
    """
6459 
    Parameters:
6460 
     - operatorId
6461 
    """
6462 
    self.send_getPlansForOperator(operatorId)
6463 
    return self.recv_getPlansForOperator()
6154 rajveer 6464 
 
6159 rajveer 6465 
  def send_getPlansForOperator(self, operatorId):
6466 
    self._oprot.writeMessageBegin('getPlansForOperator', TMessageType.CALL, self._seqid)
6467 
    args = getPlansForOperator_args()
6468 
    args.operatorId = operatorId
6469 
    args.write(self._oprot)
6470 
    self._oprot.writeMessageEnd()
6471 
    self._oprot.trans.flush()
6472 
 
6473 
  def recv_getPlansForOperator(self, ):
6474 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6475 
    if mtype == TMessageType.EXCEPTION:
6476 
      x = TApplicationException()
6477 
      x.read(self._iprot)
6478 
      self._iprot.readMessageEnd()
6479 
      raise x
6480 
    result = getPlansForOperator_result()
6481 
    result.read(self._iprot)
6482 
    self._iprot.readMessageEnd()
6483 
    if result.success is not None:
6484 
      return result.success
6485 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getPlansForOperator failed: unknown result");
6486 
 
6307 anupam.sin 6487 
  def getRechargeDenominations(self, operatorId, circleCode, denominationType):
6289 anupam.sin 6488 
    """
6489 
    Returns denominations for a given operator and circle
6159 rajveer 6490 
 
6289 anupam.sin 6491 
    Parameters:
6492 
     - operatorId
6307 anupam.sin 6493 
     - circleCode
6289 anupam.sin 6494 
     - denominationType
6495 
    """
6307 anupam.sin 6496 
    self.send_getRechargeDenominations(operatorId, circleCode, denominationType)
6289 anupam.sin 6497 
    return self.recv_getRechargeDenominations()
6498 
 
6307 anupam.sin 6499 
  def send_getRechargeDenominations(self, operatorId, circleCode, denominationType):
6289 anupam.sin 6500 
    self._oprot.writeMessageBegin('getRechargeDenominations', TMessageType.CALL, self._seqid)
6501 
    args = getRechargeDenominations_args()
6502 
    args.operatorId = operatorId
6307 anupam.sin 6503 
    args.circleCode = circleCode
6289 anupam.sin 6504 
    args.denominationType = denominationType
6505 
    args.write(self._oprot)
6506 
    self._oprot.writeMessageEnd()
6507 
    self._oprot.trans.flush()
6508 
 
6509 
  def recv_getRechargeDenominations(self, ):
6510 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6511 
    if mtype == TMessageType.EXCEPTION:
6512 
      x = TApplicationException()
6513 
      x.read(self._iprot)
6514 
      self._iprot.readMessageEnd()
6515 
      raise x
6516 
    result = getRechargeDenominations_result()
6517 
    result.read(self._iprot)
6518 
    self._iprot.readMessageEnd()
6519 
    if result.success is not None:
6520 
      return result.success
6521 
    if result.ex is not None:
6522 
      raise result.ex
6523 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getRechargeDenominations failed: unknown result");
6524 
 
6371 rajveer 6525 
  def updateAvailabilityStatus(self, operatorId, circleId, isAvailable):
6526 
    """
6527 
    Parameters:
6528 
     - operatorId
6529 
     - circleId
6530 
     - isAvailable
6531 
    """
6532 
    self.send_updateAvailabilityStatus(operatorId, circleId, isAvailable)
6533 
    self.recv_updateAvailabilityStatus()
6289 anupam.sin 6534 
 
6371 rajveer 6535 
  def send_updateAvailabilityStatus(self, operatorId, circleId, isAvailable):
6536 
    self._oprot.writeMessageBegin('updateAvailabilityStatus', TMessageType.CALL, self._seqid)
6537 
    args = updateAvailabilityStatus_args()
6538 
    args.operatorId = operatorId
6539 
    args.circleId = circleId
6540 
    args.isAvailable = isAvailable
6541 
    args.write(self._oprot)
6542 
    self._oprot.writeMessageEnd()
6543 
    self._oprot.trans.flush()
6544 
 
6545 
  def recv_updateAvailabilityStatus(self, ):
6546 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6547 
    if mtype == TMessageType.EXCEPTION:
6548 
      x = TApplicationException()
6549 
      x.read(self._iprot)
6550 
      self._iprot.readMessageEnd()
6551 
      raise x
6552 
    result = updateAvailabilityStatus_result()
6553 
    result.read(self._iprot)
6554 
    self._iprot.readMessageEnd()
6555 
    return
6556 
 
6389 rajveer 6557 
  def getAvailableEmiSchemes(self, ):
6558 
    self.send_getAvailableEmiSchemes()
6559 
    return self.recv_getAvailableEmiSchemes()
6371 rajveer 6560 
 
6389 rajveer 6561 
  def send_getAvailableEmiSchemes(self, ):
6562 
    self._oprot.writeMessageBegin('getAvailableEmiSchemes', TMessageType.CALL, self._seqid)
6563 
    args = getAvailableEmiSchemes_args()
6564 
    args.write(self._oprot)
6565 
    self._oprot.writeMessageEnd()
6566 
    self._oprot.trans.flush()
6567 
 
6568 
  def recv_getAvailableEmiSchemes(self, ):
6569 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6570 
    if mtype == TMessageType.EXCEPTION:
6571 
      x = TApplicationException()
6572 
      x.read(self._iprot)
6573 
      self._iprot.readMessageEnd()
6574 
      raise x
6575 
    result = getAvailableEmiSchemes_result()
6576 
    result.read(self._iprot)
6577 
    self._iprot.readMessageEnd()
6578 
    if result.success is not None:
6579 
      return result.success
6580 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAvailableEmiSchemes failed: unknown result");
6581 
 
6582 
  def getMiscCharges(self, transactionId):
6583 
    """
6584 
    Parameters:
6585 
     - transactionId
6586 
    """
6587 
    self.send_getMiscCharges(transactionId)
6588 
    return self.recv_getMiscCharges()
6589 
 
6590 
  def send_getMiscCharges(self, transactionId):
6591 
    self._oprot.writeMessageBegin('getMiscCharges', TMessageType.CALL, self._seqid)
6592 
    args = getMiscCharges_args()
6593 
    args.transactionId = transactionId
6594 
    args.write(self._oprot)
6595 
    self._oprot.writeMessageEnd()
6596 
    self._oprot.trans.flush()
6597 
 
6598 
  def recv_getMiscCharges(self, ):
6599 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6600 
    if mtype == TMessageType.EXCEPTION:
6601 
      x = TApplicationException()
6602 
      x.read(self._iprot)
6603 
      self._iprot.readMessageEnd()
6604 
      raise x
6605 
    result = getMiscCharges_result()
6606 
    result.read(self._iprot)
6607 
    self._iprot.readMessageEnd()
6608 
    if result.success is not None:
6609 
      return result.success
6610 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getMiscCharges failed: unknown result");
6611 
 
6507 anupam.sin 6612 
  def refundRechargeOrder(self, rechargeOrderId):
6613 
    """
6614 
    Parameters:
6615 
     - rechargeOrderId
6616 
    """
6617 
    self.send_refundRechargeOrder(rechargeOrderId)
6618 
    return self.recv_refundRechargeOrder()
6389 rajveer 6619 
 
6507 anupam.sin 6620 
  def send_refundRechargeOrder(self, rechargeOrderId):
6621 
    self._oprot.writeMessageBegin('refundRechargeOrder', TMessageType.CALL, self._seqid)
6622 
    args = refundRechargeOrder_args()
6623 
    args.rechargeOrderId = rechargeOrderId
6624 
    args.write(self._oprot)
6625 
    self._oprot.writeMessageEnd()
6626 
    self._oprot.trans.flush()
6627 
 
6628 
  def recv_refundRechargeOrder(self, ):
6629 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6630 
    if mtype == TMessageType.EXCEPTION:
6631 
      x = TApplicationException()
6632 
      x.read(self._iprot)
6633 
      self._iprot.readMessageEnd()
6634 
      raise x
6635 
    result = refundRechargeOrder_result()
6636 
    result.read(self._iprot)
6637 
    self._iprot.readMessageEnd()
6638 
    if result.success is not None:
6639 
      return result.success
6640 
    if result.ex is not None:
6641 
      raise result.ex
6642 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "refundRechargeOrder failed: unknown result");
6643 
 
6821 amar.kumar 6644 
  def getPhysicalOrders(self, fromDate, toDate):
6645 
    """
6646 
    Parameters:
6647 
     - fromDate
6648 
     - toDate
6649 
    """
6650 
    self.send_getPhysicalOrders(fromDate, toDate)
6651 
    return self.recv_getPhysicalOrders()
6507 anupam.sin 6652 
 
6821 amar.kumar 6653 
  def send_getPhysicalOrders(self, fromDate, toDate):
6654 
    self._oprot.writeMessageBegin('getPhysicalOrders', TMessageType.CALL, self._seqid)
6655 
    args = getPhysicalOrders_args()
6656 
    args.fromDate = fromDate
6657 
    args.toDate = toDate
6658 
    args.write(self._oprot)
6659 
    self._oprot.writeMessageEnd()
6660 
    self._oprot.trans.flush()
6661 
 
6662 
  def recv_getPhysicalOrders(self, ):
6663 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6664 
    if mtype == TMessageType.EXCEPTION:
6665 
      x = TApplicationException()
6666 
      x.read(self._iprot)
6667 
      self._iprot.readMessageEnd()
6668 
      raise x
6669 
    result = getPhysicalOrders_result()
6670 
    result.read(self._iprot)
6671 
    self._iprot.readMessageEnd()
6672 
    if result.success is not None:
6673 
      return result.success
6674 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getPhysicalOrders failed: unknown result");
6675 
 
6906 rajveer 6676 
  def getDocument(self, docType, docSource):
6677 
    """
6678 
    Parameters:
6679 
     - docType
6680 
     - docSource
6681 
    """
6682 
    self.send_getDocument(docType, docSource)
6683 
    return self.recv_getDocument()
6821 amar.kumar 6684 
 
6906 rajveer 6685 
  def send_getDocument(self, docType, docSource):
6686 
    self._oprot.writeMessageBegin('getDocument', TMessageType.CALL, self._seqid)
6687 
    args = getDocument_args()
6688 
    args.docType = docType
6689 
    args.docSource = docSource
6690 
    args.write(self._oprot)
6691 
    self._oprot.writeMessageEnd()
6692 
    self._oprot.trans.flush()
6693 
 
6694 
  def recv_getDocument(self, ):
6695 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6696 
    if mtype == TMessageType.EXCEPTION:
6697 
      x = TApplicationException()
6698 
      x.read(self._iprot)
6699 
      self._iprot.readMessageEnd()
6700 
      raise x
6701 
    result = getDocument_result()
6702 
    result.read(self._iprot)
6703 
    self._iprot.readMessageEnd()
6704 
    if result.success is not None:
6705 
      return result.success
6706 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getDocument failed: unknown result");
6707 
 
6985 anupam.sin 6708 
  def changeShippingAddress(self, orderId, line1, line2, city, state, pin):
6709 
    """
6710 
    Parameters:
6711 
     - orderId
6712 
     - line1
6713 
     - line2
6714 
     - city
6715 
     - state
6716 
     - pin
6717 
    """
6718 
    self.send_changeShippingAddress(orderId, line1, line2, city, state, pin)
6719 
    return self.recv_changeShippingAddress()
6906 rajveer 6720 
 
6985 anupam.sin 6721 
  def send_changeShippingAddress(self, orderId, line1, line2, city, state, pin):
6722 
    self._oprot.writeMessageBegin('changeShippingAddress', TMessageType.CALL, self._seqid)
6723 
    args = changeShippingAddress_args()
6724 
    args.orderId = orderId
6725 
    args.line1 = line1
6726 
    args.line2 = line2
6727 
    args.city = city
6728 
    args.state = state
6729 
    args.pin = pin
6730 
    args.write(self._oprot)
6731 
    self._oprot.writeMessageEnd()
6732 
    self._oprot.trans.flush()
6733 
 
6734 
  def recv_changeShippingAddress(self, ):
6735 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6736 
    if mtype == TMessageType.EXCEPTION:
6737 
      x = TApplicationException()
6738 
      x.read(self._iprot)
6739 
      self._iprot.readMessageEnd()
6740 
      raise x
6741 
    result = changeShippingAddress_result()
6742 
    result.read(self._iprot)
6743 
    self._iprot.readMessageEnd()
6744 
    if result.success is not None:
6745 
      return result.success
6746 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "changeShippingAddress failed: unknown result");
6747 
 
7075 rajveer 6748 
  def retrieveInvoice(self, orderId, userId):
6988 rajveer 6749 
    """
6750 
    Parameters:
6751 
     - orderId
7075 rajveer 6752 
     - userId
6988 rajveer 6753 
    """
7075 rajveer 6754 
    self.send_retrieveInvoice(orderId, userId)
6988 rajveer 6755 
    return self.recv_retrieveInvoice()
6985 anupam.sin 6756 
 
7075 rajveer 6757 
  def send_retrieveInvoice(self, orderId, userId):
6988 rajveer 6758 
    self._oprot.writeMessageBegin('retrieveInvoice', TMessageType.CALL, self._seqid)
6759 
    args = retrieveInvoice_args()
6760 
    args.orderId = orderId
7075 rajveer 6761 
    args.userId = userId
6988 rajveer 6762 
    args.write(self._oprot)
6763 
    self._oprot.writeMessageEnd()
6764 
    self._oprot.trans.flush()
6765 
 
6766 
  def recv_retrieveInvoice(self, ):
6767 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6768 
    if mtype == TMessageType.EXCEPTION:
6769 
      x = TApplicationException()
6770 
      x.read(self._iprot)
6771 
      self._iprot.readMessageEnd()
6772 
      raise x
6773 
    result = retrieveInvoice_result()
6774 
    result.read(self._iprot)
6775 
    self._iprot.readMessageEnd()
6776 
    if result.success is not None:
6777 
      return result.success
6778 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "retrieveInvoice failed: unknown result");
6779 
 
7026 rajveer 6780 
  def receiveUpdatesForRedExpress(self, awbNumber):
6781 
    """
6782 
    Parameters:
6783 
     - awbNumber
6784 
    """
6785 
    self.send_receiveUpdatesForRedExpress(awbNumber)
6786 
    return self.recv_receiveUpdatesForRedExpress()
6988 rajveer 6787 
 
7026 rajveer 6788 
  def send_receiveUpdatesForRedExpress(self, awbNumber):
6789 
    self._oprot.writeMessageBegin('receiveUpdatesForRedExpress', TMessageType.CALL, self._seqid)
6790 
    args = receiveUpdatesForRedExpress_args()
6791 
    args.awbNumber = awbNumber
6792 
    args.write(self._oprot)
6793 
    self._oprot.writeMessageEnd()
6794 
    self._oprot.trans.flush()
6795 
 
6796 
  def recv_receiveUpdatesForRedExpress(self, ):
6797 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6798 
    if mtype == TMessageType.EXCEPTION:
6799 
      x = TApplicationException()
6800 
      x.read(self._iprot)
6801 
      self._iprot.readMessageEnd()
6802 
      raise x
6803 
    result = receiveUpdatesForRedExpress_result()
6804 
    result.read(self._iprot)
6805 
    self._iprot.readMessageEnd()
6806 
    if result.success is not None:
6807 
      return result.success
6808 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "receiveUpdatesForRedExpress failed: unknown result");
6809 
 
7073 anupam.sin 6810 
  def createRechargeTransaction(self, thriftRechargeTransaction):
6811 
    """
6812 
    Parameters:
6813 
     - thriftRechargeTransaction
6814 
    """
6815 
    self.send_createRechargeTransaction(thriftRechargeTransaction)
6816 
    return self.recv_createRechargeTransaction()
7026 rajveer 6817 
 
7073 anupam.sin 6818 
  def send_createRechargeTransaction(self, thriftRechargeTransaction):
6819 
    self._oprot.writeMessageBegin('createRechargeTransaction', TMessageType.CALL, self._seqid)
6820 
    args = createRechargeTransaction_args()
6821 
    args.thriftRechargeTransaction = thriftRechargeTransaction
6822 
    args.write(self._oprot)
6823 
    self._oprot.writeMessageEnd()
6824 
    self._oprot.trans.flush()
6825 
 
6826 
  def recv_createRechargeTransaction(self, ):
6827 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6828 
    if mtype == TMessageType.EXCEPTION:
6829 
      x = TApplicationException()
6830 
      x.read(self._iprot)
6831 
      self._iprot.readMessageEnd()
6832 
      raise x
6833 
    result = createRechargeTransaction_result()
6834 
    result.read(self._iprot)
6835 
    self._iprot.readMessageEnd()
6836 
    if result.success is not None:
6837 
      return result.success
6838 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createRechargeTransaction failed: unknown result");
6839 
 
7085 rajveer 6840 
  def getRechargeTransactions(self, storeId):
6841 
    """
6842 
    Parameters:
6843 
     - storeId
6844 
    """
6845 
    self.send_getRechargeTransactions(storeId)
6846 
    return self.recv_getRechargeTransactions()
6847 
 
6848 
  def send_getRechargeTransactions(self, storeId):
6849 
    self._oprot.writeMessageBegin('getRechargeTransactions', TMessageType.CALL, self._seqid)
6850 
    args = getRechargeTransactions_args()
6851 
    args.storeId = storeId
6852 
    args.write(self._oprot)
6853 
    self._oprot.writeMessageEnd()
6854 
    self._oprot.trans.flush()
6855 
 
6856 
  def recv_getRechargeTransactions(self, ):
6857 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6858 
    if mtype == TMessageType.EXCEPTION:
6859 
      x = TApplicationException()
6860 
      x.read(self._iprot)
6861 
      self._iprot.readMessageEnd()
6862 
      raise x
6863 
    result = getRechargeTransactions_result()
6864 
    result.read(self._iprot)
6865 
    self._iprot.readMessageEnd()
6866 
    if result.success is not None:
6867 
      return result.success
6868 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getRechargeTransactions failed: unknown result");
6869 
 
7080 anupam.sin 6870 
  def getRechargeTransaction(self, rechargeId):
6871 
    """
6872 
    Parameters:
6873 
     - rechargeId
6874 
    """
6875 
    self.send_getRechargeTransaction(rechargeId)
6876 
    return self.recv_getRechargeTransaction()
7073 anupam.sin 6877 
 
7080 anupam.sin 6878 
  def send_getRechargeTransaction(self, rechargeId):
6879 
    self._oprot.writeMessageBegin('getRechargeTransaction', TMessageType.CALL, self._seqid)
6880 
    args = getRechargeTransaction_args()
6881 
    args.rechargeId = rechargeId
6882 
    args.write(self._oprot)
6883 
    self._oprot.writeMessageEnd()
6884 
    self._oprot.trans.flush()
6885 
 
6886 
  def recv_getRechargeTransaction(self, ):
6887 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6888 
    if mtype == TMessageType.EXCEPTION:
6889 
      x = TApplicationException()
6890 
      x.read(self._iprot)
6891 
      self._iprot.readMessageEnd()
6892 
      raise x
6893 
    result = getRechargeTransaction_result()
6894 
    result.read(self._iprot)
6895 
    self._iprot.readMessageEnd()
6896 
    if result.success is not None:
6897 
      return result.success
6898 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getRechargeTransaction failed: unknown result");
6899 
 
6900 
  def getFRCs(self, circleId, operatorId):
6901 
    """
6902 
    Parameters:
6903 
     - circleId
6904 
     - operatorId
6905 
    """
6906 
    self.send_getFRCs(circleId, operatorId)
6907 
    return self.recv_getFRCs()
6908 
 
6909 
  def send_getFRCs(self, circleId, operatorId):
6910 
    self._oprot.writeMessageBegin('getFRCs', TMessageType.CALL, self._seqid)
6911 
    args = getFRCs_args()
6912 
    args.circleId = circleId
6913 
    args.operatorId = operatorId
6914 
    args.write(self._oprot)
6915 
    self._oprot.writeMessageEnd()
6916 
    self._oprot.trans.flush()
6917 
 
6918 
  def recv_getFRCs(self, ):
6919 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6920 
    if mtype == TMessageType.EXCEPTION:
6921 
      x = TApplicationException()
6922 
      x.read(self._iprot)
6923 
      self._iprot.readMessageEnd()
6924 
      raise x
6925 
    result = getFRCs_result()
6926 
    result.read(self._iprot)
6927 
    self._iprot.readMessageEnd()
6928 
    if result.success is not None:
6929 
      return result.success
6930 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getFRCs failed: unknown result");
6931 
 
7096 anupam.sin 6932 
  def getHotspotStore(self, id, hotspotid):
6933 
    """
6934 
    Parameters:
6935 
     - id
6936 
     - hotspotid
6937 
    """
6938 
    self.send_getHotspotStore(id, hotspotid)
6939 
    return self.recv_getHotspotStore()
7080 anupam.sin 6940 
 
7096 anupam.sin 6941 
  def send_getHotspotStore(self, id, hotspotid):
6942 
    self._oprot.writeMessageBegin('getHotspotStore', TMessageType.CALL, self._seqid)
6943 
    args = getHotspotStore_args()
6944 
    args.id = id
6945 
    args.hotspotid = hotspotid
6946 
    args.write(self._oprot)
6947 
    self._oprot.writeMessageEnd()
6948 
    self._oprot.trans.flush()
6949 
 
6950 
  def recv_getHotspotStore(self, ):
6951 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6952 
    if mtype == TMessageType.EXCEPTION:
6953 
      x = TApplicationException()
6954 
      x.read(self._iprot)
6955 
      self._iprot.readMessageEnd()
6956 
      raise x
6957 
    result = getHotspotStore_result()
6958 
    result.read(self._iprot)
6959 
    self._iprot.readMessageEnd()
6960 
    if result.success is not None:
6961 
      return result.success
6962 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getHotspotStore failed: unknown result");
6963 
 
6964 
  def getTelecomCircle(self, id, code):
6965 
    """
6966 
    Parameters:
6967 
     - id
6968 
     - code
6969 
    """
6970 
    self.send_getTelecomCircle(id, code)
6971 
    return self.recv_getTelecomCircle()
6972 
 
6973 
  def send_getTelecomCircle(self, id, code):
6974 
    self._oprot.writeMessageBegin('getTelecomCircle', TMessageType.CALL, self._seqid)
6975 
    args = getTelecomCircle_args()
6976 
    args.id = id
6977 
    args.code = code
6978 
    args.write(self._oprot)
6979 
    self._oprot.writeMessageEnd()
6980 
    self._oprot.trans.flush()
6981 
 
6982 
  def recv_getTelecomCircle(self, ):
6983 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6984 
    if mtype == TMessageType.EXCEPTION:
6985 
      x = TApplicationException()
6986 
      x.read(self._iprot)
6987 
      self._iprot.readMessageEnd()
6988 
      raise x
6989 
    result = getTelecomCircle_result()
6990 
    result.read(self._iprot)
6991 
    self._iprot.readMessageEnd()
6992 
    if result.success is not None:
6993 
      return result.success
6994 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTelecomCircle failed: unknown result");
6995 
 
7109 anupam.sin 6996 
  def retrieveHotspotRechargeInvoice(self, rechargeId):
6997 
    """
6998 
    Parameters:
6999 
     - rechargeId
7000 
    """
7001 
    self.send_retrieveHotspotRechargeInvoice(rechargeId)
7002 
    return self.recv_retrieveHotspotRechargeInvoice()
7096 anupam.sin 7003 
 
7109 anupam.sin 7004 
  def send_retrieveHotspotRechargeInvoice(self, rechargeId):
7005 
    self._oprot.writeMessageBegin('retrieveHotspotRechargeInvoice', TMessageType.CALL, self._seqid)
7006 
    args = retrieveHotspotRechargeInvoice_args()
7007 
    args.rechargeId = rechargeId
7008 
    args.write(self._oprot)
7009 
    self._oprot.writeMessageEnd()
7010 
    self._oprot.trans.flush()
7011 
 
7012 
  def recv_retrieveHotspotRechargeInvoice(self, ):
7013 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
7014 
    if mtype == TMessageType.EXCEPTION:
7015 
      x = TApplicationException()
7016 
      x.read(self._iprot)
7017 
      self._iprot.readMessageEnd()
7018 
      raise x
7019 
    result = retrieveHotspotRechargeInvoice_result()
7020 
    result.read(self._iprot)
7021 
    self._iprot.readMessageEnd()
7022 
    if result.success is not None:
7023 
      return result.success
7024 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "retrieveHotspotRechargeInvoice failed: unknown result");
7025 
 
7026 
 
3376 rajveer 7027 
class Processor(shop2020.thriftpy.generic.GenericService.Processor, Iface, TProcessor):
94 ashish 7028 
  def __init__(self, handler):
3376 rajveer 7029 
    shop2020.thriftpy.generic.GenericService.Processor.__init__(self, handler)
94 ashish 7030 
    self._processMap["createTransaction"] = Processor.process_createTransaction
7031 
    self._processMap["getTransaction"] = Processor.process_getTransaction
7032 
    self._processMap["getTransactionsForCustomer"] = Processor.process_getTransactionsForCustomer
132 ashish 7033 
    self._processMap["getTransactionsForShoppingCartId"] = Processor.process_getTransactionsForShoppingCartId
94 ashish 7034 
    self._processMap["getTransactionStatus"] = Processor.process_getTransactionStatus
7035 
    self._processMap["changeTransactionStatus"] = Processor.process_changeTransactionStatus
1398 varun.gupt 7036 
    self._processMap["enqueueTransactionInfoEmail"] = Processor.process_enqueueTransactionInfoEmail
483 rajveer 7037 
    self._processMap["getAllOrders"] = Processor.process_getAllOrders
4133 chandransh 7038 
    self._processMap["getOrdersInBatch"] = Processor.process_getOrdersInBatch
7039 
    self._processMap["getOrderCount"] = Processor.process_getOrderCount
999 varun.gupt 7040 
    self._processMap["getOrdersByBillingDate"] = Processor.process_getOrdersByBillingDate
3427 chandransh 7041 
    self._processMap["getOrdersByShippingDate"] = Processor.process_getOrdersByShippingDate
1382 varun.gupt 7042 
    self._processMap["getReturnableOrdersForCustomer"] = Processor.process_getReturnableOrdersForCustomer
7043 
    self._processMap["getCancellableOrdersForCustomer"] = Processor.process_getCancellableOrdersForCustomer
483 rajveer 7044 
    self._processMap["changeOrderStatus"] = Processor.process_changeOrderStatus
7045 
    self._processMap["getOrdersForTransaction"] = Processor.process_getOrdersForTransaction
7046 
    self._processMap["getOrdersForCustomer"] = Processor.process_getOrdersForCustomer
7047 
    self._processMap["createOrder"] = Processor.process_createOrder
7048 
    self._processMap["getOrder"] = Processor.process_getOrder
7049 
    self._processMap["getLineItemsForOrder"] = Processor.process_getLineItemsForOrder
4999 phani.kuma 7050 
    self._processMap["getOrderList"] = Processor.process_getOrderList
5386 phani.kuma 7051 
    self._processMap["getOrderListForVendor"] = Processor.process_getOrderListForVendor
1528 ankur.sing 7052 
    self._processMap["getOrderForCustomer"] = Processor.process_getOrderForCustomer
3064 chandransh 7053 
    self._processMap["getAlerts"] = Processor.process_getAlerts
4394 rajveer 7054 
    self._processMap["addAlert"] = Processor.process_addAlert
4444 rajveer 7055 
    self._processMap["markAlertsAsSeen"] = Processor.process_markAlertsAsSeen
3064 chandransh 7056 
    self._processMap["getValidOrderCount"] = Processor.process_getValidOrderCount
7057 
    self._processMap["getNoOfCustomersWithSuccessfulTransaction"] = Processor.process_getNoOfCustomersWithSuccessfulTransaction
7058 
    self._processMap["getValidOrdersAmountRange"] = Processor.process_getValidOrdersAmountRange
7059 
    self._processMap["getValidOrders"] = Processor.process_getValidOrders
1220 chandransh 7060 
    self._processMap["batchOrders"] = Processor.process_batchOrders
1208 chandransh 7061 
    self._processMap["markOrderAsOutOfStock"] = Processor.process_markOrderAsOutOfStock
3064 chandransh 7062 
    self._processMap["verifyOrder"] = Processor.process_verifyOrder
7063 
    self._processMap["acceptOrder"] = Processor.process_acceptOrder
7064 
    self._processMap["addBillingDetails"] = Processor.process_addBillingDetails
4579 rajveer 7065 
    self._processMap["addInvoiceNumber"] = Processor.process_addInvoiceNumber
4410 rajveer 7066 
    self._processMap["markOrdersAsShippedFromWarehouse"] = Processor.process_markOrdersAsShippedFromWarehouse
5676 rajveer 7067 
    self._processMap["markOrdersAsReturnedFromStore"] = Processor.process_markOrdersAsReturnedFromStore
1113 chandransh 7068 
    self._processMap["markOrdersAsPickedUp"] = Processor.process_markOrdersAsPickedUp
4910 phani.kuma 7069 
    self._processMap["getOrdersNotPickedUp"] = Processor.process_getOrdersNotPickedUp
1132 chandransh 7070 
    self._processMap["markOrdersAsDelivered"] = Processor.process_markOrdersAsDelivered
4910 phani.kuma 7071 
    self._processMap["markAsRTOrders"] = Processor.process_markAsRTOrders
7072 
    self._processMap["getRTOrders"] = Processor.process_getRTOrders
1246 chandransh 7073 
    self._processMap["updateNonDeliveryReason"] = Processor.process_updateNonDeliveryReason
4910 phani.kuma 7074 
    self._processMap["getNonDeliveredOrdersbyCourier"] = Processor.process_getNonDeliveredOrdersbyCourier
7075 
    self._processMap["markOrdersAsLocalConnected"] = Processor.process_markOrdersAsLocalConnected
7076 
    self._processMap["getOrdersNotLocalConnected"] = Processor.process_getOrdersNotLocalConnected
7077 
    self._processMap["markOrdersAsDestinationCityReached"] = Processor.process_markOrdersAsDestinationCityReached
7078 
    self._processMap["markOrdersAsFirstDeliveryAttempted"] = Processor.process_markOrdersAsFirstDeliveryAttempted
1408 ankur.sing 7079 
    self._processMap["getUndeliveredOrders"] = Processor.process_getUndeliveredOrders
4783 phani.kuma 7080 
    self._processMap["getUndeliveredOrdersExpectedDeliveryDateNotMet"] = Processor.process_getUndeliveredOrdersExpectedDeliveryDateNotMet
2536 chandransh 7081 
    self._processMap["toggleDOAFlag"] = Processor.process_toggleDOAFlag
4712 rajveer 7082 
    self._processMap["markOrderAsDelivered"] = Processor.process_markOrderAsDelivered
5553 rajveer 7083 
    self._processMap["markOrderAsReceivedAtStore"] = Processor.process_markOrderAsReceivedAtStore
4454 rajveer 7084 
    self._processMap["markOrderDoaRequestReceived"] = Processor.process_markOrderDoaRequestReceived
7085 
    self._processMap["markOrderDoaRequestAuthorized"] = Processor.process_markOrderDoaRequestAuthorized
4488 rajveer 7086 
    self._processMap["markOrderReturnRequestReceived"] = Processor.process_markOrderReturnRequestReceived
7087 
    self._processMap["markOrderReturnRequestAuthorized"] = Processor.process_markOrderReturnRequestAuthorized
2536 chandransh 7088 
    self._processMap["requestPickupNumber"] = Processor.process_requestPickupNumber
7089 
    self._processMap["authorizePickup"] = Processor.process_authorizePickup
2764 chandransh 7090 
    self._processMap["markDoasAsPickedUp"] = Processor.process_markDoasAsPickedUp
4910 phani.kuma 7091 
    self._processMap["getDoasNotPickedUp"] = Processor.process_getDoasNotPickedUp
4741 phani.kuma 7092 
    self._processMap["markReturnOrdersAsPickedUp"] = Processor.process_markReturnOrdersAsPickedUp
4910 phani.kuma 7093 
    self._processMap["getReturnOrdersNotPickedUp"] = Processor.process_getReturnOrdersNotPickedUp
2616 chandransh 7094 
    self._processMap["receiveReturn"] = Processor.process_receiveReturn
2591 chandransh 7095 
    self._processMap["validateDoa"] = Processor.process_validateDoa
4495 rajveer 7096 
    self._processMap["validateReturnProduct"] = Processor.process_validateReturnProduct
2616 chandransh 7097 
    self._processMap["reshipOrder"] = Processor.process_reshipOrder
7098 
    self._processMap["refundOrder"] = Processor.process_refundOrder
2690 chandransh 7099 
    self._processMap["getReturnOrders"] = Processor.process_getReturnOrders
5481 phani.kuma 7100 
    self._processMap["getAllReturnOrders"] = Processor.process_getAllReturnOrders
2700 chandransh 7101 
    self._processMap["getReturnOrder"] = Processor.process_getReturnOrder
2690 chandransh 7102 
    self._processMap["processReturn"] = Processor.process_processReturn
3451 chandransh 7103 
    self._processMap["updateWeight"] = Processor.process_updateWeight
3469 chandransh 7104 
    self._processMap["changeItem"] = Processor.process_changeItem
7105 
    self._processMap["shiftToWarehouse"] = Processor.process_shiftToWarehouse
3553 chandransh 7106 
    self._processMap["addDelayReason"] = Processor.process_addDelayReason
3956 chandransh 7107 
    self._processMap["reconcileCodCollection"] = Processor.process_reconcileCodCollection
4008 mandeep.dh 7108 
    self._processMap["getTransactionsRequiringExtraProcessing"] = Processor.process_getTransactionsRequiringExtraProcessing
7109 
    self._processMap["markTransactionAsProcessed"] = Processor.process_markTransactionAsProcessed
4018 chandransh 7110 
    self._processMap["getItemWiseRiskyOrdersCount"] = Processor.process_getItemWiseRiskyOrdersCount
4295 varun.gupt 7111 
    self._processMap["getOrdersForItemIds"] = Processor.process_getOrdersForItemIds
4247 rajveer 7112 
    self._processMap["markOrderCancellationRequestReceived"] = Processor.process_markOrderCancellationRequestReceived
7113 
    self._processMap["markOrderCancellationRequestConfirmed"] = Processor.process_markOrderCancellationRequestConfirmed
7114 
    self._processMap["markOrderCancellationRequestDenied"] = Processor.process_markOrderCancellationRequestDenied
4258 rajveer 7115 
    self._processMap["markTransactionAsPaymentFlagRemoved"] = Processor.process_markTransactionAsPaymentFlagRemoved
4259 anupam.sin 7116 
    self._processMap["refundTransaction"] = Processor.process_refundTransaction
4324 mandeep.dh 7117 
    self._processMap["updateShipmentAddress"] = Processor.process_updateShipmentAddress
4285 rajveer 7118 
    self._processMap["acceptOrdersForItemId"] = Processor.process_acceptOrdersForItemId
4303 rajveer 7119 
    self._processMap["markOrdersAsPORaised"] = Processor.process_markOrdersAsPORaised
7120 
    self._processMap["markOrdersAsReversalInitiated"] = Processor.process_markOrdersAsReversalInitiated
7121 
    self._processMap["markOrdersAsNotAvailabke"] = Processor.process_markOrdersAsNotAvailabke
4369 rajveer 7122 
    self._processMap["markOrdersAsTimeout"] = Processor.process_markOrdersAsTimeout
4662 rajveer 7123 
    self._processMap["markOrderAsLostInTransit"] = Processor.process_markOrderAsLostInTransit
4386 anupam.sin 7124 
    self._processMap["getOrderForAwb"] = Processor.process_getOrderForAwb
4506 phani.kuma 7125 
    self._processMap["getOrdersForProviderForStatus"] = Processor.process_getOrdersForProviderForStatus
4600 varun.gupt 7126 
    self._processMap["getBilledOrdersForVendor"] = Processor.process_getBilledOrdersForVendor
4607 rajveer 7127 
    self._processMap["getSlippedSippingDateOrders"] = Processor.process_getSlippedSippingDateOrders
4709 rajveer 7128 
    self._processMap["getCancelledOrders"] = Processor.process_getCancelledOrders
4600 varun.gupt 7129 
    self._processMap["saveBluedartSettlements"] = Processor.process_saveBluedartSettlements
7130 
    self._processMap["savePaymentSettlements"] = Processor.process_savePaymentSettlements
7131 
    self._processMap["saveEBSSettlementSummary"] = Processor.process_saveEBSSettlementSummary
5386 phani.kuma 7132 
    self._processMap["getSettlementForPrepaid"] = Processor.process_getSettlementForPrepaid
7133 
    self._processMap["getSettlementForCod"] = Processor.process_getSettlementForCod
4600 varun.gupt 7134 
    self._processMap["getEBSSettlementSummaries"] = Processor.process_getEBSSettlementSummaries
7135 
    self._processMap["markEBSSettlementUploaded"] = Processor.process_markEBSSettlementUploaded
7136 
    self._processMap["getEBSSettlementDate"] = Processor.process_getEBSSettlementDate
4715 varun.gupt 7137 
    self._processMap["getSettlementsByDate"] = Processor.process_getSettlementsByDate
7138 
    self._processMap["getReshippedOrderIds"] = Processor.process_getReshippedOrderIds
5481 phani.kuma 7139 
    self._processMap["getBilledOrders"] = Processor.process_getBilledOrders
5031 varun.gupt 7140 
    self._processMap["getStatusDistributionOfOrders"] = Processor.process_getStatusDistributionOfOrders
5067 varun.gupt 7141 
    self._processMap["getOrderIdsForStatus"] = Processor.process_getOrderIdsForStatus
5348 anupam.sin 7142 
    self._processMap["updateCODAgent"] = Processor.process_updateCODAgent
5099 varun.gupt 7143 
    self._processMap["updateOrderAsPaidToVendor"] = Processor.process_updateOrderAsPaidToVendor
5386 phani.kuma 7144 
    self._processMap["updateOrderOnlyAsPaidToVendor"] = Processor.process_updateOrderOnlyAsPaidToVendor
5208 varun.gupt 7145 
    self._processMap["getRefundedOrdersMarkedPaid"] = Processor.process_getRefundedOrdersMarkedPaid
5447 anupam.sin 7146 
    self._processMap["getAllVerificationAgents"] = Processor.process_getAllVerificationAgents
5527 anupam.sin 7147 
    self._processMap["getAllAttributesForOrderId"] = Processor.process_getAllAttributesForOrderId
5676 rajveer 7148 
    self._processMap["setOrderAttributes"] = Processor.process_setOrderAttributes
5527 anupam.sin 7149 
    self._processMap["setOrderAttributeForTransaction"] = Processor.process_setOrderAttributeForTransaction
5553 rajveer 7150 
    self._processMap["getReceivePendingOrders"] = Processor.process_getReceivePendingOrders
7151 
    self._processMap["getReceivedAtStoreOrders"] = Processor.process_getReceivedAtStoreOrders
5713 rajveer 7152 
    self._processMap["getOrdersCollectionAtStore"] = Processor.process_getOrdersCollectionAtStore
5833 rajveer 7153 
    self._processMap["getOrderAttributeValue"] = Processor.process_getOrderAttributeValue
6019 rajveer 7154 
    self._processMap["changeJacketNumber"] = Processor.process_changeJacketNumber
7155 
    self._processMap["markOrderAsRtoInTransit"] = Processor.process_markOrderAsRtoInTransit
5593 mandeep.dh 7156 
    self._processMap["acceptOrderForItem"] = Processor.process_acceptOrderForItem
6000 mandeep.dh 7157 
    self._processMap["createRechargeOrder"] = Processor.process_createRechargeOrder
6031 rajveer 7158 
    self._processMap["getRechargeOrder"] = Processor.process_getRechargeOrder
7159 
    self._processMap["getRechargeOrders"] = Processor.process_getRechargeOrders
6000 mandeep.dh 7160 
    self._processMap["updateRechargeOrderStatus"] = Processor.process_updateRechargeOrderStatus
7161 
    self._processMap["activateRechargeTxn"] = Processor.process_activateRechargeTxn
6031 rajveer 7162 
    self._processMap["getUserWallet"] = Processor.process_getUserWallet
7163 
    self._processMap["getUserWalletHistory"] = Processor.process_getUserWalletHistory
6050 anupam.sin 7164 
    self._processMap["getRechargeOrdersForTransaction"] = Processor.process_getRechargeOrdersForTransaction
6048 rajveer 7165 
    self._processMap["getServiceProviders"] = Processor.process_getServiceProviders
7166 
    self._processMap["getServiceProviderForDevice"] = Processor.process_getServiceProviderForDevice
6269 rajveer 7167 
    self._processMap["validateRecharge"] = Processor.process_validateRecharge
6094 rajveer 7168 
    self._processMap["getRechargeOrdersForDevice"] = Processor.process_getRechargeOrdersForDevice
7169 
    self._processMap["addAmountToWallet"] = Processor.process_addAmountToWallet
6188 rajveer 7170 
    self._processMap["getRechargeStatistics"] = Processor.process_getRechargeStatistics
6154 rajveer 7171 
    self._processMap["getRechargeOrdersForStatus"] = Processor.process_getRechargeOrdersForStatus
6159 rajveer 7172 
    self._processMap["getPlansForOperator"] = Processor.process_getPlansForOperator
6289 anupam.sin 7173 
    self._processMap["getRechargeDenominations"] = Processor.process_getRechargeDenominations
6371 rajveer 7174 
    self._processMap["updateAvailabilityStatus"] = Processor.process_updateAvailabilityStatus
6389 rajveer 7175 
    self._processMap["getAvailableEmiSchemes"] = Processor.process_getAvailableEmiSchemes
7176 
    self._processMap["getMiscCharges"] = Processor.process_getMiscCharges
6507 anupam.sin 7177 
    self._processMap["refundRechargeOrder"] = Processor.process_refundRechargeOrder
6821 amar.kumar 7178 
    self._processMap["getPhysicalOrders"] = Processor.process_getPhysicalOrders
6906 rajveer 7179 
    self._processMap["getDocument"] = Processor.process_getDocument
6985 anupam.sin 7180 
    self._processMap["changeShippingAddress"] = Processor.process_changeShippingAddress
6988 rajveer 7181 
    self._processMap["retrieveInvoice"] = Processor.process_retrieveInvoice
7026 rajveer 7182 
    self._processMap["receiveUpdatesForRedExpress"] = Processor.process_receiveUpdatesForRedExpress
7073 anupam.sin 7183 
    self._processMap["createRechargeTransaction"] = Processor.process_createRechargeTransaction
7085 rajveer 7184 
    self._processMap["getRechargeTransactions"] = Processor.process_getRechargeTransactions
7080 anupam.sin 7185 
    self._processMap["getRechargeTransaction"] = Processor.process_getRechargeTransaction
7186 
    self._processMap["getFRCs"] = Processor.process_getFRCs
7096 anupam.sin 7187 
    self._processMap["getHotspotStore"] = Processor.process_getHotspotStore
7188 
    self._processMap["getTelecomCircle"] = Processor.process_getTelecomCircle
7109 anupam.sin 7189 
    self._processMap["retrieveHotspotRechargeInvoice"] = Processor.process_retrieveHotspotRechargeInvoice
94 ashish 7190 
 
7191 
  def process(self, iprot, oprot):
7192 
    (name, type, seqid) = iprot.readMessageBegin()
7193 
    if name not in self._processMap:
7194 
      iprot.skip(TType.STRUCT)
7195 
      iprot.readMessageEnd()
7196 
      x = TApplicationException(TApplicationException.UNKNOWN_METHOD, 'Unknown function %s' % (name))
7197 
      oprot.writeMessageBegin(name, TMessageType.EXCEPTION, seqid)
7198 
      x.write(oprot)
7199 
      oprot.writeMessageEnd()
7200 
      oprot.trans.flush()
7201 
      return
7202 
    else:
7203 
      self._processMap[name](self, seqid, iprot, oprot)
7204 
    return True
7205 
 
7206 
  def process_createTransaction(self, seqid, iprot, oprot):
7207 
    args = createTransaction_args()
7208 
    args.read(iprot)
7209 
    iprot.readMessageEnd()
7210 
    result = createTransaction_result()
7211 
    try:
132 ashish 7212 
      result.success = self._handler.createTransaction(args.transaction)
94 ashish 7213 
    except TransactionServiceException, ex:
7214 
      result.ex = ex
7215 
    oprot.writeMessageBegin("createTransaction", TMessageType.REPLY, seqid)
7216 
    result.write(oprot)
7217 
    oprot.writeMessageEnd()
7218 
    oprot.trans.flush()
7219 
 
7220 
  def process_getTransaction(self, seqid, iprot, oprot):
7221 
    args = getTransaction_args()
7222 
    args.read(iprot)
7223 
    iprot.readMessageEnd()
7224 
    result = getTransaction_result()
7225 
    try:
7226 
      result.success = self._handler.getTransaction(args.id)
7227 
    except TransactionServiceException, ex:
7228 
      result.ex = ex
7229 
    oprot.writeMessageBegin("getTransaction", TMessageType.REPLY, seqid)
7230 
    result.write(oprot)
7231 
    oprot.writeMessageEnd()
7232 
    oprot.trans.flush()
7233 
 
7234 
  def process_getTransactionsForCustomer(self, seqid, iprot, oprot):
7235 
    args = getTransactionsForCustomer_args()
7236 
    args.read(iprot)
7237 
    iprot.readMessageEnd()
7238 
    result = getTransactionsForCustomer_result()
7239 
    try:
7240 
      result.success = self._handler.getTransactionsForCustomer(args.customerId, args.from_date, args.to_date, args.status)
7241 
    except TransactionServiceException, ex:
7242 
      result.ex = ex
7243 
    oprot.writeMessageBegin("getTransactionsForCustomer", TMessageType.REPLY, seqid)
7244 
    result.write(oprot)
7245 
    oprot.writeMessageEnd()
7246 
    oprot.trans.flush()
7247 
 
132 ashish 7248 
  def process_getTransactionsForShoppingCartId(self, seqid, iprot, oprot):
7249 
    args = getTransactionsForShoppingCartId_args()
7250 
    args.read(iprot)
7251 
    iprot.readMessageEnd()
7252 
    result = getTransactionsForShoppingCartId_result()
7253 
    try:
7254 
      result.success = self._handler.getTransactionsForShoppingCartId(args.shoppingCartId)
7255 
    except TransactionServiceException, ex:
7256 
      result.ex = ex
7257 
    oprot.writeMessageBegin("getTransactionsForShoppingCartId", TMessageType.REPLY, seqid)
7258 
    result.write(oprot)
7259 
    oprot.writeMessageEnd()
7260 
    oprot.trans.flush()
7261 
 
94 ashish 7262 
  def process_getTransactionStatus(self, seqid, iprot, oprot):
7263 
    args = getTransactionStatus_args()
7264 
    args.read(iprot)
7265 
    iprot.readMessageEnd()
7266 
    result = getTransactionStatus_result()
7267 
    try:
7268 
      result.success = self._handler.getTransactionStatus(args.transactionId)
7269 
    except TransactionServiceException, ex:
7270 
      result.ex = ex
7271 
    oprot.writeMessageBegin("getTransactionStatus", TMessageType.REPLY, seqid)
7272 
    result.write(oprot)
7273 
    oprot.writeMessageEnd()
7274 
    oprot.trans.flush()
7275 
 
7276 
  def process_changeTransactionStatus(self, seqid, iprot, oprot):
7277 
    args = changeTransactionStatus_args()
7278 
    args.read(iprot)
7279 
    iprot.readMessageEnd()
7280 
    result = changeTransactionStatus_result()
7281 
    try:
5527 anupam.sin 7282 
      result.success = self._handler.changeTransactionStatus(args.transactionId, args.status, args.description, args.pickUp, args.orderType)
94 ashish 7283 
    except TransactionServiceException, ex:
7284 
      result.ex = ex
7285 
    oprot.writeMessageBegin("changeTransactionStatus", TMessageType.REPLY, seqid)
7286 
    result.write(oprot)
7287 
    oprot.writeMessageEnd()
7288 
    oprot.trans.flush()
7289 
 
1398 varun.gupt 7290 
  def process_enqueueTransactionInfoEmail(self, seqid, iprot, oprot):
7291 
    args = enqueueTransactionInfoEmail_args()
1382 varun.gupt 7292 
    args.read(iprot)
7293 
    iprot.readMessageEnd()
1398 varun.gupt 7294 
    result = enqueueTransactionInfoEmail_result()
1382 varun.gupt 7295 
    try:
1398 varun.gupt 7296 
      result.success = self._handler.enqueueTransactionInfoEmail(args.transactionId)
1382 varun.gupt 7297 
    except TransactionServiceException, ex:
7298 
      result.ex = ex
1398 varun.gupt 7299 
    oprot.writeMessageBegin("enqueueTransactionInfoEmail", TMessageType.REPLY, seqid)
1382 varun.gupt 7300 
    result.write(oprot)
7301 
    oprot.writeMessageEnd()
7302 
    oprot.trans.flush()
7303 
 
483 rajveer 7304 
  def process_getAllOrders(self, seqid, iprot, oprot):
7305 
    args = getAllOrders_args()
94 ashish 7306 
    args.read(iprot)
7307 
    iprot.readMessageEnd()
483 rajveer 7308 
    result = getAllOrders_result()
94 ashish 7309 
    try:
4801 anupam.sin 7310 
      result.success = self._handler.getAllOrders(args.statuses, args.from_date, args.to_date, args.warehouse_id)
94 ashish 7311 
    except TransactionServiceException, ex:
7312 
      result.ex = ex
483 rajveer 7313 
    oprot.writeMessageBegin("getAllOrders", TMessageType.REPLY, seqid)
94 ashish 7314 
    result.write(oprot)
7315 
    oprot.writeMessageEnd()
7316 
    oprot.trans.flush()
7317 
 
4133 chandransh 7318 
  def process_getOrdersInBatch(self, seqid, iprot, oprot):
7319 
    args = getOrdersInBatch_args()
7320 
    args.read(iprot)
7321 
    iprot.readMessageEnd()
7322 
    result = getOrdersInBatch_result()
7323 
    try:
7324 
      result.success = self._handler.getOrdersInBatch(args.statuses, args.offset, args.limit, args.warehouse_id)
7325 
    except TransactionServiceException, ex:
7326 
      result.ex = ex
7327 
    oprot.writeMessageBegin("getOrdersInBatch", TMessageType.REPLY, seqid)
7328 
    result.write(oprot)
7329 
    oprot.writeMessageEnd()
7330 
    oprot.trans.flush()
7331 
 
7332 
  def process_getOrderCount(self, seqid, iprot, oprot):
7333 
    args = getOrderCount_args()
7334 
    args.read(iprot)
7335 
    iprot.readMessageEnd()
7336 
    result = getOrderCount_result()
7337 
    try:
7338 
      result.success = self._handler.getOrderCount(args.statuses, args.warehouseId)
7339 
    except TransactionServiceException, ex:
7340 
      result.ex = ex
7341 
    oprot.writeMessageBegin("getOrderCount", TMessageType.REPLY, seqid)
7342 
    result.write(oprot)
7343 
    oprot.writeMessageEnd()
7344 
    oprot.trans.flush()
7345 
 
999 varun.gupt 7346 
  def process_getOrdersByBillingDate(self, seqid, iprot, oprot):
7347 
    args = getOrdersByBillingDate_args()
7348 
    args.read(iprot)
7349 
    iprot.readMessageEnd()
7350 
    result = getOrdersByBillingDate_result()
7351 
    try:
7352 
      result.success = self._handler.getOrdersByBillingDate(args.status, args.start_billing_date, args.end_billing_date, args.warehouse_id)
7353 
    except TransactionServiceException, ex:
7354 
      result.ex = ex
7355 
    oprot.writeMessageBegin("getOrdersByBillingDate", TMessageType.REPLY, seqid)
7356 
    result.write(oprot)
7357 
    oprot.writeMessageEnd()
7358 
    oprot.trans.flush()
7359 
 
3427 chandransh 7360 
  def process_getOrdersByShippingDate(self, seqid, iprot, oprot):
7361 
    args = getOrdersByShippingDate_args()
7362 
    args.read(iprot)
7363 
    iprot.readMessageEnd()
7364 
    result = getOrdersByShippingDate_result()
7365 
    try:
3451 chandransh 7366 
      result.success = self._handler.getOrdersByShippingDate(args.fromShippingDate, args.toShippingDate, args.providerId, args.warehouseId, args.cod)
3427 chandransh 7367 
    except TransactionServiceException, ex:
7368 
      result.ex = ex
7369 
    oprot.writeMessageBegin("getOrdersByShippingDate", TMessageType.REPLY, seqid)
7370 
    result.write(oprot)
7371 
    oprot.writeMessageEnd()
7372 
    oprot.trans.flush()
7373 
 
1382 varun.gupt 7374 
  def process_getReturnableOrdersForCustomer(self, seqid, iprot, oprot):
7375 
    args = getReturnableOrdersForCustomer_args()
7376 
    args.read(iprot)
7377 
    iprot.readMessageEnd()
7378 
    result = getReturnableOrdersForCustomer_result()
7379 
    try:
7380 
      result.success = self._handler.getReturnableOrdersForCustomer(args.customer_id, args.limit)
7381 
    except TransactionServiceException, ex:
7382 
      result.ex = ex
7383 
    oprot.writeMessageBegin("getReturnableOrdersForCustomer", TMessageType.REPLY, seqid)
7384 
    result.write(oprot)
7385 
    oprot.writeMessageEnd()
7386 
    oprot.trans.flush()
7387 
 
7388 
  def process_getCancellableOrdersForCustomer(self, seqid, iprot, oprot):
7389 
    args = getCancellableOrdersForCustomer_args()
7390 
    args.read(iprot)
7391 
    iprot.readMessageEnd()
7392 
    result = getCancellableOrdersForCustomer_result()
7393 
    try:
7394 
      result.success = self._handler.getCancellableOrdersForCustomer(args.customer_id, args.limit)
7395 
    except TransactionServiceException, ex:
7396 
      result.ex = ex
7397 
    oprot.writeMessageBegin("getCancellableOrdersForCustomer", TMessageType.REPLY, seqid)
7398 
    result.write(oprot)
7399 
    oprot.writeMessageEnd()
7400 
    oprot.trans.flush()
7401 
 
483 rajveer 7402 
  def process_changeOrderStatus(self, seqid, iprot, oprot):
7403 
    args = changeOrderStatus_args()
94 ashish 7404 
    args.read(iprot)
7405 
    iprot.readMessageEnd()
483 rajveer 7406 
    result = changeOrderStatus_result()
94 ashish 7407 
    try:
483 rajveer 7408 
      result.success = self._handler.changeOrderStatus(args.orderId, args.status, args.description)
94 ashish 7409 
    except TransactionServiceException, ex:
7410 
      result.ex = ex
483 rajveer 7411 
    oprot.writeMessageBegin("changeOrderStatus", TMessageType.REPLY, seqid)
94 ashish 7412 
    result.write(oprot)
7413 
    oprot.writeMessageEnd()
7414 
    oprot.trans.flush()
7415 
 
483 rajveer 7416 
  def process_getOrdersForTransaction(self, seqid, iprot, oprot):
7417 
    args = getOrdersForTransaction_args()
94 ashish 7418 
    args.read(iprot)
7419 
    iprot.readMessageEnd()
483 rajveer 7420 
    result = getOrdersForTransaction_result()
94 ashish 7421 
    try:
1528 ankur.sing 7422 
      result.success = self._handler.getOrdersForTransaction(args.transactionId, args.customerId)
94 ashish 7423 
    except TransactionServiceException, ex:
7424 
      result.ex = ex
483 rajveer 7425 
    oprot.writeMessageBegin("getOrdersForTransaction", TMessageType.REPLY, seqid)
94 ashish 7426 
    result.write(oprot)
7427 
    oprot.writeMessageEnd()
7428 
    oprot.trans.flush()
7429 
 
483 rajveer 7430 
  def process_getOrdersForCustomer(self, seqid, iprot, oprot):
7431 
    args = getOrdersForCustomer_args()
94 ashish 7432 
    args.read(iprot)
7433 
    iprot.readMessageEnd()
483 rajveer 7434 
    result = getOrdersForCustomer_result()
94 ashish 7435 
    try:
3014 chandransh 7436 
      result.success = self._handler.getOrdersForCustomer(args.customerId, args.from_date, args.to_date, args.statuses)
94 ashish 7437 
    except TransactionServiceException, ex:
7438 
      result.ex = ex
483 rajveer 7439 
    oprot.writeMessageBegin("getOrdersForCustomer", TMessageType.REPLY, seqid)
94 ashish 7440 
    result.write(oprot)
7441 
    oprot.writeMessageEnd()
7442 
    oprot.trans.flush()
7443 
 
483 rajveer 7444 
  def process_createOrder(self, seqid, iprot, oprot):
7445 
    args = createOrder_args()
94 ashish 7446 
    args.read(iprot)
7447 
    iprot.readMessageEnd()
483 rajveer 7448 
    result = createOrder_result()
94 ashish 7449 
    try:
483 rajveer 7450 
      result.success = self._handler.createOrder(args.order)
94 ashish 7451 
    except TransactionServiceException, ex:
7452 
      result.ex = ex
483 rajveer 7453 
    oprot.writeMessageBegin("createOrder", TMessageType.REPLY, seqid)
94 ashish 7454 
    result.write(oprot)
7455 
    oprot.writeMessageEnd()
7456 
    oprot.trans.flush()
7457 
 
483 rajveer 7458 
  def process_getOrder(self, seqid, iprot, oprot):
7459 
    args = getOrder_args()
94 ashish 7460 
    args.read(iprot)
7461 
    iprot.readMessageEnd()
483 rajveer 7462 
    result = getOrder_result()
94 ashish 7463 
    try:
483 rajveer 7464 
      result.success = self._handler.getOrder(args.id)
94 ashish 7465 
    except TransactionServiceException, ex:
7466 
      result.ex = ex
483 rajveer 7467 
    oprot.writeMessageBegin("getOrder", TMessageType.REPLY, seqid)
94 ashish 7468 
    result.write(oprot)
7469 
    oprot.writeMessageEnd()
7470 
    oprot.trans.flush()
7471 
 
483 rajveer 7472 
  def process_getLineItemsForOrder(self, seqid, iprot, oprot):
7473 
    args = getLineItemsForOrder_args()
94 ashish 7474 
    args.read(iprot)
7475 
    iprot.readMessageEnd()
483 rajveer 7476 
    result = getLineItemsForOrder_result()
94 ashish 7477 
    try:
483 rajveer 7478 
      result.success = self._handler.getLineItemsForOrder(args.orderId)
94 ashish 7479 
    except TransactionServiceException, ex:
7480 
      result.ex = ex
483 rajveer 7481 
    oprot.writeMessageBegin("getLineItemsForOrder", TMessageType.REPLY, seqid)
94 ashish 7482 
    result.write(oprot)
7483 
    oprot.writeMessageEnd()
7484 
    oprot.trans.flush()
7485 
 
4999 phani.kuma 7486 
  def process_getOrderList(self, seqid, iprot, oprot):
7487 
    args = getOrderList_args()
7488 
    args.read(iprot)
7489 
    iprot.readMessageEnd()
7490 
    result = getOrderList_result()
7491 
    result.success = self._handler.getOrderList(args.order_ids)
7492 
    oprot.writeMessageBegin("getOrderList", TMessageType.REPLY, seqid)
7493 
    result.write(oprot)
7494 
    oprot.writeMessageEnd()
7495 
    oprot.trans.flush()
7496 
 
5386 phani.kuma 7497 
  def process_getOrderListForVendor(self, seqid, iprot, oprot):
7498 
    args = getOrderListForVendor_args()
7499 
    args.read(iprot)
7500 
    iprot.readMessageEnd()
7501 
    result = getOrderListForVendor_result()
7502 
    result.success = self._handler.getOrderListForVendor(args.order_ids, args.vendorId)
7503 
    oprot.writeMessageBegin("getOrderListForVendor", TMessageType.REPLY, seqid)
7504 
    result.write(oprot)
7505 
    oprot.writeMessageEnd()
7506 
    oprot.trans.flush()
7507 
 
1528 ankur.sing 7508 
  def process_getOrderForCustomer(self, seqid, iprot, oprot):
7509 
    args = getOrderForCustomer_args()
7510 
    args.read(iprot)
7511 
    iprot.readMessageEnd()
7512 
    result = getOrderForCustomer_result()
7513 
    try:
7514 
      result.success = self._handler.getOrderForCustomer(args.orderId, args.customerId)
7515 
    except TransactionServiceException, ex:
7516 
      result.ex = ex
7517 
    oprot.writeMessageBegin("getOrderForCustomer", TMessageType.REPLY, seqid)
7518 
    result.write(oprot)
7519 
    oprot.writeMessageEnd()
7520 
    oprot.trans.flush()
7521 
 
3064 chandransh 7522 
  def process_getAlerts(self, seqid, iprot, oprot):
7523 
    args = getAlerts_args()
7524 
    args.read(iprot)
7525 
    iprot.readMessageEnd()
7526 
    result = getAlerts_result()
4444 rajveer 7527 
    result.success = self._handler.getAlerts(args.type, args.warehouseId, args.status, args.timestamp)
3064 chandransh 7528 
    oprot.writeMessageBegin("getAlerts", TMessageType.REPLY, seqid)
7529 
    result.write(oprot)
7530 
    oprot.writeMessageEnd()
7531 
    oprot.trans.flush()
7532 
 
4394 rajveer 7533 
  def process_addAlert(self, seqid, iprot, oprot):
7534 
    args = addAlert_args()
3064 chandransh 7535 
    args.read(iprot)
7536 
    iprot.readMessageEnd()
4394 rajveer 7537 
    result = addAlert_result()
4444 rajveer 7538 
    self._handler.addAlert(args.type, args.warehouseId, args.description)
4394 rajveer 7539 
    oprot.writeMessageBegin("addAlert", TMessageType.REPLY, seqid)
3064 chandransh 7540 
    result.write(oprot)
7541 
    oprot.writeMessageEnd()
7542 
    oprot.trans.flush()
7543 
 
4444 rajveer 7544 
  def process_markAlertsAsSeen(self, seqid, iprot, oprot):
7545 
    args = markAlertsAsSeen_args()
7546 
    args.read(iprot)
7547 
    iprot.readMessageEnd()
7548 
    result = markAlertsAsSeen_result()
7549 
    self._handler.markAlertsAsSeen(args.warehouseId)
7550 
    oprot.writeMessageBegin("markAlertsAsSeen", TMessageType.REPLY, seqid)
7551 
    result.write(oprot)
7552 
    oprot.writeMessageEnd()
7553 
    oprot.trans.flush()
7554 
 
3064 chandransh 7555 
  def process_getValidOrderCount(self, seqid, iprot, oprot):
7556 
    args = getValidOrderCount_args()
7557 
    args.read(iprot)
7558 
    iprot.readMessageEnd()
7559 
    result = getValidOrderCount_result()
7560 
    result.success = self._handler.getValidOrderCount()
7561 
    oprot.writeMessageBegin("getValidOrderCount", TMessageType.REPLY, seqid)
7562 
    result.write(oprot)
7563 
    oprot.writeMessageEnd()
7564 
    oprot.trans.flush()
7565 
 
7566 
  def process_getNoOfCustomersWithSuccessfulTransaction(self, seqid, iprot, oprot):
7567 
    args = getNoOfCustomersWithSuccessfulTransaction_args()
7568 
    args.read(iprot)
7569 
    iprot.readMessageEnd()
7570 
    result = getNoOfCustomersWithSuccessfulTransaction_result()
7571 
    result.success = self._handler.getNoOfCustomersWithSuccessfulTransaction()
7572 
    oprot.writeMessageBegin("getNoOfCustomersWithSuccessfulTransaction", TMessageType.REPLY, seqid)
7573 
    result.write(oprot)
7574 
    oprot.writeMessageEnd()
7575 
    oprot.trans.flush()
7576 
 
7577 
  def process_getValidOrdersAmountRange(self, seqid, iprot, oprot):
7578 
    args = getValidOrdersAmountRange_args()
7579 
    args.read(iprot)
7580 
    iprot.readMessageEnd()
7581 
    result = getValidOrdersAmountRange_result()
7582 
    result.success = self._handler.getValidOrdersAmountRange()
7583 
    oprot.writeMessageBegin("getValidOrdersAmountRange", TMessageType.REPLY, seqid)
7584 
    result.write(oprot)
7585 
    oprot.writeMessageEnd()
7586 
    oprot.trans.flush()
7587 
 
7588 
  def process_getValidOrders(self, seqid, iprot, oprot):
7589 
    args = getValidOrders_args()
7590 
    args.read(iprot)
7591 
    iprot.readMessageEnd()
7592 
    result = getValidOrders_result()
5874 rajveer 7593 
    result.success = self._handler.getValidOrders(args.limit, args.onlyStore)
3064 chandransh 7594 
    oprot.writeMessageBegin("getValidOrders", TMessageType.REPLY, seqid)
7595 
    result.write(oprot)
7596 
    oprot.writeMessageEnd()
7597 
    oprot.trans.flush()
7598 
 
1220 chandransh 7599 
  def process_batchOrders(self, seqid, iprot, oprot):
7600 
    args = batchOrders_args()
7601 
    args.read(iprot)
7602 
    iprot.readMessageEnd()
7603 
    result = batchOrders_result()
7604 
    try:
7605 
      result.success = self._handler.batchOrders(args.warehouseId)
7606 
    except TransactionServiceException, ex:
7607 
      result.ex = ex
7608 
    oprot.writeMessageBegin("batchOrders", TMessageType.REPLY, seqid)
7609 
    result.write(oprot)
7610 
    oprot.writeMessageEnd()
7611 
    oprot.trans.flush()
7612 
 
1208 chandransh 7613 
  def process_markOrderAsOutOfStock(self, seqid, iprot, oprot):
7614 
    args = markOrderAsOutOfStock_args()
7615 
    args.read(iprot)
7616 
    iprot.readMessageEnd()
7617 
    result = markOrderAsOutOfStock_result()
7618 
    try:
7619 
      result.success = self._handler.markOrderAsOutOfStock(args.orderId)
7620 
    except TransactionServiceException, ex:
7621 
      result.ex = ex
7622 
    oprot.writeMessageBegin("markOrderAsOutOfStock", TMessageType.REPLY, seqid)
7623 
    result.write(oprot)
7624 
    oprot.writeMessageEnd()
7625 
    oprot.trans.flush()
7626 
 
3064 chandransh 7627 
  def process_verifyOrder(self, seqid, iprot, oprot):
7628 
    args = verifyOrder_args()
759 chandransh 7629 
    args.read(iprot)
7630 
    iprot.readMessageEnd()
3064 chandransh 7631 
    result = verifyOrder_result()
759 chandransh 7632 
    try:
3064 chandransh 7633 
      result.success = self._handler.verifyOrder(args.orderId)
759 chandransh 7634 
    except TransactionServiceException, ex:
7635 
      result.ex = ex
3064 chandransh 7636 
    oprot.writeMessageBegin("verifyOrder", TMessageType.REPLY, seqid)
759 chandransh 7637 
    result.write(oprot)
7638 
    oprot.writeMessageEnd()
7639 
    oprot.trans.flush()
7640 
 
3064 chandransh 7641 
  def process_acceptOrder(self, seqid, iprot, oprot):
7642 
    args = acceptOrder_args()
1113 chandransh 7643 
    args.read(iprot)
7644 
    iprot.readMessageEnd()
3064 chandransh 7645 
    result = acceptOrder_result()
1113 chandransh 7646 
    try:
3064 chandransh 7647 
      result.success = self._handler.acceptOrder(args.orderId)
1113 chandransh 7648 
    except TransactionServiceException, ex:
7649 
      result.ex = ex
3064 chandransh 7650 
    oprot.writeMessageBegin("acceptOrder", TMessageType.REPLY, seqid)
1113 chandransh 7651 
    result.write(oprot)
7652 
    oprot.writeMessageEnd()
7653 
    oprot.trans.flush()
7654 
 
3064 chandransh 7655 
  def process_addBillingDetails(self, seqid, iprot, oprot):
7656 
    args = addBillingDetails_args()
1135 chandransh 7657 
    args.read(iprot)
7658 
    iprot.readMessageEnd()
3064 chandransh 7659 
    result = addBillingDetails_result()
1135 chandransh 7660 
    try:
5110 mandeep.dh 7661 
      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 7662 
    except TransactionServiceException, ex:
7663 
      result.ex = ex
3064 chandransh 7664 
    oprot.writeMessageBegin("addBillingDetails", TMessageType.REPLY, seqid)
1135 chandransh 7665 
    result.write(oprot)
7666 
    oprot.writeMessageEnd()
7667 
    oprot.trans.flush()
7668 
 
4579 rajveer 7669 
  def process_addInvoiceNumber(self, seqid, iprot, oprot):
7670 
    args = addInvoiceNumber_args()
7671 
    args.read(iprot)
7672 
    iprot.readMessageEnd()
7673 
    result = addInvoiceNumber_result()
7674 
    try:
6756 amar.kumar 7675 
      self._handler.addInvoiceNumber(args.orderId, args.invoiceNumber, args.color, args.serialNumber, args.itemNumber)
4579 rajveer 7676 
    except TransactionServiceException, ex:
7677 
      result.ex = ex
7678 
    oprot.writeMessageBegin("addInvoiceNumber", TMessageType.REPLY, seqid)
7679 
    result.write(oprot)
7680 
    oprot.writeMessageEnd()
7681 
    oprot.trans.flush()
7682 
 
4410 rajveer 7683 
  def process_markOrdersAsShippedFromWarehouse(self, seqid, iprot, oprot):
7684 
    args = markOrdersAsShippedFromWarehouse_args()
7685 
    args.read(iprot)
7686 
    iprot.readMessageEnd()
7687 
    result = markOrdersAsShippedFromWarehouse_result()
7688 
    try:
4789 rajveer 7689 
      result.success = self._handler.markOrdersAsShippedFromWarehouse(args.warehouseId, args.providerId, args.cod, args.orderIds)
4410 rajveer 7690 
    except TransactionServiceException, ex:
7691 
      result.ex = ex
7692 
    oprot.writeMessageBegin("markOrdersAsShippedFromWarehouse", TMessageType.REPLY, seqid)
7693 
    result.write(oprot)
7694 
    oprot.writeMessageEnd()
7695 
    oprot.trans.flush()
7696 
 
5676 rajveer 7697 
  def process_markOrdersAsReturnedFromStore(self, seqid, iprot, oprot):
7698 
    args = markOrdersAsReturnedFromStore_args()
7699 
    args.read(iprot)
7700 
    iprot.readMessageEnd()
7701 
    result = markOrdersAsReturnedFromStore_result()
7702 
    try:
5713 rajveer 7703 
      result.success = self._handler.markOrdersAsReturnedFromStore(args.providerId, args.orderIds, args.awbs)
5676 rajveer 7704 
    except TransactionServiceException, ex:
7705 
      result.ex = ex
7706 
    oprot.writeMessageBegin("markOrdersAsReturnedFromStore", TMessageType.REPLY, seqid)
7707 
    result.write(oprot)
7708 
    oprot.writeMessageEnd()
7709 
    oprot.trans.flush()
7710 
 
3064 chandransh 7711 
  def process_markOrdersAsPickedUp(self, seqid, iprot, oprot):
7712 
    args = markOrdersAsPickedUp_args()
304 ashish 7713 
    args.read(iprot)
7714 
    iprot.readMessageEnd()
3064 chandransh 7715 
    result = markOrdersAsPickedUp_result()
7716 
    try:
4910 phani.kuma 7717 
      self._handler.markOrdersAsPickedUp(args.providerId, args.pickupDetails)
3064 chandransh 7718 
    except TransactionServiceException, ex:
7719 
      result.ex = ex
7720 
    oprot.writeMessageBegin("markOrdersAsPickedUp", TMessageType.REPLY, seqid)
304 ashish 7721 
    result.write(oprot)
7722 
    oprot.writeMessageEnd()
7723 
    oprot.trans.flush()
94 ashish 7724 
 
4910 phani.kuma 7725 
  def process_getOrdersNotPickedUp(self, seqid, iprot, oprot):
7726 
    args = getOrdersNotPickedUp_args()
7727 
    args.read(iprot)
7728 
    iprot.readMessageEnd()
7729 
    result = getOrdersNotPickedUp_result()
7730 
    result.success = self._handler.getOrdersNotPickedUp(args.providerId)
7731 
    oprot.writeMessageBegin("getOrdersNotPickedUp", TMessageType.REPLY, seqid)
7732 
    result.write(oprot)
7733 
    oprot.writeMessageEnd()
7734 
    oprot.trans.flush()
7735 
 
3064 chandransh 7736 
  def process_markOrdersAsDelivered(self, seqid, iprot, oprot):
7737 
    args = markOrdersAsDelivered_args()
304 ashish 7738 
    args.read(iprot)
7739 
    iprot.readMessageEnd()
3064 chandransh 7740 
    result = markOrdersAsDelivered_result()
7741 
    try:
7742 
      self._handler.markOrdersAsDelivered(args.providerId, args.deliveredOrders)
7743 
    except TransactionServiceException, ex:
7744 
      result.ex = ex
7745 
    oprot.writeMessageBegin("markOrdersAsDelivered", TMessageType.REPLY, seqid)
304 ashish 7746 
    result.write(oprot)
7747 
    oprot.writeMessageEnd()
7748 
    oprot.trans.flush()
7749 
 
4910 phani.kuma 7750 
  def process_markAsRTOrders(self, seqid, iprot, oprot):
7751 
    args = markAsRTOrders_args()
1596 ankur.sing 7752 
    args.read(iprot)
7753 
    iprot.readMessageEnd()
4910 phani.kuma 7754 
    result = markAsRTOrders_result()
3064 chandransh 7755 
    try:
4910 phani.kuma 7756 
      self._handler.markAsRTOrders(args.providerId, args.returnedOrders)
3064 chandransh 7757 
    except TransactionServiceException, ex:
7758 
      result.ex = ex
4910 phani.kuma 7759 
    oprot.writeMessageBegin("markAsRTOrders", TMessageType.REPLY, seqid)
1596 ankur.sing 7760 
    result.write(oprot)
7761 
    oprot.writeMessageEnd()
7762 
    oprot.trans.flush()
304 ashish 7763 
 
4910 phani.kuma 7764 
  def process_getRTOrders(self, seqid, iprot, oprot):
7765 
    args = getRTOrders_args()
7766 
    args.read(iprot)
7767 
    iprot.readMessageEnd()
7768 
    result = getRTOrders_result()
7769 
    result.success = self._handler.getRTOrders(args.providerId)
7770 
    oprot.writeMessageBegin("getRTOrders", TMessageType.REPLY, seqid)
7771 
    result.write(oprot)
7772 
    oprot.writeMessageEnd()
7773 
    oprot.trans.flush()
7774 
 
3064 chandransh 7775 
  def process_updateNonDeliveryReason(self, seqid, iprot, oprot):
7776 
    args = updateNonDeliveryReason_args()
1627 ankur.sing 7777 
    args.read(iprot)
7778 
    iprot.readMessageEnd()
3064 chandransh 7779 
    result = updateNonDeliveryReason_result()
7780 
    try:
4910 phani.kuma 7781 
      self._handler.updateNonDeliveryReason(args.providerId, args.undeliveredOrders)
3064 chandransh 7782 
    except TransactionServiceException, ex:
7783 
      result.ex = ex
7784 
    oprot.writeMessageBegin("updateNonDeliveryReason", TMessageType.REPLY, seqid)
1627 ankur.sing 7785 
    result.write(oprot)
7786 
    oprot.writeMessageEnd()
7787 
    oprot.trans.flush()
1596 ankur.sing 7788 
 
4910 phani.kuma 7789 
  def process_getNonDeliveredOrdersbyCourier(self, seqid, iprot, oprot):
7790 
    args = getNonDeliveredOrdersbyCourier_args()
7791 
    args.read(iprot)
7792 
    iprot.readMessageEnd()
7793 
    result = getNonDeliveredOrdersbyCourier_result()
7794 
    result.success = self._handler.getNonDeliveredOrdersbyCourier(args.providerId)
7795 
    oprot.writeMessageBegin("getNonDeliveredOrdersbyCourier", TMessageType.REPLY, seqid)
7796 
    result.write(oprot)
7797 
    oprot.writeMessageEnd()
7798 
    oprot.trans.flush()
7799 
 
7800 
  def process_markOrdersAsLocalConnected(self, seqid, iprot, oprot):
7801 
    args = markOrdersAsLocalConnected_args()
7802 
    args.read(iprot)
7803 
    iprot.readMessageEnd()
7804 
    result = markOrdersAsLocalConnected_result()
7805 
    try:
7806 
      self._handler.markOrdersAsLocalConnected(args.providerId, args.local_connected_orders)
7807 
    except TransactionServiceException, ex:
7808 
      result.ex = ex
7809 
    oprot.writeMessageBegin("markOrdersAsLocalConnected", TMessageType.REPLY, seqid)
7810 
    result.write(oprot)
7811 
    oprot.writeMessageEnd()
7812 
    oprot.trans.flush()
7813 
 
7814 
  def process_getOrdersNotLocalConnected(self, seqid, iprot, oprot):
7815 
    args = getOrdersNotLocalConnected_args()
7816 
    args.read(iprot)
7817 
    iprot.readMessageEnd()
7818 
    result = getOrdersNotLocalConnected_result()
7819 
    result.success = self._handler.getOrdersNotLocalConnected(args.providerId)
7820 
    oprot.writeMessageBegin("getOrdersNotLocalConnected", TMessageType.REPLY, seqid)
7821 
    result.write(oprot)
7822 
    oprot.writeMessageEnd()
7823 
    oprot.trans.flush()
7824 
 
7825 
  def process_markOrdersAsDestinationCityReached(self, seqid, iprot, oprot):
7826 
    args = markOrdersAsDestinationCityReached_args()
7827 
    args.read(iprot)
7828 
    iprot.readMessageEnd()
7829 
    result = markOrdersAsDestinationCityReached_result()
7830 
    try:
7831 
      self._handler.markOrdersAsDestinationCityReached(args.providerId, args.destination_city_reached_orders)
7832 
    except TransactionServiceException, ex:
7833 
      result.ex = ex
7834 
    oprot.writeMessageBegin("markOrdersAsDestinationCityReached", TMessageType.REPLY, seqid)
7835 
    result.write(oprot)
7836 
    oprot.writeMessageEnd()
7837 
    oprot.trans.flush()
7838 
 
7839 
  def process_markOrdersAsFirstDeliveryAttempted(self, seqid, iprot, oprot):
7840 
    args = markOrdersAsFirstDeliveryAttempted_args()
7841 
    args.read(iprot)
7842 
    iprot.readMessageEnd()
7843 
    result = markOrdersAsFirstDeliveryAttempted_result()
7844 
    try:
7845 
      self._handler.markOrdersAsFirstDeliveryAttempted(args.providerId, args.first_atdl_orders)
7846 
    except TransactionServiceException, ex:
7847 
      result.ex = ex
7848 
    oprot.writeMessageBegin("markOrdersAsFirstDeliveryAttempted", TMessageType.REPLY, seqid)
7849 
    result.write(oprot)
7850 
    oprot.writeMessageEnd()
7851 
    oprot.trans.flush()
7852 
 
3064 chandransh 7853 
  def process_getUndeliveredOrders(self, seqid, iprot, oprot):
7854 
    args = getUndeliveredOrders_args()
1627 ankur.sing 7855 
    args.read(iprot)
7856 
    iprot.readMessageEnd()
3064 chandransh 7857 
    result = getUndeliveredOrders_result()
7858 
    result.success = self._handler.getUndeliveredOrders(args.providerId, args.warehouseId)
7859 
    oprot.writeMessageBegin("getUndeliveredOrders", TMessageType.REPLY, seqid)
1627 ankur.sing 7860 
    result.write(oprot)
7861 
    oprot.writeMessageEnd()
7862 
    oprot.trans.flush()
7863 
 
4783 phani.kuma 7864 
  def process_getUndeliveredOrdersExpectedDeliveryDateNotMet(self, seqid, iprot, oprot):
7865 
    args = getUndeliveredOrdersExpectedDeliveryDateNotMet_args()
7866 
    args.read(iprot)
7867 
    iprot.readMessageEnd()
7868 
    result = getUndeliveredOrdersExpectedDeliveryDateNotMet_result()
7869 
    result.success = self._handler.getUndeliveredOrdersExpectedDeliveryDateNotMet()
7870 
    oprot.writeMessageBegin("getUndeliveredOrdersExpectedDeliveryDateNotMet", TMessageType.REPLY, seqid)
7871 
    result.write(oprot)
7872 
    oprot.writeMessageEnd()
7873 
    oprot.trans.flush()
7874 
 
2536 chandransh 7875 
  def process_toggleDOAFlag(self, seqid, iprot, oprot):
7876 
    args = toggleDOAFlag_args()
7877 
    args.read(iprot)
7878 
    iprot.readMessageEnd()
7879 
    result = toggleDOAFlag_result()
7880 
    try:
7881 
      result.success = self._handler.toggleDOAFlag(args.orderId)
7882 
    except TransactionServiceException, ex:
7883 
      result.ex = ex
7884 
    oprot.writeMessageBegin("toggleDOAFlag", TMessageType.REPLY, seqid)
7885 
    result.write(oprot)
7886 
    oprot.writeMessageEnd()
7887 
    oprot.trans.flush()
1886 ankur.sing 7888 
 
4712 rajveer 7889 
  def process_markOrderAsDelivered(self, seqid, iprot, oprot):
7890 
    args = markOrderAsDelivered_args()
7891 
    args.read(iprot)
7892 
    iprot.readMessageEnd()
7893 
    result = markOrderAsDelivered_result()
7894 
    try:
7895 
      self._handler.markOrderAsDelivered(args.orderId, args.deliveryTimestamp, args.receiver)
7896 
    except TransactionServiceException, ex:
7897 
      result.ex = ex
7898 
    oprot.writeMessageBegin("markOrderAsDelivered", TMessageType.REPLY, seqid)
7899 
    result.write(oprot)
7900 
    oprot.writeMessageEnd()
7901 
    oprot.trans.flush()
7902 
 
5553 rajveer 7903 
  def process_markOrderAsReceivedAtStore(self, seqid, iprot, oprot):
7904 
    args = markOrderAsReceivedAtStore_args()
7905 
    args.read(iprot)
7906 
    iprot.readMessageEnd()
7907 
    result = markOrderAsReceivedAtStore_result()
7908 
    try:
7909 
      self._handler.markOrderAsReceivedAtStore(args.orderId, args.deliveryTimestamp)
7910 
    except TransactionServiceException, ex:
7911 
      result.ex = ex
7912 
    oprot.writeMessageBegin("markOrderAsReceivedAtStore", TMessageType.REPLY, seqid)
7913 
    result.write(oprot)
7914 
    oprot.writeMessageEnd()
7915 
    oprot.trans.flush()
7916 
 
4454 rajveer 7917 
  def process_markOrderDoaRequestReceived(self, seqid, iprot, oprot):
7918 
    args = markOrderDoaRequestReceived_args()
7919 
    args.read(iprot)
7920 
    iprot.readMessageEnd()
7921 
    result = markOrderDoaRequestReceived_result()
7922 
    try:
7923 
      result.success = self._handler.markOrderDoaRequestReceived(args.orderId)
7924 
    except TransactionServiceException, ex:
7925 
      result.ex = ex
7926 
    oprot.writeMessageBegin("markOrderDoaRequestReceived", TMessageType.REPLY, seqid)
7927 
    result.write(oprot)
7928 
    oprot.writeMessageEnd()
7929 
    oprot.trans.flush()
7930 
 
7931 
  def process_markOrderDoaRequestAuthorized(self, seqid, iprot, oprot):
7932 
    args = markOrderDoaRequestAuthorized_args()
7933 
    args.read(iprot)
7934 
    iprot.readMessageEnd()
7935 
    result = markOrderDoaRequestAuthorized_result()
7936 
    try:
7937 
      result.success = self._handler.markOrderDoaRequestAuthorized(args.orderId, args.isAuthorized)
7938 
    except TransactionServiceException, ex:
7939 
      result.ex = ex
7940 
    oprot.writeMessageBegin("markOrderDoaRequestAuthorized", TMessageType.REPLY, seqid)
7941 
    result.write(oprot)
7942 
    oprot.writeMessageEnd()
7943 
    oprot.trans.flush()
7944 
 
4488 rajveer 7945 
  def process_markOrderReturnRequestReceived(self, seqid, iprot, oprot):
7946 
    args = markOrderReturnRequestReceived_args()
7947 
    args.read(iprot)
7948 
    iprot.readMessageEnd()
7949 
    result = markOrderReturnRequestReceived_result()
7950 
    try:
7951 
      result.success = self._handler.markOrderReturnRequestReceived(args.orderId)
7952 
    except TransactionServiceException, ex:
7953 
      result.ex = ex
7954 
    oprot.writeMessageBegin("markOrderReturnRequestReceived", TMessageType.REPLY, seqid)
7955 
    result.write(oprot)
7956 
    oprot.writeMessageEnd()
7957 
    oprot.trans.flush()
7958 
 
7959 
  def process_markOrderReturnRequestAuthorized(self, seqid, iprot, oprot):
7960 
    args = markOrderReturnRequestAuthorized_args()
7961 
    args.read(iprot)
7962 
    iprot.readMessageEnd()
7963 
    result = markOrderReturnRequestAuthorized_result()
7964 
    try:
7965 
      result.success = self._handler.markOrderReturnRequestAuthorized(args.orderId, args.isAuthorized)
7966 
    except TransactionServiceException, ex:
7967 
      result.ex = ex
7968 
    oprot.writeMessageBegin("markOrderReturnRequestAuthorized", TMessageType.REPLY, seqid)
7969 
    result.write(oprot)
7970 
    oprot.writeMessageEnd()
7971 
    oprot.trans.flush()
7972 
 
2536 chandransh 7973 
  def process_requestPickupNumber(self, seqid, iprot, oprot):
7974 
    args = requestPickupNumber_args()
7975 
    args.read(iprot)
7976 
    iprot.readMessageEnd()
7977 
    result = requestPickupNumber_result()
7978 
    try:
4579 rajveer 7979 
      result.success = self._handler.requestPickupNumber(args.orderId, args.providerId)
2536 chandransh 7980 
    except TransactionServiceException, ex:
7981 
      result.ex = ex
7982 
    oprot.writeMessageBegin("requestPickupNumber", TMessageType.REPLY, seqid)
7983 
    result.write(oprot)
7984 
    oprot.writeMessageEnd()
7985 
    oprot.trans.flush()
7986 
 
7987 
  def process_authorizePickup(self, seqid, iprot, oprot):
7988 
    args = authorizePickup_args()
7989 
    args.read(iprot)
7990 
    iprot.readMessageEnd()
7991 
    result = authorizePickup_result()
7992 
    try:
4602 rajveer 7993 
      result.success = self._handler.authorizePickup(args.orderId, args.pickupNumber, args.providerId)
2536 chandransh 7994 
    except TransactionServiceException, ex:
7995 
      result.ex = ex
7996 
    oprot.writeMessageBegin("authorizePickup", TMessageType.REPLY, seqid)
7997 
    result.write(oprot)
7998 
    oprot.writeMessageEnd()
7999 
    oprot.trans.flush()
8000 
 
2764 chandransh 8001 
  def process_markDoasAsPickedUp(self, seqid, iprot, oprot):
8002 
    args = markDoasAsPickedUp_args()
8003 
    args.read(iprot)
8004 
    iprot.readMessageEnd()
8005 
    result = markDoasAsPickedUp_result()
4910 phani.kuma 8006 
    self._handler.markDoasAsPickedUp(args.providerId, args.pickupDetails)
2764 chandransh 8007 
    oprot.writeMessageBegin("markDoasAsPickedUp", TMessageType.REPLY, seqid)
8008 
    result.write(oprot)
8009 
    oprot.writeMessageEnd()
8010 
    oprot.trans.flush()
8011 
 
4910 phani.kuma 8012 
  def process_getDoasNotPickedUp(self, seqid, iprot, oprot):
8013 
    args = getDoasNotPickedUp_args()
8014 
    args.read(iprot)
8015 
    iprot.readMessageEnd()
8016 
    result = getDoasNotPickedUp_result()
8017 
    result.success = self._handler.getDoasNotPickedUp(args.providerId)
8018 
    oprot.writeMessageBegin("getDoasNotPickedUp", TMessageType.REPLY, seqid)
8019 
    result.write(oprot)
8020 
    oprot.writeMessageEnd()
8021 
    oprot.trans.flush()
8022 
 
4741 phani.kuma 8023 
  def process_markReturnOrdersAsPickedUp(self, seqid, iprot, oprot):
8024 
    args = markReturnOrdersAsPickedUp_args()
8025 
    args.read(iprot)
8026 
    iprot.readMessageEnd()
8027 
    result = markReturnOrdersAsPickedUp_result()
4910 phani.kuma 8028 
    self._handler.markReturnOrdersAsPickedUp(args.providerId, args.pickupDetails)
4741 phani.kuma 8029 
    oprot.writeMessageBegin("markReturnOrdersAsPickedUp", TMessageType.REPLY, seqid)
8030 
    result.write(oprot)
8031 
    oprot.writeMessageEnd()
8032 
    oprot.trans.flush()
8033 
 
4910 phani.kuma 8034 
  def process_getReturnOrdersNotPickedUp(self, seqid, iprot, oprot):
8035 
    args = getReturnOrdersNotPickedUp_args()
8036 
    args.read(iprot)
8037 
    iprot.readMessageEnd()
8038 
    result = getReturnOrdersNotPickedUp_result()
8039 
    result.success = self._handler.getReturnOrdersNotPickedUp(args.providerId)
8040 
    oprot.writeMessageBegin("getReturnOrdersNotPickedUp", TMessageType.REPLY, seqid)
8041 
    result.write(oprot)
8042 
    oprot.writeMessageEnd()
8043 
    oprot.trans.flush()
8044 
 
2616 chandransh 8045 
  def process_receiveReturn(self, seqid, iprot, oprot):
8046 
    args = receiveReturn_args()
2591 chandransh 8047 
    args.read(iprot)
8048 
    iprot.readMessageEnd()
2616 chandransh 8049 
    result = receiveReturn_result()
2591 chandransh 8050 
    try:
4479 rajveer 8051 
      result.success = self._handler.receiveReturn(args.orderId, args.receiveCondition)
2591 chandransh 8052 
    except TransactionServiceException, ex:
8053 
      result.ex = ex
2616 chandransh 8054 
    oprot.writeMessageBegin("receiveReturn", TMessageType.REPLY, seqid)
2591 chandransh 8055 
    result.write(oprot)
8056 
    oprot.writeMessageEnd()
8057 
    oprot.trans.flush()
2536 chandransh 8058 
 
2591 chandransh 8059 
  def process_validateDoa(self, seqid, iprot, oprot):
8060 
    args = validateDoa_args()
8061 
    args.read(iprot)
8062 
    iprot.readMessageEnd()
8063 
    result = validateDoa_result()
8064 
    try:
8065 
      result.success = self._handler.validateDoa(args.orderId, args.isValid)
8066 
    except TransactionServiceException, ex:
8067 
      result.ex = ex
8068 
    oprot.writeMessageBegin("validateDoa", TMessageType.REPLY, seqid)
8069 
    result.write(oprot)
8070 
    oprot.writeMessageEnd()
8071 
    oprot.trans.flush()
8072 
 
4495 rajveer 8073 
  def process_validateReturnProduct(self, seqid, iprot, oprot):
8074 
    args = validateReturnProduct_args()
8075 
    args.read(iprot)
8076 
    iprot.readMessageEnd()
8077 
    result = validateReturnProduct_result()
8078 
    try:
8079 
      result.success = self._handler.validateReturnProduct(args.orderId, args.isUsable)
8080 
    except TransactionServiceException, ex:
8081 
      result.ex = ex
8082 
    oprot.writeMessageBegin("validateReturnProduct", TMessageType.REPLY, seqid)
8083 
    result.write(oprot)
8084 
    oprot.writeMessageEnd()
8085 
    oprot.trans.flush()
8086 
 
2616 chandransh 8087 
  def process_reshipOrder(self, seqid, iprot, oprot):
8088 
    args = reshipOrder_args()
8089 
    args.read(iprot)
8090 
    iprot.readMessageEnd()
8091 
    result = reshipOrder_result()
8092 
    try:
8093 
      result.success = self._handler.reshipOrder(args.orderId)
8094 
    except TransactionServiceException, ex:
8095 
      result.ex = ex
8096 
    oprot.writeMessageBegin("reshipOrder", TMessageType.REPLY, seqid)
8097 
    result.write(oprot)
8098 
    oprot.writeMessageEnd()
8099 
    oprot.trans.flush()
2591 chandransh 8100 
 
2616 chandransh 8101 
  def process_refundOrder(self, seqid, iprot, oprot):
8102 
    args = refundOrder_args()
8103 
    args.read(iprot)
8104 
    iprot.readMessageEnd()
8105 
    result = refundOrder_result()
8106 
    try:
3226 chandransh 8107 
      result.success = self._handler.refundOrder(args.orderId, args.refundedBy, args.reason)
2616 chandransh 8108 
    except TransactionServiceException, ex:
8109 
      result.ex = ex
8110 
    oprot.writeMessageBegin("refundOrder", TMessageType.REPLY, seqid)
8111 
    result.write(oprot)
8112 
    oprot.writeMessageEnd()
8113 
    oprot.trans.flush()
8114 
 
2690 chandransh 8115 
  def process_getReturnOrders(self, seqid, iprot, oprot):
8116 
    args = getReturnOrders_args()
8117 
    args.read(iprot)
8118 
    iprot.readMessageEnd()
8119 
    result = getReturnOrders_result()
8120 
    result.success = self._handler.getReturnOrders(args.warehouseId, args.fromDate, args.toDate)
8121 
    oprot.writeMessageBegin("getReturnOrders", TMessageType.REPLY, seqid)
8122 
    result.write(oprot)
8123 
    oprot.writeMessageEnd()
8124 
    oprot.trans.flush()
2616 chandransh 8125 
 
5481 phani.kuma 8126 
  def process_getAllReturnOrders(self, seqid, iprot, oprot):
8127 
    args = getAllReturnOrders_args()
8128 
    args.read(iprot)
8129 
    iprot.readMessageEnd()
8130 
    result = getAllReturnOrders_result()
8131 
    result.success = self._handler.getAllReturnOrders(args.onlyNotProcessed, args.fromDate, args.toDate)
8132 
    oprot.writeMessageBegin("getAllReturnOrders", TMessageType.REPLY, seqid)
8133 
    result.write(oprot)
8134 
    oprot.writeMessageEnd()
8135 
    oprot.trans.flush()
8136 
 
2700 chandransh 8137 
  def process_getReturnOrder(self, seqid, iprot, oprot):
8138 
    args = getReturnOrder_args()
8139 
    args.read(iprot)
8140 
    iprot.readMessageEnd()
8141 
    result = getReturnOrder_result()
8142 
    try:
8143 
      result.success = self._handler.getReturnOrder(args.id)
8144 
    except TransactionServiceException, ex:
8145 
      result.ex = ex
8146 
    oprot.writeMessageBegin("getReturnOrder", TMessageType.REPLY, seqid)
8147 
    result.write(oprot)
8148 
    oprot.writeMessageEnd()
8149 
    oprot.trans.flush()
8150 
 
2690 chandransh 8151 
  def process_processReturn(self, seqid, iprot, oprot):
8152 
    args = processReturn_args()
8153 
    args.read(iprot)
8154 
    iprot.readMessageEnd()
8155 
    result = processReturn_result()
8156 
    try:
8157 
      self._handler.processReturn(args.returnOrderId)
8158 
    except TransactionServiceException, ex:
8159 
      result.ex = ex
8160 
    oprot.writeMessageBegin("processReturn", TMessageType.REPLY, seqid)
8161 
    result.write(oprot)
8162 
    oprot.writeMessageEnd()
8163 
    oprot.trans.flush()
8164 
 
3451 chandransh 8165 
  def process_updateWeight(self, seqid, iprot, oprot):
8166 
    args = updateWeight_args()
8167 
    args.read(iprot)
8168 
    iprot.readMessageEnd()
8169 
    result = updateWeight_result()
8170 
    try:
8171 
      result.success = self._handler.updateWeight(args.orderId, args.weight)
8172 
    except TransactionServiceException, ex:
8173 
      result.ex = ex
8174 
    oprot.writeMessageBegin("updateWeight", TMessageType.REPLY, seqid)
8175 
    result.write(oprot)
8176 
    oprot.writeMessageEnd()
8177 
    oprot.trans.flush()
2819 chandransh 8178 
 
3469 chandransh 8179 
  def process_changeItem(self, seqid, iprot, oprot):
8180 
    args = changeItem_args()
8181 
    args.read(iprot)
8182 
    iprot.readMessageEnd()
8183 
    result = changeItem_result()
8184 
    try:
8185 
      result.success = self._handler.changeItem(args.orderId, args.itemId)
8186 
    except TransactionServiceException, ex:
8187 
      result.ex = ex
8188 
    oprot.writeMessageBegin("changeItem", TMessageType.REPLY, seqid)
8189 
    result.write(oprot)
8190 
    oprot.writeMessageEnd()
8191 
    oprot.trans.flush()
3451 chandransh 8192 
 
3469 chandransh 8193 
  def process_shiftToWarehouse(self, seqid, iprot, oprot):
8194 
    args = shiftToWarehouse_args()
8195 
    args.read(iprot)
8196 
    iprot.readMessageEnd()
8197 
    result = shiftToWarehouse_result()
8198 
    try:
8199 
      result.success = self._handler.shiftToWarehouse(args.orderId, args.warehouseId)
8200 
    except TransactionServiceException, ex:
8201 
      result.ex = ex
8202 
    oprot.writeMessageBegin("shiftToWarehouse", TMessageType.REPLY, seqid)
8203 
    result.write(oprot)
8204 
    oprot.writeMessageEnd()
8205 
    oprot.trans.flush()
8206 
 
3553 chandransh 8207 
  def process_addDelayReason(self, seqid, iprot, oprot):
8208 
    args = addDelayReason_args()
8209 
    args.read(iprot)
8210 
    iprot.readMessageEnd()
8211 
    result = addDelayReason_result()
8212 
    try:
4647 rajveer 8213 
      result.success = self._handler.addDelayReason(args.orderId, args.delayReason, args.furtherDelay, args.delayReasonText)
3553 chandransh 8214 
    except TransactionServiceException, ex:
8215 
      result.ex = ex
8216 
    oprot.writeMessageBegin("addDelayReason", TMessageType.REPLY, seqid)
8217 
    result.write(oprot)
8218 
    oprot.writeMessageEnd()
8219 
    oprot.trans.flush()
3469 chandransh 8220 
 
3956 chandransh 8221 
  def process_reconcileCodCollection(self, seqid, iprot, oprot):
8222 
    args = reconcileCodCollection_args()
8223 
    args.read(iprot)
8224 
    iprot.readMessageEnd()
8225 
    result = reconcileCodCollection_result()
8226 
    try:
8227 
      result.success = self._handler.reconcileCodCollection(args.collectedAmountMap, args.xferBy, args.xferTxnId, args.xferDate)
8228 
    except TransactionServiceException, ex:
8229 
      result.ex = ex
8230 
    oprot.writeMessageBegin("reconcileCodCollection", TMessageType.REPLY, seqid)
8231 
    result.write(oprot)
8232 
    oprot.writeMessageEnd()
8233 
    oprot.trans.flush()
3553 chandransh 8234 
 
4008 mandeep.dh 8235 
  def process_getTransactionsRequiringExtraProcessing(self, seqid, iprot, oprot):
8236 
    args = getTransactionsRequiringExtraProcessing_args()
8237 
    args.read(iprot)
8238 
    iprot.readMessageEnd()
8239 
    result = getTransactionsRequiringExtraProcessing_result()
8240 
    result.success = self._handler.getTransactionsRequiringExtraProcessing(args.category)
8241 
    oprot.writeMessageBegin("getTransactionsRequiringExtraProcessing", TMessageType.REPLY, seqid)
8242 
    result.write(oprot)
8243 
    oprot.writeMessageEnd()
8244 
    oprot.trans.flush()
3956 chandransh 8245 
 
4008 mandeep.dh 8246 
  def process_markTransactionAsProcessed(self, seqid, iprot, oprot):
8247 
    args = markTransactionAsProcessed_args()
8248 
    args.read(iprot)
8249 
    iprot.readMessageEnd()
8250 
    result = markTransactionAsProcessed_result()
8251 
    self._handler.markTransactionAsProcessed(args.transactionId, args.category)
8252 
    oprot.writeMessageBegin("markTransactionAsProcessed", TMessageType.REPLY, seqid)
8253 
    result.write(oprot)
8254 
    oprot.writeMessageEnd()
8255 
    oprot.trans.flush()
8256 
 
4018 chandransh 8257 
  def process_getItemWiseRiskyOrdersCount(self, seqid, iprot, oprot):
8258 
    args = getItemWiseRiskyOrdersCount_args()
8259 
    args.read(iprot)
8260 
    iprot.readMessageEnd()
8261 
    result = getItemWiseRiskyOrdersCount_result()
8262 
    result.success = self._handler.getItemWiseRiskyOrdersCount()
8263 
    oprot.writeMessageBegin("getItemWiseRiskyOrdersCount", TMessageType.REPLY, seqid)
8264 
    result.write(oprot)
8265 
    oprot.writeMessageEnd()
8266 
    oprot.trans.flush()
4008 mandeep.dh 8267 
 
4295 varun.gupt 8268 
  def process_getOrdersForItemIds(self, seqid, iprot, oprot):
8269 
    args = getOrdersForItemIds_args()
8270 
    args.read(iprot)
8271 
    iprot.readMessageEnd()
8272 
    result = getOrdersForItemIds_result()
8273 
    result.success = self._handler.getOrdersForItemIds(args.itemIds)
8274 
    oprot.writeMessageBegin("getOrdersForItemIds", TMessageType.REPLY, seqid)
8275 
    result.write(oprot)
8276 
    oprot.writeMessageEnd()
8277 
    oprot.trans.flush()
8278 
 
4247 rajveer 8279 
  def process_markOrderCancellationRequestReceived(self, seqid, iprot, oprot):
8280 
    args = markOrderCancellationRequestReceived_args()
8281 
    args.read(iprot)
8282 
    iprot.readMessageEnd()
8283 
    result = markOrderCancellationRequestReceived_result()
8284 
    try:
8285 
      self._handler.markOrderCancellationRequestReceived(args.orderId)
8286 
    except TransactionServiceException, ex:
8287 
      result.ex = ex
8288 
    oprot.writeMessageBegin("markOrderCancellationRequestReceived", TMessageType.REPLY, seqid)
8289 
    result.write(oprot)
8290 
    oprot.writeMessageEnd()
8291 
    oprot.trans.flush()
4018 chandransh 8292 
 
4247 rajveer 8293 
  def process_markOrderCancellationRequestConfirmed(self, seqid, iprot, oprot):
8294 
    args = markOrderCancellationRequestConfirmed_args()
8295 
    args.read(iprot)
8296 
    iprot.readMessageEnd()
8297 
    result = markOrderCancellationRequestConfirmed_result()
8298 
    try:
8299 
      self._handler.markOrderCancellationRequestConfirmed(args.orderId)
8300 
    except TransactionServiceException, ex:
8301 
      result.ex = ex
8302 
    oprot.writeMessageBegin("markOrderCancellationRequestConfirmed", TMessageType.REPLY, seqid)
8303 
    result.write(oprot)
8304 
    oprot.writeMessageEnd()
8305 
    oprot.trans.flush()
8306 
 
8307 
  def process_markOrderCancellationRequestDenied(self, seqid, iprot, oprot):
8308 
    args = markOrderCancellationRequestDenied_args()
8309 
    args.read(iprot)
8310 
    iprot.readMessageEnd()
8311 
    result = markOrderCancellationRequestDenied_result()
8312 
    try:
8313 
      self._handler.markOrderCancellationRequestDenied(args.orderId)
8314 
    except TransactionServiceException, ex:
8315 
      result.ex = ex
8316 
    oprot.writeMessageBegin("markOrderCancellationRequestDenied", TMessageType.REPLY, seqid)
8317 
    result.write(oprot)
8318 
    oprot.writeMessageEnd()
8319 
    oprot.trans.flush()
8320 
 
4258 rajveer 8321 
  def process_markTransactionAsPaymentFlagRemoved(self, seqid, iprot, oprot):
8322 
    args = markTransactionAsPaymentFlagRemoved_args()
4247 rajveer 8323 
    args.read(iprot)
8324 
    iprot.readMessageEnd()
4258 rajveer 8325 
    result = markTransactionAsPaymentFlagRemoved_result()
4247 rajveer 8326 
    try:
4258 rajveer 8327 
      self._handler.markTransactionAsPaymentFlagRemoved(args.transactionId)
4247 rajveer 8328 
    except TransactionServiceException, ex:
8329 
      result.ex = ex
4258 rajveer 8330 
    oprot.writeMessageBegin("markTransactionAsPaymentFlagRemoved", TMessageType.REPLY, seqid)
4247 rajveer 8331 
    result.write(oprot)
8332 
    oprot.writeMessageEnd()
8333 
    oprot.trans.flush()
8334 
 
4259 anupam.sin 8335 
  def process_refundTransaction(self, seqid, iprot, oprot):
8336 
    args = refundTransaction_args()
8337 
    args.read(iprot)
8338 
    iprot.readMessageEnd()
8339 
    result = refundTransaction_result()
8340 
    try:
8341 
      self._handler.refundTransaction(args.transactionId, args.refundedBy, args.reason)
8342 
    except TransactionServiceException, ex:
8343 
      result.ex = ex
8344 
    oprot.writeMessageBegin("refundTransaction", TMessageType.REPLY, seqid)
8345 
    result.write(oprot)
8346 
    oprot.writeMessageEnd()
8347 
    oprot.trans.flush()
4247 rajveer 8348 
 
4324 mandeep.dh 8349 
  def process_updateShipmentAddress(self, seqid, iprot, oprot):
8350 
    args = updateShipmentAddress_args()
8351 
    args.read(iprot)
8352 
    iprot.readMessageEnd()
8353 
    result = updateShipmentAddress_result()
8354 
    try:
8355 
      self._handler.updateShipmentAddress(args.orderId, args.addressId)
8356 
    except TransactionServiceException, ex:
8357 
      result.ex = ex
8358 
    oprot.writeMessageBegin("updateShipmentAddress", TMessageType.REPLY, seqid)
8359 
    result.write(oprot)
8360 
    oprot.writeMessageEnd()
8361 
    oprot.trans.flush()
8362 
 
4285 rajveer 8363 
  def process_acceptOrdersForItemId(self, seqid, iprot, oprot):
8364 
    args = acceptOrdersForItemId_args()
8365 
    args.read(iprot)
8366 
    iprot.readMessageEnd()
8367 
    result = acceptOrdersForItemId_result()
8368 
    try:
8369 
      result.success = self._handler.acceptOrdersForItemId(args.itemId, args.inventory)
8370 
    except TransactionServiceException, ex:
8371 
      result.ex = ex
8372 
    oprot.writeMessageBegin("acceptOrdersForItemId", TMessageType.REPLY, seqid)
8373 
    result.write(oprot)
8374 
    oprot.writeMessageEnd()
8375 
    oprot.trans.flush()
4259 anupam.sin 8376 
 
4303 rajveer 8377 
  def process_markOrdersAsPORaised(self, seqid, iprot, oprot):
8378 
    args = markOrdersAsPORaised_args()
8379 
    args.read(iprot)
8380 
    iprot.readMessageEnd()
8381 
    result = markOrdersAsPORaised_result()
8382 
    try:
4369 rajveer 8383 
      self._handler.markOrdersAsPORaised(args.vendorId, args.itemId, args.quantity, args.estimate, args.isReminder)
4303 rajveer 8384 
    except TransactionServiceException, ex:
8385 
      result.ex = ex
8386 
    oprot.writeMessageBegin("markOrdersAsPORaised", TMessageType.REPLY, seqid)
8387 
    result.write(oprot)
8388 
    oprot.writeMessageEnd()
8389 
    oprot.trans.flush()
4285 rajveer 8390 
 
4303 rajveer 8391 
  def process_markOrdersAsReversalInitiated(self, seqid, iprot, oprot):
8392 
    args = markOrdersAsReversalInitiated_args()
8393 
    args.read(iprot)
8394 
    iprot.readMessageEnd()
8395 
    result = markOrdersAsReversalInitiated_result()
8396 
    try:
4369 rajveer 8397 
      self._handler.markOrdersAsReversalInitiated(args.vendorId, args.itemId, args.quantity, args.estimate, args.isReminder)
4303 rajveer 8398 
    except TransactionServiceException, ex:
8399 
      result.ex = ex
8400 
    oprot.writeMessageBegin("markOrdersAsReversalInitiated", TMessageType.REPLY, seqid)
8401 
    result.write(oprot)
8402 
    oprot.writeMessageEnd()
8403 
    oprot.trans.flush()
8404 
 
8405 
  def process_markOrdersAsNotAvailabke(self, seqid, iprot, oprot):
8406 
    args = markOrdersAsNotAvailabke_args()
8407 
    args.read(iprot)
8408 
    iprot.readMessageEnd()
8409 
    result = markOrdersAsNotAvailabke_result()
8410 
    try:
4369 rajveer 8411 
      self._handler.markOrdersAsNotAvailabke(args.vendorId, args.itemId, args.quantity, args.estimate, args.isReminder)
4303 rajveer 8412 
    except TransactionServiceException, ex:
8413 
      result.ex = ex
8414 
    oprot.writeMessageBegin("markOrdersAsNotAvailabke", TMessageType.REPLY, seqid)
8415 
    result.write(oprot)
8416 
    oprot.writeMessageEnd()
8417 
    oprot.trans.flush()
8418 
 
4369 rajveer 8419 
  def process_markOrdersAsTimeout(self, seqid, iprot, oprot):
8420 
    args = markOrdersAsTimeout_args()
8421 
    args.read(iprot)
8422 
    iprot.readMessageEnd()
8423 
    result = markOrdersAsTimeout_result()
8424 
    try:
8425 
      result.success = self._handler.markOrdersAsTimeout(args.vendorId)
8426 
    except TransactionServiceException, ex:
8427 
      result.ex = ex
8428 
    oprot.writeMessageBegin("markOrdersAsTimeout", TMessageType.REPLY, seqid)
8429 
    result.write(oprot)
8430 
    oprot.writeMessageEnd()
8431 
    oprot.trans.flush()
4303 rajveer 8432 
 
4662 rajveer 8433 
  def process_markOrderAsLostInTransit(self, seqid, iprot, oprot):
8434 
    args = markOrderAsLostInTransit_args()
8435 
    args.read(iprot)
8436 
    iprot.readMessageEnd()
8437 
    result = markOrderAsLostInTransit_result()
8438 
    try:
8439 
      result.success = self._handler.markOrderAsLostInTransit(args.orderId)
8440 
    except TransactionServiceException, ex:
8441 
      result.ex = ex
8442 
    oprot.writeMessageBegin("markOrderAsLostInTransit", TMessageType.REPLY, seqid)
8443 
    result.write(oprot)
8444 
    oprot.writeMessageEnd()
8445 
    oprot.trans.flush()
8446 
 
4386 anupam.sin 8447 
  def process_getOrderForAwb(self, seqid, iprot, oprot):
8448 
    args = getOrderForAwb_args()
8449 
    args.read(iprot)
8450 
    iprot.readMessageEnd()
8451 
    result = getOrderForAwb_result()
8452 
    try:
8453 
      result.success = self._handler.getOrderForAwb(args.awb)
8454 
    except TransactionServiceException, ex:
8455 
      result.ex = ex
8456 
    oprot.writeMessageBegin("getOrderForAwb", TMessageType.REPLY, seqid)
8457 
    result.write(oprot)
8458 
    oprot.writeMessageEnd()
8459 
    oprot.trans.flush()
4369 rajveer 8460 
 
4506 phani.kuma 8461 
  def process_getOrdersForProviderForStatus(self, seqid, iprot, oprot):
8462 
    args = getOrdersForProviderForStatus_args()
8463 
    args.read(iprot)
8464 
    iprot.readMessageEnd()
8465 
    result = getOrdersForProviderForStatus_result()
8466 
    try:
4910 phani.kuma 8467 
      result.success = self._handler.getOrdersForProviderForStatus(args.logistics_provider_id, args.order_status_list)
4506 phani.kuma 8468 
    except TransactionServiceException, ex:
8469 
      result.ex = ex
8470 
    oprot.writeMessageBegin("getOrdersForProviderForStatus", TMessageType.REPLY, seqid)
8471 
    result.write(oprot)
8472 
    oprot.writeMessageEnd()
8473 
    oprot.trans.flush()
4386 anupam.sin 8474 
 
4600 varun.gupt 8475 
  def process_getBilledOrdersForVendor(self, seqid, iprot, oprot):
8476 
    args = getBilledOrdersForVendor_args()
8477 
    args.read(iprot)
8478 
    iprot.readMessageEnd()
8479 
    result = getBilledOrdersForVendor_result()
8480 
    try:
8481 
      result.success = self._handler.getBilledOrdersForVendor(args.vendorId, args.billingDateFrom, args.billingDateTo)
8482 
    except TransactionServiceException, ex:
8483 
      result.ex = ex
8484 
    oprot.writeMessageBegin("getBilledOrdersForVendor", TMessageType.REPLY, seqid)
8485 
    result.write(oprot)
8486 
    oprot.writeMessageEnd()
8487 
    oprot.trans.flush()
4506 phani.kuma 8488 
 
4607 rajveer 8489 
  def process_getSlippedSippingDateOrders(self, seqid, iprot, oprot):
8490 
    args = getSlippedSippingDateOrders_args()
8491 
    args.read(iprot)
8492 
    iprot.readMessageEnd()
8493 
    result = getSlippedSippingDateOrders_result()
8494 
    try:
8495 
      result.success = self._handler.getSlippedSippingDateOrders()
8496 
    except TransactionServiceException, ex:
8497 
      result.ex = ex
8498 
    oprot.writeMessageBegin("getSlippedSippingDateOrders", TMessageType.REPLY, seqid)
8499 
    result.write(oprot)
8500 
    oprot.writeMessageEnd()
8501 
    oprot.trans.flush()
8502 
 
4709 rajveer 8503 
  def process_getCancelledOrders(self, seqid, iprot, oprot):
8504 
    args = getCancelledOrders_args()
8505 
    args.read(iprot)
8506 
    iprot.readMessageEnd()
8507 
    result = getCancelledOrders_result()
8508 
    try:
8509 
      result.success = self._handler.getCancelledOrders(args.cancelDateFrom, args.cancelDateTo)
8510 
    except TransactionServiceException, ex:
8511 
      result.ex = ex
8512 
    oprot.writeMessageBegin("getCancelledOrders", TMessageType.REPLY, seqid)
8513 
    result.write(oprot)
8514 
    oprot.writeMessageEnd()
8515 
    oprot.trans.flush()
8516 
 
4600 varun.gupt 8517 
  def process_saveBluedartSettlements(self, seqid, iprot, oprot):
8518 
    args = saveBluedartSettlements_args()
8519 
    args.read(iprot)
8520 
    iprot.readMessageEnd()
8521 
    result = saveBluedartSettlements_result()
8522 
    try:
8523 
      self._handler.saveBluedartSettlements(args.mapAWBAndAmount)
8524 
    except TransactionServiceException, ex:
8525 
      result.ex = ex
8526 
    oprot.writeMessageBegin("saveBluedartSettlements", TMessageType.REPLY, seqid)
8527 
    result.write(oprot)
8528 
    oprot.writeMessageEnd()
8529 
    oprot.trans.flush()
8530 
 
8531 
  def process_savePaymentSettlements(self, seqid, iprot, oprot):
8532 
    args = savePaymentSettlements_args()
8533 
    args.read(iprot)
8534 
    iprot.readMessageEnd()
8535 
    result = savePaymentSettlements_result()
8536 
    try:
4905 varun.gupt 8537 
      self._handler.savePaymentSettlements(args.settlementDate, args.paymentGatewayId, args.referenceId, args.serviceTax, args.otherCharges, args.netCollection)
4600 varun.gupt 8538 
    except TransactionServiceException, ex:
8539 
      result.ex = ex
8540 
    oprot.writeMessageBegin("savePaymentSettlements", TMessageType.REPLY, seqid)
8541 
    result.write(oprot)
8542 
    oprot.writeMessageEnd()
8543 
    oprot.trans.flush()
8544 
 
8545 
  def process_saveEBSSettlementSummary(self, seqid, iprot, oprot):
8546 
    args = saveEBSSettlementSummary_args()
8547 
    args.read(iprot)
8548 
    iprot.readMessageEnd()
8549 
    result = saveEBSSettlementSummary_result()
8550 
    try:
8551 
      self._handler.saveEBSSettlementSummary(args.settlementId, args.settlementDate, args.transactionDateFrom, args.transactionDateTo, args.amount)
8552 
    except TransactionServiceException, ex:
8553 
      result.ex = ex
8554 
    oprot.writeMessageBegin("saveEBSSettlementSummary", TMessageType.REPLY, seqid)
8555 
    result.write(oprot)
8556 
    oprot.writeMessageEnd()
8557 
    oprot.trans.flush()
8558 
 
5386 phani.kuma 8559 
  def process_getSettlementForPrepaid(self, seqid, iprot, oprot):
8560 
    args = getSettlementForPrepaid_args()
4600 varun.gupt 8561 
    args.read(iprot)
8562 
    iprot.readMessageEnd()
5386 phani.kuma 8563 
    result = getSettlementForPrepaid_result()
4600 varun.gupt 8564 
    try:
5386 phani.kuma 8565 
      result.success = self._handler.getSettlementForPrepaid(args.referenceId, args.isRefund)
4600 varun.gupt 8566 
    except TransactionServiceException, ex:
8567 
      result.ex = ex
5386 phani.kuma 8568 
    oprot.writeMessageBegin("getSettlementForPrepaid", TMessageType.REPLY, seqid)
4600 varun.gupt 8569 
    result.write(oprot)
8570 
    oprot.writeMessageEnd()
8571 
    oprot.trans.flush()
8572 
 
5386 phani.kuma 8573 
  def process_getSettlementForCod(self, seqid, iprot, oprot):
8574 
    args = getSettlementForCod_args()
8575 
    args.read(iprot)
8576 
    iprot.readMessageEnd()
8577 
    result = getSettlementForCod_result()
8578 
    try:
8579 
      result.success = self._handler.getSettlementForCod(args.orderId, args.isRefund)
8580 
    except TransactionServiceException, ex:
8581 
      result.ex = ex
8582 
    oprot.writeMessageBegin("getSettlementForCod", TMessageType.REPLY, seqid)
8583 
    result.write(oprot)
8584 
    oprot.writeMessageEnd()
8585 
    oprot.trans.flush()
8586 
 
4600 varun.gupt 8587 
  def process_getEBSSettlementSummaries(self, seqid, iprot, oprot):
8588 
    args = getEBSSettlementSummaries_args()
8589 
    args.read(iprot)
8590 
    iprot.readMessageEnd()
8591 
    result = getEBSSettlementSummaries_result()
8592 
    try:
8593 
      result.success = self._handler.getEBSSettlementSummaries()
8594 
    except TransactionServiceException, ex:
8595 
      result.ex = ex
8596 
    oprot.writeMessageBegin("getEBSSettlementSummaries", TMessageType.REPLY, seqid)
8597 
    result.write(oprot)
8598 
    oprot.writeMessageEnd()
8599 
    oprot.trans.flush()
8600 
 
8601 
  def process_markEBSSettlementUploaded(self, seqid, iprot, oprot):
8602 
    args = markEBSSettlementUploaded_args()
8603 
    args.read(iprot)
8604 
    iprot.readMessageEnd()
8605 
    result = markEBSSettlementUploaded_result()
8606 
    try:
8607 
      self._handler.markEBSSettlementUploaded(args.settlementId)
8608 
    except TransactionServiceException, ex:
8609 
      result.ex = ex
8610 
    oprot.writeMessageBegin("markEBSSettlementUploaded", TMessageType.REPLY, seqid)
8611 
    result.write(oprot)
8612 
    oprot.writeMessageEnd()
8613 
    oprot.trans.flush()
8614 
 
8615 
  def process_getEBSSettlementDate(self, seqid, iprot, oprot):
8616 
    args = getEBSSettlementDate_args()
8617 
    args.read(iprot)
8618 
    iprot.readMessageEnd()
8619 
    result = getEBSSettlementDate_result()
8620 
    try:
8621 
      result.success = self._handler.getEBSSettlementDate(args.settlementId)
8622 
    except TransactionServiceException, ex:
8623 
      result.ex = ex
8624 
    oprot.writeMessageBegin("getEBSSettlementDate", TMessageType.REPLY, seqid)
8625 
    result.write(oprot)
8626 
    oprot.writeMessageEnd()
8627 
    oprot.trans.flush()
8628 
 
4715 varun.gupt 8629 
  def process_getSettlementsByDate(self, seqid, iprot, oprot):
8630 
    args = getSettlementsByDate_args()
8631 
    args.read(iprot)
8632 
    iprot.readMessageEnd()
8633 
    result = getSettlementsByDate_result()
8634 
    try:
8635 
      result.success = self._handler.getSettlementsByDate(args.settlementDateFrom, args.settlementDateTo, args.isRefund)
8636 
    except TransactionServiceException, ex:
8637 
      result.ex = ex
8638 
    oprot.writeMessageBegin("getSettlementsByDate", TMessageType.REPLY, seqid)
8639 
    result.write(oprot)
8640 
    oprot.writeMessageEnd()
8641 
    oprot.trans.flush()
4600 varun.gupt 8642 
 
4715 varun.gupt 8643 
  def process_getReshippedOrderIds(self, seqid, iprot, oprot):
8644 
    args = getReshippedOrderIds_args()
8645 
    args.read(iprot)
8646 
    iprot.readMessageEnd()
8647 
    result = getReshippedOrderIds_result()
8648 
    try:
8649 
      result.success = self._handler.getReshippedOrderIds(args.orderIds)
8650 
    except TransactionServiceException, ex:
8651 
      result.ex = ex
8652 
    oprot.writeMessageBegin("getReshippedOrderIds", TMessageType.REPLY, seqid)
8653 
    result.write(oprot)
8654 
    oprot.writeMessageEnd()
8655 
    oprot.trans.flush()
8656 
 
5481 phani.kuma 8657 
  def process_getBilledOrders(self, seqid, iprot, oprot):
8658 
    args = getBilledOrders_args()
4875 varun.gupt 8659 
    args.read(iprot)
8660 
    iprot.readMessageEnd()
5481 phani.kuma 8661 
    result = getBilledOrders_result()
4875 varun.gupt 8662 
    try:
5481 phani.kuma 8663 
      result.success = self._handler.getBilledOrders(args.vendorId, args.onlyVendorNotPaid, args.billingDateFrom, args.billingDateTo)
4875 varun.gupt 8664 
    except TransactionServiceException, ex:
8665 
      result.ex = ex
5481 phani.kuma 8666 
    oprot.writeMessageBegin("getBilledOrders", TMessageType.REPLY, seqid)
4875 varun.gupt 8667 
    result.write(oprot)
8668 
    oprot.writeMessageEnd()
8669 
    oprot.trans.flush()
4757 mandeep.dh 8670 
 
5031 varun.gupt 8671 
  def process_getStatusDistributionOfOrders(self, seqid, iprot, oprot):
8672 
    args = getStatusDistributionOfOrders_args()
8673 
    args.read(iprot)
8674 
    iprot.readMessageEnd()
8675 
    result = getStatusDistributionOfOrders_result()
8676 
    try:
8677 
      result.success = self._handler.getStatusDistributionOfOrders(args.startDate, args.endDate)
8678 
    except TransactionServiceException, ex:
8679 
      result.ex = ex
8680 
    oprot.writeMessageBegin("getStatusDistributionOfOrders", TMessageType.REPLY, seqid)
8681 
    result.write(oprot)
8682 
    oprot.writeMessageEnd()
8683 
    oprot.trans.flush()
4875 varun.gupt 8684 
 
5067 varun.gupt 8685 
  def process_getOrderIdsForStatus(self, seqid, iprot, oprot):
8686 
    args = getOrderIdsForStatus_args()
8687 
    args.read(iprot)
8688 
    iprot.readMessageEnd()
8689 
    result = getOrderIdsForStatus_result()
8690 
    try:
8691 
      result.success = self._handler.getOrderIdsForStatus(args.status, args.startDatetime, args.endDatetime)
8692 
    except TransactionServiceException, ex:
8693 
      result.ex = ex
8694 
    oprot.writeMessageBegin("getOrderIdsForStatus", TMessageType.REPLY, seqid)
8695 
    result.write(oprot)
8696 
    oprot.writeMessageEnd()
8697 
    oprot.trans.flush()
5031 varun.gupt 8698 
 
5348 anupam.sin 8699 
  def process_updateCODAgent(self, seqid, iprot, oprot):
8700 
    args = updateCODAgent_args()
8701 
    args.read(iprot)
8702 
    iprot.readMessageEnd()
8703 
    result = updateCODAgent_result()
8704 
    try:
8705 
      self._handler.updateCODAgent(args.agent, args.orderId)
8706 
    except TransactionServiceException, ex:
8707 
      result.ex = ex
8708 
    oprot.writeMessageBegin("updateCODAgent", TMessageType.REPLY, seqid)
8709 
    result.write(oprot)
8710 
    oprot.writeMessageEnd()
8711 
    oprot.trans.flush()
8712 
 
5099 varun.gupt 8713 
  def process_updateOrderAsPaidToVendor(self, seqid, iprot, oprot):
8714 
    args = updateOrderAsPaidToVendor_args()
8715 
    args.read(iprot)
8716 
    iprot.readMessageEnd()
8717 
    result = updateOrderAsPaidToVendor_result()
8718 
    try:
8719 
      self._handler.updateOrderAsPaidToVendor(args.orderId)
8720 
    except TransactionServiceException, ex:
8721 
      result.ex = ex
8722 
    oprot.writeMessageBegin("updateOrderAsPaidToVendor", TMessageType.REPLY, seqid)
8723 
    result.write(oprot)
8724 
    oprot.writeMessageEnd()
8725 
    oprot.trans.flush()
5067 varun.gupt 8726 
 
5386 phani.kuma 8727 
  def process_updateOrderOnlyAsPaidToVendor(self, seqid, iprot, oprot):
8728 
    args = updateOrderOnlyAsPaidToVendor_args()
8729 
    args.read(iprot)
8730 
    iprot.readMessageEnd()
8731 
    result = updateOrderOnlyAsPaidToVendor_result()
8732 
    try:
8733 
      self._handler.updateOrderOnlyAsPaidToVendor(args.orderId)
8734 
    except TransactionServiceException, ex:
8735 
      result.ex = ex
8736 
    oprot.writeMessageBegin("updateOrderOnlyAsPaidToVendor", TMessageType.REPLY, seqid)
8737 
    result.write(oprot)
8738 
    oprot.writeMessageEnd()
8739 
    oprot.trans.flush()
8740 
 
5208 varun.gupt 8741 
  def process_getRefundedOrdersMarkedPaid(self, seqid, iprot, oprot):
8742 
    args = getRefundedOrdersMarkedPaid_args()
8743 
    args.read(iprot)
8744 
    iprot.readMessageEnd()
8745 
    result = getRefundedOrdersMarkedPaid_result()
8746 
    try:
8747 
      result.success = self._handler.getRefundedOrdersMarkedPaid()
8748 
    except TransactionServiceException, ex:
8749 
      result.ex = ex
8750 
    oprot.writeMessageBegin("getRefundedOrdersMarkedPaid", TMessageType.REPLY, seqid)
8751 
    result.write(oprot)
8752 
    oprot.writeMessageEnd()
8753 
    oprot.trans.flush()
5099 varun.gupt 8754 
 
5447 anupam.sin 8755 
  def process_getAllVerificationAgents(self, seqid, iprot, oprot):
8756 
    args = getAllVerificationAgents_args()
8757 
    args.read(iprot)
8758 
    iprot.readMessageEnd()
8759 
    result = getAllVerificationAgents_result()
8760 
    result.success = self._handler.getAllVerificationAgents(args.minOrderId, args.maxOrderId)
8761 
    oprot.writeMessageBegin("getAllVerificationAgents", TMessageType.REPLY, seqid)
8762 
    result.write(oprot)
8763 
    oprot.writeMessageEnd()
8764 
    oprot.trans.flush()
5208 varun.gupt 8765 
 
5527 anupam.sin 8766 
  def process_getAllAttributesForOrderId(self, seqid, iprot, oprot):
8767 
    args = getAllAttributesForOrderId_args()
8768 
    args.read(iprot)
8769 
    iprot.readMessageEnd()
8770 
    result = getAllAttributesForOrderId_result()
8771 
    result.success = self._handler.getAllAttributesForOrderId(args.orderId)
8772 
    oprot.writeMessageBegin("getAllAttributesForOrderId", TMessageType.REPLY, seqid)
8773 
    result.write(oprot)
8774 
    oprot.writeMessageEnd()
8775 
    oprot.trans.flush()
5447 anupam.sin 8776 
 
5676 rajveer 8777 
  def process_setOrderAttributes(self, seqid, iprot, oprot):
8778 
    args = setOrderAttributes_args()
8779 
    args.read(iprot)
8780 
    iprot.readMessageEnd()
8781 
    result = setOrderAttributes_result()
8782 
    self._handler.setOrderAttributes(args.orderId, args.attributes)
8783 
    oprot.writeMessageBegin("setOrderAttributes", TMessageType.REPLY, seqid)
8784 
    result.write(oprot)
8785 
    oprot.writeMessageEnd()
8786 
    oprot.trans.flush()
8787 
 
5527 anupam.sin 8788 
  def process_setOrderAttributeForTransaction(self, seqid, iprot, oprot):
8789 
    args = setOrderAttributeForTransaction_args()
8790 
    args.read(iprot)
8791 
    iprot.readMessageEnd()
8792 
    result = setOrderAttributeForTransaction_result()
8793 
    self._handler.setOrderAttributeForTransaction(args.transactionId, args.attribute)
8794 
    oprot.writeMessageBegin("setOrderAttributeForTransaction", TMessageType.REPLY, seqid)
8795 
    result.write(oprot)
8796 
    oprot.writeMessageEnd()
8797 
    oprot.trans.flush()
8798 
 
5553 rajveer 8799 
  def process_getReceivePendingOrders(self, seqid, iprot, oprot):
8800 
    args = getReceivePendingOrders_args()
8801 
    args.read(iprot)
8802 
    iprot.readMessageEnd()
8803 
    result = getReceivePendingOrders_result()
8804 
    result.success = self._handler.getReceivePendingOrders(args.storeId)
8805 
    oprot.writeMessageBegin("getReceivePendingOrders", TMessageType.REPLY, seqid)
8806 
    result.write(oprot)
8807 
    oprot.writeMessageEnd()
8808 
    oprot.trans.flush()
5527 anupam.sin 8809 
 
5553 rajveer 8810 
  def process_getReceivedAtStoreOrders(self, seqid, iprot, oprot):
8811 
    args = getReceivedAtStoreOrders_args()
8812 
    args.read(iprot)
8813 
    iprot.readMessageEnd()
8814 
    result = getReceivedAtStoreOrders_result()
8815 
    result.success = self._handler.getReceivedAtStoreOrders(args.storeId)
8816 
    oprot.writeMessageBegin("getReceivedAtStoreOrders", TMessageType.REPLY, seqid)
8817 
    result.write(oprot)
8818 
    oprot.writeMessageEnd()
8819 
    oprot.trans.flush()
8820 
 
5713 rajveer 8821 
  def process_getOrdersCollectionAtStore(self, seqid, iprot, oprot):
8822 
    args = getOrdersCollectionAtStore_args()
8823 
    args.read(iprot)
8824 
    iprot.readMessageEnd()
8825 
    result = getOrdersCollectionAtStore_result()
8826 
    result.success = self._handler.getOrdersCollectionAtStore(args.storeId, args.fromDate, args.toDate, args.onlyCod)
8827 
    oprot.writeMessageBegin("getOrdersCollectionAtStore", TMessageType.REPLY, seqid)
8828 
    result.write(oprot)
8829 
    oprot.writeMessageEnd()
8830 
    oprot.trans.flush()
8831 
 
5833 rajveer 8832 
  def process_getOrderAttributeValue(self, seqid, iprot, oprot):
8833 
    args = getOrderAttributeValue_args()
8834 
    args.read(iprot)
8835 
    iprot.readMessageEnd()
8836 
    result = getOrderAttributeValue_result()
8837 
    result.success = self._handler.getOrderAttributeValue(args.orderId, args.attributeName)
8838 
    oprot.writeMessageBegin("getOrderAttributeValue", TMessageType.REPLY, seqid)
8839 
    result.write(oprot)
8840 
    oprot.writeMessageEnd()
8841 
    oprot.trans.flush()
8842 
 
6019 rajveer 8843 
  def process_changeJacketNumber(self, seqid, iprot, oprot):
8844 
    args = changeJacketNumber_args()
8845 
    args.read(iprot)
8846 
    iprot.readMessageEnd()
8847 
    result = changeJacketNumber_result()
8848 
    result.success = self._handler.changeJacketNumber(args.orderId, args.jacketNumber)
8849 
    oprot.writeMessageBegin("changeJacketNumber", TMessageType.REPLY, seqid)
8850 
    result.write(oprot)
8851 
    oprot.writeMessageEnd()
8852 
    oprot.trans.flush()
8853 
 
8854 
  def process_markOrderAsRtoInTransit(self, seqid, iprot, oprot):
8855 
    args = markOrderAsRtoInTransit_args()
8856 
    args.read(iprot)
8857 
    iprot.readMessageEnd()
8858 
    result = markOrderAsRtoInTransit_result()
8859 
    result.success = self._handler.markOrderAsRtoInTransit(args.orderId)
8860 
    oprot.writeMessageBegin("markOrderAsRtoInTransit", TMessageType.REPLY, seqid)
8861 
    result.write(oprot)
8862 
    oprot.writeMessageEnd()
8863 
    oprot.trans.flush()
8864 
 
5593 mandeep.dh 8865 
  def process_acceptOrderForItem(self, seqid, iprot, oprot):
8866 
    args = acceptOrderForItem_args()
8867 
    args.read(iprot)
8868 
    iprot.readMessageEnd()
8869 
    result = acceptOrderForItem_result()
8870 
    self._handler.acceptOrderForItem(args.itemId, args.quantity, args.fulfilmentWarehouseId, args.billingWarehouseId)
8871 
    oprot.writeMessageBegin("acceptOrderForItem", TMessageType.REPLY, seqid)
8872 
    result.write(oprot)
8873 
    oprot.writeMessageEnd()
8874 
    oprot.trans.flush()
5553 rajveer 8875 
 
6000 mandeep.dh 8876 
  def process_createRechargeOrder(self, seqid, iprot, oprot):
8877 
    args = createRechargeOrder_args()
8878 
    args.read(iprot)
8879 
    iprot.readMessageEnd()
8880 
    result = createRechargeOrder_result()
8881 
    try:
8882 
      result.success = self._handler.createRechargeOrder(args.rechargeOrder)
8883 
    except TransactionServiceException, ex:
8884 
      result.ex = ex
8885 
    oprot.writeMessageBegin("createRechargeOrder", TMessageType.REPLY, seqid)
8886 
    result.write(oprot)
8887 
    oprot.writeMessageEnd()
8888 
    oprot.trans.flush()
5593 mandeep.dh 8889 
 
6031 rajveer 8890 
  def process_getRechargeOrder(self, seqid, iprot, oprot):
8891 
    args = getRechargeOrder_args()
8892 
    args.read(iprot)
8893 
    iprot.readMessageEnd()
8894 
    result = getRechargeOrder_result()
8895 
    try:
8896 
      result.success = self._handler.getRechargeOrder(args.rechargeRrderId)
8897 
    except TransactionServiceException, ex:
8898 
      result.ex = ex
8899 
    oprot.writeMessageBegin("getRechargeOrder", TMessageType.REPLY, seqid)
8900 
    result.write(oprot)
8901 
    oprot.writeMessageEnd()
8902 
    oprot.trans.flush()
8903 
 
8904 
  def process_getRechargeOrders(self, seqid, iprot, oprot):
8905 
    args = getRechargeOrders_args()
8906 
    args.read(iprot)
8907 
    iprot.readMessageEnd()
8908 
    result = getRechargeOrders_result()
8909 
    result.success = self._handler.getRechargeOrders(args.userId)
8910 
    oprot.writeMessageBegin("getRechargeOrders", TMessageType.REPLY, seqid)
8911 
    result.write(oprot)
8912 
    oprot.writeMessageEnd()
8913 
    oprot.trans.flush()
8914 
 
6000 mandeep.dh 8915 
  def process_updateRechargeOrderStatus(self, seqid, iprot, oprot):
8916 
    args = updateRechargeOrderStatus_args()
8917 
    args.read(iprot)
8918 
    iprot.readMessageEnd()
8919 
    result = updateRechargeOrderStatus_result()
8920 
    try:
6031 rajveer 8921 
      result.success = self._handler.updateRechargeOrderStatus(args.rechargeOrderId, args.rechargeOrderStatus)
6000 mandeep.dh 8922 
    except TransactionServiceException, ex:
8923 
      result.ex = ex
8924 
    oprot.writeMessageBegin("updateRechargeOrderStatus", TMessageType.REPLY, seqid)
8925 
    result.write(oprot)
8926 
    oprot.writeMessageEnd()
8927 
    oprot.trans.flush()
8928 
 
8929 
  def process_activateRechargeTxn(self, seqid, iprot, oprot):
8930 
    args = activateRechargeTxn_args()
8931 
    args.read(iprot)
8932 
    iprot.readMessageEnd()
8933 
    result = activateRechargeTxn_result()
8934 
    try:
6031 rajveer 8935 
      result.success = self._handler.activateRechargeTxn(args.rechargeOrderId)
6000 mandeep.dh 8936 
    except TransactionServiceException, ex:
8937 
      result.ex = ex
8938 
    oprot.writeMessageBegin("activateRechargeTxn", TMessageType.REPLY, seqid)
8939 
    result.write(oprot)
8940 
    oprot.writeMessageEnd()
8941 
    oprot.trans.flush()
8942 
 
6031 rajveer 8943 
  def process_getUserWallet(self, seqid, iprot, oprot):
8944 
    args = getUserWallet_args()
6000 mandeep.dh 8945 
    args.read(iprot)
8946 
    iprot.readMessageEnd()
6031 rajveer 8947 
    result = getUserWallet_result()
8948 
    result.success = self._handler.getUserWallet(args.userId)
8949 
    oprot.writeMessageBegin("getUserWallet", TMessageType.REPLY, seqid)
6000 mandeep.dh 8950 
    result.write(oprot)
8951 
    oprot.writeMessageEnd()
8952 
    oprot.trans.flush()
8953 
 
6031 rajveer 8954 
  def process_getUserWalletHistory(self, seqid, iprot, oprot):
8955 
    args = getUserWalletHistory_args()
6000 mandeep.dh 8956 
    args.read(iprot)
8957 
    iprot.readMessageEnd()
6031 rajveer 8958 
    result = getUserWalletHistory_result()
8959 
    result.success = self._handler.getUserWalletHistory(args.userId)
8960 
    oprot.writeMessageBegin("getUserWalletHistory", TMessageType.REPLY, seqid)
6000 mandeep.dh 8961 
    result.write(oprot)
8962 
    oprot.writeMessageEnd()
8963 
    oprot.trans.flush()
8964 
 
6050 anupam.sin 8965 
  def process_getRechargeOrdersForTransaction(self, seqid, iprot, oprot):
8966 
    args = getRechargeOrdersForTransaction_args()
8967 
    args.read(iprot)
8968 
    iprot.readMessageEnd()
8969 
    result = getRechargeOrdersForTransaction_result()
8970 
    try:
8971 
      result.success = self._handler.getRechargeOrdersForTransaction(args.txnId)
8972 
    except TransactionServiceException, ex:
8973 
      result.ex = ex
8974 
    oprot.writeMessageBegin("getRechargeOrdersForTransaction", TMessageType.REPLY, seqid)
8975 
    result.write(oprot)
8976 
    oprot.writeMessageEnd()
8977 
    oprot.trans.flush()
8978 
 
6048 rajveer 8979 
  def process_getServiceProviders(self, seqid, iprot, oprot):
8980 
    args = getServiceProviders_args()
8981 
    args.read(iprot)
8982 
    iprot.readMessageEnd()
8983 
    result = getServiceProviders_result()
6206 rajveer 8984 
    result.success = self._handler.getServiceProviders(args.rechargeType, args.onlyActive)
6048 rajveer 8985 
    oprot.writeMessageBegin("getServiceProviders", TMessageType.REPLY, seqid)
8986 
    result.write(oprot)
8987 
    oprot.writeMessageEnd()
8988 
    oprot.trans.flush()
6000 mandeep.dh 8989 
 
6048 rajveer 8990 
  def process_getServiceProviderForDevice(self, seqid, iprot, oprot):
8991 
    args = getServiceProviderForDevice_args()
8992 
    args.read(iprot)
8993 
    iprot.readMessageEnd()
8994 
    result = getServiceProviderForDevice_result()
6049 rajveer 8995 
    result.success = self._handler.getServiceProviderForDevice(args.rechargeType, args.deviceNumber)
6048 rajveer 8996 
    oprot.writeMessageBegin("getServiceProviderForDevice", TMessageType.REPLY, seqid)
8997 
    result.write(oprot)
8998 
    oprot.writeMessageEnd()
8999 
    oprot.trans.flush()
9000 
 
6269 rajveer 9001 
  def process_validateRecharge(self, seqid, iprot, oprot):
9002 
    args = validateRecharge_args()
9003 
    args.read(iprot)
9004 
    iprot.readMessageEnd()
9005 
    result = validateRecharge_result()
6591 anupam.sin 9006 
    result.success = self._handler.validateRecharge(args.rechargeType, args.deviceNumber, args.userSelectedProviderId, args.clientAddress)
6269 rajveer 9007 
    oprot.writeMessageBegin("validateRecharge", TMessageType.REPLY, seqid)
9008 
    result.write(oprot)
9009 
    oprot.writeMessageEnd()
9010 
    oprot.trans.flush()
9011 
 
6094 rajveer 9012 
  def process_getRechargeOrdersForDevice(self, seqid, iprot, oprot):
9013 
    args = getRechargeOrdersForDevice_args()
9014 
    args.read(iprot)
9015 
    iprot.readMessageEnd()
9016 
    result = getRechargeOrdersForDevice_result()
9017 
    result.success = self._handler.getRechargeOrdersForDevice(args.deviceNumber)
9018 
    oprot.writeMessageBegin("getRechargeOrdersForDevice", TMessageType.REPLY, seqid)
9019 
    result.write(oprot)
9020 
    oprot.writeMessageEnd()
9021 
    oprot.trans.flush()
6048 rajveer 9022 
 
6094 rajveer 9023 
  def process_addAmountToWallet(self, seqid, iprot, oprot):
9024 
    args = addAmountToWallet_args()
9025 
    args.read(iprot)
9026 
    iprot.readMessageEnd()
9027 
    result = addAmountToWallet_result()
9028 
    self._handler.addAmountToWallet(args.userId, args.orderId, args.amount)
9029 
    oprot.writeMessageBegin("addAmountToWallet", TMessageType.REPLY, seqid)
9030 
    result.write(oprot)
9031 
    oprot.writeMessageEnd()
9032 
    oprot.trans.flush()
9033 
 
6188 rajveer 9034 
  def process_getRechargeStatistics(self, seqid, iprot, oprot):
9035 
    args = getRechargeStatistics_args()
9036 
    args.read(iprot)
9037 
    iprot.readMessageEnd()
9038 
    result = getRechargeStatistics_result()
9039 
    result.success = self._handler.getRechargeStatistics()
9040 
    oprot.writeMessageBegin("getRechargeStatistics", TMessageType.REPLY, seqid)
9041 
    result.write(oprot)
9042 
    oprot.writeMessageEnd()
9043 
    oprot.trans.flush()
9044 
 
6154 rajveer 9045 
  def process_getRechargeOrdersForStatus(self, seqid, iprot, oprot):
9046 
    args = getRechargeOrdersForStatus_args()
9047 
    args.read(iprot)
9048 
    iprot.readMessageEnd()
9049 
    result = getRechargeOrdersForStatus_result()
9050 
    result.success = self._handler.getRechargeOrdersForStatus(args.status)
9051 
    oprot.writeMessageBegin("getRechargeOrdersForStatus", TMessageType.REPLY, seqid)
9052 
    result.write(oprot)
9053 
    oprot.writeMessageEnd()
9054 
    oprot.trans.flush()
6094 rajveer 9055 
 
6159 rajveer 9056 
  def process_getPlansForOperator(self, seqid, iprot, oprot):
9057 
    args = getPlansForOperator_args()
9058 
    args.read(iprot)
9059 
    iprot.readMessageEnd()
9060 
    result = getPlansForOperator_result()
9061 
    result.success = self._handler.getPlansForOperator(args.operatorId)
9062 
    oprot.writeMessageBegin("getPlansForOperator", TMessageType.REPLY, seqid)
9063 
    result.write(oprot)
9064 
    oprot.writeMessageEnd()
9065 
    oprot.trans.flush()
6154 rajveer 9066 
 
6289 anupam.sin 9067 
  def process_getRechargeDenominations(self, seqid, iprot, oprot):
9068 
    args = getRechargeDenominations_args()
9069 
    args.read(iprot)
9070 
    iprot.readMessageEnd()
9071 
    result = getRechargeDenominations_result()
9072 
    try:
6307 anupam.sin 9073 
      result.success = self._handler.getRechargeDenominations(args.operatorId, args.circleCode, args.denominationType)
6289 anupam.sin 9074 
    except TransactionServiceException, ex:
9075 
      result.ex = ex
9076 
    oprot.writeMessageBegin("getRechargeDenominations", TMessageType.REPLY, seqid)
9077 
    result.write(oprot)
9078 
    oprot.writeMessageEnd()
9079 
    oprot.trans.flush()
6159 rajveer 9080 
 
6371 rajveer 9081 
  def process_updateAvailabilityStatus(self, seqid, iprot, oprot):
9082 
    args = updateAvailabilityStatus_args()
9083 
    args.read(iprot)
9084 
    iprot.readMessageEnd()
9085 
    result = updateAvailabilityStatus_result()
9086 
    self._handler.updateAvailabilityStatus(args.operatorId, args.circleId, args.isAvailable)
9087 
    oprot.writeMessageBegin("updateAvailabilityStatus", TMessageType.REPLY, seqid)
9088 
    result.write(oprot)
9089 
    oprot.writeMessageEnd()
9090 
    oprot.trans.flush()
6289 anupam.sin 9091 
 
6389 rajveer 9092 
  def process_getAvailableEmiSchemes(self, seqid, iprot, oprot):
9093 
    args = getAvailableEmiSchemes_args()
9094 
    args.read(iprot)
9095 
    iprot.readMessageEnd()
9096 
    result = getAvailableEmiSchemes_result()
9097 
    result.success = self._handler.getAvailableEmiSchemes()
9098 
    oprot.writeMessageBegin("getAvailableEmiSchemes", TMessageType.REPLY, seqid)
9099 
    result.write(oprot)
9100 
    oprot.writeMessageEnd()
9101 
    oprot.trans.flush()
6371 rajveer 9102 
 
6389 rajveer 9103 
  def process_getMiscCharges(self, seqid, iprot, oprot):
9104 
    args = getMiscCharges_args()
9105 
    args.read(iprot)
9106 
    iprot.readMessageEnd()
9107 
    result = getMiscCharges_result()
9108 
    result.success = self._handler.getMiscCharges(args.transactionId)
9109 
    oprot.writeMessageBegin("getMiscCharges", TMessageType.REPLY, seqid)
9110 
    result.write(oprot)
9111 
    oprot.writeMessageEnd()
9112 
    oprot.trans.flush()
9113 
 
6507 anupam.sin 9114 
  def process_refundRechargeOrder(self, seqid, iprot, oprot):
9115 
    args = refundRechargeOrder_args()
9116 
    args.read(iprot)
9117 
    iprot.readMessageEnd()
9118 
    result = refundRechargeOrder_result()
9119 
    try:
9120 
      result.success = self._handler.refundRechargeOrder(args.rechargeOrderId)
9121 
    except TransactionServiceException, ex:
9122 
      result.ex = ex
9123 
    oprot.writeMessageBegin("refundRechargeOrder", TMessageType.REPLY, seqid)
9124 
    result.write(oprot)
9125 
    oprot.writeMessageEnd()
9126 
    oprot.trans.flush()
6389 rajveer 9127 
 
6821 amar.kumar 9128 
  def process_getPhysicalOrders(self, seqid, iprot, oprot):
9129 
    args = getPhysicalOrders_args()
9130 
    args.read(iprot)
9131 
    iprot.readMessageEnd()
9132 
    result = getPhysicalOrders_result()
9133 
    result.success = self._handler.getPhysicalOrders(args.fromDate, args.toDate)
9134 
    oprot.writeMessageBegin("getPhysicalOrders", TMessageType.REPLY, seqid)
9135 
    result.write(oprot)
9136 
    oprot.writeMessageEnd()
9137 
    oprot.trans.flush()
6507 anupam.sin 9138 
 
6906 rajveer 9139 
  def process_getDocument(self, seqid, iprot, oprot):
9140 
    args = getDocument_args()
9141 
    args.read(iprot)
9142 
    iprot.readMessageEnd()
9143 
    result = getDocument_result()
9144 
    result.success = self._handler.getDocument(args.docType, args.docSource)
9145 
    oprot.writeMessageBegin("getDocument", TMessageType.REPLY, seqid)
9146 
    result.write(oprot)
9147 
    oprot.writeMessageEnd()
9148 
    oprot.trans.flush()
6821 amar.kumar 9149 
 
6985 anupam.sin 9150 
  def process_changeShippingAddress(self, seqid, iprot, oprot):
9151 
    args = changeShippingAddress_args()
9152 
    args.read(iprot)
9153 
    iprot.readMessageEnd()
9154 
    result = changeShippingAddress_result()
9155 
    result.success = self._handler.changeShippingAddress(args.orderId, args.line1, args.line2, args.city, args.state, args.pin)
9156 
    oprot.writeMessageBegin("changeShippingAddress", TMessageType.REPLY, seqid)
9157 
    result.write(oprot)
9158 
    oprot.writeMessageEnd()
9159 
    oprot.trans.flush()
6906 rajveer 9160 
 
6988 rajveer 9161 
  def process_retrieveInvoice(self, seqid, iprot, oprot):
9162 
    args = retrieveInvoice_args()
9163 
    args.read(iprot)
9164 
    iprot.readMessageEnd()
9165 
    result = retrieveInvoice_result()
7075 rajveer 9166 
    result.success = self._handler.retrieveInvoice(args.orderId, args.userId)
6988 rajveer 9167 
    oprot.writeMessageBegin("retrieveInvoice", TMessageType.REPLY, seqid)
9168 
    result.write(oprot)
9169 
    oprot.writeMessageEnd()
9170 
    oprot.trans.flush()
6985 anupam.sin 9171 
 
7026 rajveer 9172 
  def process_receiveUpdatesForRedExpress(self, seqid, iprot, oprot):
9173 
    args = receiveUpdatesForRedExpress_args()
9174 
    args.read(iprot)
9175 
    iprot.readMessageEnd()
9176 
    result = receiveUpdatesForRedExpress_result()
9177 
    result.success = self._handler.receiveUpdatesForRedExpress(args.awbNumber)
9178 
    oprot.writeMessageBegin("receiveUpdatesForRedExpress", TMessageType.REPLY, seqid)
9179 
    result.write(oprot)
9180 
    oprot.writeMessageEnd()
9181 
    oprot.trans.flush()
6988 rajveer 9182 
 
7073 anupam.sin 9183 
  def process_createRechargeTransaction(self, seqid, iprot, oprot):
9184 
    args = createRechargeTransaction_args()
9185 
    args.read(iprot)
9186 
    iprot.readMessageEnd()
9187 
    result = createRechargeTransaction_result()
9188 
    result.success = self._handler.createRechargeTransaction(args.thriftRechargeTransaction)
9189 
    oprot.writeMessageBegin("createRechargeTransaction", TMessageType.REPLY, seqid)
9190 
    result.write(oprot)
9191 
    oprot.writeMessageEnd()
9192 
    oprot.trans.flush()
7026 rajveer 9193 
 
7085 rajveer 9194 
  def process_getRechargeTransactions(self, seqid, iprot, oprot):
9195 
    args = getRechargeTransactions_args()
9196 
    args.read(iprot)
9197 
    iprot.readMessageEnd()
9198 
    result = getRechargeTransactions_result()
9199 
    result.success = self._handler.getRechargeTransactions(args.storeId)
9200 
    oprot.writeMessageBegin("getRechargeTransactions", TMessageType.REPLY, seqid)
9201 
    result.write(oprot)
9202 
    oprot.writeMessageEnd()
9203 
    oprot.trans.flush()
9204 
 
7080 anupam.sin 9205 
  def process_getRechargeTransaction(self, seqid, iprot, oprot):
9206 
    args = getRechargeTransaction_args()
9207 
    args.read(iprot)
9208 
    iprot.readMessageEnd()
9209 
    result = getRechargeTransaction_result()
9210 
    result.success = self._handler.getRechargeTransaction(args.rechargeId)
9211 
    oprot.writeMessageBegin("getRechargeTransaction", TMessageType.REPLY, seqid)
9212 
    result.write(oprot)
9213 
    oprot.writeMessageEnd()
9214 
    oprot.trans.flush()
7073 anupam.sin 9215 
 
7080 anupam.sin 9216 
  def process_getFRCs(self, seqid, iprot, oprot):
9217 
    args = getFRCs_args()
9218 
    args.read(iprot)
9219 
    iprot.readMessageEnd()
9220 
    result = getFRCs_result()
9221 
    result.success = self._handler.getFRCs(args.circleId, args.operatorId)
9222 
    oprot.writeMessageBegin("getFRCs", TMessageType.REPLY, seqid)
9223 
    result.write(oprot)
9224 
    oprot.writeMessageEnd()
9225 
    oprot.trans.flush()
9226 
 
7096 anupam.sin 9227 
  def process_getHotspotStore(self, seqid, iprot, oprot):
9228 
    args = getHotspotStore_args()
9229 
    args.read(iprot)
9230 
    iprot.readMessageEnd()
9231 
    result = getHotspotStore_result()
9232 
    result.success = self._handler.getHotspotStore(args.id, args.hotspotid)
9233 
    oprot.writeMessageBegin("getHotspotStore", TMessageType.REPLY, seqid)
9234 
    result.write(oprot)
9235 
    oprot.writeMessageEnd()
9236 
    oprot.trans.flush()
7080 anupam.sin 9237 
 
7096 anupam.sin 9238 
  def process_getTelecomCircle(self, seqid, iprot, oprot):
9239 
    args = getTelecomCircle_args()
9240 
    args.read(iprot)
9241 
    iprot.readMessageEnd()
9242 
    result = getTelecomCircle_result()
9243 
    result.success = self._handler.getTelecomCircle(args.id, args.code)
9244 
    oprot.writeMessageBegin("getTelecomCircle", TMessageType.REPLY, seqid)
9245 
    result.write(oprot)
9246 
    oprot.writeMessageEnd()
9247 
    oprot.trans.flush()
9248 
 
7109 anupam.sin 9249 
  def process_retrieveHotspotRechargeInvoice(self, seqid, iprot, oprot):
9250 
    args = retrieveHotspotRechargeInvoice_args()
9251 
    args.read(iprot)
9252 
    iprot.readMessageEnd()
9253 
    result = retrieveHotspotRechargeInvoice_result()
9254 
    result.success = self._handler.retrieveHotspotRechargeInvoice(args.rechargeId)
9255 
    oprot.writeMessageBegin("retrieveHotspotRechargeInvoice", TMessageType.REPLY, seqid)
9256 
    result.write(oprot)
9257 
    oprot.writeMessageEnd()
9258 
    oprot.trans.flush()
7096 anupam.sin 9259 
 
7109 anupam.sin 9260 
 
94 ashish 9261 
# HELPER FUNCTIONS AND STRUCTURES
9262 
 
9263 
class createTransaction_args:
9264 
  """
9265 
  Attributes:
9266 
   - transaction
9267 
  """
9268 
 
9269 
  thrift_spec = (
9270 
    None, # 0
9271 
    (1, TType.STRUCT, 'transaction', (Transaction, Transaction.thrift_spec), None, ), # 1
9272 
  )
9273 
 
9274 
  def __init__(self, transaction=None,):
9275 
    self.transaction = transaction
9276 
 
9277 
  def read(self, iprot):
9278 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9279 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9280 
      return
9281 
    iprot.readStructBegin()
9282 
    while True:
9283 
      (fname, ftype, fid) = iprot.readFieldBegin()
9284 
      if ftype == TType.STOP:
9285 
        break
9286 
      if fid == 1:
9287 
        if ftype == TType.STRUCT:
9288 
          self.transaction = Transaction()
9289 
          self.transaction.read(iprot)
9290 
        else:
9291 
          iprot.skip(ftype)
9292 
      else:
9293 
        iprot.skip(ftype)
9294 
      iprot.readFieldEnd()
9295 
    iprot.readStructEnd()
9296 
 
9297 
  def write(self, oprot):
9298 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9299 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9300 
      return
9301 
    oprot.writeStructBegin('createTransaction_args')
3431 rajveer 9302 
    if self.transaction is not None:
94 ashish 9303 
      oprot.writeFieldBegin('transaction', TType.STRUCT, 1)
9304 
      self.transaction.write(oprot)
9305 
      oprot.writeFieldEnd()
9306 
    oprot.writeFieldStop()
9307 
    oprot.writeStructEnd()
9308 
 
3431 rajveer 9309 
  def validate(self):
9310 
    return
9311 
 
9312 
 
94 ashish 9313 
  def __repr__(self):
9314 
    L = ['%s=%r' % (key, value)
9315 
      for key, value in self.__dict__.iteritems()]
9316 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9317 
 
9318 
  def __eq__(self, other):
9319 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9320 
 
9321 
  def __ne__(self, other):
9322 
    return not (self == other)
9323 
 
9324 
class createTransaction_result:
9325 
  """
9326 
  Attributes:
132 ashish 9327 
   - success
94 ashish 9328 
   - ex
9329 
  """
9330 
 
9331 
  thrift_spec = (
132 ashish 9332 
    (0, TType.I64, 'success', None, None, ), # 0
94 ashish 9333 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
9334 
  )
9335 
 
132 ashish 9336 
  def __init__(self, success=None, ex=None,):
9337 
    self.success = success
94 ashish 9338 
    self.ex = ex
9339 
 
9340 
  def read(self, iprot):
9341 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9342 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9343 
      return
9344 
    iprot.readStructBegin()
9345 
    while True:
9346 
      (fname, ftype, fid) = iprot.readFieldBegin()
9347 
      if ftype == TType.STOP:
9348 
        break
132 ashish 9349 
      if fid == 0:
9350 
        if ftype == TType.I64:
9351 
          self.success = iprot.readI64();
9352 
        else:
9353 
          iprot.skip(ftype)
9354 
      elif fid == 1:
94 ashish 9355 
        if ftype == TType.STRUCT:
9356 
          self.ex = TransactionServiceException()
9357 
          self.ex.read(iprot)
9358 
        else:
9359 
          iprot.skip(ftype)
9360 
      else:
9361 
        iprot.skip(ftype)
9362 
      iprot.readFieldEnd()
9363 
    iprot.readStructEnd()
9364 
 
9365 
  def write(self, oprot):
9366 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9367 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9368 
      return
9369 
    oprot.writeStructBegin('createTransaction_result')
3431 rajveer 9370 
    if self.success is not None:
132 ashish 9371 
      oprot.writeFieldBegin('success', TType.I64, 0)
9372 
      oprot.writeI64(self.success)
9373 
      oprot.writeFieldEnd()
3431 rajveer 9374 
    if self.ex is not None:
94 ashish 9375 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9376 
      self.ex.write(oprot)
9377 
      oprot.writeFieldEnd()
9378 
    oprot.writeFieldStop()
9379 
    oprot.writeStructEnd()
9380 
 
3431 rajveer 9381 
  def validate(self):
9382 
    return
9383 
 
9384 
 
94 ashish 9385 
  def __repr__(self):
9386 
    L = ['%s=%r' % (key, value)
9387 
      for key, value in self.__dict__.iteritems()]
9388 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9389 
 
9390 
  def __eq__(self, other):
9391 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9392 
 
9393 
  def __ne__(self, other):
9394 
    return not (self == other)
9395 
 
9396 
class getTransaction_args:
9397 
  """
9398 
  Attributes:
9399 
   - id
9400 
  """
9401 
 
9402 
  thrift_spec = (
9403 
    None, # 0
9404 
    (1, TType.I64, 'id', None, None, ), # 1
9405 
  )
9406 
 
9407 
  def __init__(self, id=None,):
9408 
    self.id = id
9409 
 
9410 
  def read(self, iprot):
9411 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9412 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9413 
      return
9414 
    iprot.readStructBegin()
9415 
    while True:
9416 
      (fname, ftype, fid) = iprot.readFieldBegin()
9417 
      if ftype == TType.STOP:
9418 
        break
9419 
      if fid == 1:
9420 
        if ftype == TType.I64:
9421 
          self.id = iprot.readI64();
9422 
        else:
9423 
          iprot.skip(ftype)
9424 
      else:
9425 
        iprot.skip(ftype)
9426 
      iprot.readFieldEnd()
9427 
    iprot.readStructEnd()
9428 
 
9429 
  def write(self, oprot):
9430 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9431 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9432 
      return
9433 
    oprot.writeStructBegin('getTransaction_args')
3431 rajveer 9434 
    if self.id is not None:
94 ashish 9435 
      oprot.writeFieldBegin('id', TType.I64, 1)
9436 
      oprot.writeI64(self.id)
9437 
      oprot.writeFieldEnd()
9438 
    oprot.writeFieldStop()
9439 
    oprot.writeStructEnd()
9440 
 
3431 rajveer 9441 
  def validate(self):
9442 
    return
9443 
 
9444 
 
94 ashish 9445 
  def __repr__(self):
9446 
    L = ['%s=%r' % (key, value)
9447 
      for key, value in self.__dict__.iteritems()]
9448 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9449 
 
9450 
  def __eq__(self, other):
9451 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9452 
 
9453 
  def __ne__(self, other):
9454 
    return not (self == other)
9455 
 
9456 
class getTransaction_result:
9457 
  """
9458 
  Attributes:
9459 
   - success
9460 
   - ex
9461 
  """
9462 
 
9463 
  thrift_spec = (
9464 
    (0, TType.STRUCT, 'success', (Transaction, Transaction.thrift_spec), None, ), # 0
9465 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
9466 
  )
9467 
 
9468 
  def __init__(self, success=None, ex=None,):
9469 
    self.success = success
9470 
    self.ex = ex
9471 
 
9472 
  def read(self, iprot):
9473 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9474 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9475 
      return
9476 
    iprot.readStructBegin()
9477 
    while True:
9478 
      (fname, ftype, fid) = iprot.readFieldBegin()
9479 
      if ftype == TType.STOP:
9480 
        break
9481 
      if fid == 0:
9482 
        if ftype == TType.STRUCT:
9483 
          self.success = Transaction()
9484 
          self.success.read(iprot)
9485 
        else:
9486 
          iprot.skip(ftype)
9487 
      elif fid == 1:
9488 
        if ftype == TType.STRUCT:
9489 
          self.ex = TransactionServiceException()
9490 
          self.ex.read(iprot)
9491 
        else:
9492 
          iprot.skip(ftype)
9493 
      else:
9494 
        iprot.skip(ftype)
9495 
      iprot.readFieldEnd()
9496 
    iprot.readStructEnd()
9497 
 
9498 
  def write(self, oprot):
9499 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9500 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9501 
      return
9502 
    oprot.writeStructBegin('getTransaction_result')
3431 rajveer 9503 
    if self.success is not None:
94 ashish 9504 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
9505 
      self.success.write(oprot)
9506 
      oprot.writeFieldEnd()
3431 rajveer 9507 
    if self.ex is not None:
94 ashish 9508 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9509 
      self.ex.write(oprot)
9510 
      oprot.writeFieldEnd()
9511 
    oprot.writeFieldStop()
9512 
    oprot.writeStructEnd()
9513 
 
3431 rajveer 9514 
  def validate(self):
9515 
    return
9516 
 
9517 
 
94 ashish 9518 
  def __repr__(self):
9519 
    L = ['%s=%r' % (key, value)
9520 
      for key, value in self.__dict__.iteritems()]
9521 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9522 
 
9523 
  def __eq__(self, other):
9524 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9525 
 
9526 
  def __ne__(self, other):
9527 
    return not (self == other)
9528 
 
9529 
class getTransactionsForCustomer_args:
9530 
  """
9531 
  Attributes:
9532 
   - customerId
9533 
   - from_date
9534 
   - to_date
9535 
   - status
9536 
  """
9537 
 
9538 
  thrift_spec = (
9539 
    None, # 0
9540 
    (1, TType.I64, 'customerId', None, None, ), # 1
9541 
    (2, TType.I64, 'from_date', None, None, ), # 2
9542 
    (3, TType.I64, 'to_date', None, None, ), # 3
9543 
    (4, TType.I32, 'status', None, None, ), # 4
9544 
  )
9545 
 
9546 
  def __init__(self, customerId=None, from_date=None, to_date=None, status=None,):
9547 
    self.customerId = customerId
9548 
    self.from_date = from_date
9549 
    self.to_date = to_date
9550 
    self.status = status
9551 
 
9552 
  def read(self, iprot):
9553 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9554 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9555 
      return
9556 
    iprot.readStructBegin()
9557 
    while True:
9558 
      (fname, ftype, fid) = iprot.readFieldBegin()
9559 
      if ftype == TType.STOP:
9560 
        break
9561 
      if fid == 1:
9562 
        if ftype == TType.I64:
9563 
          self.customerId = iprot.readI64();
9564 
        else:
9565 
          iprot.skip(ftype)
9566 
      elif fid == 2:
9567 
        if ftype == TType.I64:
9568 
          self.from_date = iprot.readI64();
9569 
        else:
9570 
          iprot.skip(ftype)
9571 
      elif fid == 3:
9572 
        if ftype == TType.I64:
9573 
          self.to_date = iprot.readI64();
9574 
        else:
9575 
          iprot.skip(ftype)
9576 
      elif fid == 4:
9577 
        if ftype == TType.I32:
9578 
          self.status = iprot.readI32();
9579 
        else:
9580 
          iprot.skip(ftype)
9581 
      else:
9582 
        iprot.skip(ftype)
9583 
      iprot.readFieldEnd()
9584 
    iprot.readStructEnd()
9585 
 
9586 
  def write(self, oprot):
9587 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9588 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9589 
      return
9590 
    oprot.writeStructBegin('getTransactionsForCustomer_args')
3431 rajveer 9591 
    if self.customerId is not None:
94 ashish 9592 
      oprot.writeFieldBegin('customerId', TType.I64, 1)
9593 
      oprot.writeI64(self.customerId)
9594 
      oprot.writeFieldEnd()
3431 rajveer 9595 
    if self.from_date is not None:
94 ashish 9596 
      oprot.writeFieldBegin('from_date', TType.I64, 2)
9597 
      oprot.writeI64(self.from_date)
9598 
      oprot.writeFieldEnd()
3431 rajveer 9599 
    if self.to_date is not None:
94 ashish 9600 
      oprot.writeFieldBegin('to_date', TType.I64, 3)
9601 
      oprot.writeI64(self.to_date)
9602 
      oprot.writeFieldEnd()
3431 rajveer 9603 
    if self.status is not None:
94 ashish 9604 
      oprot.writeFieldBegin('status', TType.I32, 4)
9605 
      oprot.writeI32(self.status)
9606 
      oprot.writeFieldEnd()
9607 
    oprot.writeFieldStop()
9608 
    oprot.writeStructEnd()
9609 
 
3431 rajveer 9610 
  def validate(self):
9611 
    return
9612 
 
9613 
 
94 ashish 9614 
  def __repr__(self):
9615 
    L = ['%s=%r' % (key, value)
9616 
      for key, value in self.__dict__.iteritems()]
9617 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9618 
 
9619 
  def __eq__(self, other):
9620 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9621 
 
9622 
  def __ne__(self, other):
9623 
    return not (self == other)
9624 
 
9625 
class getTransactionsForCustomer_result:
9626 
  """
9627 
  Attributes:
9628 
   - success
9629 
   - ex
9630 
  """
9631 
 
9632 
  thrift_spec = (
9633 
    (0, TType.LIST, 'success', (TType.STRUCT,(Transaction, Transaction.thrift_spec)), None, ), # 0
9634 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
9635 
  )
9636 
 
9637 
  def __init__(self, success=None, ex=None,):
9638 
    self.success = success
9639 
    self.ex = ex
9640 
 
9641 
  def read(self, iprot):
9642 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9643 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9644 
      return
9645 
    iprot.readStructBegin()
9646 
    while True:
9647 
      (fname, ftype, fid) = iprot.readFieldBegin()
9648 
      if ftype == TType.STOP:
9649 
        break
9650 
      if fid == 0:
9651 
        if ftype == TType.LIST:
9652 
          self.success = []
6188 rajveer 9653 
          (_etype109, _size106) = iprot.readListBegin()
9654 
          for _i110 in xrange(_size106):
9655 
            _elem111 = Transaction()
9656 
            _elem111.read(iprot)
9657 
            self.success.append(_elem111)
94 ashish 9658 
          iprot.readListEnd()
9659 
        else:
9660 
          iprot.skip(ftype)
9661 
      elif fid == 1:
9662 
        if ftype == TType.STRUCT:
9663 
          self.ex = TransactionServiceException()
9664 
          self.ex.read(iprot)
9665 
        else:
9666 
          iprot.skip(ftype)
9667 
      else:
9668 
        iprot.skip(ftype)
9669 
      iprot.readFieldEnd()
9670 
    iprot.readStructEnd()
9671 
 
9672 
  def write(self, oprot):
9673 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9674 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9675 
      return
9676 
    oprot.writeStructBegin('getTransactionsForCustomer_result')
3431 rajveer 9677 
    if self.success is not None:
94 ashish 9678 
      oprot.writeFieldBegin('success', TType.LIST, 0)
9679 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 9680 
      for iter112 in self.success:
9681 
        iter112.write(oprot)
94 ashish 9682 
      oprot.writeListEnd()
9683 
      oprot.writeFieldEnd()
3431 rajveer 9684 
    if self.ex is not None:
94 ashish 9685 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9686 
      self.ex.write(oprot)
9687 
      oprot.writeFieldEnd()
9688 
    oprot.writeFieldStop()
9689 
    oprot.writeStructEnd()
9690 
 
3431 rajveer 9691 
  def validate(self):
9692 
    return
9693 
 
9694 
 
94 ashish 9695 
  def __repr__(self):
9696 
    L = ['%s=%r' % (key, value)
9697 
      for key, value in self.__dict__.iteritems()]
9698 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9699 
 
9700 
  def __eq__(self, other):
9701 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9702 
 
9703 
  def __ne__(self, other):
9704 
    return not (self == other)
9705 
 
132 ashish 9706 
class getTransactionsForShoppingCartId_args:
9707 
  """
9708 
  Attributes:
9709 
   - shoppingCartId
9710 
  """
9711 
 
9712 
  thrift_spec = (
9713 
    None, # 0
9714 
    (1, TType.I64, 'shoppingCartId', None, None, ), # 1
9715 
  )
9716 
 
9717 
  def __init__(self, shoppingCartId=None,):
9718 
    self.shoppingCartId = shoppingCartId
9719 
 
9720 
  def read(self, iprot):
9721 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9722 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9723 
      return
9724 
    iprot.readStructBegin()
9725 
    while True:
9726 
      (fname, ftype, fid) = iprot.readFieldBegin()
9727 
      if ftype == TType.STOP:
9728 
        break
9729 
      if fid == 1:
9730 
        if ftype == TType.I64:
9731 
          self.shoppingCartId = iprot.readI64();
9732 
        else:
9733 
          iprot.skip(ftype)
9734 
      else:
9735 
        iprot.skip(ftype)
9736 
      iprot.readFieldEnd()
9737 
    iprot.readStructEnd()
9738 
 
9739 
  def write(self, oprot):
9740 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9741 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9742 
      return
9743 
    oprot.writeStructBegin('getTransactionsForShoppingCartId_args')
3431 rajveer 9744 
    if self.shoppingCartId is not None:
132 ashish 9745 
      oprot.writeFieldBegin('shoppingCartId', TType.I64, 1)
9746 
      oprot.writeI64(self.shoppingCartId)
9747 
      oprot.writeFieldEnd()
9748 
    oprot.writeFieldStop()
9749 
    oprot.writeStructEnd()
9750 
 
3431 rajveer 9751 
  def validate(self):
9752 
    return
9753 
 
9754 
 
132 ashish 9755 
  def __repr__(self):
9756 
    L = ['%s=%r' % (key, value)
9757 
      for key, value in self.__dict__.iteritems()]
9758 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9759 
 
9760 
  def __eq__(self, other):
9761 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9762 
 
9763 
  def __ne__(self, other):
9764 
    return not (self == other)
9765 
 
9766 
class getTransactionsForShoppingCartId_result:
9767 
  """
9768 
  Attributes:
9769 
   - success
9770 
   - ex
9771 
  """
9772 
 
9773 
  thrift_spec = (
9774 
    (0, TType.LIST, 'success', (TType.STRUCT,(Transaction, Transaction.thrift_spec)), None, ), # 0
9775 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
9776 
  )
9777 
 
9778 
  def __init__(self, success=None, ex=None,):
9779 
    self.success = success
9780 
    self.ex = ex
9781 
 
9782 
  def read(self, iprot):
9783 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9784 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9785 
      return
9786 
    iprot.readStructBegin()
9787 
    while True:
9788 
      (fname, ftype, fid) = iprot.readFieldBegin()
9789 
      if ftype == TType.STOP:
9790 
        break
9791 
      if fid == 0:
9792 
        if ftype == TType.LIST:
9793 
          self.success = []
6188 rajveer 9794 
          (_etype116, _size113) = iprot.readListBegin()
9795 
          for _i117 in xrange(_size113):
9796 
            _elem118 = Transaction()
9797 
            _elem118.read(iprot)
9798 
            self.success.append(_elem118)
132 ashish 9799 
          iprot.readListEnd()
9800 
        else:
9801 
          iprot.skip(ftype)
9802 
      elif fid == 1:
9803 
        if ftype == TType.STRUCT:
9804 
          self.ex = TransactionServiceException()
9805 
          self.ex.read(iprot)
9806 
        else:
9807 
          iprot.skip(ftype)
9808 
      else:
9809 
        iprot.skip(ftype)
9810 
      iprot.readFieldEnd()
9811 
    iprot.readStructEnd()
9812 
 
9813 
  def write(self, oprot):
9814 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9815 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9816 
      return
9817 
    oprot.writeStructBegin('getTransactionsForShoppingCartId_result')
3431 rajveer 9818 
    if self.success is not None:
132 ashish 9819 
      oprot.writeFieldBegin('success', TType.LIST, 0)
9820 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 9821 
      for iter119 in self.success:
9822 
        iter119.write(oprot)
132 ashish 9823 
      oprot.writeListEnd()
9824 
      oprot.writeFieldEnd()
3431 rajveer 9825 
    if self.ex is not None:
132 ashish 9826 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9827 
      self.ex.write(oprot)
9828 
      oprot.writeFieldEnd()
9829 
    oprot.writeFieldStop()
9830 
    oprot.writeStructEnd()
9831 
 
3431 rajveer 9832 
  def validate(self):
9833 
    return
9834 
 
9835 
 
132 ashish 9836 
  def __repr__(self):
9837 
    L = ['%s=%r' % (key, value)
9838 
      for key, value in self.__dict__.iteritems()]
9839 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9840 
 
9841 
  def __eq__(self, other):
9842 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9843 
 
9844 
  def __ne__(self, other):
9845 
    return not (self == other)
9846 
 
94 ashish 9847 
class getTransactionStatus_args:
9848 
  """
9849 
  Attributes:
9850 
   - transactionId
9851 
  """
9852 
 
9853 
  thrift_spec = (
9854 
    None, # 0
9855 
    (1, TType.I64, 'transactionId', None, None, ), # 1
9856 
  )
9857 
 
9858 
  def __init__(self, transactionId=None,):
9859 
    self.transactionId = transactionId
9860 
 
9861 
  def read(self, iprot):
9862 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9863 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9864 
      return
9865 
    iprot.readStructBegin()
9866 
    while True:
9867 
      (fname, ftype, fid) = iprot.readFieldBegin()
9868 
      if ftype == TType.STOP:
9869 
        break
9870 
      if fid == 1:
9871 
        if ftype == TType.I64:
9872 
          self.transactionId = iprot.readI64();
9873 
        else:
9874 
          iprot.skip(ftype)
9875 
      else:
9876 
        iprot.skip(ftype)
9877 
      iprot.readFieldEnd()
9878 
    iprot.readStructEnd()
9879 
 
9880 
  def write(self, oprot):
9881 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9882 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9883 
      return
9884 
    oprot.writeStructBegin('getTransactionStatus_args')
3431 rajveer 9885 
    if self.transactionId is not None:
94 ashish 9886 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
9887 
      oprot.writeI64(self.transactionId)
9888 
      oprot.writeFieldEnd()
9889 
    oprot.writeFieldStop()
9890 
    oprot.writeStructEnd()
9891 
 
3431 rajveer 9892 
  def validate(self):
9893 
    return
9894 
 
9895 
 
94 ashish 9896 
  def __repr__(self):
9897 
    L = ['%s=%r' % (key, value)
9898 
      for key, value in self.__dict__.iteritems()]
9899 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9900 
 
9901 
  def __eq__(self, other):
9902 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9903 
 
9904 
  def __ne__(self, other):
9905 
    return not (self == other)
9906 
 
9907 
class getTransactionStatus_result:
9908 
  """
9909 
  Attributes:
9910 
   - success
9911 
   - ex
9912 
  """
9913 
 
9914 
  thrift_spec = (
9915 
    (0, TType.I32, 'success', None, None, ), # 0
9916 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
9917 
  )
9918 
 
9919 
  def __init__(self, success=None, ex=None,):
9920 
    self.success = success
9921 
    self.ex = ex
9922 
 
9923 
  def read(self, iprot):
9924 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9925 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9926 
      return
9927 
    iprot.readStructBegin()
9928 
    while True:
9929 
      (fname, ftype, fid) = iprot.readFieldBegin()
9930 
      if ftype == TType.STOP:
9931 
        break
9932 
      if fid == 0:
9933 
        if ftype == TType.I32:
9934 
          self.success = iprot.readI32();
9935 
        else:
9936 
          iprot.skip(ftype)
9937 
      elif fid == 1:
9938 
        if ftype == TType.STRUCT:
9939 
          self.ex = TransactionServiceException()
9940 
          self.ex.read(iprot)
9941 
        else:
9942 
          iprot.skip(ftype)
9943 
      else:
9944 
        iprot.skip(ftype)
9945 
      iprot.readFieldEnd()
9946 
    iprot.readStructEnd()
9947 
 
9948 
  def write(self, oprot):
9949 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9950 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9951 
      return
9952 
    oprot.writeStructBegin('getTransactionStatus_result')
3431 rajveer 9953 
    if self.success is not None:
94 ashish 9954 
      oprot.writeFieldBegin('success', TType.I32, 0)
9955 
      oprot.writeI32(self.success)
9956 
      oprot.writeFieldEnd()
3431 rajveer 9957 
    if self.ex is not None:
94 ashish 9958 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9959 
      self.ex.write(oprot)
9960 
      oprot.writeFieldEnd()
9961 
    oprot.writeFieldStop()
9962 
    oprot.writeStructEnd()
9963 
 
3431 rajveer 9964 
  def validate(self):
9965 
    return
9966 
 
9967 
 
94 ashish 9968 
  def __repr__(self):
9969 
    L = ['%s=%r' % (key, value)
9970 
      for key, value in self.__dict__.iteritems()]
9971 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9972 
 
9973 
  def __eq__(self, other):
9974 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9975 
 
9976 
  def __ne__(self, other):
9977 
    return not (self == other)
9978 
 
9979 
class changeTransactionStatus_args:
9980 
  """
9981 
  Attributes:
9982 
   - transactionId
9983 
   - status
9984 
   - description
5527 anupam.sin 9985 
   - pickUp
9986 
   - orderType
94 ashish 9987 
  """
9988 
 
9989 
  thrift_spec = (
9990 
    None, # 0
9991 
    (1, TType.I64, 'transactionId', None, None, ), # 1
9992 
    (2, TType.I32, 'status', None, None, ), # 2
9993 
    (3, TType.STRING, 'description', None, None, ), # 3
5527 anupam.sin 9994 
    (4, TType.I64, 'pickUp', None, None, ), # 4
9995 
    (5, TType.I32, 'orderType', None, None, ), # 5
94 ashish 9996 
  )
9997 
 
5527 anupam.sin 9998 
  def __init__(self, transactionId=None, status=None, description=None, pickUp=None, orderType=None,):
94 ashish 9999 
    self.transactionId = transactionId
10000 
    self.status = status
10001 
    self.description = description
5527 anupam.sin 10002 
    self.pickUp = pickUp
10003 
    self.orderType = orderType
94 ashish 10004 
 
10005 
  def read(self, iprot):
10006 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10007 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10008 
      return
10009 
    iprot.readStructBegin()
10010 
    while True:
10011 
      (fname, ftype, fid) = iprot.readFieldBegin()
10012 
      if ftype == TType.STOP:
10013 
        break
10014 
      if fid == 1:
10015 
        if ftype == TType.I64:
10016 
          self.transactionId = iprot.readI64();
10017 
        else:
10018 
          iprot.skip(ftype)
10019 
      elif fid == 2:
10020 
        if ftype == TType.I32:
10021 
          self.status = iprot.readI32();
10022 
        else:
10023 
          iprot.skip(ftype)
10024 
      elif fid == 3:
10025 
        if ftype == TType.STRING:
10026 
          self.description = iprot.readString();
10027 
        else:
10028 
          iprot.skip(ftype)
5387 rajveer 10029 
      elif fid == 4:
5527 anupam.sin 10030 
        if ftype == TType.I64:
10031 
          self.pickUp = iprot.readI64();
5387 rajveer 10032 
        else:
10033 
          iprot.skip(ftype)
5527 anupam.sin 10034 
      elif fid == 5:
10035 
        if ftype == TType.I32:
10036 
          self.orderType = iprot.readI32();
10037 
        else:
10038 
          iprot.skip(ftype)
94 ashish 10039 
      else:
10040 
        iprot.skip(ftype)
10041 
      iprot.readFieldEnd()
10042 
    iprot.readStructEnd()
10043 
 
10044 
  def write(self, oprot):
10045 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10046 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10047 
      return
10048 
    oprot.writeStructBegin('changeTransactionStatus_args')
3431 rajveer 10049 
    if self.transactionId is not None:
94 ashish 10050 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
10051 
      oprot.writeI64(self.transactionId)
10052 
      oprot.writeFieldEnd()
3431 rajveer 10053 
    if self.status is not None:
94 ashish 10054 
      oprot.writeFieldBegin('status', TType.I32, 2)
10055 
      oprot.writeI32(self.status)
10056 
      oprot.writeFieldEnd()
3431 rajveer 10057 
    if self.description is not None:
94 ashish 10058 
      oprot.writeFieldBegin('description', TType.STRING, 3)
10059 
      oprot.writeString(self.description)
10060 
      oprot.writeFieldEnd()
5527 anupam.sin 10061 
    if self.pickUp is not None:
10062 
      oprot.writeFieldBegin('pickUp', TType.I64, 4)
10063 
      oprot.writeI64(self.pickUp)
5387 rajveer 10064 
      oprot.writeFieldEnd()
5527 anupam.sin 10065 
    if self.orderType is not None:
10066 
      oprot.writeFieldBegin('orderType', TType.I32, 5)
10067 
      oprot.writeI32(self.orderType)
10068 
      oprot.writeFieldEnd()
94 ashish 10069 
    oprot.writeFieldStop()
10070 
    oprot.writeStructEnd()
10071 
 
3431 rajveer 10072 
  def validate(self):
10073 
    return
10074 
 
10075 
 
94 ashish 10076 
  def __repr__(self):
10077 
    L = ['%s=%r' % (key, value)
10078 
      for key, value in self.__dict__.iteritems()]
10079 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10080 
 
10081 
  def __eq__(self, other):
10082 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10083 
 
10084 
  def __ne__(self, other):
10085 
    return not (self == other)
10086 
 
10087 
class changeTransactionStatus_result:
10088 
  """
10089 
  Attributes:
10090 
   - success
10091 
   - ex
10092 
  """
10093 
 
10094 
  thrift_spec = (
10095 
    (0, TType.BOOL, 'success', None, None, ), # 0
10096 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
10097 
  )
10098 
 
10099 
  def __init__(self, success=None, ex=None,):
10100 
    self.success = success
10101 
    self.ex = ex
10102 
 
10103 
  def read(self, iprot):
10104 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10105 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10106 
      return
10107 
    iprot.readStructBegin()
10108 
    while True:
10109 
      (fname, ftype, fid) = iprot.readFieldBegin()
10110 
      if ftype == TType.STOP:
10111 
        break
10112 
      if fid == 0:
10113 
        if ftype == TType.BOOL:
10114 
          self.success = iprot.readBool();
10115 
        else:
10116 
          iprot.skip(ftype)
10117 
      elif fid == 1:
10118 
        if ftype == TType.STRUCT:
10119 
          self.ex = TransactionServiceException()
10120 
          self.ex.read(iprot)
10121 
        else:
10122 
          iprot.skip(ftype)
10123 
      else:
10124 
        iprot.skip(ftype)
10125 
      iprot.readFieldEnd()
10126 
    iprot.readStructEnd()
10127 
 
10128 
  def write(self, oprot):
10129 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10130 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10131 
      return
10132 
    oprot.writeStructBegin('changeTransactionStatus_result')
3431 rajveer 10133 
    if self.success is not None:
94 ashish 10134 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
10135 
      oprot.writeBool(self.success)
10136 
      oprot.writeFieldEnd()
3431 rajveer 10137 
    if self.ex is not None:
94 ashish 10138 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10139 
      self.ex.write(oprot)
10140 
      oprot.writeFieldEnd()
10141 
    oprot.writeFieldStop()
10142 
    oprot.writeStructEnd()
10143 
 
3431 rajveer 10144 
  def validate(self):
10145 
    return
10146 
 
10147 
 
94 ashish 10148 
  def __repr__(self):
10149 
    L = ['%s=%r' % (key, value)
10150 
      for key, value in self.__dict__.iteritems()]
10151 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10152 
 
10153 
  def __eq__(self, other):
10154 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10155 
 
10156 
  def __ne__(self, other):
10157 
    return not (self == other)
10158 
 
1398 varun.gupt 10159 
class enqueueTransactionInfoEmail_args:
1382 varun.gupt 10160 
  """
10161 
  Attributes:
10162 
   - transactionId
10163 
  """
10164 
 
10165 
  thrift_spec = (
10166 
    None, # 0
10167 
    (1, TType.I64, 'transactionId', None, None, ), # 1
10168 
  )
10169 
 
10170 
  def __init__(self, transactionId=None,):
10171 
    self.transactionId = transactionId
10172 
 
10173 
  def read(self, iprot):
10174 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10175 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10176 
      return
10177 
    iprot.readStructBegin()
10178 
    while True:
10179 
      (fname, ftype, fid) = iprot.readFieldBegin()
10180 
      if ftype == TType.STOP:
10181 
        break
10182 
      if fid == 1:
10183 
        if ftype == TType.I64:
10184 
          self.transactionId = iprot.readI64();
10185 
        else:
10186 
          iprot.skip(ftype)
10187 
      else:
10188 
        iprot.skip(ftype)
10189 
      iprot.readFieldEnd()
10190 
    iprot.readStructEnd()
10191 
 
10192 
  def write(self, oprot):
10193 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10194 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10195 
      return
1398 varun.gupt 10196 
    oprot.writeStructBegin('enqueueTransactionInfoEmail_args')
3431 rajveer 10197 
    if self.transactionId is not None:
1382 varun.gupt 10198 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
10199 
      oprot.writeI64(self.transactionId)
10200 
      oprot.writeFieldEnd()
10201 
    oprot.writeFieldStop()
10202 
    oprot.writeStructEnd()
10203 
 
3431 rajveer 10204 
  def validate(self):
10205 
    return
10206 
 
10207 
 
1382 varun.gupt 10208 
  def __repr__(self):
10209 
    L = ['%s=%r' % (key, value)
10210 
      for key, value in self.__dict__.iteritems()]
10211 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10212 
 
10213 
  def __eq__(self, other):
10214 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10215 
 
10216 
  def __ne__(self, other):
10217 
    return not (self == other)
10218 
 
1398 varun.gupt 10219 
class enqueueTransactionInfoEmail_result:
1382 varun.gupt 10220 
  """
10221 
  Attributes:
10222 
   - success
10223 
   - ex
10224 
  """
10225 
 
10226 
  thrift_spec = (
10227 
    (0, TType.BOOL, 'success', None, None, ), # 0
10228 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
10229 
  )
10230 
 
10231 
  def __init__(self, success=None, ex=None,):
10232 
    self.success = success
10233 
    self.ex = ex
10234 
 
10235 
  def read(self, iprot):
10236 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10237 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10238 
      return
10239 
    iprot.readStructBegin()
10240 
    while True:
10241 
      (fname, ftype, fid) = iprot.readFieldBegin()
10242 
      if ftype == TType.STOP:
10243 
        break
10244 
      if fid == 0:
10245 
        if ftype == TType.BOOL:
10246 
          self.success = iprot.readBool();
10247 
        else:
10248 
          iprot.skip(ftype)
10249 
      elif fid == 1:
10250 
        if ftype == TType.STRUCT:
10251 
          self.ex = TransactionServiceException()
10252 
          self.ex.read(iprot)
10253 
        else:
10254 
          iprot.skip(ftype)
10255 
      else:
10256 
        iprot.skip(ftype)
10257 
      iprot.readFieldEnd()
10258 
    iprot.readStructEnd()
10259 
 
10260 
  def write(self, oprot):
10261 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10262 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10263 
      return
1398 varun.gupt 10264 
    oprot.writeStructBegin('enqueueTransactionInfoEmail_result')
3431 rajveer 10265 
    if self.success is not None:
1382 varun.gupt 10266 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
10267 
      oprot.writeBool(self.success)
10268 
      oprot.writeFieldEnd()
3431 rajveer 10269 
    if self.ex is not None:
1382 varun.gupt 10270 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10271 
      self.ex.write(oprot)
10272 
      oprot.writeFieldEnd()
10273 
    oprot.writeFieldStop()
10274 
    oprot.writeStructEnd()
10275 
 
3431 rajveer 10276 
  def validate(self):
10277 
    return
10278 
 
10279 
 
1382 varun.gupt 10280 
  def __repr__(self):
10281 
    L = ['%s=%r' % (key, value)
10282 
      for key, value in self.__dict__.iteritems()]
10283 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10284 
 
10285 
  def __eq__(self, other):
10286 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10287 
 
10288 
  def __ne__(self, other):
10289 
    return not (self == other)
10290 
 
483 rajveer 10291 
class getAllOrders_args:
94 ashish 10292 
  """
10293 
  Attributes:
4801 anupam.sin 10294 
   - statuses
483 rajveer 10295 
   - from_date
10296 
   - to_date
10297 
   - warehouse_id
94 ashish 10298 
  """
10299 
 
10300 
  thrift_spec = (
10301 
    None, # 0
4801 anupam.sin 10302 
    (1, TType.LIST, 'statuses', (TType.I32,None), None, ), # 1
483 rajveer 10303 
    (2, TType.I64, 'from_date', None, None, ), # 2
10304 
    (3, TType.I64, 'to_date', None, None, ), # 3
10305 
    (4, TType.I64, 'warehouse_id', None, None, ), # 4
94 ashish 10306 
  )
10307 
 
4801 anupam.sin 10308 
  def __init__(self, statuses=None, from_date=None, to_date=None, warehouse_id=None,):
10309 
    self.statuses = statuses
483 rajveer 10310 
    self.from_date = from_date
10311 
    self.to_date = to_date
10312 
    self.warehouse_id = warehouse_id
94 ashish 10313 
 
10314 
  def read(self, iprot):
10315 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10316 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10317 
      return
10318 
    iprot.readStructBegin()
10319 
    while True:
10320 
      (fname, ftype, fid) = iprot.readFieldBegin()
10321 
      if ftype == TType.STOP:
10322 
        break
10323 
      if fid == 1:
4801 anupam.sin 10324 
        if ftype == TType.LIST:
10325 
          self.statuses = []
6188 rajveer 10326 
          (_etype123, _size120) = iprot.readListBegin()
10327 
          for _i124 in xrange(_size120):
10328 
            _elem125 = iprot.readI32();
10329 
            self.statuses.append(_elem125)
4801 anupam.sin 10330 
          iprot.readListEnd()
94 ashish 10331 
        else:
10332 
          iprot.skip(ftype)
483 rajveer 10333 
      elif fid == 2:
10334 
        if ftype == TType.I64:
10335 
          self.from_date = iprot.readI64();
94 ashish 10336 
        else:
10337 
          iprot.skip(ftype)
483 rajveer 10338 
      elif fid == 3:
10339 
        if ftype == TType.I64:
10340 
          self.to_date = iprot.readI64();
94 ashish 10341 
        else:
10342 
          iprot.skip(ftype)
483 rajveer 10343 
      elif fid == 4:
94 ashish 10344 
        if ftype == TType.I64:
483 rajveer 10345 
          self.warehouse_id = iprot.readI64();
94 ashish 10346 
        else:
10347 
          iprot.skip(ftype)
10348 
      else:
10349 
        iprot.skip(ftype)
10350 
      iprot.readFieldEnd()
10351 
    iprot.readStructEnd()
10352 
 
10353 
  def write(self, oprot):
10354 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10355 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10356 
      return
483 rajveer 10357 
    oprot.writeStructBegin('getAllOrders_args')
4801 anupam.sin 10358 
    if self.statuses is not None:
10359 
      oprot.writeFieldBegin('statuses', TType.LIST, 1)
10360 
      oprot.writeListBegin(TType.I32, len(self.statuses))
6188 rajveer 10361 
      for iter126 in self.statuses:
10362 
        oprot.writeI32(iter126)
4801 anupam.sin 10363 
      oprot.writeListEnd()
94 ashish 10364 
      oprot.writeFieldEnd()
3431 rajveer 10365 
    if self.from_date is not None:
483 rajveer 10366 
      oprot.writeFieldBegin('from_date', TType.I64, 2)
10367 
      oprot.writeI64(self.from_date)
94 ashish 10368 
      oprot.writeFieldEnd()
3431 rajveer 10369 
    if self.to_date is not None:
483 rajveer 10370 
      oprot.writeFieldBegin('to_date', TType.I64, 3)
10371 
      oprot.writeI64(self.to_date)
94 ashish 10372 
      oprot.writeFieldEnd()
3431 rajveer 10373 
    if self.warehouse_id is not None:
483 rajveer 10374 
      oprot.writeFieldBegin('warehouse_id', TType.I64, 4)
10375 
      oprot.writeI64(self.warehouse_id)
94 ashish 10376 
      oprot.writeFieldEnd()
10377 
    oprot.writeFieldStop()
10378 
    oprot.writeStructEnd()
10379 
 
3431 rajveer 10380 
  def validate(self):
10381 
    return
10382 
 
10383 
 
94 ashish 10384 
  def __repr__(self):
10385 
    L = ['%s=%r' % (key, value)
10386 
      for key, value in self.__dict__.iteritems()]
10387 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10388 
 
10389 
  def __eq__(self, other):
10390 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10391 
 
10392 
  def __ne__(self, other):
10393 
    return not (self == other)
10394 
 
483 rajveer 10395 
class getAllOrders_result:
94 ashish 10396 
  """
10397 
  Attributes:
10398 
   - success
10399 
   - ex
10400 
  """
10401 
 
10402 
  thrift_spec = (
483 rajveer 10403 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
94 ashish 10404 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
10405 
  )
10406 
 
10407 
  def __init__(self, success=None, ex=None,):
10408 
    self.success = success
10409 
    self.ex = ex
10410 
 
10411 
  def read(self, iprot):
10412 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10413 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10414 
      return
10415 
    iprot.readStructBegin()
10416 
    while True:
10417 
      (fname, ftype, fid) = iprot.readFieldBegin()
10418 
      if ftype == TType.STOP:
10419 
        break
10420 
      if fid == 0:
483 rajveer 10421 
        if ftype == TType.LIST:
10422 
          self.success = []
6188 rajveer 10423 
          (_etype130, _size127) = iprot.readListBegin()
10424 
          for _i131 in xrange(_size127):
10425 
            _elem132 = Order()
10426 
            _elem132.read(iprot)
10427 
            self.success.append(_elem132)
483 rajveer 10428 
          iprot.readListEnd()
94 ashish 10429 
        else:
10430 
          iprot.skip(ftype)
10431 
      elif fid == 1:
10432 
        if ftype == TType.STRUCT:
10433 
          self.ex = TransactionServiceException()
10434 
          self.ex.read(iprot)
10435 
        else:
10436 
          iprot.skip(ftype)
10437 
      else:
10438 
        iprot.skip(ftype)
10439 
      iprot.readFieldEnd()
10440 
    iprot.readStructEnd()
10441 
 
10442 
  def write(self, oprot):
10443 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10444 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10445 
      return
483 rajveer 10446 
    oprot.writeStructBegin('getAllOrders_result')
3431 rajveer 10447 
    if self.success is not None:
483 rajveer 10448 
      oprot.writeFieldBegin('success', TType.LIST, 0)
10449 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 10450 
      for iter133 in self.success:
10451 
        iter133.write(oprot)
483 rajveer 10452 
      oprot.writeListEnd()
94 ashish 10453 
      oprot.writeFieldEnd()
3431 rajveer 10454 
    if self.ex is not None:
94 ashish 10455 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10456 
      self.ex.write(oprot)
10457 
      oprot.writeFieldEnd()
10458 
    oprot.writeFieldStop()
10459 
    oprot.writeStructEnd()
10460 
 
3431 rajveer 10461 
  def validate(self):
10462 
    return
10463 
 
10464 
 
94 ashish 10465 
  def __repr__(self):
10466 
    L = ['%s=%r' % (key, value)
10467 
      for key, value in self.__dict__.iteritems()]
10468 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10469 
 
10470 
  def __eq__(self, other):
10471 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10472 
 
10473 
  def __ne__(self, other):
10474 
    return not (self == other)
10475 
 
4133 chandransh 10476 
class getOrdersInBatch_args:
10477 
  """
10478 
  Attributes:
10479 
   - statuses
10480 
   - offset
10481 
   - limit
10482 
   - warehouse_id
10483 
  """
10484 
 
10485 
  thrift_spec = (
10486 
    None, # 0
10487 
    (1, TType.LIST, 'statuses', (TType.I32,None), None, ), # 1
10488 
    (2, TType.I64, 'offset', None, None, ), # 2
10489 
    (3, TType.I64, 'limit', None, None, ), # 3
10490 
    (4, TType.I64, 'warehouse_id', None, None, ), # 4
10491 
  )
10492 
 
10493 
  def __init__(self, statuses=None, offset=None, limit=None, warehouse_id=None,):
10494 
    self.statuses = statuses
10495 
    self.offset = offset
10496 
    self.limit = limit
10497 
    self.warehouse_id = warehouse_id
10498 
 
10499 
  def read(self, iprot):
10500 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10501 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10502 
      return
10503 
    iprot.readStructBegin()
10504 
    while True:
10505 
      (fname, ftype, fid) = iprot.readFieldBegin()
10506 
      if ftype == TType.STOP:
10507 
        break
10508 
      if fid == 1:
10509 
        if ftype == TType.LIST:
10510 
          self.statuses = []
6188 rajveer 10511 
          (_etype137, _size134) = iprot.readListBegin()
10512 
          for _i138 in xrange(_size134):
10513 
            _elem139 = iprot.readI32();
10514 
            self.statuses.append(_elem139)
4133 chandransh 10515 
          iprot.readListEnd()
10516 
        else:
10517 
          iprot.skip(ftype)
10518 
      elif fid == 2:
10519 
        if ftype == TType.I64:
10520 
          self.offset = iprot.readI64();
10521 
        else:
10522 
          iprot.skip(ftype)
10523 
      elif fid == 3:
10524 
        if ftype == TType.I64:
10525 
          self.limit = iprot.readI64();
10526 
        else:
10527 
          iprot.skip(ftype)
10528 
      elif fid == 4:
10529 
        if ftype == TType.I64:
10530 
          self.warehouse_id = iprot.readI64();
10531 
        else:
10532 
          iprot.skip(ftype)
10533 
      else:
10534 
        iprot.skip(ftype)
10535 
      iprot.readFieldEnd()
10536 
    iprot.readStructEnd()
10537 
 
10538 
  def write(self, oprot):
10539 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10540 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10541 
      return
10542 
    oprot.writeStructBegin('getOrdersInBatch_args')
10543 
    if self.statuses is not None:
10544 
      oprot.writeFieldBegin('statuses', TType.LIST, 1)
10545 
      oprot.writeListBegin(TType.I32, len(self.statuses))
6188 rajveer 10546 
      for iter140 in self.statuses:
10547 
        oprot.writeI32(iter140)
4133 chandransh 10548 
      oprot.writeListEnd()
10549 
      oprot.writeFieldEnd()
10550 
    if self.offset is not None:
10551 
      oprot.writeFieldBegin('offset', TType.I64, 2)
10552 
      oprot.writeI64(self.offset)
10553 
      oprot.writeFieldEnd()
10554 
    if self.limit is not None:
10555 
      oprot.writeFieldBegin('limit', TType.I64, 3)
10556 
      oprot.writeI64(self.limit)
10557 
      oprot.writeFieldEnd()
10558 
    if self.warehouse_id is not None:
10559 
      oprot.writeFieldBegin('warehouse_id', TType.I64, 4)
10560 
      oprot.writeI64(self.warehouse_id)
10561 
      oprot.writeFieldEnd()
10562 
    oprot.writeFieldStop()
10563 
    oprot.writeStructEnd()
10564 
 
10565 
  def validate(self):
10566 
    return
10567 
 
10568 
 
10569 
  def __repr__(self):
10570 
    L = ['%s=%r' % (key, value)
10571 
      for key, value in self.__dict__.iteritems()]
10572 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10573 
 
10574 
  def __eq__(self, other):
10575 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10576 
 
10577 
  def __ne__(self, other):
10578 
    return not (self == other)
10579 
 
10580 
class getOrdersInBatch_result:
10581 
  """
10582 
  Attributes:
10583 
   - success
10584 
   - ex
10585 
  """
10586 
 
10587 
  thrift_spec = (
10588 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
10589 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
10590 
  )
10591 
 
10592 
  def __init__(self, success=None, ex=None,):
10593 
    self.success = success
10594 
    self.ex = ex
10595 
 
10596 
  def read(self, iprot):
10597 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10598 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10599 
      return
10600 
    iprot.readStructBegin()
10601 
    while True:
10602 
      (fname, ftype, fid) = iprot.readFieldBegin()
10603 
      if ftype == TType.STOP:
10604 
        break
10605 
      if fid == 0:
10606 
        if ftype == TType.LIST:
10607 
          self.success = []
6188 rajveer 10608 
          (_etype144, _size141) = iprot.readListBegin()
10609 
          for _i145 in xrange(_size141):
10610 
            _elem146 = Order()
10611 
            _elem146.read(iprot)
10612 
            self.success.append(_elem146)
4133 chandransh 10613 
          iprot.readListEnd()
10614 
        else:
10615 
          iprot.skip(ftype)
10616 
      elif fid == 1:
10617 
        if ftype == TType.STRUCT:
10618 
          self.ex = TransactionServiceException()
10619 
          self.ex.read(iprot)
10620 
        else:
10621 
          iprot.skip(ftype)
10622 
      else:
10623 
        iprot.skip(ftype)
10624 
      iprot.readFieldEnd()
10625 
    iprot.readStructEnd()
10626 
 
10627 
  def write(self, oprot):
10628 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10629 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10630 
      return
10631 
    oprot.writeStructBegin('getOrdersInBatch_result')
10632 
    if self.success is not None:
10633 
      oprot.writeFieldBegin('success', TType.LIST, 0)
10634 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 10635 
      for iter147 in self.success:
10636 
        iter147.write(oprot)
4133 chandransh 10637 
      oprot.writeListEnd()
10638 
      oprot.writeFieldEnd()
10639 
    if self.ex is not None:
10640 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10641 
      self.ex.write(oprot)
10642 
      oprot.writeFieldEnd()
10643 
    oprot.writeFieldStop()
10644 
    oprot.writeStructEnd()
10645 
 
10646 
  def validate(self):
10647 
    return
10648 
 
10649 
 
10650 
  def __repr__(self):
10651 
    L = ['%s=%r' % (key, value)
10652 
      for key, value in self.__dict__.iteritems()]
10653 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10654 
 
10655 
  def __eq__(self, other):
10656 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10657 
 
10658 
  def __ne__(self, other):
10659 
    return not (self == other)
10660 
 
10661 
class getOrderCount_args:
10662 
  """
10663 
  Attributes:
10664 
   - statuses
10665 
   - warehouseId
10666 
  """
10667 
 
10668 
  thrift_spec = (
10669 
    None, # 0
10670 
    (1, TType.LIST, 'statuses', (TType.I32,None), None, ), # 1
10671 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
10672 
  )
10673 
 
10674 
  def __init__(self, statuses=None, warehouseId=None,):
10675 
    self.statuses = statuses
10676 
    self.warehouseId = warehouseId
10677 
 
10678 
  def read(self, iprot):
10679 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10680 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10681 
      return
10682 
    iprot.readStructBegin()
10683 
    while True:
10684 
      (fname, ftype, fid) = iprot.readFieldBegin()
10685 
      if ftype == TType.STOP:
10686 
        break
10687 
      if fid == 1:
10688 
        if ftype == TType.LIST:
10689 
          self.statuses = []
6188 rajveer 10690 
          (_etype151, _size148) = iprot.readListBegin()
10691 
          for _i152 in xrange(_size148):
10692 
            _elem153 = iprot.readI32();
10693 
            self.statuses.append(_elem153)
4133 chandransh 10694 
          iprot.readListEnd()
10695 
        else:
10696 
          iprot.skip(ftype)
10697 
      elif fid == 2:
10698 
        if ftype == TType.I64:
10699 
          self.warehouseId = iprot.readI64();
10700 
        else:
10701 
          iprot.skip(ftype)
10702 
      else:
10703 
        iprot.skip(ftype)
10704 
      iprot.readFieldEnd()
10705 
    iprot.readStructEnd()
10706 
 
10707 
  def write(self, oprot):
10708 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10709 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10710 
      return
10711 
    oprot.writeStructBegin('getOrderCount_args')
10712 
    if self.statuses is not None:
10713 
      oprot.writeFieldBegin('statuses', TType.LIST, 1)
10714 
      oprot.writeListBegin(TType.I32, len(self.statuses))
6188 rajveer 10715 
      for iter154 in self.statuses:
10716 
        oprot.writeI32(iter154)
4133 chandransh 10717 
      oprot.writeListEnd()
10718 
      oprot.writeFieldEnd()
10719 
    if self.warehouseId is not None:
10720 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
10721 
      oprot.writeI64(self.warehouseId)
10722 
      oprot.writeFieldEnd()
10723 
    oprot.writeFieldStop()
10724 
    oprot.writeStructEnd()
10725 
 
10726 
  def validate(self):
10727 
    return
10728 
 
10729 
 
10730 
  def __repr__(self):
10731 
    L = ['%s=%r' % (key, value)
10732 
      for key, value in self.__dict__.iteritems()]
10733 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10734 
 
10735 
  def __eq__(self, other):
10736 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10737 
 
10738 
  def __ne__(self, other):
10739 
    return not (self == other)
10740 
 
10741 
class getOrderCount_result:
10742 
  """
10743 
  Attributes:
10744 
   - success
10745 
   - ex
10746 
  """
10747 
 
10748 
  thrift_spec = (
10749 
    (0, TType.I32, 'success', None, None, ), # 0
10750 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
10751 
  )
10752 
 
10753 
  def __init__(self, success=None, ex=None,):
10754 
    self.success = success
10755 
    self.ex = ex
10756 
 
10757 
  def read(self, iprot):
10758 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10759 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10760 
      return
10761 
    iprot.readStructBegin()
10762 
    while True:
10763 
      (fname, ftype, fid) = iprot.readFieldBegin()
10764 
      if ftype == TType.STOP:
10765 
        break
10766 
      if fid == 0:
10767 
        if ftype == TType.I32:
10768 
          self.success = iprot.readI32();
10769 
        else:
10770 
          iprot.skip(ftype)
10771 
      elif fid == 1:
10772 
        if ftype == TType.STRUCT:
10773 
          self.ex = TransactionServiceException()
10774 
          self.ex.read(iprot)
10775 
        else:
10776 
          iprot.skip(ftype)
10777 
      else:
10778 
        iprot.skip(ftype)
10779 
      iprot.readFieldEnd()
10780 
    iprot.readStructEnd()
10781 
 
10782 
  def write(self, oprot):
10783 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10784 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10785 
      return
10786 
    oprot.writeStructBegin('getOrderCount_result')
10787 
    if self.success is not None:
10788 
      oprot.writeFieldBegin('success', TType.I32, 0)
10789 
      oprot.writeI32(self.success)
10790 
      oprot.writeFieldEnd()
10791 
    if self.ex is not None:
10792 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10793 
      self.ex.write(oprot)
10794 
      oprot.writeFieldEnd()
10795 
    oprot.writeFieldStop()
10796 
    oprot.writeStructEnd()
10797 
 
10798 
  def validate(self):
10799 
    return
10800 
 
10801 
 
10802 
  def __repr__(self):
10803 
    L = ['%s=%r' % (key, value)
10804 
      for key, value in self.__dict__.iteritems()]
10805 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10806 
 
10807 
  def __eq__(self, other):
10808 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10809 
 
10810 
  def __ne__(self, other):
10811 
    return not (self == other)
10812 
 
999 varun.gupt 10813 
class getOrdersByBillingDate_args:
10814 
  """
10815 
  Attributes:
10816 
   - status
10817 
   - start_billing_date
10818 
   - end_billing_date
10819 
   - warehouse_id
10820 
  """
10821 
 
10822 
  thrift_spec = (
10823 
    None, # 0
10824 
    (1, TType.I32, 'status', None, None, ), # 1
10825 
    (2, TType.I64, 'start_billing_date', None, None, ), # 2
10826 
    (3, TType.I64, 'end_billing_date', None, None, ), # 3
10827 
    (4, TType.I64, 'warehouse_id', None, None, ), # 4
10828 
  )
10829 
 
10830 
  def __init__(self, status=None, start_billing_date=None, end_billing_date=None, warehouse_id=None,):
10831 
    self.status = status
10832 
    self.start_billing_date = start_billing_date
10833 
    self.end_billing_date = end_billing_date
10834 
    self.warehouse_id = warehouse_id
10835 
 
10836 
  def read(self, iprot):
10837 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10838 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10839 
      return
10840 
    iprot.readStructBegin()
10841 
    while True:
10842 
      (fname, ftype, fid) = iprot.readFieldBegin()
10843 
      if ftype == TType.STOP:
10844 
        break
10845 
      if fid == 1:
10846 
        if ftype == TType.I32:
10847 
          self.status = iprot.readI32();
10848 
        else:
10849 
          iprot.skip(ftype)
10850 
      elif fid == 2:
10851 
        if ftype == TType.I64:
10852 
          self.start_billing_date = iprot.readI64();
10853 
        else:
10854 
          iprot.skip(ftype)
10855 
      elif fid == 3:
10856 
        if ftype == TType.I64:
10857 
          self.end_billing_date = iprot.readI64();
10858 
        else:
10859 
          iprot.skip(ftype)
10860 
      elif fid == 4:
10861 
        if ftype == TType.I64:
10862 
          self.warehouse_id = iprot.readI64();
10863 
        else:
10864 
          iprot.skip(ftype)
10865 
      else:
10866 
        iprot.skip(ftype)
10867 
      iprot.readFieldEnd()
10868 
    iprot.readStructEnd()
10869 
 
10870 
  def write(self, oprot):
10871 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10872 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10873 
      return
10874 
    oprot.writeStructBegin('getOrdersByBillingDate_args')
3431 rajveer 10875 
    if self.status is not None:
999 varun.gupt 10876 
      oprot.writeFieldBegin('status', TType.I32, 1)
10877 
      oprot.writeI32(self.status)
10878 
      oprot.writeFieldEnd()
3431 rajveer 10879 
    if self.start_billing_date is not None:
999 varun.gupt 10880 
      oprot.writeFieldBegin('start_billing_date', TType.I64, 2)
10881 
      oprot.writeI64(self.start_billing_date)
10882 
      oprot.writeFieldEnd()
3431 rajveer 10883 
    if self.end_billing_date is not None:
999 varun.gupt 10884 
      oprot.writeFieldBegin('end_billing_date', TType.I64, 3)
10885 
      oprot.writeI64(self.end_billing_date)
10886 
      oprot.writeFieldEnd()
3431 rajveer 10887 
    if self.warehouse_id is not None:
999 varun.gupt 10888 
      oprot.writeFieldBegin('warehouse_id', TType.I64, 4)
10889 
      oprot.writeI64(self.warehouse_id)
10890 
      oprot.writeFieldEnd()
10891 
    oprot.writeFieldStop()
10892 
    oprot.writeStructEnd()
10893 
 
3431 rajveer 10894 
  def validate(self):
10895 
    return
10896 
 
10897 
 
999 varun.gupt 10898 
  def __repr__(self):
10899 
    L = ['%s=%r' % (key, value)
10900 
      for key, value in self.__dict__.iteritems()]
10901 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10902 
 
10903 
  def __eq__(self, other):
10904 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10905 
 
10906 
  def __ne__(self, other):
10907 
    return not (self == other)
10908 
 
10909 
class getOrdersByBillingDate_result:
10910 
  """
10911 
  Attributes:
10912 
   - success
10913 
   - ex
10914 
  """
10915 
 
10916 
  thrift_spec = (
10917 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
10918 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
10919 
  )
10920 
 
10921 
  def __init__(self, success=None, ex=None,):
10922 
    self.success = success
10923 
    self.ex = ex
10924 
 
10925 
  def read(self, iprot):
10926 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10927 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10928 
      return
10929 
    iprot.readStructBegin()
10930 
    while True:
10931 
      (fname, ftype, fid) = iprot.readFieldBegin()
10932 
      if ftype == TType.STOP:
10933 
        break
10934 
      if fid == 0:
10935 
        if ftype == TType.LIST:
10936 
          self.success = []
6188 rajveer 10937 
          (_etype158, _size155) = iprot.readListBegin()
10938 
          for _i159 in xrange(_size155):
10939 
            _elem160 = Order()
10940 
            _elem160.read(iprot)
10941 
            self.success.append(_elem160)
999 varun.gupt 10942 
          iprot.readListEnd()
10943 
        else:
10944 
          iprot.skip(ftype)
10945 
      elif fid == 1:
10946 
        if ftype == TType.STRUCT:
10947 
          self.ex = TransactionServiceException()
10948 
          self.ex.read(iprot)
10949 
        else:
10950 
          iprot.skip(ftype)
10951 
      else:
10952 
        iprot.skip(ftype)
10953 
      iprot.readFieldEnd()
10954 
    iprot.readStructEnd()
10955 
 
10956 
  def write(self, oprot):
10957 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10958 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10959 
      return
10960 
    oprot.writeStructBegin('getOrdersByBillingDate_result')
3431 rajveer 10961 
    if self.success is not None:
999 varun.gupt 10962 
      oprot.writeFieldBegin('success', TType.LIST, 0)
10963 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 10964 
      for iter161 in self.success:
10965 
        iter161.write(oprot)
999 varun.gupt 10966 
      oprot.writeListEnd()
10967 
      oprot.writeFieldEnd()
3431 rajveer 10968 
    if self.ex is not None:
999 varun.gupt 10969 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10970 
      self.ex.write(oprot)
10971 
      oprot.writeFieldEnd()
10972 
    oprot.writeFieldStop()
10973 
    oprot.writeStructEnd()
10974 
 
3431 rajveer 10975 
  def validate(self):
10976 
    return
10977 
 
10978 
 
999 varun.gupt 10979 
  def __repr__(self):
10980 
    L = ['%s=%r' % (key, value)
10981 
      for key, value in self.__dict__.iteritems()]
10982 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10983 
 
10984 
  def __eq__(self, other):
10985 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10986 
 
10987 
  def __ne__(self, other):
10988 
    return not (self == other)
10989 
 
3427 chandransh 10990 
class getOrdersByShippingDate_args:
10991 
  """
10992 
  Attributes:
10993 
   - fromShippingDate
10994 
   - toShippingDate
10995 
   - providerId
10996 
   - warehouseId
3451 chandransh 10997 
   - cod
3427 chandransh 10998 
  """
10999 
 
11000 
  thrift_spec = (
11001 
    None, # 0
11002 
    (1, TType.I64, 'fromShippingDate', None, None, ), # 1
11003 
    (2, TType.I64, 'toShippingDate', None, None, ), # 2
11004 
    (3, TType.I64, 'providerId', None, None, ), # 3
11005 
    (4, TType.I64, 'warehouseId', None, None, ), # 4
3451 chandransh 11006 
    (5, TType.BOOL, 'cod', None, None, ), # 5
3427 chandransh 11007 
  )
11008 
 
3451 chandransh 11009 
  def __init__(self, fromShippingDate=None, toShippingDate=None, providerId=None, warehouseId=None, cod=None,):
3427 chandransh 11010 
    self.fromShippingDate = fromShippingDate
11011 
    self.toShippingDate = toShippingDate
11012 
    self.providerId = providerId
11013 
    self.warehouseId = warehouseId
3451 chandransh 11014 
    self.cod = cod
3427 chandransh 11015 
 
11016 
  def read(self, iprot):
11017 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11018 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11019 
      return
11020 
    iprot.readStructBegin()
11021 
    while True:
11022 
      (fname, ftype, fid) = iprot.readFieldBegin()
11023 
      if ftype == TType.STOP:
11024 
        break
11025 
      if fid == 1:
11026 
        if ftype == TType.I64:
11027 
          self.fromShippingDate = iprot.readI64();
11028 
        else:
11029 
          iprot.skip(ftype)
11030 
      elif fid == 2:
11031 
        if ftype == TType.I64:
11032 
          self.toShippingDate = iprot.readI64();
11033 
        else:
11034 
          iprot.skip(ftype)
11035 
      elif fid == 3:
11036 
        if ftype == TType.I64:
11037 
          self.providerId = iprot.readI64();
11038 
        else:
11039 
          iprot.skip(ftype)
11040 
      elif fid == 4:
11041 
        if ftype == TType.I64:
11042 
          self.warehouseId = iprot.readI64();
11043 
        else:
11044 
          iprot.skip(ftype)
3451 chandransh 11045 
      elif fid == 5:
11046 
        if ftype == TType.BOOL:
11047 
          self.cod = iprot.readBool();
11048 
        else:
11049 
          iprot.skip(ftype)
3427 chandransh 11050 
      else:
11051 
        iprot.skip(ftype)
11052 
      iprot.readFieldEnd()
11053 
    iprot.readStructEnd()
11054 
 
11055 
  def write(self, oprot):
11056 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11057 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11058 
      return
11059 
    oprot.writeStructBegin('getOrdersByShippingDate_args')
3431 rajveer 11060 
    if self.fromShippingDate is not None:
3427 chandransh 11061 
      oprot.writeFieldBegin('fromShippingDate', TType.I64, 1)
11062 
      oprot.writeI64(self.fromShippingDate)
11063 
      oprot.writeFieldEnd()
3431 rajveer 11064 
    if self.toShippingDate is not None:
3427 chandransh 11065 
      oprot.writeFieldBegin('toShippingDate', TType.I64, 2)
11066 
      oprot.writeI64(self.toShippingDate)
11067 
      oprot.writeFieldEnd()
3431 rajveer 11068 
    if self.providerId is not None:
3427 chandransh 11069 
      oprot.writeFieldBegin('providerId', TType.I64, 3)
11070 
      oprot.writeI64(self.providerId)
11071 
      oprot.writeFieldEnd()
3431 rajveer 11072 
    if self.warehouseId is not None:
3427 chandransh 11073 
      oprot.writeFieldBegin('warehouseId', TType.I64, 4)
11074 
      oprot.writeI64(self.warehouseId)
11075 
      oprot.writeFieldEnd()
3451 chandransh 11076 
    if self.cod is not None:
11077 
      oprot.writeFieldBegin('cod', TType.BOOL, 5)
11078 
      oprot.writeBool(self.cod)
11079 
      oprot.writeFieldEnd()
3427 chandransh 11080 
    oprot.writeFieldStop()
11081 
    oprot.writeStructEnd()
11082 
 
3431 rajveer 11083 
  def validate(self):
11084 
    return
11085 
 
11086 
 
3427 chandransh 11087 
  def __repr__(self):
11088 
    L = ['%s=%r' % (key, value)
11089 
      for key, value in self.__dict__.iteritems()]
11090 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11091 
 
11092 
  def __eq__(self, other):
11093 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11094 
 
11095 
  def __ne__(self, other):
11096 
    return not (self == other)
11097 
 
11098 
class getOrdersByShippingDate_result:
11099 
  """
11100 
  Attributes:
11101 
   - success
11102 
   - ex
11103 
  """
11104 
 
11105 
  thrift_spec = (
11106 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
11107 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
11108 
  )
11109 
 
11110 
  def __init__(self, success=None, ex=None,):
11111 
    self.success = success
11112 
    self.ex = ex
11113 
 
11114 
  def read(self, iprot):
11115 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11116 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11117 
      return
11118 
    iprot.readStructBegin()
11119 
    while True:
11120 
      (fname, ftype, fid) = iprot.readFieldBegin()
11121 
      if ftype == TType.STOP:
11122 
        break
11123 
      if fid == 0:
11124 
        if ftype == TType.LIST:
11125 
          self.success = []
6188 rajveer 11126 
          (_etype165, _size162) = iprot.readListBegin()
11127 
          for _i166 in xrange(_size162):
11128 
            _elem167 = Order()
11129 
            _elem167.read(iprot)
11130 
            self.success.append(_elem167)
3427 chandransh 11131 
          iprot.readListEnd()
11132 
        else:
11133 
          iprot.skip(ftype)
11134 
      elif fid == 1:
11135 
        if ftype == TType.STRUCT:
11136 
          self.ex = TransactionServiceException()
11137 
          self.ex.read(iprot)
11138 
        else:
11139 
          iprot.skip(ftype)
11140 
      else:
11141 
        iprot.skip(ftype)
11142 
      iprot.readFieldEnd()
11143 
    iprot.readStructEnd()
11144 
 
11145 
  def write(self, oprot):
11146 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11147 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11148 
      return
11149 
    oprot.writeStructBegin('getOrdersByShippingDate_result')
3431 rajveer 11150 
    if self.success is not None:
3427 chandransh 11151 
      oprot.writeFieldBegin('success', TType.LIST, 0)
11152 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 11153 
      for iter168 in self.success:
11154 
        iter168.write(oprot)
3427 chandransh 11155 
      oprot.writeListEnd()
11156 
      oprot.writeFieldEnd()
3431 rajveer 11157 
    if self.ex is not None:
3427 chandransh 11158 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11159 
      self.ex.write(oprot)
11160 
      oprot.writeFieldEnd()
11161 
    oprot.writeFieldStop()
11162 
    oprot.writeStructEnd()
11163 
 
3431 rajveer 11164 
  def validate(self):
11165 
    return
11166 
 
11167 
 
3427 chandransh 11168 
  def __repr__(self):
11169 
    L = ['%s=%r' % (key, value)
11170 
      for key, value in self.__dict__.iteritems()]
11171 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11172 
 
11173 
  def __eq__(self, other):
11174 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11175 
 
11176 
  def __ne__(self, other):
11177 
    return not (self == other)
11178 
 
1382 varun.gupt 11179 
class getReturnableOrdersForCustomer_args:
11180 
  """
11181 
  Attributes:
11182 
   - customer_id
11183 
   - limit
11184 
  """
11185 
 
11186 
  thrift_spec = (
11187 
    None, # 0
11188 
    (1, TType.I64, 'customer_id', None, None, ), # 1
11189 
    (2, TType.I64, 'limit', None, None, ), # 2
11190 
  )
11191 
 
11192 
  def __init__(self, customer_id=None, limit=None,):
11193 
    self.customer_id = customer_id
11194 
    self.limit = limit
11195 
 
11196 
  def read(self, iprot):
11197 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11198 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11199 
      return
11200 
    iprot.readStructBegin()
11201 
    while True:
11202 
      (fname, ftype, fid) = iprot.readFieldBegin()
11203 
      if ftype == TType.STOP:
11204 
        break
11205 
      if fid == 1:
11206 
        if ftype == TType.I64:
11207 
          self.customer_id = iprot.readI64();
11208 
        else:
11209 
          iprot.skip(ftype)
11210 
      elif fid == 2:
11211 
        if ftype == TType.I64:
11212 
          self.limit = iprot.readI64();
11213 
        else:
11214 
          iprot.skip(ftype)
11215 
      else:
11216 
        iprot.skip(ftype)
11217 
      iprot.readFieldEnd()
11218 
    iprot.readStructEnd()
11219 
 
11220 
  def write(self, oprot):
11221 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11222 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11223 
      return
11224 
    oprot.writeStructBegin('getReturnableOrdersForCustomer_args')
3431 rajveer 11225 
    if self.customer_id is not None:
1382 varun.gupt 11226 
      oprot.writeFieldBegin('customer_id', TType.I64, 1)
11227 
      oprot.writeI64(self.customer_id)
11228 
      oprot.writeFieldEnd()
3431 rajveer 11229 
    if self.limit is not None:
1382 varun.gupt 11230 
      oprot.writeFieldBegin('limit', TType.I64, 2)
11231 
      oprot.writeI64(self.limit)
11232 
      oprot.writeFieldEnd()
11233 
    oprot.writeFieldStop()
11234 
    oprot.writeStructEnd()
11235 
 
3431 rajveer 11236 
  def validate(self):
11237 
    return
11238 
 
11239 
 
1382 varun.gupt 11240 
  def __repr__(self):
11241 
    L = ['%s=%r' % (key, value)
11242 
      for key, value in self.__dict__.iteritems()]
11243 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11244 
 
11245 
  def __eq__(self, other):
11246 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11247 
 
11248 
  def __ne__(self, other):
11249 
    return not (self == other)
11250 
 
11251 
class getReturnableOrdersForCustomer_result:
11252 
  """
11253 
  Attributes:
11254 
   - success
11255 
   - ex
11256 
  """
11257 
 
11258 
  thrift_spec = (
11259 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
11260 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
11261 
  )
11262 
 
11263 
  def __init__(self, success=None, ex=None,):
11264 
    self.success = success
11265 
    self.ex = ex
11266 
 
11267 
  def read(self, iprot):
11268 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11269 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11270 
      return
11271 
    iprot.readStructBegin()
11272 
    while True:
11273 
      (fname, ftype, fid) = iprot.readFieldBegin()
11274 
      if ftype == TType.STOP:
11275 
        break
11276 
      if fid == 0:
11277 
        if ftype == TType.LIST:
11278 
          self.success = []
6188 rajveer 11279 
          (_etype172, _size169) = iprot.readListBegin()
11280 
          for _i173 in xrange(_size169):
11281 
            _elem174 = iprot.readI64();
11282 
            self.success.append(_elem174)
1382 varun.gupt 11283 
          iprot.readListEnd()
11284 
        else:
11285 
          iprot.skip(ftype)
11286 
      elif fid == 1:
11287 
        if ftype == TType.STRUCT:
11288 
          self.ex = TransactionServiceException()
11289 
          self.ex.read(iprot)
11290 
        else:
11291 
          iprot.skip(ftype)
11292 
      else:
11293 
        iprot.skip(ftype)
11294 
      iprot.readFieldEnd()
11295 
    iprot.readStructEnd()
11296 
 
11297 
  def write(self, oprot):
11298 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11299 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11300 
      return
11301 
    oprot.writeStructBegin('getReturnableOrdersForCustomer_result')
3431 rajveer 11302 
    if self.success is not None:
1382 varun.gupt 11303 
      oprot.writeFieldBegin('success', TType.LIST, 0)
11304 
      oprot.writeListBegin(TType.I64, len(self.success))
6188 rajveer 11305 
      for iter175 in self.success:
11306 
        oprot.writeI64(iter175)
1382 varun.gupt 11307 
      oprot.writeListEnd()
11308 
      oprot.writeFieldEnd()
3431 rajveer 11309 
    if self.ex is not None:
1382 varun.gupt 11310 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11311 
      self.ex.write(oprot)
11312 
      oprot.writeFieldEnd()
11313 
    oprot.writeFieldStop()
11314 
    oprot.writeStructEnd()
11315 
 
3431 rajveer 11316 
  def validate(self):
11317 
    return
11318 
 
11319 
 
1382 varun.gupt 11320 
  def __repr__(self):
11321 
    L = ['%s=%r' % (key, value)
11322 
      for key, value in self.__dict__.iteritems()]
11323 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11324 
 
11325 
  def __eq__(self, other):
11326 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11327 
 
11328 
  def __ne__(self, other):
11329 
    return not (self == other)
11330 
 
11331 
class getCancellableOrdersForCustomer_args:
11332 
  """
11333 
  Attributes:
11334 
   - customer_id
11335 
   - limit
11336 
  """
11337 
 
11338 
  thrift_spec = (
11339 
    None, # 0
11340 
    (1, TType.I64, 'customer_id', None, None, ), # 1
11341 
    (2, TType.I64, 'limit', None, None, ), # 2
11342 
  )
11343 
 
11344 
  def __init__(self, customer_id=None, limit=None,):
11345 
    self.customer_id = customer_id
11346 
    self.limit = limit
11347 
 
11348 
  def read(self, iprot):
11349 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11350 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11351 
      return
11352 
    iprot.readStructBegin()
11353 
    while True:
11354 
      (fname, ftype, fid) = iprot.readFieldBegin()
11355 
      if ftype == TType.STOP:
11356 
        break
11357 
      if fid == 1:
11358 
        if ftype == TType.I64:
11359 
          self.customer_id = iprot.readI64();
11360 
        else:
11361 
          iprot.skip(ftype)
11362 
      elif fid == 2:
11363 
        if ftype == TType.I64:
11364 
          self.limit = iprot.readI64();
11365 
        else:
11366 
          iprot.skip(ftype)
11367 
      else:
11368 
        iprot.skip(ftype)
11369 
      iprot.readFieldEnd()
11370 
    iprot.readStructEnd()
11371 
 
11372 
  def write(self, oprot):
11373 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11374 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11375 
      return
11376 
    oprot.writeStructBegin('getCancellableOrdersForCustomer_args')
3431 rajveer 11377 
    if self.customer_id is not None:
1382 varun.gupt 11378 
      oprot.writeFieldBegin('customer_id', TType.I64, 1)
11379 
      oprot.writeI64(self.customer_id)
11380 
      oprot.writeFieldEnd()
3431 rajveer 11381 
    if self.limit is not None:
1382 varun.gupt 11382 
      oprot.writeFieldBegin('limit', TType.I64, 2)
11383 
      oprot.writeI64(self.limit)
11384 
      oprot.writeFieldEnd()
11385 
    oprot.writeFieldStop()
11386 
    oprot.writeStructEnd()
11387 
 
3431 rajveer 11388 
  def validate(self):
11389 
    return
11390 
 
11391 
 
1382 varun.gupt 11392 
  def __repr__(self):
11393 
    L = ['%s=%r' % (key, value)
11394 
      for key, value in self.__dict__.iteritems()]
11395 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11396 
 
11397 
  def __eq__(self, other):
11398 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11399 
 
11400 
  def __ne__(self, other):
11401 
    return not (self == other)
11402 
 
11403 
class getCancellableOrdersForCustomer_result:
11404 
  """
11405 
  Attributes:
11406 
   - success
11407 
   - ex
11408 
  """
11409 
 
11410 
  thrift_spec = (
11411 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
11412 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
11413 
  )
11414 
 
11415 
  def __init__(self, success=None, ex=None,):
11416 
    self.success = success
11417 
    self.ex = ex
11418 
 
11419 
  def read(self, iprot):
11420 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11421 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11422 
      return
11423 
    iprot.readStructBegin()
11424 
    while True:
11425 
      (fname, ftype, fid) = iprot.readFieldBegin()
11426 
      if ftype == TType.STOP:
11427 
        break
11428 
      if fid == 0:
11429 
        if ftype == TType.LIST:
11430 
          self.success = []
6188 rajveer 11431 
          (_etype179, _size176) = iprot.readListBegin()
11432 
          for _i180 in xrange(_size176):
11433 
            _elem181 = iprot.readI64();
11434 
            self.success.append(_elem181)
1382 varun.gupt 11435 
          iprot.readListEnd()
11436 
        else:
11437 
          iprot.skip(ftype)
11438 
      elif fid == 1:
11439 
        if ftype == TType.STRUCT:
11440 
          self.ex = TransactionServiceException()
11441 
          self.ex.read(iprot)
11442 
        else:
11443 
          iprot.skip(ftype)
11444 
      else:
11445 
        iprot.skip(ftype)
11446 
      iprot.readFieldEnd()
11447 
    iprot.readStructEnd()
11448 
 
11449 
  def write(self, oprot):
11450 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11451 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11452 
      return
11453 
    oprot.writeStructBegin('getCancellableOrdersForCustomer_result')
3431 rajveer 11454 
    if self.success is not None:
1382 varun.gupt 11455 
      oprot.writeFieldBegin('success', TType.LIST, 0)
11456 
      oprot.writeListBegin(TType.I64, len(self.success))
6188 rajveer 11457 
      for iter182 in self.success:
11458 
        oprot.writeI64(iter182)
1382 varun.gupt 11459 
      oprot.writeListEnd()
11460 
      oprot.writeFieldEnd()
3431 rajveer 11461 
    if self.ex is not None:
1382 varun.gupt 11462 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11463 
      self.ex.write(oprot)
11464 
      oprot.writeFieldEnd()
11465 
    oprot.writeFieldStop()
11466 
    oprot.writeStructEnd()
11467 
 
3431 rajveer 11468 
  def validate(self):
11469 
    return
11470 
 
11471 
 
1382 varun.gupt 11472 
  def __repr__(self):
11473 
    L = ['%s=%r' % (key, value)
11474 
      for key, value in self.__dict__.iteritems()]
11475 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11476 
 
11477 
  def __eq__(self, other):
11478 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11479 
 
11480 
  def __ne__(self, other):
11481 
    return not (self == other)
11482 
 
483 rajveer 11483 
class changeOrderStatus_args:
94 ashish 11484 
  """
11485 
  Attributes:
483 rajveer 11486 
   - orderId
11487 
   - status
11488 
   - description
94 ashish 11489 
  """
11490 
 
11491 
  thrift_spec = (
11492 
    None, # 0
483 rajveer 11493 
    (1, TType.I64, 'orderId', None, None, ), # 1
11494 
    (2, TType.I32, 'status', None, None, ), # 2
11495 
    (3, TType.STRING, 'description', None, None, ), # 3
94 ashish 11496 
  )
11497 
 
483 rajveer 11498 
  def __init__(self, orderId=None, status=None, description=None,):
11499 
    self.orderId = orderId
11500 
    self.status = status
11501 
    self.description = description
94 ashish 11502 
 
11503 
  def read(self, iprot):
11504 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11505 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11506 
      return
11507 
    iprot.readStructBegin()
11508 
    while True:
11509 
      (fname, ftype, fid) = iprot.readFieldBegin()
11510 
      if ftype == TType.STOP:
11511 
        break
11512 
      if fid == 1:
11513 
        if ftype == TType.I64:
483 rajveer 11514 
          self.orderId = iprot.readI64();
94 ashish 11515 
        else:
11516 
          iprot.skip(ftype)
11517 
      elif fid == 2:
483 rajveer 11518 
        if ftype == TType.I32:
11519 
          self.status = iprot.readI32();
94 ashish 11520 
        else:
11521 
          iprot.skip(ftype)
483 rajveer 11522 
      elif fid == 3:
11523 
        if ftype == TType.STRING:
11524 
          self.description = iprot.readString();
11525 
        else:
11526 
          iprot.skip(ftype)
94 ashish 11527 
      else:
11528 
        iprot.skip(ftype)
11529 
      iprot.readFieldEnd()
11530 
    iprot.readStructEnd()
11531 
 
11532 
  def write(self, oprot):
11533 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11534 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11535 
      return
483 rajveer 11536 
    oprot.writeStructBegin('changeOrderStatus_args')
3431 rajveer 11537 
    if self.orderId is not None:
483 rajveer 11538 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
11539 
      oprot.writeI64(self.orderId)
94 ashish 11540 
      oprot.writeFieldEnd()
3431 rajveer 11541 
    if self.status is not None:
483 rajveer 11542 
      oprot.writeFieldBegin('status', TType.I32, 2)
11543 
      oprot.writeI32(self.status)
94 ashish 11544 
      oprot.writeFieldEnd()
3431 rajveer 11545 
    if self.description is not None:
483 rajveer 11546 
      oprot.writeFieldBegin('description', TType.STRING, 3)
11547 
      oprot.writeString(self.description)
11548 
      oprot.writeFieldEnd()
94 ashish 11549 
    oprot.writeFieldStop()
11550 
    oprot.writeStructEnd()
11551 
 
3431 rajveer 11552 
  def validate(self):
11553 
    return
11554 
 
11555 
 
94 ashish 11556 
  def __repr__(self):
11557 
    L = ['%s=%r' % (key, value)
11558 
      for key, value in self.__dict__.iteritems()]
11559 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11560 
 
11561 
  def __eq__(self, other):
11562 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11563 
 
11564 
  def __ne__(self, other):
11565 
    return not (self == other)
11566 
 
483 rajveer 11567 
class changeOrderStatus_result:
94 ashish 11568 
  """
11569 
  Attributes:
11570 
   - success
11571 
   - ex
11572 
  """
11573 
 
11574 
  thrift_spec = (
11575 
    (0, TType.BOOL, 'success', None, None, ), # 0
11576 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
11577 
  )
11578 
 
11579 
  def __init__(self, success=None, ex=None,):
11580 
    self.success = success
11581 
    self.ex = ex
11582 
 
11583 
  def read(self, iprot):
11584 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11585 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11586 
      return
11587 
    iprot.readStructBegin()
11588 
    while True:
11589 
      (fname, ftype, fid) = iprot.readFieldBegin()
11590 
      if ftype == TType.STOP:
11591 
        break
11592 
      if fid == 0:
11593 
        if ftype == TType.BOOL:
11594 
          self.success = iprot.readBool();
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
483 rajveer 11612 
    oprot.writeStructBegin('changeOrderStatus_result')
3431 rajveer 11613 
    if self.success is not None:
94 ashish 11614 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
11615 
      oprot.writeBool(self.success)
11616 
      oprot.writeFieldEnd()
3431 rajveer 11617 
    if self.ex is not None:
94 ashish 11618 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11619 
      self.ex.write(oprot)
11620 
      oprot.writeFieldEnd()
11621 
    oprot.writeFieldStop()
11622 
    oprot.writeStructEnd()
11623 
 
3431 rajveer 11624 
  def validate(self):
11625 
    return
11626 
 
11627 
 
94 ashish 11628 
  def __repr__(self):
11629 
    L = ['%s=%r' % (key, value)
11630 
      for key, value in self.__dict__.iteritems()]
11631 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11632 
 
11633 
  def __eq__(self, other):
11634 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11635 
 
11636 
  def __ne__(self, other):
11637 
    return not (self == other)
11638 
 
3064 chandransh 11639 
class getOrdersForTransaction_args:
494 rajveer 11640 
  """
11641 
  Attributes:
3064 chandransh 11642 
   - transactionId
11643 
   - customerId
494 rajveer 11644 
  """
11645 
 
11646 
  thrift_spec = (
11647 
    None, # 0
3064 chandransh 11648 
    (1, TType.I64, 'transactionId', None, None, ), # 1
11649 
    (2, TType.I64, 'customerId', None, None, ), # 2
494 rajveer 11650 
  )
11651 
 
3064 chandransh 11652 
  def __init__(self, transactionId=None, customerId=None,):
11653 
    self.transactionId = transactionId
11654 
    self.customerId = customerId
494 rajveer 11655 
 
11656 
  def read(self, iprot):
11657 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11658 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11659 
      return
11660 
    iprot.readStructBegin()
11661 
    while True:
11662 
      (fname, ftype, fid) = iprot.readFieldBegin()
11663 
      if ftype == TType.STOP:
11664 
        break
11665 
      if fid == 1:
11666 
        if ftype == TType.I64:
3064 chandransh 11667 
          self.transactionId = iprot.readI64();
494 rajveer 11668 
        else:
11669 
          iprot.skip(ftype)
11670 
      elif fid == 2:
3064 chandransh 11671 
        if ftype == TType.I64:
11672 
          self.customerId = iprot.readI64();
494 rajveer 11673 
        else:
11674 
          iprot.skip(ftype)
11675 
      else:
11676 
        iprot.skip(ftype)
11677 
      iprot.readFieldEnd()
11678 
    iprot.readStructEnd()
11679 
 
11680 
  def write(self, oprot):
11681 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11682 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11683 
      return
3064 chandransh 11684 
    oprot.writeStructBegin('getOrdersForTransaction_args')
3431 rajveer 11685 
    if self.transactionId is not None:
3064 chandransh 11686 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
11687 
      oprot.writeI64(self.transactionId)
494 rajveer 11688 
      oprot.writeFieldEnd()
3431 rajveer 11689 
    if self.customerId is not None:
3064 chandransh 11690 
      oprot.writeFieldBegin('customerId', TType.I64, 2)
11691 
      oprot.writeI64(self.customerId)
494 rajveer 11692 
      oprot.writeFieldEnd()
11693 
    oprot.writeFieldStop()
11694 
    oprot.writeStructEnd()
11695 
 
3431 rajveer 11696 
  def validate(self):
11697 
    return
11698 
 
11699 
 
494 rajveer 11700 
  def __repr__(self):
11701 
    L = ['%s=%r' % (key, value)
11702 
      for key, value in self.__dict__.iteritems()]
11703 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11704 
 
11705 
  def __eq__(self, other):
11706 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11707 
 
11708 
  def __ne__(self, other):
11709 
    return not (self == other)
11710 
 
3064 chandransh 11711 
class getOrdersForTransaction_result:
494 rajveer 11712 
  """
11713 
  Attributes:
11714 
   - success
11715 
   - ex
11716 
  """
11717 
 
11718 
  thrift_spec = (
3064 chandransh 11719 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
494 rajveer 11720 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
11721 
  )
11722 
 
11723 
  def __init__(self, success=None, ex=None,):
11724 
    self.success = success
11725 
    self.ex = ex
11726 
 
11727 
  def read(self, iprot):
11728 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11729 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11730 
      return
11731 
    iprot.readStructBegin()
11732 
    while True:
11733 
      (fname, ftype, fid) = iprot.readFieldBegin()
11734 
      if ftype == TType.STOP:
11735 
        break
11736 
      if fid == 0:
3064 chandransh 11737 
        if ftype == TType.LIST:
11738 
          self.success = []
6188 rajveer 11739 
          (_etype186, _size183) = iprot.readListBegin()
11740 
          for _i187 in xrange(_size183):
11741 
            _elem188 = Order()
11742 
            _elem188.read(iprot)
11743 
            self.success.append(_elem188)
3064 chandransh 11744 
          iprot.readListEnd()
494 rajveer 11745 
        else:
11746 
          iprot.skip(ftype)
11747 
      elif fid == 1:
11748 
        if ftype == TType.STRUCT:
11749 
          self.ex = TransactionServiceException()
11750 
          self.ex.read(iprot)
11751 
        else:
11752 
          iprot.skip(ftype)
11753 
      else:
11754 
        iprot.skip(ftype)
11755 
      iprot.readFieldEnd()
11756 
    iprot.readStructEnd()
11757 
 
11758 
  def write(self, oprot):
11759 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11760 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11761 
      return
3064 chandransh 11762 
    oprot.writeStructBegin('getOrdersForTransaction_result')
3431 rajveer 11763 
    if self.success is not None:
3064 chandransh 11764 
      oprot.writeFieldBegin('success', TType.LIST, 0)
11765 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 11766 
      for iter189 in self.success:
11767 
        iter189.write(oprot)
3064 chandransh 11768 
      oprot.writeListEnd()
494 rajveer 11769 
      oprot.writeFieldEnd()
3431 rajveer 11770 
    if self.ex is not None:
494 rajveer 11771 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11772 
      self.ex.write(oprot)
11773 
      oprot.writeFieldEnd()
11774 
    oprot.writeFieldStop()
11775 
    oprot.writeStructEnd()
11776 
 
3431 rajveer 11777 
  def validate(self):
11778 
    return
11779 
 
11780 
 
494 rajveer 11781 
  def __repr__(self):
11782 
    L = ['%s=%r' % (key, value)
11783 
      for key, value in self.__dict__.iteritems()]
11784 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11785 
 
11786 
  def __eq__(self, other):
11787 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11788 
 
11789 
  def __ne__(self, other):
11790 
    return not (self == other)
11791 
 
3064 chandransh 11792 
class getOrdersForCustomer_args:
1149 chandransh 11793 
  """
11794 
  Attributes:
3064 chandransh 11795 
   - customerId
11796 
   - from_date
11797 
   - to_date
11798 
   - statuses
1149 chandransh 11799 
  """
11800 
 
11801 
  thrift_spec = (
11802 
    None, # 0
3064 chandransh 11803 
    (1, TType.I64, 'customerId', None, None, ), # 1
11804 
    (2, TType.I64, 'from_date', None, None, ), # 2
11805 
    (3, TType.I64, 'to_date', None, None, ), # 3
11806 
    (4, TType.LIST, 'statuses', (TType.I32,None), None, ), # 4
1149 chandransh 11807 
  )
11808 
 
3064 chandransh 11809 
  def __init__(self, customerId=None, from_date=None, to_date=None, statuses=None,):
11810 
    self.customerId = customerId
11811 
    self.from_date = from_date
11812 
    self.to_date = to_date
11813 
    self.statuses = statuses
1149 chandransh 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.customerId = iprot.readI64();
1149 chandransh 11827 
        else:
11828 
          iprot.skip(ftype)
11829 
      elif fid == 2:
11830 
        if ftype == TType.I64:
3064 chandransh 11831 
          self.from_date = iprot.readI64();
1149 chandransh 11832 
        else:
11833 
          iprot.skip(ftype)
2783 chandransh 11834 
      elif fid == 3:
11835 
        if ftype == TType.I64:
3064 chandransh 11836 
          self.to_date = iprot.readI64();
2783 chandransh 11837 
        else:
11838 
          iprot.skip(ftype)
11839 
      elif fid == 4:
3064 chandransh 11840 
        if ftype == TType.LIST:
11841 
          self.statuses = []
6188 rajveer 11842 
          (_etype193, _size190) = iprot.readListBegin()
11843 
          for _i194 in xrange(_size190):
11844 
            _elem195 = iprot.readI32();
11845 
            self.statuses.append(_elem195)
3064 chandransh 11846 
          iprot.readListEnd()
2783 chandransh 11847 
        else:
11848 
          iprot.skip(ftype)
1149 chandransh 11849 
      else:
11850 
        iprot.skip(ftype)
11851 
      iprot.readFieldEnd()
11852 
    iprot.readStructEnd()
11853 
 
11854 
  def write(self, oprot):
11855 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11856 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11857 
      return
3064 chandransh 11858 
    oprot.writeStructBegin('getOrdersForCustomer_args')
3431 rajveer 11859 
    if self.customerId is not None:
3064 chandransh 11860 
      oprot.writeFieldBegin('customerId', TType.I64, 1)
11861 
      oprot.writeI64(self.customerId)
1149 chandransh 11862 
      oprot.writeFieldEnd()
3431 rajveer 11863 
    if self.from_date is not None:
3064 chandransh 11864 
      oprot.writeFieldBegin('from_date', TType.I64, 2)
11865 
      oprot.writeI64(self.from_date)
1149 chandransh 11866 
      oprot.writeFieldEnd()
3431 rajveer 11867 
    if self.to_date is not None:
3064 chandransh 11868 
      oprot.writeFieldBegin('to_date', TType.I64, 3)
11869 
      oprot.writeI64(self.to_date)
2783 chandransh 11870 
      oprot.writeFieldEnd()
3431 rajveer 11871 
    if self.statuses is not None:
3064 chandransh 11872 
      oprot.writeFieldBegin('statuses', TType.LIST, 4)
11873 
      oprot.writeListBegin(TType.I32, len(self.statuses))
6188 rajveer 11874 
      for iter196 in self.statuses:
11875 
        oprot.writeI32(iter196)
3064 chandransh 11876 
      oprot.writeListEnd()
2783 chandransh 11877 
      oprot.writeFieldEnd()
1149 chandransh 11878 
    oprot.writeFieldStop()
11879 
    oprot.writeStructEnd()
11880 
 
3431 rajveer 11881 
  def validate(self):
11882 
    return
11883 
 
11884 
 
1149 chandransh 11885 
  def __repr__(self):
11886 
    L = ['%s=%r' % (key, value)
11887 
      for key, value in self.__dict__.iteritems()]
11888 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11889 
 
11890 
  def __eq__(self, other):
11891 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11892 
 
11893 
  def __ne__(self, other):
11894 
    return not (self == other)
11895 
 
3064 chandransh 11896 
class getOrdersForCustomer_result:
1149 chandransh 11897 
  """
11898 
  Attributes:
11899 
   - success
11900 
   - ex
11901 
  """
11902 
 
11903 
  thrift_spec = (
3064 chandransh 11904 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
1149 chandransh 11905 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
11906 
  )
11907 
 
11908 
  def __init__(self, success=None, ex=None,):
11909 
    self.success = success
11910 
    self.ex = ex
11911 
 
11912 
  def read(self, iprot):
11913 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11914 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11915 
      return
11916 
    iprot.readStructBegin()
11917 
    while True:
11918 
      (fname, ftype, fid) = iprot.readFieldBegin()
11919 
      if ftype == TType.STOP:
11920 
        break
11921 
      if fid == 0:
3064 chandransh 11922 
        if ftype == TType.LIST:
11923 
          self.success = []
6188 rajveer 11924 
          (_etype200, _size197) = iprot.readListBegin()
11925 
          for _i201 in xrange(_size197):
11926 
            _elem202 = Order()
11927 
            _elem202.read(iprot)
11928 
            self.success.append(_elem202)
3064 chandransh 11929 
          iprot.readListEnd()
1149 chandransh 11930 
        else:
11931 
          iprot.skip(ftype)
11932 
      elif fid == 1:
11933 
        if ftype == TType.STRUCT:
11934 
          self.ex = TransactionServiceException()
11935 
          self.ex.read(iprot)
11936 
        else:
11937 
          iprot.skip(ftype)
11938 
      else:
11939 
        iprot.skip(ftype)
11940 
      iprot.readFieldEnd()
11941 
    iprot.readStructEnd()
11942 
 
11943 
  def write(self, oprot):
11944 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11945 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11946 
      return
3064 chandransh 11947 
    oprot.writeStructBegin('getOrdersForCustomer_result')
3431 rajveer 11948 
    if self.success is not None:
3064 chandransh 11949 
      oprot.writeFieldBegin('success', TType.LIST, 0)
11950 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 11951 
      for iter203 in self.success:
11952 
        iter203.write(oprot)
3064 chandransh 11953 
      oprot.writeListEnd()
1149 chandransh 11954 
      oprot.writeFieldEnd()
3431 rajveer 11955 
    if self.ex is not None:
1149 chandransh 11956 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11957 
      self.ex.write(oprot)
11958 
      oprot.writeFieldEnd()
11959 
    oprot.writeFieldStop()
11960 
    oprot.writeStructEnd()
11961 
 
3431 rajveer 11962 
  def validate(self):
11963 
    return
11964 
 
11965 
 
1149 chandransh 11966 
  def __repr__(self):
11967 
    L = ['%s=%r' % (key, value)
11968 
      for key, value in self.__dict__.iteritems()]
11969 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11970 
 
11971 
  def __eq__(self, other):
11972 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11973 
 
11974 
  def __ne__(self, other):
11975 
    return not (self == other)
11976 
 
3064 chandransh 11977 
class createOrder_args:
921 rajveer 11978 
  """
11979 
  Attributes:
3064 chandransh 11980 
   - order
921 rajveer 11981 
  """
11982 
 
11983 
  thrift_spec = (
11984 
    None, # 0
3064 chandransh 11985 
    (1, TType.STRUCT, 'order', (Order, Order.thrift_spec), None, ), # 1
921 rajveer 11986 
  )
11987 
 
3064 chandransh 11988 
  def __init__(self, order=None,):
11989 
    self.order = order
921 rajveer 11990 
 
11991 
  def read(self, iprot):
11992 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11993 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11994 
      return
11995 
    iprot.readStructBegin()
11996 
    while True:
11997 
      (fname, ftype, fid) = iprot.readFieldBegin()
11998 
      if ftype == TType.STOP:
11999 
        break
12000 
      if fid == 1:
3064 chandransh 12001 
        if ftype == TType.STRUCT:
12002 
          self.order = Order()
12003 
          self.order.read(iprot)
921 rajveer 12004 
        else:
12005 
          iprot.skip(ftype)
12006 
      else:
12007 
        iprot.skip(ftype)
12008 
      iprot.readFieldEnd()
12009 
    iprot.readStructEnd()
12010 
 
12011 
  def write(self, oprot):
12012 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12013 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12014 
      return
3064 chandransh 12015 
    oprot.writeStructBegin('createOrder_args')
3431 rajveer 12016 
    if self.order is not None:
3064 chandransh 12017 
      oprot.writeFieldBegin('order', TType.STRUCT, 1)
12018 
      self.order.write(oprot)
921 rajveer 12019 
      oprot.writeFieldEnd()
12020 
    oprot.writeFieldStop()
12021 
    oprot.writeStructEnd()
12022 
 
3431 rajveer 12023 
  def validate(self):
12024 
    return
12025 
 
12026 
 
921 rajveer 12027 
  def __repr__(self):
12028 
    L = ['%s=%r' % (key, value)
12029 
      for key, value in self.__dict__.iteritems()]
12030 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12031 
 
12032 
  def __eq__(self, other):
12033 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12034 
 
12035 
  def __ne__(self, other):
12036 
    return not (self == other)
12037 
 
3064 chandransh 12038 
class createOrder_result:
921 rajveer 12039 
  """
12040 
  Attributes:
12041 
   - success
12042 
   - ex
12043 
  """
12044 
 
12045 
  thrift_spec = (
3064 chandransh 12046 
    (0, TType.I64, 'success', None, None, ), # 0
921 rajveer 12047 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
12048 
  )
12049 
 
12050 
  def __init__(self, success=None, ex=None,):
12051 
    self.success = success
12052 
    self.ex = ex
12053 
 
12054 
  def read(self, iprot):
12055 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12056 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12057 
      return
12058 
    iprot.readStructBegin()
12059 
    while True:
12060 
      (fname, ftype, fid) = iprot.readFieldBegin()
12061 
      if ftype == TType.STOP:
12062 
        break
12063 
      if fid == 0:
3064 chandransh 12064 
        if ftype == TType.I64:
12065 
          self.success = iprot.readI64();
921 rajveer 12066 
        else:
12067 
          iprot.skip(ftype)
12068 
      elif fid == 1:
12069 
        if ftype == TType.STRUCT:
12070 
          self.ex = TransactionServiceException()
12071 
          self.ex.read(iprot)
12072 
        else:
12073 
          iprot.skip(ftype)
12074 
      else:
12075 
        iprot.skip(ftype)
12076 
      iprot.readFieldEnd()
12077 
    iprot.readStructEnd()
12078 
 
12079 
  def write(self, oprot):
12080 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12081 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12082 
      return
3064 chandransh 12083 
    oprot.writeStructBegin('createOrder_result')
3431 rajveer 12084 
    if self.success is not None:
3064 chandransh 12085 
      oprot.writeFieldBegin('success', TType.I64, 0)
12086 
      oprot.writeI64(self.success)
921 rajveer 12087 
      oprot.writeFieldEnd()
3431 rajveer 12088 
    if self.ex is not None:
921 rajveer 12089 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
12090 
      self.ex.write(oprot)
12091 
      oprot.writeFieldEnd()
12092 
    oprot.writeFieldStop()
12093 
    oprot.writeStructEnd()
12094 
 
3431 rajveer 12095 
  def validate(self):
12096 
    return
12097 
 
12098 
 
921 rajveer 12099 
  def __repr__(self):
12100 
    L = ['%s=%r' % (key, value)
12101 
      for key, value in self.__dict__.iteritems()]
12102 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12103 
 
12104 
  def __eq__(self, other):
12105 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12106 
 
12107 
  def __ne__(self, other):
12108 
    return not (self == other)
12109 
 
3064 chandransh 12110 
class getOrder_args:
921 rajveer 12111 
  """
12112 
  Attributes:
3064 chandransh 12113 
   - id
921 rajveer 12114 
  """
12115 
 
12116 
  thrift_spec = (
12117 
    None, # 0
3064 chandransh 12118 
    (1, TType.I64, 'id', None, None, ), # 1
921 rajveer 12119 
  )
12120 
 
3064 chandransh 12121 
  def __init__(self, id=None,):
12122 
    self.id = id
921 rajveer 12123 
 
12124 
  def read(self, iprot):
12125 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12126 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12127 
      return
12128 
    iprot.readStructBegin()
12129 
    while True:
12130 
      (fname, ftype, fid) = iprot.readFieldBegin()
12131 
      if ftype == TType.STOP:
12132 
        break
12133 
      if fid == 1:
12134 
        if ftype == TType.I64:
3064 chandransh 12135 
          self.id = iprot.readI64();
921 rajveer 12136 
        else:
12137 
          iprot.skip(ftype)
12138 
      else:
12139 
        iprot.skip(ftype)
12140 
      iprot.readFieldEnd()
12141 
    iprot.readStructEnd()
12142 
 
12143 
  def write(self, oprot):
12144 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12145 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12146 
      return
3064 chandransh 12147 
    oprot.writeStructBegin('getOrder_args')
3431 rajveer 12148 
    if self.id is not None:
3064 chandransh 12149 
      oprot.writeFieldBegin('id', TType.I64, 1)
12150 
      oprot.writeI64(self.id)
921 rajveer 12151 
      oprot.writeFieldEnd()
12152 
    oprot.writeFieldStop()
12153 
    oprot.writeStructEnd()
12154 
 
3431 rajveer 12155 
  def validate(self):
12156 
    return
12157 
 
12158 
 
921 rajveer 12159 
  def __repr__(self):
12160 
    L = ['%s=%r' % (key, value)
12161 
      for key, value in self.__dict__.iteritems()]
12162 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12163 
 
12164 
  def __eq__(self, other):
12165 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12166 
 
12167 
  def __ne__(self, other):
12168 
    return not (self == other)
12169 
 
3064 chandransh 12170 
class getOrder_result:
921 rajveer 12171 
  """
12172 
  Attributes:
12173 
   - success
12174 
   - ex
12175 
  """
12176 
 
12177 
  thrift_spec = (
3064 chandransh 12178 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
921 rajveer 12179 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
12180 
  )
12181 
 
12182 
  def __init__(self, success=None, ex=None,):
12183 
    self.success = success
12184 
    self.ex = ex
12185 
 
12186 
  def read(self, iprot):
12187 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12188 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12189 
      return
12190 
    iprot.readStructBegin()
12191 
    while True:
12192 
      (fname, ftype, fid) = iprot.readFieldBegin()
12193 
      if ftype == TType.STOP:
12194 
        break
12195 
      if fid == 0:
3064 chandransh 12196 
        if ftype == TType.STRUCT:
12197 
          self.success = Order()
12198 
          self.success.read(iprot)
921 rajveer 12199 
        else:
12200 
          iprot.skip(ftype)
12201 
      elif fid == 1:
12202 
        if ftype == TType.STRUCT:
12203 
          self.ex = TransactionServiceException()
12204 
          self.ex.read(iprot)
12205 
        else:
12206 
          iprot.skip(ftype)
12207 
      else:
12208 
        iprot.skip(ftype)
12209 
      iprot.readFieldEnd()
12210 
    iprot.readStructEnd()
12211 
 
12212 
  def write(self, oprot):
12213 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12214 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12215 
      return
3064 chandransh 12216 
    oprot.writeStructBegin('getOrder_result')
3431 rajveer 12217 
    if self.success is not None:
3064 chandransh 12218 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
12219 
      self.success.write(oprot)
921 rajveer 12220 
      oprot.writeFieldEnd()
3431 rajveer 12221 
    if self.ex is not None:
921 rajveer 12222 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
12223 
      self.ex.write(oprot)
12224 
      oprot.writeFieldEnd()
12225 
    oprot.writeFieldStop()
12226 
    oprot.writeStructEnd()
12227 
 
3431 rajveer 12228 
  def validate(self):
12229 
    return
12230 
 
12231 
 
921 rajveer 12232 
  def __repr__(self):
12233 
    L = ['%s=%r' % (key, value)
12234 
      for key, value in self.__dict__.iteritems()]
12235 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12236 
 
12237 
  def __eq__(self, other):
12238 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12239 
 
12240 
  def __ne__(self, other):
12241 
    return not (self == other)
12242 
 
3064 chandransh 12243 
class getLineItemsForOrder_args:
94 ashish 12244 
  """
12245 
  Attributes:
3064 chandransh 12246 
   - orderId
94 ashish 12247 
  """
12248 
 
12249 
  thrift_spec = (
12250 
    None, # 0
3064 chandransh 12251 
    (1, TType.I64, 'orderId', None, None, ), # 1
94 ashish 12252 
  )
12253 
 
3064 chandransh 12254 
  def __init__(self, orderId=None,):
12255 
    self.orderId = orderId
94 ashish 12256 
 
12257 
  def read(self, iprot):
12258 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12259 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12260 
      return
12261 
    iprot.readStructBegin()
12262 
    while True:
12263 
      (fname, ftype, fid) = iprot.readFieldBegin()
12264 
      if ftype == TType.STOP:
12265 
        break
12266 
      if fid == 1:
12267 
        if ftype == TType.I64:
3064 chandransh 12268 
          self.orderId = iprot.readI64();
94 ashish 12269 
        else:
12270 
          iprot.skip(ftype)
12271 
      else:
12272 
        iprot.skip(ftype)
12273 
      iprot.readFieldEnd()
12274 
    iprot.readStructEnd()
12275 
 
12276 
  def write(self, oprot):
12277 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12278 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12279 
      return
3064 chandransh 12280 
    oprot.writeStructBegin('getLineItemsForOrder_args')
3431 rajveer 12281 
    if self.orderId is not None:
3064 chandransh 12282 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
12283 
      oprot.writeI64(self.orderId)
94 ashish 12284 
      oprot.writeFieldEnd()
12285 
    oprot.writeFieldStop()
12286 
    oprot.writeStructEnd()
12287 
 
3431 rajveer 12288 
  def validate(self):
12289 
    return
12290 
 
12291 
 
94 ashish 12292 
  def __repr__(self):
12293 
    L = ['%s=%r' % (key, value)
12294 
      for key, value in self.__dict__.iteritems()]
12295 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12296 
 
12297 
  def __eq__(self, other):
12298 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12299 
 
12300 
  def __ne__(self, other):
12301 
    return not (self == other)
12302 
 
3064 chandransh 12303 
class getLineItemsForOrder_result:
94 ashish 12304 
  """
12305 
  Attributes:
12306 
   - success
12307 
   - ex
12308 
  """
12309 
 
12310 
  thrift_spec = (
3064 chandransh 12311 
    (0, TType.LIST, 'success', (TType.STRUCT,(LineItem, LineItem.thrift_spec)), None, ), # 0
94 ashish 12312 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
12313 
  )
12314 
 
12315 
  def __init__(self, success=None, ex=None,):
12316 
    self.success = success
12317 
    self.ex = ex
12318 
 
12319 
  def read(self, iprot):
12320 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12321 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12322 
      return
12323 
    iprot.readStructBegin()
12324 
    while True:
12325 
      (fname, ftype, fid) = iprot.readFieldBegin()
12326 
      if ftype == TType.STOP:
12327 
        break
12328 
      if fid == 0:
483 rajveer 12329 
        if ftype == TType.LIST:
12330 
          self.success = []
6188 rajveer 12331 
          (_etype207, _size204) = iprot.readListBegin()
12332 
          for _i208 in xrange(_size204):
12333 
            _elem209 = LineItem()
12334 
            _elem209.read(iprot)
12335 
            self.success.append(_elem209)
483 rajveer 12336 
          iprot.readListEnd()
94 ashish 12337 
        else:
12338 
          iprot.skip(ftype)
12339 
      elif fid == 1:
12340 
        if ftype == TType.STRUCT:
12341 
          self.ex = TransactionServiceException()
12342 
          self.ex.read(iprot)
12343 
        else:
12344 
          iprot.skip(ftype)
12345 
      else:
12346 
        iprot.skip(ftype)
12347 
      iprot.readFieldEnd()
12348 
    iprot.readStructEnd()
12349 
 
12350 
  def write(self, oprot):
12351 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12352 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12353 
      return
3064 chandransh 12354 
    oprot.writeStructBegin('getLineItemsForOrder_result')
3431 rajveer 12355 
    if self.success is not None:
483 rajveer 12356 
      oprot.writeFieldBegin('success', TType.LIST, 0)
12357 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 12358 
      for iter210 in self.success:
12359 
        iter210.write(oprot)
483 rajveer 12360 
      oprot.writeListEnd()
94 ashish 12361 
      oprot.writeFieldEnd()
3431 rajveer 12362 
    if self.ex is not None:
94 ashish 12363 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
12364 
      self.ex.write(oprot)
12365 
      oprot.writeFieldEnd()
12366 
    oprot.writeFieldStop()
12367 
    oprot.writeStructEnd()
12368 
 
3431 rajveer 12369 
  def validate(self):
12370 
    return
12371 
 
12372 
 
94 ashish 12373 
  def __repr__(self):
12374 
    L = ['%s=%r' % (key, value)
12375 
      for key, value in self.__dict__.iteritems()]
12376 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12377 
 
12378 
  def __eq__(self, other):
12379 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12380 
 
12381 
  def __ne__(self, other):
12382 
    return not (self == other)
12383 
 
4999 phani.kuma 12384 
class getOrderList_args:
12385 
  """
12386 
  Attributes:
12387 
   - order_ids
12388 
  """
12389 
 
12390 
  thrift_spec = (
12391 
    None, # 0
12392 
    (1, TType.LIST, 'order_ids', (TType.I64,None), None, ), # 1
12393 
  )
12394 
 
12395 
  def __init__(self, order_ids=None,):
12396 
    self.order_ids = order_ids
12397 
 
12398 
  def read(self, iprot):
12399 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12400 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12401 
      return
12402 
    iprot.readStructBegin()
12403 
    while True:
12404 
      (fname, ftype, fid) = iprot.readFieldBegin()
12405 
      if ftype == TType.STOP:
12406 
        break
12407 
      if fid == 1:
12408 
        if ftype == TType.LIST:
12409 
          self.order_ids = []
6188 rajveer 12410 
          (_etype214, _size211) = iprot.readListBegin()
12411 
          for _i215 in xrange(_size211):
12412 
            _elem216 = iprot.readI64();
12413 
            self.order_ids.append(_elem216)
4999 phani.kuma 12414 
          iprot.readListEnd()
12415 
        else:
12416 
          iprot.skip(ftype)
12417 
      else:
12418 
        iprot.skip(ftype)
12419 
      iprot.readFieldEnd()
12420 
    iprot.readStructEnd()
12421 
 
12422 
  def write(self, oprot):
12423 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12424 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12425 
      return
12426 
    oprot.writeStructBegin('getOrderList_args')
12427 
    if self.order_ids is not None:
12428 
      oprot.writeFieldBegin('order_ids', TType.LIST, 1)
12429 
      oprot.writeListBegin(TType.I64, len(self.order_ids))
6188 rajveer 12430 
      for iter217 in self.order_ids:
12431 
        oprot.writeI64(iter217)
4999 phani.kuma 12432 
      oprot.writeListEnd()
12433 
      oprot.writeFieldEnd()
12434 
    oprot.writeFieldStop()
12435 
    oprot.writeStructEnd()
12436 
 
12437 
  def validate(self):
12438 
    return
12439 
 
12440 
 
12441 
  def __repr__(self):
12442 
    L = ['%s=%r' % (key, value)
12443 
      for key, value in self.__dict__.iteritems()]
12444 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12445 
 
12446 
  def __eq__(self, other):
12447 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12448 
 
12449 
  def __ne__(self, other):
12450 
    return not (self == other)
12451 
 
12452 
class getOrderList_result:
12453 
  """
12454 
  Attributes:
12455 
   - success
12456 
  """
12457 
 
12458 
  thrift_spec = (
12459 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
12460 
  )
12461 
 
12462 
  def __init__(self, success=None,):
12463 
    self.success = success
12464 
 
12465 
  def read(self, iprot):
12466 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12467 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12468 
      return
12469 
    iprot.readStructBegin()
12470 
    while True:
12471 
      (fname, ftype, fid) = iprot.readFieldBegin()
12472 
      if ftype == TType.STOP:
12473 
        break
12474 
      if fid == 0:
12475 
        if ftype == TType.LIST:
12476 
          self.success = []
6188 rajveer 12477 
          (_etype221, _size218) = iprot.readListBegin()
12478 
          for _i222 in xrange(_size218):
12479 
            _elem223 = Order()
12480 
            _elem223.read(iprot)
12481 
            self.success.append(_elem223)
4999 phani.kuma 12482 
          iprot.readListEnd()
12483 
        else:
12484 
          iprot.skip(ftype)
12485 
      else:
12486 
        iprot.skip(ftype)
12487 
      iprot.readFieldEnd()
12488 
    iprot.readStructEnd()
12489 
 
12490 
  def write(self, oprot):
12491 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12492 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12493 
      return
12494 
    oprot.writeStructBegin('getOrderList_result')
12495 
    if self.success is not None:
12496 
      oprot.writeFieldBegin('success', TType.LIST, 0)
12497 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 12498 
      for iter224 in self.success:
12499 
        iter224.write(oprot)
4999 phani.kuma 12500 
      oprot.writeListEnd()
12501 
      oprot.writeFieldEnd()
12502 
    oprot.writeFieldStop()
12503 
    oprot.writeStructEnd()
12504 
 
12505 
  def validate(self):
12506 
    return
12507 
 
12508 
 
12509 
  def __repr__(self):
12510 
    L = ['%s=%r' % (key, value)
12511 
      for key, value in self.__dict__.iteritems()]
12512 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12513 
 
12514 
  def __eq__(self, other):
12515 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12516 
 
12517 
  def __ne__(self, other):
12518 
    return not (self == other)
12519 
 
5386 phani.kuma 12520 
class getOrderListForVendor_args:
12521 
  """
12522 
  Attributes:
12523 
   - order_ids
12524 
   - vendorId
12525 
  """
12526 
 
12527 
  thrift_spec = (
12528 
    None, # 0
12529 
    (1, TType.LIST, 'order_ids', (TType.I64,None), None, ), # 1
12530 
    (2, TType.I64, 'vendorId', None, None, ), # 2
12531 
  )
12532 
 
12533 
  def __init__(self, order_ids=None, vendorId=None,):
12534 
    self.order_ids = order_ids
12535 
    self.vendorId = vendorId
12536 
 
12537 
  def read(self, iprot):
12538 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12539 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12540 
      return
12541 
    iprot.readStructBegin()
12542 
    while True:
12543 
      (fname, ftype, fid) = iprot.readFieldBegin()
12544 
      if ftype == TType.STOP:
12545 
        break
12546 
      if fid == 1:
12547 
        if ftype == TType.LIST:
12548 
          self.order_ids = []
6188 rajveer 12549 
          (_etype228, _size225) = iprot.readListBegin()
12550 
          for _i229 in xrange(_size225):
12551 
            _elem230 = iprot.readI64();
12552 
            self.order_ids.append(_elem230)
5386 phani.kuma 12553 
          iprot.readListEnd()
12554 
        else:
12555 
          iprot.skip(ftype)
12556 
      elif fid == 2:
12557 
        if ftype == TType.I64:
12558 
          self.vendorId = iprot.readI64();
12559 
        else:
12560 
          iprot.skip(ftype)
12561 
      else:
12562 
        iprot.skip(ftype)
12563 
      iprot.readFieldEnd()
12564 
    iprot.readStructEnd()
12565 
 
12566 
  def write(self, oprot):
12567 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12568 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12569 
      return
12570 
    oprot.writeStructBegin('getOrderListForVendor_args')
12571 
    if self.order_ids is not None:
12572 
      oprot.writeFieldBegin('order_ids', TType.LIST, 1)
12573 
      oprot.writeListBegin(TType.I64, len(self.order_ids))
6188 rajveer 12574 
      for iter231 in self.order_ids:
12575 
        oprot.writeI64(iter231)
5386 phani.kuma 12576 
      oprot.writeListEnd()
12577 
      oprot.writeFieldEnd()
12578 
    if self.vendorId is not None:
12579 
      oprot.writeFieldBegin('vendorId', TType.I64, 2)
12580 
      oprot.writeI64(self.vendorId)
12581 
      oprot.writeFieldEnd()
12582 
    oprot.writeFieldStop()
12583 
    oprot.writeStructEnd()
12584 
 
12585 
  def validate(self):
12586 
    return
12587 
 
12588 
 
12589 
  def __repr__(self):
12590 
    L = ['%s=%r' % (key, value)
12591 
      for key, value in self.__dict__.iteritems()]
12592 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12593 
 
12594 
  def __eq__(self, other):
12595 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12596 
 
12597 
  def __ne__(self, other):
12598 
    return not (self == other)
12599 
 
12600 
class getOrderListForVendor_result:
12601 
  """
12602 
  Attributes:
12603 
   - success
12604 
  """
12605 
 
12606 
  thrift_spec = (
12607 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
12608 
  )
12609 
 
12610 
  def __init__(self, success=None,):
12611 
    self.success = success
12612 
 
12613 
  def read(self, iprot):
12614 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12615 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12616 
      return
12617 
    iprot.readStructBegin()
12618 
    while True:
12619 
      (fname, ftype, fid) = iprot.readFieldBegin()
12620 
      if ftype == TType.STOP:
12621 
        break
12622 
      if fid == 0:
12623 
        if ftype == TType.LIST:
12624 
          self.success = []
6188 rajveer 12625 
          (_etype235, _size232) = iprot.readListBegin()
12626 
          for _i236 in xrange(_size232):
12627 
            _elem237 = Order()
12628 
            _elem237.read(iprot)
12629 
            self.success.append(_elem237)
5386 phani.kuma 12630 
          iprot.readListEnd()
12631 
        else:
12632 
          iprot.skip(ftype)
12633 
      else:
12634 
        iprot.skip(ftype)
12635 
      iprot.readFieldEnd()
12636 
    iprot.readStructEnd()
12637 
 
12638 
  def write(self, oprot):
12639 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12640 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12641 
      return
12642 
    oprot.writeStructBegin('getOrderListForVendor_result')
12643 
    if self.success is not None:
12644 
      oprot.writeFieldBegin('success', TType.LIST, 0)
12645 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 12646 
      for iter238 in self.success:
12647 
        iter238.write(oprot)
5386 phani.kuma 12648 
      oprot.writeListEnd()
12649 
      oprot.writeFieldEnd()
12650 
    oprot.writeFieldStop()
12651 
    oprot.writeStructEnd()
12652 
 
12653 
  def validate(self):
12654 
    return
12655 
 
12656 
 
12657 
  def __repr__(self):
12658 
    L = ['%s=%r' % (key, value)
12659 
      for key, value in self.__dict__.iteritems()]
12660 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12661 
 
12662 
  def __eq__(self, other):
12663 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12664 
 
12665 
  def __ne__(self, other):
12666 
    return not (self == other)
12667 
 
3064 chandransh 12668 
class getOrderForCustomer_args:
94 ashish 12669 
  """
12670 
  Attributes:
3064 chandransh 12671 
   - orderId
483 rajveer 12672 
   - customerId
94 ashish 12673 
  """
12674 
 
12675 
  thrift_spec = (
12676 
    None, # 0
3064 chandransh 12677 
    (1, TType.I64, 'orderId', None, None, ), # 1
12678 
    (2, TType.I64, 'customerId', None, None, ), # 2
94 ashish 12679 
  )
12680 
 
3064 chandransh 12681 
  def __init__(self, orderId=None, customerId=None,):
12682 
    self.orderId = orderId
483 rajveer 12683 
    self.customerId = customerId
94 ashish 12684 
 
12685 
  def read(self, iprot):
12686 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12687 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12688 
      return
12689 
    iprot.readStructBegin()
12690 
    while True:
12691 
      (fname, ftype, fid) = iprot.readFieldBegin()
12692 
      if ftype == TType.STOP:
12693 
        break
12694 
      if fid == 1:
12695 
        if ftype == TType.I64:
3064 chandransh 12696 
          self.orderId = iprot.readI64();
94 ashish 12697 
        else:
12698 
          iprot.skip(ftype)
12699 
      elif fid == 2:
12700 
        if ftype == TType.I64:
3064 chandransh 12701 
          self.customerId = iprot.readI64();
94 ashish 12702 
        else:
12703 
          iprot.skip(ftype)
12704 
      else:
12705 
        iprot.skip(ftype)
12706 
      iprot.readFieldEnd()
12707 
    iprot.readStructEnd()
12708 
 
12709 
  def write(self, oprot):
12710 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12711 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12712 
      return
3064 chandransh 12713 
    oprot.writeStructBegin('getOrderForCustomer_args')
3431 rajveer 12714 
    if self.orderId is not None:
3064 chandransh 12715 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
12716 
      oprot.writeI64(self.orderId)
12717 
      oprot.writeFieldEnd()
3431 rajveer 12718 
    if self.customerId is not None:
3064 chandransh 12719 
      oprot.writeFieldBegin('customerId', TType.I64, 2)
483 rajveer 12720 
      oprot.writeI64(self.customerId)
94 ashish 12721 
      oprot.writeFieldEnd()
12722 
    oprot.writeFieldStop()
12723 
    oprot.writeStructEnd()
12724 
 
3431 rajveer 12725 
  def validate(self):
12726 
    return
12727 
 
12728 
 
94 ashish 12729 
  def __repr__(self):
12730 
    L = ['%s=%r' % (key, value)
12731 
      for key, value in self.__dict__.iteritems()]
12732 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12733 
 
12734 
  def __eq__(self, other):
12735 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12736 
 
12737 
  def __ne__(self, other):
12738 
    return not (self == other)
12739 
 
3064 chandransh 12740 
class getOrderForCustomer_result:
94 ashish 12741 
  """
12742 
  Attributes:
12743 
   - success
12744 
   - ex
12745 
  """
12746 
 
12747 
  thrift_spec = (
3064 chandransh 12748 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
94 ashish 12749 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
12750 
  )
12751 
 
12752 
  def __init__(self, success=None, ex=None,):
12753 
    self.success = success
12754 
    self.ex = ex
12755 
 
12756 
  def read(self, iprot):
12757 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12758 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12759 
      return
12760 
    iprot.readStructBegin()
12761 
    while True:
12762 
      (fname, ftype, fid) = iprot.readFieldBegin()
12763 
      if ftype == TType.STOP:
12764 
        break
12765 
      if fid == 0:
3064 chandransh 12766 
        if ftype == TType.STRUCT:
12767 
          self.success = Order()
12768 
          self.success.read(iprot)
94 ashish 12769 
        else:
12770 
          iprot.skip(ftype)
12771 
      elif fid == 1:
12772 
        if ftype == TType.STRUCT:
12773 
          self.ex = TransactionServiceException()
12774 
          self.ex.read(iprot)
12775 
        else:
12776 
          iprot.skip(ftype)
12777 
      else:
12778 
        iprot.skip(ftype)
12779 
      iprot.readFieldEnd()
12780 
    iprot.readStructEnd()
12781 
 
12782 
  def write(self, oprot):
12783 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12784 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12785 
      return
3064 chandransh 12786 
    oprot.writeStructBegin('getOrderForCustomer_result')
3431 rajveer 12787 
    if self.success is not None:
3064 chandransh 12788 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
12789 
      self.success.write(oprot)
94 ashish 12790 
      oprot.writeFieldEnd()
3431 rajveer 12791 
    if self.ex is not None:
94 ashish 12792 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
12793 
      self.ex.write(oprot)
12794 
      oprot.writeFieldEnd()
12795 
    oprot.writeFieldStop()
12796 
    oprot.writeStructEnd()
12797 
 
3431 rajveer 12798 
  def validate(self):
12799 
    return
12800 
 
12801 
 
94 ashish 12802 
  def __repr__(self):
12803 
    L = ['%s=%r' % (key, value)
12804 
      for key, value in self.__dict__.iteritems()]
12805 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12806 
 
12807 
  def __eq__(self, other):
12808 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12809 
 
12810 
  def __ne__(self, other):
12811 
    return not (self == other)
12812 
 
3064 chandransh 12813 
class getAlerts_args:
94 ashish 12814 
  """
12815 
  Attributes:
4394 rajveer 12816 
   - type
4444 rajveer 12817 
   - warehouseId
4394 rajveer 12818 
   - status
12819 
   - timestamp
94 ashish 12820 
  """
12821 
 
12822 
  thrift_spec = (
12823 
    None, # 0
4394 rajveer 12824 
    (1, TType.I64, 'type', None, None, ), # 1
4444 rajveer 12825 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
12826 
    (3, TType.I64, 'status', None, None, ), # 3
12827 
    (4, TType.I64, 'timestamp', None, None, ), # 4
94 ashish 12828 
  )
12829 
 
4444 rajveer 12830 
  def __init__(self, type=None, warehouseId=None, status=None, timestamp=None,):
4394 rajveer 12831 
    self.type = type
4444 rajveer 12832 
    self.warehouseId = warehouseId
4394 rajveer 12833 
    self.status = status
12834 
    self.timestamp = timestamp
94 ashish 12835 
 
12836 
  def read(self, iprot):
12837 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12838 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12839 
      return
12840 
    iprot.readStructBegin()
12841 
    while True:
12842 
      (fname, ftype, fid) = iprot.readFieldBegin()
12843 
      if ftype == TType.STOP:
12844 
        break
12845 
      if fid == 1:
3064 chandransh 12846 
        if ftype == TType.I64:
4394 rajveer 12847 
          self.type = iprot.readI64();
94 ashish 12848 
        else:
12849 
          iprot.skip(ftype)
3064 chandransh 12850 
      elif fid == 2:
4394 rajveer 12851 
        if ftype == TType.I64:
4444 rajveer 12852 
          self.warehouseId = iprot.readI64();
3064 chandransh 12853 
        else:
12854 
          iprot.skip(ftype)
4394 rajveer 12855 
      elif fid == 3:
12856 
        if ftype == TType.I64:
4444 rajveer 12857 
          self.status = iprot.readI64();
12858 
        else:
12859 
          iprot.skip(ftype)
12860 
      elif fid == 4:
12861 
        if ftype == TType.I64:
4394 rajveer 12862 
          self.timestamp = iprot.readI64();
12863 
        else:
12864 
          iprot.skip(ftype)
94 ashish 12865 
      else:
12866 
        iprot.skip(ftype)
12867 
      iprot.readFieldEnd()
12868 
    iprot.readStructEnd()
12869 
 
12870 
  def write(self, oprot):
12871 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12872 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12873 
      return
3064 chandransh 12874 
    oprot.writeStructBegin('getAlerts_args')
4394 rajveer 12875 
    if self.type is not None:
12876 
      oprot.writeFieldBegin('type', TType.I64, 1)
12877 
      oprot.writeI64(self.type)
94 ashish 12878 
      oprot.writeFieldEnd()
4444 rajveer 12879 
    if self.warehouseId is not None:
12880 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
12881 
      oprot.writeI64(self.warehouseId)
12882 
      oprot.writeFieldEnd()
4394 rajveer 12883 
    if self.status is not None:
4444 rajveer 12884 
      oprot.writeFieldBegin('status', TType.I64, 3)
4394 rajveer 12885 
      oprot.writeI64(self.status)
3064 chandransh 12886 
      oprot.writeFieldEnd()
4394 rajveer 12887 
    if self.timestamp is not None:
4444 rajveer 12888 
      oprot.writeFieldBegin('timestamp', TType.I64, 4)
4394 rajveer 12889 
      oprot.writeI64(self.timestamp)
12890 
      oprot.writeFieldEnd()
94 ashish 12891 
    oprot.writeFieldStop()
12892 
    oprot.writeStructEnd()
12893 
 
3431 rajveer 12894 
  def validate(self):
12895 
    return
12896 
 
12897 
 
94 ashish 12898 
  def __repr__(self):
12899 
    L = ['%s=%r' % (key, value)
12900 
      for key, value in self.__dict__.iteritems()]
12901 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12902 
 
12903 
  def __eq__(self, other):
12904 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12905 
 
12906 
  def __ne__(self, other):
12907 
    return not (self == other)
12908 
 
3064 chandransh 12909 
class getAlerts_result:
94 ashish 12910 
  """
12911 
  Attributes:
12912 
   - success
12913 
  """
12914 
 
12915 
  thrift_spec = (
3064 chandransh 12916 
    (0, TType.LIST, 'success', (TType.STRUCT,(Alert, Alert.thrift_spec)), None, ), # 0
94 ashish 12917 
  )
12918 
 
3064 chandransh 12919 
  def __init__(self, success=None,):
94 ashish 12920 
    self.success = success
12921 
 
12922 
  def read(self, iprot):
12923 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12924 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12925 
      return
12926 
    iprot.readStructBegin()
12927 
    while True:
12928 
      (fname, ftype, fid) = iprot.readFieldBegin()
12929 
      if ftype == TType.STOP:
12930 
        break
12931 
      if fid == 0:
3064 chandransh 12932 
        if ftype == TType.LIST:
12933 
          self.success = []
6188 rajveer 12934 
          (_etype242, _size239) = iprot.readListBegin()
12935 
          for _i243 in xrange(_size239):
12936 
            _elem244 = Alert()
12937 
            _elem244.read(iprot)
12938 
            self.success.append(_elem244)
3064 chandransh 12939 
          iprot.readListEnd()
94 ashish 12940 
        else:
12941 
          iprot.skip(ftype)
12942 
      else:
12943 
        iprot.skip(ftype)
12944 
      iprot.readFieldEnd()
12945 
    iprot.readStructEnd()
12946 
 
12947 
  def write(self, oprot):
12948 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12949 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12950 
      return
3064 chandransh 12951 
    oprot.writeStructBegin('getAlerts_result')
3431 rajveer 12952 
    if self.success is not None:
3064 chandransh 12953 
      oprot.writeFieldBegin('success', TType.LIST, 0)
12954 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 12955 
      for iter245 in self.success:
12956 
        iter245.write(oprot)
3064 chandransh 12957 
      oprot.writeListEnd()
94 ashish 12958 
      oprot.writeFieldEnd()
12959 
    oprot.writeFieldStop()
12960 
    oprot.writeStructEnd()
12961 
 
3431 rajveer 12962 
  def validate(self):
12963 
    return
12964 
 
12965 
 
94 ashish 12966 
  def __repr__(self):
12967 
    L = ['%s=%r' % (key, value)
12968 
      for key, value in self.__dict__.iteritems()]
12969 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12970 
 
12971 
  def __eq__(self, other):
12972 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12973 
 
12974 
  def __ne__(self, other):
12975 
    return not (self == other)
12976 
 
4394 rajveer 12977 
class addAlert_args:
94 ashish 12978 
  """
12979 
  Attributes:
3064 chandransh 12980 
   - type
4444 rajveer 12981 
   - warehouseId
4394 rajveer 12982 
   - description
94 ashish 12983 
  """
12984 
 
12985 
  thrift_spec = (
12986 
    None, # 0
4394 rajveer 12987 
    (1, TType.I64, 'type', None, None, ), # 1
4444 rajveer 12988 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
12989 
    (3, TType.STRING, 'description', None, None, ), # 3
94 ashish 12990 
  )
12991 
 
4444 rajveer 12992 
  def __init__(self, type=None, warehouseId=None, description=None,):
3064 chandransh 12993 
    self.type = type
4444 rajveer 12994 
    self.warehouseId = warehouseId
4394 rajveer 12995 
    self.description = description
94 ashish 12996 
 
12997 
  def read(self, iprot):
12998 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12999 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13000 
      return
13001 
    iprot.readStructBegin()
13002 
    while True:
13003 
      (fname, ftype, fid) = iprot.readFieldBegin()
13004 
      if ftype == TType.STOP:
13005 
        break
13006 
      if fid == 1:
13007 
        if ftype == TType.I64:
4394 rajveer 13008 
          self.type = iprot.readI64();
94 ashish 13009 
        else:
13010 
          iprot.skip(ftype)
3064 chandransh 13011 
      elif fid == 2:
4444 rajveer 13012 
        if ftype == TType.I64:
13013 
          self.warehouseId = iprot.readI64();
13014 
        else:
13015 
          iprot.skip(ftype)
13016 
      elif fid == 3:
3064 chandransh 13017 
        if ftype == TType.STRING:
4394 rajveer 13018 
          self.description = iprot.readString();
3064 chandransh 13019 
        else:
13020 
          iprot.skip(ftype)
94 ashish 13021 
      else:
13022 
        iprot.skip(ftype)
13023 
      iprot.readFieldEnd()
13024 
    iprot.readStructEnd()
13025 
 
13026 
  def write(self, oprot):
13027 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13028 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13029 
      return
4394 rajveer 13030 
    oprot.writeStructBegin('addAlert_args')
3431 rajveer 13031 
    if self.type is not None:
4394 rajveer 13032 
      oprot.writeFieldBegin('type', TType.I64, 1)
3064 chandransh 13033 
      oprot.writeI64(self.type)
13034 
      oprot.writeFieldEnd()
4444 rajveer 13035 
    if self.warehouseId is not None:
13036 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
13037 
      oprot.writeI64(self.warehouseId)
13038 
      oprot.writeFieldEnd()
4394 rajveer 13039 
    if self.description is not None:
4444 rajveer 13040 
      oprot.writeFieldBegin('description', TType.STRING, 3)
4394 rajveer 13041 
      oprot.writeString(self.description)
3064 chandransh 13042 
      oprot.writeFieldEnd()
94 ashish 13043 
    oprot.writeFieldStop()
13044 
    oprot.writeStructEnd()
13045 
 
3431 rajveer 13046 
  def validate(self):
13047 
    return
13048 
 
13049 
 
94 ashish 13050 
  def __repr__(self):
13051 
    L = ['%s=%r' % (key, value)
13052 
      for key, value in self.__dict__.iteritems()]
13053 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13054 
 
13055 
  def __eq__(self, other):
13056 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13057 
 
13058 
  def __ne__(self, other):
13059 
    return not (self == other)
13060 
 
4394 rajveer 13061 
class addAlert_result:
3064 chandransh 13062 
 
13063 
  thrift_spec = (
13064 
  )
13065 
 
13066 
  def read(self, iprot):
13067 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13068 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13069 
      return
13070 
    iprot.readStructBegin()
13071 
    while True:
13072 
      (fname, ftype, fid) = iprot.readFieldBegin()
13073 
      if ftype == TType.STOP:
13074 
        break
13075 
      else:
13076 
        iprot.skip(ftype)
13077 
      iprot.readFieldEnd()
13078 
    iprot.readStructEnd()
13079 
 
13080 
  def write(self, oprot):
13081 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13082 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13083 
      return
4394 rajveer 13084 
    oprot.writeStructBegin('addAlert_result')
3064 chandransh 13085 
    oprot.writeFieldStop()
13086 
    oprot.writeStructEnd()
13087 
 
3431 rajveer 13088 
  def validate(self):
13089 
    return
13090 
 
13091 
 
3064 chandransh 13092 
  def __repr__(self):
13093 
    L = ['%s=%r' % (key, value)
13094 
      for key, value in self.__dict__.iteritems()]
13095 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13096 
 
13097 
  def __eq__(self, other):
13098 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13099 
 
13100 
  def __ne__(self, other):
13101 
    return not (self == other)
13102 
 
4444 rajveer 13103 
class markAlertsAsSeen_args:
13104 
  """
13105 
  Attributes:
13106 
   - warehouseId
13107 
  """
13108 
 
13109 
  thrift_spec = (
13110 
    None, # 0
13111 
    (1, TType.I64, 'warehouseId', None, None, ), # 1
13112 
  )
13113 
 
13114 
  def __init__(self, warehouseId=None,):
13115 
    self.warehouseId = warehouseId
13116 
 
13117 
  def read(self, iprot):
13118 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13119 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13120 
      return
13121 
    iprot.readStructBegin()
13122 
    while True:
13123 
      (fname, ftype, fid) = iprot.readFieldBegin()
13124 
      if ftype == TType.STOP:
13125 
        break
13126 
      if fid == 1:
13127 
        if ftype == TType.I64:
13128 
          self.warehouseId = iprot.readI64();
13129 
        else:
13130 
          iprot.skip(ftype)
13131 
      else:
13132 
        iprot.skip(ftype)
13133 
      iprot.readFieldEnd()
13134 
    iprot.readStructEnd()
13135 
 
13136 
  def write(self, oprot):
13137 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13138 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13139 
      return
13140 
    oprot.writeStructBegin('markAlertsAsSeen_args')
13141 
    if self.warehouseId is not None:
13142 
      oprot.writeFieldBegin('warehouseId', TType.I64, 1)
13143 
      oprot.writeI64(self.warehouseId)
13144 
      oprot.writeFieldEnd()
13145 
    oprot.writeFieldStop()
13146 
    oprot.writeStructEnd()
13147 
 
13148 
  def validate(self):
13149 
    return
13150 
 
13151 
 
13152 
  def __repr__(self):
13153 
    L = ['%s=%r' % (key, value)
13154 
      for key, value in self.__dict__.iteritems()]
13155 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13156 
 
13157 
  def __eq__(self, other):
13158 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13159 
 
13160 
  def __ne__(self, other):
13161 
    return not (self == other)
13162 
 
13163 
class markAlertsAsSeen_result:
13164 
 
13165 
  thrift_spec = (
13166 
  )
13167 
 
13168 
  def read(self, iprot):
13169 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13170 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13171 
      return
13172 
    iprot.readStructBegin()
13173 
    while True:
13174 
      (fname, ftype, fid) = iprot.readFieldBegin()
13175 
      if ftype == TType.STOP:
13176 
        break
13177 
      else:
13178 
        iprot.skip(ftype)
13179 
      iprot.readFieldEnd()
13180 
    iprot.readStructEnd()
13181 
 
13182 
  def write(self, oprot):
13183 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13184 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13185 
      return
13186 
    oprot.writeStructBegin('markAlertsAsSeen_result')
13187 
    oprot.writeFieldStop()
13188 
    oprot.writeStructEnd()
13189 
 
13190 
  def validate(self):
13191 
    return
13192 
 
13193 
 
13194 
  def __repr__(self):
13195 
    L = ['%s=%r' % (key, value)
13196 
      for key, value in self.__dict__.iteritems()]
13197 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13198 
 
13199 
  def __eq__(self, other):
13200 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13201 
 
13202 
  def __ne__(self, other):
13203 
    return not (self == other)
13204 
 
3064 chandransh 13205 
class getValidOrderCount_args:
13206 
 
13207 
  thrift_spec = (
13208 
  )
13209 
 
13210 
  def read(self, iprot):
13211 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13212 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13213 
      return
13214 
    iprot.readStructBegin()
13215 
    while True:
13216 
      (fname, ftype, fid) = iprot.readFieldBegin()
13217 
      if ftype == TType.STOP:
13218 
        break
13219 
      else:
13220 
        iprot.skip(ftype)
13221 
      iprot.readFieldEnd()
13222 
    iprot.readStructEnd()
13223 
 
13224 
  def write(self, oprot):
13225 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13226 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13227 
      return
13228 
    oprot.writeStructBegin('getValidOrderCount_args')
13229 
    oprot.writeFieldStop()
13230 
    oprot.writeStructEnd()
13231 
 
3431 rajveer 13232 
  def validate(self):
13233 
    return
13234 
 
13235 
 
3064 chandransh 13236 
  def __repr__(self):
13237 
    L = ['%s=%r' % (key, value)
13238 
      for key, value in self.__dict__.iteritems()]
13239 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13240 
 
13241 
  def __eq__(self, other):
13242 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13243 
 
13244 
  def __ne__(self, other):
13245 
    return not (self == other)
13246 
 
13247 
class getValidOrderCount_result:
94 ashish 13248 
  """
13249 
  Attributes:
13250 
   - success
13251 
  """
13252 
 
13253 
  thrift_spec = (
3064 chandransh 13254 
    (0, TType.I64, 'success', None, None, ), # 0
94 ashish 13255 
  )
13256 
 
3064 chandransh 13257 
  def __init__(self, success=None,):
94 ashish 13258 
    self.success = success
13259 
 
13260 
  def read(self, iprot):
13261 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13262 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13263 
      return
13264 
    iprot.readStructBegin()
13265 
    while True:
13266 
      (fname, ftype, fid) = iprot.readFieldBegin()
13267 
      if ftype == TType.STOP:
13268 
        break
13269 
      if fid == 0:
3064 chandransh 13270 
        if ftype == TType.I64:
13271 
          self.success = iprot.readI64();
94 ashish 13272 
        else:
13273 
          iprot.skip(ftype)
13274 
      else:
13275 
        iprot.skip(ftype)
13276 
      iprot.readFieldEnd()
13277 
    iprot.readStructEnd()
13278 
 
13279 
  def write(self, oprot):
13280 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13281 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13282 
      return
3064 chandransh 13283 
    oprot.writeStructBegin('getValidOrderCount_result')
3431 rajveer 13284 
    if self.success is not None:
3064 chandransh 13285 
      oprot.writeFieldBegin('success', TType.I64, 0)
13286 
      oprot.writeI64(self.success)
94 ashish 13287 
      oprot.writeFieldEnd()
13288 
    oprot.writeFieldStop()
13289 
    oprot.writeStructEnd()
13290 
 
3431 rajveer 13291 
  def validate(self):
13292 
    return
13293 
 
13294 
 
94 ashish 13295 
  def __repr__(self):
13296 
    L = ['%s=%r' % (key, value)
13297 
      for key, value in self.__dict__.iteritems()]
13298 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13299 
 
13300 
  def __eq__(self, other):
13301 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13302 
 
13303 
  def __ne__(self, other):
13304 
    return not (self == other)
13305 
 
3064 chandransh 13306 
class getNoOfCustomersWithSuccessfulTransaction_args:
13307 
 
13308 
  thrift_spec = (
13309 
  )
13310 
 
13311 
  def read(self, iprot):
13312 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13313 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13314 
      return
13315 
    iprot.readStructBegin()
13316 
    while True:
13317 
      (fname, ftype, fid) = iprot.readFieldBegin()
13318 
      if ftype == TType.STOP:
13319 
        break
13320 
      else:
13321 
        iprot.skip(ftype)
13322 
      iprot.readFieldEnd()
13323 
    iprot.readStructEnd()
13324 
 
13325 
  def write(self, oprot):
13326 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13327 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13328 
      return
13329 
    oprot.writeStructBegin('getNoOfCustomersWithSuccessfulTransaction_args')
13330 
    oprot.writeFieldStop()
13331 
    oprot.writeStructEnd()
13332 
 
3431 rajveer 13333 
  def validate(self):
13334 
    return
13335 
 
13336 
 
3064 chandransh 13337 
  def __repr__(self):
13338 
    L = ['%s=%r' % (key, value)
13339 
      for key, value in self.__dict__.iteritems()]
13340 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13341 
 
13342 
  def __eq__(self, other):
13343 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13344 
 
13345 
  def __ne__(self, other):
13346 
    return not (self == other)
13347 
 
13348 
class getNoOfCustomersWithSuccessfulTransaction_result:
94 ashish 13349 
  """
13350 
  Attributes:
3064 chandransh 13351 
   - success
94 ashish 13352 
  """
13353 
 
13354 
  thrift_spec = (
3064 chandransh 13355 
    (0, TType.I64, 'success', None, None, ), # 0
94 ashish 13356 
  )
13357 
 
3064 chandransh 13358 
  def __init__(self, success=None,):
13359 
    self.success = success
94 ashish 13360 
 
13361 
  def read(self, iprot):
13362 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13363 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13364 
      return
13365 
    iprot.readStructBegin()
13366 
    while True:
13367 
      (fname, ftype, fid) = iprot.readFieldBegin()
13368 
      if ftype == TType.STOP:
13369 
        break
3064 chandransh 13370 
      if fid == 0:
94 ashish 13371 
        if ftype == TType.I64:
3064 chandransh 13372 
          self.success = iprot.readI64();
94 ashish 13373 
        else:
13374 
          iprot.skip(ftype)
13375 
      else:
13376 
        iprot.skip(ftype)
13377 
      iprot.readFieldEnd()
13378 
    iprot.readStructEnd()
13379 
 
13380 
  def write(self, oprot):
13381 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13382 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13383 
      return
3064 chandransh 13384 
    oprot.writeStructBegin('getNoOfCustomersWithSuccessfulTransaction_result')
3431 rajveer 13385 
    if self.success is not None:
3064 chandransh 13386 
      oprot.writeFieldBegin('success', TType.I64, 0)
13387 
      oprot.writeI64(self.success)
94 ashish 13388 
      oprot.writeFieldEnd()
13389 
    oprot.writeFieldStop()
13390 
    oprot.writeStructEnd()
13391 
 
3431 rajveer 13392 
  def validate(self):
13393 
    return
13394 
 
13395 
 
94 ashish 13396 
  def __repr__(self):
13397 
    L = ['%s=%r' % (key, value)
13398 
      for key, value in self.__dict__.iteritems()]
13399 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13400 
 
13401 
  def __eq__(self, other):
13402 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13403 
 
13404 
  def __ne__(self, other):
13405 
    return not (self == other)
13406 
 
3064 chandransh 13407 
class getValidOrdersAmountRange_args:
13408 
 
13409 
  thrift_spec = (
13410 
  )
13411 
 
13412 
  def read(self, iprot):
13413 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13414 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13415 
      return
13416 
    iprot.readStructBegin()
13417 
    while True:
13418 
      (fname, ftype, fid) = iprot.readFieldBegin()
13419 
      if ftype == TType.STOP:
13420 
        break
13421 
      else:
13422 
        iprot.skip(ftype)
13423 
      iprot.readFieldEnd()
13424 
    iprot.readStructEnd()
13425 
 
13426 
  def write(self, oprot):
13427 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13428 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13429 
      return
13430 
    oprot.writeStructBegin('getValidOrdersAmountRange_args')
13431 
    oprot.writeFieldStop()
13432 
    oprot.writeStructEnd()
13433 
 
3431 rajveer 13434 
  def validate(self):
13435 
    return
13436 
 
13437 
 
3064 chandransh 13438 
  def __repr__(self):
13439 
    L = ['%s=%r' % (key, value)
13440 
      for key, value in self.__dict__.iteritems()]
13441 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13442 
 
13443 
  def __eq__(self, other):
13444 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13445 
 
13446 
  def __ne__(self, other):
13447 
    return not (self == other)
13448 
 
13449 
class getValidOrdersAmountRange_result:
94 ashish 13450 
  """
13451 
  Attributes:
13452 
   - success
13453 
  """
13454 
 
13455 
  thrift_spec = (
3064 chandransh 13456 
    (0, TType.LIST, 'success', (TType.DOUBLE,None), None, ), # 0
94 ashish 13457 
  )
13458 
 
3064 chandransh 13459 
  def __init__(self, success=None,):
94 ashish 13460 
    self.success = success
13461 
 
13462 
  def read(self, iprot):
13463 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13464 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13465 
      return
13466 
    iprot.readStructBegin()
13467 
    while True:
13468 
      (fname, ftype, fid) = iprot.readFieldBegin()
13469 
      if ftype == TType.STOP:
13470 
        break
13471 
      if fid == 0:
483 rajveer 13472 
        if ftype == TType.LIST:
13473 
          self.success = []
6188 rajveer 13474 
          (_etype249, _size246) = iprot.readListBegin()
13475 
          for _i250 in xrange(_size246):
13476 
            _elem251 = iprot.readDouble();
13477 
            self.success.append(_elem251)
483 rajveer 13478 
          iprot.readListEnd()
94 ashish 13479 
        else:
13480 
          iprot.skip(ftype)
13481 
      else:
13482 
        iprot.skip(ftype)
13483 
      iprot.readFieldEnd()
13484 
    iprot.readStructEnd()
13485 
 
13486 
  def write(self, oprot):
13487 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13488 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13489 
      return
3064 chandransh 13490 
    oprot.writeStructBegin('getValidOrdersAmountRange_result')
3431 rajveer 13491 
    if self.success is not None:
483 rajveer 13492 
      oprot.writeFieldBegin('success', TType.LIST, 0)
3064 chandransh 13493 
      oprot.writeListBegin(TType.DOUBLE, len(self.success))
6188 rajveer 13494 
      for iter252 in self.success:
13495 
        oprot.writeDouble(iter252)
483 rajveer 13496 
      oprot.writeListEnd()
94 ashish 13497 
      oprot.writeFieldEnd()
13498 
    oprot.writeFieldStop()
13499 
    oprot.writeStructEnd()
13500 
 
3431 rajveer 13501 
  def validate(self):
13502 
    return
13503 
 
13504 
 
94 ashish 13505 
  def __repr__(self):
13506 
    L = ['%s=%r' % (key, value)
13507 
      for key, value in self.__dict__.iteritems()]
13508 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13509 
 
13510 
  def __eq__(self, other):
13511 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13512 
 
13513 
  def __ne__(self, other):
13514 
    return not (self == other)
13515 
 
3064 chandransh 13516 
class getValidOrders_args:
1528 ankur.sing 13517 
  """
13518 
  Attributes:
3064 chandransh 13519 
   - limit
5874 rajveer 13520 
   - onlyStore
1528 ankur.sing 13521 
  """
13522 
 
13523 
  thrift_spec = (
13524 
    None, # 0
3064 chandransh 13525 
    (1, TType.I64, 'limit', None, None, ), # 1
5874 rajveer 13526 
    (2, TType.BOOL, 'onlyStore', None, None, ), # 2
1528 ankur.sing 13527 
  )
13528 
 
5874 rajveer 13529 
  def __init__(self, limit=None, onlyStore=None,):
3064 chandransh 13530 
    self.limit = limit
5874 rajveer 13531 
    self.onlyStore = onlyStore
1528 ankur.sing 13532 
 
13533 
  def read(self, iprot):
13534 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13535 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13536 
      return
13537 
    iprot.readStructBegin()
13538 
    while True:
13539 
      (fname, ftype, fid) = iprot.readFieldBegin()
13540 
      if ftype == TType.STOP:
13541 
        break
13542 
      if fid == 1:
13543 
        if ftype == TType.I64:
3064 chandransh 13544 
          self.limit = iprot.readI64();
1528 ankur.sing 13545 
        else:
13546 
          iprot.skip(ftype)
5874 rajveer 13547 
      elif fid == 2:
13548 
        if ftype == TType.BOOL:
13549 
          self.onlyStore = iprot.readBool();
13550 
        else:
13551 
          iprot.skip(ftype)
1528 ankur.sing 13552 
      else:
13553 
        iprot.skip(ftype)
13554 
      iprot.readFieldEnd()
13555 
    iprot.readStructEnd()
13556 
 
13557 
  def write(self, oprot):
13558 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13559 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13560 
      return
3064 chandransh 13561 
    oprot.writeStructBegin('getValidOrders_args')
3431 rajveer 13562 
    if self.limit is not None:
3064 chandransh 13563 
      oprot.writeFieldBegin('limit', TType.I64, 1)
13564 
      oprot.writeI64(self.limit)
1528 ankur.sing 13565 
      oprot.writeFieldEnd()
5874 rajveer 13566 
    if self.onlyStore is not None:
13567 
      oprot.writeFieldBegin('onlyStore', TType.BOOL, 2)
13568 
      oprot.writeBool(self.onlyStore)
13569 
      oprot.writeFieldEnd()
1528 ankur.sing 13570 
    oprot.writeFieldStop()
13571 
    oprot.writeStructEnd()
13572 
 
3431 rajveer 13573 
  def validate(self):
13574 
    return
13575 
 
13576 
 
1528 ankur.sing 13577 
  def __repr__(self):
13578 
    L = ['%s=%r' % (key, value)
13579 
      for key, value in self.__dict__.iteritems()]
13580 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13581 
 
13582 
  def __eq__(self, other):
13583 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13584 
 
13585 
  def __ne__(self, other):
13586 
    return not (self == other)
13587 
 
3064 chandransh 13588 
class getValidOrders_result:
1528 ankur.sing 13589 
  """
13590 
  Attributes:
13591 
   - success
13592 
  """
13593 
 
13594 
  thrift_spec = (
3064 chandransh 13595 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
1528 ankur.sing 13596 
  )
13597 
 
3064 chandransh 13598 
  def __init__(self, success=None,):
1528 ankur.sing 13599 
    self.success = success
13600 
 
13601 
  def read(self, iprot):
13602 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13603 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13604 
      return
13605 
    iprot.readStructBegin()
13606 
    while True:
13607 
      (fname, ftype, fid) = iprot.readFieldBegin()
13608 
      if ftype == TType.STOP:
13609 
        break
13610 
      if fid == 0:
3064 chandransh 13611 
        if ftype == TType.LIST:
13612 
          self.success = []
6188 rajveer 13613 
          (_etype256, _size253) = iprot.readListBegin()
13614 
          for _i257 in xrange(_size253):
13615 
            _elem258 = Order()
13616 
            _elem258.read(iprot)
13617 
            self.success.append(_elem258)
3064 chandransh 13618 
          iprot.readListEnd()
1528 ankur.sing 13619 
        else:
13620 
          iprot.skip(ftype)
13621 
      else:
13622 
        iprot.skip(ftype)
13623 
      iprot.readFieldEnd()
13624 
    iprot.readStructEnd()
13625 
 
13626 
  def write(self, oprot):
13627 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13628 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13629 
      return
3064 chandransh 13630 
    oprot.writeStructBegin('getValidOrders_result')
3431 rajveer 13631 
    if self.success is not None:
3064 chandransh 13632 
      oprot.writeFieldBegin('success', TType.LIST, 0)
13633 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 13634 
      for iter259 in self.success:
13635 
        iter259.write(oprot)
3064 chandransh 13636 
      oprot.writeListEnd()
1528 ankur.sing 13637 
      oprot.writeFieldEnd()
13638 
    oprot.writeFieldStop()
13639 
    oprot.writeStructEnd()
13640 
 
3431 rajveer 13641 
  def validate(self):
13642 
    return
13643 
 
13644 
 
1528 ankur.sing 13645 
  def __repr__(self):
13646 
    L = ['%s=%r' % (key, value)
13647 
      for key, value in self.__dict__.iteritems()]
13648 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13649 
 
13650 
  def __eq__(self, other):
13651 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13652 
 
13653 
  def __ne__(self, other):
13654 
    return not (self == other)
13655 
 
1220 chandransh 13656 
class batchOrders_args:
13657 
  """
13658 
  Attributes:
13659 
   - warehouseId
13660 
  """
13661 
 
13662 
  thrift_spec = (
13663 
    None, # 0
13664 
    (1, TType.I64, 'warehouseId', None, None, ), # 1
13665 
  )
13666 
 
13667 
  def __init__(self, warehouseId=None,):
13668 
    self.warehouseId = warehouseId
13669 
 
13670 
  def read(self, iprot):
13671 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13672 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13673 
      return
13674 
    iprot.readStructBegin()
13675 
    while True:
13676 
      (fname, ftype, fid) = iprot.readFieldBegin()
13677 
      if ftype == TType.STOP:
13678 
        break
13679 
      if fid == 1:
13680 
        if ftype == TType.I64:
13681 
          self.warehouseId = iprot.readI64();
13682 
        else:
13683 
          iprot.skip(ftype)
13684 
      else:
13685 
        iprot.skip(ftype)
13686 
      iprot.readFieldEnd()
13687 
    iprot.readStructEnd()
13688 
 
13689 
  def write(self, oprot):
13690 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13691 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13692 
      return
13693 
    oprot.writeStructBegin('batchOrders_args')
3431 rajveer 13694 
    if self.warehouseId is not None:
1220 chandransh 13695 
      oprot.writeFieldBegin('warehouseId', TType.I64, 1)
13696 
      oprot.writeI64(self.warehouseId)
13697 
      oprot.writeFieldEnd()
13698 
    oprot.writeFieldStop()
13699 
    oprot.writeStructEnd()
13700 
 
3431 rajveer 13701 
  def validate(self):
13702 
    return
13703 
 
13704 
 
1220 chandransh 13705 
  def __repr__(self):
13706 
    L = ['%s=%r' % (key, value)
13707 
      for key, value in self.__dict__.iteritems()]
13708 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13709 
 
13710 
  def __eq__(self, other):
13711 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13712 
 
13713 
  def __ne__(self, other):
13714 
    return not (self == other)
13715 
 
13716 
class batchOrders_result:
13717 
  """
13718 
  Attributes:
13719 
   - success
13720 
   - ex
13721 
  """
13722 
 
13723 
  thrift_spec = (
13724 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
13725 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
13726 
  )
13727 
 
13728 
  def __init__(self, success=None, ex=None,):
13729 
    self.success = success
13730 
    self.ex = ex
13731 
 
13732 
  def read(self, iprot):
13733 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13734 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13735 
      return
13736 
    iprot.readStructBegin()
13737 
    while True:
13738 
      (fname, ftype, fid) = iprot.readFieldBegin()
13739 
      if ftype == TType.STOP:
13740 
        break
13741 
      if fid == 0:
13742 
        if ftype == TType.LIST:
13743 
          self.success = []
6188 rajveer 13744 
          (_etype263, _size260) = iprot.readListBegin()
13745 
          for _i264 in xrange(_size260):
13746 
            _elem265 = Order()
13747 
            _elem265.read(iprot)
13748 
            self.success.append(_elem265)
1220 chandransh 13749 
          iprot.readListEnd()
13750 
        else:
13751 
          iprot.skip(ftype)
13752 
      elif fid == 1:
13753 
        if ftype == TType.STRUCT:
13754 
          self.ex = TransactionServiceException()
13755 
          self.ex.read(iprot)
13756 
        else:
13757 
          iprot.skip(ftype)
13758 
      else:
13759 
        iprot.skip(ftype)
13760 
      iprot.readFieldEnd()
13761 
    iprot.readStructEnd()
13762 
 
13763 
  def write(self, oprot):
13764 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13765 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13766 
      return
13767 
    oprot.writeStructBegin('batchOrders_result')
3431 rajveer 13768 
    if self.success is not None:
1220 chandransh 13769 
      oprot.writeFieldBegin('success', TType.LIST, 0)
13770 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 13771 
      for iter266 in self.success:
13772 
        iter266.write(oprot)
1220 chandransh 13773 
      oprot.writeListEnd()
13774 
      oprot.writeFieldEnd()
3431 rajveer 13775 
    if self.ex is not None:
1220 chandransh 13776 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
13777 
      self.ex.write(oprot)
13778 
      oprot.writeFieldEnd()
13779 
    oprot.writeFieldStop()
13780 
    oprot.writeStructEnd()
13781 
 
3431 rajveer 13782 
  def validate(self):
13783 
    return
13784 
 
13785 
 
1220 chandransh 13786 
  def __repr__(self):
13787 
    L = ['%s=%r' % (key, value)
13788 
      for key, value in self.__dict__.iteritems()]
13789 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13790 
 
13791 
  def __eq__(self, other):
13792 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13793 
 
13794 
  def __ne__(self, other):
13795 
    return not (self == other)
13796 
 
1208 chandransh 13797 
class markOrderAsOutOfStock_args:
13798 
  """
13799 
  Attributes:
13800 
   - orderId
13801 
  """
13802 
 
13803 
  thrift_spec = (
13804 
    None, # 0
13805 
    (1, TType.I64, 'orderId', None, None, ), # 1
13806 
  )
13807 
 
13808 
  def __init__(self, orderId=None,):
13809 
    self.orderId = orderId
13810 
 
13811 
  def read(self, iprot):
13812 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13813 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13814 
      return
13815 
    iprot.readStructBegin()
13816 
    while True:
13817 
      (fname, ftype, fid) = iprot.readFieldBegin()
13818 
      if ftype == TType.STOP:
13819 
        break
13820 
      if fid == 1:
13821 
        if ftype == TType.I64:
13822 
          self.orderId = iprot.readI64();
13823 
        else:
13824 
          iprot.skip(ftype)
13825 
      else:
13826 
        iprot.skip(ftype)
13827 
      iprot.readFieldEnd()
13828 
    iprot.readStructEnd()
13829 
 
13830 
  def write(self, oprot):
13831 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13832 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13833 
      return
13834 
    oprot.writeStructBegin('markOrderAsOutOfStock_args')
3431 rajveer 13835 
    if self.orderId is not None:
1208 chandransh 13836 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
13837 
      oprot.writeI64(self.orderId)
13838 
      oprot.writeFieldEnd()
13839 
    oprot.writeFieldStop()
13840 
    oprot.writeStructEnd()
13841 
 
3431 rajveer 13842 
  def validate(self):
13843 
    return
13844 
 
13845 
 
1208 chandransh 13846 
  def __repr__(self):
13847 
    L = ['%s=%r' % (key, value)
13848 
      for key, value in self.__dict__.iteritems()]
13849 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13850 
 
13851 
  def __eq__(self, other):
13852 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13853 
 
13854 
  def __ne__(self, other):
13855 
    return not (self == other)
13856 
 
13857 
class markOrderAsOutOfStock_result:
13858 
  """
13859 
  Attributes:
13860 
   - success
13861 
   - ex
13862 
  """
13863 
 
13864 
  thrift_spec = (
13865 
    (0, TType.BOOL, 'success', None, None, ), # 0
13866 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
13867 
  )
13868 
 
13869 
  def __init__(self, success=None, ex=None,):
13870 
    self.success = success
13871 
    self.ex = ex
13872 
 
13873 
  def read(self, iprot):
13874 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13875 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13876 
      return
13877 
    iprot.readStructBegin()
13878 
    while True:
13879 
      (fname, ftype, fid) = iprot.readFieldBegin()
13880 
      if ftype == TType.STOP:
13881 
        break
13882 
      if fid == 0:
13883 
        if ftype == TType.BOOL:
13884 
          self.success = iprot.readBool();
13885 
        else:
13886 
          iprot.skip(ftype)
13887 
      elif fid == 1:
13888 
        if ftype == TType.STRUCT:
13889 
          self.ex = TransactionServiceException()
13890 
          self.ex.read(iprot)
13891 
        else:
13892 
          iprot.skip(ftype)
13893 
      else:
13894 
        iprot.skip(ftype)
13895 
      iprot.readFieldEnd()
13896 
    iprot.readStructEnd()
13897 
 
13898 
  def write(self, oprot):
13899 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13900 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13901 
      return
13902 
    oprot.writeStructBegin('markOrderAsOutOfStock_result')
3431 rajveer 13903 
    if self.success is not None:
1208 chandransh 13904 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
13905 
      oprot.writeBool(self.success)
13906 
      oprot.writeFieldEnd()
3431 rajveer 13907 
    if self.ex is not None:
1208 chandransh 13908 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
13909 
      self.ex.write(oprot)
13910 
      oprot.writeFieldEnd()
13911 
    oprot.writeFieldStop()
13912 
    oprot.writeStructEnd()
13913 
 
3431 rajveer 13914 
  def validate(self):
13915 
    return
13916 
 
13917 
 
1208 chandransh 13918 
  def __repr__(self):
13919 
    L = ['%s=%r' % (key, value)
13920 
      for key, value in self.__dict__.iteritems()]
13921 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13922 
 
13923 
  def __eq__(self, other):
13924 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13925 
 
13926 
  def __ne__(self, other):
13927 
    return not (self == other)
13928 
 
3064 chandransh 13929 
class verifyOrder_args:
759 chandransh 13930 
  """
13931 
  Attributes:
3064 chandransh 13932 
   - orderId
759 chandransh 13933 
  """
13934 
 
13935 
  thrift_spec = (
13936 
    None, # 0
3064 chandransh 13937 
    (1, TType.I64, 'orderId', None, None, ), # 1
759 chandransh 13938 
  )
13939 
 
3064 chandransh 13940 
  def __init__(self, orderId=None,):
13941 
    self.orderId = orderId
759 chandransh 13942 
 
13943 
  def read(self, iprot):
13944 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13945 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13946 
      return
13947 
    iprot.readStructBegin()
13948 
    while True:
13949 
      (fname, ftype, fid) = iprot.readFieldBegin()
13950 
      if ftype == TType.STOP:
13951 
        break
13952 
      if fid == 1:
13953 
        if ftype == TType.I64:
3064 chandransh 13954 
          self.orderId = iprot.readI64();
759 chandransh 13955 
        else:
13956 
          iprot.skip(ftype)
13957 
      else:
13958 
        iprot.skip(ftype)
13959 
      iprot.readFieldEnd()
13960 
    iprot.readStructEnd()
13961 
 
13962 
  def write(self, oprot):
13963 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13964 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13965 
      return
3064 chandransh 13966 
    oprot.writeStructBegin('verifyOrder_args')
3431 rajveer 13967 
    if self.orderId is not None:
3064 chandransh 13968 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
13969 
      oprot.writeI64(self.orderId)
759 chandransh 13970 
      oprot.writeFieldEnd()
13971 
    oprot.writeFieldStop()
13972 
    oprot.writeStructEnd()
13973 
 
3431 rajveer 13974 
  def validate(self):
13975 
    return
13976 
 
13977 
 
759 chandransh 13978 
  def __repr__(self):
13979 
    L = ['%s=%r' % (key, value)
13980 
      for key, value in self.__dict__.iteritems()]
13981 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13982 
 
13983 
  def __eq__(self, other):
13984 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13985 
 
13986 
  def __ne__(self, other):
13987 
    return not (self == other)
13988 
 
3064 chandransh 13989 
class verifyOrder_result:
759 chandransh 13990 
  """
13991 
  Attributes:
13992 
   - success
13993 
   - ex
13994 
  """
13995 
 
13996 
  thrift_spec = (
13997 
    (0, TType.BOOL, 'success', None, None, ), # 0
13998 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
13999 
  )
14000 
 
14001 
  def __init__(self, success=None, ex=None,):
14002 
    self.success = success
14003 
    self.ex = ex
14004 
 
14005 
  def read(self, iprot):
14006 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14007 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14008 
      return
14009 
    iprot.readStructBegin()
14010 
    while True:
14011 
      (fname, ftype, fid) = iprot.readFieldBegin()
14012 
      if ftype == TType.STOP:
14013 
        break
14014 
      if fid == 0:
14015 
        if ftype == TType.BOOL:
14016 
          self.success = iprot.readBool();
14017 
        else:
14018 
          iprot.skip(ftype)
14019 
      elif fid == 1:
14020 
        if ftype == TType.STRUCT:
14021 
          self.ex = TransactionServiceException()
14022 
          self.ex.read(iprot)
14023 
        else:
14024 
          iprot.skip(ftype)
14025 
      else:
14026 
        iprot.skip(ftype)
14027 
      iprot.readFieldEnd()
14028 
    iprot.readStructEnd()
14029 
 
14030 
  def write(self, oprot):
14031 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14032 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14033 
      return
3064 chandransh 14034 
    oprot.writeStructBegin('verifyOrder_result')
3431 rajveer 14035 
    if self.success is not None:
759 chandransh 14036 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
14037 
      oprot.writeBool(self.success)
14038 
      oprot.writeFieldEnd()
3431 rajveer 14039 
    if self.ex is not None:
759 chandransh 14040 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
14041 
      self.ex.write(oprot)
14042 
      oprot.writeFieldEnd()
14043 
    oprot.writeFieldStop()
14044 
    oprot.writeStructEnd()
14045 
 
3431 rajveer 14046 
  def validate(self):
14047 
    return
14048 
 
14049 
 
759 chandransh 14050 
  def __repr__(self):
14051 
    L = ['%s=%r' % (key, value)
14052 
      for key, value in self.__dict__.iteritems()]
14053 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14054 
 
14055 
  def __eq__(self, other):
14056 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14057 
 
14058 
  def __ne__(self, other):
14059 
    return not (self == other)
14060 
 
3064 chandransh 14061 
class acceptOrder_args:
1113 chandransh 14062 
  """
14063 
  Attributes:
3064 chandransh 14064 
   - orderId
1113 chandransh 14065 
  """
14066 
 
14067 
  thrift_spec = (
14068 
    None, # 0
3064 chandransh 14069 
    (1, TType.I64, 'orderId', None, None, ), # 1
1113 chandransh 14070 
  )
14071 
 
3064 chandransh 14072 
  def __init__(self, orderId=None,):
14073 
    self.orderId = orderId
1113 chandransh 14074 
 
14075 
  def read(self, iprot):
14076 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14077 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14078 
      return
14079 
    iprot.readStructBegin()
14080 
    while True:
14081 
      (fname, ftype, fid) = iprot.readFieldBegin()
14082 
      if ftype == TType.STOP:
14083 
        break
14084 
      if fid == 1:
14085 
        if ftype == TType.I64:
3064 chandransh 14086 
          self.orderId = iprot.readI64();
1113 chandransh 14087 
        else:
14088 
          iprot.skip(ftype)
14089 
      else:
14090 
        iprot.skip(ftype)
14091 
      iprot.readFieldEnd()
14092 
    iprot.readStructEnd()
14093 
 
14094 
  def write(self, oprot):
14095 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14096 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14097 
      return
3064 chandransh 14098 
    oprot.writeStructBegin('acceptOrder_args')
3431 rajveer 14099 
    if self.orderId is not None:
3064 chandransh 14100 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
14101 
      oprot.writeI64(self.orderId)
1113 chandransh 14102 
      oprot.writeFieldEnd()
14103 
    oprot.writeFieldStop()
14104 
    oprot.writeStructEnd()
14105 
 
3431 rajveer 14106 
  def validate(self):
14107 
    return
14108 
 
14109 
 
1113 chandransh 14110 
  def __repr__(self):
14111 
    L = ['%s=%r' % (key, value)
14112 
      for key, value in self.__dict__.iteritems()]
14113 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14114 
 
14115 
  def __eq__(self, other):
14116 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14117 
 
14118 
  def __ne__(self, other):
14119 
    return not (self == other)
14120 
 
3064 chandransh 14121 
class acceptOrder_result:
1113 chandransh 14122 
  """
14123 
  Attributes:
14124 
   - success
14125 
   - ex
14126 
  """
14127 
 
14128 
  thrift_spec = (
3064 chandransh 14129 
    (0, TType.BOOL, 'success', None, None, ), # 0
1113 chandransh 14130 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
14131 
  )
14132 
 
14133 
  def __init__(self, success=None, ex=None,):
14134 
    self.success = success
14135 
    self.ex = ex
14136 
 
14137 
  def read(self, iprot):
14138 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14139 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14140 
      return
14141 
    iprot.readStructBegin()
14142 
    while True:
14143 
      (fname, ftype, fid) = iprot.readFieldBegin()
14144 
      if ftype == TType.STOP:
14145 
        break
14146 
      if fid == 0:
3064 chandransh 14147 
        if ftype == TType.BOOL:
14148 
          self.success = iprot.readBool();
1113 chandransh 14149 
        else:
14150 
          iprot.skip(ftype)
14151 
      elif fid == 1:
14152 
        if ftype == TType.STRUCT:
14153 
          self.ex = TransactionServiceException()
14154 
          self.ex.read(iprot)
14155 
        else:
14156 
          iprot.skip(ftype)
14157 
      else:
14158 
        iprot.skip(ftype)
14159 
      iprot.readFieldEnd()
14160 
    iprot.readStructEnd()
14161 
 
14162 
  def write(self, oprot):
14163 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14164 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14165 
      return
3064 chandransh 14166 
    oprot.writeStructBegin('acceptOrder_result')
3431 rajveer 14167 
    if self.success is not None:
3064 chandransh 14168 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
14169 
      oprot.writeBool(self.success)
1113 chandransh 14170 
      oprot.writeFieldEnd()
3431 rajveer 14171 
    if self.ex is not None:
1113 chandransh 14172 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
14173 
      self.ex.write(oprot)
14174 
      oprot.writeFieldEnd()
14175 
    oprot.writeFieldStop()
14176 
    oprot.writeStructEnd()
14177 
 
3431 rajveer 14178 
  def validate(self):
14179 
    return
14180 
 
14181 
 
1113 chandransh 14182 
  def __repr__(self):
14183 
    L = ['%s=%r' % (key, value)
14184 
      for key, value in self.__dict__.iteritems()]
14185 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14186 
 
14187 
  def __eq__(self, other):
14188 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14189 
 
14190 
  def __ne__(self, other):
14191 
    return not (self == other)
14192 
 
3064 chandransh 14193 
class addBillingDetails_args:
1135 chandransh 14194 
  """
14195 
  Attributes:
3064 chandransh 14196 
   - orderId
14197 
   - invoice_number
4658 mandeep.dh 14198 
   - serialNumber
4283 anupam.sin 14199 
   - itemNumber
3064 chandransh 14200 
   - billed_by
4264 rajveer 14201 
   - jacketNumber
4283 anupam.sin 14202 
   - billingType
5110 mandeep.dh 14203 
   - fulfilmentWarehouseId
4763 rajveer 14204 
   - authorize
1135 chandransh 14205 
  """
14206 
 
14207 
  thrift_spec = (
14208 
    None, # 0
3064 chandransh 14209 
    (1, TType.I64, 'orderId', None, None, ), # 1
14210 
    (2, TType.STRING, 'invoice_number', None, None, ), # 2
5411 rajveer 14211 
    (3, TType.LIST, 'serialNumber', (TType.STRING,None), None, ), # 3
14212 
    (4, TType.LIST, 'itemNumber', (TType.STRING,None), None, ), # 4
4283 anupam.sin 14213 
    (5, TType.STRING, 'billed_by', None, None, ), # 5
14214 
    (6, TType.I64, 'jacketNumber', None, None, ), # 6
14215 
    (7, TType.I64, 'billingType', None, None, ), # 7
5110 mandeep.dh 14216 
    (8, TType.I64, 'fulfilmentWarehouseId', None, None, ), # 8
4763 rajveer 14217 
    (9, TType.BOOL, 'authorize', None, None, ), # 9
1135 chandransh 14218 
  )
14219 
 
5110 mandeep.dh 14220 
  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 14221 
    self.orderId = orderId
14222 
    self.invoice_number = invoice_number
4658 mandeep.dh 14223 
    self.serialNumber = serialNumber
4283 anupam.sin 14224 
    self.itemNumber = itemNumber
3064 chandransh 14225 
    self.billed_by = billed_by
4264 rajveer 14226 
    self.jacketNumber = jacketNumber
4283 anupam.sin 14227 
    self.billingType = billingType
5110 mandeep.dh 14228 
    self.fulfilmentWarehouseId = fulfilmentWarehouseId
4763 rajveer 14229 
    self.authorize = authorize
1135 chandransh 14230 
 
14231 
  def read(self, iprot):
14232 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14233 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14234 
      return
14235 
    iprot.readStructBegin()
14236 
    while True:
14237 
      (fname, ftype, fid) = iprot.readFieldBegin()
14238 
      if ftype == TType.STOP:
14239 
        break
14240 
      if fid == 1:
14241 
        if ftype == TType.I64:
3064 chandransh 14242 
          self.orderId = iprot.readI64();
1135 chandransh 14243 
        else:
14244 
          iprot.skip(ftype)
14245 
      elif fid == 2:
3064 chandransh 14246 
        if ftype == TType.STRING:
14247 
          self.invoice_number = iprot.readString();
1135 chandransh 14248 
        else:
14249 
          iprot.skip(ftype)
3064 chandransh 14250 
      elif fid == 3:
5411 rajveer 14251 
        if ftype == TType.LIST:
14252 
          self.serialNumber = []
6188 rajveer 14253 
          (_etype270, _size267) = iprot.readListBegin()
14254 
          for _i271 in xrange(_size267):
14255 
            _elem272 = iprot.readString();
14256 
            self.serialNumber.append(_elem272)
5411 rajveer 14257 
          iprot.readListEnd()
3064 chandransh 14258 
        else:
14259 
          iprot.skip(ftype)
14260 
      elif fid == 4:
5411 rajveer 14261 
        if ftype == TType.LIST:
14262 
          self.itemNumber = []
6188 rajveer 14263 
          (_etype276, _size273) = iprot.readListBegin()
14264 
          for _i277 in xrange(_size273):
14265 
            _elem278 = iprot.readString();
14266 
            self.itemNumber.append(_elem278)
5411 rajveer 14267 
          iprot.readListEnd()
3064 chandransh 14268 
        else:
14269 
          iprot.skip(ftype)
14270 
      elif fid == 5:
14271 
        if ftype == TType.STRING:
4283 anupam.sin 14272 
          self.billed_by = iprot.readString();
3064 chandransh 14273 
        else:
14274 
          iprot.skip(ftype)
14275 
      elif fid == 6:
14276 
        if ftype == TType.I64:
4283 anupam.sin 14277 
          self.jacketNumber = iprot.readI64();
14278 
        else:
14279 
          iprot.skip(ftype)
14280 
      elif fid == 7:
14281 
        if ftype == TType.I64:
3064 chandransh 14282 
          self.billingType = iprot.readI64();
14283 
        else:
14284 
          iprot.skip(ftype)
4283 anupam.sin 14285 
      elif fid == 8:
14286 
        if ftype == TType.I64:
5110 mandeep.dh 14287 
          self.fulfilmentWarehouseId = iprot.readI64();
4283 anupam.sin 14288 
        else:
14289 
          iprot.skip(ftype)
4763 rajveer 14290 
      elif fid == 9:
14291 
        if ftype == TType.BOOL:
14292 
          self.authorize = iprot.readBool();
14293 
        else:
14294 
          iprot.skip(ftype)
1246 chandransh 14295 
      else:
14296 
        iprot.skip(ftype)
14297 
      iprot.readFieldEnd()
14298 
    iprot.readStructEnd()
14299 
 
14300 
  def write(self, oprot):
14301 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14302 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14303 
      return
4283 anupam.sin 14304 
    oprot.writeStructBegin('addBillingDetails_args')
3431 rajveer 14305 
    if self.orderId is not None:
3064 chandransh 14306 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
14307 
      oprot.writeI64(self.orderId)
1246 chandransh 14308 
      oprot.writeFieldEnd()
4283 anupam.sin 14309 
    if self.invoice_number is not None:
14310 
      oprot.writeFieldBegin('invoice_number', TType.STRING, 2)
14311 
      oprot.writeString(self.invoice_number)
1246 chandransh 14312 
      oprot.writeFieldEnd()
4658 mandeep.dh 14313 
    if self.serialNumber is not None:
5411 rajveer 14314 
      oprot.writeFieldBegin('serialNumber', TType.LIST, 3)
14315 
      oprot.writeListBegin(TType.STRING, len(self.serialNumber))
6188 rajveer 14316 
      for iter279 in self.serialNumber:
14317 
        oprot.writeString(iter279)
5411 rajveer 14318 
      oprot.writeListEnd()
3064 chandransh 14319 
      oprot.writeFieldEnd()
3431 rajveer 14320 
    if self.itemNumber is not None:
5411 rajveer 14321 
      oprot.writeFieldBegin('itemNumber', TType.LIST, 4)
14322 
      oprot.writeListBegin(TType.STRING, len(self.itemNumber))
6188 rajveer 14323 
      for iter280 in self.itemNumber:
14324 
        oprot.writeString(iter280)
5411 rajveer 14325 
      oprot.writeListEnd()
3064 chandransh 14326 
      oprot.writeFieldEnd()
4283 anupam.sin 14327 
    if self.billed_by is not None:
14328 
      oprot.writeFieldBegin('billed_by', TType.STRING, 5)
14329 
      oprot.writeString(self.billed_by)
3064 chandransh 14330 
      oprot.writeFieldEnd()
4283 anupam.sin 14331 
    if self.jacketNumber is not None:
14332 
      oprot.writeFieldBegin('jacketNumber', TType.I64, 6)
14333 
      oprot.writeI64(self.jacketNumber)
14334 
      oprot.writeFieldEnd()
3431 rajveer 14335 
    if self.billingType is not None:
4283 anupam.sin 14336 
      oprot.writeFieldBegin('billingType', TType.I64, 7)
3064 chandransh 14337 
      oprot.writeI64(self.billingType)
14338 
      oprot.writeFieldEnd()
5110 mandeep.dh 14339 
    if self.fulfilmentWarehouseId is not None:
14340 
      oprot.writeFieldBegin('fulfilmentWarehouseId', TType.I64, 8)
14341 
      oprot.writeI64(self.fulfilmentWarehouseId)
4283 anupam.sin 14342 
      oprot.writeFieldEnd()
4763 rajveer 14343 
    if self.authorize is not None:
14344 
      oprot.writeFieldBegin('authorize', TType.BOOL, 9)
14345 
      oprot.writeBool(self.authorize)
14346 
      oprot.writeFieldEnd()
1246 chandransh 14347 
    oprot.writeFieldStop()
14348 
    oprot.writeStructEnd()
14349 
 
3431 rajveer 14350 
  def validate(self):
14351 
    return
14352 
 
14353 
 
1246 chandransh 14354 
  def __repr__(self):
14355 
    L = ['%s=%r' % (key, value)
14356 
      for key, value in self.__dict__.iteritems()]
14357 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14358 
 
14359 
  def __eq__(self, other):
14360 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14361 
 
14362 
  def __ne__(self, other):
14363 
    return not (self == other)
14364 
 
4283 anupam.sin 14365 
class addBillingDetails_result:
1246 chandransh 14366 
  """
14367 
  Attributes:
3064 chandransh 14368 
   - success
1246 chandransh 14369 
   - ex
14370 
  """
14371 
 
14372 
  thrift_spec = (
3064 chandransh 14373 
    (0, TType.BOOL, 'success', None, None, ), # 0
1246 chandransh 14374 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
14375 
  )
14376 
 
3064 chandransh 14377 
  def __init__(self, success=None, ex=None,):
14378 
    self.success = success
1246 chandransh 14379 
    self.ex = ex
14380 
 
14381 
  def read(self, iprot):
14382 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14383 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14384 
      return
14385 
    iprot.readStructBegin()
14386 
    while True:
14387 
      (fname, ftype, fid) = iprot.readFieldBegin()
14388 
      if ftype == TType.STOP:
14389 
        break
3064 chandransh 14390 
      if fid == 0:
14391 
        if ftype == TType.BOOL:
14392 
          self.success = iprot.readBool();
14393 
        else:
14394 
          iprot.skip(ftype)
14395 
      elif fid == 1:
1246 chandransh 14396 
        if ftype == TType.STRUCT:
14397 
          self.ex = TransactionServiceException()
14398 
          self.ex.read(iprot)
14399 
        else:
14400 
          iprot.skip(ftype)
14401 
      else:
14402 
        iprot.skip(ftype)
14403 
      iprot.readFieldEnd()
14404 
    iprot.readStructEnd()
14405 
 
14406 
  def write(self, oprot):
14407 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14408 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14409 
      return
4283 anupam.sin 14410 
    oprot.writeStructBegin('addBillingDetails_result')
3431 rajveer 14411 
    if self.success is not None:
3064 chandransh 14412 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
14413 
      oprot.writeBool(self.success)
14414 
      oprot.writeFieldEnd()
3431 rajveer 14415 
    if self.ex is not None:
1246 chandransh 14416 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
14417 
      self.ex.write(oprot)
14418 
      oprot.writeFieldEnd()
14419 
    oprot.writeFieldStop()
14420 
    oprot.writeStructEnd()
14421 
 
3431 rajveer 14422 
  def validate(self):
14423 
    return
14424 
 
14425 
 
1246 chandransh 14426 
  def __repr__(self):
14427 
    L = ['%s=%r' % (key, value)
14428 
      for key, value in self.__dict__.iteritems()]
14429 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14430 
 
14431 
  def __eq__(self, other):
14432 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14433 
 
14434 
  def __ne__(self, other):
14435 
    return not (self == other)
14436 
 
4579 rajveer 14437 
class addInvoiceNumber_args:
14438 
  """
14439 
  Attributes:
14440 
   - orderId
14441 
   - invoiceNumber
4763 rajveer 14442 
   - color
6756 amar.kumar 14443 
   - serialNumber
14444 
   - itemNumber
4579 rajveer 14445 
  """
14446 
 
14447 
  thrift_spec = (
14448 
    None, # 0
14449 
    (1, TType.I64, 'orderId', None, None, ), # 1
14450 
    (2, TType.STRING, 'invoiceNumber', None, None, ), # 2
4763 rajveer 14451 
    (3, TType.STRING, 'color', None, None, ), # 3
6756 amar.kumar 14452 
    (4, TType.STRING, 'serialNumber', None, None, ), # 4
14453 
    (5, TType.STRING, 'itemNumber', None, None, ), # 5
4579 rajveer 14454 
  )
14455 
 
6756 amar.kumar 14456 
  def __init__(self, orderId=None, invoiceNumber=None, color=None, serialNumber=None, itemNumber=None,):
4579 rajveer 14457 
    self.orderId = orderId
14458 
    self.invoiceNumber = invoiceNumber
4763 rajveer 14459 
    self.color = color
6756 amar.kumar 14460 
    self.serialNumber = serialNumber
14461 
    self.itemNumber = itemNumber
4579 rajveer 14462 
 
14463 
  def read(self, iprot):
14464 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14465 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14466 
      return
14467 
    iprot.readStructBegin()
14468 
    while True:
14469 
      (fname, ftype, fid) = iprot.readFieldBegin()
14470 
      if ftype == TType.STOP:
14471 
        break
14472 
      if fid == 1:
14473 
        if ftype == TType.I64:
14474 
          self.orderId = iprot.readI64();
14475 
        else:
14476 
          iprot.skip(ftype)
14477 
      elif fid == 2:
14478 
        if ftype == TType.STRING:
14479 
          self.invoiceNumber = iprot.readString();
14480 
        else:
14481 
          iprot.skip(ftype)
4763 rajveer 14482 
      elif fid == 3:
14483 
        if ftype == TType.STRING:
14484 
          self.color = iprot.readString();
14485 
        else:
14486 
          iprot.skip(ftype)
6756 amar.kumar 14487 
      elif fid == 4:
14488 
        if ftype == TType.STRING:
14489 
          self.serialNumber = iprot.readString();
14490 
        else:
14491 
          iprot.skip(ftype)
14492 
      elif fid == 5:
14493 
        if ftype == TType.STRING:
14494 
          self.itemNumber = iprot.readString();
14495 
        else:
14496 
          iprot.skip(ftype)
4579 rajveer 14497 
      else:
14498 
        iprot.skip(ftype)
14499 
      iprot.readFieldEnd()
14500 
    iprot.readStructEnd()
14501 
 
14502 
  def write(self, oprot):
14503 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14504 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14505 
      return
14506 
    oprot.writeStructBegin('addInvoiceNumber_args')
14507 
    if self.orderId is not None:
14508 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
14509 
      oprot.writeI64(self.orderId)
14510 
      oprot.writeFieldEnd()
14511 
    if self.invoiceNumber is not None:
14512 
      oprot.writeFieldBegin('invoiceNumber', TType.STRING, 2)
14513 
      oprot.writeString(self.invoiceNumber)
14514 
      oprot.writeFieldEnd()
4763 rajveer 14515 
    if self.color is not None:
14516 
      oprot.writeFieldBegin('color', TType.STRING, 3)
14517 
      oprot.writeString(self.color)
14518 
      oprot.writeFieldEnd()
6756 amar.kumar 14519 
    if self.serialNumber is not None:
14520 
      oprot.writeFieldBegin('serialNumber', TType.STRING, 4)
14521 
      oprot.writeString(self.serialNumber)
14522 
      oprot.writeFieldEnd()
14523 
    if self.itemNumber is not None:
14524 
      oprot.writeFieldBegin('itemNumber', TType.STRING, 5)
14525 
      oprot.writeString(self.itemNumber)
14526 
      oprot.writeFieldEnd()
4579 rajveer 14527 
    oprot.writeFieldStop()
14528 
    oprot.writeStructEnd()
14529 
 
14530 
  def validate(self):
14531 
    return
14532 
 
14533 
 
14534 
  def __repr__(self):
14535 
    L = ['%s=%r' % (key, value)
14536 
      for key, value in self.__dict__.iteritems()]
14537 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14538 
 
14539 
  def __eq__(self, other):
14540 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14541 
 
14542 
  def __ne__(self, other):
14543 
    return not (self == other)
14544 
 
14545 
class addInvoiceNumber_result:
14546 
  """
14547 
  Attributes:
14548 
   - ex
14549 
  """
14550 
 
14551 
  thrift_spec = (
14552 
    None, # 0
14553 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
14554 
  )
14555 
 
14556 
  def __init__(self, ex=None,):
14557 
    self.ex = ex
14558 
 
14559 
  def read(self, iprot):
14560 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14561 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14562 
      return
14563 
    iprot.readStructBegin()
14564 
    while True:
14565 
      (fname, ftype, fid) = iprot.readFieldBegin()
14566 
      if ftype == TType.STOP:
14567 
        break
14568 
      if fid == 1:
14569 
        if ftype == TType.STRUCT:
14570 
          self.ex = TransactionServiceException()
14571 
          self.ex.read(iprot)
14572 
        else:
14573 
          iprot.skip(ftype)
14574 
      else:
14575 
        iprot.skip(ftype)
14576 
      iprot.readFieldEnd()
14577 
    iprot.readStructEnd()
14578 
 
14579 
  def write(self, oprot):
14580 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14581 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14582 
      return
14583 
    oprot.writeStructBegin('addInvoiceNumber_result')
14584 
    if self.ex is not None:
14585 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
14586 
      self.ex.write(oprot)
14587 
      oprot.writeFieldEnd()
14588 
    oprot.writeFieldStop()
14589 
    oprot.writeStructEnd()
14590 
 
14591 
  def validate(self):
14592 
    return
14593 
 
14594 
 
14595 
  def __repr__(self):
14596 
    L = ['%s=%r' % (key, value)
14597 
      for key, value in self.__dict__.iteritems()]
14598 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14599 
 
14600 
  def __eq__(self, other):
14601 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14602 
 
14603 
  def __ne__(self, other):
14604 
    return not (self == other)
14605 
 
4910 phani.kuma 14606 
class markOrdersAsShippedFromWarehouse_args:
1408 ankur.sing 14607 
  """
14608 
  Attributes:
3064 chandransh 14609 
   - warehouseId
1408 ankur.sing 14610 
   - providerId
3064 chandransh 14611 
   - cod
4910 phani.kuma 14612 
   - orderIds
1408 ankur.sing 14613 
  """
14614 
 
14615 
  thrift_spec = (
14616 
    None, # 0
3064 chandransh 14617 
    (1, TType.I64, 'warehouseId', None, None, ), # 1
14618 
    (2, TType.I64, 'providerId', None, None, ), # 2
14619 
    (3, TType.BOOL, 'cod', None, None, ), # 3
4910 phani.kuma 14620 
    (4, TType.LIST, 'orderIds', (TType.I64,None), None, ), # 4
1408 ankur.sing 14621 
  )
14622 
 
4910 phani.kuma 14623 
  def __init__(self, warehouseId=None, providerId=None, cod=None, orderIds=None,):
3064 chandransh 14624 
    self.warehouseId = warehouseId
1408 ankur.sing 14625 
    self.providerId = providerId
3064 chandransh 14626 
    self.cod = cod
4910 phani.kuma 14627 
    self.orderIds = orderIds
1408 ankur.sing 14628 
 
14629 
  def read(self, iprot):
14630 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14631 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14632 
      return
14633 
    iprot.readStructBegin()
14634 
    while True:
14635 
      (fname, ftype, fid) = iprot.readFieldBegin()
14636 
      if ftype == TType.STOP:
14637 
        break
14638 
      if fid == 1:
14639 
        if ftype == TType.I64:
3064 chandransh 14640 
          self.warehouseId = iprot.readI64();
1408 ankur.sing 14641 
        else:
14642 
          iprot.skip(ftype)
14643 
      elif fid == 2:
14644 
        if ftype == TType.I64:
3064 chandransh 14645 
          self.providerId = iprot.readI64();
1408 ankur.sing 14646 
        else:
14647 
          iprot.skip(ftype)
3064 chandransh 14648 
      elif fid == 3:
14649 
        if ftype == TType.BOOL:
14650 
          self.cod = iprot.readBool();
14651 
        else:
14652 
          iprot.skip(ftype)
4910 phani.kuma 14653 
      elif fid == 4:
14654 
        if ftype == TType.LIST:
14655 
          self.orderIds = []
6188 rajveer 14656 
          (_etype284, _size281) = iprot.readListBegin()
14657 
          for _i285 in xrange(_size281):
14658 
            _elem286 = iprot.readI64();
14659 
            self.orderIds.append(_elem286)
4910 phani.kuma 14660 
          iprot.readListEnd()
14661 
        else:
14662 
          iprot.skip(ftype)
1408 ankur.sing 14663 
      else:
14664 
        iprot.skip(ftype)
14665 
      iprot.readFieldEnd()
14666 
    iprot.readStructEnd()
14667 
 
14668 
  def write(self, oprot):
14669 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14670 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14671 
      return
4910 phani.kuma 14672 
    oprot.writeStructBegin('markOrdersAsShippedFromWarehouse_args')
3431 rajveer 14673 
    if self.warehouseId is not None:
3064 chandransh 14674 
      oprot.writeFieldBegin('warehouseId', TType.I64, 1)
14675 
      oprot.writeI64(self.warehouseId)
14676 
      oprot.writeFieldEnd()
3431 rajveer 14677 
    if self.providerId is not None:
3064 chandransh 14678 
      oprot.writeFieldBegin('providerId', TType.I64, 2)
1408 ankur.sing 14679 
      oprot.writeI64(self.providerId)
14680 
      oprot.writeFieldEnd()
3431 rajveer 14681 
    if self.cod is not None:
3064 chandransh 14682 
      oprot.writeFieldBegin('cod', TType.BOOL, 3)
14683 
      oprot.writeBool(self.cod)
1408 ankur.sing 14684 
      oprot.writeFieldEnd()
4910 phani.kuma 14685 
    if self.orderIds is not None:
14686 
      oprot.writeFieldBegin('orderIds', TType.LIST, 4)
14687 
      oprot.writeListBegin(TType.I64, len(self.orderIds))
6188 rajveer 14688 
      for iter287 in self.orderIds:
14689 
        oprot.writeI64(iter287)
4910 phani.kuma 14690 
      oprot.writeListEnd()
14691 
      oprot.writeFieldEnd()
1408 ankur.sing 14692 
    oprot.writeFieldStop()
14693 
    oprot.writeStructEnd()
14694 
 
3431 rajveer 14695 
  def validate(self):
14696 
    return
14697 
 
14698 
 
1408 ankur.sing 14699 
  def __repr__(self):
14700 
    L = ['%s=%r' % (key, value)
14701 
      for key, value in self.__dict__.iteritems()]
14702 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14703 
 
14704 
  def __eq__(self, other):
14705 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14706 
 
14707 
  def __ne__(self, other):
14708 
    return not (self == other)
14709 
 
4910 phani.kuma 14710 
class markOrdersAsShippedFromWarehouse_result:
1408 ankur.sing 14711 
  """
14712 
  Attributes:
14713 
   - success
3064 chandransh 14714 
   - ex
1408 ankur.sing 14715 
  """
14716 
 
14717 
  thrift_spec = (
3064 chandransh 14718 
    (0, TType.BOOL, 'success', None, None, ), # 0
14719 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
1408 ankur.sing 14720 
  )
14721 
 
3064 chandransh 14722 
  def __init__(self, success=None, ex=None,):
1408 ankur.sing 14723 
    self.success = success
3064 chandransh 14724 
    self.ex = ex
1408 ankur.sing 14725 
 
14726 
  def read(self, iprot):
14727 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14728 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14729 
      return
14730 
    iprot.readStructBegin()
14731 
    while True:
14732 
      (fname, ftype, fid) = iprot.readFieldBegin()
14733 
      if ftype == TType.STOP:
14734 
        break
14735 
      if fid == 0:
3064 chandransh 14736 
        if ftype == TType.BOOL:
14737 
          self.success = iprot.readBool();
1408 ankur.sing 14738 
        else:
14739 
          iprot.skip(ftype)
3064 chandransh 14740 
      elif fid == 1:
14741 
        if ftype == TType.STRUCT:
14742 
          self.ex = TransactionServiceException()
14743 
          self.ex.read(iprot)
14744 
        else:
14745 
          iprot.skip(ftype)
1408 ankur.sing 14746 
      else:
14747 
        iprot.skip(ftype)
14748 
      iprot.readFieldEnd()
14749 
    iprot.readStructEnd()
14750 
 
14751 
  def write(self, oprot):
14752 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14753 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14754 
      return
4910 phani.kuma 14755 
    oprot.writeStructBegin('markOrdersAsShippedFromWarehouse_result')
3431 rajveer 14756 
    if self.success is not None:
3064 chandransh 14757 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
14758 
      oprot.writeBool(self.success)
1408 ankur.sing 14759 
      oprot.writeFieldEnd()
3431 rajveer 14760 
    if self.ex is not None:
3064 chandransh 14761 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
14762 
      self.ex.write(oprot)
14763 
      oprot.writeFieldEnd()
1408 ankur.sing 14764 
    oprot.writeFieldStop()
14765 
    oprot.writeStructEnd()
14766 
 
3431 rajveer 14767 
  def validate(self):
14768 
    return
14769 
 
14770 
 
1408 ankur.sing 14771 
  def __repr__(self):
14772 
    L = ['%s=%r' % (key, value)
14773 
      for key, value in self.__dict__.iteritems()]
14774 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14775 
 
14776 
  def __eq__(self, other):
14777 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14778 
 
14779 
  def __ne__(self, other):
14780 
    return not (self == other)
14781 
 
5676 rajveer 14782 
class markOrdersAsReturnedFromStore_args:
14783 
  """
14784 
  Attributes:
14785 
   - providerId
14786 
   - orderIds
5713 rajveer 14787 
   - awbs
5676 rajveer 14788 
  """
14789 
 
14790 
  thrift_spec = (
14791 
    None, # 0
14792 
    (1, TType.I64, 'providerId', None, None, ), # 1
14793 
    (2, TType.LIST, 'orderIds', (TType.I64,None), None, ), # 2
5713 rajveer 14794 
    (3, TType.LIST, 'awbs', (TType.STRING,None), None, ), # 3
5676 rajveer 14795 
  )
14796 
 
5713 rajveer 14797 
  def __init__(self, providerId=None, orderIds=None, awbs=None,):
5676 rajveer 14798 
    self.providerId = providerId
14799 
    self.orderIds = orderIds
5713 rajveer 14800 
    self.awbs = awbs
5676 rajveer 14801 
 
14802 
  def read(self, iprot):
14803 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14804 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14805 
      return
14806 
    iprot.readStructBegin()
14807 
    while True:
14808 
      (fname, ftype, fid) = iprot.readFieldBegin()
14809 
      if ftype == TType.STOP:
14810 
        break
14811 
      if fid == 1:
14812 
        if ftype == TType.I64:
14813 
          self.providerId = iprot.readI64();
14814 
        else:
14815 
          iprot.skip(ftype)
14816 
      elif fid == 2:
14817 
        if ftype == TType.LIST:
14818 
          self.orderIds = []
6188 rajveer 14819 
          (_etype291, _size288) = iprot.readListBegin()
14820 
          for _i292 in xrange(_size288):
14821 
            _elem293 = iprot.readI64();
14822 
            self.orderIds.append(_elem293)
5676 rajveer 14823 
          iprot.readListEnd()
14824 
        else:
14825 
          iprot.skip(ftype)
5713 rajveer 14826 
      elif fid == 3:
14827 
        if ftype == TType.LIST:
14828 
          self.awbs = []
6188 rajveer 14829 
          (_etype297, _size294) = iprot.readListBegin()
14830 
          for _i298 in xrange(_size294):
14831 
            _elem299 = iprot.readString();
14832 
            self.awbs.append(_elem299)
5713 rajveer 14833 
          iprot.readListEnd()
14834 
        else:
14835 
          iprot.skip(ftype)
5676 rajveer 14836 
      else:
14837 
        iprot.skip(ftype)
14838 
      iprot.readFieldEnd()
14839 
    iprot.readStructEnd()
14840 
 
14841 
  def write(self, oprot):
14842 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14843 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14844 
      return
14845 
    oprot.writeStructBegin('markOrdersAsReturnedFromStore_args')
14846 
    if self.providerId is not None:
14847 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
14848 
      oprot.writeI64(self.providerId)
14849 
      oprot.writeFieldEnd()
14850 
    if self.orderIds is not None:
14851 
      oprot.writeFieldBegin('orderIds', TType.LIST, 2)
14852 
      oprot.writeListBegin(TType.I64, len(self.orderIds))
6188 rajveer 14853 
      for iter300 in self.orderIds:
14854 
        oprot.writeI64(iter300)
5676 rajveer 14855 
      oprot.writeListEnd()
14856 
      oprot.writeFieldEnd()
5713 rajveer 14857 
    if self.awbs is not None:
14858 
      oprot.writeFieldBegin('awbs', TType.LIST, 3)
14859 
      oprot.writeListBegin(TType.STRING, len(self.awbs))
6188 rajveer 14860 
      for iter301 in self.awbs:
14861 
        oprot.writeString(iter301)
5713 rajveer 14862 
      oprot.writeListEnd()
14863 
      oprot.writeFieldEnd()
5676 rajveer 14864 
    oprot.writeFieldStop()
14865 
    oprot.writeStructEnd()
14866 
 
14867 
  def validate(self):
14868 
    return
14869 
 
14870 
 
14871 
  def __repr__(self):
14872 
    L = ['%s=%r' % (key, value)
14873 
      for key, value in self.__dict__.iteritems()]
14874 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14875 
 
14876 
  def __eq__(self, other):
14877 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14878 
 
14879 
  def __ne__(self, other):
14880 
    return not (self == other)
14881 
 
14882 
class markOrdersAsReturnedFromStore_result:
14883 
  """
14884 
  Attributes:
14885 
   - success
14886 
   - ex
14887 
  """
14888 
 
14889 
  thrift_spec = (
14890 
    (0, TType.BOOL, 'success', None, None, ), # 0
14891 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
14892 
  )
14893 
 
14894 
  def __init__(self, success=None, ex=None,):
14895 
    self.success = success
14896 
    self.ex = ex
14897 
 
14898 
  def read(self, iprot):
14899 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14900 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14901 
      return
14902 
    iprot.readStructBegin()
14903 
    while True:
14904 
      (fname, ftype, fid) = iprot.readFieldBegin()
14905 
      if ftype == TType.STOP:
14906 
        break
14907 
      if fid == 0:
14908 
        if ftype == TType.BOOL:
14909 
          self.success = iprot.readBool();
14910 
        else:
14911 
          iprot.skip(ftype)
14912 
      elif fid == 1:
14913 
        if ftype == TType.STRUCT:
14914 
          self.ex = TransactionServiceException()
14915 
          self.ex.read(iprot)
14916 
        else:
14917 
          iprot.skip(ftype)
14918 
      else:
14919 
        iprot.skip(ftype)
14920 
      iprot.readFieldEnd()
14921 
    iprot.readStructEnd()
14922 
 
14923 
  def write(self, oprot):
14924 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14925 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14926 
      return
14927 
    oprot.writeStructBegin('markOrdersAsReturnedFromStore_result')
14928 
    if self.success is not None:
14929 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
14930 
      oprot.writeBool(self.success)
14931 
      oprot.writeFieldEnd()
14932 
    if self.ex is not None:
14933 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
14934 
      self.ex.write(oprot)
14935 
      oprot.writeFieldEnd()
14936 
    oprot.writeFieldStop()
14937 
    oprot.writeStructEnd()
14938 
 
14939 
  def validate(self):
14940 
    return
14941 
 
14942 
 
14943 
  def __repr__(self):
14944 
    L = ['%s=%r' % (key, value)
14945 
      for key, value in self.__dict__.iteritems()]
14946 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14947 
 
14948 
  def __eq__(self, other):
14949 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14950 
 
14951 
  def __ne__(self, other):
14952 
    return not (self == other)
14953 
 
4910 phani.kuma 14954 
class markOrdersAsPickedUp_args:
4410 rajveer 14955 
  """
14956 
  Attributes:
14957 
   - providerId
4910 phani.kuma 14958 
   - pickupDetails
4410 rajveer 14959 
  """
14960 
 
14961 
  thrift_spec = (
14962 
    None, # 0
4910 phani.kuma 14963 
    (1, TType.I64, 'providerId', None, None, ), # 1
14964 
    (2, TType.MAP, 'pickupDetails', (TType.STRING,None,TType.STRING,None), None, ), # 2
4410 rajveer 14965 
  )
14966 
 
4910 phani.kuma 14967 
  def __init__(self, providerId=None, pickupDetails=None,):
4410 rajveer 14968 
    self.providerId = providerId
4910 phani.kuma 14969 
    self.pickupDetails = pickupDetails
4410 rajveer 14970 
 
14971 
  def read(self, iprot):
14972 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14973 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14974 
      return
14975 
    iprot.readStructBegin()
14976 
    while True:
14977 
      (fname, ftype, fid) = iprot.readFieldBegin()
14978 
      if ftype == TType.STOP:
14979 
        break
14980 
      if fid == 1:
14981 
        if ftype == TType.I64:
4910 phani.kuma 14982 
          self.providerId = iprot.readI64();
4410 rajveer 14983 
        else:
14984 
          iprot.skip(ftype)
14985 
      elif fid == 2:
4910 phani.kuma 14986 
        if ftype == TType.MAP:
14987 
          self.pickupDetails = {}
6188 rajveer 14988 
          (_ktype303, _vtype304, _size302 ) = iprot.readMapBegin()
14989 
          for _i306 in xrange(_size302):
14990 
            _key307 = iprot.readString();
14991 
            _val308 = iprot.readString();
14992 
            self.pickupDetails[_key307] = _val308
4910 phani.kuma 14993 
          iprot.readMapEnd()
4410 rajveer 14994 
        else:
14995 
          iprot.skip(ftype)
14996 
      else:
14997 
        iprot.skip(ftype)
14998 
      iprot.readFieldEnd()
14999 
    iprot.readStructEnd()
15000 
 
15001 
  def write(self, oprot):
15002 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15003 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15004 
      return
4910 phani.kuma 15005 
    oprot.writeStructBegin('markOrdersAsPickedUp_args')
4410 rajveer 15006 
    if self.providerId is not None:
4910 phani.kuma 15007 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
4410 rajveer 15008 
      oprot.writeI64(self.providerId)
15009 
      oprot.writeFieldEnd()
4910 phani.kuma 15010 
    if self.pickupDetails is not None:
15011 
      oprot.writeFieldBegin('pickupDetails', TType.MAP, 2)
15012 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.pickupDetails))
6188 rajveer 15013 
      for kiter309,viter310 in self.pickupDetails.items():
15014 
        oprot.writeString(kiter309)
15015 
        oprot.writeString(viter310)
4910 phani.kuma 15016 
      oprot.writeMapEnd()
4410 rajveer 15017 
      oprot.writeFieldEnd()
15018 
    oprot.writeFieldStop()
15019 
    oprot.writeStructEnd()
15020 
 
15021 
  def validate(self):
15022 
    return
15023 
 
15024 
 
15025 
  def __repr__(self):
15026 
    L = ['%s=%r' % (key, value)
15027 
      for key, value in self.__dict__.iteritems()]
15028 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15029 
 
15030 
  def __eq__(self, other):
15031 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15032 
 
15033 
  def __ne__(self, other):
15034 
    return not (self == other)
15035 
 
4910 phani.kuma 15036 
class markOrdersAsPickedUp_result:
4410 rajveer 15037 
  """
15038 
  Attributes:
15039 
   - ex
15040 
  """
15041 
 
15042 
  thrift_spec = (
4910 phani.kuma 15043 
    None, # 0
4410 rajveer 15044 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
15045 
  )
15046 
 
4910 phani.kuma 15047 
  def __init__(self, ex=None,):
4410 rajveer 15048 
    self.ex = ex
15049 
 
15050 
  def read(self, iprot):
15051 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15052 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15053 
      return
15054 
    iprot.readStructBegin()
15055 
    while True:
15056 
      (fname, ftype, fid) = iprot.readFieldBegin()
15057 
      if ftype == TType.STOP:
15058 
        break
4910 phani.kuma 15059 
      if fid == 1:
4410 rajveer 15060 
        if ftype == TType.STRUCT:
15061 
          self.ex = TransactionServiceException()
15062 
          self.ex.read(iprot)
15063 
        else:
15064 
          iprot.skip(ftype)
15065 
      else:
15066 
        iprot.skip(ftype)
15067 
      iprot.readFieldEnd()
15068 
    iprot.readStructEnd()
15069 
 
15070 
  def write(self, oprot):
15071 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15072 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15073 
      return
4910 phani.kuma 15074 
    oprot.writeStructBegin('markOrdersAsPickedUp_result')
4410 rajveer 15075 
    if self.ex is not None:
15076 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
15077 
      self.ex.write(oprot)
15078 
      oprot.writeFieldEnd()
15079 
    oprot.writeFieldStop()
15080 
    oprot.writeStructEnd()
15081 
 
15082 
  def validate(self):
15083 
    return
15084 
 
15085 
 
15086 
  def __repr__(self):
15087 
    L = ['%s=%r' % (key, value)
15088 
      for key, value in self.__dict__.iteritems()]
15089 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15090 
 
15091 
  def __eq__(self, other):
15092 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15093 
 
15094 
  def __ne__(self, other):
15095 
    return not (self == other)
15096 
 
4910 phani.kuma 15097 
class getOrdersNotPickedUp_args:
304 ashish 15098 
  """
15099 
  Attributes:
3064 chandransh 15100 
   - providerId
304 ashish 15101 
  """
94 ashish 15102 
 
304 ashish 15103 
  thrift_spec = (
15104 
    None, # 0
3064 chandransh 15105 
    (1, TType.I64, 'providerId', None, None, ), # 1
304 ashish 15106 
  )
15107 
 
4910 phani.kuma 15108 
  def __init__(self, providerId=None,):
3064 chandransh 15109 
    self.providerId = providerId
304 ashish 15110 
 
15111 
  def read(self, iprot):
15112 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15113 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15114 
      return
15115 
    iprot.readStructBegin()
15116 
    while True:
15117 
      (fname, ftype, fid) = iprot.readFieldBegin()
15118 
      if ftype == TType.STOP:
15119 
        break
15120 
      if fid == 1:
15121 
        if ftype == TType.I64:
3064 chandransh 15122 
          self.providerId = iprot.readI64();
304 ashish 15123 
        else:
15124 
          iprot.skip(ftype)
15125 
      else:
15126 
        iprot.skip(ftype)
15127 
      iprot.readFieldEnd()
15128 
    iprot.readStructEnd()
15129 
 
15130 
  def write(self, oprot):
15131 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15132 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15133 
      return
4910 phani.kuma 15134 
    oprot.writeStructBegin('getOrdersNotPickedUp_args')
3431 rajveer 15135 
    if self.providerId is not None:
3064 chandransh 15136 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
15137 
      oprot.writeI64(self.providerId)
304 ashish 15138 
      oprot.writeFieldEnd()
15139 
    oprot.writeFieldStop()
15140 
    oprot.writeStructEnd()
15141 
 
3431 rajveer 15142 
  def validate(self):
15143 
    return
15144 
 
15145 
 
304 ashish 15146 
  def __repr__(self):
15147 
    L = ['%s=%r' % (key, value)
15148 
      for key, value in self.__dict__.iteritems()]
15149 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15150 
 
15151 
  def __eq__(self, other):
15152 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15153 
 
15154 
  def __ne__(self, other):
15155 
    return not (self == other)
15156 
 
4910 phani.kuma 15157 
class getOrdersNotPickedUp_result:
304 ashish 15158 
  """
15159 
  Attributes:
15160 
   - success
15161 
  """
15162 
 
15163 
  thrift_spec = (
3064 chandransh 15164 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
304 ashish 15165 
  )
15166 
 
4910 phani.kuma 15167 
  def __init__(self, success=None,):
304 ashish 15168 
    self.success = success
15169 
 
15170 
  def read(self, iprot):
15171 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15172 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15173 
      return
15174 
    iprot.readStructBegin()
15175 
    while True:
15176 
      (fname, ftype, fid) = iprot.readFieldBegin()
15177 
      if ftype == TType.STOP:
15178 
        break
15179 
      if fid == 0:
15180 
        if ftype == TType.LIST:
15181 
          self.success = []
6188 rajveer 15182 
          (_etype314, _size311) = iprot.readListBegin()
15183 
          for _i315 in xrange(_size311):
15184 
            _elem316 = Order()
15185 
            _elem316.read(iprot)
15186 
            self.success.append(_elem316)
304 ashish 15187 
          iprot.readListEnd()
15188 
        else:
15189 
          iprot.skip(ftype)
15190 
      else:
15191 
        iprot.skip(ftype)
15192 
      iprot.readFieldEnd()
15193 
    iprot.readStructEnd()
15194 
 
15195 
  def write(self, oprot):
15196 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15197 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15198 
      return
4910 phani.kuma 15199 
    oprot.writeStructBegin('getOrdersNotPickedUp_result')
3431 rajveer 15200 
    if self.success is not None:
304 ashish 15201 
      oprot.writeFieldBegin('success', TType.LIST, 0)
15202 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 15203 
      for iter317 in self.success:
15204 
        iter317.write(oprot)
304 ashish 15205 
      oprot.writeListEnd()
15206 
      oprot.writeFieldEnd()
15207 
    oprot.writeFieldStop()
15208 
    oprot.writeStructEnd()
15209 
 
3431 rajveer 15210 
  def validate(self):
15211 
    return
15212 
 
15213 
 
304 ashish 15214 
  def __repr__(self):
15215 
    L = ['%s=%r' % (key, value)
15216 
      for key, value in self.__dict__.iteritems()]
15217 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15218 
 
15219 
  def __eq__(self, other):
15220 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15221 
 
15222 
  def __ne__(self, other):
15223 
    return not (self == other)
15224 
 
3064 chandransh 15225 
class markOrdersAsDelivered_args:
304 ashish 15226 
  """
15227 
  Attributes:
3064 chandransh 15228 
   - providerId
15229 
   - deliveredOrders
304 ashish 15230 
  """
15231 
 
15232 
  thrift_spec = (
15233 
    None, # 0
3064 chandransh 15234 
    (1, TType.I64, 'providerId', None, None, ), # 1
15235 
    (2, TType.MAP, 'deliveredOrders', (TType.STRING,None,TType.STRING,None), None, ), # 2
304 ashish 15236 
  )
15237 
 
3064 chandransh 15238 
  def __init__(self, providerId=None, deliveredOrders=None,):
15239 
    self.providerId = providerId
15240 
    self.deliveredOrders = deliveredOrders
304 ashish 15241 
 
15242 
  def read(self, iprot):
15243 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15244 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15245 
      return
15246 
    iprot.readStructBegin()
15247 
    while True:
15248 
      (fname, ftype, fid) = iprot.readFieldBegin()
15249 
      if ftype == TType.STOP:
15250 
        break
15251 
      if fid == 1:
15252 
        if ftype == TType.I64:
3064 chandransh 15253 
          self.providerId = iprot.readI64();
304 ashish 15254 
        else:
15255 
          iprot.skip(ftype)
15256 
      elif fid == 2:
3064 chandransh 15257 
        if ftype == TType.MAP:
15258 
          self.deliveredOrders = {}
6188 rajveer 15259 
          (_ktype319, _vtype320, _size318 ) = iprot.readMapBegin()
15260 
          for _i322 in xrange(_size318):
15261 
            _key323 = iprot.readString();
15262 
            _val324 = iprot.readString();
15263 
            self.deliveredOrders[_key323] = _val324
3064 chandransh 15264 
          iprot.readMapEnd()
304 ashish 15265 
        else:
15266 
          iprot.skip(ftype)
15267 
      else:
15268 
        iprot.skip(ftype)
15269 
      iprot.readFieldEnd()
15270 
    iprot.readStructEnd()
15271 
 
15272 
  def write(self, oprot):
15273 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15274 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15275 
      return
3064 chandransh 15276 
    oprot.writeStructBegin('markOrdersAsDelivered_args')
3431 rajveer 15277 
    if self.providerId is not None:
3064 chandransh 15278 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
15279 
      oprot.writeI64(self.providerId)
304 ashish 15280 
      oprot.writeFieldEnd()
3431 rajveer 15281 
    if self.deliveredOrders is not None:
3064 chandransh 15282 
      oprot.writeFieldBegin('deliveredOrders', TType.MAP, 2)
15283 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.deliveredOrders))
6188 rajveer 15284 
      for kiter325,viter326 in self.deliveredOrders.items():
15285 
        oprot.writeString(kiter325)
15286 
        oprot.writeString(viter326)
3064 chandransh 15287 
      oprot.writeMapEnd()
304 ashish 15288 
      oprot.writeFieldEnd()
15289 
    oprot.writeFieldStop()
15290 
    oprot.writeStructEnd()
15291 
 
3431 rajveer 15292 
  def validate(self):
15293 
    return
15294 
 
15295 
 
304 ashish 15296 
  def __repr__(self):
15297 
    L = ['%s=%r' % (key, value)
15298 
      for key, value in self.__dict__.iteritems()]
15299 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15300 
 
15301 
  def __eq__(self, other):
15302 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15303 
 
15304 
  def __ne__(self, other):
15305 
    return not (self == other)
15306 
 
3064 chandransh 15307 
class markOrdersAsDelivered_result:
15308 
  """
15309 
  Attributes:
15310 
   - ex
15311 
  """
304 ashish 15312 
 
15313 
  thrift_spec = (
3064 chandransh 15314 
    None, # 0
15315 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
304 ashish 15316 
  )
15317 
 
3064 chandransh 15318 
  def __init__(self, ex=None,):
15319 
    self.ex = ex
304 ashish 15320 
 
1596 ankur.sing 15321 
  def read(self, iprot):
15322 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15323 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15324 
      return
15325 
    iprot.readStructBegin()
15326 
    while True:
15327 
      (fname, ftype, fid) = iprot.readFieldBegin()
15328 
      if ftype == TType.STOP:
15329 
        break
3064 chandransh 15330 
      if fid == 1:
15331 
        if ftype == TType.STRUCT:
15332 
          self.ex = TransactionServiceException()
15333 
          self.ex.read(iprot)
15334 
        else:
15335 
          iprot.skip(ftype)
1596 ankur.sing 15336 
      else:
15337 
        iprot.skip(ftype)
15338 
      iprot.readFieldEnd()
15339 
    iprot.readStructEnd()
15340 
 
15341 
  def write(self, oprot):
15342 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15343 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15344 
      return
3064 chandransh 15345 
    oprot.writeStructBegin('markOrdersAsDelivered_result')
3431 rajveer 15346 
    if self.ex is not None:
3064 chandransh 15347 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
15348 
      self.ex.write(oprot)
15349 
      oprot.writeFieldEnd()
1596 ankur.sing 15350 
    oprot.writeFieldStop()
15351 
    oprot.writeStructEnd()
15352 
 
3431 rajveer 15353 
  def validate(self):
15354 
    return
15355 
 
15356 
 
1596 ankur.sing 15357 
  def __repr__(self):
15358 
    L = ['%s=%r' % (key, value)
15359 
      for key, value in self.__dict__.iteritems()]
15360 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15361 
 
15362 
  def __eq__(self, other):
15363 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15364 
 
15365 
  def __ne__(self, other):
15366 
    return not (self == other)
15367 
 
4910 phani.kuma 15368 
class markAsRTOrders_args:
1596 ankur.sing 15369 
  """
15370 
  Attributes:
3064 chandransh 15371 
   - providerId
15372 
   - returnedOrders
1596 ankur.sing 15373 
  """
15374 
 
15375 
  thrift_spec = (
3064 chandransh 15376 
    None, # 0
15377 
    (1, TType.I64, 'providerId', None, None, ), # 1
15378 
    (2, TType.MAP, 'returnedOrders', (TType.STRING,None,TType.STRING,None), None, ), # 2
1596 ankur.sing 15379 
  )
15380 
 
3064 chandransh 15381 
  def __init__(self, providerId=None, returnedOrders=None,):
15382 
    self.providerId = providerId
15383 
    self.returnedOrders = returnedOrders
1596 ankur.sing 15384 
 
15385 
  def read(self, iprot):
15386 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15387 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15388 
      return
15389 
    iprot.readStructBegin()
15390 
    while True:
15391 
      (fname, ftype, fid) = iprot.readFieldBegin()
15392 
      if ftype == TType.STOP:
15393 
        break
3064 chandransh 15394 
      if fid == 1:
1596 ankur.sing 15395 
        if ftype == TType.I64:
3064 chandransh 15396 
          self.providerId = iprot.readI64();
1596 ankur.sing 15397 
        else:
15398 
          iprot.skip(ftype)
3064 chandransh 15399 
      elif fid == 2:
15400 
        if ftype == TType.MAP:
15401 
          self.returnedOrders = {}
6188 rajveer 15402 
          (_ktype328, _vtype329, _size327 ) = iprot.readMapBegin()
15403 
          for _i331 in xrange(_size327):
15404 
            _key332 = iprot.readString();
15405 
            _val333 = iprot.readString();
15406 
            self.returnedOrders[_key332] = _val333
3064 chandransh 15407 
          iprot.readMapEnd()
15408 
        else:
15409 
          iprot.skip(ftype)
1596 ankur.sing 15410 
      else:
15411 
        iprot.skip(ftype)
15412 
      iprot.readFieldEnd()
15413 
    iprot.readStructEnd()
15414 
 
15415 
  def write(self, oprot):
15416 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15417 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15418 
      return
4910 phani.kuma 15419 
    oprot.writeStructBegin('markAsRTOrders_args')
3431 rajveer 15420 
    if self.providerId is not None:
3064 chandransh 15421 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
15422 
      oprot.writeI64(self.providerId)
1596 ankur.sing 15423 
      oprot.writeFieldEnd()
3431 rajveer 15424 
    if self.returnedOrders is not None:
3064 chandransh 15425 
      oprot.writeFieldBegin('returnedOrders', TType.MAP, 2)
15426 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.returnedOrders))
6188 rajveer 15427 
      for kiter334,viter335 in self.returnedOrders.items():
15428 
        oprot.writeString(kiter334)
15429 
        oprot.writeString(viter335)
3064 chandransh 15430 
      oprot.writeMapEnd()
15431 
      oprot.writeFieldEnd()
1596 ankur.sing 15432 
    oprot.writeFieldStop()
15433 
    oprot.writeStructEnd()
15434 
 
3431 rajveer 15435 
  def validate(self):
15436 
    return
15437 
 
15438 
 
1596 ankur.sing 15439 
  def __repr__(self):
15440 
    L = ['%s=%r' % (key, value)
15441 
      for key, value in self.__dict__.iteritems()]
15442 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15443 
 
15444 
  def __eq__(self, other):
15445 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15446 
 
15447 
  def __ne__(self, other):
15448 
    return not (self == other)
15449 
 
4910 phani.kuma 15450 
class markAsRTOrders_result:
3064 chandransh 15451 
  """
15452 
  Attributes:
15453 
   - ex
15454 
  """
1596 ankur.sing 15455 
 
1627 ankur.sing 15456 
  thrift_spec = (
3064 chandransh 15457 
    None, # 0
15458 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
1627 ankur.sing 15459 
  )
15460 
 
3064 chandransh 15461 
  def __init__(self, ex=None,):
15462 
    self.ex = ex
15463 
 
1627 ankur.sing 15464 
  def read(self, iprot):
15465 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15466 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15467 
      return
15468 
    iprot.readStructBegin()
15469 
    while True:
15470 
      (fname, ftype, fid) = iprot.readFieldBegin()
15471 
      if ftype == TType.STOP:
15472 
        break
3064 chandransh 15473 
      if fid == 1:
15474 
        if ftype == TType.STRUCT:
15475 
          self.ex = TransactionServiceException()
15476 
          self.ex.read(iprot)
15477 
        else:
15478 
          iprot.skip(ftype)
1627 ankur.sing 15479 
      else:
15480 
        iprot.skip(ftype)
15481 
      iprot.readFieldEnd()
15482 
    iprot.readStructEnd()
15483 
 
15484 
  def write(self, oprot):
15485 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15486 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15487 
      return
4910 phani.kuma 15488 
    oprot.writeStructBegin('markAsRTOrders_result')
3431 rajveer 15489 
    if self.ex is not None:
3064 chandransh 15490 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
15491 
      self.ex.write(oprot)
15492 
      oprot.writeFieldEnd()
1627 ankur.sing 15493 
    oprot.writeFieldStop()
15494 
    oprot.writeStructEnd()
15495 
 
3431 rajveer 15496 
  def validate(self):
15497 
    return
15498 
 
15499 
 
1627 ankur.sing 15500 
  def __repr__(self):
15501 
    L = ['%s=%r' % (key, value)
15502 
      for key, value in self.__dict__.iteritems()]
15503 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15504 
 
15505 
  def __eq__(self, other):
15506 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15507 
 
15508 
  def __ne__(self, other):
15509 
    return not (self == other)
15510 
 
4910 phani.kuma 15511 
class getRTOrders_args:
15512 
  """
15513 
  Attributes:
15514 
   - providerId
15515 
  """
15516 
 
15517 
  thrift_spec = (
15518 
    None, # 0
15519 
    (1, TType.I64, 'providerId', None, None, ), # 1
15520 
  )
15521 
 
15522 
  def __init__(self, providerId=None,):
15523 
    self.providerId = providerId
15524 
 
15525 
  def read(self, iprot):
15526 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15527 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15528 
      return
15529 
    iprot.readStructBegin()
15530 
    while True:
15531 
      (fname, ftype, fid) = iprot.readFieldBegin()
15532 
      if ftype == TType.STOP:
15533 
        break
15534 
      if fid == 1:
15535 
        if ftype == TType.I64:
15536 
          self.providerId = iprot.readI64();
15537 
        else:
15538 
          iprot.skip(ftype)
15539 
      else:
15540 
        iprot.skip(ftype)
15541 
      iprot.readFieldEnd()
15542 
    iprot.readStructEnd()
15543 
 
15544 
  def write(self, oprot):
15545 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15546 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15547 
      return
15548 
    oprot.writeStructBegin('getRTOrders_args')
15549 
    if self.providerId is not None:
15550 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
15551 
      oprot.writeI64(self.providerId)
15552 
      oprot.writeFieldEnd()
15553 
    oprot.writeFieldStop()
15554 
    oprot.writeStructEnd()
15555 
 
15556 
  def validate(self):
15557 
    return
15558 
 
15559 
 
15560 
  def __repr__(self):
15561 
    L = ['%s=%r' % (key, value)
15562 
      for key, value in self.__dict__.iteritems()]
15563 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15564 
 
15565 
  def __eq__(self, other):
15566 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15567 
 
15568 
  def __ne__(self, other):
15569 
    return not (self == other)
15570 
 
15571 
class getRTOrders_result:
15572 
  """
15573 
  Attributes:
15574 
   - success
15575 
  """
15576 
 
15577 
  thrift_spec = (
15578 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
15579 
  )
15580 
 
15581 
  def __init__(self, success=None,):
15582 
    self.success = success
15583 
 
15584 
  def read(self, iprot):
15585 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15586 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15587 
      return
15588 
    iprot.readStructBegin()
15589 
    while True:
15590 
      (fname, ftype, fid) = iprot.readFieldBegin()
15591 
      if ftype == TType.STOP:
15592 
        break
15593 
      if fid == 0:
15594 
        if ftype == TType.LIST:
15595 
          self.success = []
6188 rajveer 15596 
          (_etype339, _size336) = iprot.readListBegin()
15597 
          for _i340 in xrange(_size336):
15598 
            _elem341 = Order()
15599 
            _elem341.read(iprot)
15600 
            self.success.append(_elem341)
4910 phani.kuma 15601 
          iprot.readListEnd()
15602 
        else:
15603 
          iprot.skip(ftype)
15604 
      else:
15605 
        iprot.skip(ftype)
15606 
      iprot.readFieldEnd()
15607 
    iprot.readStructEnd()
15608 
 
15609 
  def write(self, oprot):
15610 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15611 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15612 
      return
15613 
    oprot.writeStructBegin('getRTOrders_result')
15614 
    if self.success is not None:
15615 
      oprot.writeFieldBegin('success', TType.LIST, 0)
15616 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 15617 
      for iter342 in self.success:
15618 
        iter342.write(oprot)
4910 phani.kuma 15619 
      oprot.writeListEnd()
15620 
      oprot.writeFieldEnd()
15621 
    oprot.writeFieldStop()
15622 
    oprot.writeStructEnd()
15623 
 
15624 
  def validate(self):
15625 
    return
15626 
 
15627 
 
15628 
  def __repr__(self):
15629 
    L = ['%s=%r' % (key, value)
15630 
      for key, value in self.__dict__.iteritems()]
15631 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15632 
 
15633 
  def __eq__(self, other):
15634 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15635 
 
15636 
  def __ne__(self, other):
15637 
    return not (self == other)
15638 
 
3064 chandransh 15639 
class updateNonDeliveryReason_args:
1627 ankur.sing 15640 
  """
15641 
  Attributes:
3064 chandransh 15642 
   - providerId
15643 
   - undeliveredOrders
1627 ankur.sing 15644 
  """
15645 
 
15646 
  thrift_spec = (
3064 chandransh 15647 
    None, # 0
15648 
    (1, TType.I64, 'providerId', None, None, ), # 1
15649 
    (2, TType.MAP, 'undeliveredOrders', (TType.STRING,None,TType.STRING,None), None, ), # 2
1627 ankur.sing 15650 
  )
15651 
 
3064 chandransh 15652 
  def __init__(self, providerId=None, undeliveredOrders=None,):
15653 
    self.providerId = providerId
15654 
    self.undeliveredOrders = undeliveredOrders
1627 ankur.sing 15655 
 
15656 
  def read(self, iprot):
15657 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15658 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15659 
      return
15660 
    iprot.readStructBegin()
15661 
    while True:
15662 
      (fname, ftype, fid) = iprot.readFieldBegin()
15663 
      if ftype == TType.STOP:
15664 
        break
3064 chandransh 15665 
      if fid == 1:
1627 ankur.sing 15666 
        if ftype == TType.I64:
3064 chandransh 15667 
          self.providerId = iprot.readI64();
1627 ankur.sing 15668 
        else:
15669 
          iprot.skip(ftype)
3064 chandransh 15670 
      elif fid == 2:
15671 
        if ftype == TType.MAP:
15672 
          self.undeliveredOrders = {}
6188 rajveer 15673 
          (_ktype344, _vtype345, _size343 ) = iprot.readMapBegin()
15674 
          for _i347 in xrange(_size343):
15675 
            _key348 = iprot.readString();
15676 
            _val349 = iprot.readString();
15677 
            self.undeliveredOrders[_key348] = _val349
3064 chandransh 15678 
          iprot.readMapEnd()
15679 
        else:
15680 
          iprot.skip(ftype)
1627 ankur.sing 15681 
      else:
15682 
        iprot.skip(ftype)
15683 
      iprot.readFieldEnd()
15684 
    iprot.readStructEnd()
15685 
 
15686 
  def write(self, oprot):
15687 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15688 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15689 
      return
3064 chandransh 15690 
    oprot.writeStructBegin('updateNonDeliveryReason_args')
3431 rajveer 15691 
    if self.providerId is not None:
3064 chandransh 15692 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
15693 
      oprot.writeI64(self.providerId)
1627 ankur.sing 15694 
      oprot.writeFieldEnd()
3431 rajveer 15695 
    if self.undeliveredOrders is not None:
3064 chandransh 15696 
      oprot.writeFieldBegin('undeliveredOrders', TType.MAP, 2)
15697 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.undeliveredOrders))
6188 rajveer 15698 
      for kiter350,viter351 in self.undeliveredOrders.items():
15699 
        oprot.writeString(kiter350)
15700 
        oprot.writeString(viter351)
3064 chandransh 15701 
      oprot.writeMapEnd()
15702 
      oprot.writeFieldEnd()
1627 ankur.sing 15703 
    oprot.writeFieldStop()
15704 
    oprot.writeStructEnd()
15705 
 
3431 rajveer 15706 
  def validate(self):
15707 
    return
15708 
 
15709 
 
1627 ankur.sing 15710 
  def __repr__(self):
15711 
    L = ['%s=%r' % (key, value)
15712 
      for key, value in self.__dict__.iteritems()]
15713 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15714 
 
15715 
  def __eq__(self, other):
15716 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15717 
 
15718 
  def __ne__(self, other):
15719 
    return not (self == other)
15720 
 
3064 chandransh 15721 
class updateNonDeliveryReason_result:
1627 ankur.sing 15722 
  """
15723 
  Attributes:
3064 chandransh 15724 
   - ex
1627 ankur.sing 15725 
  """
15726 
 
15727 
  thrift_spec = (
4910 phani.kuma 15728 
    None, # 0
3064 chandransh 15729 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
1627 ankur.sing 15730 
  )
15731 
 
4910 phani.kuma 15732 
  def __init__(self, ex=None,):
3064 chandransh 15733 
    self.ex = ex
1627 ankur.sing 15734 
 
15735 
  def read(self, iprot):
15736 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15737 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15738 
      return
15739 
    iprot.readStructBegin()
15740 
    while True:
15741 
      (fname, ftype, fid) = iprot.readFieldBegin()
15742 
      if ftype == TType.STOP:
15743 
        break
4910 phani.kuma 15744 
      if fid == 1:
15745 
        if ftype == TType.STRUCT:
15746 
          self.ex = TransactionServiceException()
15747 
          self.ex.read(iprot)
15748 
        else:
15749 
          iprot.skip(ftype)
15750 
      else:
15751 
        iprot.skip(ftype)
15752 
      iprot.readFieldEnd()
15753 
    iprot.readStructEnd()
15754 
 
15755 
  def write(self, oprot):
15756 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15757 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15758 
      return
15759 
    oprot.writeStructBegin('updateNonDeliveryReason_result')
15760 
    if self.ex is not None:
15761 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
15762 
      self.ex.write(oprot)
15763 
      oprot.writeFieldEnd()
15764 
    oprot.writeFieldStop()
15765 
    oprot.writeStructEnd()
15766 
 
15767 
  def validate(self):
15768 
    return
15769 
 
15770 
 
15771 
  def __repr__(self):
15772 
    L = ['%s=%r' % (key, value)
15773 
      for key, value in self.__dict__.iteritems()]
15774 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15775 
 
15776 
  def __eq__(self, other):
15777 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15778 
 
15779 
  def __ne__(self, other):
15780 
    return not (self == other)
15781 
 
15782 
class getNonDeliveredOrdersbyCourier_args:
15783 
  """
15784 
  Attributes:
15785 
   - providerId
15786 
  """
15787 
 
15788 
  thrift_spec = (
15789 
    None, # 0
15790 
    (1, TType.I64, 'providerId', None, None, ), # 1
15791 
  )
15792 
 
15793 
  def __init__(self, providerId=None,):
15794 
    self.providerId = providerId
15795 
 
15796 
  def read(self, iprot):
15797 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15798 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15799 
      return
15800 
    iprot.readStructBegin()
15801 
    while True:
15802 
      (fname, ftype, fid) = iprot.readFieldBegin()
15803 
      if ftype == TType.STOP:
15804 
        break
15805 
      if fid == 1:
15806 
        if ftype == TType.I64:
15807 
          self.providerId = iprot.readI64();
15808 
        else:
15809 
          iprot.skip(ftype)
15810 
      else:
15811 
        iprot.skip(ftype)
15812 
      iprot.readFieldEnd()
15813 
    iprot.readStructEnd()
15814 
 
15815 
  def write(self, oprot):
15816 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15817 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15818 
      return
15819 
    oprot.writeStructBegin('getNonDeliveredOrdersbyCourier_args')
15820 
    if self.providerId is not None:
15821 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
15822 
      oprot.writeI64(self.providerId)
15823 
      oprot.writeFieldEnd()
15824 
    oprot.writeFieldStop()
15825 
    oprot.writeStructEnd()
15826 
 
15827 
  def validate(self):
15828 
    return
15829 
 
15830 
 
15831 
  def __repr__(self):
15832 
    L = ['%s=%r' % (key, value)
15833 
      for key, value in self.__dict__.iteritems()]
15834 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15835 
 
15836 
  def __eq__(self, other):
15837 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15838 
 
15839 
  def __ne__(self, other):
15840 
    return not (self == other)
15841 
 
15842 
class getNonDeliveredOrdersbyCourier_result:
15843 
  """
15844 
  Attributes:
15845 
   - success
15846 
  """
15847 
 
15848 
  thrift_spec = (
15849 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
15850 
  )
15851 
 
15852 
  def __init__(self, success=None,):
15853 
    self.success = success
15854 
 
15855 
  def read(self, iprot):
15856 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15857 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15858 
      return
15859 
    iprot.readStructBegin()
15860 
    while True:
15861 
      (fname, ftype, fid) = iprot.readFieldBegin()
15862 
      if ftype == TType.STOP:
15863 
        break
4581 phani.kuma 15864 
      if fid == 0:
15865 
        if ftype == TType.LIST:
15866 
          self.success = []
6188 rajveer 15867 
          (_etype355, _size352) = iprot.readListBegin()
15868 
          for _i356 in xrange(_size352):
15869 
            _elem357 = Order()
15870 
            _elem357.read(iprot)
15871 
            self.success.append(_elem357)
4581 phani.kuma 15872 
          iprot.readListEnd()
15873 
        else:
15874 
          iprot.skip(ftype)
4910 phani.kuma 15875 
      else:
15876 
        iprot.skip(ftype)
15877 
      iprot.readFieldEnd()
15878 
    iprot.readStructEnd()
15879 
 
15880 
  def write(self, oprot):
15881 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15882 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15883 
      return
15884 
    oprot.writeStructBegin('getNonDeliveredOrdersbyCourier_result')
15885 
    if self.success is not None:
15886 
      oprot.writeFieldBegin('success', TType.LIST, 0)
15887 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 15888 
      for iter358 in self.success:
15889 
        iter358.write(oprot)
4910 phani.kuma 15890 
      oprot.writeListEnd()
15891 
      oprot.writeFieldEnd()
15892 
    oprot.writeFieldStop()
15893 
    oprot.writeStructEnd()
15894 
 
15895 
  def validate(self):
15896 
    return
15897 
 
15898 
 
15899 
  def __repr__(self):
15900 
    L = ['%s=%r' % (key, value)
15901 
      for key, value in self.__dict__.iteritems()]
15902 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15903 
 
15904 
  def __eq__(self, other):
15905 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15906 
 
15907 
  def __ne__(self, other):
15908 
    return not (self == other)
15909 
 
15910 
class markOrdersAsLocalConnected_args:
15911 
  """
15912 
  Attributes:
15913 
   - providerId
15914 
   - local_connected_orders
15915 
  """
15916 
 
15917 
  thrift_spec = (
15918 
    None, # 0
15919 
    (1, TType.I64, 'providerId', None, None, ), # 1
15920 
    (2, TType.MAP, 'local_connected_orders', (TType.STRING,None,TType.STRING,None), None, ), # 2
15921 
  )
15922 
 
15923 
  def __init__(self, providerId=None, local_connected_orders=None,):
15924 
    self.providerId = providerId
15925 
    self.local_connected_orders = local_connected_orders
15926 
 
15927 
  def read(self, iprot):
15928 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15929 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15930 
      return
15931 
    iprot.readStructBegin()
15932 
    while True:
15933 
      (fname, ftype, fid) = iprot.readFieldBegin()
15934 
      if ftype == TType.STOP:
15935 
        break
15936 
      if fid == 1:
15937 
        if ftype == TType.I64:
15938 
          self.providerId = iprot.readI64();
15939 
        else:
15940 
          iprot.skip(ftype)
15941 
      elif fid == 2:
15942 
        if ftype == TType.MAP:
15943 
          self.local_connected_orders = {}
6188 rajveer 15944 
          (_ktype360, _vtype361, _size359 ) = iprot.readMapBegin()
15945 
          for _i363 in xrange(_size359):
15946 
            _key364 = iprot.readString();
15947 
            _val365 = iprot.readString();
15948 
            self.local_connected_orders[_key364] = _val365
4910 phani.kuma 15949 
          iprot.readMapEnd()
15950 
        else:
15951 
          iprot.skip(ftype)
15952 
      else:
15953 
        iprot.skip(ftype)
15954 
      iprot.readFieldEnd()
15955 
    iprot.readStructEnd()
15956 
 
15957 
  def write(self, oprot):
15958 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15959 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15960 
      return
15961 
    oprot.writeStructBegin('markOrdersAsLocalConnected_args')
15962 
    if self.providerId is not None:
15963 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
15964 
      oprot.writeI64(self.providerId)
15965 
      oprot.writeFieldEnd()
15966 
    if self.local_connected_orders is not None:
15967 
      oprot.writeFieldBegin('local_connected_orders', TType.MAP, 2)
15968 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.local_connected_orders))
6188 rajveer 15969 
      for kiter366,viter367 in self.local_connected_orders.items():
15970 
        oprot.writeString(kiter366)
15971 
        oprot.writeString(viter367)
4910 phani.kuma 15972 
      oprot.writeMapEnd()
15973 
      oprot.writeFieldEnd()
15974 
    oprot.writeFieldStop()
15975 
    oprot.writeStructEnd()
15976 
 
15977 
  def validate(self):
15978 
    return
15979 
 
15980 
 
15981 
  def __repr__(self):
15982 
    L = ['%s=%r' % (key, value)
15983 
      for key, value in self.__dict__.iteritems()]
15984 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15985 
 
15986 
  def __eq__(self, other):
15987 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15988 
 
15989 
  def __ne__(self, other):
15990 
    return not (self == other)
15991 
 
15992 
class markOrdersAsLocalConnected_result:
15993 
  """
15994 
  Attributes:
15995 
   - ex
15996 
  """
15997 
 
15998 
  thrift_spec = (
15999 
    None, # 0
16000 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
16001 
  )
16002 
 
16003 
  def __init__(self, ex=None,):
16004 
    self.ex = ex
16005 
 
16006 
  def read(self, iprot):
16007 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16008 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16009 
      return
16010 
    iprot.readStructBegin()
16011 
    while True:
16012 
      (fname, ftype, fid) = iprot.readFieldBegin()
16013 
      if ftype == TType.STOP:
16014 
        break
16015 
      if fid == 1:
3064 chandransh 16016 
        if ftype == TType.STRUCT:
16017 
          self.ex = TransactionServiceException()
16018 
          self.ex.read(iprot)
1627 ankur.sing 16019 
        else:
16020 
          iprot.skip(ftype)
16021 
      else:
16022 
        iprot.skip(ftype)
16023 
      iprot.readFieldEnd()
16024 
    iprot.readStructEnd()
16025 
 
16026 
  def write(self, oprot):
16027 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16028 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16029 
      return
4910 phani.kuma 16030 
    oprot.writeStructBegin('markOrdersAsLocalConnected_result')
16031 
    if self.ex is not None:
16032 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
16033 
      self.ex.write(oprot)
16034 
      oprot.writeFieldEnd()
16035 
    oprot.writeFieldStop()
16036 
    oprot.writeStructEnd()
16037 
 
16038 
  def validate(self):
16039 
    return
16040 
 
16041 
 
16042 
  def __repr__(self):
16043 
    L = ['%s=%r' % (key, value)
16044 
      for key, value in self.__dict__.iteritems()]
16045 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16046 
 
16047 
  def __eq__(self, other):
16048 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16049 
 
16050 
  def __ne__(self, other):
16051 
    return not (self == other)
16052 
 
16053 
class getOrdersNotLocalConnected_args:
16054 
  """
16055 
  Attributes:
16056 
   - providerId
16057 
  """
16058 
 
16059 
  thrift_spec = (
16060 
    None, # 0
16061 
    (1, TType.I64, 'providerId', None, None, ), # 1
16062 
  )
16063 
 
16064 
  def __init__(self, providerId=None,):
16065 
    self.providerId = providerId
16066 
 
16067 
  def read(self, iprot):
16068 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16069 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16070 
      return
16071 
    iprot.readStructBegin()
16072 
    while True:
16073 
      (fname, ftype, fid) = iprot.readFieldBegin()
16074 
      if ftype == TType.STOP:
16075 
        break
16076 
      if fid == 1:
16077 
        if ftype == TType.I64:
16078 
          self.providerId = iprot.readI64();
16079 
        else:
16080 
          iprot.skip(ftype)
16081 
      else:
16082 
        iprot.skip(ftype)
16083 
      iprot.readFieldEnd()
16084 
    iprot.readStructEnd()
16085 
 
16086 
  def write(self, oprot):
16087 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16088 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16089 
      return
16090 
    oprot.writeStructBegin('getOrdersNotLocalConnected_args')
16091 
    if self.providerId is not None:
16092 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
16093 
      oprot.writeI64(self.providerId)
16094 
      oprot.writeFieldEnd()
16095 
    oprot.writeFieldStop()
16096 
    oprot.writeStructEnd()
16097 
 
16098 
  def validate(self):
16099 
    return
16100 
 
16101 
 
16102 
  def __repr__(self):
16103 
    L = ['%s=%r' % (key, value)
16104 
      for key, value in self.__dict__.iteritems()]
16105 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16106 
 
16107 
  def __eq__(self, other):
16108 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16109 
 
16110 
  def __ne__(self, other):
16111 
    return not (self == other)
16112 
 
16113 
class getOrdersNotLocalConnected_result:
16114 
  """
16115 
  Attributes:
16116 
   - success
16117 
  """
16118 
 
16119 
  thrift_spec = (
16120 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
16121 
  )
16122 
 
16123 
  def __init__(self, success=None,):
16124 
    self.success = success
16125 
 
16126 
  def read(self, iprot):
16127 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16128 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16129 
      return
16130 
    iprot.readStructBegin()
16131 
    while True:
16132 
      (fname, ftype, fid) = iprot.readFieldBegin()
16133 
      if ftype == TType.STOP:
16134 
        break
16135 
      if fid == 0:
16136 
        if ftype == TType.LIST:
16137 
          self.success = []
6188 rajveer 16138 
          (_etype371, _size368) = iprot.readListBegin()
16139 
          for _i372 in xrange(_size368):
16140 
            _elem373 = Order()
16141 
            _elem373.read(iprot)
16142 
            self.success.append(_elem373)
4910 phani.kuma 16143 
          iprot.readListEnd()
16144 
        else:
16145 
          iprot.skip(ftype)
16146 
      else:
16147 
        iprot.skip(ftype)
16148 
      iprot.readFieldEnd()
16149 
    iprot.readStructEnd()
16150 
 
16151 
  def write(self, oprot):
16152 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16153 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16154 
      return
16155 
    oprot.writeStructBegin('getOrdersNotLocalConnected_result')
4581 phani.kuma 16156 
    if self.success is not None:
16157 
      oprot.writeFieldBegin('success', TType.LIST, 0)
16158 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 16159 
      for iter374 in self.success:
16160 
        iter374.write(oprot)
4581 phani.kuma 16161 
      oprot.writeListEnd()
16162 
      oprot.writeFieldEnd()
4910 phani.kuma 16163 
    oprot.writeFieldStop()
16164 
    oprot.writeStructEnd()
16165 
 
16166 
  def validate(self):
16167 
    return
16168 
 
16169 
 
16170 
  def __repr__(self):
16171 
    L = ['%s=%r' % (key, value)
16172 
      for key, value in self.__dict__.iteritems()]
16173 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16174 
 
16175 
  def __eq__(self, other):
16176 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16177 
 
16178 
  def __ne__(self, other):
16179 
    return not (self == other)
16180 
 
16181 
class markOrdersAsDestinationCityReached_args:
16182 
  """
16183 
  Attributes:
16184 
   - providerId
16185 
   - destination_city_reached_orders
16186 
  """
16187 
 
16188 
  thrift_spec = (
16189 
    None, # 0
16190 
    (1, TType.I64, 'providerId', None, None, ), # 1
16191 
    (2, TType.MAP, 'destination_city_reached_orders', (TType.STRING,None,TType.STRING,None), None, ), # 2
16192 
  )
16193 
 
16194 
  def __init__(self, providerId=None, destination_city_reached_orders=None,):
16195 
    self.providerId = providerId
16196 
    self.destination_city_reached_orders = destination_city_reached_orders
16197 
 
16198 
  def read(self, iprot):
16199 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16200 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16201 
      return
16202 
    iprot.readStructBegin()
16203 
    while True:
16204 
      (fname, ftype, fid) = iprot.readFieldBegin()
16205 
      if ftype == TType.STOP:
16206 
        break
16207 
      if fid == 1:
16208 
        if ftype == TType.I64:
16209 
          self.providerId = iprot.readI64();
16210 
        else:
16211 
          iprot.skip(ftype)
16212 
      elif fid == 2:
16213 
        if ftype == TType.MAP:
16214 
          self.destination_city_reached_orders = {}
6188 rajveer 16215 
          (_ktype376, _vtype377, _size375 ) = iprot.readMapBegin()
16216 
          for _i379 in xrange(_size375):
16217 
            _key380 = iprot.readString();
16218 
            _val381 = iprot.readString();
16219 
            self.destination_city_reached_orders[_key380] = _val381
4910 phani.kuma 16220 
          iprot.readMapEnd()
16221 
        else:
16222 
          iprot.skip(ftype)
16223 
      else:
16224 
        iprot.skip(ftype)
16225 
      iprot.readFieldEnd()
16226 
    iprot.readStructEnd()
16227 
 
16228 
  def write(self, oprot):
16229 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16230 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16231 
      return
16232 
    oprot.writeStructBegin('markOrdersAsDestinationCityReached_args')
16233 
    if self.providerId is not None:
16234 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
16235 
      oprot.writeI64(self.providerId)
16236 
      oprot.writeFieldEnd()
16237 
    if self.destination_city_reached_orders is not None:
16238 
      oprot.writeFieldBegin('destination_city_reached_orders', TType.MAP, 2)
16239 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.destination_city_reached_orders))
6188 rajveer 16240 
      for kiter382,viter383 in self.destination_city_reached_orders.items():
16241 
        oprot.writeString(kiter382)
16242 
        oprot.writeString(viter383)
4910 phani.kuma 16243 
      oprot.writeMapEnd()
16244 
      oprot.writeFieldEnd()
16245 
    oprot.writeFieldStop()
16246 
    oprot.writeStructEnd()
16247 
 
16248 
  def validate(self):
16249 
    return
16250 
 
16251 
 
16252 
  def __repr__(self):
16253 
    L = ['%s=%r' % (key, value)
16254 
      for key, value in self.__dict__.iteritems()]
16255 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16256 
 
16257 
  def __eq__(self, other):
16258 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16259 
 
16260 
  def __ne__(self, other):
16261 
    return not (self == other)
16262 
 
16263 
class markOrdersAsDestinationCityReached_result:
16264 
  """
16265 
  Attributes:
16266 
   - ex
16267 
  """
16268 
 
16269 
  thrift_spec = (
16270 
    None, # 0
16271 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
16272 
  )
16273 
 
16274 
  def __init__(self, ex=None,):
16275 
    self.ex = ex
16276 
 
16277 
  def read(self, iprot):
16278 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16279 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16280 
      return
16281 
    iprot.readStructBegin()
16282 
    while True:
16283 
      (fname, ftype, fid) = iprot.readFieldBegin()
16284 
      if ftype == TType.STOP:
16285 
        break
16286 
      if fid == 1:
16287 
        if ftype == TType.STRUCT:
16288 
          self.ex = TransactionServiceException()
16289 
          self.ex.read(iprot)
16290 
        else:
16291 
          iprot.skip(ftype)
16292 
      else:
16293 
        iprot.skip(ftype)
16294 
      iprot.readFieldEnd()
16295 
    iprot.readStructEnd()
16296 
 
16297 
  def write(self, oprot):
16298 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16299 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16300 
      return
16301 
    oprot.writeStructBegin('markOrdersAsDestinationCityReached_result')
3431 rajveer 16302 
    if self.ex is not None:
3064 chandransh 16303 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
16304 
      self.ex.write(oprot)
1627 ankur.sing 16305 
      oprot.writeFieldEnd()
16306 
    oprot.writeFieldStop()
16307 
    oprot.writeStructEnd()
16308 
 
3431 rajveer 16309 
  def validate(self):
16310 
    return
16311 
 
16312 
 
1627 ankur.sing 16313 
  def __repr__(self):
16314 
    L = ['%s=%r' % (key, value)
16315 
      for key, value in self.__dict__.iteritems()]
16316 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16317 
 
16318 
  def __eq__(self, other):
16319 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16320 
 
16321 
  def __ne__(self, other):
16322 
    return not (self == other)
16323 
 
4910 phani.kuma 16324 
class markOrdersAsFirstDeliveryAttempted_args:
16325 
  """
16326 
  Attributes:
16327 
   - providerId
16328 
   - first_atdl_orders
16329 
  """
16330 
 
16331 
  thrift_spec = (
16332 
    None, # 0
16333 
    (1, TType.I64, 'providerId', None, None, ), # 1
16334 
    (2, TType.MAP, 'first_atdl_orders', (TType.STRING,None,TType.STRING,None), None, ), # 2
16335 
  )
16336 
 
16337 
  def __init__(self, providerId=None, first_atdl_orders=None,):
16338 
    self.providerId = providerId
16339 
    self.first_atdl_orders = first_atdl_orders
16340 
 
16341 
  def read(self, iprot):
16342 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16343 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16344 
      return
16345 
    iprot.readStructBegin()
16346 
    while True:
16347 
      (fname, ftype, fid) = iprot.readFieldBegin()
16348 
      if ftype == TType.STOP:
16349 
        break
16350 
      if fid == 1:
16351 
        if ftype == TType.I64:
16352 
          self.providerId = iprot.readI64();
16353 
        else:
16354 
          iprot.skip(ftype)
16355 
      elif fid == 2:
16356 
        if ftype == TType.MAP:
16357 
          self.first_atdl_orders = {}
6188 rajveer 16358 
          (_ktype385, _vtype386, _size384 ) = iprot.readMapBegin()
16359 
          for _i388 in xrange(_size384):
16360 
            _key389 = iprot.readString();
16361 
            _val390 = iprot.readString();
16362 
            self.first_atdl_orders[_key389] = _val390
4910 phani.kuma 16363 
          iprot.readMapEnd()
16364 
        else:
16365 
          iprot.skip(ftype)
16366 
      else:
16367 
        iprot.skip(ftype)
16368 
      iprot.readFieldEnd()
16369 
    iprot.readStructEnd()
16370 
 
16371 
  def write(self, oprot):
16372 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16373 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16374 
      return
16375 
    oprot.writeStructBegin('markOrdersAsFirstDeliveryAttempted_args')
16376 
    if self.providerId is not None:
16377 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
16378 
      oprot.writeI64(self.providerId)
16379 
      oprot.writeFieldEnd()
16380 
    if self.first_atdl_orders is not None:
16381 
      oprot.writeFieldBegin('first_atdl_orders', TType.MAP, 2)
16382 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.first_atdl_orders))
6188 rajveer 16383 
      for kiter391,viter392 in self.first_atdl_orders.items():
16384 
        oprot.writeString(kiter391)
16385 
        oprot.writeString(viter392)
4910 phani.kuma 16386 
      oprot.writeMapEnd()
16387 
      oprot.writeFieldEnd()
16388 
    oprot.writeFieldStop()
16389 
    oprot.writeStructEnd()
16390 
 
16391 
  def validate(self):
16392 
    return
16393 
 
16394 
 
16395 
  def __repr__(self):
16396 
    L = ['%s=%r' % (key, value)
16397 
      for key, value in self.__dict__.iteritems()]
16398 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16399 
 
16400 
  def __eq__(self, other):
16401 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16402 
 
16403 
  def __ne__(self, other):
16404 
    return not (self == other)
16405 
 
16406 
class markOrdersAsFirstDeliveryAttempted_result:
16407 
  """
16408 
  Attributes:
16409 
   - ex
16410 
  """
16411 
 
16412 
  thrift_spec = (
16413 
    None, # 0
16414 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
16415 
  )
16416 
 
16417 
  def __init__(self, ex=None,):
16418 
    self.ex = ex
16419 
 
16420 
  def read(self, iprot):
16421 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16422 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16423 
      return
16424 
    iprot.readStructBegin()
16425 
    while True:
16426 
      (fname, ftype, fid) = iprot.readFieldBegin()
16427 
      if ftype == TType.STOP:
16428 
        break
16429 
      if fid == 1:
16430 
        if ftype == TType.STRUCT:
16431 
          self.ex = TransactionServiceException()
16432 
          self.ex.read(iprot)
16433 
        else:
16434 
          iprot.skip(ftype)
16435 
      else:
16436 
        iprot.skip(ftype)
16437 
      iprot.readFieldEnd()
16438 
    iprot.readStructEnd()
16439 
 
16440 
  def write(self, oprot):
16441 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16442 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16443 
      return
16444 
    oprot.writeStructBegin('markOrdersAsFirstDeliveryAttempted_result')
16445 
    if self.ex is not None:
16446 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
16447 
      self.ex.write(oprot)
16448 
      oprot.writeFieldEnd()
16449 
    oprot.writeFieldStop()
16450 
    oprot.writeStructEnd()
16451 
 
16452 
  def validate(self):
16453 
    return
16454 
 
16455 
 
16456 
  def __repr__(self):
16457 
    L = ['%s=%r' % (key, value)
16458 
      for key, value in self.__dict__.iteritems()]
16459 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16460 
 
16461 
  def __eq__(self, other):
16462 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16463 
 
16464 
  def __ne__(self, other):
16465 
    return not (self == other)
16466 
 
3064 chandransh 16467 
class getUndeliveredOrders_args:
1886 ankur.sing 16468 
  """
16469 
  Attributes:
3064 chandransh 16470 
   - providerId
16471 
   - warehouseId
1886 ankur.sing 16472 
  """
1627 ankur.sing 16473 
 
1886 ankur.sing 16474 
  thrift_spec = (
16475 
    None, # 0
3064 chandransh 16476 
    (1, TType.I64, 'providerId', None, None, ), # 1
16477 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
1886 ankur.sing 16478 
  )
16479 
 
3064 chandransh 16480 
  def __init__(self, providerId=None, warehouseId=None,):
16481 
    self.providerId = providerId
16482 
    self.warehouseId = warehouseId
1886 ankur.sing 16483 
 
16484 
  def read(self, iprot):
16485 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16486 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16487 
      return
16488 
    iprot.readStructBegin()
16489 
    while True:
16490 
      (fname, ftype, fid) = iprot.readFieldBegin()
16491 
      if ftype == TType.STOP:
16492 
        break
16493 
      if fid == 1:
16494 
        if ftype == TType.I64:
3064 chandransh 16495 
          self.providerId = iprot.readI64();
1886 ankur.sing 16496 
        else:
16497 
          iprot.skip(ftype)
3064 chandransh 16498 
      elif fid == 2:
16499 
        if ftype == TType.I64:
16500 
          self.warehouseId = iprot.readI64();
16501 
        else:
16502 
          iprot.skip(ftype)
1886 ankur.sing 16503 
      else:
16504 
        iprot.skip(ftype)
16505 
      iprot.readFieldEnd()
16506 
    iprot.readStructEnd()
16507 
 
16508 
  def write(self, oprot):
16509 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16510 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16511 
      return
3064 chandransh 16512 
    oprot.writeStructBegin('getUndeliveredOrders_args')
3431 rajveer 16513 
    if self.providerId is not None:
3064 chandransh 16514 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
16515 
      oprot.writeI64(self.providerId)
1886 ankur.sing 16516 
      oprot.writeFieldEnd()
3431 rajveer 16517 
    if self.warehouseId is not None:
3064 chandransh 16518 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
16519 
      oprot.writeI64(self.warehouseId)
16520 
      oprot.writeFieldEnd()
1886 ankur.sing 16521 
    oprot.writeFieldStop()
16522 
    oprot.writeStructEnd()
16523 
 
3431 rajveer 16524 
  def validate(self):
16525 
    return
16526 
 
16527 
 
1886 ankur.sing 16528 
  def __repr__(self):
16529 
    L = ['%s=%r' % (key, value)
16530 
      for key, value in self.__dict__.iteritems()]
16531 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16532 
 
16533 
  def __eq__(self, other):
16534 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16535 
 
16536 
  def __ne__(self, other):
16537 
    return not (self == other)
16538 
 
3064 chandransh 16539 
class getUndeliveredOrders_result:
1886 ankur.sing 16540 
  """
16541 
  Attributes:
16542 
   - success
16543 
  """
16544 
 
16545 
  thrift_spec = (
16546 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
16547 
  )
16548 
 
16549 
  def __init__(self, success=None,):
16550 
    self.success = success
16551 
 
16552 
  def read(self, iprot):
16553 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16554 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16555 
      return
16556 
    iprot.readStructBegin()
16557 
    while True:
16558 
      (fname, ftype, fid) = iprot.readFieldBegin()
16559 
      if ftype == TType.STOP:
16560 
        break
16561 
      if fid == 0:
16562 
        if ftype == TType.LIST:
16563 
          self.success = []
6188 rajveer 16564 
          (_etype396, _size393) = iprot.readListBegin()
16565 
          for _i397 in xrange(_size393):
16566 
            _elem398 = Order()
16567 
            _elem398.read(iprot)
16568 
            self.success.append(_elem398)
1886 ankur.sing 16569 
          iprot.readListEnd()
16570 
        else:
16571 
          iprot.skip(ftype)
16572 
      else:
16573 
        iprot.skip(ftype)
16574 
      iprot.readFieldEnd()
16575 
    iprot.readStructEnd()
16576 
 
16577 
  def write(self, oprot):
16578 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16579 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16580 
      return
3064 chandransh 16581 
    oprot.writeStructBegin('getUndeliveredOrders_result')
3431 rajveer 16582 
    if self.success is not None:
1886 ankur.sing 16583 
      oprot.writeFieldBegin('success', TType.LIST, 0)
16584 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 16585 
      for iter399 in self.success:
16586 
        iter399.write(oprot)
1886 ankur.sing 16587 
      oprot.writeListEnd()
16588 
      oprot.writeFieldEnd()
16589 
    oprot.writeFieldStop()
16590 
    oprot.writeStructEnd()
16591 
 
3431 rajveer 16592 
  def validate(self):
16593 
    return
16594 
 
16595 
 
1886 ankur.sing 16596 
  def __repr__(self):
16597 
    L = ['%s=%r' % (key, value)
16598 
      for key, value in self.__dict__.iteritems()]
16599 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16600 
 
16601 
  def __eq__(self, other):
16602 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16603 
 
16604 
  def __ne__(self, other):
16605 
    return not (self == other)
16606 
 
4783 phani.kuma 16607 
class getUndeliveredOrdersExpectedDeliveryDateNotMet_args:
16608 
 
16609 
  thrift_spec = (
16610 
  )
16611 
 
16612 
  def read(self, iprot):
16613 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16614 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16615 
      return
16616 
    iprot.readStructBegin()
16617 
    while True:
16618 
      (fname, ftype, fid) = iprot.readFieldBegin()
16619 
      if ftype == TType.STOP:
16620 
        break
16621 
      else:
16622 
        iprot.skip(ftype)
16623 
      iprot.readFieldEnd()
16624 
    iprot.readStructEnd()
16625 
 
16626 
  def write(self, oprot):
16627 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16628 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16629 
      return
16630 
    oprot.writeStructBegin('getUndeliveredOrdersExpectedDeliveryDateNotMet_args')
16631 
    oprot.writeFieldStop()
16632 
    oprot.writeStructEnd()
16633 
 
16634 
  def validate(self):
16635 
    return
16636 
 
16637 
 
16638 
  def __repr__(self):
16639 
    L = ['%s=%r' % (key, value)
16640 
      for key, value in self.__dict__.iteritems()]
16641 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16642 
 
16643 
  def __eq__(self, other):
16644 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16645 
 
16646 
  def __ne__(self, other):
16647 
    return not (self == other)
16648 
 
16649 
class getUndeliveredOrdersExpectedDeliveryDateNotMet_result:
16650 
  """
16651 
  Attributes:
16652 
   - success
16653 
  """
16654 
 
16655 
  thrift_spec = (
16656 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
16657 
  )
16658 
 
16659 
  def __init__(self, success=None,):
16660 
    self.success = success
16661 
 
16662 
  def read(self, iprot):
16663 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16664 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16665 
      return
16666 
    iprot.readStructBegin()
16667 
    while True:
16668 
      (fname, ftype, fid) = iprot.readFieldBegin()
16669 
      if ftype == TType.STOP:
16670 
        break
16671 
      if fid == 0:
16672 
        if ftype == TType.LIST:
16673 
          self.success = []
6188 rajveer 16674 
          (_etype403, _size400) = iprot.readListBegin()
16675 
          for _i404 in xrange(_size400):
16676 
            _elem405 = Order()
16677 
            _elem405.read(iprot)
16678 
            self.success.append(_elem405)
4783 phani.kuma 16679 
          iprot.readListEnd()
16680 
        else:
16681 
          iprot.skip(ftype)
16682 
      else:
16683 
        iprot.skip(ftype)
16684 
      iprot.readFieldEnd()
16685 
    iprot.readStructEnd()
16686 
 
16687 
  def write(self, oprot):
16688 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16689 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16690 
      return
16691 
    oprot.writeStructBegin('getUndeliveredOrdersExpectedDeliveryDateNotMet_result')
16692 
    if self.success is not None:
16693 
      oprot.writeFieldBegin('success', TType.LIST, 0)
16694 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 16695 
      for iter406 in self.success:
16696 
        iter406.write(oprot)
4783 phani.kuma 16697 
      oprot.writeListEnd()
16698 
      oprot.writeFieldEnd()
16699 
    oprot.writeFieldStop()
16700 
    oprot.writeStructEnd()
16701 
 
16702 
  def validate(self):
16703 
    return
16704 
 
16705 
 
16706 
  def __repr__(self):
16707 
    L = ['%s=%r' % (key, value)
16708 
      for key, value in self.__dict__.iteritems()]
16709 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16710 
 
16711 
  def __eq__(self, other):
16712 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16713 
 
16714 
  def __ne__(self, other):
16715 
    return not (self == other)
16716 
 
2536 chandransh 16717 
class toggleDOAFlag_args:
16718 
  """
16719 
  Attributes:
16720 
   - orderId
16721 
  """
1886 ankur.sing 16722 
 
2536 chandransh 16723 
  thrift_spec = (
16724 
    None, # 0
16725 
    (1, TType.I64, 'orderId', None, None, ), # 1
16726 
  )
16727 
 
16728 
  def __init__(self, orderId=None,):
16729 
    self.orderId = orderId
16730 
 
16731 
  def read(self, iprot):
16732 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16733 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16734 
      return
16735 
    iprot.readStructBegin()
16736 
    while True:
16737 
      (fname, ftype, fid) = iprot.readFieldBegin()
16738 
      if ftype == TType.STOP:
16739 
        break
16740 
      if fid == 1:
16741 
        if ftype == TType.I64:
16742 
          self.orderId = iprot.readI64();
16743 
        else:
16744 
          iprot.skip(ftype)
16745 
      else:
16746 
        iprot.skip(ftype)
16747 
      iprot.readFieldEnd()
16748 
    iprot.readStructEnd()
16749 
 
16750 
  def write(self, oprot):
16751 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16752 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16753 
      return
16754 
    oprot.writeStructBegin('toggleDOAFlag_args')
3431 rajveer 16755 
    if self.orderId is not None:
2536 chandransh 16756 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
16757 
      oprot.writeI64(self.orderId)
16758 
      oprot.writeFieldEnd()
16759 
    oprot.writeFieldStop()
16760 
    oprot.writeStructEnd()
16761 
 
3431 rajveer 16762 
  def validate(self):
16763 
    return
16764 
 
16765 
 
2536 chandransh 16766 
  def __repr__(self):
16767 
    L = ['%s=%r' % (key, value)
16768 
      for key, value in self.__dict__.iteritems()]
16769 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16770 
 
16771 
  def __eq__(self, other):
16772 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16773 
 
16774 
  def __ne__(self, other):
16775 
    return not (self == other)
16776 
 
16777 
class toggleDOAFlag_result:
16778 
  """
16779 
  Attributes:
16780 
   - success
16781 
   - ex
16782 
  """
16783 
 
16784 
  thrift_spec = (
16785 
    (0, TType.BOOL, 'success', None, None, ), # 0
16786 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
16787 
  )
16788 
 
16789 
  def __init__(self, success=None, ex=None,):
16790 
    self.success = success
16791 
    self.ex = ex
16792 
 
16793 
  def read(self, iprot):
16794 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16795 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16796 
      return
16797 
    iprot.readStructBegin()
16798 
    while True:
16799 
      (fname, ftype, fid) = iprot.readFieldBegin()
16800 
      if ftype == TType.STOP:
16801 
        break
16802 
      if fid == 0:
16803 
        if ftype == TType.BOOL:
16804 
          self.success = iprot.readBool();
16805 
        else:
16806 
          iprot.skip(ftype)
16807 
      elif fid == 1:
16808 
        if ftype == TType.STRUCT:
16809 
          self.ex = TransactionServiceException()
16810 
          self.ex.read(iprot)
16811 
        else:
16812 
          iprot.skip(ftype)
16813 
      else:
16814 
        iprot.skip(ftype)
16815 
      iprot.readFieldEnd()
16816 
    iprot.readStructEnd()
16817 
 
16818 
  def write(self, oprot):
16819 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16820 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16821 
      return
16822 
    oprot.writeStructBegin('toggleDOAFlag_result')
3431 rajveer 16823 
    if self.success is not None:
2536 chandransh 16824 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
16825 
      oprot.writeBool(self.success)
16826 
      oprot.writeFieldEnd()
3431 rajveer 16827 
    if self.ex is not None:
2536 chandransh 16828 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
16829 
      self.ex.write(oprot)
16830 
      oprot.writeFieldEnd()
16831 
    oprot.writeFieldStop()
16832 
    oprot.writeStructEnd()
16833 
 
3431 rajveer 16834 
  def validate(self):
16835 
    return
16836 
 
16837 
 
2536 chandransh 16838 
  def __repr__(self):
16839 
    L = ['%s=%r' % (key, value)
16840 
      for key, value in self.__dict__.iteritems()]
16841 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16842 
 
16843 
  def __eq__(self, other):
16844 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16845 
 
16846 
  def __ne__(self, other):
16847 
    return not (self == other)
16848 
 
4712 rajveer 16849 
class markOrderAsDelivered_args:
16850 
  """
16851 
  Attributes:
16852 
   - orderId
16853 
   - deliveryTimestamp
16854 
   - receiver
16855 
  """
16856 
 
16857 
  thrift_spec = None
16858 
  def __init__(self, orderId=None, deliveryTimestamp=None, receiver=None,):
16859 
    self.orderId = orderId
16860 
    self.deliveryTimestamp = deliveryTimestamp
16861 
    self.receiver = receiver
16862 
 
16863 
  def read(self, iprot):
16864 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16865 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16866 
      return
16867 
    iprot.readStructBegin()
16868 
    while True:
16869 
      (fname, ftype, fid) = iprot.readFieldBegin()
16870 
      if ftype == TType.STOP:
16871 
        break
16872 
      if fid == 1:
16873 
        if ftype == TType.I64:
16874 
          self.orderId = iprot.readI64();
16875 
        else:
16876 
          iprot.skip(ftype)
16877 
      elif fid == 2:
16878 
        if ftype == TType.I64:
16879 
          self.deliveryTimestamp = iprot.readI64();
16880 
        else:
16881 
          iprot.skip(ftype)
16882 
      elif fid == -1:
16883 
        if ftype == TType.STRING:
16884 
          self.receiver = iprot.readString();
16885 
        else:
16886 
          iprot.skip(ftype)
16887 
      else:
16888 
        iprot.skip(ftype)
16889 
      iprot.readFieldEnd()
16890 
    iprot.readStructEnd()
16891 
 
16892 
  def write(self, oprot):
16893 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16894 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16895 
      return
16896 
    oprot.writeStructBegin('markOrderAsDelivered_args')
16897 
    if self.receiver is not None:
16898 
      oprot.writeFieldBegin('receiver', TType.STRING, -1)
16899 
      oprot.writeString(self.receiver)
16900 
      oprot.writeFieldEnd()
16901 
    if self.orderId is not None:
16902 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
16903 
      oprot.writeI64(self.orderId)
16904 
      oprot.writeFieldEnd()
16905 
    if self.deliveryTimestamp is not None:
16906 
      oprot.writeFieldBegin('deliveryTimestamp', TType.I64, 2)
16907 
      oprot.writeI64(self.deliveryTimestamp)
16908 
      oprot.writeFieldEnd()
16909 
    oprot.writeFieldStop()
16910 
    oprot.writeStructEnd()
16911 
 
16912 
  def validate(self):
16913 
    return
16914 
 
16915 
 
16916 
  def __repr__(self):
16917 
    L = ['%s=%r' % (key, value)
16918 
      for key, value in self.__dict__.iteritems()]
16919 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16920 
 
16921 
  def __eq__(self, other):
16922 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16923 
 
16924 
  def __ne__(self, other):
16925 
    return not (self == other)
16926 
 
16927 
class markOrderAsDelivered_result:
16928 
  """
16929 
  Attributes:
16930 
   - ex
16931 
  """
16932 
 
16933 
  thrift_spec = (
16934 
    None, # 0
16935 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
16936 
  )
16937 
 
16938 
  def __init__(self, ex=None,):
16939 
    self.ex = ex
16940 
 
16941 
  def read(self, iprot):
16942 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16943 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16944 
      return
16945 
    iprot.readStructBegin()
16946 
    while True:
16947 
      (fname, ftype, fid) = iprot.readFieldBegin()
16948 
      if ftype == TType.STOP:
16949 
        break
16950 
      if fid == 1:
16951 
        if ftype == TType.STRUCT:
16952 
          self.ex = TransactionServiceException()
16953 
          self.ex.read(iprot)
16954 
        else:
16955 
          iprot.skip(ftype)
16956 
      else:
16957 
        iprot.skip(ftype)
16958 
      iprot.readFieldEnd()
16959 
    iprot.readStructEnd()
16960 
 
16961 
  def write(self, oprot):
16962 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16963 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16964 
      return
16965 
    oprot.writeStructBegin('markOrderAsDelivered_result')
16966 
    if self.ex is not None:
16967 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
16968 
      self.ex.write(oprot)
16969 
      oprot.writeFieldEnd()
16970 
    oprot.writeFieldStop()
16971 
    oprot.writeStructEnd()
16972 
 
16973 
  def validate(self):
16974 
    return
16975 
 
16976 
 
16977 
  def __repr__(self):
16978 
    L = ['%s=%r' % (key, value)
16979 
      for key, value in self.__dict__.iteritems()]
16980 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16981 
 
16982 
  def __eq__(self, other):
16983 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16984 
 
16985 
  def __ne__(self, other):
16986 
    return not (self == other)
16987 
 
5553 rajveer 16988 
class markOrderAsReceivedAtStore_args:
16989 
  """
16990 
  Attributes:
16991 
   - orderId
16992 
   - deliveryTimestamp
16993 
  """
16994 
 
16995 
  thrift_spec = (
16996 
    None, # 0
16997 
    (1, TType.I64, 'orderId', None, None, ), # 1
16998 
    (2, TType.I64, 'deliveryTimestamp', None, None, ), # 2
16999 
  )
17000 
 
17001 
  def __init__(self, orderId=None, deliveryTimestamp=None,):
17002 
    self.orderId = orderId
17003 
    self.deliveryTimestamp = deliveryTimestamp
17004 
 
17005 
  def read(self, iprot):
17006 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17007 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17008 
      return
17009 
    iprot.readStructBegin()
17010 
    while True:
17011 
      (fname, ftype, fid) = iprot.readFieldBegin()
17012 
      if ftype == TType.STOP:
17013 
        break
17014 
      if fid == 1:
17015 
        if ftype == TType.I64:
17016 
          self.orderId = iprot.readI64();
17017 
        else:
17018 
          iprot.skip(ftype)
17019 
      elif fid == 2:
17020 
        if ftype == TType.I64:
17021 
          self.deliveryTimestamp = iprot.readI64();
17022 
        else:
17023 
          iprot.skip(ftype)
17024 
      else:
17025 
        iprot.skip(ftype)
17026 
      iprot.readFieldEnd()
17027 
    iprot.readStructEnd()
17028 
 
17029 
  def write(self, oprot):
17030 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17031 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17032 
      return
17033 
    oprot.writeStructBegin('markOrderAsReceivedAtStore_args')
17034 
    if self.orderId is not None:
17035 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
17036 
      oprot.writeI64(self.orderId)
17037 
      oprot.writeFieldEnd()
17038 
    if self.deliveryTimestamp is not None:
17039 
      oprot.writeFieldBegin('deliveryTimestamp', TType.I64, 2)
17040 
      oprot.writeI64(self.deliveryTimestamp)
17041 
      oprot.writeFieldEnd()
17042 
    oprot.writeFieldStop()
17043 
    oprot.writeStructEnd()
17044 
 
17045 
  def validate(self):
17046 
    return
17047 
 
17048 
 
17049 
  def __repr__(self):
17050 
    L = ['%s=%r' % (key, value)
17051 
      for key, value in self.__dict__.iteritems()]
17052 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17053 
 
17054 
  def __eq__(self, other):
17055 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17056 
 
17057 
  def __ne__(self, other):
17058 
    return not (self == other)
17059 
 
17060 
class markOrderAsReceivedAtStore_result:
17061 
  """
17062 
  Attributes:
17063 
   - ex
17064 
  """
17065 
 
17066 
  thrift_spec = (
17067 
    None, # 0
17068 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
17069 
  )
17070 
 
17071 
  def __init__(self, ex=None,):
17072 
    self.ex = ex
17073 
 
17074 
  def read(self, iprot):
17075 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17076 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17077 
      return
17078 
    iprot.readStructBegin()
17079 
    while True:
17080 
      (fname, ftype, fid) = iprot.readFieldBegin()
17081 
      if ftype == TType.STOP:
17082 
        break
17083 
      if fid == 1:
17084 
        if ftype == TType.STRUCT:
17085 
          self.ex = TransactionServiceException()
17086 
          self.ex.read(iprot)
17087 
        else:
17088 
          iprot.skip(ftype)
17089 
      else:
17090 
        iprot.skip(ftype)
17091 
      iprot.readFieldEnd()
17092 
    iprot.readStructEnd()
17093 
 
17094 
  def write(self, oprot):
17095 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17096 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17097 
      return
17098 
    oprot.writeStructBegin('markOrderAsReceivedAtStore_result')
17099 
    if self.ex is not None:
17100 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
17101 
      self.ex.write(oprot)
17102 
      oprot.writeFieldEnd()
17103 
    oprot.writeFieldStop()
17104 
    oprot.writeStructEnd()
17105 
 
17106 
  def validate(self):
17107 
    return
17108 
 
17109 
 
17110 
  def __repr__(self):
17111 
    L = ['%s=%r' % (key, value)
17112 
      for key, value in self.__dict__.iteritems()]
17113 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17114 
 
17115 
  def __eq__(self, other):
17116 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17117 
 
17118 
  def __ne__(self, other):
17119 
    return not (self == other)
17120 
 
4454 rajveer 17121 
class markOrderDoaRequestReceived_args:
17122 
  """
17123 
  Attributes:
17124 
   - orderId
17125 
  """
17126 
 
17127 
  thrift_spec = (
17128 
    None, # 0
17129 
    (1, TType.I64, 'orderId', None, None, ), # 1
17130 
  )
17131 
 
17132 
  def __init__(self, orderId=None,):
17133 
    self.orderId = orderId
17134 
 
17135 
  def read(self, iprot):
17136 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17137 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17138 
      return
17139 
    iprot.readStructBegin()
17140 
    while True:
17141 
      (fname, ftype, fid) = iprot.readFieldBegin()
17142 
      if ftype == TType.STOP:
17143 
        break
17144 
      if fid == 1:
17145 
        if ftype == TType.I64:
17146 
          self.orderId = iprot.readI64();
17147 
        else:
17148 
          iprot.skip(ftype)
17149 
      else:
17150 
        iprot.skip(ftype)
17151 
      iprot.readFieldEnd()
17152 
    iprot.readStructEnd()
17153 
 
17154 
  def write(self, oprot):
17155 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17156 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17157 
      return
17158 
    oprot.writeStructBegin('markOrderDoaRequestReceived_args')
17159 
    if self.orderId is not None:
17160 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
17161 
      oprot.writeI64(self.orderId)
17162 
      oprot.writeFieldEnd()
17163 
    oprot.writeFieldStop()
17164 
    oprot.writeStructEnd()
17165 
 
17166 
  def validate(self):
17167 
    return
17168 
 
17169 
 
17170 
  def __repr__(self):
17171 
    L = ['%s=%r' % (key, value)
17172 
      for key, value in self.__dict__.iteritems()]
17173 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17174 
 
17175 
  def __eq__(self, other):
17176 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17177 
 
17178 
  def __ne__(self, other):
17179 
    return not (self == other)
17180 
 
17181 
class markOrderDoaRequestReceived_result:
17182 
  """
17183 
  Attributes:
17184 
   - success
17185 
   - ex
17186 
  """
17187 
 
17188 
  thrift_spec = (
17189 
    (0, TType.BOOL, 'success', None, None, ), # 0
17190 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
17191 
  )
17192 
 
17193 
  def __init__(self, success=None, ex=None,):
17194 
    self.success = success
17195 
    self.ex = ex
17196 
 
17197 
  def read(self, iprot):
17198 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17199 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17200 
      return
17201 
    iprot.readStructBegin()
17202 
    while True:
17203 
      (fname, ftype, fid) = iprot.readFieldBegin()
17204 
      if ftype == TType.STOP:
17205 
        break
17206 
      if fid == 0:
17207 
        if ftype == TType.BOOL:
17208 
          self.success = iprot.readBool();
17209 
        else:
17210 
          iprot.skip(ftype)
17211 
      elif fid == 1:
17212 
        if ftype == TType.STRUCT:
17213 
          self.ex = TransactionServiceException()
17214 
          self.ex.read(iprot)
17215 
        else:
17216 
          iprot.skip(ftype)
17217 
      else:
17218 
        iprot.skip(ftype)
17219 
      iprot.readFieldEnd()
17220 
    iprot.readStructEnd()
17221 
 
17222 
  def write(self, oprot):
17223 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17224 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17225 
      return
17226 
    oprot.writeStructBegin('markOrderDoaRequestReceived_result')
17227 
    if self.success is not None:
17228 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
17229 
      oprot.writeBool(self.success)
17230 
      oprot.writeFieldEnd()
17231 
    if self.ex is not None:
17232 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
17233 
      self.ex.write(oprot)
17234 
      oprot.writeFieldEnd()
17235 
    oprot.writeFieldStop()
17236 
    oprot.writeStructEnd()
17237 
 
17238 
  def validate(self):
17239 
    return
17240 
 
17241 
 
17242 
  def __repr__(self):
17243 
    L = ['%s=%r' % (key, value)
17244 
      for key, value in self.__dict__.iteritems()]
17245 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17246 
 
17247 
  def __eq__(self, other):
17248 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17249 
 
17250 
  def __ne__(self, other):
17251 
    return not (self == other)
17252 
 
17253 
class markOrderDoaRequestAuthorized_args:
17254 
  """
17255 
  Attributes:
17256 
   - orderId
17257 
   - isAuthorized
17258 
  """
17259 
 
17260 
  thrift_spec = (
17261 
    None, # 0
17262 
    (1, TType.I64, 'orderId', None, None, ), # 1
17263 
    (2, TType.BOOL, 'isAuthorized', None, None, ), # 2
17264 
  )
17265 
 
17266 
  def __init__(self, orderId=None, isAuthorized=None,):
17267 
    self.orderId = orderId
17268 
    self.isAuthorized = isAuthorized
17269 
 
17270 
  def read(self, iprot):
17271 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17272 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17273 
      return
17274 
    iprot.readStructBegin()
17275 
    while True:
17276 
      (fname, ftype, fid) = iprot.readFieldBegin()
17277 
      if ftype == TType.STOP:
17278 
        break
17279 
      if fid == 1:
17280 
        if ftype == TType.I64:
17281 
          self.orderId = iprot.readI64();
17282 
        else:
17283 
          iprot.skip(ftype)
17284 
      elif fid == 2:
17285 
        if ftype == TType.BOOL:
17286 
          self.isAuthorized = iprot.readBool();
17287 
        else:
17288 
          iprot.skip(ftype)
17289 
      else:
17290 
        iprot.skip(ftype)
17291 
      iprot.readFieldEnd()
17292 
    iprot.readStructEnd()
17293 
 
17294 
  def write(self, oprot):
17295 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17296 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17297 
      return
17298 
    oprot.writeStructBegin('markOrderDoaRequestAuthorized_args')
17299 
    if self.orderId is not None:
17300 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
17301 
      oprot.writeI64(self.orderId)
17302 
      oprot.writeFieldEnd()
17303 
    if self.isAuthorized is not None:
17304 
      oprot.writeFieldBegin('isAuthorized', TType.BOOL, 2)
17305 
      oprot.writeBool(self.isAuthorized)
17306 
      oprot.writeFieldEnd()
17307 
    oprot.writeFieldStop()
17308 
    oprot.writeStructEnd()
17309 
 
17310 
  def validate(self):
17311 
    return
17312 
 
17313 
 
17314 
  def __repr__(self):
17315 
    L = ['%s=%r' % (key, value)
17316 
      for key, value in self.__dict__.iteritems()]
17317 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17318 
 
17319 
  def __eq__(self, other):
17320 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17321 
 
17322 
  def __ne__(self, other):
17323 
    return not (self == other)
17324 
 
17325 
class markOrderDoaRequestAuthorized_result:
17326 
  """
17327 
  Attributes:
17328 
   - success
17329 
   - ex
17330 
  """
17331 
 
17332 
  thrift_spec = (
17333 
    (0, TType.BOOL, 'success', None, None, ), # 0
17334 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
17335 
  )
17336 
 
17337 
  def __init__(self, success=None, ex=None,):
17338 
    self.success = success
17339 
    self.ex = ex
17340 
 
17341 
  def read(self, iprot):
17342 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17343 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17344 
      return
17345 
    iprot.readStructBegin()
17346 
    while True:
17347 
      (fname, ftype, fid) = iprot.readFieldBegin()
17348 
      if ftype == TType.STOP:
17349 
        break
17350 
      if fid == 0:
17351 
        if ftype == TType.BOOL:
17352 
          self.success = iprot.readBool();
17353 
        else:
17354 
          iprot.skip(ftype)
17355 
      elif fid == 1:
17356 
        if ftype == TType.STRUCT:
17357 
          self.ex = TransactionServiceException()
17358 
          self.ex.read(iprot)
17359 
        else:
17360 
          iprot.skip(ftype)
17361 
      else:
17362 
        iprot.skip(ftype)
17363 
      iprot.readFieldEnd()
17364 
    iprot.readStructEnd()
17365 
 
17366 
  def write(self, oprot):
17367 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17368 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17369 
      return
17370 
    oprot.writeStructBegin('markOrderDoaRequestAuthorized_result')
17371 
    if self.success is not None:
17372 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
17373 
      oprot.writeBool(self.success)
17374 
      oprot.writeFieldEnd()
17375 
    if self.ex is not None:
17376 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
17377 
      self.ex.write(oprot)
17378 
      oprot.writeFieldEnd()
17379 
    oprot.writeFieldStop()
17380 
    oprot.writeStructEnd()
17381 
 
17382 
  def validate(self):
17383 
    return
17384 
 
17385 
 
17386 
  def __repr__(self):
17387 
    L = ['%s=%r' % (key, value)
17388 
      for key, value in self.__dict__.iteritems()]
17389 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17390 
 
17391 
  def __eq__(self, other):
17392 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17393 
 
17394 
  def __ne__(self, other):
17395 
    return not (self == other)
17396 
 
4488 rajveer 17397 
class markOrderReturnRequestReceived_args:
17398 
  """
17399 
  Attributes:
17400 
   - orderId
17401 
  """
17402 
 
17403 
  thrift_spec = (
17404 
    None, # 0
17405 
    (1, TType.I64, 'orderId', None, None, ), # 1
17406 
  )
17407 
 
17408 
  def __init__(self, orderId=None,):
17409 
    self.orderId = orderId
17410 
 
17411 
  def read(self, iprot):
17412 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17413 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17414 
      return
17415 
    iprot.readStructBegin()
17416 
    while True:
17417 
      (fname, ftype, fid) = iprot.readFieldBegin()
17418 
      if ftype == TType.STOP:
17419 
        break
17420 
      if fid == 1:
17421 
        if ftype == TType.I64:
17422 
          self.orderId = iprot.readI64();
17423 
        else:
17424 
          iprot.skip(ftype)
17425 
      else:
17426 
        iprot.skip(ftype)
17427 
      iprot.readFieldEnd()
17428 
    iprot.readStructEnd()
17429 
 
17430 
  def write(self, oprot):
17431 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17432 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17433 
      return
17434 
    oprot.writeStructBegin('markOrderReturnRequestReceived_args')
17435 
    if self.orderId is not None:
17436 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
17437 
      oprot.writeI64(self.orderId)
17438 
      oprot.writeFieldEnd()
17439 
    oprot.writeFieldStop()
17440 
    oprot.writeStructEnd()
17441 
 
17442 
  def validate(self):
17443 
    return
17444 
 
17445 
 
17446 
  def __repr__(self):
17447 
    L = ['%s=%r' % (key, value)
17448 
      for key, value in self.__dict__.iteritems()]
17449 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17450 
 
17451 
  def __eq__(self, other):
17452 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17453 
 
17454 
  def __ne__(self, other):
17455 
    return not (self == other)
17456 
 
17457 
class markOrderReturnRequestReceived_result:
17458 
  """
17459 
  Attributes:
17460 
   - success
17461 
   - ex
17462 
  """
17463 
 
17464 
  thrift_spec = (
17465 
    (0, TType.BOOL, 'success', None, None, ), # 0
17466 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
17467 
  )
17468 
 
17469 
  def __init__(self, success=None, ex=None,):
17470 
    self.success = success
17471 
    self.ex = ex
17472 
 
17473 
  def read(self, iprot):
17474 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17475 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17476 
      return
17477 
    iprot.readStructBegin()
17478 
    while True:
17479 
      (fname, ftype, fid) = iprot.readFieldBegin()
17480 
      if ftype == TType.STOP:
17481 
        break
17482 
      if fid == 0:
17483 
        if ftype == TType.BOOL:
17484 
          self.success = iprot.readBool();
17485 
        else:
17486 
          iprot.skip(ftype)
17487 
      elif fid == 1:
17488 
        if ftype == TType.STRUCT:
17489 
          self.ex = TransactionServiceException()
17490 
          self.ex.read(iprot)
17491 
        else:
17492 
          iprot.skip(ftype)
17493 
      else:
17494 
        iprot.skip(ftype)
17495 
      iprot.readFieldEnd()
17496 
    iprot.readStructEnd()
17497 
 
17498 
  def write(self, oprot):
17499 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17500 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17501 
      return
17502 
    oprot.writeStructBegin('markOrderReturnRequestReceived_result')
17503 
    if self.success is not None:
17504 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
17505 
      oprot.writeBool(self.success)
17506 
      oprot.writeFieldEnd()
17507 
    if self.ex is not None:
17508 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
17509 
      self.ex.write(oprot)
17510 
      oprot.writeFieldEnd()
17511 
    oprot.writeFieldStop()
17512 
    oprot.writeStructEnd()
17513 
 
17514 
  def validate(self):
17515 
    return
17516 
 
17517 
 
17518 
  def __repr__(self):
17519 
    L = ['%s=%r' % (key, value)
17520 
      for key, value in self.__dict__.iteritems()]
17521 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17522 
 
17523 
  def __eq__(self, other):
17524 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17525 
 
17526 
  def __ne__(self, other):
17527 
    return not (self == other)
17528 
 
17529 
class markOrderReturnRequestAuthorized_args:
17530 
  """
17531 
  Attributes:
17532 
   - orderId
17533 
   - isAuthorized
17534 
  """
17535 
 
17536 
  thrift_spec = (
17537 
    None, # 0
17538 
    (1, TType.I64, 'orderId', None, None, ), # 1
17539 
    (2, TType.BOOL, 'isAuthorized', None, None, ), # 2
17540 
  )
17541 
 
17542 
  def __init__(self, orderId=None, isAuthorized=None,):
17543 
    self.orderId = orderId
17544 
    self.isAuthorized = isAuthorized
17545 
 
17546 
  def read(self, iprot):
17547 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17548 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17549 
      return
17550 
    iprot.readStructBegin()
17551 
    while True:
17552 
      (fname, ftype, fid) = iprot.readFieldBegin()
17553 
      if ftype == TType.STOP:
17554 
        break
17555 
      if fid == 1:
17556 
        if ftype == TType.I64:
17557 
          self.orderId = iprot.readI64();
17558 
        else:
17559 
          iprot.skip(ftype)
17560 
      elif fid == 2:
17561 
        if ftype == TType.BOOL:
17562 
          self.isAuthorized = iprot.readBool();
17563 
        else:
17564 
          iprot.skip(ftype)
17565 
      else:
17566 
        iprot.skip(ftype)
17567 
      iprot.readFieldEnd()
17568 
    iprot.readStructEnd()
17569 
 
17570 
  def write(self, oprot):
17571 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17572 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17573 
      return
17574 
    oprot.writeStructBegin('markOrderReturnRequestAuthorized_args')
17575 
    if self.orderId is not None:
17576 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
17577 
      oprot.writeI64(self.orderId)
17578 
      oprot.writeFieldEnd()
17579 
    if self.isAuthorized is not None:
17580 
      oprot.writeFieldBegin('isAuthorized', TType.BOOL, 2)
17581 
      oprot.writeBool(self.isAuthorized)
17582 
      oprot.writeFieldEnd()
17583 
    oprot.writeFieldStop()
17584 
    oprot.writeStructEnd()
17585 
 
17586 
  def validate(self):
17587 
    return
17588 
 
17589 
 
17590 
  def __repr__(self):
17591 
    L = ['%s=%r' % (key, value)
17592 
      for key, value in self.__dict__.iteritems()]
17593 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17594 
 
17595 
  def __eq__(self, other):
17596 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17597 
 
17598 
  def __ne__(self, other):
17599 
    return not (self == other)
17600 
 
17601 
class markOrderReturnRequestAuthorized_result:
17602 
  """
17603 
  Attributes:
17604 
   - success
17605 
   - ex
17606 
  """
17607 
 
17608 
  thrift_spec = (
17609 
    (0, TType.BOOL, 'success', None, None, ), # 0
17610 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
17611 
  )
17612 
 
17613 
  def __init__(self, success=None, ex=None,):
17614 
    self.success = success
17615 
    self.ex = ex
17616 
 
17617 
  def read(self, iprot):
17618 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17619 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17620 
      return
17621 
    iprot.readStructBegin()
17622 
    while True:
17623 
      (fname, ftype, fid) = iprot.readFieldBegin()
17624 
      if ftype == TType.STOP:
17625 
        break
17626 
      if fid == 0:
17627 
        if ftype == TType.BOOL:
17628 
          self.success = iprot.readBool();
17629 
        else:
17630 
          iprot.skip(ftype)
17631 
      elif fid == 1:
17632 
        if ftype == TType.STRUCT:
17633 
          self.ex = TransactionServiceException()
17634 
          self.ex.read(iprot)
17635 
        else:
17636 
          iprot.skip(ftype)
17637 
      else:
17638 
        iprot.skip(ftype)
17639 
      iprot.readFieldEnd()
17640 
    iprot.readStructEnd()
17641 
 
17642 
  def write(self, oprot):
17643 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17644 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17645 
      return
17646 
    oprot.writeStructBegin('markOrderReturnRequestAuthorized_result')
17647 
    if self.success is not None:
17648 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
17649 
      oprot.writeBool(self.success)
17650 
      oprot.writeFieldEnd()
17651 
    if self.ex is not None:
17652 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
17653 
      self.ex.write(oprot)
17654 
      oprot.writeFieldEnd()
17655 
    oprot.writeFieldStop()
17656 
    oprot.writeStructEnd()
17657 
 
17658 
  def validate(self):
17659 
    return
17660 
 
17661 
 
17662 
  def __repr__(self):
17663 
    L = ['%s=%r' % (key, value)
17664 
      for key, value in self.__dict__.iteritems()]
17665 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17666 
 
17667 
  def __eq__(self, other):
17668 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17669 
 
17670 
  def __ne__(self, other):
17671 
    return not (self == other)
17672 
 
2536 chandransh 17673 
class requestPickupNumber_args:
17674 
  """
17675 
  Attributes:
17676 
   - orderId
4579 rajveer 17677 
   - providerId
2536 chandransh 17678 
  """
17679 
 
17680 
  thrift_spec = (
17681 
    None, # 0
17682 
    (1, TType.I64, 'orderId', None, None, ), # 1
4579 rajveer 17683 
    (2, TType.I64, 'providerId', None, None, ), # 2
2536 chandransh 17684 
  )
17685 
 
4579 rajveer 17686 
  def __init__(self, orderId=None, providerId=None,):
2536 chandransh 17687 
    self.orderId = orderId
4579 rajveer 17688 
    self.providerId = providerId
2536 chandransh 17689 
 
17690 
  def read(self, iprot):
17691 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17692 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17693 
      return
17694 
    iprot.readStructBegin()
17695 
    while True:
17696 
      (fname, ftype, fid) = iprot.readFieldBegin()
17697 
      if ftype == TType.STOP:
17698 
        break
17699 
      if fid == 1:
17700 
        if ftype == TType.I64:
17701 
          self.orderId = iprot.readI64();
17702 
        else:
17703 
          iprot.skip(ftype)
4579 rajveer 17704 
      elif fid == 2:
17705 
        if ftype == TType.I64:
17706 
          self.providerId = iprot.readI64();
17707 
        else:
17708 
          iprot.skip(ftype)
2536 chandransh 17709 
      else:
17710 
        iprot.skip(ftype)
17711 
      iprot.readFieldEnd()
17712 
    iprot.readStructEnd()
17713 
 
17714 
  def write(self, oprot):
17715 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17716 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17717 
      return
17718 
    oprot.writeStructBegin('requestPickupNumber_args')
3431 rajveer 17719 
    if self.orderId is not None:
2536 chandransh 17720 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
17721 
      oprot.writeI64(self.orderId)
17722 
      oprot.writeFieldEnd()
4579 rajveer 17723 
    if self.providerId is not None:
17724 
      oprot.writeFieldBegin('providerId', TType.I64, 2)
17725 
      oprot.writeI64(self.providerId)
17726 
      oprot.writeFieldEnd()
2536 chandransh 17727 
    oprot.writeFieldStop()
17728 
    oprot.writeStructEnd()
17729 
 
3431 rajveer 17730 
  def validate(self):
17731 
    return
17732 
 
17733 
 
2536 chandransh 17734 
  def __repr__(self):
17735 
    L = ['%s=%r' % (key, value)
17736 
      for key, value in self.__dict__.iteritems()]
17737 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17738 
 
17739 
  def __eq__(self, other):
17740 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17741 
 
17742 
  def __ne__(self, other):
17743 
    return not (self == other)
17744 
 
17745 
class requestPickupNumber_result:
17746 
  """
17747 
  Attributes:
17748 
   - success
17749 
   - ex
17750 
  """
17751 
 
17752 
  thrift_spec = (
17753 
    (0, TType.BOOL, 'success', None, None, ), # 0
17754 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
17755 
  )
17756 
 
17757 
  def __init__(self, success=None, ex=None,):
17758 
    self.success = success
17759 
    self.ex = ex
17760 
 
17761 
  def read(self, iprot):
17762 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17763 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17764 
      return
17765 
    iprot.readStructBegin()
17766 
    while True:
17767 
      (fname, ftype, fid) = iprot.readFieldBegin()
17768 
      if ftype == TType.STOP:
17769 
        break
17770 
      if fid == 0:
17771 
        if ftype == TType.BOOL:
17772 
          self.success = iprot.readBool();
17773 
        else:
17774 
          iprot.skip(ftype)
17775 
      elif fid == 1:
17776 
        if ftype == TType.STRUCT:
17777 
          self.ex = TransactionServiceException()
17778 
          self.ex.read(iprot)
17779 
        else:
17780 
          iprot.skip(ftype)
17781 
      else:
17782 
        iprot.skip(ftype)
17783 
      iprot.readFieldEnd()
17784 
    iprot.readStructEnd()
17785 
 
17786 
  def write(self, oprot):
17787 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17788 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17789 
      return
17790 
    oprot.writeStructBegin('requestPickupNumber_result')
3431 rajveer 17791 
    if self.success is not None:
2536 chandransh 17792 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
17793 
      oprot.writeBool(self.success)
17794 
      oprot.writeFieldEnd()
3431 rajveer 17795 
    if self.ex is not None:
2536 chandransh 17796 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
17797 
      self.ex.write(oprot)
17798 
      oprot.writeFieldEnd()
17799 
    oprot.writeFieldStop()
17800 
    oprot.writeStructEnd()
17801 
 
3431 rajveer 17802 
  def validate(self):
17803 
    return
17804 
 
17805 
 
2536 chandransh 17806 
  def __repr__(self):
17807 
    L = ['%s=%r' % (key, value)
17808 
      for key, value in self.__dict__.iteritems()]
17809 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17810 
 
17811 
  def __eq__(self, other):
17812 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17813 
 
17814 
  def __ne__(self, other):
17815 
    return not (self == other)
17816 
 
17817 
class authorizePickup_args:
17818 
  """
17819 
  Attributes:
17820 
   - orderId
17821 
   - pickupNumber
4602 rajveer 17822 
   - providerId
2536 chandransh 17823 
  """
17824 
 
17825 
  thrift_spec = (
17826 
    None, # 0
17827 
    (1, TType.I64, 'orderId', None, None, ), # 1
17828 
    (2, TType.STRING, 'pickupNumber', None, None, ), # 2
4602 rajveer 17829 
    (3, TType.I64, 'providerId', None, None, ), # 3
2536 chandransh 17830 
  )
17831 
 
4602 rajveer 17832 
  def __init__(self, orderId=None, pickupNumber=None, providerId=None,):
2536 chandransh 17833 
    self.orderId = orderId
17834 
    self.pickupNumber = pickupNumber
4602 rajveer 17835 
    self.providerId = providerId
2536 chandransh 17836 
 
17837 
  def read(self, iprot):
17838 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17839 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17840 
      return
17841 
    iprot.readStructBegin()
17842 
    while True:
17843 
      (fname, ftype, fid) = iprot.readFieldBegin()
17844 
      if ftype == TType.STOP:
17845 
        break
17846 
      if fid == 1:
17847 
        if ftype == TType.I64:
17848 
          self.orderId = iprot.readI64();
17849 
        else:
17850 
          iprot.skip(ftype)
17851 
      elif fid == 2:
17852 
        if ftype == TType.STRING:
17853 
          self.pickupNumber = iprot.readString();
17854 
        else:
17855 
          iprot.skip(ftype)
4602 rajveer 17856 
      elif fid == 3:
17857 
        if ftype == TType.I64:
17858 
          self.providerId = iprot.readI64();
17859 
        else:
17860 
          iprot.skip(ftype)
2536 chandransh 17861 
      else:
17862 
        iprot.skip(ftype)
17863 
      iprot.readFieldEnd()
17864 
    iprot.readStructEnd()
17865 
 
17866 
  def write(self, oprot):
17867 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17868 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17869 
      return
17870 
    oprot.writeStructBegin('authorizePickup_args')
3431 rajveer 17871 
    if self.orderId is not None:
2536 chandransh 17872 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
17873 
      oprot.writeI64(self.orderId)
17874 
      oprot.writeFieldEnd()
3431 rajveer 17875 
    if self.pickupNumber is not None:
2536 chandransh 17876 
      oprot.writeFieldBegin('pickupNumber', TType.STRING, 2)
17877 
      oprot.writeString(self.pickupNumber)
17878 
      oprot.writeFieldEnd()
4602 rajveer 17879 
    if self.providerId is not None:
17880 
      oprot.writeFieldBegin('providerId', TType.I64, 3)
17881 
      oprot.writeI64(self.providerId)
17882 
      oprot.writeFieldEnd()
2536 chandransh 17883 
    oprot.writeFieldStop()
17884 
    oprot.writeStructEnd()
17885 
 
3431 rajveer 17886 
  def validate(self):
17887 
    return
17888 
 
17889 
 
2536 chandransh 17890 
  def __repr__(self):
17891 
    L = ['%s=%r' % (key, value)
17892 
      for key, value in self.__dict__.iteritems()]
17893 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17894 
 
17895 
  def __eq__(self, other):
17896 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17897 
 
17898 
  def __ne__(self, other):
17899 
    return not (self == other)
17900 
 
17901 
class authorizePickup_result:
17902 
  """
17903 
  Attributes:
17904 
   - success
17905 
   - ex
17906 
  """
17907 
 
17908 
  thrift_spec = (
17909 
    (0, TType.BOOL, 'success', None, None, ), # 0
17910 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
17911 
  )
17912 
 
17913 
  def __init__(self, success=None, ex=None,):
17914 
    self.success = success
17915 
    self.ex = ex
17916 
 
17917 
  def read(self, iprot):
17918 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17919 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17920 
      return
17921 
    iprot.readStructBegin()
17922 
    while True:
17923 
      (fname, ftype, fid) = iprot.readFieldBegin()
17924 
      if ftype == TType.STOP:
17925 
        break
17926 
      if fid == 0:
17927 
        if ftype == TType.BOOL:
17928 
          self.success = iprot.readBool();
17929 
        else:
17930 
          iprot.skip(ftype)
17931 
      elif fid == 1:
17932 
        if ftype == TType.STRUCT:
17933 
          self.ex = TransactionServiceException()
17934 
          self.ex.read(iprot)
17935 
        else:
17936 
          iprot.skip(ftype)
17937 
      else:
17938 
        iprot.skip(ftype)
17939 
      iprot.readFieldEnd()
17940 
    iprot.readStructEnd()
17941 
 
17942 
  def write(self, oprot):
17943 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17944 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17945 
      return
17946 
    oprot.writeStructBegin('authorizePickup_result')
3431 rajveer 17947 
    if self.success is not None:
2536 chandransh 17948 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
17949 
      oprot.writeBool(self.success)
17950 
      oprot.writeFieldEnd()
3431 rajveer 17951 
    if self.ex is not None:
2536 chandransh 17952 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
17953 
      self.ex.write(oprot)
17954 
      oprot.writeFieldEnd()
17955 
    oprot.writeFieldStop()
17956 
    oprot.writeStructEnd()
17957 
 
3431 rajveer 17958 
  def validate(self):
17959 
    return
17960 
 
17961 
 
2536 chandransh 17962 
  def __repr__(self):
17963 
    L = ['%s=%r' % (key, value)
17964 
      for key, value in self.__dict__.iteritems()]
17965 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17966 
 
17967 
  def __eq__(self, other):
17968 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17969 
 
17970 
  def __ne__(self, other):
17971 
    return not (self == other)
17972 
 
2764 chandransh 17973 
class markDoasAsPickedUp_args:
17974 
  """
17975 
  Attributes:
17976 
   - providerId
17977 
   - pickupDetails
17978 
  """
17979 
 
17980 
  thrift_spec = (
17981 
    None, # 0
17982 
    (1, TType.I64, 'providerId', None, None, ), # 1
17983 
    (2, TType.MAP, 'pickupDetails', (TType.STRING,None,TType.STRING,None), None, ), # 2
17984 
  )
17985 
 
17986 
  def __init__(self, providerId=None, pickupDetails=None,):
17987 
    self.providerId = providerId
17988 
    self.pickupDetails = pickupDetails
17989 
 
17990 
  def read(self, iprot):
17991 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17992 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17993 
      return
17994 
    iprot.readStructBegin()
17995 
    while True:
17996 
      (fname, ftype, fid) = iprot.readFieldBegin()
17997 
      if ftype == TType.STOP:
17998 
        break
17999 
      if fid == 1:
18000 
        if ftype == TType.I64:
18001 
          self.providerId = iprot.readI64();
18002 
        else:
18003 
          iprot.skip(ftype)
18004 
      elif fid == 2:
18005 
        if ftype == TType.MAP:
18006 
          self.pickupDetails = {}
6188 rajveer 18007 
          (_ktype408, _vtype409, _size407 ) = iprot.readMapBegin()
18008 
          for _i411 in xrange(_size407):
18009 
            _key412 = iprot.readString();
18010 
            _val413 = iprot.readString();
18011 
            self.pickupDetails[_key412] = _val413
2764 chandransh 18012 
          iprot.readMapEnd()
18013 
        else:
18014 
          iprot.skip(ftype)
18015 
      else:
18016 
        iprot.skip(ftype)
18017 
      iprot.readFieldEnd()
18018 
    iprot.readStructEnd()
18019 
 
18020 
  def write(self, oprot):
18021 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18022 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18023 
      return
18024 
    oprot.writeStructBegin('markDoasAsPickedUp_args')
3431 rajveer 18025 
    if self.providerId is not None:
2764 chandransh 18026 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
18027 
      oprot.writeI64(self.providerId)
18028 
      oprot.writeFieldEnd()
3431 rajveer 18029 
    if self.pickupDetails is not None:
2764 chandransh 18030 
      oprot.writeFieldBegin('pickupDetails', TType.MAP, 2)
18031 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.pickupDetails))
6188 rajveer 18032 
      for kiter414,viter415 in self.pickupDetails.items():
18033 
        oprot.writeString(kiter414)
18034 
        oprot.writeString(viter415)
2764 chandransh 18035 
      oprot.writeMapEnd()
18036 
      oprot.writeFieldEnd()
18037 
    oprot.writeFieldStop()
18038 
    oprot.writeStructEnd()
18039 
 
3431 rajveer 18040 
  def validate(self):
18041 
    return
18042 
 
18043 
 
2764 chandransh 18044 
  def __repr__(self):
18045 
    L = ['%s=%r' % (key, value)
18046 
      for key, value in self.__dict__.iteritems()]
18047 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18048 
 
18049 
  def __eq__(self, other):
18050 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18051 
 
18052 
  def __ne__(self, other):
18053 
    return not (self == other)
18054 
 
18055 
class markDoasAsPickedUp_result:
4910 phani.kuma 18056 
 
18057 
  thrift_spec = (
18058 
  )
18059 
 
18060 
  def read(self, iprot):
18061 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18062 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18063 
      return
18064 
    iprot.readStructBegin()
18065 
    while True:
18066 
      (fname, ftype, fid) = iprot.readFieldBegin()
18067 
      if ftype == TType.STOP:
18068 
        break
18069 
      else:
18070 
        iprot.skip(ftype)
18071 
      iprot.readFieldEnd()
18072 
    iprot.readStructEnd()
18073 
 
18074 
  def write(self, oprot):
18075 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18076 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18077 
      return
18078 
    oprot.writeStructBegin('markDoasAsPickedUp_result')
18079 
    oprot.writeFieldStop()
18080 
    oprot.writeStructEnd()
18081 
 
18082 
  def validate(self):
18083 
    return
18084 
 
18085 
 
18086 
  def __repr__(self):
18087 
    L = ['%s=%r' % (key, value)
18088 
      for key, value in self.__dict__.iteritems()]
18089 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18090 
 
18091 
  def __eq__(self, other):
18092 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18093 
 
18094 
  def __ne__(self, other):
18095 
    return not (self == other)
18096 
 
18097 
class getDoasNotPickedUp_args:
2764 chandransh 18098 
  """
18099 
  Attributes:
4910 phani.kuma 18100 
   - providerId
18101 
  """
18102 
 
18103 
  thrift_spec = (
18104 
    None, # 0
18105 
    (1, TType.I64, 'providerId', None, None, ), # 1
18106 
  )
18107 
 
18108 
  def __init__(self, providerId=None,):
18109 
    self.providerId = providerId
18110 
 
18111 
  def read(self, iprot):
18112 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18113 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18114 
      return
18115 
    iprot.readStructBegin()
18116 
    while True:
18117 
      (fname, ftype, fid) = iprot.readFieldBegin()
18118 
      if ftype == TType.STOP:
18119 
        break
18120 
      if fid == 1:
18121 
        if ftype == TType.I64:
18122 
          self.providerId = iprot.readI64();
18123 
        else:
18124 
          iprot.skip(ftype)
18125 
      else:
18126 
        iprot.skip(ftype)
18127 
      iprot.readFieldEnd()
18128 
    iprot.readStructEnd()
18129 
 
18130 
  def write(self, oprot):
18131 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18132 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18133 
      return
18134 
    oprot.writeStructBegin('getDoasNotPickedUp_args')
18135 
    if self.providerId is not None:
18136 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
18137 
      oprot.writeI64(self.providerId)
18138 
      oprot.writeFieldEnd()
18139 
    oprot.writeFieldStop()
18140 
    oprot.writeStructEnd()
18141 
 
18142 
  def validate(self):
18143 
    return
18144 
 
18145 
 
18146 
  def __repr__(self):
18147 
    L = ['%s=%r' % (key, value)
18148 
      for key, value in self.__dict__.iteritems()]
18149 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18150 
 
18151 
  def __eq__(self, other):
18152 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18153 
 
18154 
  def __ne__(self, other):
18155 
    return not (self == other)
18156 
 
18157 
class getDoasNotPickedUp_result:
18158 
  """
18159 
  Attributes:
2764 chandransh 18160 
   - success
18161 
  """
18162 
 
18163 
  thrift_spec = (
18164 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
18165 
  )
18166 
 
18167 
  def __init__(self, success=None,):
18168 
    self.success = success
18169 
 
18170 
  def read(self, iprot):
18171 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18172 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18173 
      return
18174 
    iprot.readStructBegin()
18175 
    while True:
18176 
      (fname, ftype, fid) = iprot.readFieldBegin()
18177 
      if ftype == TType.STOP:
18178 
        break
18179 
      if fid == 0:
18180 
        if ftype == TType.LIST:
18181 
          self.success = []
6188 rajveer 18182 
          (_etype419, _size416) = iprot.readListBegin()
18183 
          for _i420 in xrange(_size416):
18184 
            _elem421 = Order()
18185 
            _elem421.read(iprot)
18186 
            self.success.append(_elem421)
2764 chandransh 18187 
          iprot.readListEnd()
18188 
        else:
18189 
          iprot.skip(ftype)
18190 
      else:
18191 
        iprot.skip(ftype)
18192 
      iprot.readFieldEnd()
18193 
    iprot.readStructEnd()
18194 
 
18195 
  def write(self, oprot):
18196 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18197 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18198 
      return
4910 phani.kuma 18199 
    oprot.writeStructBegin('getDoasNotPickedUp_result')
3431 rajveer 18200 
    if self.success is not None:
2764 chandransh 18201 
      oprot.writeFieldBegin('success', TType.LIST, 0)
18202 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 18203 
      for iter422 in self.success:
18204 
        iter422.write(oprot)
2764 chandransh 18205 
      oprot.writeListEnd()
18206 
      oprot.writeFieldEnd()
18207 
    oprot.writeFieldStop()
18208 
    oprot.writeStructEnd()
18209 
 
3431 rajveer 18210 
  def validate(self):
18211 
    return
18212 
 
18213 
 
2764 chandransh 18214 
  def __repr__(self):
18215 
    L = ['%s=%r' % (key, value)
18216 
      for key, value in self.__dict__.iteritems()]
18217 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18218 
 
18219 
  def __eq__(self, other):
18220 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18221 
 
18222 
  def __ne__(self, other):
18223 
    return not (self == other)
18224 
 
4741 phani.kuma 18225 
class markReturnOrdersAsPickedUp_args:
18226 
  """
18227 
  Attributes:
18228 
   - providerId
18229 
   - pickupDetails
18230 
  """
18231 
 
18232 
  thrift_spec = (
18233 
    None, # 0
18234 
    (1, TType.I64, 'providerId', None, None, ), # 1
18235 
    (2, TType.MAP, 'pickupDetails', (TType.STRING,None,TType.STRING,None), None, ), # 2
18236 
  )
18237 
 
18238 
  def __init__(self, providerId=None, pickupDetails=None,):
18239 
    self.providerId = providerId
18240 
    self.pickupDetails = pickupDetails
18241 
 
18242 
  def read(self, iprot):
18243 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18244 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18245 
      return
18246 
    iprot.readStructBegin()
18247 
    while True:
18248 
      (fname, ftype, fid) = iprot.readFieldBegin()
18249 
      if ftype == TType.STOP:
18250 
        break
18251 
      if fid == 1:
18252 
        if ftype == TType.I64:
18253 
          self.providerId = iprot.readI64();
18254 
        else:
18255 
          iprot.skip(ftype)
18256 
      elif fid == 2:
18257 
        if ftype == TType.MAP:
18258 
          self.pickupDetails = {}
6188 rajveer 18259 
          (_ktype424, _vtype425, _size423 ) = iprot.readMapBegin()
18260 
          for _i427 in xrange(_size423):
18261 
            _key428 = iprot.readString();
18262 
            _val429 = iprot.readString();
18263 
            self.pickupDetails[_key428] = _val429
4741 phani.kuma 18264 
          iprot.readMapEnd()
18265 
        else:
18266 
          iprot.skip(ftype)
18267 
      else:
18268 
        iprot.skip(ftype)
18269 
      iprot.readFieldEnd()
18270 
    iprot.readStructEnd()
18271 
 
18272 
  def write(self, oprot):
18273 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18274 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18275 
      return
18276 
    oprot.writeStructBegin('markReturnOrdersAsPickedUp_args')
18277 
    if self.providerId is not None:
18278 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
18279 
      oprot.writeI64(self.providerId)
18280 
      oprot.writeFieldEnd()
18281 
    if self.pickupDetails is not None:
18282 
      oprot.writeFieldBegin('pickupDetails', TType.MAP, 2)
18283 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.pickupDetails))
6188 rajveer 18284 
      for kiter430,viter431 in self.pickupDetails.items():
18285 
        oprot.writeString(kiter430)
18286 
        oprot.writeString(viter431)
4741 phani.kuma 18287 
      oprot.writeMapEnd()
18288 
      oprot.writeFieldEnd()
18289 
    oprot.writeFieldStop()
18290 
    oprot.writeStructEnd()
18291 
 
18292 
  def validate(self):
18293 
    return
18294 
 
18295 
 
18296 
  def __repr__(self):
18297 
    L = ['%s=%r' % (key, value)
18298 
      for key, value in self.__dict__.iteritems()]
18299 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18300 
 
18301 
  def __eq__(self, other):
18302 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18303 
 
18304 
  def __ne__(self, other):
18305 
    return not (self == other)
18306 
 
18307 
class markReturnOrdersAsPickedUp_result:
4910 phani.kuma 18308 
 
18309 
  thrift_spec = (
18310 
  )
18311 
 
18312 
  def read(self, iprot):
18313 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18314 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18315 
      return
18316 
    iprot.readStructBegin()
18317 
    while True:
18318 
      (fname, ftype, fid) = iprot.readFieldBegin()
18319 
      if ftype == TType.STOP:
18320 
        break
18321 
      else:
18322 
        iprot.skip(ftype)
18323 
      iprot.readFieldEnd()
18324 
    iprot.readStructEnd()
18325 
 
18326 
  def write(self, oprot):
18327 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18328 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18329 
      return
18330 
    oprot.writeStructBegin('markReturnOrdersAsPickedUp_result')
18331 
    oprot.writeFieldStop()
18332 
    oprot.writeStructEnd()
18333 
 
18334 
  def validate(self):
18335 
    return
18336 
 
18337 
 
18338 
  def __repr__(self):
18339 
    L = ['%s=%r' % (key, value)
18340 
      for key, value in self.__dict__.iteritems()]
18341 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18342 
 
18343 
  def __eq__(self, other):
18344 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18345 
 
18346 
  def __ne__(self, other):
18347 
    return not (self == other)
18348 
 
18349 
class getReturnOrdersNotPickedUp_args:
4741 phani.kuma 18350 
  """
18351 
  Attributes:
4910 phani.kuma 18352 
   - providerId
18353 
  """
18354 
 
18355 
  thrift_spec = (
18356 
    None, # 0
18357 
    (1, TType.I64, 'providerId', None, None, ), # 1
18358 
  )
18359 
 
18360 
  def __init__(self, providerId=None,):
18361 
    self.providerId = providerId
18362 
 
18363 
  def read(self, iprot):
18364 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18365 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18366 
      return
18367 
    iprot.readStructBegin()
18368 
    while True:
18369 
      (fname, ftype, fid) = iprot.readFieldBegin()
18370 
      if ftype == TType.STOP:
18371 
        break
18372 
      if fid == 1:
18373 
        if ftype == TType.I64:
18374 
          self.providerId = iprot.readI64();
18375 
        else:
18376 
          iprot.skip(ftype)
18377 
      else:
18378 
        iprot.skip(ftype)
18379 
      iprot.readFieldEnd()
18380 
    iprot.readStructEnd()
18381 
 
18382 
  def write(self, oprot):
18383 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18384 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18385 
      return
18386 
    oprot.writeStructBegin('getReturnOrdersNotPickedUp_args')
18387 
    if self.providerId is not None:
18388 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
18389 
      oprot.writeI64(self.providerId)
18390 
      oprot.writeFieldEnd()
18391 
    oprot.writeFieldStop()
18392 
    oprot.writeStructEnd()
18393 
 
18394 
  def validate(self):
18395 
    return
18396 
 
18397 
 
18398 
  def __repr__(self):
18399 
    L = ['%s=%r' % (key, value)
18400 
      for key, value in self.__dict__.iteritems()]
18401 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18402 
 
18403 
  def __eq__(self, other):
18404 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18405 
 
18406 
  def __ne__(self, other):
18407 
    return not (self == other)
18408 
 
18409 
class getReturnOrdersNotPickedUp_result:
18410 
  """
18411 
  Attributes:
4741 phani.kuma 18412 
   - success
18413 
  """
18414 
 
18415 
  thrift_spec = (
18416 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
18417 
  )
18418 
 
18419 
  def __init__(self, success=None,):
18420 
    self.success = success
18421 
 
18422 
  def read(self, iprot):
18423 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18424 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18425 
      return
18426 
    iprot.readStructBegin()
18427 
    while True:
18428 
      (fname, ftype, fid) = iprot.readFieldBegin()
18429 
      if ftype == TType.STOP:
18430 
        break
18431 
      if fid == 0:
18432 
        if ftype == TType.LIST:
18433 
          self.success = []
6188 rajveer 18434 
          (_etype435, _size432) = iprot.readListBegin()
18435 
          for _i436 in xrange(_size432):
18436 
            _elem437 = Order()
18437 
            _elem437.read(iprot)
18438 
            self.success.append(_elem437)
4741 phani.kuma 18439 
          iprot.readListEnd()
18440 
        else:
18441 
          iprot.skip(ftype)
18442 
      else:
18443 
        iprot.skip(ftype)
18444 
      iprot.readFieldEnd()
18445 
    iprot.readStructEnd()
18446 
 
18447 
  def write(self, oprot):
18448 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18449 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18450 
      return
4910 phani.kuma 18451 
    oprot.writeStructBegin('getReturnOrdersNotPickedUp_result')
4741 phani.kuma 18452 
    if self.success is not None:
18453 
      oprot.writeFieldBegin('success', TType.LIST, 0)
18454 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 18455 
      for iter438 in self.success:
18456 
        iter438.write(oprot)
4741 phani.kuma 18457 
      oprot.writeListEnd()
18458 
      oprot.writeFieldEnd()
18459 
    oprot.writeFieldStop()
18460 
    oprot.writeStructEnd()
18461 
 
18462 
  def validate(self):
18463 
    return
18464 
 
18465 
 
18466 
  def __repr__(self):
18467 
    L = ['%s=%r' % (key, value)
18468 
      for key, value in self.__dict__.iteritems()]
18469 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18470 
 
18471 
  def __eq__(self, other):
18472 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18473 
 
18474 
  def __ne__(self, other):
18475 
    return not (self == other)
18476 
 
2616 chandransh 18477 
class receiveReturn_args:
2591 chandransh 18478 
  """
18479 
  Attributes:
18480 
   - orderId
4479 rajveer 18481 
   - receiveCondition
2591 chandransh 18482 
  """
2536 chandransh 18483 
 
2591 chandransh 18484 
  thrift_spec = (
18485 
    None, # 0
18486 
    (1, TType.I64, 'orderId', None, None, ), # 1
4479 rajveer 18487 
    (2, TType.I64, 'receiveCondition', None, None, ), # 2
2591 chandransh 18488 
  )
18489 
 
4479 rajveer 18490 
  def __init__(self, orderId=None, receiveCondition=None,):
2591 chandransh 18491 
    self.orderId = orderId
4479 rajveer 18492 
    self.receiveCondition = receiveCondition
2591 chandransh 18493 
 
18494 
  def read(self, iprot):
18495 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18496 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18497 
      return
18498 
    iprot.readStructBegin()
18499 
    while True:
18500 
      (fname, ftype, fid) = iprot.readFieldBegin()
18501 
      if ftype == TType.STOP:
18502 
        break
18503 
      if fid == 1:
18504 
        if ftype == TType.I64:
18505 
          self.orderId = iprot.readI64();
18506 
        else:
18507 
          iprot.skip(ftype)
4479 rajveer 18508 
      elif fid == 2:
18509 
        if ftype == TType.I64:
18510 
          self.receiveCondition = iprot.readI64();
18511 
        else:
18512 
          iprot.skip(ftype)
2591 chandransh 18513 
      else:
18514 
        iprot.skip(ftype)
18515 
      iprot.readFieldEnd()
18516 
    iprot.readStructEnd()
18517 
 
18518 
  def write(self, oprot):
18519 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18520 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18521 
      return
2616 chandransh 18522 
    oprot.writeStructBegin('receiveReturn_args')
3431 rajveer 18523 
    if self.orderId is not None:
2591 chandransh 18524 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
18525 
      oprot.writeI64(self.orderId)
18526 
      oprot.writeFieldEnd()
4479 rajveer 18527 
    if self.receiveCondition is not None:
18528 
      oprot.writeFieldBegin('receiveCondition', TType.I64, 2)
18529 
      oprot.writeI64(self.receiveCondition)
18530 
      oprot.writeFieldEnd()
2591 chandransh 18531 
    oprot.writeFieldStop()
18532 
    oprot.writeStructEnd()
18533 
 
3431 rajveer 18534 
  def validate(self):
18535 
    return
18536 
 
18537 
 
2591 chandransh 18538 
  def __repr__(self):
18539 
    L = ['%s=%r' % (key, value)
18540 
      for key, value in self.__dict__.iteritems()]
18541 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18542 
 
18543 
  def __eq__(self, other):
18544 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18545 
 
18546 
  def __ne__(self, other):
18547 
    return not (self == other)
18548 
 
2616 chandransh 18549 
class receiveReturn_result:
2591 chandransh 18550 
  """
18551 
  Attributes:
18552 
   - success
18553 
   - ex
18554 
  """
18555 
 
18556 
  thrift_spec = (
18557 
    (0, TType.BOOL, 'success', None, None, ), # 0
18558 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
18559 
  )
18560 
 
18561 
  def __init__(self, success=None, ex=None,):
18562 
    self.success = success
18563 
    self.ex = ex
18564 
 
18565 
  def read(self, iprot):
18566 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18567 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18568 
      return
18569 
    iprot.readStructBegin()
18570 
    while True:
18571 
      (fname, ftype, fid) = iprot.readFieldBegin()
18572 
      if ftype == TType.STOP:
18573 
        break
18574 
      if fid == 0:
18575 
        if ftype == TType.BOOL:
18576 
          self.success = iprot.readBool();
18577 
        else:
18578 
          iprot.skip(ftype)
18579 
      elif fid == 1:
18580 
        if ftype == TType.STRUCT:
18581 
          self.ex = TransactionServiceException()
18582 
          self.ex.read(iprot)
18583 
        else:
18584 
          iprot.skip(ftype)
18585 
      else:
18586 
        iprot.skip(ftype)
18587 
      iprot.readFieldEnd()
18588 
    iprot.readStructEnd()
18589 
 
18590 
  def write(self, oprot):
18591 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18592 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18593 
      return
2616 chandransh 18594 
    oprot.writeStructBegin('receiveReturn_result')
3431 rajveer 18595 
    if self.success is not None:
2591 chandransh 18596 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
18597 
      oprot.writeBool(self.success)
18598 
      oprot.writeFieldEnd()
3431 rajveer 18599 
    if self.ex is not None:
2591 chandransh 18600 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
18601 
      self.ex.write(oprot)
18602 
      oprot.writeFieldEnd()
18603 
    oprot.writeFieldStop()
18604 
    oprot.writeStructEnd()
18605 
 
3431 rajveer 18606 
  def validate(self):
18607 
    return
18608 
 
18609 
 
2591 chandransh 18610 
  def __repr__(self):
18611 
    L = ['%s=%r' % (key, value)
18612 
      for key, value in self.__dict__.iteritems()]
18613 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18614 
 
18615 
  def __eq__(self, other):
18616 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18617 
 
18618 
  def __ne__(self, other):
18619 
    return not (self == other)
18620 
 
18621 
class validateDoa_args:
18622 
  """
18623 
  Attributes:
18624 
   - orderId
18625 
   - isValid
18626 
  """
18627 
 
18628 
  thrift_spec = (
18629 
    None, # 0
18630 
    (1, TType.I64, 'orderId', None, None, ), # 1
18631 
    (2, TType.BOOL, 'isValid', None, None, ), # 2
18632 
  )
18633 
 
18634 
  def __init__(self, orderId=None, isValid=None,):
18635 
    self.orderId = orderId
18636 
    self.isValid = isValid
18637 
 
18638 
  def read(self, iprot):
18639 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18640 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18641 
      return
18642 
    iprot.readStructBegin()
18643 
    while True:
18644 
      (fname, ftype, fid) = iprot.readFieldBegin()
18645 
      if ftype == TType.STOP:
18646 
        break
18647 
      if fid == 1:
18648 
        if ftype == TType.I64:
18649 
          self.orderId = iprot.readI64();
18650 
        else:
18651 
          iprot.skip(ftype)
18652 
      elif fid == 2:
18653 
        if ftype == TType.BOOL:
18654 
          self.isValid = iprot.readBool();
18655 
        else:
18656 
          iprot.skip(ftype)
18657 
      else:
18658 
        iprot.skip(ftype)
18659 
      iprot.readFieldEnd()
18660 
    iprot.readStructEnd()
18661 
 
18662 
  def write(self, oprot):
18663 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18664 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18665 
      return
18666 
    oprot.writeStructBegin('validateDoa_args')
3431 rajveer 18667 
    if self.orderId is not None:
2591 chandransh 18668 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
18669 
      oprot.writeI64(self.orderId)
18670 
      oprot.writeFieldEnd()
3431 rajveer 18671 
    if self.isValid is not None:
2591 chandransh 18672 
      oprot.writeFieldBegin('isValid', TType.BOOL, 2)
18673 
      oprot.writeBool(self.isValid)
18674 
      oprot.writeFieldEnd()
18675 
    oprot.writeFieldStop()
18676 
    oprot.writeStructEnd()
18677 
 
3431 rajveer 18678 
  def validate(self):
18679 
    return
18680 
 
18681 
 
2591 chandransh 18682 
  def __repr__(self):
18683 
    L = ['%s=%r' % (key, value)
18684 
      for key, value in self.__dict__.iteritems()]
18685 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18686 
 
18687 
  def __eq__(self, other):
18688 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18689 
 
18690 
  def __ne__(self, other):
18691 
    return not (self == other)
18692 
 
18693 
class validateDoa_result:
18694 
  """
18695 
  Attributes:
18696 
   - success
18697 
   - ex
18698 
  """
18699 
 
18700 
  thrift_spec = (
18701 
    (0, TType.BOOL, 'success', None, None, ), # 0
18702 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
18703 
  )
18704 
 
18705 
  def __init__(self, success=None, ex=None,):
18706 
    self.success = success
18707 
    self.ex = ex
18708 
 
18709 
  def read(self, iprot):
18710 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18711 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18712 
      return
18713 
    iprot.readStructBegin()
18714 
    while True:
18715 
      (fname, ftype, fid) = iprot.readFieldBegin()
18716 
      if ftype == TType.STOP:
18717 
        break
18718 
      if fid == 0:
18719 
        if ftype == TType.BOOL:
18720 
          self.success = iprot.readBool();
18721 
        else:
18722 
          iprot.skip(ftype)
18723 
      elif fid == 1:
18724 
        if ftype == TType.STRUCT:
18725 
          self.ex = TransactionServiceException()
18726 
          self.ex.read(iprot)
18727 
        else:
18728 
          iprot.skip(ftype)
18729 
      else:
18730 
        iprot.skip(ftype)
18731 
      iprot.readFieldEnd()
18732 
    iprot.readStructEnd()
18733 
 
18734 
  def write(self, oprot):
18735 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18736 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18737 
      return
18738 
    oprot.writeStructBegin('validateDoa_result')
3431 rajveer 18739 
    if self.success is not None:
2591 chandransh 18740 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
18741 
      oprot.writeBool(self.success)
18742 
      oprot.writeFieldEnd()
3431 rajveer 18743 
    if self.ex is not None:
2591 chandransh 18744 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
18745 
      self.ex.write(oprot)
18746 
      oprot.writeFieldEnd()
18747 
    oprot.writeFieldStop()
18748 
    oprot.writeStructEnd()
18749 
 
3431 rajveer 18750 
  def validate(self):
18751 
    return
18752 
 
18753 
 
2591 chandransh 18754 
  def __repr__(self):
18755 
    L = ['%s=%r' % (key, value)
18756 
      for key, value in self.__dict__.iteritems()]
18757 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18758 
 
18759 
  def __eq__(self, other):
18760 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18761 
 
18762 
  def __ne__(self, other):
18763 
    return not (self == other)
18764 
 
4495 rajveer 18765 
class validateReturnProduct_args:
18766 
  """
18767 
  Attributes:
18768 
   - orderId
18769 
   - isUsable
18770 
  """
18771 
 
18772 
  thrift_spec = (
18773 
    None, # 0
18774 
    (1, TType.I64, 'orderId', None, None, ), # 1
18775 
    (2, TType.BOOL, 'isUsable', None, None, ), # 2
18776 
  )
18777 
 
18778 
  def __init__(self, orderId=None, isUsable=None,):
18779 
    self.orderId = orderId
18780 
    self.isUsable = isUsable
18781 
 
18782 
  def read(self, iprot):
18783 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18784 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18785 
      return
18786 
    iprot.readStructBegin()
18787 
    while True:
18788 
      (fname, ftype, fid) = iprot.readFieldBegin()
18789 
      if ftype == TType.STOP:
18790 
        break
18791 
      if fid == 1:
18792 
        if ftype == TType.I64:
18793 
          self.orderId = iprot.readI64();
18794 
        else:
18795 
          iprot.skip(ftype)
18796 
      elif fid == 2:
18797 
        if ftype == TType.BOOL:
18798 
          self.isUsable = iprot.readBool();
18799 
        else:
18800 
          iprot.skip(ftype)
18801 
      else:
18802 
        iprot.skip(ftype)
18803 
      iprot.readFieldEnd()
18804 
    iprot.readStructEnd()
18805 
 
18806 
  def write(self, oprot):
18807 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18808 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18809 
      return
18810 
    oprot.writeStructBegin('validateReturnProduct_args')
18811 
    if self.orderId is not None:
18812 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
18813 
      oprot.writeI64(self.orderId)
18814 
      oprot.writeFieldEnd()
18815 
    if self.isUsable is not None:
18816 
      oprot.writeFieldBegin('isUsable', TType.BOOL, 2)
18817 
      oprot.writeBool(self.isUsable)
18818 
      oprot.writeFieldEnd()
18819 
    oprot.writeFieldStop()
18820 
    oprot.writeStructEnd()
18821 
 
18822 
  def validate(self):
18823 
    return
18824 
 
18825 
 
18826 
  def __repr__(self):
18827 
    L = ['%s=%r' % (key, value)
18828 
      for key, value in self.__dict__.iteritems()]
18829 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18830 
 
18831 
  def __eq__(self, other):
18832 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18833 
 
18834 
  def __ne__(self, other):
18835 
    return not (self == other)
18836 
 
18837 
class validateReturnProduct_result:
18838 
  """
18839 
  Attributes:
18840 
   - success
18841 
   - ex
18842 
  """
18843 
 
18844 
  thrift_spec = (
18845 
    (0, TType.BOOL, 'success', None, None, ), # 0
18846 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
18847 
  )
18848 
 
18849 
  def __init__(self, success=None, ex=None,):
18850 
    self.success = success
18851 
    self.ex = ex
18852 
 
18853 
  def read(self, iprot):
18854 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18855 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18856 
      return
18857 
    iprot.readStructBegin()
18858 
    while True:
18859 
      (fname, ftype, fid) = iprot.readFieldBegin()
18860 
      if ftype == TType.STOP:
18861 
        break
18862 
      if fid == 0:
18863 
        if ftype == TType.BOOL:
18864 
          self.success = iprot.readBool();
18865 
        else:
18866 
          iprot.skip(ftype)
18867 
      elif fid == 1:
18868 
        if ftype == TType.STRUCT:
18869 
          self.ex = TransactionServiceException()
18870 
          self.ex.read(iprot)
18871 
        else:
18872 
          iprot.skip(ftype)
18873 
      else:
18874 
        iprot.skip(ftype)
18875 
      iprot.readFieldEnd()
18876 
    iprot.readStructEnd()
18877 
 
18878 
  def write(self, oprot):
18879 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18880 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18881 
      return
18882 
    oprot.writeStructBegin('validateReturnProduct_result')
18883 
    if self.success is not None:
18884 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
18885 
      oprot.writeBool(self.success)
18886 
      oprot.writeFieldEnd()
18887 
    if self.ex is not None:
18888 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
18889 
      self.ex.write(oprot)
18890 
      oprot.writeFieldEnd()
18891 
    oprot.writeFieldStop()
18892 
    oprot.writeStructEnd()
18893 
 
18894 
  def validate(self):
18895 
    return
18896 
 
18897 
 
18898 
  def __repr__(self):
18899 
    L = ['%s=%r' % (key, value)
18900 
      for key, value in self.__dict__.iteritems()]
18901 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18902 
 
18903 
  def __eq__(self, other):
18904 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18905 
 
18906 
  def __ne__(self, other):
18907 
    return not (self == other)
18908 
 
2616 chandransh 18909 
class reshipOrder_args:
18910 
  """
18911 
  Attributes:
18912 
   - orderId
18913 
  """
2591 chandransh 18914 
 
2616 chandransh 18915 
  thrift_spec = (
18916 
    None, # 0
18917 
    (1, TType.I64, 'orderId', None, None, ), # 1
18918 
  )
18919 
 
18920 
  def __init__(self, orderId=None,):
18921 
    self.orderId = orderId
18922 
 
18923 
  def read(self, iprot):
18924 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18925 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18926 
      return
18927 
    iprot.readStructBegin()
18928 
    while True:
18929 
      (fname, ftype, fid) = iprot.readFieldBegin()
18930 
      if ftype == TType.STOP:
18931 
        break
18932 
      if fid == 1:
18933 
        if ftype == TType.I64:
18934 
          self.orderId = iprot.readI64();
18935 
        else:
18936 
          iprot.skip(ftype)
18937 
      else:
18938 
        iprot.skip(ftype)
18939 
      iprot.readFieldEnd()
18940 
    iprot.readStructEnd()
18941 
 
18942 
  def write(self, oprot):
18943 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18944 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18945 
      return
18946 
    oprot.writeStructBegin('reshipOrder_args')
3431 rajveer 18947 
    if self.orderId is not None:
2616 chandransh 18948 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
18949 
      oprot.writeI64(self.orderId)
18950 
      oprot.writeFieldEnd()
18951 
    oprot.writeFieldStop()
18952 
    oprot.writeStructEnd()
18953 
 
3431 rajveer 18954 
  def validate(self):
18955 
    return
18956 
 
18957 
 
2616 chandransh 18958 
  def __repr__(self):
18959 
    L = ['%s=%r' % (key, value)
18960 
      for key, value in self.__dict__.iteritems()]
18961 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18962 
 
18963 
  def __eq__(self, other):
18964 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18965 
 
18966 
  def __ne__(self, other):
18967 
    return not (self == other)
18968 
 
18969 
class reshipOrder_result:
18970 
  """
18971 
  Attributes:
18972 
   - success
18973 
   - ex
18974 
  """
18975 
 
18976 
  thrift_spec = (
18977 
    (0, TType.I64, 'success', None, None, ), # 0
18978 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
18979 
  )
18980 
 
18981 
  def __init__(self, success=None, ex=None,):
18982 
    self.success = success
18983 
    self.ex = ex
18984 
 
18985 
  def read(self, iprot):
18986 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18987 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18988 
      return
18989 
    iprot.readStructBegin()
18990 
    while True:
18991 
      (fname, ftype, fid) = iprot.readFieldBegin()
18992 
      if ftype == TType.STOP:
18993 
        break
18994 
      if fid == 0:
18995 
        if ftype == TType.I64:
18996 
          self.success = iprot.readI64();
18997 
        else:
18998 
          iprot.skip(ftype)
18999 
      elif fid == 1:
19000 
        if ftype == TType.STRUCT:
19001 
          self.ex = TransactionServiceException()
19002 
          self.ex.read(iprot)
19003 
        else:
19004 
          iprot.skip(ftype)
19005 
      else:
19006 
        iprot.skip(ftype)
19007 
      iprot.readFieldEnd()
19008 
    iprot.readStructEnd()
19009 
 
19010 
  def write(self, oprot):
19011 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19012 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19013 
      return
19014 
    oprot.writeStructBegin('reshipOrder_result')
3431 rajveer 19015 
    if self.success is not None:
2616 chandransh 19016 
      oprot.writeFieldBegin('success', TType.I64, 0)
19017 
      oprot.writeI64(self.success)
19018 
      oprot.writeFieldEnd()
3431 rajveer 19019 
    if self.ex is not None:
2616 chandransh 19020 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
19021 
      self.ex.write(oprot)
19022 
      oprot.writeFieldEnd()
19023 
    oprot.writeFieldStop()
19024 
    oprot.writeStructEnd()
19025 
 
3431 rajveer 19026 
  def validate(self):
19027 
    return
19028 
 
19029 
 
2616 chandransh 19030 
  def __repr__(self):
19031 
    L = ['%s=%r' % (key, value)
19032 
      for key, value in self.__dict__.iteritems()]
19033 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19034 
 
19035 
  def __eq__(self, other):
19036 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19037 
 
19038 
  def __ne__(self, other):
19039 
    return not (self == other)
19040 
 
19041 
class refundOrder_args:
19042 
  """
19043 
  Attributes:
19044 
   - orderId
3226 chandransh 19045 
   - refundedBy
19046 
   - reason
2616 chandransh 19047 
  """
19048 
 
19049 
  thrift_spec = (
19050 
    None, # 0
19051 
    (1, TType.I64, 'orderId', None, None, ), # 1
3226 chandransh 19052 
    (2, TType.STRING, 'refundedBy', None, None, ), # 2
19053 
    (3, TType.STRING, 'reason', None, None, ), # 3
2616 chandransh 19054 
  )
19055 
 
3226 chandransh 19056 
  def __init__(self, orderId=None, refundedBy=None, reason=None,):
2616 chandransh 19057 
    self.orderId = orderId
3226 chandransh 19058 
    self.refundedBy = refundedBy
19059 
    self.reason = reason
2616 chandransh 19060 
 
19061 
  def read(self, iprot):
19062 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19063 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19064 
      return
19065 
    iprot.readStructBegin()
19066 
    while True:
19067 
      (fname, ftype, fid) = iprot.readFieldBegin()
19068 
      if ftype == TType.STOP:
19069 
        break
19070 
      if fid == 1:
19071 
        if ftype == TType.I64:
19072 
          self.orderId = iprot.readI64();
19073 
        else:
19074 
          iprot.skip(ftype)
3226 chandransh 19075 
      elif fid == 2:
19076 
        if ftype == TType.STRING:
19077 
          self.refundedBy = iprot.readString();
19078 
        else:
19079 
          iprot.skip(ftype)
19080 
      elif fid == 3:
19081 
        if ftype == TType.STRING:
19082 
          self.reason = iprot.readString();
19083 
        else:
19084 
          iprot.skip(ftype)
2616 chandransh 19085 
      else:
19086 
        iprot.skip(ftype)
19087 
      iprot.readFieldEnd()
19088 
    iprot.readStructEnd()
19089 
 
19090 
  def write(self, oprot):
19091 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19092 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19093 
      return
19094 
    oprot.writeStructBegin('refundOrder_args')
3431 rajveer 19095 
    if self.orderId is not None:
2616 chandransh 19096 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
19097 
      oprot.writeI64(self.orderId)
19098 
      oprot.writeFieldEnd()
3431 rajveer 19099 
    if self.refundedBy is not None:
3226 chandransh 19100 
      oprot.writeFieldBegin('refundedBy', TType.STRING, 2)
19101 
      oprot.writeString(self.refundedBy)
19102 
      oprot.writeFieldEnd()
3431 rajveer 19103 
    if self.reason is not None:
3226 chandransh 19104 
      oprot.writeFieldBegin('reason', TType.STRING, 3)
19105 
      oprot.writeString(self.reason)
19106 
      oprot.writeFieldEnd()
2616 chandransh 19107 
    oprot.writeFieldStop()
19108 
    oprot.writeStructEnd()
19109 
 
3431 rajveer 19110 
  def validate(self):
19111 
    return
19112 
 
19113 
 
2616 chandransh 19114 
  def __repr__(self):
19115 
    L = ['%s=%r' % (key, value)
19116 
      for key, value in self.__dict__.iteritems()]
19117 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19118 
 
19119 
  def __eq__(self, other):
19120 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19121 
 
19122 
  def __ne__(self, other):
19123 
    return not (self == other)
19124 
 
19125 
class refundOrder_result:
19126 
  """
19127 
  Attributes:
19128 
   - success
19129 
   - ex
19130 
  """
19131 
 
19132 
  thrift_spec = (
19133 
    (0, TType.BOOL, 'success', None, None, ), # 0
19134 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
19135 
  )
19136 
 
19137 
  def __init__(self, success=None, ex=None,):
19138 
    self.success = success
19139 
    self.ex = ex
19140 
 
19141 
  def read(self, iprot):
19142 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19143 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19144 
      return
19145 
    iprot.readStructBegin()
19146 
    while True:
19147 
      (fname, ftype, fid) = iprot.readFieldBegin()
19148 
      if ftype == TType.STOP:
19149 
        break
19150 
      if fid == 0:
19151 
        if ftype == TType.BOOL:
19152 
          self.success = iprot.readBool();
19153 
        else:
19154 
          iprot.skip(ftype)
19155 
      elif fid == 1:
19156 
        if ftype == TType.STRUCT:
19157 
          self.ex = TransactionServiceException()
19158 
          self.ex.read(iprot)
19159 
        else:
19160 
          iprot.skip(ftype)
19161 
      else:
19162 
        iprot.skip(ftype)
19163 
      iprot.readFieldEnd()
19164 
    iprot.readStructEnd()
19165 
 
19166 
  def write(self, oprot):
19167 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19168 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19169 
      return
19170 
    oprot.writeStructBegin('refundOrder_result')
3431 rajveer 19171 
    if self.success is not None:
2616 chandransh 19172 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
19173 
      oprot.writeBool(self.success)
19174 
      oprot.writeFieldEnd()
3431 rajveer 19175 
    if self.ex is not None:
2616 chandransh 19176 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
19177 
      self.ex.write(oprot)
19178 
      oprot.writeFieldEnd()
19179 
    oprot.writeFieldStop()
19180 
    oprot.writeStructEnd()
19181 
 
3431 rajveer 19182 
  def validate(self):
19183 
    return
19184 
 
19185 
 
2616 chandransh 19186 
  def __repr__(self):
19187 
    L = ['%s=%r' % (key, value)
19188 
      for key, value in self.__dict__.iteritems()]
19189 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19190 
 
19191 
  def __eq__(self, other):
19192 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19193 
 
19194 
  def __ne__(self, other):
19195 
    return not (self == other)
19196 
 
2690 chandransh 19197 
class getReturnOrders_args:
19198 
  """
19199 
  Attributes:
19200 
   - warehouseId
19201 
   - fromDate
19202 
   - toDate
19203 
  """
2616 chandransh 19204 
 
2690 chandransh 19205 
  thrift_spec = (
19206 
    None, # 0
19207 
    (1, TType.I64, 'warehouseId', None, None, ), # 1
19208 
    (2, TType.I64, 'fromDate', None, None, ), # 2
19209 
    (3, TType.I64, 'toDate', None, None, ), # 3
19210 
  )
19211 
 
19212 
  def __init__(self, warehouseId=None, fromDate=None, toDate=None,):
19213 
    self.warehouseId = warehouseId
19214 
    self.fromDate = fromDate
19215 
    self.toDate = toDate
19216 
 
19217 
  def read(self, iprot):
19218 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19219 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19220 
      return
19221 
    iprot.readStructBegin()
19222 
    while True:
19223 
      (fname, ftype, fid) = iprot.readFieldBegin()
19224 
      if ftype == TType.STOP:
19225 
        break
19226 
      if fid == 1:
19227 
        if ftype == TType.I64:
19228 
          self.warehouseId = iprot.readI64();
19229 
        else:
19230 
          iprot.skip(ftype)
19231 
      elif fid == 2:
19232 
        if ftype == TType.I64:
19233 
          self.fromDate = iprot.readI64();
19234 
        else:
19235 
          iprot.skip(ftype)
19236 
      elif fid == 3:
19237 
        if ftype == TType.I64:
19238 
          self.toDate = iprot.readI64();
19239 
        else:
19240 
          iprot.skip(ftype)
19241 
      else:
19242 
        iprot.skip(ftype)
19243 
      iprot.readFieldEnd()
19244 
    iprot.readStructEnd()
19245 
 
19246 
  def write(self, oprot):
19247 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19248 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19249 
      return
19250 
    oprot.writeStructBegin('getReturnOrders_args')
3431 rajveer 19251 
    if self.warehouseId is not None:
2690 chandransh 19252 
      oprot.writeFieldBegin('warehouseId', TType.I64, 1)
19253 
      oprot.writeI64(self.warehouseId)
19254 
      oprot.writeFieldEnd()
3431 rajveer 19255 
    if self.fromDate is not None:
2690 chandransh 19256 
      oprot.writeFieldBegin('fromDate', TType.I64, 2)
19257 
      oprot.writeI64(self.fromDate)
19258 
      oprot.writeFieldEnd()
3431 rajveer 19259 
    if self.toDate is not None:
2690 chandransh 19260 
      oprot.writeFieldBegin('toDate', TType.I64, 3)
19261 
      oprot.writeI64(self.toDate)
19262 
      oprot.writeFieldEnd()
19263 
    oprot.writeFieldStop()
19264 
    oprot.writeStructEnd()
19265 
 
3431 rajveer 19266 
  def validate(self):
19267 
    return
19268 
 
19269 
 
2690 chandransh 19270 
  def __repr__(self):
19271 
    L = ['%s=%r' % (key, value)
19272 
      for key, value in self.__dict__.iteritems()]
19273 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19274 
 
19275 
  def __eq__(self, other):
19276 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19277 
 
19278 
  def __ne__(self, other):
19279 
    return not (self == other)
19280 
 
19281 
class getReturnOrders_result:
19282 
  """
19283 
  Attributes:
19284 
   - success
19285 
  """
19286 
 
19287 
  thrift_spec = (
19288 
    (0, TType.LIST, 'success', (TType.STRUCT,(ReturnOrder, ReturnOrder.thrift_spec)), None, ), # 0
19289 
  )
19290 
 
19291 
  def __init__(self, success=None,):
19292 
    self.success = success
19293 
 
19294 
  def read(self, iprot):
19295 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19296 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19297 
      return
19298 
    iprot.readStructBegin()
19299 
    while True:
19300 
      (fname, ftype, fid) = iprot.readFieldBegin()
19301 
      if ftype == TType.STOP:
19302 
        break
19303 
      if fid == 0:
19304 
        if ftype == TType.LIST:
19305 
          self.success = []
6188 rajveer 19306 
          (_etype442, _size439) = iprot.readListBegin()
19307 
          for _i443 in xrange(_size439):
19308 
            _elem444 = ReturnOrder()
19309 
            _elem444.read(iprot)
19310 
            self.success.append(_elem444)
2690 chandransh 19311 
          iprot.readListEnd()
19312 
        else:
19313 
          iprot.skip(ftype)
19314 
      else:
19315 
        iprot.skip(ftype)
19316 
      iprot.readFieldEnd()
19317 
    iprot.readStructEnd()
19318 
 
19319 
  def write(self, oprot):
19320 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19321 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19322 
      return
19323 
    oprot.writeStructBegin('getReturnOrders_result')
3431 rajveer 19324 
    if self.success is not None:
2690 chandransh 19325 
      oprot.writeFieldBegin('success', TType.LIST, 0)
19326 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 19327 
      for iter445 in self.success:
19328 
        iter445.write(oprot)
2690 chandransh 19329 
      oprot.writeListEnd()
19330 
      oprot.writeFieldEnd()
19331 
    oprot.writeFieldStop()
19332 
    oprot.writeStructEnd()
19333 
 
3431 rajveer 19334 
  def validate(self):
19335 
    return
19336 
 
19337 
 
2690 chandransh 19338 
  def __repr__(self):
19339 
    L = ['%s=%r' % (key, value)
19340 
      for key, value in self.__dict__.iteritems()]
19341 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19342 
 
19343 
  def __eq__(self, other):
19344 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19345 
 
19346 
  def __ne__(self, other):
19347 
    return not (self == other)
19348 
 
5481 phani.kuma 19349 
class getAllReturnOrders_args:
19350 
  """
19351 
  Attributes:
19352 
   - onlyNotProcessed
19353 
   - fromDate
19354 
   - toDate
19355 
  """
19356 
 
19357 
  thrift_spec = (
19358 
    None, # 0
19359 
    (1, TType.BOOL, 'onlyNotProcessed', None, None, ), # 1
19360 
    (2, TType.I64, 'fromDate', None, None, ), # 2
19361 
    (3, TType.I64, 'toDate', None, None, ), # 3
19362 
  )
19363 
 
19364 
  def __init__(self, onlyNotProcessed=None, fromDate=None, toDate=None,):
19365 
    self.onlyNotProcessed = onlyNotProcessed
19366 
    self.fromDate = fromDate
19367 
    self.toDate = toDate
19368 
 
19369 
  def read(self, iprot):
19370 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19371 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19372 
      return
19373 
    iprot.readStructBegin()
19374 
    while True:
19375 
      (fname, ftype, fid) = iprot.readFieldBegin()
19376 
      if ftype == TType.STOP:
19377 
        break
19378 
      if fid == 1:
19379 
        if ftype == TType.BOOL:
19380 
          self.onlyNotProcessed = iprot.readBool();
19381 
        else:
19382 
          iprot.skip(ftype)
19383 
      elif fid == 2:
19384 
        if ftype == TType.I64:
19385 
          self.fromDate = iprot.readI64();
19386 
        else:
19387 
          iprot.skip(ftype)
19388 
      elif fid == 3:
19389 
        if ftype == TType.I64:
19390 
          self.toDate = iprot.readI64();
19391 
        else:
19392 
          iprot.skip(ftype)
19393 
      else:
19394 
        iprot.skip(ftype)
19395 
      iprot.readFieldEnd()
19396 
    iprot.readStructEnd()
19397 
 
19398 
  def write(self, oprot):
19399 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19400 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19401 
      return
19402 
    oprot.writeStructBegin('getAllReturnOrders_args')
19403 
    if self.onlyNotProcessed is not None:
19404 
      oprot.writeFieldBegin('onlyNotProcessed', TType.BOOL, 1)
19405 
      oprot.writeBool(self.onlyNotProcessed)
19406 
      oprot.writeFieldEnd()
19407 
    if self.fromDate is not None:
19408 
      oprot.writeFieldBegin('fromDate', TType.I64, 2)
19409 
      oprot.writeI64(self.fromDate)
19410 
      oprot.writeFieldEnd()
19411 
    if self.toDate is not None:
19412 
      oprot.writeFieldBegin('toDate', TType.I64, 3)
19413 
      oprot.writeI64(self.toDate)
19414 
      oprot.writeFieldEnd()
19415 
    oprot.writeFieldStop()
19416 
    oprot.writeStructEnd()
19417 
 
19418 
  def validate(self):
19419 
    return
19420 
 
19421 
 
19422 
  def __repr__(self):
19423 
    L = ['%s=%r' % (key, value)
19424 
      for key, value in self.__dict__.iteritems()]
19425 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19426 
 
19427 
  def __eq__(self, other):
19428 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19429 
 
19430 
  def __ne__(self, other):
19431 
    return not (self == other)
19432 
 
19433 
class getAllReturnOrders_result:
19434 
  """
19435 
  Attributes:
19436 
   - success
19437 
  """
19438 
 
19439 
  thrift_spec = (
19440 
    (0, TType.LIST, 'success', (TType.STRUCT,(ReturnOrder, ReturnOrder.thrift_spec)), None, ), # 0
19441 
  )
19442 
 
19443 
  def __init__(self, success=None,):
19444 
    self.success = success
19445 
 
19446 
  def read(self, iprot):
19447 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19448 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19449 
      return
19450 
    iprot.readStructBegin()
19451 
    while True:
19452 
      (fname, ftype, fid) = iprot.readFieldBegin()
19453 
      if ftype == TType.STOP:
19454 
        break
19455 
      if fid == 0:
19456 
        if ftype == TType.LIST:
19457 
          self.success = []
6188 rajveer 19458 
          (_etype449, _size446) = iprot.readListBegin()
19459 
          for _i450 in xrange(_size446):
19460 
            _elem451 = ReturnOrder()
19461 
            _elem451.read(iprot)
19462 
            self.success.append(_elem451)
5481 phani.kuma 19463 
          iprot.readListEnd()
19464 
        else:
19465 
          iprot.skip(ftype)
19466 
      else:
19467 
        iprot.skip(ftype)
19468 
      iprot.readFieldEnd()
19469 
    iprot.readStructEnd()
19470 
 
19471 
  def write(self, oprot):
19472 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19473 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19474 
      return
19475 
    oprot.writeStructBegin('getAllReturnOrders_result')
19476 
    if self.success is not None:
19477 
      oprot.writeFieldBegin('success', TType.LIST, 0)
19478 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 19479 
      for iter452 in self.success:
19480 
        iter452.write(oprot)
5481 phani.kuma 19481 
      oprot.writeListEnd()
19482 
      oprot.writeFieldEnd()
19483 
    oprot.writeFieldStop()
19484 
    oprot.writeStructEnd()
19485 
 
19486 
  def validate(self):
19487 
    return
19488 
 
19489 
 
19490 
  def __repr__(self):
19491 
    L = ['%s=%r' % (key, value)
19492 
      for key, value in self.__dict__.iteritems()]
19493 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19494 
 
19495 
  def __eq__(self, other):
19496 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19497 
 
19498 
  def __ne__(self, other):
19499 
    return not (self == other)
19500 
 
2700 chandransh 19501 
class getReturnOrder_args:
19502 
  """
19503 
  Attributes:
19504 
   - id
19505 
  """
19506 
 
19507 
  thrift_spec = (
19508 
    None, # 0
19509 
    (1, TType.I64, 'id', None, None, ), # 1
19510 
  )
19511 
 
19512 
  def __init__(self, id=None,):
19513 
    self.id = id
19514 
 
19515 
  def read(self, iprot):
19516 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19517 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19518 
      return
19519 
    iprot.readStructBegin()
19520 
    while True:
19521 
      (fname, ftype, fid) = iprot.readFieldBegin()
19522 
      if ftype == TType.STOP:
19523 
        break
19524 
      if fid == 1:
19525 
        if ftype == TType.I64:
19526 
          self.id = iprot.readI64();
19527 
        else:
19528 
          iprot.skip(ftype)
19529 
      else:
19530 
        iprot.skip(ftype)
19531 
      iprot.readFieldEnd()
19532 
    iprot.readStructEnd()
19533 
 
19534 
  def write(self, oprot):
19535 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19536 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19537 
      return
19538 
    oprot.writeStructBegin('getReturnOrder_args')
3431 rajveer 19539 
    if self.id is not None:
2700 chandransh 19540 
      oprot.writeFieldBegin('id', TType.I64, 1)
19541 
      oprot.writeI64(self.id)
19542 
      oprot.writeFieldEnd()
19543 
    oprot.writeFieldStop()
19544 
    oprot.writeStructEnd()
19545 
 
3431 rajveer 19546 
  def validate(self):
19547 
    return
19548 
 
19549 
 
2700 chandransh 19550 
  def __repr__(self):
19551 
    L = ['%s=%r' % (key, value)
19552 
      for key, value in self.__dict__.iteritems()]
19553 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19554 
 
19555 
  def __eq__(self, other):
19556 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19557 
 
19558 
  def __ne__(self, other):
19559 
    return not (self == other)
19560 
 
19561 
class getReturnOrder_result:
19562 
  """
19563 
  Attributes:
19564 
   - success
19565 
   - ex
19566 
  """
19567 
 
19568 
  thrift_spec = (
19569 
    (0, TType.STRUCT, 'success', (ReturnOrder, ReturnOrder.thrift_spec), None, ), # 0
19570 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
19571 
  )
19572 
 
19573 
  def __init__(self, success=None, ex=None,):
19574 
    self.success = success
19575 
    self.ex = ex
19576 
 
19577 
  def read(self, iprot):
19578 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19579 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19580 
      return
19581 
    iprot.readStructBegin()
19582 
    while True:
19583 
      (fname, ftype, fid) = iprot.readFieldBegin()
19584 
      if ftype == TType.STOP:
19585 
        break
19586 
      if fid == 0:
19587 
        if ftype == TType.STRUCT:
19588 
          self.success = ReturnOrder()
19589 
          self.success.read(iprot)
19590 
        else:
19591 
          iprot.skip(ftype)
19592 
      elif fid == 1:
19593 
        if ftype == TType.STRUCT:
19594 
          self.ex = TransactionServiceException()
19595 
          self.ex.read(iprot)
19596 
        else:
19597 
          iprot.skip(ftype)
19598 
      else:
19599 
        iprot.skip(ftype)
19600 
      iprot.readFieldEnd()
19601 
    iprot.readStructEnd()
19602 
 
19603 
  def write(self, oprot):
19604 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19605 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19606 
      return
19607 
    oprot.writeStructBegin('getReturnOrder_result')
3431 rajveer 19608 
    if self.success is not None:
2700 chandransh 19609 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
19610 
      self.success.write(oprot)
19611 
      oprot.writeFieldEnd()
3431 rajveer 19612 
    if self.ex is not None:
2700 chandransh 19613 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
19614 
      self.ex.write(oprot)
19615 
      oprot.writeFieldEnd()
19616 
    oprot.writeFieldStop()
19617 
    oprot.writeStructEnd()
19618 
 
3431 rajveer 19619 
  def validate(self):
19620 
    return
19621 
 
19622 
 
2700 chandransh 19623 
  def __repr__(self):
19624 
    L = ['%s=%r' % (key, value)
19625 
      for key, value in self.__dict__.iteritems()]
19626 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19627 
 
19628 
  def __eq__(self, other):
19629 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19630 
 
19631 
  def __ne__(self, other):
19632 
    return not (self == other)
19633 
 
2690 chandransh 19634 
class processReturn_args:
19635 
  """
19636 
  Attributes:
19637 
   - returnOrderId
19638 
  """
19639 
 
19640 
  thrift_spec = (
19641 
    None, # 0
19642 
    (1, TType.I64, 'returnOrderId', None, None, ), # 1
19643 
  )
19644 
 
19645 
  def __init__(self, returnOrderId=None,):
19646 
    self.returnOrderId = returnOrderId
19647 
 
19648 
  def read(self, iprot):
19649 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19650 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19651 
      return
19652 
    iprot.readStructBegin()
19653 
    while True:
19654 
      (fname, ftype, fid) = iprot.readFieldBegin()
19655 
      if ftype == TType.STOP:
19656 
        break
19657 
      if fid == 1:
19658 
        if ftype == TType.I64:
19659 
          self.returnOrderId = iprot.readI64();
19660 
        else:
19661 
          iprot.skip(ftype)
19662 
      else:
19663 
        iprot.skip(ftype)
19664 
      iprot.readFieldEnd()
19665 
    iprot.readStructEnd()
19666 
 
19667 
  def write(self, oprot):
19668 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19669 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19670 
      return
19671 
    oprot.writeStructBegin('processReturn_args')
3431 rajveer 19672 
    if self.returnOrderId is not None:
2690 chandransh 19673 
      oprot.writeFieldBegin('returnOrderId', TType.I64, 1)
19674 
      oprot.writeI64(self.returnOrderId)
19675 
      oprot.writeFieldEnd()
19676 
    oprot.writeFieldStop()
19677 
    oprot.writeStructEnd()
19678 
 
3431 rajveer 19679 
  def validate(self):
19680 
    return
19681 
 
19682 
 
2690 chandransh 19683 
  def __repr__(self):
19684 
    L = ['%s=%r' % (key, value)
19685 
      for key, value in self.__dict__.iteritems()]
19686 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19687 
 
19688 
  def __eq__(self, other):
19689 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19690 
 
19691 
  def __ne__(self, other):
19692 
    return not (self == other)
19693 
 
19694 
class processReturn_result:
19695 
  """
19696 
  Attributes:
19697 
   - ex
19698 
  """
19699 
 
19700 
  thrift_spec = (
19701 
    None, # 0
19702 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
19703 
  )
19704 
 
19705 
  def __init__(self, ex=None,):
19706 
    self.ex = ex
19707 
 
19708 
  def read(self, iprot):
19709 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19710 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19711 
      return
19712 
    iprot.readStructBegin()
19713 
    while True:
19714 
      (fname, ftype, fid) = iprot.readFieldBegin()
19715 
      if ftype == TType.STOP:
19716 
        break
19717 
      if fid == 1:
19718 
        if ftype == TType.STRUCT:
19719 
          self.ex = TransactionServiceException()
19720 
          self.ex.read(iprot)
19721 
        else:
19722 
          iprot.skip(ftype)
19723 
      else:
19724 
        iprot.skip(ftype)
19725 
      iprot.readFieldEnd()
19726 
    iprot.readStructEnd()
19727 
 
19728 
  def write(self, oprot):
19729 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19730 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19731 
      return
19732 
    oprot.writeStructBegin('processReturn_result')
3431 rajveer 19733 
    if self.ex is not None:
2690 chandransh 19734 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
19735 
      self.ex.write(oprot)
19736 
      oprot.writeFieldEnd()
19737 
    oprot.writeFieldStop()
19738 
    oprot.writeStructEnd()
19739 
 
3431 rajveer 19740 
  def validate(self):
19741 
    return
19742 
 
19743 
 
2690 chandransh 19744 
  def __repr__(self):
19745 
    L = ['%s=%r' % (key, value)
19746 
      for key, value in self.__dict__.iteritems()]
19747 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19748 
 
19749 
  def __eq__(self, other):
19750 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19751 
 
19752 
  def __ne__(self, other):
19753 
    return not (self == other)
19754 
 
3451 chandransh 19755 
class updateWeight_args:
19756 
  """
19757 
  Attributes:
19758 
   - orderId
19759 
   - weight
19760 
  """
19761 
 
19762 
  thrift_spec = (
19763 
    None, # 0
19764 
    (1, TType.I64, 'orderId', None, None, ), # 1
19765 
    (2, TType.DOUBLE, 'weight', None, None, ), # 2
19766 
  )
19767 
 
19768 
  def __init__(self, orderId=None, weight=None,):
19769 
    self.orderId = orderId
19770 
    self.weight = weight
19771 
 
19772 
  def read(self, iprot):
19773 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19774 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19775 
      return
19776 
    iprot.readStructBegin()
19777 
    while True:
19778 
      (fname, ftype, fid) = iprot.readFieldBegin()
19779 
      if ftype == TType.STOP:
19780 
        break
19781 
      if fid == 1:
19782 
        if ftype == TType.I64:
19783 
          self.orderId = iprot.readI64();
19784 
        else:
19785 
          iprot.skip(ftype)
19786 
      elif fid == 2:
19787 
        if ftype == TType.DOUBLE:
19788 
          self.weight = iprot.readDouble();
19789 
        else:
19790 
          iprot.skip(ftype)
19791 
      else:
19792 
        iprot.skip(ftype)
19793 
      iprot.readFieldEnd()
19794 
    iprot.readStructEnd()
19795 
 
19796 
  def write(self, oprot):
19797 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19798 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19799 
      return
19800 
    oprot.writeStructBegin('updateWeight_args')
19801 
    if self.orderId is not None:
19802 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
19803 
      oprot.writeI64(self.orderId)
19804 
      oprot.writeFieldEnd()
19805 
    if self.weight is not None:
19806 
      oprot.writeFieldBegin('weight', TType.DOUBLE, 2)
19807 
      oprot.writeDouble(self.weight)
19808 
      oprot.writeFieldEnd()
19809 
    oprot.writeFieldStop()
19810 
    oprot.writeStructEnd()
19811 
 
19812 
  def validate(self):
19813 
    return
19814 
 
19815 
 
19816 
  def __repr__(self):
19817 
    L = ['%s=%r' % (key, value)
19818 
      for key, value in self.__dict__.iteritems()]
19819 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19820 
 
19821 
  def __eq__(self, other):
19822 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19823 
 
19824 
  def __ne__(self, other):
19825 
    return not (self == other)
19826 
 
19827 
class updateWeight_result:
19828 
  """
19829 
  Attributes:
19830 
   - success
19831 
   - ex
19832 
  """
19833 
 
19834 
  thrift_spec = (
19835 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
19836 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
19837 
  )
19838 
 
19839 
  def __init__(self, success=None, ex=None,):
19840 
    self.success = success
19841 
    self.ex = ex
19842 
 
19843 
  def read(self, iprot):
19844 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19845 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19846 
      return
19847 
    iprot.readStructBegin()
19848 
    while True:
19849 
      (fname, ftype, fid) = iprot.readFieldBegin()
19850 
      if ftype == TType.STOP:
19851 
        break
19852 
      if fid == 0:
19853 
        if ftype == TType.STRUCT:
19854 
          self.success = Order()
19855 
          self.success.read(iprot)
19856 
        else:
19857 
          iprot.skip(ftype)
19858 
      elif fid == 1:
19859 
        if ftype == TType.STRUCT:
19860 
          self.ex = TransactionServiceException()
19861 
          self.ex.read(iprot)
19862 
        else:
19863 
          iprot.skip(ftype)
19864 
      else:
19865 
        iprot.skip(ftype)
19866 
      iprot.readFieldEnd()
19867 
    iprot.readStructEnd()
19868 
 
19869 
  def write(self, oprot):
19870 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19871 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19872 
      return
19873 
    oprot.writeStructBegin('updateWeight_result')
19874 
    if self.success is not None:
19875 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
19876 
      self.success.write(oprot)
19877 
      oprot.writeFieldEnd()
19878 
    if self.ex is not None:
19879 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
19880 
      self.ex.write(oprot)
19881 
      oprot.writeFieldEnd()
19882 
    oprot.writeFieldStop()
19883 
    oprot.writeStructEnd()
19884 
 
19885 
  def validate(self):
19886 
    return
19887 
 
19888 
 
19889 
  def __repr__(self):
19890 
    L = ['%s=%r' % (key, value)
19891 
      for key, value in self.__dict__.iteritems()]
19892 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19893 
 
19894 
  def __eq__(self, other):
19895 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19896 
 
19897 
  def __ne__(self, other):
19898 
    return not (self == other)
3469 chandransh 19899 
 
19900 
class changeItem_args:
19901 
  """
19902 
  Attributes:
19903 
   - orderId
19904 
   - itemId
19905 
  """
19906 
 
19907 
  thrift_spec = (
19908 
    None, # 0
19909 
    (1, TType.I64, 'orderId', None, None, ), # 1
19910 
    (2, TType.I64, 'itemId', None, None, ), # 2
19911 
  )
19912 
 
19913 
  def __init__(self, orderId=None, itemId=None,):
19914 
    self.orderId = orderId
19915 
    self.itemId = itemId
19916 
 
19917 
  def read(self, iprot):
19918 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19919 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19920 
      return
19921 
    iprot.readStructBegin()
19922 
    while True:
19923 
      (fname, ftype, fid) = iprot.readFieldBegin()
19924 
      if ftype == TType.STOP:
19925 
        break
19926 
      if fid == 1:
19927 
        if ftype == TType.I64:
19928 
          self.orderId = iprot.readI64();
19929 
        else:
19930 
          iprot.skip(ftype)
19931 
      elif fid == 2:
19932 
        if ftype == TType.I64:
19933 
          self.itemId = iprot.readI64();
19934 
        else:
19935 
          iprot.skip(ftype)
19936 
      else:
19937 
        iprot.skip(ftype)
19938 
      iprot.readFieldEnd()
19939 
    iprot.readStructEnd()
19940 
 
19941 
  def write(self, oprot):
19942 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19943 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19944 
      return
19945 
    oprot.writeStructBegin('changeItem_args')
19946 
    if self.orderId is not None:
19947 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
19948 
      oprot.writeI64(self.orderId)
19949 
      oprot.writeFieldEnd()
19950 
    if self.itemId is not None:
19951 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
19952 
      oprot.writeI64(self.itemId)
19953 
      oprot.writeFieldEnd()
19954 
    oprot.writeFieldStop()
19955 
    oprot.writeStructEnd()
19956 
 
19957 
  def validate(self):
19958 
    return
19959 
 
19960 
 
19961 
  def __repr__(self):
19962 
    L = ['%s=%r' % (key, value)
19963 
      for key, value in self.__dict__.iteritems()]
19964 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19965 
 
19966 
  def __eq__(self, other):
19967 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19968 
 
19969 
  def __ne__(self, other):
19970 
    return not (self == other)
19971 
 
19972 
class changeItem_result:
19973 
  """
19974 
  Attributes:
19975 
   - success
19976 
   - ex
19977 
  """
19978 
 
19979 
  thrift_spec = (
19980 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
19981 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
19982 
  )
19983 
 
19984 
  def __init__(self, success=None, ex=None,):
19985 
    self.success = success
19986 
    self.ex = ex
19987 
 
19988 
  def read(self, iprot):
19989 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19990 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19991 
      return
19992 
    iprot.readStructBegin()
19993 
    while True:
19994 
      (fname, ftype, fid) = iprot.readFieldBegin()
19995 
      if ftype == TType.STOP:
19996 
        break
19997 
      if fid == 0:
19998 
        if ftype == TType.STRUCT:
19999 
          self.success = Order()
20000 
          self.success.read(iprot)
20001 
        else:
20002 
          iprot.skip(ftype)
20003 
      elif fid == 1:
20004 
        if ftype == TType.STRUCT:
20005 
          self.ex = TransactionServiceException()
20006 
          self.ex.read(iprot)
20007 
        else:
20008 
          iprot.skip(ftype)
20009 
      else:
20010 
        iprot.skip(ftype)
20011 
      iprot.readFieldEnd()
20012 
    iprot.readStructEnd()
20013 
 
20014 
  def write(self, oprot):
20015 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20016 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20017 
      return
20018 
    oprot.writeStructBegin('changeItem_result')
20019 
    if self.success is not None:
20020 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
20021 
      self.success.write(oprot)
20022 
      oprot.writeFieldEnd()
20023 
    if self.ex is not None:
20024 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
20025 
      self.ex.write(oprot)
20026 
      oprot.writeFieldEnd()
20027 
    oprot.writeFieldStop()
20028 
    oprot.writeStructEnd()
20029 
 
20030 
  def validate(self):
20031 
    return
20032 
 
20033 
 
20034 
  def __repr__(self):
20035 
    L = ['%s=%r' % (key, value)
20036 
      for key, value in self.__dict__.iteritems()]
20037 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20038 
 
20039 
  def __eq__(self, other):
20040 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20041 
 
20042 
  def __ne__(self, other):
20043 
    return not (self == other)
20044 
 
20045 
class shiftToWarehouse_args:
20046 
  """
20047 
  Attributes:
20048 
   - orderId
20049 
   - warehouseId
20050 
  """
20051 
 
20052 
  thrift_spec = (
20053 
    None, # 0
20054 
    (1, TType.I64, 'orderId', None, None, ), # 1
20055 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
20056 
  )
20057 
 
20058 
  def __init__(self, orderId=None, warehouseId=None,):
20059 
    self.orderId = orderId
20060 
    self.warehouseId = warehouseId
20061 
 
20062 
  def read(self, iprot):
20063 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20064 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20065 
      return
20066 
    iprot.readStructBegin()
20067 
    while True:
20068 
      (fname, ftype, fid) = iprot.readFieldBegin()
20069 
      if ftype == TType.STOP:
20070 
        break
20071 
      if fid == 1:
20072 
        if ftype == TType.I64:
20073 
          self.orderId = iprot.readI64();
20074 
        else:
20075 
          iprot.skip(ftype)
20076 
      elif fid == 2:
20077 
        if ftype == TType.I64:
20078 
          self.warehouseId = iprot.readI64();
20079 
        else:
20080 
          iprot.skip(ftype)
20081 
      else:
20082 
        iprot.skip(ftype)
20083 
      iprot.readFieldEnd()
20084 
    iprot.readStructEnd()
20085 
 
20086 
  def write(self, oprot):
20087 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20088 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20089 
      return
20090 
    oprot.writeStructBegin('shiftToWarehouse_args')
20091 
    if self.orderId is not None:
20092 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
20093 
      oprot.writeI64(self.orderId)
20094 
      oprot.writeFieldEnd()
20095 
    if self.warehouseId is not None:
20096 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
20097 
      oprot.writeI64(self.warehouseId)
20098 
      oprot.writeFieldEnd()
20099 
    oprot.writeFieldStop()
20100 
    oprot.writeStructEnd()
20101 
 
20102 
  def validate(self):
20103 
    return
20104 
 
20105 
 
20106 
  def __repr__(self):
20107 
    L = ['%s=%r' % (key, value)
20108 
      for key, value in self.__dict__.iteritems()]
20109 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20110 
 
20111 
  def __eq__(self, other):
20112 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20113 
 
20114 
  def __ne__(self, other):
20115 
    return not (self == other)
20116 
 
20117 
class shiftToWarehouse_result:
20118 
  """
20119 
  Attributes:
20120 
   - success
20121 
   - ex
20122 
  """
20123 
 
20124 
  thrift_spec = (
20125 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
20126 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
20127 
  )
20128 
 
20129 
  def __init__(self, success=None, ex=None,):
20130 
    self.success = success
20131 
    self.ex = ex
20132 
 
20133 
  def read(self, iprot):
20134 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20135 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20136 
      return
20137 
    iprot.readStructBegin()
20138 
    while True:
20139 
      (fname, ftype, fid) = iprot.readFieldBegin()
20140 
      if ftype == TType.STOP:
20141 
        break
20142 
      if fid == 0:
20143 
        if ftype == TType.STRUCT:
20144 
          self.success = Order()
20145 
          self.success.read(iprot)
20146 
        else:
20147 
          iprot.skip(ftype)
20148 
      elif fid == 1:
20149 
        if ftype == TType.STRUCT:
20150 
          self.ex = TransactionServiceException()
20151 
          self.ex.read(iprot)
20152 
        else:
20153 
          iprot.skip(ftype)
20154 
      else:
20155 
        iprot.skip(ftype)
20156 
      iprot.readFieldEnd()
20157 
    iprot.readStructEnd()
20158 
 
20159 
  def write(self, oprot):
20160 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20161 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20162 
      return
20163 
    oprot.writeStructBegin('shiftToWarehouse_result')
20164 
    if self.success is not None:
20165 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
20166 
      self.success.write(oprot)
20167 
      oprot.writeFieldEnd()
20168 
    if self.ex is not None:
20169 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
20170 
      self.ex.write(oprot)
20171 
      oprot.writeFieldEnd()
20172 
    oprot.writeFieldStop()
20173 
    oprot.writeStructEnd()
20174 
 
20175 
  def validate(self):
20176 
    return
20177 
 
20178 
 
20179 
  def __repr__(self):
20180 
    L = ['%s=%r' % (key, value)
20181 
      for key, value in self.__dict__.iteritems()]
20182 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20183 
 
20184 
  def __eq__(self, other):
20185 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20186 
 
20187 
  def __ne__(self, other):
20188 
    return not (self == other)
3553 chandransh 20189 
 
20190 
class addDelayReason_args:
20191 
  """
20192 
  Attributes:
20193 
   - orderId
20194 
   - delayReason
3986 chandransh 20195 
   - furtherDelay
4647 rajveer 20196 
   - delayReasonText
3553 chandransh 20197 
  """
20198 
 
20199 
  thrift_spec = (
20200 
    None, # 0
20201 
    (1, TType.I64, 'orderId', None, None, ), # 1
20202 
    (2, TType.I32, 'delayReason', None, None, ), # 2
3986 chandransh 20203 
    (3, TType.I64, 'furtherDelay', None, None, ), # 3
4647 rajveer 20204 
    (4, TType.STRING, 'delayReasonText', None, None, ), # 4
3553 chandransh 20205 
  )
20206 
 
4647 rajveer 20207 
  def __init__(self, orderId=None, delayReason=None, furtherDelay=None, delayReasonText=None,):
3553 chandransh 20208 
    self.orderId = orderId
20209 
    self.delayReason = delayReason
3986 chandransh 20210 
    self.furtherDelay = furtherDelay
4647 rajveer 20211 
    self.delayReasonText = delayReasonText
3553 chandransh 20212 
 
20213 
  def read(self, iprot):
20214 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20215 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20216 
      return
20217 
    iprot.readStructBegin()
20218 
    while True:
20219 
      (fname, ftype, fid) = iprot.readFieldBegin()
20220 
      if ftype == TType.STOP:
20221 
        break
20222 
      if fid == 1:
20223 
        if ftype == TType.I64:
20224 
          self.orderId = iprot.readI64();
20225 
        else:
20226 
          iprot.skip(ftype)
20227 
      elif fid == 2:
20228 
        if ftype == TType.I32:
20229 
          self.delayReason = iprot.readI32();
20230 
        else:
20231 
          iprot.skip(ftype)
3986 chandransh 20232 
      elif fid == 3:
20233 
        if ftype == TType.I64:
20234 
          self.furtherDelay = iprot.readI64();
20235 
        else:
20236 
          iprot.skip(ftype)
4647 rajveer 20237 
      elif fid == 4:
20238 
        if ftype == TType.STRING:
20239 
          self.delayReasonText = iprot.readString();
20240 
        else:
20241 
          iprot.skip(ftype)
3553 chandransh 20242 
      else:
20243 
        iprot.skip(ftype)
20244 
      iprot.readFieldEnd()
20245 
    iprot.readStructEnd()
20246 
 
20247 
  def write(self, oprot):
20248 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20249 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20250 
      return
20251 
    oprot.writeStructBegin('addDelayReason_args')
20252 
    if self.orderId is not None:
20253 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
20254 
      oprot.writeI64(self.orderId)
20255 
      oprot.writeFieldEnd()
20256 
    if self.delayReason is not None:
20257 
      oprot.writeFieldBegin('delayReason', TType.I32, 2)
20258 
      oprot.writeI32(self.delayReason)
20259 
      oprot.writeFieldEnd()
3986 chandransh 20260 
    if self.furtherDelay is not None:
20261 
      oprot.writeFieldBegin('furtherDelay', TType.I64, 3)
20262 
      oprot.writeI64(self.furtherDelay)
20263 
      oprot.writeFieldEnd()
4647 rajveer 20264 
    if self.delayReasonText is not None:
20265 
      oprot.writeFieldBegin('delayReasonText', TType.STRING, 4)
20266 
      oprot.writeString(self.delayReasonText)
20267 
      oprot.writeFieldEnd()
3553 chandransh 20268 
    oprot.writeFieldStop()
20269 
    oprot.writeStructEnd()
20270 
 
20271 
  def validate(self):
20272 
    return
20273 
 
20274 
 
20275 
  def __repr__(self):
20276 
    L = ['%s=%r' % (key, value)
20277 
      for key, value in self.__dict__.iteritems()]
20278 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20279 
 
20280 
  def __eq__(self, other):
20281 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20282 
 
20283 
  def __ne__(self, other):
20284 
    return not (self == other)
20285 
 
20286 
class addDelayReason_result:
20287 
  """
20288 
  Attributes:
20289 
   - success
20290 
   - ex
20291 
  """
20292 
 
20293 
  thrift_spec = (
20294 
    (0, TType.BOOL, 'success', None, None, ), # 0
20295 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
20296 
  )
20297 
 
20298 
  def __init__(self, success=None, ex=None,):
20299 
    self.success = success
20300 
    self.ex = ex
20301 
 
20302 
  def read(self, iprot):
20303 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20304 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20305 
      return
20306 
    iprot.readStructBegin()
20307 
    while True:
20308 
      (fname, ftype, fid) = iprot.readFieldBegin()
20309 
      if ftype == TType.STOP:
20310 
        break
20311 
      if fid == 0:
20312 
        if ftype == TType.BOOL:
20313 
          self.success = iprot.readBool();
20314 
        else:
20315 
          iprot.skip(ftype)
20316 
      elif fid == 1:
20317 
        if ftype == TType.STRUCT:
20318 
          self.ex = TransactionServiceException()
20319 
          self.ex.read(iprot)
20320 
        else:
20321 
          iprot.skip(ftype)
20322 
      else:
20323 
        iprot.skip(ftype)
20324 
      iprot.readFieldEnd()
20325 
    iprot.readStructEnd()
20326 
 
20327 
  def write(self, oprot):
20328 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20329 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20330 
      return
20331 
    oprot.writeStructBegin('addDelayReason_result')
20332 
    if self.success is not None:
20333 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
20334 
      oprot.writeBool(self.success)
20335 
      oprot.writeFieldEnd()
20336 
    if self.ex is not None:
20337 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
20338 
      self.ex.write(oprot)
20339 
      oprot.writeFieldEnd()
20340 
    oprot.writeFieldStop()
20341 
    oprot.writeStructEnd()
20342 
 
20343 
  def validate(self):
20344 
    return
20345 
 
20346 
 
20347 
  def __repr__(self):
20348 
    L = ['%s=%r' % (key, value)
20349 
      for key, value in self.__dict__.iteritems()]
20350 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20351 
 
20352 
  def __eq__(self, other):
20353 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20354 
 
20355 
  def __ne__(self, other):
20356 
    return not (self == other)
3956 chandransh 20357 
 
20358 
class reconcileCodCollection_args:
20359 
  """
20360 
  Attributes:
20361 
   - collectedAmountMap
20362 
   - xferBy
20363 
   - xferTxnId
20364 
   - xferDate
20365 
  """
20366 
 
20367 
  thrift_spec = (
20368 
    None, # 0
20369 
    (1, TType.MAP, 'collectedAmountMap', (TType.STRING,None,TType.DOUBLE,None), None, ), # 1
20370 
    (2, TType.STRING, 'xferBy', None, None, ), # 2
20371 
    (3, TType.STRING, 'xferTxnId', None, None, ), # 3
20372 
    (4, TType.I64, 'xferDate', None, None, ), # 4
20373 
  )
20374 
 
20375 
  def __init__(self, collectedAmountMap=None, xferBy=None, xferTxnId=None, xferDate=None,):
20376 
    self.collectedAmountMap = collectedAmountMap
20377 
    self.xferBy = xferBy
20378 
    self.xferTxnId = xferTxnId
20379 
    self.xferDate = xferDate
20380 
 
20381 
  def read(self, iprot):
20382 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20383 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20384 
      return
20385 
    iprot.readStructBegin()
20386 
    while True:
20387 
      (fname, ftype, fid) = iprot.readFieldBegin()
20388 
      if ftype == TType.STOP:
20389 
        break
20390 
      if fid == 1:
20391 
        if ftype == TType.MAP:
20392 
          self.collectedAmountMap = {}
6188 rajveer 20393 
          (_ktype454, _vtype455, _size453 ) = iprot.readMapBegin()
20394 
          for _i457 in xrange(_size453):
20395 
            _key458 = iprot.readString();
20396 
            _val459 = iprot.readDouble();
20397 
            self.collectedAmountMap[_key458] = _val459
3956 chandransh 20398 
          iprot.readMapEnd()
20399 
        else:
20400 
          iprot.skip(ftype)
20401 
      elif fid == 2:
20402 
        if ftype == TType.STRING:
20403 
          self.xferBy = iprot.readString();
20404 
        else:
20405 
          iprot.skip(ftype)
20406 
      elif fid == 3:
20407 
        if ftype == TType.STRING:
20408 
          self.xferTxnId = iprot.readString();
20409 
        else:
20410 
          iprot.skip(ftype)
20411 
      elif fid == 4:
20412 
        if ftype == TType.I64:
20413 
          self.xferDate = iprot.readI64();
20414 
        else:
20415 
          iprot.skip(ftype)
20416 
      else:
20417 
        iprot.skip(ftype)
20418 
      iprot.readFieldEnd()
20419 
    iprot.readStructEnd()
20420 
 
20421 
  def write(self, oprot):
20422 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20423 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20424 
      return
20425 
    oprot.writeStructBegin('reconcileCodCollection_args')
20426 
    if self.collectedAmountMap is not None:
20427 
      oprot.writeFieldBegin('collectedAmountMap', TType.MAP, 1)
20428 
      oprot.writeMapBegin(TType.STRING, TType.DOUBLE, len(self.collectedAmountMap))
6188 rajveer 20429 
      for kiter460,viter461 in self.collectedAmountMap.items():
20430 
        oprot.writeString(kiter460)
20431 
        oprot.writeDouble(viter461)
3956 chandransh 20432 
      oprot.writeMapEnd()
20433 
      oprot.writeFieldEnd()
20434 
    if self.xferBy is not None:
20435 
      oprot.writeFieldBegin('xferBy', TType.STRING, 2)
20436 
      oprot.writeString(self.xferBy)
20437 
      oprot.writeFieldEnd()
20438 
    if self.xferTxnId is not None:
20439 
      oprot.writeFieldBegin('xferTxnId', TType.STRING, 3)
20440 
      oprot.writeString(self.xferTxnId)
20441 
      oprot.writeFieldEnd()
20442 
    if self.xferDate is not None:
20443 
      oprot.writeFieldBegin('xferDate', TType.I64, 4)
20444 
      oprot.writeI64(self.xferDate)
20445 
      oprot.writeFieldEnd()
20446 
    oprot.writeFieldStop()
20447 
    oprot.writeStructEnd()
20448 
 
20449 
  def validate(self):
20450 
    return
20451 
 
20452 
 
20453 
  def __repr__(self):
20454 
    L = ['%s=%r' % (key, value)
20455 
      for key, value in self.__dict__.iteritems()]
20456 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20457 
 
20458 
  def __eq__(self, other):
20459 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20460 
 
20461 
  def __ne__(self, other):
20462 
    return not (self == other)
20463 
 
20464 
class reconcileCodCollection_result:
20465 
  """
20466 
  Attributes:
20467 
   - success
20468 
   - ex
20469 
  """
20470 
 
20471 
  thrift_spec = (
20472 
    (0, TType.MAP, 'success', (TType.STRING,None,TType.STRING,None), None, ), # 0
20473 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
20474 
  )
20475 
 
20476 
  def __init__(self, success=None, ex=None,):
20477 
    self.success = success
20478 
    self.ex = ex
20479 
 
20480 
  def read(self, iprot):
20481 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20482 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20483 
      return
20484 
    iprot.readStructBegin()
20485 
    while True:
20486 
      (fname, ftype, fid) = iprot.readFieldBegin()
20487 
      if ftype == TType.STOP:
20488 
        break
20489 
      if fid == 0:
20490 
        if ftype == TType.MAP:
20491 
          self.success = {}
6188 rajveer 20492 
          (_ktype463, _vtype464, _size462 ) = iprot.readMapBegin()
20493 
          for _i466 in xrange(_size462):
20494 
            _key467 = iprot.readString();
20495 
            _val468 = iprot.readString();
20496 
            self.success[_key467] = _val468
3956 chandransh 20497 
          iprot.readMapEnd()
20498 
        else:
20499 
          iprot.skip(ftype)
20500 
      elif fid == 1:
20501 
        if ftype == TType.STRUCT:
20502 
          self.ex = TransactionServiceException()
20503 
          self.ex.read(iprot)
20504 
        else:
20505 
          iprot.skip(ftype)
20506 
      else:
20507 
        iprot.skip(ftype)
20508 
      iprot.readFieldEnd()
20509 
    iprot.readStructEnd()
20510 
 
20511 
  def write(self, oprot):
20512 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20513 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20514 
      return
20515 
    oprot.writeStructBegin('reconcileCodCollection_result')
20516 
    if self.success is not None:
20517 
      oprot.writeFieldBegin('success', TType.MAP, 0)
20518 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.success))
6188 rajveer 20519 
      for kiter469,viter470 in self.success.items():
20520 
        oprot.writeString(kiter469)
20521 
        oprot.writeString(viter470)
3956 chandransh 20522 
      oprot.writeMapEnd()
20523 
      oprot.writeFieldEnd()
20524 
    if self.ex is not None:
20525 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
20526 
      self.ex.write(oprot)
20527 
      oprot.writeFieldEnd()
20528 
    oprot.writeFieldStop()
20529 
    oprot.writeStructEnd()
20530 
 
20531 
  def validate(self):
20532 
    return
20533 
 
20534 
 
20535 
  def __repr__(self):
20536 
    L = ['%s=%r' % (key, value)
20537 
      for key, value in self.__dict__.iteritems()]
20538 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20539 
 
20540 
  def __eq__(self, other):
20541 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20542 
 
20543 
  def __ne__(self, other):
20544 
    return not (self == other)
4008 mandeep.dh 20545 
 
20546 
class getTransactionsRequiringExtraProcessing_args:
20547 
  """
20548 
  Attributes:
20549 
   - category
20550 
  """
20551 
 
20552 
  thrift_spec = (
20553 
    None, # 0
20554 
    (1, TType.I32, 'category', None, None, ), # 1
20555 
  )
20556 
 
20557 
  def __init__(self, category=None,):
20558 
    self.category = category
20559 
 
20560 
  def read(self, iprot):
20561 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20562 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20563 
      return
20564 
    iprot.readStructBegin()
20565 
    while True:
20566 
      (fname, ftype, fid) = iprot.readFieldBegin()
20567 
      if ftype == TType.STOP:
20568 
        break
20569 
      if fid == 1:
20570 
        if ftype == TType.I32:
20571 
          self.category = iprot.readI32();
20572 
        else:
20573 
          iprot.skip(ftype)
20574 
      else:
20575 
        iprot.skip(ftype)
20576 
      iprot.readFieldEnd()
20577 
    iprot.readStructEnd()
20578 
 
20579 
  def write(self, oprot):
20580 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20581 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20582 
      return
20583 
    oprot.writeStructBegin('getTransactionsRequiringExtraProcessing_args')
20584 
    if self.category is not None:
20585 
      oprot.writeFieldBegin('category', TType.I32, 1)
20586 
      oprot.writeI32(self.category)
20587 
      oprot.writeFieldEnd()
20588 
    oprot.writeFieldStop()
20589 
    oprot.writeStructEnd()
20590 
 
20591 
  def validate(self):
20592 
    return
20593 
 
20594 
 
20595 
  def __repr__(self):
20596 
    L = ['%s=%r' % (key, value)
20597 
      for key, value in self.__dict__.iteritems()]
20598 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20599 
 
20600 
  def __eq__(self, other):
20601 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20602 
 
20603 
  def __ne__(self, other):
20604 
    return not (self == other)
20605 
 
20606 
class getTransactionsRequiringExtraProcessing_result:
20607 
  """
20608 
  Attributes:
20609 
   - success
20610 
  """
20611 
 
20612 
  thrift_spec = (
20613 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
20614 
  )
20615 
 
20616 
  def __init__(self, success=None,):
20617 
    self.success = success
20618 
 
20619 
  def read(self, iprot):
20620 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20621 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20622 
      return
20623 
    iprot.readStructBegin()
20624 
    while True:
20625 
      (fname, ftype, fid) = iprot.readFieldBegin()
20626 
      if ftype == TType.STOP:
20627 
        break
20628 
      if fid == 0:
20629 
        if ftype == TType.LIST:
20630 
          self.success = []
6188 rajveer 20631 
          (_etype474, _size471) = iprot.readListBegin()
20632 
          for _i475 in xrange(_size471):
20633 
            _elem476 = iprot.readI64();
20634 
            self.success.append(_elem476)
4008 mandeep.dh 20635 
          iprot.readListEnd()
20636 
        else:
20637 
          iprot.skip(ftype)
20638 
      else:
20639 
        iprot.skip(ftype)
20640 
      iprot.readFieldEnd()
20641 
    iprot.readStructEnd()
20642 
 
20643 
  def write(self, oprot):
20644 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20645 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20646 
      return
20647 
    oprot.writeStructBegin('getTransactionsRequiringExtraProcessing_result')
20648 
    if self.success is not None:
20649 
      oprot.writeFieldBegin('success', TType.LIST, 0)
20650 
      oprot.writeListBegin(TType.I64, len(self.success))
6188 rajveer 20651 
      for iter477 in self.success:
20652 
        oprot.writeI64(iter477)
4008 mandeep.dh 20653 
      oprot.writeListEnd()
20654 
      oprot.writeFieldEnd()
20655 
    oprot.writeFieldStop()
20656 
    oprot.writeStructEnd()
20657 
 
20658 
  def validate(self):
20659 
    return
20660 
 
20661 
 
20662 
  def __repr__(self):
20663 
    L = ['%s=%r' % (key, value)
20664 
      for key, value in self.__dict__.iteritems()]
20665 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20666 
 
20667 
  def __eq__(self, other):
20668 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20669 
 
20670 
  def __ne__(self, other):
20671 
    return not (self == other)
20672 
 
20673 
class markTransactionAsProcessed_args:
20674 
  """
20675 
  Attributes:
20676 
   - transactionId
20677 
   - category
20678 
  """
20679 
 
20680 
  thrift_spec = (
20681 
    None, # 0
20682 
    (1, TType.I64, 'transactionId', None, None, ), # 1
20683 
    (2, TType.I32, 'category', None, None, ), # 2
20684 
  )
20685 
 
20686 
  def __init__(self, transactionId=None, category=None,):
20687 
    self.transactionId = transactionId
20688 
    self.category = category
20689 
 
20690 
  def read(self, iprot):
20691 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20692 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20693 
      return
20694 
    iprot.readStructBegin()
20695 
    while True:
20696 
      (fname, ftype, fid) = iprot.readFieldBegin()
20697 
      if ftype == TType.STOP:
20698 
        break
20699 
      if fid == 1:
20700 
        if ftype == TType.I64:
20701 
          self.transactionId = iprot.readI64();
20702 
        else:
20703 
          iprot.skip(ftype)
20704 
      elif fid == 2:
20705 
        if ftype == TType.I32:
20706 
          self.category = iprot.readI32();
20707 
        else:
20708 
          iprot.skip(ftype)
20709 
      else:
20710 
        iprot.skip(ftype)
20711 
      iprot.readFieldEnd()
20712 
    iprot.readStructEnd()
20713 
 
20714 
  def write(self, oprot):
20715 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20716 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20717 
      return
20718 
    oprot.writeStructBegin('markTransactionAsProcessed_args')
20719 
    if self.transactionId is not None:
20720 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
20721 
      oprot.writeI64(self.transactionId)
20722 
      oprot.writeFieldEnd()
20723 
    if self.category is not None:
20724 
      oprot.writeFieldBegin('category', TType.I32, 2)
20725 
      oprot.writeI32(self.category)
20726 
      oprot.writeFieldEnd()
20727 
    oprot.writeFieldStop()
20728 
    oprot.writeStructEnd()
20729 
 
20730 
  def validate(self):
20731 
    return
20732 
 
20733 
 
20734 
  def __repr__(self):
20735 
    L = ['%s=%r' % (key, value)
20736 
      for key, value in self.__dict__.iteritems()]
20737 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20738 
 
20739 
  def __eq__(self, other):
20740 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20741 
 
20742 
  def __ne__(self, other):
20743 
    return not (self == other)
20744 
 
20745 
class markTransactionAsProcessed_result:
20746 
 
20747 
  thrift_spec = (
20748 
  )
20749 
 
20750 
  def read(self, iprot):
20751 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20752 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20753 
      return
20754 
    iprot.readStructBegin()
20755 
    while True:
20756 
      (fname, ftype, fid) = iprot.readFieldBegin()
20757 
      if ftype == TType.STOP:
20758 
        break
20759 
      else:
20760 
        iprot.skip(ftype)
20761 
      iprot.readFieldEnd()
20762 
    iprot.readStructEnd()
20763 
 
20764 
  def write(self, oprot):
20765 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20766 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20767 
      return
20768 
    oprot.writeStructBegin('markTransactionAsProcessed_result')
20769 
    oprot.writeFieldStop()
20770 
    oprot.writeStructEnd()
20771 
 
20772 
  def validate(self):
20773 
    return
20774 
 
20775 
 
20776 
  def __repr__(self):
20777 
    L = ['%s=%r' % (key, value)
20778 
      for key, value in self.__dict__.iteritems()]
20779 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20780 
 
20781 
  def __eq__(self, other):
20782 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20783 
 
20784 
  def __ne__(self, other):
20785 
    return not (self == other)
4018 chandransh 20786 
 
20787 
class getItemWiseRiskyOrdersCount_args:
20788 
 
20789 
  thrift_spec = (
20790 
  )
20791 
 
20792 
  def read(self, iprot):
20793 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20794 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20795 
      return
20796 
    iprot.readStructBegin()
20797 
    while True:
20798 
      (fname, ftype, fid) = iprot.readFieldBegin()
20799 
      if ftype == TType.STOP:
20800 
        break
20801 
      else:
20802 
        iprot.skip(ftype)
20803 
      iprot.readFieldEnd()
20804 
    iprot.readStructEnd()
20805 
 
20806 
  def write(self, oprot):
20807 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20808 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20809 
      return
20810 
    oprot.writeStructBegin('getItemWiseRiskyOrdersCount_args')
20811 
    oprot.writeFieldStop()
20812 
    oprot.writeStructEnd()
20813 
 
20814 
  def validate(self):
20815 
    return
20816 
 
20817 
 
20818 
  def __repr__(self):
20819 
    L = ['%s=%r' % (key, value)
20820 
      for key, value in self.__dict__.iteritems()]
20821 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20822 
 
20823 
  def __eq__(self, other):
20824 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20825 
 
20826 
  def __ne__(self, other):
20827 
    return not (self == other)
20828 
 
20829 
class getItemWiseRiskyOrdersCount_result:
20830 
  """
20831 
  Attributes:
20832 
   - success
20833 
  """
20834 
 
20835 
  thrift_spec = (
20836 
    (0, TType.MAP, 'success', (TType.I64,None,TType.I64,None), None, ), # 0
20837 
  )
20838 
 
20839 
  def __init__(self, success=None,):
20840 
    self.success = success
20841 
 
20842 
  def read(self, iprot):
20843 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20844 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20845 
      return
20846 
    iprot.readStructBegin()
20847 
    while True:
20848 
      (fname, ftype, fid) = iprot.readFieldBegin()
20849 
      if ftype == TType.STOP:
20850 
        break
20851 
      if fid == 0:
20852 
        if ftype == TType.MAP:
20853 
          self.success = {}
6188 rajveer 20854 
          (_ktype479, _vtype480, _size478 ) = iprot.readMapBegin()
20855 
          for _i482 in xrange(_size478):
20856 
            _key483 = iprot.readI64();
20857 
            _val484 = iprot.readI64();
20858 
            self.success[_key483] = _val484
4018 chandransh 20859 
          iprot.readMapEnd()
20860 
        else:
20861 
          iprot.skip(ftype)
20862 
      else:
20863 
        iprot.skip(ftype)
20864 
      iprot.readFieldEnd()
20865 
    iprot.readStructEnd()
20866 
 
20867 
  def write(self, oprot):
20868 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20869 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20870 
      return
20871 
    oprot.writeStructBegin('getItemWiseRiskyOrdersCount_result')
20872 
    if self.success is not None:
20873 
      oprot.writeFieldBegin('success', TType.MAP, 0)
20874 
      oprot.writeMapBegin(TType.I64, TType.I64, len(self.success))
6188 rajveer 20875 
      for kiter485,viter486 in self.success.items():
20876 
        oprot.writeI64(kiter485)
20877 
        oprot.writeI64(viter486)
4018 chandransh 20878 
      oprot.writeMapEnd()
20879 
      oprot.writeFieldEnd()
20880 
    oprot.writeFieldStop()
20881 
    oprot.writeStructEnd()
20882 
 
20883 
  def validate(self):
20884 
    return
20885 
 
20886 
 
20887 
  def __repr__(self):
20888 
    L = ['%s=%r' % (key, value)
20889 
      for key, value in self.__dict__.iteritems()]
20890 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20891 
 
20892 
  def __eq__(self, other):
20893 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20894 
 
20895 
  def __ne__(self, other):
20896 
    return not (self == other)
4247 rajveer 20897 
 
4295 varun.gupt 20898 
class getOrdersForItemIds_args:
20899 
  """
20900 
  Attributes:
20901 
   - itemIds
20902 
  """
20903 
 
20904 
  thrift_spec = (
20905 
    None, # 0
20906 
    (1, TType.LIST, 'itemIds', (TType.I64,None), None, ), # 1
20907 
  )
20908 
 
20909 
  def __init__(self, itemIds=None,):
20910 
    self.itemIds = itemIds
20911 
 
20912 
  def read(self, iprot):
20913 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20914 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20915 
      return
20916 
    iprot.readStructBegin()
20917 
    while True:
20918 
      (fname, ftype, fid) = iprot.readFieldBegin()
20919 
      if ftype == TType.STOP:
20920 
        break
20921 
      if fid == 1:
20922 
        if ftype == TType.LIST:
20923 
          self.itemIds = []
6188 rajveer 20924 
          (_etype490, _size487) = iprot.readListBegin()
20925 
          for _i491 in xrange(_size487):
20926 
            _elem492 = iprot.readI64();
20927 
            self.itemIds.append(_elem492)
4295 varun.gupt 20928 
          iprot.readListEnd()
20929 
        else:
20930 
          iprot.skip(ftype)
20931 
      else:
20932 
        iprot.skip(ftype)
20933 
      iprot.readFieldEnd()
20934 
    iprot.readStructEnd()
20935 
 
20936 
  def write(self, oprot):
20937 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20938 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20939 
      return
20940 
    oprot.writeStructBegin('getOrdersForItemIds_args')
20941 
    if self.itemIds is not None:
20942 
      oprot.writeFieldBegin('itemIds', TType.LIST, 1)
20943 
      oprot.writeListBegin(TType.I64, len(self.itemIds))
6188 rajveer 20944 
      for iter493 in self.itemIds:
20945 
        oprot.writeI64(iter493)
4295 varun.gupt 20946 
      oprot.writeListEnd()
20947 
      oprot.writeFieldEnd()
20948 
    oprot.writeFieldStop()
20949 
    oprot.writeStructEnd()
20950 
 
20951 
  def validate(self):
20952 
    return
20953 
 
20954 
 
20955 
  def __repr__(self):
20956 
    L = ['%s=%r' % (key, value)
20957 
      for key, value in self.__dict__.iteritems()]
20958 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20959 
 
20960 
  def __eq__(self, other):
20961 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20962 
 
20963 
  def __ne__(self, other):
20964 
    return not (self == other)
20965 
 
20966 
class getOrdersForItemIds_result:
20967 
  """
20968 
  Attributes:
20969 
   - success
20970 
  """
20971 
 
20972 
  thrift_spec = (
20973 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
20974 
  )
20975 
 
20976 
  def __init__(self, success=None,):
20977 
    self.success = success
20978 
 
20979 
  def read(self, iprot):
20980 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20981 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20982 
      return
20983 
    iprot.readStructBegin()
20984 
    while True:
20985 
      (fname, ftype, fid) = iprot.readFieldBegin()
20986 
      if ftype == TType.STOP:
20987 
        break
20988 
      if fid == 0:
20989 
        if ftype == TType.LIST:
20990 
          self.success = []
6188 rajveer 20991 
          (_etype497, _size494) = iprot.readListBegin()
20992 
          for _i498 in xrange(_size494):
20993 
            _elem499 = Order()
20994 
            _elem499.read(iprot)
20995 
            self.success.append(_elem499)
4295 varun.gupt 20996 
          iprot.readListEnd()
20997 
        else:
20998 
          iprot.skip(ftype)
20999 
      else:
21000 
        iprot.skip(ftype)
21001 
      iprot.readFieldEnd()
21002 
    iprot.readStructEnd()
21003 
 
21004 
  def write(self, oprot):
21005 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21006 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21007 
      return
21008 
    oprot.writeStructBegin('getOrdersForItemIds_result')
21009 
    if self.success is not None:
21010 
      oprot.writeFieldBegin('success', TType.LIST, 0)
21011 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 21012 
      for iter500 in self.success:
21013 
        iter500.write(oprot)
4295 varun.gupt 21014 
      oprot.writeListEnd()
21015 
      oprot.writeFieldEnd()
21016 
    oprot.writeFieldStop()
21017 
    oprot.writeStructEnd()
21018 
 
21019 
  def validate(self):
21020 
    return
21021 
 
21022 
 
21023 
  def __repr__(self):
21024 
    L = ['%s=%r' % (key, value)
21025 
      for key, value in self.__dict__.iteritems()]
21026 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21027 
 
21028 
  def __eq__(self, other):
21029 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21030 
 
21031 
  def __ne__(self, other):
21032 
    return not (self == other)
21033 
 
4247 rajveer 21034 
class markOrderCancellationRequestReceived_args:
21035 
  """
21036 
  Attributes:
21037 
   - orderId
21038 
  """
21039 
 
21040 
  thrift_spec = (
21041 
    None, # 0
21042 
    (1, TType.I64, 'orderId', None, None, ), # 1
21043 
  )
21044 
 
21045 
  def __init__(self, orderId=None,):
21046 
    self.orderId = orderId
21047 
 
21048 
  def read(self, iprot):
21049 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21050 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21051 
      return
21052 
    iprot.readStructBegin()
21053 
    while True:
21054 
      (fname, ftype, fid) = iprot.readFieldBegin()
21055 
      if ftype == TType.STOP:
21056 
        break
21057 
      if fid == 1:
21058 
        if ftype == TType.I64:
21059 
          self.orderId = iprot.readI64();
21060 
        else:
21061 
          iprot.skip(ftype)
21062 
      else:
21063 
        iprot.skip(ftype)
21064 
      iprot.readFieldEnd()
21065 
    iprot.readStructEnd()
21066 
 
21067 
  def write(self, oprot):
21068 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21069 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21070 
      return
21071 
    oprot.writeStructBegin('markOrderCancellationRequestReceived_args')
21072 
    if self.orderId is not None:
21073 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
21074 
      oprot.writeI64(self.orderId)
21075 
      oprot.writeFieldEnd()
21076 
    oprot.writeFieldStop()
21077 
    oprot.writeStructEnd()
21078 
 
21079 
  def validate(self):
21080 
    return
21081 
 
21082 
 
21083 
  def __repr__(self):
21084 
    L = ['%s=%r' % (key, value)
21085 
      for key, value in self.__dict__.iteritems()]
21086 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21087 
 
21088 
  def __eq__(self, other):
21089 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21090 
 
21091 
  def __ne__(self, other):
21092 
    return not (self == other)
21093 
 
21094 
class markOrderCancellationRequestReceived_result:
21095 
  """
21096 
  Attributes:
21097 
   - ex
21098 
  """
21099 
 
21100 
  thrift_spec = (
21101 
    None, # 0
21102 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
21103 
  )
21104 
 
21105 
  def __init__(self, ex=None,):
21106 
    self.ex = ex
21107 
 
21108 
  def read(self, iprot):
21109 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21110 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21111 
      return
21112 
    iprot.readStructBegin()
21113 
    while True:
21114 
      (fname, ftype, fid) = iprot.readFieldBegin()
21115 
      if ftype == TType.STOP:
21116 
        break
21117 
      if fid == 1:
21118 
        if ftype == TType.STRUCT:
21119 
          self.ex = TransactionServiceException()
21120 
          self.ex.read(iprot)
21121 
        else:
21122 
          iprot.skip(ftype)
21123 
      else:
21124 
        iprot.skip(ftype)
21125 
      iprot.readFieldEnd()
21126 
    iprot.readStructEnd()
21127 
 
21128 
  def write(self, oprot):
21129 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21130 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21131 
      return
21132 
    oprot.writeStructBegin('markOrderCancellationRequestReceived_result')
21133 
    if self.ex is not None:
21134 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
21135 
      self.ex.write(oprot)
21136 
      oprot.writeFieldEnd()
21137 
    oprot.writeFieldStop()
21138 
    oprot.writeStructEnd()
21139 
 
21140 
  def validate(self):
21141 
    return
21142 
 
21143 
 
21144 
  def __repr__(self):
21145 
    L = ['%s=%r' % (key, value)
21146 
      for key, value in self.__dict__.iteritems()]
21147 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21148 
 
21149 
  def __eq__(self, other):
21150 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21151 
 
21152 
  def __ne__(self, other):
21153 
    return not (self == other)
21154 
 
21155 
class markOrderCancellationRequestConfirmed_args:
21156 
  """
21157 
  Attributes:
21158 
   - orderId
21159 
  """
21160 
 
21161 
  thrift_spec = (
21162 
    None, # 0
21163 
    (1, TType.I64, 'orderId', None, None, ), # 1
21164 
  )
21165 
 
21166 
  def __init__(self, orderId=None,):
21167 
    self.orderId = orderId
21168 
 
21169 
  def read(self, iprot):
21170 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21171 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21172 
      return
21173 
    iprot.readStructBegin()
21174 
    while True:
21175 
      (fname, ftype, fid) = iprot.readFieldBegin()
21176 
      if ftype == TType.STOP:
21177 
        break
21178 
      if fid == 1:
21179 
        if ftype == TType.I64:
21180 
          self.orderId = iprot.readI64();
21181 
        else:
21182 
          iprot.skip(ftype)
21183 
      else:
21184 
        iprot.skip(ftype)
21185 
      iprot.readFieldEnd()
21186 
    iprot.readStructEnd()
21187 
 
21188 
  def write(self, oprot):
21189 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21190 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21191 
      return
21192 
    oprot.writeStructBegin('markOrderCancellationRequestConfirmed_args')
21193 
    if self.orderId is not None:
21194 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
21195 
      oprot.writeI64(self.orderId)
21196 
      oprot.writeFieldEnd()
21197 
    oprot.writeFieldStop()
21198 
    oprot.writeStructEnd()
21199 
 
21200 
  def validate(self):
21201 
    return
21202 
 
21203 
 
21204 
  def __repr__(self):
21205 
    L = ['%s=%r' % (key, value)
21206 
      for key, value in self.__dict__.iteritems()]
21207 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21208 
 
21209 
  def __eq__(self, other):
21210 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21211 
 
21212 
  def __ne__(self, other):
21213 
    return not (self == other)
21214 
 
21215 
class markOrderCancellationRequestConfirmed_result:
21216 
  """
21217 
  Attributes:
21218 
   - ex
21219 
  """
21220 
 
21221 
  thrift_spec = (
21222 
    None, # 0
21223 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
21224 
  )
21225 
 
21226 
  def __init__(self, ex=None,):
21227 
    self.ex = ex
21228 
 
21229 
  def read(self, iprot):
21230 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21231 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21232 
      return
21233 
    iprot.readStructBegin()
21234 
    while True:
21235 
      (fname, ftype, fid) = iprot.readFieldBegin()
21236 
      if ftype == TType.STOP:
21237 
        break
21238 
      if fid == 1:
21239 
        if ftype == TType.STRUCT:
21240 
          self.ex = TransactionServiceException()
21241 
          self.ex.read(iprot)
21242 
        else:
21243 
          iprot.skip(ftype)
21244 
      else:
21245 
        iprot.skip(ftype)
21246 
      iprot.readFieldEnd()
21247 
    iprot.readStructEnd()
21248 
 
21249 
  def write(self, oprot):
21250 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21251 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21252 
      return
21253 
    oprot.writeStructBegin('markOrderCancellationRequestConfirmed_result')
21254 
    if self.ex is not None:
21255 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
21256 
      self.ex.write(oprot)
21257 
      oprot.writeFieldEnd()
21258 
    oprot.writeFieldStop()
21259 
    oprot.writeStructEnd()
21260 
 
21261 
  def validate(self):
21262 
    return
21263 
 
21264 
 
21265 
  def __repr__(self):
21266 
    L = ['%s=%r' % (key, value)
21267 
      for key, value in self.__dict__.iteritems()]
21268 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21269 
 
21270 
  def __eq__(self, other):
21271 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21272 
 
21273 
  def __ne__(self, other):
21274 
    return not (self == other)
21275 
 
21276 
class markOrderCancellationRequestDenied_args:
21277 
  """
21278 
  Attributes:
21279 
   - orderId
21280 
  """
21281 
 
21282 
  thrift_spec = (
21283 
    None, # 0
21284 
    (1, TType.I64, 'orderId', None, None, ), # 1
21285 
  )
21286 
 
21287 
  def __init__(self, orderId=None,):
21288 
    self.orderId = orderId
21289 
 
21290 
  def read(self, iprot):
21291 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21292 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21293 
      return
21294 
    iprot.readStructBegin()
21295 
    while True:
21296 
      (fname, ftype, fid) = iprot.readFieldBegin()
21297 
      if ftype == TType.STOP:
21298 
        break
21299 
      if fid == 1:
21300 
        if ftype == TType.I64:
21301 
          self.orderId = iprot.readI64();
21302 
        else:
21303 
          iprot.skip(ftype)
21304 
      else:
21305 
        iprot.skip(ftype)
21306 
      iprot.readFieldEnd()
21307 
    iprot.readStructEnd()
21308 
 
21309 
  def write(self, oprot):
21310 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21311 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21312 
      return
21313 
    oprot.writeStructBegin('markOrderCancellationRequestDenied_args')
21314 
    if self.orderId is not None:
21315 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
21316 
      oprot.writeI64(self.orderId)
21317 
      oprot.writeFieldEnd()
21318 
    oprot.writeFieldStop()
21319 
    oprot.writeStructEnd()
21320 
 
21321 
  def validate(self):
21322 
    return
21323 
 
21324 
 
21325 
  def __repr__(self):
21326 
    L = ['%s=%r' % (key, value)
21327 
      for key, value in self.__dict__.iteritems()]
21328 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21329 
 
21330 
  def __eq__(self, other):
21331 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21332 
 
21333 
  def __ne__(self, other):
21334 
    return not (self == other)
21335 
 
21336 
class markOrderCancellationRequestDenied_result:
21337 
  """
21338 
  Attributes:
21339 
   - ex
21340 
  """
21341 
 
21342 
  thrift_spec = (
21343 
    None, # 0
21344 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
21345 
  )
21346 
 
21347 
  def __init__(self, ex=None,):
21348 
    self.ex = ex
21349 
 
21350 
  def read(self, iprot):
21351 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21352 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21353 
      return
21354 
    iprot.readStructBegin()
21355 
    while True:
21356 
      (fname, ftype, fid) = iprot.readFieldBegin()
21357 
      if ftype == TType.STOP:
21358 
        break
21359 
      if fid == 1:
21360 
        if ftype == TType.STRUCT:
21361 
          self.ex = TransactionServiceException()
21362 
          self.ex.read(iprot)
21363 
        else:
21364 
          iprot.skip(ftype)
21365 
      else:
21366 
        iprot.skip(ftype)
21367 
      iprot.readFieldEnd()
21368 
    iprot.readStructEnd()
21369 
 
21370 
  def write(self, oprot):
21371 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21372 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21373 
      return
21374 
    oprot.writeStructBegin('markOrderCancellationRequestDenied_result')
21375 
    if self.ex is not None:
21376 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
21377 
      self.ex.write(oprot)
21378 
      oprot.writeFieldEnd()
21379 
    oprot.writeFieldStop()
21380 
    oprot.writeStructEnd()
21381 
 
21382 
  def validate(self):
21383 
    return
21384 
 
21385 
 
21386 
  def __repr__(self):
21387 
    L = ['%s=%r' % (key, value)
21388 
      for key, value in self.__dict__.iteritems()]
21389 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21390 
 
21391 
  def __eq__(self, other):
21392 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21393 
 
21394 
  def __ne__(self, other):
21395 
    return not (self == other)
21396 
 
4258 rajveer 21397 
class markTransactionAsPaymentFlagRemoved_args:
4247 rajveer 21398 
  """
21399 
  Attributes:
4258 rajveer 21400 
   - transactionId
4247 rajveer 21401 
  """
21402 
 
21403 
  thrift_spec = (
21404 
    None, # 0
4258 rajveer 21405 
    (1, TType.I64, 'transactionId', None, None, ), # 1
4247 rajveer 21406 
  )
21407 
 
4258 rajveer 21408 
  def __init__(self, transactionId=None,):
21409 
    self.transactionId = transactionId
4247 rajveer 21410 
 
21411 
  def read(self, iprot):
21412 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21413 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21414 
      return
21415 
    iprot.readStructBegin()
21416 
    while True:
21417 
      (fname, ftype, fid) = iprot.readFieldBegin()
21418 
      if ftype == TType.STOP:
21419 
        break
21420 
      if fid == 1:
21421 
        if ftype == TType.I64:
4258 rajveer 21422 
          self.transactionId = iprot.readI64();
4247 rajveer 21423 
        else:
21424 
          iprot.skip(ftype)
21425 
      else:
21426 
        iprot.skip(ftype)
21427 
      iprot.readFieldEnd()
21428 
    iprot.readStructEnd()
21429 
 
21430 
  def write(self, oprot):
21431 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21432 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21433 
      return
4258 rajveer 21434 
    oprot.writeStructBegin('markTransactionAsPaymentFlagRemoved_args')
21435 
    if self.transactionId is not None:
21436 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
21437 
      oprot.writeI64(self.transactionId)
4247 rajveer 21438 
      oprot.writeFieldEnd()
21439 
    oprot.writeFieldStop()
21440 
    oprot.writeStructEnd()
21441 
 
21442 
  def validate(self):
21443 
    return
21444 
 
21445 
 
21446 
  def __repr__(self):
21447 
    L = ['%s=%r' % (key, value)
21448 
      for key, value in self.__dict__.iteritems()]
21449 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21450 
 
21451 
  def __eq__(self, other):
21452 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21453 
 
21454 
  def __ne__(self, other):
21455 
    return not (self == other)
21456 
 
4258 rajveer 21457 
class markTransactionAsPaymentFlagRemoved_result:
4247 rajveer 21458 
  """
21459 
  Attributes:
21460 
   - ex
21461 
  """
21462 
 
21463 
  thrift_spec = (
21464 
    None, # 0
21465 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
21466 
  )
21467 
 
21468 
  def __init__(self, ex=None,):
21469 
    self.ex = ex
21470 
 
21471 
  def read(self, iprot):
21472 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21473 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21474 
      return
21475 
    iprot.readStructBegin()
21476 
    while True:
21477 
      (fname, ftype, fid) = iprot.readFieldBegin()
21478 
      if ftype == TType.STOP:
21479 
        break
21480 
      if fid == 1:
21481 
        if ftype == TType.STRUCT:
21482 
          self.ex = TransactionServiceException()
21483 
          self.ex.read(iprot)
21484 
        else:
21485 
          iprot.skip(ftype)
21486 
      else:
21487 
        iprot.skip(ftype)
21488 
      iprot.readFieldEnd()
21489 
    iprot.readStructEnd()
21490 
 
21491 
  def write(self, oprot):
21492 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21493 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21494 
      return
4258 rajveer 21495 
    oprot.writeStructBegin('markTransactionAsPaymentFlagRemoved_result')
4247 rajveer 21496 
    if self.ex is not None:
21497 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
21498 
      self.ex.write(oprot)
21499 
      oprot.writeFieldEnd()
21500 
    oprot.writeFieldStop()
21501 
    oprot.writeStructEnd()
21502 
 
21503 
  def validate(self):
21504 
    return
21505 
 
21506 
 
21507 
  def __repr__(self):
21508 
    L = ['%s=%r' % (key, value)
21509 
      for key, value in self.__dict__.iteritems()]
21510 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21511 
 
21512 
  def __eq__(self, other):
21513 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21514 
 
21515 
  def __ne__(self, other):
21516 
    return not (self == other)
4259 anupam.sin 21517 
 
21518 
class refundTransaction_args:
21519 
  """
21520 
  Attributes:
21521 
   - transactionId
21522 
   - refundedBy
21523 
   - reason
21524 
  """
21525 
 
21526 
  thrift_spec = (
21527 
    None, # 0
21528 
    (1, TType.I64, 'transactionId', None, None, ), # 1
21529 
    (2, TType.STRING, 'refundedBy', None, None, ), # 2
21530 
    (3, TType.STRING, 'reason', None, None, ), # 3
21531 
  )
21532 
 
21533 
  def __init__(self, transactionId=None, refundedBy=None, reason=None,):
21534 
    self.transactionId = transactionId
21535 
    self.refundedBy = refundedBy
21536 
    self.reason = reason
21537 
 
21538 
  def read(self, iprot):
21539 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21540 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21541 
      return
21542 
    iprot.readStructBegin()
21543 
    while True:
21544 
      (fname, ftype, fid) = iprot.readFieldBegin()
21545 
      if ftype == TType.STOP:
21546 
        break
21547 
      if fid == 1:
21548 
        if ftype == TType.I64:
21549 
          self.transactionId = iprot.readI64();
21550 
        else:
21551 
          iprot.skip(ftype)
21552 
      elif fid == 2:
21553 
        if ftype == TType.STRING:
21554 
          self.refundedBy = iprot.readString();
21555 
        else:
21556 
          iprot.skip(ftype)
21557 
      elif fid == 3:
21558 
        if ftype == TType.STRING:
21559 
          self.reason = iprot.readString();
21560 
        else:
21561 
          iprot.skip(ftype)
21562 
      else:
21563 
        iprot.skip(ftype)
21564 
      iprot.readFieldEnd()
21565 
    iprot.readStructEnd()
21566 
 
21567 
  def write(self, oprot):
21568 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21569 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21570 
      return
21571 
    oprot.writeStructBegin('refundTransaction_args')
21572 
    if self.transactionId is not None:
21573 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
21574 
      oprot.writeI64(self.transactionId)
21575 
      oprot.writeFieldEnd()
21576 
    if self.refundedBy is not None:
21577 
      oprot.writeFieldBegin('refundedBy', TType.STRING, 2)
21578 
      oprot.writeString(self.refundedBy)
21579 
      oprot.writeFieldEnd()
21580 
    if self.reason is not None:
21581 
      oprot.writeFieldBegin('reason', TType.STRING, 3)
21582 
      oprot.writeString(self.reason)
21583 
      oprot.writeFieldEnd()
21584 
    oprot.writeFieldStop()
21585 
    oprot.writeStructEnd()
21586 
 
21587 
  def validate(self):
21588 
    return
21589 
 
21590 
 
21591 
  def __repr__(self):
21592 
    L = ['%s=%r' % (key, value)
21593 
      for key, value in self.__dict__.iteritems()]
21594 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21595 
 
21596 
  def __eq__(self, other):
21597 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21598 
 
21599 
  def __ne__(self, other):
21600 
    return not (self == other)
21601 
 
21602 
class refundTransaction_result:
21603 
  """
21604 
  Attributes:
21605 
   - ex
21606 
  """
21607 
 
21608 
  thrift_spec = (
21609 
    None, # 0
21610 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
21611 
  )
21612 
 
21613 
  def __init__(self, ex=None,):
21614 
    self.ex = ex
21615 
 
21616 
  def read(self, iprot):
21617 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21618 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21619 
      return
21620 
    iprot.readStructBegin()
21621 
    while True:
21622 
      (fname, ftype, fid) = iprot.readFieldBegin()
21623 
      if ftype == TType.STOP:
21624 
        break
21625 
      if fid == 1:
21626 
        if ftype == TType.STRUCT:
21627 
          self.ex = TransactionServiceException()
21628 
          self.ex.read(iprot)
21629 
        else:
21630 
          iprot.skip(ftype)
21631 
      else:
21632 
        iprot.skip(ftype)
21633 
      iprot.readFieldEnd()
21634 
    iprot.readStructEnd()
21635 
 
21636 
  def write(self, oprot):
21637 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21638 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21639 
      return
21640 
    oprot.writeStructBegin('refundTransaction_result')
21641 
    if self.ex is not None:
21642 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
21643 
      self.ex.write(oprot)
21644 
      oprot.writeFieldEnd()
21645 
    oprot.writeFieldStop()
21646 
    oprot.writeStructEnd()
21647 
 
21648 
  def validate(self):
21649 
    return
21650 
 
21651 
 
21652 
  def __repr__(self):
21653 
    L = ['%s=%r' % (key, value)
21654 
      for key, value in self.__dict__.iteritems()]
21655 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21656 
 
21657 
  def __eq__(self, other):
21658 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21659 
 
21660 
  def __ne__(self, other):
21661 
    return not (self == other)
4285 rajveer 21662 
 
4324 mandeep.dh 21663 
class updateShipmentAddress_args:
21664 
  """
21665 
  Attributes:
21666 
   - orderId
21667 
   - addressId
21668 
  """
21669 
 
21670 
  thrift_spec = (
21671 
    None, # 0
21672 
    (1, TType.I64, 'orderId', None, None, ), # 1
21673 
    (2, TType.I64, 'addressId', None, None, ), # 2
21674 
  )
21675 
 
21676 
  def __init__(self, orderId=None, addressId=None,):
21677 
    self.orderId = orderId
21678 
    self.addressId = addressId
21679 
 
21680 
  def read(self, iprot):
21681 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21682 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21683 
      return
21684 
    iprot.readStructBegin()
21685 
    while True:
21686 
      (fname, ftype, fid) = iprot.readFieldBegin()
21687 
      if ftype == TType.STOP:
21688 
        break
21689 
      if fid == 1:
21690 
        if ftype == TType.I64:
21691 
          self.orderId = iprot.readI64();
21692 
        else:
21693 
          iprot.skip(ftype)
21694 
      elif fid == 2:
21695 
        if ftype == TType.I64:
21696 
          self.addressId = iprot.readI64();
21697 
        else:
21698 
          iprot.skip(ftype)
21699 
      else:
21700 
        iprot.skip(ftype)
21701 
      iprot.readFieldEnd()
21702 
    iprot.readStructEnd()
21703 
 
21704 
  def write(self, oprot):
21705 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21706 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21707 
      return
21708 
    oprot.writeStructBegin('updateShipmentAddress_args')
21709 
    if self.orderId is not None:
21710 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
21711 
      oprot.writeI64(self.orderId)
21712 
      oprot.writeFieldEnd()
21713 
    if self.addressId is not None:
21714 
      oprot.writeFieldBegin('addressId', TType.I64, 2)
21715 
      oprot.writeI64(self.addressId)
21716 
      oprot.writeFieldEnd()
21717 
    oprot.writeFieldStop()
21718 
    oprot.writeStructEnd()
21719 
 
21720 
  def validate(self):
21721 
    return
21722 
 
21723 
 
21724 
  def __repr__(self):
21725 
    L = ['%s=%r' % (key, value)
21726 
      for key, value in self.__dict__.iteritems()]
21727 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21728 
 
21729 
  def __eq__(self, other):
21730 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21731 
 
21732 
  def __ne__(self, other):
21733 
    return not (self == other)
21734 
 
21735 
class updateShipmentAddress_result:
21736 
  """
21737 
  Attributes:
21738 
   - ex
21739 
  """
21740 
 
21741 
  thrift_spec = (
21742 
    None, # 0
21743 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
21744 
  )
21745 
 
21746 
  def __init__(self, ex=None,):
21747 
    self.ex = ex
21748 
 
21749 
  def read(self, iprot):
21750 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21751 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21752 
      return
21753 
    iprot.readStructBegin()
21754 
    while True:
21755 
      (fname, ftype, fid) = iprot.readFieldBegin()
21756 
      if ftype == TType.STOP:
21757 
        break
21758 
      if fid == 1:
21759 
        if ftype == TType.STRUCT:
21760 
          self.ex = TransactionServiceException()
21761 
          self.ex.read(iprot)
21762 
        else:
21763 
          iprot.skip(ftype)
21764 
      else:
21765 
        iprot.skip(ftype)
21766 
      iprot.readFieldEnd()
21767 
    iprot.readStructEnd()
21768 
 
21769 
  def write(self, oprot):
21770 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21771 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21772 
      return
21773 
    oprot.writeStructBegin('updateShipmentAddress_result')
21774 
    if self.ex is not None:
21775 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
21776 
      self.ex.write(oprot)
21777 
      oprot.writeFieldEnd()
21778 
    oprot.writeFieldStop()
21779 
    oprot.writeStructEnd()
21780 
 
21781 
  def validate(self):
21782 
    return
21783 
 
21784 
 
21785 
  def __repr__(self):
21786 
    L = ['%s=%r' % (key, value)
21787 
      for key, value in self.__dict__.iteritems()]
21788 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21789 
 
21790 
  def __eq__(self, other):
21791 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21792 
 
21793 
  def __ne__(self, other):
21794 
    return not (self == other)
21795 
 
4285 rajveer 21796 
class acceptOrdersForItemId_args:
21797 
  """
21798 
  Attributes:
21799 
   - itemId
21800 
   - inventory
21801 
  """
21802 
 
21803 
  thrift_spec = (
21804 
    None, # 0
21805 
    (1, TType.I64, 'itemId', None, None, ), # 1
21806 
    (2, TType.I64, 'inventory', None, None, ), # 2
21807 
  )
21808 
 
21809 
  def __init__(self, itemId=None, inventory=None,):
21810 
    self.itemId = itemId
21811 
    self.inventory = inventory
21812 
 
21813 
  def read(self, iprot):
21814 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21815 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21816 
      return
21817 
    iprot.readStructBegin()
21818 
    while True:
21819 
      (fname, ftype, fid) = iprot.readFieldBegin()
21820 
      if ftype == TType.STOP:
21821 
        break
21822 
      if fid == 1:
21823 
        if ftype == TType.I64:
21824 
          self.itemId = iprot.readI64();
21825 
        else:
21826 
          iprot.skip(ftype)
21827 
      elif fid == 2:
21828 
        if ftype == TType.I64:
21829 
          self.inventory = iprot.readI64();
21830 
        else:
21831 
          iprot.skip(ftype)
21832 
      else:
21833 
        iprot.skip(ftype)
21834 
      iprot.readFieldEnd()
21835 
    iprot.readStructEnd()
21836 
 
21837 
  def write(self, oprot):
21838 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21839 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21840 
      return
21841 
    oprot.writeStructBegin('acceptOrdersForItemId_args')
21842 
    if self.itemId is not None:
21843 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
21844 
      oprot.writeI64(self.itemId)
21845 
      oprot.writeFieldEnd()
21846 
    if self.inventory is not None:
21847 
      oprot.writeFieldBegin('inventory', TType.I64, 2)
21848 
      oprot.writeI64(self.inventory)
21849 
      oprot.writeFieldEnd()
21850 
    oprot.writeFieldStop()
21851 
    oprot.writeStructEnd()
21852 
 
21853 
  def validate(self):
21854 
    return
21855 
 
21856 
 
21857 
  def __repr__(self):
21858 
    L = ['%s=%r' % (key, value)
21859 
      for key, value in self.__dict__.iteritems()]
21860 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21861 
 
21862 
  def __eq__(self, other):
21863 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21864 
 
21865 
  def __ne__(self, other):
21866 
    return not (self == other)
21867 
 
21868 
class acceptOrdersForItemId_result:
21869 
  """
21870 
  Attributes:
21871 
   - success
21872 
   - ex
21873 
  """
21874 
 
21875 
  thrift_spec = (
21876 
    (0, TType.BOOL, 'success', None, None, ), # 0
21877 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
21878 
  )
21879 
 
21880 
  def __init__(self, success=None, ex=None,):
21881 
    self.success = success
21882 
    self.ex = ex
21883 
 
21884 
  def read(self, iprot):
21885 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21886 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21887 
      return
21888 
    iprot.readStructBegin()
21889 
    while True:
21890 
      (fname, ftype, fid) = iprot.readFieldBegin()
21891 
      if ftype == TType.STOP:
21892 
        break
21893 
      if fid == 0:
21894 
        if ftype == TType.BOOL:
21895 
          self.success = iprot.readBool();
21896 
        else:
21897 
          iprot.skip(ftype)
21898 
      elif fid == 1:
21899 
        if ftype == TType.STRUCT:
21900 
          self.ex = TransactionServiceException()
21901 
          self.ex.read(iprot)
21902 
        else:
21903 
          iprot.skip(ftype)
21904 
      else:
21905 
        iprot.skip(ftype)
21906 
      iprot.readFieldEnd()
21907 
    iprot.readStructEnd()
21908 
 
21909 
  def write(self, oprot):
21910 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21911 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21912 
      return
21913 
    oprot.writeStructBegin('acceptOrdersForItemId_result')
21914 
    if self.success is not None:
21915 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
21916 
      oprot.writeBool(self.success)
21917 
      oprot.writeFieldEnd()
21918 
    if self.ex is not None:
21919 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
21920 
      self.ex.write(oprot)
21921 
      oprot.writeFieldEnd()
21922 
    oprot.writeFieldStop()
21923 
    oprot.writeStructEnd()
21924 
 
21925 
  def validate(self):
21926 
    return
21927 
 
21928 
 
21929 
  def __repr__(self):
21930 
    L = ['%s=%r' % (key, value)
21931 
      for key, value in self.__dict__.iteritems()]
21932 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21933 
 
21934 
  def __eq__(self, other):
21935 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21936 
 
21937 
  def __ne__(self, other):
21938 
    return not (self == other)
4303 rajveer 21939 
 
21940 
class markOrdersAsPORaised_args:
21941 
  """
21942 
  Attributes:
21943 
   - vendorId
21944 
   - itemId
21945 
   - quantity
21946 
   - estimate
4369 rajveer 21947 
   - isReminder
4303 rajveer 21948 
  """
21949 
 
21950 
  thrift_spec = (
21951 
    None, # 0
21952 
    (1, TType.I64, 'vendorId', None, None, ), # 1
21953 
    (2, TType.I64, 'itemId', None, None, ), # 2
21954 
    (3, TType.I64, 'quantity', None, None, ), # 3
21955 
    (4, TType.I64, 'estimate', None, None, ), # 4
4369 rajveer 21956 
    (5, TType.BOOL, 'isReminder', None, None, ), # 5
4303 rajveer 21957 
  )
21958 
 
4369 rajveer 21959 
  def __init__(self, vendorId=None, itemId=None, quantity=None, estimate=None, isReminder=None,):
4303 rajveer 21960 
    self.vendorId = vendorId
21961 
    self.itemId = itemId
21962 
    self.quantity = quantity
21963 
    self.estimate = estimate
4369 rajveer 21964 
    self.isReminder = isReminder
4303 rajveer 21965 
 
21966 
  def read(self, iprot):
21967 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21968 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21969 
      return
21970 
    iprot.readStructBegin()
21971 
    while True:
21972 
      (fname, ftype, fid) = iprot.readFieldBegin()
21973 
      if ftype == TType.STOP:
21974 
        break
21975 
      if fid == 1:
21976 
        if ftype == TType.I64:
21977 
          self.vendorId = iprot.readI64();
21978 
        else:
21979 
          iprot.skip(ftype)
21980 
      elif fid == 2:
21981 
        if ftype == TType.I64:
21982 
          self.itemId = iprot.readI64();
21983 
        else:
21984 
          iprot.skip(ftype)
21985 
      elif fid == 3:
21986 
        if ftype == TType.I64:
21987 
          self.quantity = iprot.readI64();
21988 
        else:
21989 
          iprot.skip(ftype)
21990 
      elif fid == 4:
21991 
        if ftype == TType.I64:
21992 
          self.estimate = iprot.readI64();
21993 
        else:
21994 
          iprot.skip(ftype)
4369 rajveer 21995 
      elif fid == 5:
21996 
        if ftype == TType.BOOL:
21997 
          self.isReminder = iprot.readBool();
21998 
        else:
21999 
          iprot.skip(ftype)
4303 rajveer 22000 
      else:
22001 
        iprot.skip(ftype)
22002 
      iprot.readFieldEnd()
22003 
    iprot.readStructEnd()
22004 
 
22005 
  def write(self, oprot):
22006 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22007 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22008 
      return
22009 
    oprot.writeStructBegin('markOrdersAsPORaised_args')
22010 
    if self.vendorId is not None:
22011 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
22012 
      oprot.writeI64(self.vendorId)
22013 
      oprot.writeFieldEnd()
22014 
    if self.itemId is not None:
22015 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
22016 
      oprot.writeI64(self.itemId)
22017 
      oprot.writeFieldEnd()
22018 
    if self.quantity is not None:
22019 
      oprot.writeFieldBegin('quantity', TType.I64, 3)
22020 
      oprot.writeI64(self.quantity)
22021 
      oprot.writeFieldEnd()
22022 
    if self.estimate is not None:
22023 
      oprot.writeFieldBegin('estimate', TType.I64, 4)
22024 
      oprot.writeI64(self.estimate)
22025 
      oprot.writeFieldEnd()
4369 rajveer 22026 
    if self.isReminder is not None:
22027 
      oprot.writeFieldBegin('isReminder', TType.BOOL, 5)
22028 
      oprot.writeBool(self.isReminder)
22029 
      oprot.writeFieldEnd()
4303 rajveer 22030 
    oprot.writeFieldStop()
22031 
    oprot.writeStructEnd()
22032 
 
22033 
  def validate(self):
22034 
    return
22035 
 
22036 
 
22037 
  def __repr__(self):
22038 
    L = ['%s=%r' % (key, value)
22039 
      for key, value in self.__dict__.iteritems()]
22040 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22041 
 
22042 
  def __eq__(self, other):
22043 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22044 
 
22045 
  def __ne__(self, other):
22046 
    return not (self == other)
22047 
 
22048 
class markOrdersAsPORaised_result:
22049 
  """
22050 
  Attributes:
22051 
   - ex
22052 
  """
22053 
 
22054 
  thrift_spec = (
22055 
    None, # 0
22056 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
22057 
  )
22058 
 
22059 
  def __init__(self, ex=None,):
22060 
    self.ex = ex
22061 
 
22062 
  def read(self, iprot):
22063 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22064 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22065 
      return
22066 
    iprot.readStructBegin()
22067 
    while True:
22068 
      (fname, ftype, fid) = iprot.readFieldBegin()
22069 
      if ftype == TType.STOP:
22070 
        break
22071 
      if fid == 1:
22072 
        if ftype == TType.STRUCT:
22073 
          self.ex = TransactionServiceException()
22074 
          self.ex.read(iprot)
22075 
        else:
22076 
          iprot.skip(ftype)
22077 
      else:
22078 
        iprot.skip(ftype)
22079 
      iprot.readFieldEnd()
22080 
    iprot.readStructEnd()
22081 
 
22082 
  def write(self, oprot):
22083 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22084 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22085 
      return
22086 
    oprot.writeStructBegin('markOrdersAsPORaised_result')
22087 
    if self.ex is not None:
22088 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
22089 
      self.ex.write(oprot)
22090 
      oprot.writeFieldEnd()
22091 
    oprot.writeFieldStop()
22092 
    oprot.writeStructEnd()
22093 
 
22094 
  def validate(self):
22095 
    return
22096 
 
22097 
 
22098 
  def __repr__(self):
22099 
    L = ['%s=%r' % (key, value)
22100 
      for key, value in self.__dict__.iteritems()]
22101 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22102 
 
22103 
  def __eq__(self, other):
22104 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22105 
 
22106 
  def __ne__(self, other):
22107 
    return not (self == other)
22108 
 
22109 
class markOrdersAsReversalInitiated_args:
22110 
  """
22111 
  Attributes:
22112 
   - vendorId
22113 
   - itemId
22114 
   - quantity
22115 
   - estimate
4369 rajveer 22116 
   - isReminder
4303 rajveer 22117 
  """
22118 
 
22119 
  thrift_spec = (
22120 
    None, # 0
22121 
    (1, TType.I64, 'vendorId', None, None, ), # 1
22122 
    (2, TType.I64, 'itemId', None, None, ), # 2
22123 
    (3, TType.I64, 'quantity', None, None, ), # 3
22124 
    (4, TType.I64, 'estimate', None, None, ), # 4
4369 rajveer 22125 
    (5, TType.BOOL, 'isReminder', None, None, ), # 5
4303 rajveer 22126 
  )
22127 
 
4369 rajveer 22128 
  def __init__(self, vendorId=None, itemId=None, quantity=None, estimate=None, isReminder=None,):
4303 rajveer 22129 
    self.vendorId = vendorId
22130 
    self.itemId = itemId
22131 
    self.quantity = quantity
22132 
    self.estimate = estimate
4369 rajveer 22133 
    self.isReminder = isReminder
4303 rajveer 22134 
 
22135 
  def read(self, iprot):
22136 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22137 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22138 
      return
22139 
    iprot.readStructBegin()
22140 
    while True:
22141 
      (fname, ftype, fid) = iprot.readFieldBegin()
22142 
      if ftype == TType.STOP:
22143 
        break
22144 
      if fid == 1:
22145 
        if ftype == TType.I64:
22146 
          self.vendorId = iprot.readI64();
22147 
        else:
22148 
          iprot.skip(ftype)
22149 
      elif fid == 2:
22150 
        if ftype == TType.I64:
22151 
          self.itemId = iprot.readI64();
22152 
        else:
22153 
          iprot.skip(ftype)
22154 
      elif fid == 3:
22155 
        if ftype == TType.I64:
22156 
          self.quantity = iprot.readI64();
22157 
        else:
22158 
          iprot.skip(ftype)
22159 
      elif fid == 4:
22160 
        if ftype == TType.I64:
22161 
          self.estimate = iprot.readI64();
22162 
        else:
22163 
          iprot.skip(ftype)
4369 rajveer 22164 
      elif fid == 5:
22165 
        if ftype == TType.BOOL:
22166 
          self.isReminder = iprot.readBool();
22167 
        else:
22168 
          iprot.skip(ftype)
4303 rajveer 22169 
      else:
22170 
        iprot.skip(ftype)
22171 
      iprot.readFieldEnd()
22172 
    iprot.readStructEnd()
22173 
 
22174 
  def write(self, oprot):
22175 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22176 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22177 
      return
22178 
    oprot.writeStructBegin('markOrdersAsReversalInitiated_args')
22179 
    if self.vendorId is not None:
22180 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
22181 
      oprot.writeI64(self.vendorId)
22182 
      oprot.writeFieldEnd()
22183 
    if self.itemId is not None:
22184 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
22185 
      oprot.writeI64(self.itemId)
22186 
      oprot.writeFieldEnd()
22187 
    if self.quantity is not None:
22188 
      oprot.writeFieldBegin('quantity', TType.I64, 3)
22189 
      oprot.writeI64(self.quantity)
22190 
      oprot.writeFieldEnd()
22191 
    if self.estimate is not None:
22192 
      oprot.writeFieldBegin('estimate', TType.I64, 4)
22193 
      oprot.writeI64(self.estimate)
22194 
      oprot.writeFieldEnd()
4369 rajveer 22195 
    if self.isReminder is not None:
22196 
      oprot.writeFieldBegin('isReminder', TType.BOOL, 5)
22197 
      oprot.writeBool(self.isReminder)
22198 
      oprot.writeFieldEnd()
4303 rajveer 22199 
    oprot.writeFieldStop()
22200 
    oprot.writeStructEnd()
22201 
 
22202 
  def validate(self):
22203 
    return
22204 
 
22205 
 
22206 
  def __repr__(self):
22207 
    L = ['%s=%r' % (key, value)
22208 
      for key, value in self.__dict__.iteritems()]
22209 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22210 
 
22211 
  def __eq__(self, other):
22212 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22213 
 
22214 
  def __ne__(self, other):
22215 
    return not (self == other)
22216 
 
22217 
class markOrdersAsReversalInitiated_result:
22218 
  """
22219 
  Attributes:
22220 
   - ex
22221 
  """
22222 
 
22223 
  thrift_spec = (
22224 
    None, # 0
22225 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
22226 
  )
22227 
 
22228 
  def __init__(self, ex=None,):
22229 
    self.ex = ex
22230 
 
22231 
  def read(self, iprot):
22232 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22233 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22234 
      return
22235 
    iprot.readStructBegin()
22236 
    while True:
22237 
      (fname, ftype, fid) = iprot.readFieldBegin()
22238 
      if ftype == TType.STOP:
22239 
        break
22240 
      if fid == 1:
22241 
        if ftype == TType.STRUCT:
22242 
          self.ex = TransactionServiceException()
22243 
          self.ex.read(iprot)
22244 
        else:
22245 
          iprot.skip(ftype)
22246 
      else:
22247 
        iprot.skip(ftype)
22248 
      iprot.readFieldEnd()
22249 
    iprot.readStructEnd()
22250 
 
22251 
  def write(self, oprot):
22252 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22253 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22254 
      return
22255 
    oprot.writeStructBegin('markOrdersAsReversalInitiated_result')
22256 
    if self.ex is not None:
22257 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
22258 
      self.ex.write(oprot)
22259 
      oprot.writeFieldEnd()
22260 
    oprot.writeFieldStop()
22261 
    oprot.writeStructEnd()
22262 
 
22263 
  def validate(self):
22264 
    return
22265 
 
22266 
 
22267 
  def __repr__(self):
22268 
    L = ['%s=%r' % (key, value)
22269 
      for key, value in self.__dict__.iteritems()]
22270 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22271 
 
22272 
  def __eq__(self, other):
22273 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22274 
 
22275 
  def __ne__(self, other):
22276 
    return not (self == other)
22277 
 
22278 
class markOrdersAsNotAvailabke_args:
22279 
  """
22280 
  Attributes:
22281 
   - vendorId
22282 
   - itemId
22283 
   - quantity
22284 
   - estimate
4369 rajveer 22285 
   - isReminder
4303 rajveer 22286 
  """
22287 
 
22288 
  thrift_spec = (
22289 
    None, # 0
22290 
    (1, TType.I64, 'vendorId', None, None, ), # 1
22291 
    (2, TType.I64, 'itemId', None, None, ), # 2
22292 
    (3, TType.I64, 'quantity', None, None, ), # 3
22293 
    (4, TType.I64, 'estimate', None, None, ), # 4
4369 rajveer 22294 
    (5, TType.BOOL, 'isReminder', None, None, ), # 5
4303 rajveer 22295 
  )
22296 
 
4369 rajveer 22297 
  def __init__(self, vendorId=None, itemId=None, quantity=None, estimate=None, isReminder=None,):
4303 rajveer 22298 
    self.vendorId = vendorId
22299 
    self.itemId = itemId
22300 
    self.quantity = quantity
22301 
    self.estimate = estimate
4369 rajveer 22302 
    self.isReminder = isReminder
4303 rajveer 22303 
 
22304 
  def read(self, iprot):
22305 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22306 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22307 
      return
22308 
    iprot.readStructBegin()
22309 
    while True:
22310 
      (fname, ftype, fid) = iprot.readFieldBegin()
22311 
      if ftype == TType.STOP:
22312 
        break
22313 
      if fid == 1:
22314 
        if ftype == TType.I64:
22315 
          self.vendorId = iprot.readI64();
22316 
        else:
22317 
          iprot.skip(ftype)
22318 
      elif fid == 2:
22319 
        if ftype == TType.I64:
22320 
          self.itemId = iprot.readI64();
22321 
        else:
22322 
          iprot.skip(ftype)
22323 
      elif fid == 3:
22324 
        if ftype == TType.I64:
22325 
          self.quantity = iprot.readI64();
22326 
        else:
22327 
          iprot.skip(ftype)
22328 
      elif fid == 4:
22329 
        if ftype == TType.I64:
22330 
          self.estimate = iprot.readI64();
22331 
        else:
22332 
          iprot.skip(ftype)
4369 rajveer 22333 
      elif fid == 5:
22334 
        if ftype == TType.BOOL:
22335 
          self.isReminder = iprot.readBool();
22336 
        else:
22337 
          iprot.skip(ftype)
4303 rajveer 22338 
      else:
22339 
        iprot.skip(ftype)
22340 
      iprot.readFieldEnd()
22341 
    iprot.readStructEnd()
22342 
 
22343 
  def write(self, oprot):
22344 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22345 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22346 
      return
22347 
    oprot.writeStructBegin('markOrdersAsNotAvailabke_args')
22348 
    if self.vendorId is not None:
22349 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
22350 
      oprot.writeI64(self.vendorId)
22351 
      oprot.writeFieldEnd()
22352 
    if self.itemId is not None:
22353 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
22354 
      oprot.writeI64(self.itemId)
22355 
      oprot.writeFieldEnd()
22356 
    if self.quantity is not None:
22357 
      oprot.writeFieldBegin('quantity', TType.I64, 3)
22358 
      oprot.writeI64(self.quantity)
22359 
      oprot.writeFieldEnd()
22360 
    if self.estimate is not None:
22361 
      oprot.writeFieldBegin('estimate', TType.I64, 4)
22362 
      oprot.writeI64(self.estimate)
22363 
      oprot.writeFieldEnd()
4369 rajveer 22364 
    if self.isReminder is not None:
22365 
      oprot.writeFieldBegin('isReminder', TType.BOOL, 5)
22366 
      oprot.writeBool(self.isReminder)
22367 
      oprot.writeFieldEnd()
4303 rajveer 22368 
    oprot.writeFieldStop()
22369 
    oprot.writeStructEnd()
22370 
 
22371 
  def validate(self):
22372 
    return
22373 
 
22374 
 
22375 
  def __repr__(self):
22376 
    L = ['%s=%r' % (key, value)
22377 
      for key, value in self.__dict__.iteritems()]
22378 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22379 
 
22380 
  def __eq__(self, other):
22381 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22382 
 
22383 
  def __ne__(self, other):
22384 
    return not (self == other)
22385 
 
22386 
class markOrdersAsNotAvailabke_result:
22387 
  """
22388 
  Attributes:
22389 
   - ex
22390 
  """
22391 
 
22392 
  thrift_spec = (
22393 
    None, # 0
22394 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
22395 
  )
22396 
 
22397 
  def __init__(self, ex=None,):
22398 
    self.ex = ex
22399 
 
22400 
  def read(self, iprot):
22401 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22402 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22403 
      return
22404 
    iprot.readStructBegin()
22405 
    while True:
22406 
      (fname, ftype, fid) = iprot.readFieldBegin()
22407 
      if ftype == TType.STOP:
22408 
        break
22409 
      if fid == 1:
22410 
        if ftype == TType.STRUCT:
22411 
          self.ex = TransactionServiceException()
22412 
          self.ex.read(iprot)
22413 
        else:
22414 
          iprot.skip(ftype)
22415 
      else:
22416 
        iprot.skip(ftype)
22417 
      iprot.readFieldEnd()
22418 
    iprot.readStructEnd()
22419 
 
22420 
  def write(self, oprot):
22421 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22422 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22423 
      return
22424 
    oprot.writeStructBegin('markOrdersAsNotAvailabke_result')
22425 
    if self.ex is not None:
22426 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
22427 
      self.ex.write(oprot)
22428 
      oprot.writeFieldEnd()
22429 
    oprot.writeFieldStop()
22430 
    oprot.writeStructEnd()
22431 
 
22432 
  def validate(self):
22433 
    return
22434 
 
22435 
 
22436 
  def __repr__(self):
22437 
    L = ['%s=%r' % (key, value)
22438 
      for key, value in self.__dict__.iteritems()]
22439 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22440 
 
22441 
  def __eq__(self, other):
22442 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22443 
 
22444 
  def __ne__(self, other):
22445 
    return not (self == other)
4369 rajveer 22446 
 
22447 
class markOrdersAsTimeout_args:
22448 
  """
22449 
  Attributes:
22450 
   - vendorId
22451 
  """
22452 
 
22453 
  thrift_spec = (
22454 
    None, # 0
22455 
    (1, TType.I64, 'vendorId', None, None, ), # 1
22456 
  )
22457 
 
22458 
  def __init__(self, vendorId=None,):
22459 
    self.vendorId = vendorId
22460 
 
22461 
  def read(self, iprot):
22462 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22463 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22464 
      return
22465 
    iprot.readStructBegin()
22466 
    while True:
22467 
      (fname, ftype, fid) = iprot.readFieldBegin()
22468 
      if ftype == TType.STOP:
22469 
        break
22470 
      if fid == 1:
22471 
        if ftype == TType.I64:
22472 
          self.vendorId = iprot.readI64();
22473 
        else:
22474 
          iprot.skip(ftype)
22475 
      else:
22476 
        iprot.skip(ftype)
22477 
      iprot.readFieldEnd()
22478 
    iprot.readStructEnd()
22479 
 
22480 
  def write(self, oprot):
22481 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22482 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22483 
      return
22484 
    oprot.writeStructBegin('markOrdersAsTimeout_args')
22485 
    if self.vendorId is not None:
22486 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
22487 
      oprot.writeI64(self.vendorId)
22488 
      oprot.writeFieldEnd()
22489 
    oprot.writeFieldStop()
22490 
    oprot.writeStructEnd()
22491 
 
22492 
  def validate(self):
22493 
    return
22494 
 
22495 
 
22496 
  def __repr__(self):
22497 
    L = ['%s=%r' % (key, value)
22498 
      for key, value in self.__dict__.iteritems()]
22499 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22500 
 
22501 
  def __eq__(self, other):
22502 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22503 
 
22504 
  def __ne__(self, other):
22505 
    return not (self == other)
22506 
 
22507 
class markOrdersAsTimeout_result:
22508 
  """
22509 
  Attributes:
22510 
   - success
22511 
   - ex
22512 
  """
22513 
 
22514 
  thrift_spec = (
22515 
    (0, TType.MAP, 'success', (TType.I32,None,TType.STRUCT,(TimeoutSummary, TimeoutSummary.thrift_spec)), None, ), # 0
22516 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
22517 
  )
22518 
 
22519 
  def __init__(self, success=None, ex=None,):
22520 
    self.success = success
22521 
    self.ex = ex
22522 
 
22523 
  def read(self, iprot):
22524 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22525 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22526 
      return
22527 
    iprot.readStructBegin()
22528 
    while True:
22529 
      (fname, ftype, fid) = iprot.readFieldBegin()
22530 
      if ftype == TType.STOP:
22531 
        break
22532 
      if fid == 0:
22533 
        if ftype == TType.MAP:
22534 
          self.success = {}
6188 rajveer 22535 
          (_ktype502, _vtype503, _size501 ) = iprot.readMapBegin()
22536 
          for _i505 in xrange(_size501):
22537 
            _key506 = iprot.readI32();
22538 
            _val507 = TimeoutSummary()
22539 
            _val507.read(iprot)
22540 
            self.success[_key506] = _val507
4369 rajveer 22541 
          iprot.readMapEnd()
22542 
        else:
22543 
          iprot.skip(ftype)
22544 
      elif fid == 1:
22545 
        if ftype == TType.STRUCT:
22546 
          self.ex = TransactionServiceException()
22547 
          self.ex.read(iprot)
22548 
        else:
22549 
          iprot.skip(ftype)
22550 
      else:
22551 
        iprot.skip(ftype)
22552 
      iprot.readFieldEnd()
22553 
    iprot.readStructEnd()
22554 
 
22555 
  def write(self, oprot):
22556 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22557 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22558 
      return
22559 
    oprot.writeStructBegin('markOrdersAsTimeout_result')
22560 
    if self.success is not None:
22561 
      oprot.writeFieldBegin('success', TType.MAP, 0)
22562 
      oprot.writeMapBegin(TType.I32, TType.STRUCT, len(self.success))
6188 rajveer 22563 
      for kiter508,viter509 in self.success.items():
22564 
        oprot.writeI32(kiter508)
22565 
        viter509.write(oprot)
4369 rajveer 22566 
      oprot.writeMapEnd()
22567 
      oprot.writeFieldEnd()
22568 
    if self.ex is not None:
22569 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
22570 
      self.ex.write(oprot)
22571 
      oprot.writeFieldEnd()
22572 
    oprot.writeFieldStop()
22573 
    oprot.writeStructEnd()
22574 
 
22575 
  def validate(self):
22576 
    return
22577 
 
22578 
 
22579 
  def __repr__(self):
22580 
    L = ['%s=%r' % (key, value)
22581 
      for key, value in self.__dict__.iteritems()]
22582 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22583 
 
22584 
  def __eq__(self, other):
22585 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22586 
 
22587 
  def __ne__(self, other):
22588 
    return not (self == other)
4386 anupam.sin 22589 
 
4662 rajveer 22590 
class markOrderAsLostInTransit_args:
22591 
  """
22592 
  Attributes:
22593 
   - orderId
22594 
  """
22595 
 
22596 
  thrift_spec = (
22597 
    None, # 0
22598 
    (1, TType.I64, 'orderId', None, None, ), # 1
22599 
  )
22600 
 
22601 
  def __init__(self, orderId=None,):
22602 
    self.orderId = orderId
22603 
 
22604 
  def read(self, iprot):
22605 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22606 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22607 
      return
22608 
    iprot.readStructBegin()
22609 
    while True:
22610 
      (fname, ftype, fid) = iprot.readFieldBegin()
22611 
      if ftype == TType.STOP:
22612 
        break
22613 
      if fid == 1:
22614 
        if ftype == TType.I64:
22615 
          self.orderId = iprot.readI64();
22616 
        else:
22617 
          iprot.skip(ftype)
22618 
      else:
22619 
        iprot.skip(ftype)
22620 
      iprot.readFieldEnd()
22621 
    iprot.readStructEnd()
22622 
 
22623 
  def write(self, oprot):
22624 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22625 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22626 
      return
22627 
    oprot.writeStructBegin('markOrderAsLostInTransit_args')
22628 
    if self.orderId is not None:
22629 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
22630 
      oprot.writeI64(self.orderId)
22631 
      oprot.writeFieldEnd()
22632 
    oprot.writeFieldStop()
22633 
    oprot.writeStructEnd()
22634 
 
22635 
  def validate(self):
22636 
    return
22637 
 
22638 
 
22639 
  def __repr__(self):
22640 
    L = ['%s=%r' % (key, value)
22641 
      for key, value in self.__dict__.iteritems()]
22642 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22643 
 
22644 
  def __eq__(self, other):
22645 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22646 
 
22647 
  def __ne__(self, other):
22648 
    return not (self == other)
22649 
 
22650 
class markOrderAsLostInTransit_result:
22651 
  """
22652 
  Attributes:
22653 
   - success
22654 
   - ex
22655 
  """
22656 
 
22657 
  thrift_spec = (
22658 
    (0, TType.BOOL, 'success', None, None, ), # 0
22659 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
22660 
  )
22661 
 
22662 
  def __init__(self, success=None, ex=None,):
22663 
    self.success = success
22664 
    self.ex = ex
22665 
 
22666 
  def read(self, iprot):
22667 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22668 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22669 
      return
22670 
    iprot.readStructBegin()
22671 
    while True:
22672 
      (fname, ftype, fid) = iprot.readFieldBegin()
22673 
      if ftype == TType.STOP:
22674 
        break
22675 
      if fid == 0:
22676 
        if ftype == TType.BOOL:
22677 
          self.success = iprot.readBool();
22678 
        else:
22679 
          iprot.skip(ftype)
22680 
      elif fid == 1:
22681 
        if ftype == TType.STRUCT:
22682 
          self.ex = TransactionServiceException()
22683 
          self.ex.read(iprot)
22684 
        else:
22685 
          iprot.skip(ftype)
22686 
      else:
22687 
        iprot.skip(ftype)
22688 
      iprot.readFieldEnd()
22689 
    iprot.readStructEnd()
22690 
 
22691 
  def write(self, oprot):
22692 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22693 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22694 
      return
22695 
    oprot.writeStructBegin('markOrderAsLostInTransit_result')
22696 
    if self.success is not None:
22697 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
22698 
      oprot.writeBool(self.success)
22699 
      oprot.writeFieldEnd()
22700 
    if self.ex is not None:
22701 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
22702 
      self.ex.write(oprot)
22703 
      oprot.writeFieldEnd()
22704 
    oprot.writeFieldStop()
22705 
    oprot.writeStructEnd()
22706 
 
22707 
  def validate(self):
22708 
    return
22709 
 
22710 
 
22711 
  def __repr__(self):
22712 
    L = ['%s=%r' % (key, value)
22713 
      for key, value in self.__dict__.iteritems()]
22714 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22715 
 
22716 
  def __eq__(self, other):
22717 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22718 
 
22719 
  def __ne__(self, other):
22720 
    return not (self == other)
22721 
 
4386 anupam.sin 22722 
class getOrderForAwb_args:
22723 
  """
22724 
  Attributes:
22725 
   - awb
22726 
  """
22727 
 
22728 
  thrift_spec = (
22729 
    None, # 0
22730 
    (1, TType.STRING, 'awb', None, None, ), # 1
22731 
  )
22732 
 
22733 
  def __init__(self, awb=None,):
22734 
    self.awb = awb
22735 
 
22736 
  def read(self, iprot):
22737 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22738 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22739 
      return
22740 
    iprot.readStructBegin()
22741 
    while True:
22742 
      (fname, ftype, fid) = iprot.readFieldBegin()
22743 
      if ftype == TType.STOP:
22744 
        break
22745 
      if fid == 1:
22746 
        if ftype == TType.STRING:
22747 
          self.awb = iprot.readString();
22748 
        else:
22749 
          iprot.skip(ftype)
22750 
      else:
22751 
        iprot.skip(ftype)
22752 
      iprot.readFieldEnd()
22753 
    iprot.readStructEnd()
22754 
 
22755 
  def write(self, oprot):
22756 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22757 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22758 
      return
22759 
    oprot.writeStructBegin('getOrderForAwb_args')
22760 
    if self.awb is not None:
22761 
      oprot.writeFieldBegin('awb', TType.STRING, 1)
22762 
      oprot.writeString(self.awb)
22763 
      oprot.writeFieldEnd()
22764 
    oprot.writeFieldStop()
22765 
    oprot.writeStructEnd()
22766 
 
22767 
  def validate(self):
22768 
    return
22769 
 
22770 
 
22771 
  def __repr__(self):
22772 
    L = ['%s=%r' % (key, value)
22773 
      for key, value in self.__dict__.iteritems()]
22774 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22775 
 
22776 
  def __eq__(self, other):
22777 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22778 
 
22779 
  def __ne__(self, other):
22780 
    return not (self == other)
22781 
 
22782 
class getOrderForAwb_result:
22783 
  """
22784 
  Attributes:
22785 
   - success
22786 
   - ex
22787 
  """
22788 
 
22789 
  thrift_spec = (
22790 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
22791 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
22792 
  )
22793 
 
22794 
  def __init__(self, success=None, ex=None,):
22795 
    self.success = success
22796 
    self.ex = ex
22797 
 
22798 
  def read(self, iprot):
22799 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22800 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22801 
      return
22802 
    iprot.readStructBegin()
22803 
    while True:
22804 
      (fname, ftype, fid) = iprot.readFieldBegin()
22805 
      if ftype == TType.STOP:
22806 
        break
22807 
      if fid == 0:
22808 
        if ftype == TType.STRUCT:
22809 
          self.success = Order()
22810 
          self.success.read(iprot)
22811 
        else:
22812 
          iprot.skip(ftype)
22813 
      elif fid == 1:
22814 
        if ftype == TType.STRUCT:
22815 
          self.ex = TransactionServiceException()
22816 
          self.ex.read(iprot)
22817 
        else:
22818 
          iprot.skip(ftype)
22819 
      else:
22820 
        iprot.skip(ftype)
22821 
      iprot.readFieldEnd()
22822 
    iprot.readStructEnd()
22823 
 
22824 
  def write(self, oprot):
22825 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22826 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22827 
      return
22828 
    oprot.writeStructBegin('getOrderForAwb_result')
22829 
    if self.success is not None:
22830 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
22831 
      self.success.write(oprot)
22832 
      oprot.writeFieldEnd()
22833 
    if self.ex is not None:
22834 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
22835 
      self.ex.write(oprot)
22836 
      oprot.writeFieldEnd()
22837 
    oprot.writeFieldStop()
22838 
    oprot.writeStructEnd()
22839 
 
22840 
  def validate(self):
22841 
    return
22842 
 
22843 
 
22844 
  def __repr__(self):
22845 
    L = ['%s=%r' % (key, value)
22846 
      for key, value in self.__dict__.iteritems()]
22847 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22848 
 
22849 
  def __eq__(self, other):
22850 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22851 
 
22852 
  def __ne__(self, other):
22853 
    return not (self == other)
4506 phani.kuma 22854 
 
22855 
class getOrdersForProviderForStatus_args:
22856 
  """
22857 
  Attributes:
22858 
   - logistics_provider_id
4910 phani.kuma 22859 
   - order_status_list
4506 phani.kuma 22860 
  """
22861 
 
22862 
  thrift_spec = (
22863 
    None, # 0
22864 
    (1, TType.I64, 'logistics_provider_id', None, None, ), # 1
4910 phani.kuma 22865 
    (2, TType.LIST, 'order_status_list', (TType.I32,None), None, ), # 2
4506 phani.kuma 22866 
  )
22867 
 
4910 phani.kuma 22868 
  def __init__(self, logistics_provider_id=None, order_status_list=None,):
4506 phani.kuma 22869 
    self.logistics_provider_id = logistics_provider_id
4910 phani.kuma 22870 
    self.order_status_list = order_status_list
4506 phani.kuma 22871 
 
22872 
  def read(self, iprot):
22873 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22874 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22875 
      return
22876 
    iprot.readStructBegin()
22877 
    while True:
22878 
      (fname, ftype, fid) = iprot.readFieldBegin()
22879 
      if ftype == TType.STOP:
22880 
        break
22881 
      if fid == 1:
22882 
        if ftype == TType.I64:
22883 
          self.logistics_provider_id = iprot.readI64();
22884 
        else:
22885 
          iprot.skip(ftype)
22886 
      elif fid == 2:
4910 phani.kuma 22887 
        if ftype == TType.LIST:
22888 
          self.order_status_list = []
6188 rajveer 22889 
          (_etype513, _size510) = iprot.readListBegin()
22890 
          for _i514 in xrange(_size510):
22891 
            _elem515 = iprot.readI32();
22892 
            self.order_status_list.append(_elem515)
4910 phani.kuma 22893 
          iprot.readListEnd()
4506 phani.kuma 22894 
        else:
22895 
          iprot.skip(ftype)
22896 
      else:
22897 
        iprot.skip(ftype)
22898 
      iprot.readFieldEnd()
22899 
    iprot.readStructEnd()
22900 
 
22901 
  def write(self, oprot):
22902 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22903 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22904 
      return
22905 
    oprot.writeStructBegin('getOrdersForProviderForStatus_args')
22906 
    if self.logistics_provider_id is not None:
22907 
      oprot.writeFieldBegin('logistics_provider_id', TType.I64, 1)
22908 
      oprot.writeI64(self.logistics_provider_id)
22909 
      oprot.writeFieldEnd()
4910 phani.kuma 22910 
    if self.order_status_list is not None:
22911 
      oprot.writeFieldBegin('order_status_list', TType.LIST, 2)
22912 
      oprot.writeListBegin(TType.I32, len(self.order_status_list))
6188 rajveer 22913 
      for iter516 in self.order_status_list:
22914 
        oprot.writeI32(iter516)
4910 phani.kuma 22915 
      oprot.writeListEnd()
4506 phani.kuma 22916 
      oprot.writeFieldEnd()
22917 
    oprot.writeFieldStop()
22918 
    oprot.writeStructEnd()
22919 
 
22920 
  def validate(self):
22921 
    return
22922 
 
22923 
 
22924 
  def __repr__(self):
22925 
    L = ['%s=%r' % (key, value)
22926 
      for key, value in self.__dict__.iteritems()]
22927 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22928 
 
22929 
  def __eq__(self, other):
22930 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22931 
 
22932 
  def __ne__(self, other):
22933 
    return not (self == other)
22934 
 
22935 
class getOrdersForProviderForStatus_result:
22936 
  """
22937 
  Attributes:
22938 
   - success
22939 
   - ex
22940 
  """
22941 
 
22942 
  thrift_spec = (
22943 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
22944 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
22945 
  )
22946 
 
22947 
  def __init__(self, success=None, ex=None,):
22948 
    self.success = success
22949 
    self.ex = ex
22950 
 
22951 
  def read(self, iprot):
22952 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22953 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22954 
      return
22955 
    iprot.readStructBegin()
22956 
    while True:
22957 
      (fname, ftype, fid) = iprot.readFieldBegin()
22958 
      if ftype == TType.STOP:
22959 
        break
22960 
      if fid == 0:
22961 
        if ftype == TType.LIST:
22962 
          self.success = []
6188 rajveer 22963 
          (_etype520, _size517) = iprot.readListBegin()
22964 
          for _i521 in xrange(_size517):
22965 
            _elem522 = Order()
22966 
            _elem522.read(iprot)
22967 
            self.success.append(_elem522)
4506 phani.kuma 22968 
          iprot.readListEnd()
22969 
        else:
22970 
          iprot.skip(ftype)
22971 
      elif fid == 1:
22972 
        if ftype == TType.STRUCT:
22973 
          self.ex = TransactionServiceException()
22974 
          self.ex.read(iprot)
22975 
        else:
22976 
          iprot.skip(ftype)
22977 
      else:
22978 
        iprot.skip(ftype)
22979 
      iprot.readFieldEnd()
22980 
    iprot.readStructEnd()
22981 
 
22982 
  def write(self, oprot):
22983 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22984 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22985 
      return
22986 
    oprot.writeStructBegin('getOrdersForProviderForStatus_result')
22987 
    if self.success is not None:
22988 
      oprot.writeFieldBegin('success', TType.LIST, 0)
22989 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 22990 
      for iter523 in self.success:
22991 
        iter523.write(oprot)
4506 phani.kuma 22992 
      oprot.writeListEnd()
22993 
      oprot.writeFieldEnd()
22994 
    if self.ex is not None:
22995 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
22996 
      self.ex.write(oprot)
22997 
      oprot.writeFieldEnd()
22998 
    oprot.writeFieldStop()
22999 
    oprot.writeStructEnd()
23000 
 
23001 
  def validate(self):
23002 
    return
23003 
 
23004 
 
23005 
  def __repr__(self):
23006 
    L = ['%s=%r' % (key, value)
23007 
      for key, value in self.__dict__.iteritems()]
23008 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23009 
 
23010 
  def __eq__(self, other):
23011 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23012 
 
23013 
  def __ne__(self, other):
23014 
    return not (self == other)
4600 varun.gupt 23015 
 
23016 
class getBilledOrdersForVendor_args:
23017 
  """
23018 
  Attributes:
23019 
   - vendorId
23020 
   - billingDateFrom
23021 
   - billingDateTo
23022 
  """
23023 
 
23024 
  thrift_spec = (
23025 
    None, # 0
23026 
    (1, TType.I64, 'vendorId', None, None, ), # 1
23027 
    (2, TType.I64, 'billingDateFrom', None, None, ), # 2
23028 
    (3, TType.I64, 'billingDateTo', None, None, ), # 3
23029 
  )
23030 
 
23031 
  def __init__(self, vendorId=None, billingDateFrom=None, billingDateTo=None,):
23032 
    self.vendorId = vendorId
23033 
    self.billingDateFrom = billingDateFrom
23034 
    self.billingDateTo = billingDateTo
23035 
 
23036 
  def read(self, iprot):
23037 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23038 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23039 
      return
23040 
    iprot.readStructBegin()
23041 
    while True:
23042 
      (fname, ftype, fid) = iprot.readFieldBegin()
23043 
      if ftype == TType.STOP:
23044 
        break
23045 
      if fid == 1:
23046 
        if ftype == TType.I64:
23047 
          self.vendorId = iprot.readI64();
23048 
        else:
23049 
          iprot.skip(ftype)
23050 
      elif fid == 2:
23051 
        if ftype == TType.I64:
23052 
          self.billingDateFrom = iprot.readI64();
23053 
        else:
23054 
          iprot.skip(ftype)
23055 
      elif fid == 3:
23056 
        if ftype == TType.I64:
23057 
          self.billingDateTo = iprot.readI64();
23058 
        else:
23059 
          iprot.skip(ftype)
23060 
      else:
23061 
        iprot.skip(ftype)
23062 
      iprot.readFieldEnd()
23063 
    iprot.readStructEnd()
23064 
 
23065 
  def write(self, oprot):
23066 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23067 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23068 
      return
23069 
    oprot.writeStructBegin('getBilledOrdersForVendor_args')
23070 
    if self.vendorId is not None:
23071 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
23072 
      oprot.writeI64(self.vendorId)
23073 
      oprot.writeFieldEnd()
23074 
    if self.billingDateFrom is not None:
23075 
      oprot.writeFieldBegin('billingDateFrom', TType.I64, 2)
23076 
      oprot.writeI64(self.billingDateFrom)
23077 
      oprot.writeFieldEnd()
23078 
    if self.billingDateTo is not None:
23079 
      oprot.writeFieldBegin('billingDateTo', TType.I64, 3)
23080 
      oprot.writeI64(self.billingDateTo)
23081 
      oprot.writeFieldEnd()
23082 
    oprot.writeFieldStop()
23083 
    oprot.writeStructEnd()
23084 
 
23085 
  def validate(self):
23086 
    return
23087 
 
23088 
 
23089 
  def __repr__(self):
23090 
    L = ['%s=%r' % (key, value)
23091 
      for key, value in self.__dict__.iteritems()]
23092 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23093 
 
23094 
  def __eq__(self, other):
23095 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23096 
 
23097 
  def __ne__(self, other):
23098 
    return not (self == other)
23099 
 
23100 
class getBilledOrdersForVendor_result:
23101 
  """
23102 
  Attributes:
23103 
   - success
23104 
   - ex
23105 
  """
23106 
 
23107 
  thrift_spec = (
23108 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
23109 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
23110 
  )
23111 
 
23112 
  def __init__(self, success=None, ex=None,):
23113 
    self.success = success
23114 
    self.ex = ex
23115 
 
23116 
  def read(self, iprot):
23117 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23118 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23119 
      return
23120 
    iprot.readStructBegin()
23121 
    while True:
23122 
      (fname, ftype, fid) = iprot.readFieldBegin()
23123 
      if ftype == TType.STOP:
23124 
        break
23125 
      if fid == 0:
23126 
        if ftype == TType.LIST:
23127 
          self.success = []
6188 rajveer 23128 
          (_etype527, _size524) = iprot.readListBegin()
23129 
          for _i528 in xrange(_size524):
23130 
            _elem529 = Order()
23131 
            _elem529.read(iprot)
23132 
            self.success.append(_elem529)
4600 varun.gupt 23133 
          iprot.readListEnd()
23134 
        else:
23135 
          iprot.skip(ftype)
23136 
      elif fid == 1:
23137 
        if ftype == TType.STRUCT:
23138 
          self.ex = TransactionServiceException()
23139 
          self.ex.read(iprot)
23140 
        else:
23141 
          iprot.skip(ftype)
23142 
      else:
23143 
        iprot.skip(ftype)
23144 
      iprot.readFieldEnd()
23145 
    iprot.readStructEnd()
23146 
 
23147 
  def write(self, oprot):
23148 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23149 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23150 
      return
23151 
    oprot.writeStructBegin('getBilledOrdersForVendor_result')
23152 
    if self.success is not None:
23153 
      oprot.writeFieldBegin('success', TType.LIST, 0)
23154 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 23155 
      for iter530 in self.success:
23156 
        iter530.write(oprot)
4600 varun.gupt 23157 
      oprot.writeListEnd()
23158 
      oprot.writeFieldEnd()
23159 
    if self.ex is not None:
23160 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
23161 
      self.ex.write(oprot)
23162 
      oprot.writeFieldEnd()
23163 
    oprot.writeFieldStop()
23164 
    oprot.writeStructEnd()
23165 
 
23166 
  def validate(self):
23167 
    return
23168 
 
23169 
 
23170 
  def __repr__(self):
23171 
    L = ['%s=%r' % (key, value)
23172 
      for key, value in self.__dict__.iteritems()]
23173 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23174 
 
23175 
  def __eq__(self, other):
23176 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23177 
 
23178 
  def __ne__(self, other):
23179 
    return not (self == other)
23180 
 
4607 rajveer 23181 
class getSlippedSippingDateOrders_args:
23182 
 
23183 
  thrift_spec = (
23184 
  )
23185 
 
23186 
  def read(self, iprot):
23187 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23188 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23189 
      return
23190 
    iprot.readStructBegin()
23191 
    while True:
23192 
      (fname, ftype, fid) = iprot.readFieldBegin()
23193 
      if ftype == TType.STOP:
23194 
        break
23195 
      else:
23196 
        iprot.skip(ftype)
23197 
      iprot.readFieldEnd()
23198 
    iprot.readStructEnd()
23199 
 
23200 
  def write(self, oprot):
23201 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23202 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23203 
      return
23204 
    oprot.writeStructBegin('getSlippedSippingDateOrders_args')
23205 
    oprot.writeFieldStop()
23206 
    oprot.writeStructEnd()
23207 
 
23208 
  def validate(self):
23209 
    return
23210 
 
23211 
 
23212 
  def __repr__(self):
23213 
    L = ['%s=%r' % (key, value)
23214 
      for key, value in self.__dict__.iteritems()]
23215 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23216 
 
23217 
  def __eq__(self, other):
23218 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23219 
 
23220 
  def __ne__(self, other):
23221 
    return not (self == other)
23222 
 
23223 
class getSlippedSippingDateOrders_result:
23224 
  """
23225 
  Attributes:
23226 
   - success
23227 
   - ex
23228 
  """
23229 
 
23230 
  thrift_spec = (
23231 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
23232 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
23233 
  )
23234 
 
23235 
  def __init__(self, success=None, ex=None,):
23236 
    self.success = success
23237 
    self.ex = ex
23238 
 
23239 
  def read(self, iprot):
23240 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23241 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23242 
      return
23243 
    iprot.readStructBegin()
23244 
    while True:
23245 
      (fname, ftype, fid) = iprot.readFieldBegin()
23246 
      if ftype == TType.STOP:
23247 
        break
23248 
      if fid == 0:
23249 
        if ftype == TType.LIST:
23250 
          self.success = []
6188 rajveer 23251 
          (_etype534, _size531) = iprot.readListBegin()
23252 
          for _i535 in xrange(_size531):
23253 
            _elem536 = Order()
23254 
            _elem536.read(iprot)
23255 
            self.success.append(_elem536)
4607 rajveer 23256 
          iprot.readListEnd()
23257 
        else:
23258 
          iprot.skip(ftype)
23259 
      elif fid == 1:
23260 
        if ftype == TType.STRUCT:
23261 
          self.ex = TransactionServiceException()
23262 
          self.ex.read(iprot)
23263 
        else:
23264 
          iprot.skip(ftype)
23265 
      else:
23266 
        iprot.skip(ftype)
23267 
      iprot.readFieldEnd()
23268 
    iprot.readStructEnd()
23269 
 
23270 
  def write(self, oprot):
23271 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23272 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23273 
      return
23274 
    oprot.writeStructBegin('getSlippedSippingDateOrders_result')
23275 
    if self.success is not None:
23276 
      oprot.writeFieldBegin('success', TType.LIST, 0)
23277 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 23278 
      for iter537 in self.success:
23279 
        iter537.write(oprot)
4607 rajveer 23280 
      oprot.writeListEnd()
23281 
      oprot.writeFieldEnd()
23282 
    if self.ex is not None:
23283 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
23284 
      self.ex.write(oprot)
23285 
      oprot.writeFieldEnd()
23286 
    oprot.writeFieldStop()
23287 
    oprot.writeStructEnd()
23288 
 
23289 
  def validate(self):
23290 
    return
23291 
 
23292 
 
23293 
  def __repr__(self):
23294 
    L = ['%s=%r' % (key, value)
23295 
      for key, value in self.__dict__.iteritems()]
23296 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23297 
 
23298 
  def __eq__(self, other):
23299 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23300 
 
23301 
  def __ne__(self, other):
23302 
    return not (self == other)
23303 
 
4709 rajveer 23304 
class getCancelledOrders_args:
23305 
  """
23306 
  Attributes:
23307 
   - cancelDateFrom
23308 
   - cancelDateTo
23309 
  """
23310 
 
23311 
  thrift_spec = (
23312 
    None, # 0
23313 
    (1, TType.I64, 'cancelDateFrom', None, None, ), # 1
23314 
    (2, TType.I64, 'cancelDateTo', None, None, ), # 2
23315 
  )
23316 
 
23317 
  def __init__(self, cancelDateFrom=None, cancelDateTo=None,):
23318 
    self.cancelDateFrom = cancelDateFrom
23319 
    self.cancelDateTo = cancelDateTo
23320 
 
23321 
  def read(self, iprot):
23322 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23323 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23324 
      return
23325 
    iprot.readStructBegin()
23326 
    while True:
23327 
      (fname, ftype, fid) = iprot.readFieldBegin()
23328 
      if ftype == TType.STOP:
23329 
        break
23330 
      if fid == 1:
23331 
        if ftype == TType.I64:
23332 
          self.cancelDateFrom = iprot.readI64();
23333 
        else:
23334 
          iprot.skip(ftype)
23335 
      elif fid == 2:
23336 
        if ftype == TType.I64:
23337 
          self.cancelDateTo = iprot.readI64();
23338 
        else:
23339 
          iprot.skip(ftype)
23340 
      else:
23341 
        iprot.skip(ftype)
23342 
      iprot.readFieldEnd()
23343 
    iprot.readStructEnd()
23344 
 
23345 
  def write(self, oprot):
23346 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23347 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23348 
      return
23349 
    oprot.writeStructBegin('getCancelledOrders_args')
23350 
    if self.cancelDateFrom is not None:
23351 
      oprot.writeFieldBegin('cancelDateFrom', TType.I64, 1)
23352 
      oprot.writeI64(self.cancelDateFrom)
23353 
      oprot.writeFieldEnd()
23354 
    if self.cancelDateTo is not None:
23355 
      oprot.writeFieldBegin('cancelDateTo', TType.I64, 2)
23356 
      oprot.writeI64(self.cancelDateTo)
23357 
      oprot.writeFieldEnd()
23358 
    oprot.writeFieldStop()
23359 
    oprot.writeStructEnd()
23360 
 
23361 
  def validate(self):
23362 
    return
23363 
 
23364 
 
23365 
  def __repr__(self):
23366 
    L = ['%s=%r' % (key, value)
23367 
      for key, value in self.__dict__.iteritems()]
23368 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23369 
 
23370 
  def __eq__(self, other):
23371 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23372 
 
23373 
  def __ne__(self, other):
23374 
    return not (self == other)
23375 
 
23376 
class getCancelledOrders_result:
23377 
  """
23378 
  Attributes:
23379 
   - success
23380 
   - ex
23381 
  """
23382 
 
23383 
  thrift_spec = (
23384 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
23385 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
23386 
  )
23387 
 
23388 
  def __init__(self, success=None, ex=None,):
23389 
    self.success = success
23390 
    self.ex = ex
23391 
 
23392 
  def read(self, iprot):
23393 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23394 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23395 
      return
23396 
    iprot.readStructBegin()
23397 
    while True:
23398 
      (fname, ftype, fid) = iprot.readFieldBegin()
23399 
      if ftype == TType.STOP:
23400 
        break
23401 
      if fid == 0:
23402 
        if ftype == TType.LIST:
23403 
          self.success = []
6188 rajveer 23404 
          (_etype541, _size538) = iprot.readListBegin()
23405 
          for _i542 in xrange(_size538):
23406 
            _elem543 = Order()
23407 
            _elem543.read(iprot)
23408 
            self.success.append(_elem543)
4709 rajveer 23409 
          iprot.readListEnd()
23410 
        else:
23411 
          iprot.skip(ftype)
23412 
      elif fid == 1:
23413 
        if ftype == TType.STRUCT:
23414 
          self.ex = TransactionServiceException()
23415 
          self.ex.read(iprot)
23416 
        else:
23417 
          iprot.skip(ftype)
23418 
      else:
23419 
        iprot.skip(ftype)
23420 
      iprot.readFieldEnd()
23421 
    iprot.readStructEnd()
23422 
 
23423 
  def write(self, oprot):
23424 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23425 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23426 
      return
23427 
    oprot.writeStructBegin('getCancelledOrders_result')
23428 
    if self.success is not None:
23429 
      oprot.writeFieldBegin('success', TType.LIST, 0)
23430 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 23431 
      for iter544 in self.success:
23432 
        iter544.write(oprot)
4709 rajveer 23433 
      oprot.writeListEnd()
23434 
      oprot.writeFieldEnd()
23435 
    if self.ex is not None:
23436 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
23437 
      self.ex.write(oprot)
23438 
      oprot.writeFieldEnd()
23439 
    oprot.writeFieldStop()
23440 
    oprot.writeStructEnd()
23441 
 
23442 
  def validate(self):
23443 
    return
23444 
 
23445 
 
23446 
  def __repr__(self):
23447 
    L = ['%s=%r' % (key, value)
23448 
      for key, value in self.__dict__.iteritems()]
23449 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23450 
 
23451 
  def __eq__(self, other):
23452 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23453 
 
23454 
  def __ne__(self, other):
23455 
    return not (self == other)
23456 
 
4600 varun.gupt 23457 
class saveBluedartSettlements_args:
23458 
  """
23459 
  Attributes:
23460 
   - mapAWBAndAmount
23461 
  """
23462 
 
23463 
  thrift_spec = (
23464 
    None, # 0
23465 
    (1, TType.MAP, 'mapAWBAndAmount', (TType.I64,None,TType.DOUBLE,None), None, ), # 1
23466 
  )
23467 
 
23468 
  def __init__(self, mapAWBAndAmount=None,):
23469 
    self.mapAWBAndAmount = mapAWBAndAmount
23470 
 
23471 
  def read(self, iprot):
23472 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23473 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23474 
      return
23475 
    iprot.readStructBegin()
23476 
    while True:
23477 
      (fname, ftype, fid) = iprot.readFieldBegin()
23478 
      if ftype == TType.STOP:
23479 
        break
23480 
      if fid == 1:
23481 
        if ftype == TType.MAP:
23482 
          self.mapAWBAndAmount = {}
6188 rajveer 23483 
          (_ktype546, _vtype547, _size545 ) = iprot.readMapBegin()
23484 
          for _i549 in xrange(_size545):
23485 
            _key550 = iprot.readI64();
23486 
            _val551 = iprot.readDouble();
23487 
            self.mapAWBAndAmount[_key550] = _val551
4600 varun.gupt 23488 
          iprot.readMapEnd()
23489 
        else:
23490 
          iprot.skip(ftype)
23491 
      else:
23492 
        iprot.skip(ftype)
23493 
      iprot.readFieldEnd()
23494 
    iprot.readStructEnd()
23495 
 
23496 
  def write(self, oprot):
23497 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23498 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23499 
      return
23500 
    oprot.writeStructBegin('saveBluedartSettlements_args')
23501 
    if self.mapAWBAndAmount is not None:
23502 
      oprot.writeFieldBegin('mapAWBAndAmount', TType.MAP, 1)
23503 
      oprot.writeMapBegin(TType.I64, TType.DOUBLE, len(self.mapAWBAndAmount))
6188 rajveer 23504 
      for kiter552,viter553 in self.mapAWBAndAmount.items():
23505 
        oprot.writeI64(kiter552)
23506 
        oprot.writeDouble(viter553)
4600 varun.gupt 23507 
      oprot.writeMapEnd()
23508 
      oprot.writeFieldEnd()
23509 
    oprot.writeFieldStop()
23510 
    oprot.writeStructEnd()
23511 
 
23512 
  def validate(self):
23513 
    return
23514 
 
23515 
 
23516 
  def __repr__(self):
23517 
    L = ['%s=%r' % (key, value)
23518 
      for key, value in self.__dict__.iteritems()]
23519 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23520 
 
23521 
  def __eq__(self, other):
23522 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23523 
 
23524 
  def __ne__(self, other):
23525 
    return not (self == other)
23526 
 
23527 
class saveBluedartSettlements_result:
23528 
  """
23529 
  Attributes:
23530 
   - ex
23531 
  """
23532 
 
23533 
  thrift_spec = (
23534 
    None, # 0
23535 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
23536 
  )
23537 
 
23538 
  def __init__(self, ex=None,):
23539 
    self.ex = ex
23540 
 
23541 
  def read(self, iprot):
23542 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23543 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23544 
      return
23545 
    iprot.readStructBegin()
23546 
    while True:
23547 
      (fname, ftype, fid) = iprot.readFieldBegin()
23548 
      if ftype == TType.STOP:
23549 
        break
23550 
      if fid == 1:
23551 
        if ftype == TType.STRUCT:
23552 
          self.ex = TransactionServiceException()
23553 
          self.ex.read(iprot)
23554 
        else:
23555 
          iprot.skip(ftype)
23556 
      else:
23557 
        iprot.skip(ftype)
23558 
      iprot.readFieldEnd()
23559 
    iprot.readStructEnd()
23560 
 
23561 
  def write(self, oprot):
23562 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23563 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23564 
      return
23565 
    oprot.writeStructBegin('saveBluedartSettlements_result')
23566 
    if self.ex is not None:
23567 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
23568 
      self.ex.write(oprot)
23569 
      oprot.writeFieldEnd()
23570 
    oprot.writeFieldStop()
23571 
    oprot.writeStructEnd()
23572 
 
23573 
  def validate(self):
23574 
    return
23575 
 
23576 
 
23577 
  def __repr__(self):
23578 
    L = ['%s=%r' % (key, value)
23579 
      for key, value in self.__dict__.iteritems()]
23580 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23581 
 
23582 
  def __eq__(self, other):
23583 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23584 
 
23585 
  def __ne__(self, other):
23586 
    return not (self == other)
23587 
 
23588 
class savePaymentSettlements_args:
23589 
  """
23590 
  Attributes:
23591 
   - settlementDate
23592 
   - paymentGatewayId
4905 varun.gupt 23593 
   - referenceId
4600 varun.gupt 23594 
   - serviceTax
23595 
   - otherCharges
23596 
   - netCollection
23597 
  """
23598 
 
23599 
  thrift_spec = (
23600 
    None, # 0
23601 
    (1, TType.I64, 'settlementDate', None, None, ), # 1
23602 
    (2, TType.I64, 'paymentGatewayId', None, None, ), # 2
4905 varun.gupt 23603 
    (3, TType.I64, 'referenceId', None, None, ), # 3
4600 varun.gupt 23604 
    (4, TType.DOUBLE, 'serviceTax', None, None, ), # 4
23605 
    (5, TType.DOUBLE, 'otherCharges', None, None, ), # 5
23606 
    (6, TType.DOUBLE, 'netCollection', None, None, ), # 6
23607 
  )
23608 
 
4905 varun.gupt 23609 
  def __init__(self, settlementDate=None, paymentGatewayId=None, referenceId=None, serviceTax=None, otherCharges=None, netCollection=None,):
4600 varun.gupt 23610 
    self.settlementDate = settlementDate
23611 
    self.paymentGatewayId = paymentGatewayId
4905 varun.gupt 23612 
    self.referenceId = referenceId
4600 varun.gupt 23613 
    self.serviceTax = serviceTax
23614 
    self.otherCharges = otherCharges
23615 
    self.netCollection = netCollection
23616 
 
23617 
  def read(self, iprot):
23618 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23619 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23620 
      return
23621 
    iprot.readStructBegin()
23622 
    while True:
23623 
      (fname, ftype, fid) = iprot.readFieldBegin()
23624 
      if ftype == TType.STOP:
23625 
        break
23626 
      if fid == 1:
23627 
        if ftype == TType.I64:
23628 
          self.settlementDate = iprot.readI64();
23629 
        else:
23630 
          iprot.skip(ftype)
23631 
      elif fid == 2:
23632 
        if ftype == TType.I64:
23633 
          self.paymentGatewayId = iprot.readI64();
23634 
        else:
23635 
          iprot.skip(ftype)
23636 
      elif fid == 3:
23637 
        if ftype == TType.I64:
4905 varun.gupt 23638 
          self.referenceId = iprot.readI64();
4600 varun.gupt 23639 
        else:
23640 
          iprot.skip(ftype)
23641 
      elif fid == 4:
23642 
        if ftype == TType.DOUBLE:
23643 
          self.serviceTax = iprot.readDouble();
23644 
        else:
23645 
          iprot.skip(ftype)
23646 
      elif fid == 5:
23647 
        if ftype == TType.DOUBLE:
23648 
          self.otherCharges = iprot.readDouble();
23649 
        else:
23650 
          iprot.skip(ftype)
23651 
      elif fid == 6:
23652 
        if ftype == TType.DOUBLE:
23653 
          self.netCollection = iprot.readDouble();
23654 
        else:
23655 
          iprot.skip(ftype)
23656 
      else:
23657 
        iprot.skip(ftype)
23658 
      iprot.readFieldEnd()
23659 
    iprot.readStructEnd()
23660 
 
23661 
  def write(self, oprot):
23662 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23663 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23664 
      return
23665 
    oprot.writeStructBegin('savePaymentSettlements_args')
23666 
    if self.settlementDate is not None:
23667 
      oprot.writeFieldBegin('settlementDate', TType.I64, 1)
23668 
      oprot.writeI64(self.settlementDate)
23669 
      oprot.writeFieldEnd()
23670 
    if self.paymentGatewayId is not None:
23671 
      oprot.writeFieldBegin('paymentGatewayId', TType.I64, 2)
23672 
      oprot.writeI64(self.paymentGatewayId)
23673 
      oprot.writeFieldEnd()
4905 varun.gupt 23674 
    if self.referenceId is not None:
23675 
      oprot.writeFieldBegin('referenceId', TType.I64, 3)
23676 
      oprot.writeI64(self.referenceId)
4600 varun.gupt 23677 
      oprot.writeFieldEnd()
23678 
    if self.serviceTax is not None:
23679 
      oprot.writeFieldBegin('serviceTax', TType.DOUBLE, 4)
23680 
      oprot.writeDouble(self.serviceTax)
23681 
      oprot.writeFieldEnd()
23682 
    if self.otherCharges is not None:
23683 
      oprot.writeFieldBegin('otherCharges', TType.DOUBLE, 5)
23684 
      oprot.writeDouble(self.otherCharges)
23685 
      oprot.writeFieldEnd()
23686 
    if self.netCollection is not None:
23687 
      oprot.writeFieldBegin('netCollection', TType.DOUBLE, 6)
23688 
      oprot.writeDouble(self.netCollection)
23689 
      oprot.writeFieldEnd()
23690 
    oprot.writeFieldStop()
23691 
    oprot.writeStructEnd()
23692 
 
23693 
  def validate(self):
23694 
    return
23695 
 
23696 
 
23697 
  def __repr__(self):
23698 
    L = ['%s=%r' % (key, value)
23699 
      for key, value in self.__dict__.iteritems()]
23700 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23701 
 
23702 
  def __eq__(self, other):
23703 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23704 
 
23705 
  def __ne__(self, other):
23706 
    return not (self == other)
23707 
 
23708 
class savePaymentSettlements_result:
23709 
  """
23710 
  Attributes:
23711 
   - ex
23712 
  """
23713 
 
23714 
  thrift_spec = (
23715 
    None, # 0
23716 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
23717 
  )
23718 
 
23719 
  def __init__(self, ex=None,):
23720 
    self.ex = ex
23721 
 
23722 
  def read(self, iprot):
23723 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23724 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23725 
      return
23726 
    iprot.readStructBegin()
23727 
    while True:
23728 
      (fname, ftype, fid) = iprot.readFieldBegin()
23729 
      if ftype == TType.STOP:
23730 
        break
23731 
      if fid == 1:
23732 
        if ftype == TType.STRUCT:
23733 
          self.ex = TransactionServiceException()
23734 
          self.ex.read(iprot)
23735 
        else:
23736 
          iprot.skip(ftype)
23737 
      else:
23738 
        iprot.skip(ftype)
23739 
      iprot.readFieldEnd()
23740 
    iprot.readStructEnd()
23741 
 
23742 
  def write(self, oprot):
23743 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23744 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23745 
      return
23746 
    oprot.writeStructBegin('savePaymentSettlements_result')
23747 
    if self.ex is not None:
23748 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
23749 
      self.ex.write(oprot)
23750 
      oprot.writeFieldEnd()
23751 
    oprot.writeFieldStop()
23752 
    oprot.writeStructEnd()
23753 
 
23754 
  def validate(self):
23755 
    return
23756 
 
23757 
 
23758 
  def __repr__(self):
23759 
    L = ['%s=%r' % (key, value)
23760 
      for key, value in self.__dict__.iteritems()]
23761 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23762 
 
23763 
  def __eq__(self, other):
23764 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23765 
 
23766 
  def __ne__(self, other):
23767 
    return not (self == other)
23768 
 
23769 
class saveEBSSettlementSummary_args:
23770 
  """
23771 
  Attributes:
23772 
   - settlementId
23773 
   - settlementDate
23774 
   - transactionDateFrom
23775 
   - transactionDateTo
23776 
   - amount
23777 
  """
23778 
 
23779 
  thrift_spec = (
23780 
    None, # 0
23781 
    (1, TType.I64, 'settlementId', None, None, ), # 1
23782 
    (2, TType.I64, 'settlementDate', None, None, ), # 2
23783 
    (3, TType.I64, 'transactionDateFrom', None, None, ), # 3
23784 
    (4, TType.I64, 'transactionDateTo', None, None, ), # 4
23785 
    (5, TType.DOUBLE, 'amount', None, None, ), # 5
23786 
  )
23787 
 
23788 
  def __init__(self, settlementId=None, settlementDate=None, transactionDateFrom=None, transactionDateTo=None, amount=None,):
23789 
    self.settlementId = settlementId
23790 
    self.settlementDate = settlementDate
23791 
    self.transactionDateFrom = transactionDateFrom
23792 
    self.transactionDateTo = transactionDateTo
23793 
    self.amount = amount
23794 
 
23795 
  def read(self, iprot):
23796 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23797 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23798 
      return
23799 
    iprot.readStructBegin()
23800 
    while True:
23801 
      (fname, ftype, fid) = iprot.readFieldBegin()
23802 
      if ftype == TType.STOP:
23803 
        break
23804 
      if fid == 1:
23805 
        if ftype == TType.I64:
23806 
          self.settlementId = iprot.readI64();
23807 
        else:
23808 
          iprot.skip(ftype)
23809 
      elif fid == 2:
23810 
        if ftype == TType.I64:
23811 
          self.settlementDate = iprot.readI64();
23812 
        else:
23813 
          iprot.skip(ftype)
23814 
      elif fid == 3:
23815 
        if ftype == TType.I64:
23816 
          self.transactionDateFrom = iprot.readI64();
23817 
        else:
23818 
          iprot.skip(ftype)
23819 
      elif fid == 4:
23820 
        if ftype == TType.I64:
23821 
          self.transactionDateTo = iprot.readI64();
23822 
        else:
23823 
          iprot.skip(ftype)
23824 
      elif fid == 5:
23825 
        if ftype == TType.DOUBLE:
23826 
          self.amount = iprot.readDouble();
23827 
        else:
23828 
          iprot.skip(ftype)
23829 
      else:
23830 
        iprot.skip(ftype)
23831 
      iprot.readFieldEnd()
23832 
    iprot.readStructEnd()
23833 
 
23834 
  def write(self, oprot):
23835 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23836 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23837 
      return
23838 
    oprot.writeStructBegin('saveEBSSettlementSummary_args')
23839 
    if self.settlementId is not None:
23840 
      oprot.writeFieldBegin('settlementId', TType.I64, 1)
23841 
      oprot.writeI64(self.settlementId)
23842 
      oprot.writeFieldEnd()
23843 
    if self.settlementDate is not None:
23844 
      oprot.writeFieldBegin('settlementDate', TType.I64, 2)
23845 
      oprot.writeI64(self.settlementDate)
23846 
      oprot.writeFieldEnd()
23847 
    if self.transactionDateFrom is not None:
23848 
      oprot.writeFieldBegin('transactionDateFrom', TType.I64, 3)
23849 
      oprot.writeI64(self.transactionDateFrom)
23850 
      oprot.writeFieldEnd()
23851 
    if self.transactionDateTo is not None:
23852 
      oprot.writeFieldBegin('transactionDateTo', TType.I64, 4)
23853 
      oprot.writeI64(self.transactionDateTo)
23854 
      oprot.writeFieldEnd()
23855 
    if self.amount is not None:
23856 
      oprot.writeFieldBegin('amount', TType.DOUBLE, 5)
23857 
      oprot.writeDouble(self.amount)
23858 
      oprot.writeFieldEnd()
23859 
    oprot.writeFieldStop()
23860 
    oprot.writeStructEnd()
23861 
 
23862 
  def validate(self):
23863 
    return
23864 
 
23865 
 
23866 
  def __repr__(self):
23867 
    L = ['%s=%r' % (key, value)
23868 
      for key, value in self.__dict__.iteritems()]
23869 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23870 
 
23871 
  def __eq__(self, other):
23872 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23873 
 
23874 
  def __ne__(self, other):
23875 
    return not (self == other)
23876 
 
23877 
class saveEBSSettlementSummary_result:
23878 
  """
23879 
  Attributes:
23880 
   - ex
23881 
  """
23882 
 
23883 
  thrift_spec = (
23884 
    None, # 0
23885 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
23886 
  )
23887 
 
23888 
  def __init__(self, ex=None,):
23889 
    self.ex = ex
23890 
 
23891 
  def read(self, iprot):
23892 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23893 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23894 
      return
23895 
    iprot.readStructBegin()
23896 
    while True:
23897 
      (fname, ftype, fid) = iprot.readFieldBegin()
23898 
      if ftype == TType.STOP:
23899 
        break
23900 
      if fid == 1:
23901 
        if ftype == TType.STRUCT:
23902 
          self.ex = TransactionServiceException()
23903 
          self.ex.read(iprot)
23904 
        else:
23905 
          iprot.skip(ftype)
23906 
      else:
23907 
        iprot.skip(ftype)
23908 
      iprot.readFieldEnd()
23909 
    iprot.readStructEnd()
23910 
 
23911 
  def write(self, oprot):
23912 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23913 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23914 
      return
23915 
    oprot.writeStructBegin('saveEBSSettlementSummary_result')
23916 
    if self.ex is not None:
23917 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
23918 
      self.ex.write(oprot)
23919 
      oprot.writeFieldEnd()
23920 
    oprot.writeFieldStop()
23921 
    oprot.writeStructEnd()
23922 
 
23923 
  def validate(self):
23924 
    return
23925 
 
23926 
 
23927 
  def __repr__(self):
23928 
    L = ['%s=%r' % (key, value)
23929 
      for key, value in self.__dict__.iteritems()]
23930 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23931 
 
23932 
  def __eq__(self, other):
23933 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23934 
 
23935 
  def __ne__(self, other):
23936 
    return not (self == other)
23937 
 
5386 phani.kuma 23938 
class getSettlementForPrepaid_args:
4600 varun.gupt 23939 
  """
23940 
  Attributes:
5189 varun.gupt 23941 
   - referenceId
23942 
   - isRefund
4600 varun.gupt 23943 
  """
23944 
 
23945 
  thrift_spec = (
23946 
    None, # 0
5189 varun.gupt 23947 
    (1, TType.I64, 'referenceId', None, None, ), # 1
5386 phani.kuma 23948 
    (2, TType.BOOL, 'isRefund', None, None, ), # 2
4600 varun.gupt 23949 
  )
23950 
 
5386 phani.kuma 23951 
  def __init__(self, referenceId=None, isRefund=None,):
5189 varun.gupt 23952 
    self.referenceId = referenceId
23953 
    self.isRefund = isRefund
4600 varun.gupt 23954 
 
23955 
  def read(self, iprot):
23956 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23957 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23958 
      return
23959 
    iprot.readStructBegin()
23960 
    while True:
23961 
      (fname, ftype, fid) = iprot.readFieldBegin()
23962 
      if ftype == TType.STOP:
23963 
        break
23964 
      if fid == 1:
23965 
        if ftype == TType.I64:
5189 varun.gupt 23966 
          self.referenceId = iprot.readI64();
4600 varun.gupt 23967 
        else:
23968 
          iprot.skip(ftype)
5189 varun.gupt 23969 
      elif fid == 2:
23970 
        if ftype == TType.BOOL:
23971 
          self.isRefund = iprot.readBool();
23972 
        else:
23973 
          iprot.skip(ftype)
4600 varun.gupt 23974 
      else:
23975 
        iprot.skip(ftype)
23976 
      iprot.readFieldEnd()
23977 
    iprot.readStructEnd()
23978 
 
23979 
  def write(self, oprot):
23980 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23981 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23982 
      return
5386 phani.kuma 23983 
    oprot.writeStructBegin('getSettlementForPrepaid_args')
5189 varun.gupt 23984 
    if self.referenceId is not None:
23985 
      oprot.writeFieldBegin('referenceId', TType.I64, 1)
23986 
      oprot.writeI64(self.referenceId)
4600 varun.gupt 23987 
      oprot.writeFieldEnd()
5386 phani.kuma 23988 
    if self.isRefund is not None:
23989 
      oprot.writeFieldBegin('isRefund', TType.BOOL, 2)
23990 
      oprot.writeBool(self.isRefund)
5382 varun.gupt 23991 
      oprot.writeFieldEnd()
5386 phani.kuma 23992 
    oprot.writeFieldStop()
23993 
    oprot.writeStructEnd()
23994 
 
23995 
  def validate(self):
23996 
    return
23997 
 
23998 
 
23999 
  def __repr__(self):
24000 
    L = ['%s=%r' % (key, value)
24001 
      for key, value in self.__dict__.iteritems()]
24002 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24003 
 
24004 
  def __eq__(self, other):
24005 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24006 
 
24007 
  def __ne__(self, other):
24008 
    return not (self == other)
24009 
 
24010 
class getSettlementForPrepaid_result:
24011 
  """
24012 
  Attributes:
24013 
   - success
24014 
   - ex
24015 
  """
24016 
 
24017 
  thrift_spec = (
24018 
    (0, TType.STRUCT, 'success', (PaymentSettlement, PaymentSettlement.thrift_spec), None, ), # 0
24019 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
24020 
  )
24021 
 
24022 
  def __init__(self, success=None, ex=None,):
24023 
    self.success = success
24024 
    self.ex = ex
24025 
 
24026 
  def read(self, iprot):
24027 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24028 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24029 
      return
24030 
    iprot.readStructBegin()
24031 
    while True:
24032 
      (fname, ftype, fid) = iprot.readFieldBegin()
24033 
      if ftype == TType.STOP:
24034 
        break
24035 
      if fid == 0:
24036 
        if ftype == TType.STRUCT:
24037 
          self.success = PaymentSettlement()
24038 
          self.success.read(iprot)
24039 
        else:
24040 
          iprot.skip(ftype)
24041 
      elif fid == 1:
24042 
        if ftype == TType.STRUCT:
24043 
          self.ex = TransactionServiceException()
24044 
          self.ex.read(iprot)
24045 
        else:
24046 
          iprot.skip(ftype)
24047 
      else:
24048 
        iprot.skip(ftype)
24049 
      iprot.readFieldEnd()
24050 
    iprot.readStructEnd()
24051 
 
24052 
  def write(self, oprot):
24053 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24054 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24055 
      return
24056 
    oprot.writeStructBegin('getSettlementForPrepaid_result')
24057 
    if self.success is not None:
24058 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
24059 
      self.success.write(oprot)
24060 
      oprot.writeFieldEnd()
24061 
    if self.ex is not None:
24062 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
24063 
      self.ex.write(oprot)
24064 
      oprot.writeFieldEnd()
24065 
    oprot.writeFieldStop()
24066 
    oprot.writeStructEnd()
24067 
 
24068 
  def validate(self):
24069 
    return
24070 
 
24071 
 
24072 
  def __repr__(self):
24073 
    L = ['%s=%r' % (key, value)
24074 
      for key, value in self.__dict__.iteritems()]
24075 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24076 
 
24077 
  def __eq__(self, other):
24078 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24079 
 
24080 
  def __ne__(self, other):
24081 
    return not (self == other)
24082 
 
24083 
class getSettlementForCod_args:
24084 
  """
24085 
  Attributes:
24086 
   - orderId
24087 
   - isRefund
24088 
  """
24089 
 
24090 
  thrift_spec = (
24091 
    None, # 0
24092 
    (1, TType.I64, 'orderId', None, None, ), # 1
24093 
    (2, TType.BOOL, 'isRefund', None, None, ), # 2
24094 
  )
24095 
 
24096 
  def __init__(self, orderId=None, isRefund=None,):
24097 
    self.orderId = orderId
24098 
    self.isRefund = isRefund
24099 
 
24100 
  def read(self, iprot):
24101 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24102 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24103 
      return
24104 
    iprot.readStructBegin()
24105 
    while True:
24106 
      (fname, ftype, fid) = iprot.readFieldBegin()
24107 
      if ftype == TType.STOP:
24108 
        break
24109 
      if fid == 1:
24110 
        if ftype == TType.I64:
24111 
          self.orderId = iprot.readI64();
24112 
        else:
24113 
          iprot.skip(ftype)
24114 
      elif fid == 2:
24115 
        if ftype == TType.BOOL:
24116 
          self.isRefund = iprot.readBool();
24117 
        else:
24118 
          iprot.skip(ftype)
24119 
      else:
24120 
        iprot.skip(ftype)
24121 
      iprot.readFieldEnd()
24122 
    iprot.readStructEnd()
24123 
 
24124 
  def write(self, oprot):
24125 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24126 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24127 
      return
24128 
    oprot.writeStructBegin('getSettlementForCod_args')
24129 
    if self.orderId is not None:
24130 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
24131 
      oprot.writeI64(self.orderId)
24132 
      oprot.writeFieldEnd()
5189 varun.gupt 24133 
    if self.isRefund is not None:
5386 phani.kuma 24134 
      oprot.writeFieldBegin('isRefund', TType.BOOL, 2)
5189 varun.gupt 24135 
      oprot.writeBool(self.isRefund)
24136 
      oprot.writeFieldEnd()
4600 varun.gupt 24137 
    oprot.writeFieldStop()
24138 
    oprot.writeStructEnd()
24139 
 
24140 
  def validate(self):
24141 
    return
24142 
 
24143 
 
24144 
  def __repr__(self):
24145 
    L = ['%s=%r' % (key, value)
24146 
      for key, value in self.__dict__.iteritems()]
24147 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24148 
 
24149 
  def __eq__(self, other):
24150 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24151 
 
24152 
  def __ne__(self, other):
24153 
    return not (self == other)
24154 
 
5386 phani.kuma 24155 
class getSettlementForCod_result:
4600 varun.gupt 24156 
  """
24157 
  Attributes:
24158 
   - success
24159 
   - ex
24160 
  """
24161 
 
24162 
  thrift_spec = (
24163 
    (0, TType.STRUCT, 'success', (PaymentSettlement, PaymentSettlement.thrift_spec), None, ), # 0
24164 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
24165 
  )
24166 
 
24167 
  def __init__(self, success=None, ex=None,):
24168 
    self.success = success
24169 
    self.ex = ex
24170 
 
24171 
  def read(self, iprot):
24172 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24173 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24174 
      return
24175 
    iprot.readStructBegin()
24176 
    while True:
24177 
      (fname, ftype, fid) = iprot.readFieldBegin()
24178 
      if ftype == TType.STOP:
24179 
        break
24180 
      if fid == 0:
24181 
        if ftype == TType.STRUCT:
24182 
          self.success = PaymentSettlement()
24183 
          self.success.read(iprot)
24184 
        else:
24185 
          iprot.skip(ftype)
24186 
      elif fid == 1:
24187 
        if ftype == TType.STRUCT:
24188 
          self.ex = TransactionServiceException()
24189 
          self.ex.read(iprot)
24190 
        else:
24191 
          iprot.skip(ftype)
24192 
      else:
24193 
        iprot.skip(ftype)
24194 
      iprot.readFieldEnd()
24195 
    iprot.readStructEnd()
24196 
 
24197 
  def write(self, oprot):
24198 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24199 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24200 
      return
5386 phani.kuma 24201 
    oprot.writeStructBegin('getSettlementForCod_result')
4600 varun.gupt 24202 
    if self.success is not None:
24203 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
24204 
      self.success.write(oprot)
24205 
      oprot.writeFieldEnd()
24206 
    if self.ex is not None:
24207 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
24208 
      self.ex.write(oprot)
24209 
      oprot.writeFieldEnd()
24210 
    oprot.writeFieldStop()
24211 
    oprot.writeStructEnd()
24212 
 
24213 
  def validate(self):
24214 
    return
24215 
 
24216 
 
24217 
  def __repr__(self):
24218 
    L = ['%s=%r' % (key, value)
24219 
      for key, value in self.__dict__.iteritems()]
24220 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24221 
 
24222 
  def __eq__(self, other):
24223 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24224 
 
24225 
  def __ne__(self, other):
24226 
    return not (self == other)
24227 
 
24228 
class getEBSSettlementSummaries_args:
24229 
 
24230 
  thrift_spec = (
24231 
  )
24232 
 
24233 
  def read(self, iprot):
24234 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24235 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24236 
      return
24237 
    iprot.readStructBegin()
24238 
    while True:
24239 
      (fname, ftype, fid) = iprot.readFieldBegin()
24240 
      if ftype == TType.STOP:
24241 
        break
24242 
      else:
24243 
        iprot.skip(ftype)
24244 
      iprot.readFieldEnd()
24245 
    iprot.readStructEnd()
24246 
 
24247 
  def write(self, oprot):
24248 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24249 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24250 
      return
24251 
    oprot.writeStructBegin('getEBSSettlementSummaries_args')
24252 
    oprot.writeFieldStop()
24253 
    oprot.writeStructEnd()
24254 
 
24255 
  def validate(self):
24256 
    return
24257 
 
24258 
 
24259 
  def __repr__(self):
24260 
    L = ['%s=%r' % (key, value)
24261 
      for key, value in self.__dict__.iteritems()]
24262 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24263 
 
24264 
  def __eq__(self, other):
24265 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24266 
 
24267 
  def __ne__(self, other):
24268 
    return not (self == other)
24269 
 
24270 
class getEBSSettlementSummaries_result:
24271 
  """
24272 
  Attributes:
24273 
   - success
24274 
   - ex
24275 
  """
24276 
 
24277 
  thrift_spec = (
24278 
    (0, TType.MAP, 'success', (TType.I64,None,TType.STRING,None), None, ), # 0
24279 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
24280 
  )
24281 
 
24282 
  def __init__(self, success=None, ex=None,):
24283 
    self.success = success
24284 
    self.ex = ex
24285 
 
24286 
  def read(self, iprot):
24287 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24288 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24289 
      return
24290 
    iprot.readStructBegin()
24291 
    while True:
24292 
      (fname, ftype, fid) = iprot.readFieldBegin()
24293 
      if ftype == TType.STOP:
24294 
        break
24295 
      if fid == 0:
24296 
        if ftype == TType.MAP:
24297 
          self.success = {}
6188 rajveer 24298 
          (_ktype555, _vtype556, _size554 ) = iprot.readMapBegin()
24299 
          for _i558 in xrange(_size554):
24300 
            _key559 = iprot.readI64();
24301 
            _val560 = iprot.readString();
24302 
            self.success[_key559] = _val560
4600 varun.gupt 24303 
          iprot.readMapEnd()
24304 
        else:
24305 
          iprot.skip(ftype)
24306 
      elif fid == 1:
24307 
        if ftype == TType.STRUCT:
24308 
          self.ex = TransactionServiceException()
24309 
          self.ex.read(iprot)
24310 
        else:
24311 
          iprot.skip(ftype)
24312 
      else:
24313 
        iprot.skip(ftype)
24314 
      iprot.readFieldEnd()
24315 
    iprot.readStructEnd()
24316 
 
24317 
  def write(self, oprot):
24318 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24319 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24320 
      return
24321 
    oprot.writeStructBegin('getEBSSettlementSummaries_result')
24322 
    if self.success is not None:
24323 
      oprot.writeFieldBegin('success', TType.MAP, 0)
24324 
      oprot.writeMapBegin(TType.I64, TType.STRING, len(self.success))
6188 rajveer 24325 
      for kiter561,viter562 in self.success.items():
24326 
        oprot.writeI64(kiter561)
24327 
        oprot.writeString(viter562)
4600 varun.gupt 24328 
      oprot.writeMapEnd()
24329 
      oprot.writeFieldEnd()
24330 
    if self.ex is not None:
24331 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
24332 
      self.ex.write(oprot)
24333 
      oprot.writeFieldEnd()
24334 
    oprot.writeFieldStop()
24335 
    oprot.writeStructEnd()
24336 
 
24337 
  def validate(self):
24338 
    return
24339 
 
24340 
 
24341 
  def __repr__(self):
24342 
    L = ['%s=%r' % (key, value)
24343 
      for key, value in self.__dict__.iteritems()]
24344 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24345 
 
24346 
  def __eq__(self, other):
24347 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24348 
 
24349 
  def __ne__(self, other):
24350 
    return not (self == other)
24351 
 
24352 
class markEBSSettlementUploaded_args:
24353 
  """
24354 
  Attributes:
24355 
   - settlementId
24356 
  """
24357 
 
24358 
  thrift_spec = (
24359 
    None, # 0
24360 
    (1, TType.I64, 'settlementId', None, None, ), # 1
24361 
  )
24362 
 
24363 
  def __init__(self, settlementId=None,):
24364 
    self.settlementId = settlementId
24365 
 
24366 
  def read(self, iprot):
24367 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24368 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24369 
      return
24370 
    iprot.readStructBegin()
24371 
    while True:
24372 
      (fname, ftype, fid) = iprot.readFieldBegin()
24373 
      if ftype == TType.STOP:
24374 
        break
24375 
      if fid == 1:
24376 
        if ftype == TType.I64:
24377 
          self.settlementId = iprot.readI64();
24378 
        else:
24379 
          iprot.skip(ftype)
24380 
      else:
24381 
        iprot.skip(ftype)
24382 
      iprot.readFieldEnd()
24383 
    iprot.readStructEnd()
24384 
 
24385 
  def write(self, oprot):
24386 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24387 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24388 
      return
24389 
    oprot.writeStructBegin('markEBSSettlementUploaded_args')
24390 
    if self.settlementId is not None:
24391 
      oprot.writeFieldBegin('settlementId', TType.I64, 1)
24392 
      oprot.writeI64(self.settlementId)
24393 
      oprot.writeFieldEnd()
24394 
    oprot.writeFieldStop()
24395 
    oprot.writeStructEnd()
24396 
 
24397 
  def validate(self):
24398 
    return
24399 
 
24400 
 
24401 
  def __repr__(self):
24402 
    L = ['%s=%r' % (key, value)
24403 
      for key, value in self.__dict__.iteritems()]
24404 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24405 
 
24406 
  def __eq__(self, other):
24407 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24408 
 
24409 
  def __ne__(self, other):
24410 
    return not (self == other)
24411 
 
24412 
class markEBSSettlementUploaded_result:
24413 
  """
24414 
  Attributes:
24415 
   - ex
24416 
  """
24417 
 
24418 
  thrift_spec = (
24419 
    None, # 0
24420 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
24421 
  )
24422 
 
24423 
  def __init__(self, ex=None,):
24424 
    self.ex = ex
24425 
 
24426 
  def read(self, iprot):
24427 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24428 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24429 
      return
24430 
    iprot.readStructBegin()
24431 
    while True:
24432 
      (fname, ftype, fid) = iprot.readFieldBegin()
24433 
      if ftype == TType.STOP:
24434 
        break
24435 
      if fid == 1:
24436 
        if ftype == TType.STRUCT:
24437 
          self.ex = TransactionServiceException()
24438 
          self.ex.read(iprot)
24439 
        else:
24440 
          iprot.skip(ftype)
24441 
      else:
24442 
        iprot.skip(ftype)
24443 
      iprot.readFieldEnd()
24444 
    iprot.readStructEnd()
24445 
 
24446 
  def write(self, oprot):
24447 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24448 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24449 
      return
24450 
    oprot.writeStructBegin('markEBSSettlementUploaded_result')
24451 
    if self.ex is not None:
24452 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
24453 
      self.ex.write(oprot)
24454 
      oprot.writeFieldEnd()
24455 
    oprot.writeFieldStop()
24456 
    oprot.writeStructEnd()
24457 
 
24458 
  def validate(self):
24459 
    return
24460 
 
24461 
 
24462 
  def __repr__(self):
24463 
    L = ['%s=%r' % (key, value)
24464 
      for key, value in self.__dict__.iteritems()]
24465 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24466 
 
24467 
  def __eq__(self, other):
24468 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24469 
 
24470 
  def __ne__(self, other):
24471 
    return not (self == other)
24472 
 
24473 
class getEBSSettlementDate_args:
24474 
  """
24475 
  Attributes:
24476 
   - settlementId
24477 
  """
24478 
 
24479 
  thrift_spec = (
24480 
    None, # 0
24481 
    (1, TType.I64, 'settlementId', None, None, ), # 1
24482 
  )
24483 
 
24484 
  def __init__(self, settlementId=None,):
24485 
    self.settlementId = settlementId
24486 
 
24487 
  def read(self, iprot):
24488 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24489 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24490 
      return
24491 
    iprot.readStructBegin()
24492 
    while True:
24493 
      (fname, ftype, fid) = iprot.readFieldBegin()
24494 
      if ftype == TType.STOP:
24495 
        break
24496 
      if fid == 1:
24497 
        if ftype == TType.I64:
24498 
          self.settlementId = iprot.readI64();
24499 
        else:
24500 
          iprot.skip(ftype)
24501 
      else:
24502 
        iprot.skip(ftype)
24503 
      iprot.readFieldEnd()
24504 
    iprot.readStructEnd()
24505 
 
24506 
  def write(self, oprot):
24507 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24508 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24509 
      return
24510 
    oprot.writeStructBegin('getEBSSettlementDate_args')
24511 
    if self.settlementId is not None:
24512 
      oprot.writeFieldBegin('settlementId', TType.I64, 1)
24513 
      oprot.writeI64(self.settlementId)
24514 
      oprot.writeFieldEnd()
24515 
    oprot.writeFieldStop()
24516 
    oprot.writeStructEnd()
24517 
 
24518 
  def validate(self):
24519 
    return
24520 
 
24521 
 
24522 
  def __repr__(self):
24523 
    L = ['%s=%r' % (key, value)
24524 
      for key, value in self.__dict__.iteritems()]
24525 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24526 
 
24527 
  def __eq__(self, other):
24528 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24529 
 
24530 
  def __ne__(self, other):
24531 
    return not (self == other)
24532 
 
24533 
class getEBSSettlementDate_result:
24534 
  """
24535 
  Attributes:
24536 
   - success
24537 
   - ex
24538 
  """
24539 
 
24540 
  thrift_spec = (
24541 
    (0, TType.I64, 'success', None, None, ), # 0
24542 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
24543 
  )
24544 
 
24545 
  def __init__(self, success=None, ex=None,):
24546 
    self.success = success
24547 
    self.ex = ex
24548 
 
24549 
  def read(self, iprot):
24550 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24551 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24552 
      return
24553 
    iprot.readStructBegin()
24554 
    while True:
24555 
      (fname, ftype, fid) = iprot.readFieldBegin()
24556 
      if ftype == TType.STOP:
24557 
        break
24558 
      if fid == 0:
24559 
        if ftype == TType.I64:
24560 
          self.success = iprot.readI64();
24561 
        else:
24562 
          iprot.skip(ftype)
24563 
      elif fid == 1:
24564 
        if ftype == TType.STRUCT:
24565 
          self.ex = TransactionServiceException()
24566 
          self.ex.read(iprot)
24567 
        else:
24568 
          iprot.skip(ftype)
24569 
      else:
24570 
        iprot.skip(ftype)
24571 
      iprot.readFieldEnd()
24572 
    iprot.readStructEnd()
24573 
 
24574 
  def write(self, oprot):
24575 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24576 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24577 
      return
24578 
    oprot.writeStructBegin('getEBSSettlementDate_result')
24579 
    if self.success is not None:
24580 
      oprot.writeFieldBegin('success', TType.I64, 0)
24581 
      oprot.writeI64(self.success)
24582 
      oprot.writeFieldEnd()
24583 
    if self.ex is not None:
24584 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
24585 
      self.ex.write(oprot)
24586 
      oprot.writeFieldEnd()
24587 
    oprot.writeFieldStop()
24588 
    oprot.writeStructEnd()
24589 
 
24590 
  def validate(self):
24591 
    return
24592 
 
24593 
 
24594 
  def __repr__(self):
24595 
    L = ['%s=%r' % (key, value)
24596 
      for key, value in self.__dict__.iteritems()]
24597 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24598 
 
24599 
  def __eq__(self, other):
24600 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24601 
 
24602 
  def __ne__(self, other):
24603 
    return not (self == other)
4715 varun.gupt 24604 
 
24605 
class getSettlementsByDate_args:
24606 
  """
24607 
  Attributes:
24608 
   - settlementDateFrom
24609 
   - settlementDateTo
24610 
   - isRefund
24611 
  """
24612 
 
24613 
  thrift_spec = (
24614 
    None, # 0
24615 
    (1, TType.I64, 'settlementDateFrom', None, None, ), # 1
24616 
    (2, TType.I64, 'settlementDateTo', None, None, ), # 2
24617 
    (3, TType.BOOL, 'isRefund', None, None, ), # 3
24618 
  )
24619 
 
24620 
  def __init__(self, settlementDateFrom=None, settlementDateTo=None, isRefund=None,):
24621 
    self.settlementDateFrom = settlementDateFrom
24622 
    self.settlementDateTo = settlementDateTo
24623 
    self.isRefund = isRefund
24624 
 
24625 
  def read(self, iprot):
24626 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24627 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24628 
      return
24629 
    iprot.readStructBegin()
24630 
    while True:
24631 
      (fname, ftype, fid) = iprot.readFieldBegin()
24632 
      if ftype == TType.STOP:
24633 
        break
24634 
      if fid == 1:
24635 
        if ftype == TType.I64:
24636 
          self.settlementDateFrom = iprot.readI64();
24637 
        else:
24638 
          iprot.skip(ftype)
24639 
      elif fid == 2:
24640 
        if ftype == TType.I64:
24641 
          self.settlementDateTo = iprot.readI64();
24642 
        else:
24643 
          iprot.skip(ftype)
24644 
      elif fid == 3:
24645 
        if ftype == TType.BOOL:
24646 
          self.isRefund = iprot.readBool();
24647 
        else:
24648 
          iprot.skip(ftype)
24649 
      else:
24650 
        iprot.skip(ftype)
24651 
      iprot.readFieldEnd()
24652 
    iprot.readStructEnd()
24653 
 
24654 
  def write(self, oprot):
24655 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24656 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24657 
      return
24658 
    oprot.writeStructBegin('getSettlementsByDate_args')
24659 
    if self.settlementDateFrom is not None:
24660 
      oprot.writeFieldBegin('settlementDateFrom', TType.I64, 1)
24661 
      oprot.writeI64(self.settlementDateFrom)
24662 
      oprot.writeFieldEnd()
24663 
    if self.settlementDateTo is not None:
24664 
      oprot.writeFieldBegin('settlementDateTo', TType.I64, 2)
24665 
      oprot.writeI64(self.settlementDateTo)
24666 
      oprot.writeFieldEnd()
24667 
    if self.isRefund is not None:
24668 
      oprot.writeFieldBegin('isRefund', TType.BOOL, 3)
24669 
      oprot.writeBool(self.isRefund)
24670 
      oprot.writeFieldEnd()
24671 
    oprot.writeFieldStop()
24672 
    oprot.writeStructEnd()
24673 
 
24674 
  def validate(self):
24675 
    return
24676 
 
24677 
 
24678 
  def __repr__(self):
24679 
    L = ['%s=%r' % (key, value)
24680 
      for key, value in self.__dict__.iteritems()]
24681 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24682 
 
24683 
  def __eq__(self, other):
24684 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24685 
 
24686 
  def __ne__(self, other):
24687 
    return not (self == other)
24688 
 
24689 
class getSettlementsByDate_result:
24690 
  """
24691 
  Attributes:
24692 
   - success
24693 
   - ex
24694 
  """
24695 
 
24696 
  thrift_spec = (
24697 
    (0, TType.LIST, 'success', (TType.STRUCT,(PaymentSettlement, PaymentSettlement.thrift_spec)), None, ), # 0
24698 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
24699 
  )
24700 
 
24701 
  def __init__(self, success=None, ex=None,):
24702 
    self.success = success
24703 
    self.ex = ex
24704 
 
24705 
  def read(self, iprot):
24706 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24707 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24708 
      return
24709 
    iprot.readStructBegin()
24710 
    while True:
24711 
      (fname, ftype, fid) = iprot.readFieldBegin()
24712 
      if ftype == TType.STOP:
24713 
        break
24714 
      if fid == 0:
24715 
        if ftype == TType.LIST:
24716 
          self.success = []
6188 rajveer 24717 
          (_etype566, _size563) = iprot.readListBegin()
24718 
          for _i567 in xrange(_size563):
24719 
            _elem568 = PaymentSettlement()
24720 
            _elem568.read(iprot)
24721 
            self.success.append(_elem568)
4715 varun.gupt 24722 
          iprot.readListEnd()
24723 
        else:
24724 
          iprot.skip(ftype)
24725 
      elif fid == 1:
24726 
        if ftype == TType.STRUCT:
24727 
          self.ex = TransactionServiceException()
24728 
          self.ex.read(iprot)
24729 
        else:
24730 
          iprot.skip(ftype)
24731 
      else:
24732 
        iprot.skip(ftype)
24733 
      iprot.readFieldEnd()
24734 
    iprot.readStructEnd()
24735 
 
24736 
  def write(self, oprot):
24737 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24738 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24739 
      return
24740 
    oprot.writeStructBegin('getSettlementsByDate_result')
24741 
    if self.success is not None:
24742 
      oprot.writeFieldBegin('success', TType.LIST, 0)
24743 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 24744 
      for iter569 in self.success:
24745 
        iter569.write(oprot)
4715 varun.gupt 24746 
      oprot.writeListEnd()
24747 
      oprot.writeFieldEnd()
24748 
    if self.ex is not None:
24749 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
24750 
      self.ex.write(oprot)
24751 
      oprot.writeFieldEnd()
24752 
    oprot.writeFieldStop()
24753 
    oprot.writeStructEnd()
24754 
 
24755 
  def validate(self):
24756 
    return
24757 
 
24758 
 
24759 
  def __repr__(self):
24760 
    L = ['%s=%r' % (key, value)
24761 
      for key, value in self.__dict__.iteritems()]
24762 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24763 
 
24764 
  def __eq__(self, other):
24765 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24766 
 
24767 
  def __ne__(self, other):
24768 
    return not (self == other)
24769 
 
24770 
class getReshippedOrderIds_args:
24771 
  """
24772 
  Attributes:
24773 
   - orderIds
24774 
  """
24775 
 
24776 
  thrift_spec = (
24777 
    None, # 0
24778 
    (1, TType.LIST, 'orderIds', (TType.I64,None), None, ), # 1
24779 
  )
24780 
 
24781 
  def __init__(self, orderIds=None,):
24782 
    self.orderIds = orderIds
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.LIST:
24795 
          self.orderIds = []
6188 rajveer 24796 
          (_etype573, _size570) = iprot.readListBegin()
24797 
          for _i574 in xrange(_size570):
24798 
            _elem575 = iprot.readI64();
24799 
            self.orderIds.append(_elem575)
4715 varun.gupt 24800 
          iprot.readListEnd()
24801 
        else:
24802 
          iprot.skip(ftype)
24803 
      else:
24804 
        iprot.skip(ftype)
24805 
      iprot.readFieldEnd()
24806 
    iprot.readStructEnd()
24807 
 
24808 
  def write(self, oprot):
24809 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24810 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24811 
      return
24812 
    oprot.writeStructBegin('getReshippedOrderIds_args')
24813 
    if self.orderIds is not None:
24814 
      oprot.writeFieldBegin('orderIds', TType.LIST, 1)
24815 
      oprot.writeListBegin(TType.I64, len(self.orderIds))
6188 rajveer 24816 
      for iter576 in self.orderIds:
24817 
        oprot.writeI64(iter576)
4715 varun.gupt 24818 
      oprot.writeListEnd()
24819 
      oprot.writeFieldEnd()
24820 
    oprot.writeFieldStop()
24821 
    oprot.writeStructEnd()
24822 
 
24823 
  def validate(self):
24824 
    return
24825 
 
24826 
 
24827 
  def __repr__(self):
24828 
    L = ['%s=%r' % (key, value)
24829 
      for key, value in self.__dict__.iteritems()]
24830 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24831 
 
24832 
  def __eq__(self, other):
24833 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24834 
 
24835 
  def __ne__(self, other):
24836 
    return not (self == other)
24837 
 
24838 
class getReshippedOrderIds_result:
24839 
  """
24840 
  Attributes:
24841 
   - success
24842 
   - ex
24843 
  """
24844 
 
24845 
  thrift_spec = (
24846 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
24847 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
24848 
  )
24849 
 
24850 
  def __init__(self, success=None, ex=None,):
24851 
    self.success = success
24852 
    self.ex = ex
24853 
 
24854 
  def read(self, iprot):
24855 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24856 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24857 
      return
24858 
    iprot.readStructBegin()
24859 
    while True:
24860 
      (fname, ftype, fid) = iprot.readFieldBegin()
24861 
      if ftype == TType.STOP:
24862 
        break
24863 
      if fid == 0:
24864 
        if ftype == TType.LIST:
24865 
          self.success = []
6188 rajveer 24866 
          (_etype580, _size577) = iprot.readListBegin()
24867 
          for _i581 in xrange(_size577):
24868 
            _elem582 = iprot.readI64();
24869 
            self.success.append(_elem582)
4715 varun.gupt 24870 
          iprot.readListEnd()
24871 
        else:
24872 
          iprot.skip(ftype)
24873 
      elif fid == 1:
24874 
        if ftype == TType.STRUCT:
24875 
          self.ex = TransactionServiceException()
24876 
          self.ex.read(iprot)
24877 
        else:
24878 
          iprot.skip(ftype)
24879 
      else:
24880 
        iprot.skip(ftype)
24881 
      iprot.readFieldEnd()
24882 
    iprot.readStructEnd()
24883 
 
24884 
  def write(self, oprot):
24885 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24886 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24887 
      return
24888 
    oprot.writeStructBegin('getReshippedOrderIds_result')
24889 
    if self.success is not None:
24890 
      oprot.writeFieldBegin('success', TType.LIST, 0)
24891 
      oprot.writeListBegin(TType.I64, len(self.success))
6188 rajveer 24892 
      for iter583 in self.success:
24893 
        oprot.writeI64(iter583)
4715 varun.gupt 24894 
      oprot.writeListEnd()
24895 
      oprot.writeFieldEnd()
24896 
    if self.ex is not None:
24897 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
24898 
      self.ex.write(oprot)
24899 
      oprot.writeFieldEnd()
24900 
    oprot.writeFieldStop()
24901 
    oprot.writeStructEnd()
24902 
 
24903 
  def validate(self):
24904 
    return
24905 
 
24906 
 
24907 
  def __repr__(self):
24908 
    L = ['%s=%r' % (key, value)
24909 
      for key, value in self.__dict__.iteritems()]
24910 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24911 
 
24912 
  def __eq__(self, other):
24913 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24914 
 
24915 
  def __ne__(self, other):
24916 
    return not (self == other)
4757 mandeep.dh 24917 
 
5481 phani.kuma 24918 
class getBilledOrders_args:
4875 varun.gupt 24919 
  """
24920 
  Attributes:
24921 
   - vendorId
5481 phani.kuma 24922 
   - onlyVendorNotPaid
24923 
   - billingDateFrom
24924 
   - billingDateTo
4875 varun.gupt 24925 
  """
24926 
 
24927 
  thrift_spec = (
24928 
    None, # 0
24929 
    (1, TType.I64, 'vendorId', None, None, ), # 1
5481 phani.kuma 24930 
    (2, TType.BOOL, 'onlyVendorNotPaid', None, None, ), # 2
24931 
    (3, TType.I64, 'billingDateFrom', None, None, ), # 3
24932 
    (4, TType.I64, 'billingDateTo', None, None, ), # 4
4875 varun.gupt 24933 
  )
24934 
 
5481 phani.kuma 24935 
  def __init__(self, vendorId=None, onlyVendorNotPaid=None, billingDateFrom=None, billingDateTo=None,):
4875 varun.gupt 24936 
    self.vendorId = vendorId
5481 phani.kuma 24937 
    self.onlyVendorNotPaid = onlyVendorNotPaid
24938 
    self.billingDateFrom = billingDateFrom
24939 
    self.billingDateTo = billingDateTo
4875 varun.gupt 24940 
 
24941 
  def read(self, iprot):
24942 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24943 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24944 
      return
24945 
    iprot.readStructBegin()
24946 
    while True:
24947 
      (fname, ftype, fid) = iprot.readFieldBegin()
24948 
      if ftype == TType.STOP:
24949 
        break
24950 
      if fid == 1:
24951 
        if ftype == TType.I64:
24952 
          self.vendorId = iprot.readI64();
24953 
        else:
24954 
          iprot.skip(ftype)
5481 phani.kuma 24955 
      elif fid == 2:
24956 
        if ftype == TType.BOOL:
24957 
          self.onlyVendorNotPaid = iprot.readBool();
24958 
        else:
24959 
          iprot.skip(ftype)
24960 
      elif fid == 3:
24961 
        if ftype == TType.I64:
24962 
          self.billingDateFrom = iprot.readI64();
24963 
        else:
24964 
          iprot.skip(ftype)
24965 
      elif fid == 4:
24966 
        if ftype == TType.I64:
24967 
          self.billingDateTo = iprot.readI64();
24968 
        else:
24969 
          iprot.skip(ftype)
4875 varun.gupt 24970 
      else:
24971 
        iprot.skip(ftype)
24972 
      iprot.readFieldEnd()
24973 
    iprot.readStructEnd()
24974 
 
24975 
  def write(self, oprot):
24976 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24977 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24978 
      return
5481 phani.kuma 24979 
    oprot.writeStructBegin('getBilledOrders_args')
4875 varun.gupt 24980 
    if self.vendorId is not None:
24981 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
24982 
      oprot.writeI64(self.vendorId)
24983 
      oprot.writeFieldEnd()
5481 phani.kuma 24984 
    if self.onlyVendorNotPaid is not None:
24985 
      oprot.writeFieldBegin('onlyVendorNotPaid', TType.BOOL, 2)
24986 
      oprot.writeBool(self.onlyVendorNotPaid)
24987 
      oprot.writeFieldEnd()
24988 
    if self.billingDateFrom is not None:
24989 
      oprot.writeFieldBegin('billingDateFrom', TType.I64, 3)
24990 
      oprot.writeI64(self.billingDateFrom)
24991 
      oprot.writeFieldEnd()
24992 
    if self.billingDateTo is not None:
24993 
      oprot.writeFieldBegin('billingDateTo', TType.I64, 4)
24994 
      oprot.writeI64(self.billingDateTo)
24995 
      oprot.writeFieldEnd()
4875 varun.gupt 24996 
    oprot.writeFieldStop()
24997 
    oprot.writeStructEnd()
24998 
 
24999 
  def validate(self):
25000 
    return
25001 
 
25002 
 
25003 
  def __repr__(self):
25004 
    L = ['%s=%r' % (key, value)
25005 
      for key, value in self.__dict__.iteritems()]
25006 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25007 
 
25008 
  def __eq__(self, other):
25009 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25010 
 
25011 
  def __ne__(self, other):
25012 
    return not (self == other)
25013 
 
5481 phani.kuma 25014 
class getBilledOrders_result:
4875 varun.gupt 25015 
  """
25016 
  Attributes:
25017 
   - success
25018 
   - ex
25019 
  """
25020 
 
25021 
  thrift_spec = (
25022 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
25023 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
25024 
  )
25025 
 
25026 
  def __init__(self, success=None, ex=None,):
25027 
    self.success = success
25028 
    self.ex = ex
25029 
 
25030 
  def read(self, iprot):
25031 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25032 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25033 
      return
25034 
    iprot.readStructBegin()
25035 
    while True:
25036 
      (fname, ftype, fid) = iprot.readFieldBegin()
25037 
      if ftype == TType.STOP:
25038 
        break
25039 
      if fid == 0:
25040 
        if ftype == TType.LIST:
25041 
          self.success = []
6188 rajveer 25042 
          (_etype587, _size584) = iprot.readListBegin()
25043 
          for _i588 in xrange(_size584):
25044 
            _elem589 = Order()
25045 
            _elem589.read(iprot)
25046 
            self.success.append(_elem589)
4875 varun.gupt 25047 
          iprot.readListEnd()
25048 
        else:
25049 
          iprot.skip(ftype)
25050 
      elif fid == 1:
25051 
        if ftype == TType.STRUCT:
25052 
          self.ex = TransactionServiceException()
25053 
          self.ex.read(iprot)
25054 
        else:
25055 
          iprot.skip(ftype)
25056 
      else:
25057 
        iprot.skip(ftype)
25058 
      iprot.readFieldEnd()
25059 
    iprot.readStructEnd()
25060 
 
25061 
  def write(self, oprot):
25062 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25063 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25064 
      return
5481 phani.kuma 25065 
    oprot.writeStructBegin('getBilledOrders_result')
4875 varun.gupt 25066 
    if self.success is not None:
25067 
      oprot.writeFieldBegin('success', TType.LIST, 0)
25068 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 25069 
      for iter590 in self.success:
25070 
        iter590.write(oprot)
4875 varun.gupt 25071 
      oprot.writeListEnd()
25072 
      oprot.writeFieldEnd()
25073 
    if self.ex is not None:
25074 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
25075 
      self.ex.write(oprot)
25076 
      oprot.writeFieldEnd()
25077 
    oprot.writeFieldStop()
25078 
    oprot.writeStructEnd()
25079 
 
25080 
  def validate(self):
25081 
    return
25082 
 
25083 
 
25084 
  def __repr__(self):
25085 
    L = ['%s=%r' % (key, value)
25086 
      for key, value in self.__dict__.iteritems()]
25087 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25088 
 
25089 
  def __eq__(self, other):
25090 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25091 
 
25092 
  def __ne__(self, other):
25093 
    return not (self == other)
5031 varun.gupt 25094 
 
25095 
class getStatusDistributionOfOrders_args:
25096 
  """
25097 
  Attributes:
25098 
   - startDate
25099 
   - endDate
25100 
  """
25101 
 
25102 
  thrift_spec = (
25103 
    None, # 0
25104 
    (1, TType.I64, 'startDate', None, None, ), # 1
25105 
    (2, TType.I64, 'endDate', None, None, ), # 2
25106 
  )
25107 
 
25108 
  def __init__(self, startDate=None, endDate=None,):
25109 
    self.startDate = startDate
25110 
    self.endDate = endDate
25111 
 
25112 
  def read(self, iprot):
25113 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25114 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25115 
      return
25116 
    iprot.readStructBegin()
25117 
    while True:
25118 
      (fname, ftype, fid) = iprot.readFieldBegin()
25119 
      if ftype == TType.STOP:
25120 
        break
25121 
      if fid == 1:
25122 
        if ftype == TType.I64:
25123 
          self.startDate = iprot.readI64();
25124 
        else:
25125 
          iprot.skip(ftype)
25126 
      elif fid == 2:
25127 
        if ftype == TType.I64:
25128 
          self.endDate = iprot.readI64();
25129 
        else:
25130 
          iprot.skip(ftype)
25131 
      else:
25132 
        iprot.skip(ftype)
25133 
      iprot.readFieldEnd()
25134 
    iprot.readStructEnd()
25135 
 
25136 
  def write(self, oprot):
25137 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25138 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25139 
      return
25140 
    oprot.writeStructBegin('getStatusDistributionOfOrders_args')
25141 
    if self.startDate is not None:
25142 
      oprot.writeFieldBegin('startDate', TType.I64, 1)
25143 
      oprot.writeI64(self.startDate)
25144 
      oprot.writeFieldEnd()
25145 
    if self.endDate is not None:
25146 
      oprot.writeFieldBegin('endDate', TType.I64, 2)
25147 
      oprot.writeI64(self.endDate)
25148 
      oprot.writeFieldEnd()
25149 
    oprot.writeFieldStop()
25150 
    oprot.writeStructEnd()
25151 
 
25152 
  def validate(self):
25153 
    return
25154 
 
25155 
 
25156 
  def __repr__(self):
25157 
    L = ['%s=%r' % (key, value)
25158 
      for key, value in self.__dict__.iteritems()]
25159 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25160 
 
25161 
  def __eq__(self, other):
25162 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25163 
 
25164 
  def __ne__(self, other):
25165 
    return not (self == other)
25166 
 
25167 
class getStatusDistributionOfOrders_result:
25168 
  """
25169 
  Attributes:
25170 
   - success
25171 
   - ex
25172 
  """
25173 
 
25174 
  thrift_spec = (
25175 
    (0, TType.MAP, 'success', (TType.I64,None,TType.I64,None), None, ), # 0
25176 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
25177 
  )
25178 
 
25179 
  def __init__(self, success=None, ex=None,):
25180 
    self.success = success
25181 
    self.ex = ex
25182 
 
25183 
  def read(self, iprot):
25184 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25185 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25186 
      return
25187 
    iprot.readStructBegin()
25188 
    while True:
25189 
      (fname, ftype, fid) = iprot.readFieldBegin()
25190 
      if ftype == TType.STOP:
25191 
        break
25192 
      if fid == 0:
25193 
        if ftype == TType.MAP:
25194 
          self.success = {}
6188 rajveer 25195 
          (_ktype592, _vtype593, _size591 ) = iprot.readMapBegin()
25196 
          for _i595 in xrange(_size591):
25197 
            _key596 = iprot.readI64();
25198 
            _val597 = iprot.readI64();
25199 
            self.success[_key596] = _val597
5031 varun.gupt 25200 
          iprot.readMapEnd()
25201 
        else:
25202 
          iprot.skip(ftype)
25203 
      elif fid == 1:
25204 
        if ftype == TType.STRUCT:
25205 
          self.ex = TransactionServiceException()
25206 
          self.ex.read(iprot)
25207 
        else:
25208 
          iprot.skip(ftype)
25209 
      else:
25210 
        iprot.skip(ftype)
25211 
      iprot.readFieldEnd()
25212 
    iprot.readStructEnd()
25213 
 
25214 
  def write(self, oprot):
25215 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25216 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25217 
      return
25218 
    oprot.writeStructBegin('getStatusDistributionOfOrders_result')
25219 
    if self.success is not None:
25220 
      oprot.writeFieldBegin('success', TType.MAP, 0)
25221 
      oprot.writeMapBegin(TType.I64, TType.I64, len(self.success))
6188 rajveer 25222 
      for kiter598,viter599 in self.success.items():
25223 
        oprot.writeI64(kiter598)
25224 
        oprot.writeI64(viter599)
5031 varun.gupt 25225 
      oprot.writeMapEnd()
25226 
      oprot.writeFieldEnd()
25227 
    if self.ex is not None:
25228 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
25229 
      self.ex.write(oprot)
25230 
      oprot.writeFieldEnd()
25231 
    oprot.writeFieldStop()
25232 
    oprot.writeStructEnd()
25233 
 
25234 
  def validate(self):
25235 
    return
25236 
 
25237 
 
25238 
  def __repr__(self):
25239 
    L = ['%s=%r' % (key, value)
25240 
      for key, value in self.__dict__.iteritems()]
25241 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25242 
 
25243 
  def __eq__(self, other):
25244 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25245 
 
25246 
  def __ne__(self, other):
25247 
    return not (self == other)
5067 varun.gupt 25248 
 
25249 
class getOrderIdsForStatus_args:
25250 
  """
25251 
  Attributes:
25252 
   - status
25253 
   - startDatetime
25254 
   - endDatetime
25255 
  """
25256 
 
25257 
  thrift_spec = (
25258 
    None, # 0
25259 
    (1, TType.I64, 'status', None, None, ), # 1
25260 
    (2, TType.I64, 'startDatetime', None, None, ), # 2
25261 
    (3, TType.I64, 'endDatetime', None, None, ), # 3
25262 
  )
25263 
 
25264 
  def __init__(self, status=None, startDatetime=None, endDatetime=None,):
25265 
    self.status = status
25266 
    self.startDatetime = startDatetime
25267 
    self.endDatetime = endDatetime
25268 
 
25269 
  def read(self, iprot):
25270 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25271 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25272 
      return
25273 
    iprot.readStructBegin()
25274 
    while True:
25275 
      (fname, ftype, fid) = iprot.readFieldBegin()
25276 
      if ftype == TType.STOP:
25277 
        break
25278 
      if fid == 1:
25279 
        if ftype == TType.I64:
25280 
          self.status = iprot.readI64();
25281 
        else:
25282 
          iprot.skip(ftype)
25283 
      elif fid == 2:
25284 
        if ftype == TType.I64:
25285 
          self.startDatetime = iprot.readI64();
25286 
        else:
25287 
          iprot.skip(ftype)
25288 
      elif fid == 3:
25289 
        if ftype == TType.I64:
25290 
          self.endDatetime = iprot.readI64();
25291 
        else:
25292 
          iprot.skip(ftype)
25293 
      else:
25294 
        iprot.skip(ftype)
25295 
      iprot.readFieldEnd()
25296 
    iprot.readStructEnd()
25297 
 
25298 
  def write(self, oprot):
25299 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25300 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25301 
      return
25302 
    oprot.writeStructBegin('getOrderIdsForStatus_args')
25303 
    if self.status is not None:
25304 
      oprot.writeFieldBegin('status', TType.I64, 1)
25305 
      oprot.writeI64(self.status)
25306 
      oprot.writeFieldEnd()
25307 
    if self.startDatetime is not None:
25308 
      oprot.writeFieldBegin('startDatetime', TType.I64, 2)
25309 
      oprot.writeI64(self.startDatetime)
25310 
      oprot.writeFieldEnd()
25311 
    if self.endDatetime is not None:
25312 
      oprot.writeFieldBegin('endDatetime', TType.I64, 3)
25313 
      oprot.writeI64(self.endDatetime)
25314 
      oprot.writeFieldEnd()
25315 
    oprot.writeFieldStop()
25316 
    oprot.writeStructEnd()
25317 
 
25318 
  def validate(self):
25319 
    return
25320 
 
25321 
 
25322 
  def __repr__(self):
25323 
    L = ['%s=%r' % (key, value)
25324 
      for key, value in self.__dict__.iteritems()]
25325 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25326 
 
25327 
  def __eq__(self, other):
25328 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25329 
 
25330 
  def __ne__(self, other):
25331 
    return not (self == other)
25332 
 
25333 
class getOrderIdsForStatus_result:
25334 
  """
25335 
  Attributes:
25336 
   - success
25337 
   - ex
25338 
  """
25339 
 
25340 
  thrift_spec = (
25341 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
25342 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
25343 
  )
25344 
 
25345 
  def __init__(self, success=None, ex=None,):
25346 
    self.success = success
25347 
    self.ex = ex
25348 
 
25349 
  def read(self, iprot):
25350 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25351 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25352 
      return
25353 
    iprot.readStructBegin()
25354 
    while True:
25355 
      (fname, ftype, fid) = iprot.readFieldBegin()
25356 
      if ftype == TType.STOP:
25357 
        break
25358 
      if fid == 0:
25359 
        if ftype == TType.LIST:
25360 
          self.success = []
6188 rajveer 25361 
          (_etype603, _size600) = iprot.readListBegin()
25362 
          for _i604 in xrange(_size600):
25363 
            _elem605 = iprot.readI64();
25364 
            self.success.append(_elem605)
5067 varun.gupt 25365 
          iprot.readListEnd()
25366 
        else:
25367 
          iprot.skip(ftype)
25368 
      elif fid == 1:
25369 
        if ftype == TType.STRUCT:
25370 
          self.ex = TransactionServiceException()
25371 
          self.ex.read(iprot)
25372 
        else:
25373 
          iprot.skip(ftype)
25374 
      else:
25375 
        iprot.skip(ftype)
25376 
      iprot.readFieldEnd()
25377 
    iprot.readStructEnd()
25378 
 
25379 
  def write(self, oprot):
25380 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25381 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25382 
      return
25383 
    oprot.writeStructBegin('getOrderIdsForStatus_result')
25384 
    if self.success is not None:
25385 
      oprot.writeFieldBegin('success', TType.LIST, 0)
25386 
      oprot.writeListBegin(TType.I64, len(self.success))
6188 rajveer 25387 
      for iter606 in self.success:
25388 
        oprot.writeI64(iter606)
5067 varun.gupt 25389 
      oprot.writeListEnd()
25390 
      oprot.writeFieldEnd()
25391 
    if self.ex is not None:
25392 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
25393 
      self.ex.write(oprot)
25394 
      oprot.writeFieldEnd()
25395 
    oprot.writeFieldStop()
25396 
    oprot.writeStructEnd()
25397 
 
25398 
  def validate(self):
25399 
    return
25400 
 
25401 
 
25402 
  def __repr__(self):
25403 
    L = ['%s=%r' % (key, value)
25404 
      for key, value in self.__dict__.iteritems()]
25405 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25406 
 
25407 
  def __eq__(self, other):
25408 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25409 
 
25410 
  def __ne__(self, other):
25411 
    return not (self == other)
5099 varun.gupt 25412 
 
5348 anupam.sin 25413 
class updateCODAgent_args:
25414 
  """
25415 
  Attributes:
25416 
   - agent
25417 
   - orderId
25418 
  """
25419 
 
25420 
  thrift_spec = (
25421 
    None, # 0
25422 
    (1, TType.STRING, 'agent', None, None, ), # 1
25423 
    (2, TType.I64, 'orderId', None, None, ), # 2
25424 
  )
25425 
 
25426 
  def __init__(self, agent=None, orderId=None,):
25427 
    self.agent = agent
25428 
    self.orderId = orderId
25429 
 
25430 
  def read(self, iprot):
25431 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25432 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25433 
      return
25434 
    iprot.readStructBegin()
25435 
    while True:
25436 
      (fname, ftype, fid) = iprot.readFieldBegin()
25437 
      if ftype == TType.STOP:
25438 
        break
25439 
      if fid == 1:
25440 
        if ftype == TType.STRING:
25441 
          self.agent = iprot.readString();
25442 
        else:
25443 
          iprot.skip(ftype)
25444 
      elif fid == 2:
25445 
        if ftype == TType.I64:
25446 
          self.orderId = iprot.readI64();
25447 
        else:
25448 
          iprot.skip(ftype)
25449 
      else:
25450 
        iprot.skip(ftype)
25451 
      iprot.readFieldEnd()
25452 
    iprot.readStructEnd()
25453 
 
25454 
  def write(self, oprot):
25455 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25456 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25457 
      return
25458 
    oprot.writeStructBegin('updateCODAgent_args')
25459 
    if self.agent is not None:
25460 
      oprot.writeFieldBegin('agent', TType.STRING, 1)
25461 
      oprot.writeString(self.agent)
25462 
      oprot.writeFieldEnd()
25463 
    if self.orderId is not None:
25464 
      oprot.writeFieldBegin('orderId', TType.I64, 2)
25465 
      oprot.writeI64(self.orderId)
25466 
      oprot.writeFieldEnd()
25467 
    oprot.writeFieldStop()
25468 
    oprot.writeStructEnd()
25469 
 
25470 
  def validate(self):
25471 
    return
25472 
 
25473 
 
25474 
  def __repr__(self):
25475 
    L = ['%s=%r' % (key, value)
25476 
      for key, value in self.__dict__.iteritems()]
25477 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25478 
 
25479 
  def __eq__(self, other):
25480 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25481 
 
25482 
  def __ne__(self, other):
25483 
    return not (self == other)
25484 
 
25485 
class updateCODAgent_result:
25486 
  """
25487 
  Attributes:
25488 
   - ex
25489 
  """
25490 
 
25491 
  thrift_spec = (
25492 
    None, # 0
25493 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
25494 
  )
25495 
 
25496 
  def __init__(self, ex=None,):
25497 
    self.ex = ex
25498 
 
25499 
  def read(self, iprot):
25500 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25501 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25502 
      return
25503 
    iprot.readStructBegin()
25504 
    while True:
25505 
      (fname, ftype, fid) = iprot.readFieldBegin()
25506 
      if ftype == TType.STOP:
25507 
        break
25508 
      if fid == 1:
25509 
        if ftype == TType.STRUCT:
25510 
          self.ex = TransactionServiceException()
25511 
          self.ex.read(iprot)
25512 
        else:
25513 
          iprot.skip(ftype)
25514 
      else:
25515 
        iprot.skip(ftype)
25516 
      iprot.readFieldEnd()
25517 
    iprot.readStructEnd()
25518 
 
25519 
  def write(self, oprot):
25520 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25521 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25522 
      return
25523 
    oprot.writeStructBegin('updateCODAgent_result')
25524 
    if self.ex is not None:
25525 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
25526 
      self.ex.write(oprot)
25527 
      oprot.writeFieldEnd()
25528 
    oprot.writeFieldStop()
25529 
    oprot.writeStructEnd()
25530 
 
25531 
  def validate(self):
25532 
    return
25533 
 
25534 
 
25535 
  def __repr__(self):
25536 
    L = ['%s=%r' % (key, value)
25537 
      for key, value in self.__dict__.iteritems()]
25538 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25539 
 
25540 
  def __eq__(self, other):
25541 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25542 
 
25543 
  def __ne__(self, other):
25544 
    return not (self == other)
25545 
 
5099 varun.gupt 25546 
class updateOrderAsPaidToVendor_args:
25547 
  """
25548 
  Attributes:
25549 
   - orderId
25550 
  """
25551 
 
25552 
  thrift_spec = (
25553 
    None, # 0
25554 
    (1, TType.I64, 'orderId', None, None, ), # 1
25555 
  )
25556 
 
25557 
  def __init__(self, orderId=None,):
25558 
    self.orderId = orderId
25559 
 
25560 
  def read(self, iprot):
25561 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25562 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25563 
      return
25564 
    iprot.readStructBegin()
25565 
    while True:
25566 
      (fname, ftype, fid) = iprot.readFieldBegin()
25567 
      if ftype == TType.STOP:
25568 
        break
25569 
      if fid == 1:
25570 
        if ftype == TType.I64:
25571 
          self.orderId = iprot.readI64();
25572 
        else:
25573 
          iprot.skip(ftype)
25574 
      else:
25575 
        iprot.skip(ftype)
25576 
      iprot.readFieldEnd()
25577 
    iprot.readStructEnd()
25578 
 
25579 
  def write(self, oprot):
25580 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25581 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25582 
      return
25583 
    oprot.writeStructBegin('updateOrderAsPaidToVendor_args')
25584 
    if self.orderId is not None:
25585 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
25586 
      oprot.writeI64(self.orderId)
25587 
      oprot.writeFieldEnd()
25588 
    oprot.writeFieldStop()
25589 
    oprot.writeStructEnd()
25590 
 
25591 
  def validate(self):
25592 
    return
25593 
 
25594 
 
25595 
  def __repr__(self):
25596 
    L = ['%s=%r' % (key, value)
25597 
      for key, value in self.__dict__.iteritems()]
25598 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25599 
 
25600 
  def __eq__(self, other):
25601 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25602 
 
25603 
  def __ne__(self, other):
25604 
    return not (self == other)
25605 
 
25606 
class updateOrderAsPaidToVendor_result:
25607 
  """
25608 
  Attributes:
25609 
   - ex
25610 
  """
25611 
 
25612 
  thrift_spec = (
25613 
    None, # 0
25614 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
25615 
  )
25616 
 
25617 
  def __init__(self, ex=None,):
25618 
    self.ex = ex
25619 
 
25620 
  def read(self, iprot):
25621 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25622 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25623 
      return
25624 
    iprot.readStructBegin()
25625 
    while True:
25626 
      (fname, ftype, fid) = iprot.readFieldBegin()
25627 
      if ftype == TType.STOP:
25628 
        break
25629 
      if fid == 1:
25630 
        if ftype == TType.STRUCT:
25631 
          self.ex = TransactionServiceException()
25632 
          self.ex.read(iprot)
25633 
        else:
25634 
          iprot.skip(ftype)
25635 
      else:
25636 
        iprot.skip(ftype)
25637 
      iprot.readFieldEnd()
25638 
    iprot.readStructEnd()
25639 
 
25640 
  def write(self, oprot):
25641 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25642 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25643 
      return
25644 
    oprot.writeStructBegin('updateOrderAsPaidToVendor_result')
25645 
    if self.ex is not None:
25646 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
25647 
      self.ex.write(oprot)
25648 
      oprot.writeFieldEnd()
25649 
    oprot.writeFieldStop()
25650 
    oprot.writeStructEnd()
25651 
 
25652 
  def validate(self):
25653 
    return
25654 
 
25655 
 
25656 
  def __repr__(self):
25657 
    L = ['%s=%r' % (key, value)
25658 
      for key, value in self.__dict__.iteritems()]
25659 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25660 
 
25661 
  def __eq__(self, other):
25662 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25663 
 
25664 
  def __ne__(self, other):
25665 
    return not (self == other)
5208 varun.gupt 25666 
 
5386 phani.kuma 25667 
class updateOrderOnlyAsPaidToVendor_args:
25668 
  """
25669 
  Attributes:
25670 
   - orderId
25671 
  """
25672 
 
25673 
  thrift_spec = (
25674 
    None, # 0
25675 
    (1, TType.I64, 'orderId', None, None, ), # 1
25676 
  )
25677 
 
25678 
  def __init__(self, orderId=None,):
25679 
    self.orderId = orderId
25680 
 
25681 
  def read(self, iprot):
25682 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25683 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25684 
      return
25685 
    iprot.readStructBegin()
25686 
    while True:
25687 
      (fname, ftype, fid) = iprot.readFieldBegin()
25688 
      if ftype == TType.STOP:
25689 
        break
25690 
      if fid == 1:
25691 
        if ftype == TType.I64:
25692 
          self.orderId = iprot.readI64();
25693 
        else:
25694 
          iprot.skip(ftype)
25695 
      else:
25696 
        iprot.skip(ftype)
25697 
      iprot.readFieldEnd()
25698 
    iprot.readStructEnd()
25699 
 
25700 
  def write(self, oprot):
25701 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25702 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25703 
      return
25704 
    oprot.writeStructBegin('updateOrderOnlyAsPaidToVendor_args')
25705 
    if self.orderId is not None:
25706 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
25707 
      oprot.writeI64(self.orderId)
25708 
      oprot.writeFieldEnd()
25709 
    oprot.writeFieldStop()
25710 
    oprot.writeStructEnd()
25711 
 
25712 
  def validate(self):
25713 
    return
25714 
 
25715 
 
25716 
  def __repr__(self):
25717 
    L = ['%s=%r' % (key, value)
25718 
      for key, value in self.__dict__.iteritems()]
25719 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25720 
 
25721 
  def __eq__(self, other):
25722 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25723 
 
25724 
  def __ne__(self, other):
25725 
    return not (self == other)
25726 
 
25727 
class updateOrderOnlyAsPaidToVendor_result:
25728 
  """
25729 
  Attributes:
25730 
   - ex
25731 
  """
25732 
 
25733 
  thrift_spec = (
25734 
    None, # 0
25735 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
25736 
  )
25737 
 
25738 
  def __init__(self, ex=None,):
25739 
    self.ex = ex
25740 
 
25741 
  def read(self, iprot):
25742 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25743 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25744 
      return
25745 
    iprot.readStructBegin()
25746 
    while True:
25747 
      (fname, ftype, fid) = iprot.readFieldBegin()
25748 
      if ftype == TType.STOP:
25749 
        break
25750 
      if fid == 1:
25751 
        if ftype == TType.STRUCT:
25752 
          self.ex = TransactionServiceException()
25753 
          self.ex.read(iprot)
25754 
        else:
25755 
          iprot.skip(ftype)
25756 
      else:
25757 
        iprot.skip(ftype)
25758 
      iprot.readFieldEnd()
25759 
    iprot.readStructEnd()
25760 
 
25761 
  def write(self, oprot):
25762 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25763 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25764 
      return
25765 
    oprot.writeStructBegin('updateOrderOnlyAsPaidToVendor_result')
25766 
    if self.ex is not None:
25767 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
25768 
      self.ex.write(oprot)
25769 
      oprot.writeFieldEnd()
25770 
    oprot.writeFieldStop()
25771 
    oprot.writeStructEnd()
25772 
 
25773 
  def validate(self):
25774 
    return
25775 
 
25776 
 
25777 
  def __repr__(self):
25778 
    L = ['%s=%r' % (key, value)
25779 
      for key, value in self.__dict__.iteritems()]
25780 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25781 
 
25782 
  def __eq__(self, other):
25783 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25784 
 
25785 
  def __ne__(self, other):
25786 
    return not (self == other)
25787 
 
5208 varun.gupt 25788 
class getRefundedOrdersMarkedPaid_args:
25789 
 
25790 
  thrift_spec = (
25791 
  )
25792 
 
25793 
  def read(self, iprot):
25794 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25795 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25796 
      return
25797 
    iprot.readStructBegin()
25798 
    while True:
25799 
      (fname, ftype, fid) = iprot.readFieldBegin()
25800 
      if ftype == TType.STOP:
25801 
        break
25802 
      else:
25803 
        iprot.skip(ftype)
25804 
      iprot.readFieldEnd()
25805 
    iprot.readStructEnd()
25806 
 
25807 
  def write(self, oprot):
25808 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25809 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25810 
      return
25811 
    oprot.writeStructBegin('getRefundedOrdersMarkedPaid_args')
25812 
    oprot.writeFieldStop()
25813 
    oprot.writeStructEnd()
25814 
 
25815 
  def validate(self):
25816 
    return
25817 
 
25818 
 
25819 
  def __repr__(self):
25820 
    L = ['%s=%r' % (key, value)
25821 
      for key, value in self.__dict__.iteritems()]
25822 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25823 
 
25824 
  def __eq__(self, other):
25825 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25826 
 
25827 
  def __ne__(self, other):
25828 
    return not (self == other)
25829 
 
25830 
class getRefundedOrdersMarkedPaid_result:
25831 
  """
25832 
  Attributes:
25833 
   - success
25834 
   - ex
25835 
  """
25836 
 
25837 
  thrift_spec = (
25838 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
25839 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
25840 
  )
25841 
 
25842 
  def __init__(self, success=None, ex=None,):
25843 
    self.success = success
25844 
    self.ex = ex
25845 
 
25846 
  def read(self, iprot):
25847 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25848 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25849 
      return
25850 
    iprot.readStructBegin()
25851 
    while True:
25852 
      (fname, ftype, fid) = iprot.readFieldBegin()
25853 
      if ftype == TType.STOP:
25854 
        break
25855 
      if fid == 0:
25856 
        if ftype == TType.LIST:
25857 
          self.success = []
6188 rajveer 25858 
          (_etype610, _size607) = iprot.readListBegin()
25859 
          for _i611 in xrange(_size607):
25860 
            _elem612 = Order()
25861 
            _elem612.read(iprot)
25862 
            self.success.append(_elem612)
5208 varun.gupt 25863 
          iprot.readListEnd()
25864 
        else:
25865 
          iprot.skip(ftype)
25866 
      elif fid == 1:
25867 
        if ftype == TType.STRUCT:
25868 
          self.ex = TransactionServiceException()
25869 
          self.ex.read(iprot)
25870 
        else:
25871 
          iprot.skip(ftype)
25872 
      else:
25873 
        iprot.skip(ftype)
25874 
      iprot.readFieldEnd()
25875 
    iprot.readStructEnd()
25876 
 
25877 
  def write(self, oprot):
25878 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25879 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25880 
      return
25881 
    oprot.writeStructBegin('getRefundedOrdersMarkedPaid_result')
25882 
    if self.success is not None:
25883 
      oprot.writeFieldBegin('success', TType.LIST, 0)
25884 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 25885 
      for iter613 in self.success:
25886 
        iter613.write(oprot)
5208 varun.gupt 25887 
      oprot.writeListEnd()
25888 
      oprot.writeFieldEnd()
25889 
    if self.ex is not None:
25890 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
25891 
      self.ex.write(oprot)
25892 
      oprot.writeFieldEnd()
25893 
    oprot.writeFieldStop()
25894 
    oprot.writeStructEnd()
25895 
 
25896 
  def validate(self):
25897 
    return
25898 
 
25899 
 
25900 
  def __repr__(self):
25901 
    L = ['%s=%r' % (key, value)
25902 
      for key, value in self.__dict__.iteritems()]
25903 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25904 
 
25905 
  def __eq__(self, other):
25906 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25907 
 
25908 
  def __ne__(self, other):
25909 
    return not (self == other)
5447 anupam.sin 25910 
 
25911 
class getAllVerificationAgents_args:
25912 
  """
25913 
  Attributes:
25914 
   - minOrderId
25915 
   - maxOrderId
25916 
  """
25917 
 
25918 
  thrift_spec = (
25919 
    None, # 0
25920 
    (1, TType.I64, 'minOrderId', None, None, ), # 1
25921 
    (2, TType.I64, 'maxOrderId', None, None, ), # 2
25922 
  )
25923 
 
25924 
  def __init__(self, minOrderId=None, maxOrderId=None,):
25925 
    self.minOrderId = minOrderId
25926 
    self.maxOrderId = maxOrderId
25927 
 
25928 
  def read(self, iprot):
25929 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25930 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25931 
      return
25932 
    iprot.readStructBegin()
25933 
    while True:
25934 
      (fname, ftype, fid) = iprot.readFieldBegin()
25935 
      if ftype == TType.STOP:
25936 
        break
25937 
      if fid == 1:
25938 
        if ftype == TType.I64:
25939 
          self.minOrderId = iprot.readI64();
25940 
        else:
25941 
          iprot.skip(ftype)
25942 
      elif fid == 2:
25943 
        if ftype == TType.I64:
25944 
          self.maxOrderId = iprot.readI64();
25945 
        else:
25946 
          iprot.skip(ftype)
25947 
      else:
25948 
        iprot.skip(ftype)
25949 
      iprot.readFieldEnd()
25950 
    iprot.readStructEnd()
25951 
 
25952 
  def write(self, oprot):
25953 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25954 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25955 
      return
25956 
    oprot.writeStructBegin('getAllVerificationAgents_args')
25957 
    if self.minOrderId is not None:
25958 
      oprot.writeFieldBegin('minOrderId', TType.I64, 1)
25959 
      oprot.writeI64(self.minOrderId)
25960 
      oprot.writeFieldEnd()
25961 
    if self.maxOrderId is not None:
25962 
      oprot.writeFieldBegin('maxOrderId', TType.I64, 2)
25963 
      oprot.writeI64(self.maxOrderId)
25964 
      oprot.writeFieldEnd()
25965 
    oprot.writeFieldStop()
25966 
    oprot.writeStructEnd()
25967 
 
25968 
  def validate(self):
25969 
    return
25970 
 
25971 
 
25972 
  def __repr__(self):
25973 
    L = ['%s=%r' % (key, value)
25974 
      for key, value in self.__dict__.iteritems()]
25975 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25976 
 
25977 
  def __eq__(self, other):
25978 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25979 
 
25980 
  def __ne__(self, other):
25981 
    return not (self == other)
25982 
 
25983 
class getAllVerificationAgents_result:
25984 
  """
25985 
  Attributes:
25986 
   - success
25987 
  """
25988 
 
25989 
  thrift_spec = (
25990 
    (0, TType.LIST, 'success', (TType.STRUCT,(CODVerificationAgent, CODVerificationAgent.thrift_spec)), None, ), # 0
25991 
  )
25992 
 
25993 
  def __init__(self, success=None,):
25994 
    self.success = success
25995 
 
25996 
  def read(self, iprot):
25997 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25998 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25999 
      return
26000 
    iprot.readStructBegin()
26001 
    while True:
26002 
      (fname, ftype, fid) = iprot.readFieldBegin()
26003 
      if ftype == TType.STOP:
26004 
        break
26005 
      if fid == 0:
26006 
        if ftype == TType.LIST:
26007 
          self.success = []
6188 rajveer 26008 
          (_etype617, _size614) = iprot.readListBegin()
26009 
          for _i618 in xrange(_size614):
26010 
            _elem619 = CODVerificationAgent()
26011 
            _elem619.read(iprot)
26012 
            self.success.append(_elem619)
5447 anupam.sin 26013 
          iprot.readListEnd()
26014 
        else:
26015 
          iprot.skip(ftype)
26016 
      else:
26017 
        iprot.skip(ftype)
26018 
      iprot.readFieldEnd()
26019 
    iprot.readStructEnd()
26020 
 
26021 
  def write(self, oprot):
26022 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26023 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26024 
      return
26025 
    oprot.writeStructBegin('getAllVerificationAgents_result')
26026 
    if self.success is not None:
26027 
      oprot.writeFieldBegin('success', TType.LIST, 0)
26028 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 26029 
      for iter620 in self.success:
26030 
        iter620.write(oprot)
5447 anupam.sin 26031 
      oprot.writeListEnd()
26032 
      oprot.writeFieldEnd()
26033 
    oprot.writeFieldStop()
26034 
    oprot.writeStructEnd()
26035 
 
26036 
  def validate(self):
26037 
    return
26038 
 
26039 
 
26040 
  def __repr__(self):
26041 
    L = ['%s=%r' % (key, value)
26042 
      for key, value in self.__dict__.iteritems()]
26043 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26044 
 
26045 
  def __eq__(self, other):
26046 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26047 
 
26048 
  def __ne__(self, other):
26049 
    return not (self == other)
5527 anupam.sin 26050 
 
26051 
class getAllAttributesForOrderId_args:
26052 
  """
26053 
  Attributes:
26054 
   - orderId
26055 
  """
26056 
 
26057 
  thrift_spec = (
26058 
    None, # 0
26059 
    (1, TType.I64, 'orderId', None, None, ), # 1
26060 
  )
26061 
 
26062 
  def __init__(self, orderId=None,):
26063 
    self.orderId = orderId
26064 
 
26065 
  def read(self, iprot):
26066 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26067 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26068 
      return
26069 
    iprot.readStructBegin()
26070 
    while True:
26071 
      (fname, ftype, fid) = iprot.readFieldBegin()
26072 
      if ftype == TType.STOP:
26073 
        break
26074 
      if fid == 1:
26075 
        if ftype == TType.I64:
26076 
          self.orderId = iprot.readI64();
26077 
        else:
26078 
          iprot.skip(ftype)
26079 
      else:
26080 
        iprot.skip(ftype)
26081 
      iprot.readFieldEnd()
26082 
    iprot.readStructEnd()
26083 
 
26084 
  def write(self, oprot):
26085 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26086 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26087 
      return
26088 
    oprot.writeStructBegin('getAllAttributesForOrderId_args')
26089 
    if self.orderId is not None:
26090 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
26091 
      oprot.writeI64(self.orderId)
26092 
      oprot.writeFieldEnd()
26093 
    oprot.writeFieldStop()
26094 
    oprot.writeStructEnd()
26095 
 
26096 
  def validate(self):
26097 
    return
26098 
 
26099 
 
26100 
  def __repr__(self):
26101 
    L = ['%s=%r' % (key, value)
26102 
      for key, value in self.__dict__.iteritems()]
26103 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26104 
 
26105 
  def __eq__(self, other):
26106 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26107 
 
26108 
  def __ne__(self, other):
26109 
    return not (self == other)
26110 
 
26111 
class getAllAttributesForOrderId_result:
26112 
  """
26113 
  Attributes:
26114 
   - success
26115 
  """
26116 
 
26117 
  thrift_spec = (
26118 
    (0, TType.LIST, 'success', (TType.STRUCT,(Attribute, Attribute.thrift_spec)), None, ), # 0
26119 
  )
26120 
 
26121 
  def __init__(self, success=None,):
26122 
    self.success = success
26123 
 
26124 
  def read(self, iprot):
26125 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26126 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26127 
      return
26128 
    iprot.readStructBegin()
26129 
    while True:
26130 
      (fname, ftype, fid) = iprot.readFieldBegin()
26131 
      if ftype == TType.STOP:
26132 
        break
26133 
      if fid == 0:
26134 
        if ftype == TType.LIST:
26135 
          self.success = []
6188 rajveer 26136 
          (_etype624, _size621) = iprot.readListBegin()
26137 
          for _i625 in xrange(_size621):
26138 
            _elem626 = Attribute()
26139 
            _elem626.read(iprot)
26140 
            self.success.append(_elem626)
5527 anupam.sin 26141 
          iprot.readListEnd()
26142 
        else:
26143 
          iprot.skip(ftype)
26144 
      else:
26145 
        iprot.skip(ftype)
26146 
      iprot.readFieldEnd()
26147 
    iprot.readStructEnd()
26148 
 
26149 
  def write(self, oprot):
26150 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26151 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26152 
      return
26153 
    oprot.writeStructBegin('getAllAttributesForOrderId_result')
26154 
    if self.success is not None:
26155 
      oprot.writeFieldBegin('success', TType.LIST, 0)
26156 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 26157 
      for iter627 in self.success:
26158 
        iter627.write(oprot)
5527 anupam.sin 26159 
      oprot.writeListEnd()
26160 
      oprot.writeFieldEnd()
26161 
    oprot.writeFieldStop()
26162 
    oprot.writeStructEnd()
26163 
 
26164 
  def validate(self):
26165 
    return
26166 
 
26167 
 
26168 
  def __repr__(self):
26169 
    L = ['%s=%r' % (key, value)
26170 
      for key, value in self.__dict__.iteritems()]
26171 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26172 
 
26173 
  def __eq__(self, other):
26174 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26175 
 
26176 
  def __ne__(self, other):
26177 
    return not (self == other)
26178 
 
5676 rajveer 26179 
class setOrderAttributes_args:
26180 
  """
26181 
  Attributes:
26182 
   - orderId
26183 
   - attributes
26184 
  """
26185 
 
26186 
  thrift_spec = None
26187 
  def __init__(self, orderId=None, attributes=None,):
26188 
    self.orderId = orderId
26189 
    self.attributes = attributes
26190 
 
26191 
  def read(self, iprot):
26192 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26193 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26194 
      return
26195 
    iprot.readStructBegin()
26196 
    while True:
26197 
      (fname, ftype, fid) = iprot.readFieldBegin()
26198 
      if ftype == TType.STOP:
26199 
        break
26200 
      if fid == 1:
26201 
        if ftype == TType.I64:
26202 
          self.orderId = iprot.readI64();
26203 
        else:
26204 
          iprot.skip(ftype)
26205 
      elif fid == -1:
26206 
        if ftype == TType.LIST:
26207 
          self.attributes = []
6188 rajveer 26208 
          (_etype631, _size628) = iprot.readListBegin()
26209 
          for _i632 in xrange(_size628):
26210 
            _elem633 = Attribute()
26211 
            _elem633.read(iprot)
26212 
            self.attributes.append(_elem633)
5676 rajveer 26213 
          iprot.readListEnd()
26214 
        else:
26215 
          iprot.skip(ftype)
26216 
      else:
26217 
        iprot.skip(ftype)
26218 
      iprot.readFieldEnd()
26219 
    iprot.readStructEnd()
26220 
 
26221 
  def write(self, oprot):
26222 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26223 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26224 
      return
26225 
    oprot.writeStructBegin('setOrderAttributes_args')
26226 
    if self.attributes is not None:
26227 
      oprot.writeFieldBegin('attributes', TType.LIST, -1)
26228 
      oprot.writeListBegin(TType.STRUCT, len(self.attributes))
6188 rajveer 26229 
      for iter634 in self.attributes:
26230 
        iter634.write(oprot)
5676 rajveer 26231 
      oprot.writeListEnd()
26232 
      oprot.writeFieldEnd()
26233 
    if self.orderId is not None:
26234 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
26235 
      oprot.writeI64(self.orderId)
26236 
      oprot.writeFieldEnd()
26237 
    oprot.writeFieldStop()
26238 
    oprot.writeStructEnd()
26239 
 
26240 
  def validate(self):
26241 
    return
26242 
 
26243 
 
26244 
  def __repr__(self):
26245 
    L = ['%s=%r' % (key, value)
26246 
      for key, value in self.__dict__.iteritems()]
26247 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26248 
 
26249 
  def __eq__(self, other):
26250 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26251 
 
26252 
  def __ne__(self, other):
26253 
    return not (self == other)
26254 
 
26255 
class setOrderAttributes_result:
26256 
 
26257 
  thrift_spec = (
26258 
  )
26259 
 
26260 
  def read(self, iprot):
26261 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26262 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26263 
      return
26264 
    iprot.readStructBegin()
26265 
    while True:
26266 
      (fname, ftype, fid) = iprot.readFieldBegin()
26267 
      if ftype == TType.STOP:
26268 
        break
26269 
      else:
26270 
        iprot.skip(ftype)
26271 
      iprot.readFieldEnd()
26272 
    iprot.readStructEnd()
26273 
 
26274 
  def write(self, oprot):
26275 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26276 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26277 
      return
26278 
    oprot.writeStructBegin('setOrderAttributes_result')
26279 
    oprot.writeFieldStop()
26280 
    oprot.writeStructEnd()
26281 
 
26282 
  def validate(self):
26283 
    return
26284 
 
26285 
 
26286 
  def __repr__(self):
26287 
    L = ['%s=%r' % (key, value)
26288 
      for key, value in self.__dict__.iteritems()]
26289 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26290 
 
26291 
  def __eq__(self, other):
26292 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26293 
 
26294 
  def __ne__(self, other):
26295 
    return not (self == other)
26296 
 
5527 anupam.sin 26297 
class setOrderAttributeForTransaction_args:
26298 
  """
26299 
  Attributes:
26300 
   - transactionId
26301 
   - attribute
26302 
  """
26303 
 
26304 
  thrift_spec = None
26305 
  def __init__(self, transactionId=None, attribute=None,):
26306 
    self.transactionId = transactionId
26307 
    self.attribute = attribute
26308 
 
26309 
  def read(self, iprot):
26310 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26311 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26312 
      return
26313 
    iprot.readStructBegin()
26314 
    while True:
26315 
      (fname, ftype, fid) = iprot.readFieldBegin()
26316 
      if ftype == TType.STOP:
26317 
        break
26318 
      if fid == 1:
26319 
        if ftype == TType.I64:
26320 
          self.transactionId = iprot.readI64();
26321 
        else:
26322 
          iprot.skip(ftype)
26323 
      elif fid == -1:
26324 
        if ftype == TType.STRUCT:
26325 
          self.attribute = Attribute()
26326 
          self.attribute.read(iprot)
26327 
        else:
26328 
          iprot.skip(ftype)
26329 
      else:
26330 
        iprot.skip(ftype)
26331 
      iprot.readFieldEnd()
26332 
    iprot.readStructEnd()
26333 
 
26334 
  def write(self, oprot):
26335 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26336 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26337 
      return
26338 
    oprot.writeStructBegin('setOrderAttributeForTransaction_args')
26339 
    if self.attribute is not None:
26340 
      oprot.writeFieldBegin('attribute', TType.STRUCT, -1)
26341 
      self.attribute.write(oprot)
26342 
      oprot.writeFieldEnd()
26343 
    if self.transactionId is not None:
26344 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
26345 
      oprot.writeI64(self.transactionId)
26346 
      oprot.writeFieldEnd()
26347 
    oprot.writeFieldStop()
26348 
    oprot.writeStructEnd()
26349 
 
26350 
  def validate(self):
26351 
    return
26352 
 
26353 
 
26354 
  def __repr__(self):
26355 
    L = ['%s=%r' % (key, value)
26356 
      for key, value in self.__dict__.iteritems()]
26357 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26358 
 
26359 
  def __eq__(self, other):
26360 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26361 
 
26362 
  def __ne__(self, other):
26363 
    return not (self == other)
26364 
 
26365 
class setOrderAttributeForTransaction_result:
26366 
 
26367 
  thrift_spec = (
26368 
  )
26369 
 
26370 
  def read(self, iprot):
26371 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26372 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26373 
      return
26374 
    iprot.readStructBegin()
26375 
    while True:
26376 
      (fname, ftype, fid) = iprot.readFieldBegin()
26377 
      if ftype == TType.STOP:
26378 
        break
26379 
      else:
26380 
        iprot.skip(ftype)
26381 
      iprot.readFieldEnd()
26382 
    iprot.readStructEnd()
26383 
 
26384 
  def write(self, oprot):
26385 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26386 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26387 
      return
26388 
    oprot.writeStructBegin('setOrderAttributeForTransaction_result')
26389 
    oprot.writeFieldStop()
26390 
    oprot.writeStructEnd()
26391 
 
26392 
  def validate(self):
26393 
    return
26394 
 
26395 
 
26396 
  def __repr__(self):
26397 
    L = ['%s=%r' % (key, value)
26398 
      for key, value in self.__dict__.iteritems()]
26399 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26400 
 
26401 
  def __eq__(self, other):
26402 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26403 
 
26404 
  def __ne__(self, other):
26405 
    return not (self == other)
5553 rajveer 26406 
 
26407 
class getReceivePendingOrders_args:
26408 
  """
26409 
  Attributes:
26410 
   - storeId
26411 
  """
26412 
 
26413 
  thrift_spec = (
26414 
    None, # 0
26415 
    (1, TType.I64, 'storeId', None, None, ), # 1
26416 
  )
26417 
 
26418 
  def __init__(self, storeId=None,):
26419 
    self.storeId = storeId
26420 
 
26421 
  def read(self, iprot):
26422 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26423 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26424 
      return
26425 
    iprot.readStructBegin()
26426 
    while True:
26427 
      (fname, ftype, fid) = iprot.readFieldBegin()
26428 
      if ftype == TType.STOP:
26429 
        break
26430 
      if fid == 1:
26431 
        if ftype == TType.I64:
26432 
          self.storeId = iprot.readI64();
26433 
        else:
26434 
          iprot.skip(ftype)
26435 
      else:
26436 
        iprot.skip(ftype)
26437 
      iprot.readFieldEnd()
26438 
    iprot.readStructEnd()
26439 
 
26440 
  def write(self, oprot):
26441 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26442 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26443 
      return
26444 
    oprot.writeStructBegin('getReceivePendingOrders_args')
26445 
    if self.storeId is not None:
26446 
      oprot.writeFieldBegin('storeId', TType.I64, 1)
26447 
      oprot.writeI64(self.storeId)
26448 
      oprot.writeFieldEnd()
26449 
    oprot.writeFieldStop()
26450 
    oprot.writeStructEnd()
26451 
 
26452 
  def validate(self):
26453 
    return
26454 
 
26455 
 
26456 
  def __repr__(self):
26457 
    L = ['%s=%r' % (key, value)
26458 
      for key, value in self.__dict__.iteritems()]
26459 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26460 
 
26461 
  def __eq__(self, other):
26462 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26463 
 
26464 
  def __ne__(self, other):
26465 
    return not (self == other)
26466 
 
26467 
class getReceivePendingOrders_result:
26468 
  """
26469 
  Attributes:
26470 
   - success
26471 
  """
26472 
 
26473 
  thrift_spec = (
26474 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
26475 
  )
26476 
 
26477 
  def __init__(self, success=None,):
26478 
    self.success = success
26479 
 
26480 
  def read(self, iprot):
26481 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26482 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26483 
      return
26484 
    iprot.readStructBegin()
26485 
    while True:
26486 
      (fname, ftype, fid) = iprot.readFieldBegin()
26487 
      if ftype == TType.STOP:
26488 
        break
26489 
      if fid == 0:
26490 
        if ftype == TType.LIST:
26491 
          self.success = []
6188 rajveer 26492 
          (_etype638, _size635) = iprot.readListBegin()
26493 
          for _i639 in xrange(_size635):
26494 
            _elem640 = Order()
26495 
            _elem640.read(iprot)
26496 
            self.success.append(_elem640)
5553 rajveer 26497 
          iprot.readListEnd()
26498 
        else:
26499 
          iprot.skip(ftype)
26500 
      else:
26501 
        iprot.skip(ftype)
26502 
      iprot.readFieldEnd()
26503 
    iprot.readStructEnd()
26504 
 
26505 
  def write(self, oprot):
26506 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26507 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26508 
      return
26509 
    oprot.writeStructBegin('getReceivePendingOrders_result')
26510 
    if self.success is not None:
26511 
      oprot.writeFieldBegin('success', TType.LIST, 0)
26512 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 26513 
      for iter641 in self.success:
26514 
        iter641.write(oprot)
5553 rajveer 26515 
      oprot.writeListEnd()
26516 
      oprot.writeFieldEnd()
26517 
    oprot.writeFieldStop()
26518 
    oprot.writeStructEnd()
26519 
 
26520 
  def validate(self):
26521 
    return
26522 
 
26523 
 
26524 
  def __repr__(self):
26525 
    L = ['%s=%r' % (key, value)
26526 
      for key, value in self.__dict__.iteritems()]
26527 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26528 
 
26529 
  def __eq__(self, other):
26530 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26531 
 
26532 
  def __ne__(self, other):
26533 
    return not (self == other)
26534 
 
26535 
class getReceivedAtStoreOrders_args:
26536 
  """
26537 
  Attributes:
26538 
   - storeId
26539 
  """
26540 
 
26541 
  thrift_spec = (
26542 
    None, # 0
26543 
    (1, TType.I64, 'storeId', None, None, ), # 1
26544 
  )
26545 
 
26546 
  def __init__(self, storeId=None,):
26547 
    self.storeId = storeId
26548 
 
26549 
  def read(self, iprot):
26550 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26551 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26552 
      return
26553 
    iprot.readStructBegin()
26554 
    while True:
26555 
      (fname, ftype, fid) = iprot.readFieldBegin()
26556 
      if ftype == TType.STOP:
26557 
        break
26558 
      if fid == 1:
26559 
        if ftype == TType.I64:
26560 
          self.storeId = iprot.readI64();
26561 
        else:
26562 
          iprot.skip(ftype)
26563 
      else:
26564 
        iprot.skip(ftype)
26565 
      iprot.readFieldEnd()
26566 
    iprot.readStructEnd()
26567 
 
26568 
  def write(self, oprot):
26569 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26570 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26571 
      return
26572 
    oprot.writeStructBegin('getReceivedAtStoreOrders_args')
26573 
    if self.storeId is not None:
26574 
      oprot.writeFieldBegin('storeId', TType.I64, 1)
26575 
      oprot.writeI64(self.storeId)
26576 
      oprot.writeFieldEnd()
26577 
    oprot.writeFieldStop()
26578 
    oprot.writeStructEnd()
26579 
 
26580 
  def validate(self):
26581 
    return
26582 
 
26583 
 
26584 
  def __repr__(self):
26585 
    L = ['%s=%r' % (key, value)
26586 
      for key, value in self.__dict__.iteritems()]
26587 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26588 
 
26589 
  def __eq__(self, other):
26590 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26591 
 
26592 
  def __ne__(self, other):
26593 
    return not (self == other)
26594 
 
26595 
class getReceivedAtStoreOrders_result:
26596 
  """
26597 
  Attributes:
26598 
   - success
26599 
  """
26600 
 
26601 
  thrift_spec = (
26602 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
26603 
  )
26604 
 
26605 
  def __init__(self, success=None,):
26606 
    self.success = success
26607 
 
26608 
  def read(self, iprot):
26609 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26610 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26611 
      return
26612 
    iprot.readStructBegin()
26613 
    while True:
26614 
      (fname, ftype, fid) = iprot.readFieldBegin()
26615 
      if ftype == TType.STOP:
26616 
        break
26617 
      if fid == 0:
26618 
        if ftype == TType.LIST:
26619 
          self.success = []
6188 rajveer 26620 
          (_etype645, _size642) = iprot.readListBegin()
26621 
          for _i646 in xrange(_size642):
26622 
            _elem647 = Order()
26623 
            _elem647.read(iprot)
26624 
            self.success.append(_elem647)
5553 rajveer 26625 
          iprot.readListEnd()
26626 
        else:
26627 
          iprot.skip(ftype)
26628 
      else:
26629 
        iprot.skip(ftype)
26630 
      iprot.readFieldEnd()
26631 
    iprot.readStructEnd()
26632 
 
26633 
  def write(self, oprot):
26634 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26635 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26636 
      return
26637 
    oprot.writeStructBegin('getReceivedAtStoreOrders_result')
26638 
    if self.success is not None:
26639 
      oprot.writeFieldBegin('success', TType.LIST, 0)
26640 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 26641 
      for iter648 in self.success:
26642 
        iter648.write(oprot)
5553 rajveer 26643 
      oprot.writeListEnd()
26644 
      oprot.writeFieldEnd()
26645 
    oprot.writeFieldStop()
26646 
    oprot.writeStructEnd()
26647 
 
26648 
  def validate(self):
26649 
    return
26650 
 
26651 
 
26652 
  def __repr__(self):
26653 
    L = ['%s=%r' % (key, value)
26654 
      for key, value in self.__dict__.iteritems()]
26655 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26656 
 
26657 
  def __eq__(self, other):
26658 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26659 
 
26660 
  def __ne__(self, other):
26661 
    return not (self == other)
5593 mandeep.dh 26662 
 
5713 rajveer 26663 
class getOrdersCollectionAtStore_args:
26664 
  """
26665 
  Attributes:
26666 
   - storeId
26667 
   - fromDate
26668 
   - toDate
26669 
   - onlyCod
26670 
  """
26671 
 
26672 
  thrift_spec = (
26673 
    None, # 0
26674 
    (1, TType.I64, 'storeId', None, None, ), # 1
26675 
    (2, TType.I64, 'fromDate', None, None, ), # 2
26676 
    (3, TType.I64, 'toDate', None, None, ), # 3
26677 
    (4, TType.BOOL, 'onlyCod', None, None, ), # 4
26678 
  )
26679 
 
26680 
  def __init__(self, storeId=None, fromDate=None, toDate=None, onlyCod=None,):
26681 
    self.storeId = storeId
26682 
    self.fromDate = fromDate
26683 
    self.toDate = toDate
26684 
    self.onlyCod = onlyCod
26685 
 
26686 
  def read(self, iprot):
26687 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26688 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26689 
      return
26690 
    iprot.readStructBegin()
26691 
    while True:
26692 
      (fname, ftype, fid) = iprot.readFieldBegin()
26693 
      if ftype == TType.STOP:
26694 
        break
26695 
      if fid == 1:
26696 
        if ftype == TType.I64:
26697 
          self.storeId = iprot.readI64();
26698 
        else:
26699 
          iprot.skip(ftype)
26700 
      elif fid == 2:
26701 
        if ftype == TType.I64:
26702 
          self.fromDate = iprot.readI64();
26703 
        else:
26704 
          iprot.skip(ftype)
26705 
      elif fid == 3:
26706 
        if ftype == TType.I64:
26707 
          self.toDate = iprot.readI64();
26708 
        else:
26709 
          iprot.skip(ftype)
26710 
      elif fid == 4:
26711 
        if ftype == TType.BOOL:
26712 
          self.onlyCod = iprot.readBool();
26713 
        else:
26714 
          iprot.skip(ftype)
26715 
      else:
26716 
        iprot.skip(ftype)
26717 
      iprot.readFieldEnd()
26718 
    iprot.readStructEnd()
26719 
 
26720 
  def write(self, oprot):
26721 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26722 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26723 
      return
26724 
    oprot.writeStructBegin('getOrdersCollectionAtStore_args')
26725 
    if self.storeId is not None:
26726 
      oprot.writeFieldBegin('storeId', TType.I64, 1)
26727 
      oprot.writeI64(self.storeId)
26728 
      oprot.writeFieldEnd()
26729 
    if self.fromDate is not None:
26730 
      oprot.writeFieldBegin('fromDate', TType.I64, 2)
26731 
      oprot.writeI64(self.fromDate)
26732 
      oprot.writeFieldEnd()
26733 
    if self.toDate is not None:
26734 
      oprot.writeFieldBegin('toDate', TType.I64, 3)
26735 
      oprot.writeI64(self.toDate)
26736 
      oprot.writeFieldEnd()
26737 
    if self.onlyCod is not None:
26738 
      oprot.writeFieldBegin('onlyCod', TType.BOOL, 4)
26739 
      oprot.writeBool(self.onlyCod)
26740 
      oprot.writeFieldEnd()
26741 
    oprot.writeFieldStop()
26742 
    oprot.writeStructEnd()
26743 
 
26744 
  def validate(self):
26745 
    return
26746 
 
26747 
 
26748 
  def __repr__(self):
26749 
    L = ['%s=%r' % (key, value)
26750 
      for key, value in self.__dict__.iteritems()]
26751 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26752 
 
26753 
  def __eq__(self, other):
26754 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26755 
 
26756 
  def __ne__(self, other):
26757 
    return not (self == other)
26758 
 
26759 
class getOrdersCollectionAtStore_result:
26760 
  """
26761 
  Attributes:
26762 
   - success
26763 
  """
26764 
 
26765 
  thrift_spec = (
26766 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
26767 
  )
26768 
 
26769 
  def __init__(self, success=None,):
26770 
    self.success = success
26771 
 
26772 
  def read(self, iprot):
26773 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26774 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26775 
      return
26776 
    iprot.readStructBegin()
26777 
    while True:
26778 
      (fname, ftype, fid) = iprot.readFieldBegin()
26779 
      if ftype == TType.STOP:
26780 
        break
26781 
      if fid == 0:
26782 
        if ftype == TType.LIST:
26783 
          self.success = []
6188 rajveer 26784 
          (_etype652, _size649) = iprot.readListBegin()
26785 
          for _i653 in xrange(_size649):
26786 
            _elem654 = Order()
26787 
            _elem654.read(iprot)
26788 
            self.success.append(_elem654)
5713 rajveer 26789 
          iprot.readListEnd()
26790 
        else:
26791 
          iprot.skip(ftype)
26792 
      else:
26793 
        iprot.skip(ftype)
26794 
      iprot.readFieldEnd()
26795 
    iprot.readStructEnd()
26796 
 
26797 
  def write(self, oprot):
26798 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26799 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26800 
      return
26801 
    oprot.writeStructBegin('getOrdersCollectionAtStore_result')
26802 
    if self.success is not None:
26803 
      oprot.writeFieldBegin('success', TType.LIST, 0)
26804 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 26805 
      for iter655 in self.success:
26806 
        iter655.write(oprot)
5713 rajveer 26807 
      oprot.writeListEnd()
26808 
      oprot.writeFieldEnd()
26809 
    oprot.writeFieldStop()
26810 
    oprot.writeStructEnd()
26811 
 
26812 
  def validate(self):
26813 
    return
26814 
 
26815 
 
26816 
  def __repr__(self):
26817 
    L = ['%s=%r' % (key, value)
26818 
      for key, value in self.__dict__.iteritems()]
26819 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26820 
 
26821 
  def __eq__(self, other):
26822 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26823 
 
26824 
  def __ne__(self, other):
26825 
    return not (self == other)
26826 
 
5833 rajveer 26827 
class getOrderAttributeValue_args:
26828 
  """
26829 
  Attributes:
26830 
   - orderId
26831 
   - attributeName
26832 
  """
26833 
 
26834 
  thrift_spec = None
26835 
  def __init__(self, orderId=None, attributeName=None,):
26836 
    self.orderId = orderId
26837 
    self.attributeName = attributeName
26838 
 
26839 
  def read(self, iprot):
26840 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26841 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26842 
      return
26843 
    iprot.readStructBegin()
26844 
    while True:
26845 
      (fname, ftype, fid) = iprot.readFieldBegin()
26846 
      if ftype == TType.STOP:
26847 
        break
26848 
      if fid == 1:
26849 
        if ftype == TType.I64:
26850 
          self.orderId = iprot.readI64();
26851 
        else:
26852 
          iprot.skip(ftype)
26853 
      elif fid == -1:
26854 
        if ftype == TType.STRING:
26855 
          self.attributeName = iprot.readString();
26856 
        else:
26857 
          iprot.skip(ftype)
26858 
      else:
26859 
        iprot.skip(ftype)
26860 
      iprot.readFieldEnd()
26861 
    iprot.readStructEnd()
26862 
 
26863 
  def write(self, oprot):
26864 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26865 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26866 
      return
26867 
    oprot.writeStructBegin('getOrderAttributeValue_args')
26868 
    if self.attributeName is not None:
26869 
      oprot.writeFieldBegin('attributeName', TType.STRING, -1)
26870 
      oprot.writeString(self.attributeName)
26871 
      oprot.writeFieldEnd()
26872 
    if self.orderId is not None:
26873 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
26874 
      oprot.writeI64(self.orderId)
26875 
      oprot.writeFieldEnd()
26876 
    oprot.writeFieldStop()
26877 
    oprot.writeStructEnd()
26878 
 
26879 
  def validate(self):
26880 
    return
26881 
 
26882 
 
26883 
  def __repr__(self):
26884 
    L = ['%s=%r' % (key, value)
26885 
      for key, value in self.__dict__.iteritems()]
26886 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26887 
 
26888 
  def __eq__(self, other):
26889 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26890 
 
26891 
  def __ne__(self, other):
26892 
    return not (self == other)
26893 
 
26894 
class getOrderAttributeValue_result:
26895 
  """
26896 
  Attributes:
26897 
   - success
26898 
  """
26899 
 
26900 
  thrift_spec = (
26901 
    (0, TType.STRING, 'success', None, None, ), # 0
26902 
  )
26903 
 
26904 
  def __init__(self, success=None,):
26905 
    self.success = success
26906 
 
26907 
  def read(self, iprot):
26908 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26909 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26910 
      return
26911 
    iprot.readStructBegin()
26912 
    while True:
26913 
      (fname, ftype, fid) = iprot.readFieldBegin()
26914 
      if ftype == TType.STOP:
26915 
        break
26916 
      if fid == 0:
26917 
        if ftype == TType.STRING:
26918 
          self.success = iprot.readString();
26919 
        else:
26920 
          iprot.skip(ftype)
26921 
      else:
26922 
        iprot.skip(ftype)
26923 
      iprot.readFieldEnd()
26924 
    iprot.readStructEnd()
26925 
 
26926 
  def write(self, oprot):
26927 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26928 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26929 
      return
26930 
    oprot.writeStructBegin('getOrderAttributeValue_result')
26931 
    if self.success is not None:
26932 
      oprot.writeFieldBegin('success', TType.STRING, 0)
26933 
      oprot.writeString(self.success)
26934 
      oprot.writeFieldEnd()
26935 
    oprot.writeFieldStop()
26936 
    oprot.writeStructEnd()
26937 
 
26938 
  def validate(self):
26939 
    return
26940 
 
26941 
 
26942 
  def __repr__(self):
26943 
    L = ['%s=%r' % (key, value)
26944 
      for key, value in self.__dict__.iteritems()]
26945 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26946 
 
26947 
  def __eq__(self, other):
26948 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26949 
 
26950 
  def __ne__(self, other):
26951 
    return not (self == other)
26952 
 
6019 rajveer 26953 
class changeJacketNumber_args:
26954 
  """
26955 
  Attributes:
26956 
   - orderId
26957 
   - jacketNumber
26958 
  """
26959 
 
26960 
  thrift_spec = (
26961 
    None, # 0
26962 
    (1, TType.I64, 'orderId', None, None, ), # 1
26963 
    (2, TType.I64, 'jacketNumber', None, None, ), # 2
26964 
  )
26965 
 
26966 
  def __init__(self, orderId=None, jacketNumber=None,):
26967 
    self.orderId = orderId
26968 
    self.jacketNumber = jacketNumber
26969 
 
26970 
  def read(self, iprot):
26971 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26972 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26973 
      return
26974 
    iprot.readStructBegin()
26975 
    while True:
26976 
      (fname, ftype, fid) = iprot.readFieldBegin()
26977 
      if ftype == TType.STOP:
26978 
        break
26979 
      if fid == 1:
26980 
        if ftype == TType.I64:
26981 
          self.orderId = iprot.readI64();
26982 
        else:
26983 
          iprot.skip(ftype)
26984 
      elif fid == 2:
26985 
        if ftype == TType.I64:
26986 
          self.jacketNumber = iprot.readI64();
26987 
        else:
26988 
          iprot.skip(ftype)
26989 
      else:
26990 
        iprot.skip(ftype)
26991 
      iprot.readFieldEnd()
26992 
    iprot.readStructEnd()
26993 
 
26994 
  def write(self, oprot):
26995 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26996 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26997 
      return
26998 
    oprot.writeStructBegin('changeJacketNumber_args')
26999 
    if self.orderId is not None:
27000 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
27001 
      oprot.writeI64(self.orderId)
27002 
      oprot.writeFieldEnd()
27003 
    if self.jacketNumber is not None:
27004 
      oprot.writeFieldBegin('jacketNumber', TType.I64, 2)
27005 
      oprot.writeI64(self.jacketNumber)
27006 
      oprot.writeFieldEnd()
27007 
    oprot.writeFieldStop()
27008 
    oprot.writeStructEnd()
27009 
 
27010 
  def validate(self):
27011 
    return
27012 
 
27013 
 
27014 
  def __repr__(self):
27015 
    L = ['%s=%r' % (key, value)
27016 
      for key, value in self.__dict__.iteritems()]
27017 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27018 
 
27019 
  def __eq__(self, other):
27020 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27021 
 
27022 
  def __ne__(self, other):
27023 
    return not (self == other)
27024 
 
27025 
class changeJacketNumber_result:
27026 
  """
27027 
  Attributes:
27028 
   - success
27029 
  """
27030 
 
27031 
  thrift_spec = (
27032 
    (0, TType.BOOL, 'success', None, None, ), # 0
27033 
  )
27034 
 
27035 
  def __init__(self, success=None,):
27036 
    self.success = success
27037 
 
27038 
  def read(self, iprot):
27039 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27040 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27041 
      return
27042 
    iprot.readStructBegin()
27043 
    while True:
27044 
      (fname, ftype, fid) = iprot.readFieldBegin()
27045 
      if ftype == TType.STOP:
27046 
        break
27047 
      if fid == 0:
27048 
        if ftype == TType.BOOL:
27049 
          self.success = iprot.readBool();
27050 
        else:
27051 
          iprot.skip(ftype)
27052 
      else:
27053 
        iprot.skip(ftype)
27054 
      iprot.readFieldEnd()
27055 
    iprot.readStructEnd()
27056 
 
27057 
  def write(self, oprot):
27058 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27059 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27060 
      return
27061 
    oprot.writeStructBegin('changeJacketNumber_result')
27062 
    if self.success is not None:
27063 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
27064 
      oprot.writeBool(self.success)
27065 
      oprot.writeFieldEnd()
27066 
    oprot.writeFieldStop()
27067 
    oprot.writeStructEnd()
27068 
 
27069 
  def validate(self):
27070 
    return
27071 
 
27072 
 
27073 
  def __repr__(self):
27074 
    L = ['%s=%r' % (key, value)
27075 
      for key, value in self.__dict__.iteritems()]
27076 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27077 
 
27078 
  def __eq__(self, other):
27079 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27080 
 
27081 
  def __ne__(self, other):
27082 
    return not (self == other)
27083 
 
27084 
class markOrderAsRtoInTransit_args:
27085 
  """
27086 
  Attributes:
27087 
   - orderId
27088 
  """
27089 
 
27090 
  thrift_spec = (
27091 
    None, # 0
27092 
    (1, TType.I64, 'orderId', None, None, ), # 1
27093 
  )
27094 
 
27095 
  def __init__(self, orderId=None,):
27096 
    self.orderId = orderId
27097 
 
27098 
  def read(self, iprot):
27099 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27100 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27101 
      return
27102 
    iprot.readStructBegin()
27103 
    while True:
27104 
      (fname, ftype, fid) = iprot.readFieldBegin()
27105 
      if ftype == TType.STOP:
27106 
        break
27107 
      if fid == 1:
27108 
        if ftype == TType.I64:
27109 
          self.orderId = iprot.readI64();
27110 
        else:
27111 
          iprot.skip(ftype)
27112 
      else:
27113 
        iprot.skip(ftype)
27114 
      iprot.readFieldEnd()
27115 
    iprot.readStructEnd()
27116 
 
27117 
  def write(self, oprot):
27118 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27119 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27120 
      return
27121 
    oprot.writeStructBegin('markOrderAsRtoInTransit_args')
27122 
    if self.orderId is not None:
27123 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
27124 
      oprot.writeI64(self.orderId)
27125 
      oprot.writeFieldEnd()
27126 
    oprot.writeFieldStop()
27127 
    oprot.writeStructEnd()
27128 
 
27129 
  def validate(self):
27130 
    return
27131 
 
27132 
 
27133 
  def __repr__(self):
27134 
    L = ['%s=%r' % (key, value)
27135 
      for key, value in self.__dict__.iteritems()]
27136 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27137 
 
27138 
  def __eq__(self, other):
27139 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27140 
 
27141 
  def __ne__(self, other):
27142 
    return not (self == other)
27143 
 
27144 
class markOrderAsRtoInTransit_result:
27145 
  """
27146 
  Attributes:
27147 
   - success
27148 
  """
27149 
 
27150 
  thrift_spec = (
27151 
    (0, TType.BOOL, 'success', None, None, ), # 0
27152 
  )
27153 
 
27154 
  def __init__(self, success=None,):
27155 
    self.success = success
27156 
 
27157 
  def read(self, iprot):
27158 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27159 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27160 
      return
27161 
    iprot.readStructBegin()
27162 
    while True:
27163 
      (fname, ftype, fid) = iprot.readFieldBegin()
27164 
      if ftype == TType.STOP:
27165 
        break
27166 
      if fid == 0:
27167 
        if ftype == TType.BOOL:
27168 
          self.success = iprot.readBool();
27169 
        else:
27170 
          iprot.skip(ftype)
27171 
      else:
27172 
        iprot.skip(ftype)
27173 
      iprot.readFieldEnd()
27174 
    iprot.readStructEnd()
27175 
 
27176 
  def write(self, oprot):
27177 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27178 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27179 
      return
27180 
    oprot.writeStructBegin('markOrderAsRtoInTransit_result')
27181 
    if self.success is not None:
27182 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
27183 
      oprot.writeBool(self.success)
27184 
      oprot.writeFieldEnd()
27185 
    oprot.writeFieldStop()
27186 
    oprot.writeStructEnd()
27187 
 
27188 
  def validate(self):
27189 
    return
27190 
 
27191 
 
27192 
  def __repr__(self):
27193 
    L = ['%s=%r' % (key, value)
27194 
      for key, value in self.__dict__.iteritems()]
27195 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27196 
 
27197 
  def __eq__(self, other):
27198 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27199 
 
27200 
  def __ne__(self, other):
27201 
    return not (self == other)
27202 
 
5593 mandeep.dh 27203 
class acceptOrderForItem_args:
27204 
  """
27205 
  Attributes:
27206 
   - itemId
27207 
   - quantity
27208 
   - fulfilmentWarehouseId
27209 
   - billingWarehouseId
27210 
  """
27211 
 
27212 
  thrift_spec = (
27213 
    None, # 0
27214 
    (1, TType.I64, 'itemId', None, None, ), # 1
27215 
    (2, TType.I64, 'quantity', None, None, ), # 2
27216 
    (3, TType.I64, 'fulfilmentWarehouseId', None, None, ), # 3
27217 
    (4, TType.I64, 'billingWarehouseId', None, None, ), # 4
27218 
  )
27219 
 
27220 
  def __init__(self, itemId=None, quantity=None, fulfilmentWarehouseId=None, billingWarehouseId=None,):
27221 
    self.itemId = itemId
27222 
    self.quantity = quantity
27223 
    self.fulfilmentWarehouseId = fulfilmentWarehouseId
27224 
    self.billingWarehouseId = billingWarehouseId
27225 
 
27226 
  def read(self, iprot):
27227 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27228 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27229 
      return
27230 
    iprot.readStructBegin()
27231 
    while True:
27232 
      (fname, ftype, fid) = iprot.readFieldBegin()
27233 
      if ftype == TType.STOP:
27234 
        break
27235 
      if fid == 1:
27236 
        if ftype == TType.I64:
27237 
          self.itemId = iprot.readI64();
27238 
        else:
27239 
          iprot.skip(ftype)
27240 
      elif fid == 2:
27241 
        if ftype == TType.I64:
27242 
          self.quantity = iprot.readI64();
27243 
        else:
27244 
          iprot.skip(ftype)
27245 
      elif fid == 3:
27246 
        if ftype == TType.I64:
27247 
          self.fulfilmentWarehouseId = iprot.readI64();
27248 
        else:
27249 
          iprot.skip(ftype)
27250 
      elif fid == 4:
27251 
        if ftype == TType.I64:
27252 
          self.billingWarehouseId = iprot.readI64();
27253 
        else:
27254 
          iprot.skip(ftype)
27255 
      else:
27256 
        iprot.skip(ftype)
27257 
      iprot.readFieldEnd()
27258 
    iprot.readStructEnd()
27259 
 
27260 
  def write(self, oprot):
27261 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27262 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27263 
      return
27264 
    oprot.writeStructBegin('acceptOrderForItem_args')
27265 
    if self.itemId is not None:
27266 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
27267 
      oprot.writeI64(self.itemId)
27268 
      oprot.writeFieldEnd()
27269 
    if self.quantity is not None:
27270 
      oprot.writeFieldBegin('quantity', TType.I64, 2)
27271 
      oprot.writeI64(self.quantity)
27272 
      oprot.writeFieldEnd()
27273 
    if self.fulfilmentWarehouseId is not None:
27274 
      oprot.writeFieldBegin('fulfilmentWarehouseId', TType.I64, 3)
27275 
      oprot.writeI64(self.fulfilmentWarehouseId)
27276 
      oprot.writeFieldEnd()
27277 
    if self.billingWarehouseId is not None:
27278 
      oprot.writeFieldBegin('billingWarehouseId', TType.I64, 4)
27279 
      oprot.writeI64(self.billingWarehouseId)
27280 
      oprot.writeFieldEnd()
27281 
    oprot.writeFieldStop()
27282 
    oprot.writeStructEnd()
27283 
 
27284 
  def validate(self):
27285 
    return
27286 
 
27287 
 
27288 
  def __repr__(self):
27289 
    L = ['%s=%r' % (key, value)
27290 
      for key, value in self.__dict__.iteritems()]
27291 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27292 
 
27293 
  def __eq__(self, other):
27294 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27295 
 
27296 
  def __ne__(self, other):
27297 
    return not (self == other)
27298 
 
27299 
class acceptOrderForItem_result:
27300 
 
27301 
  thrift_spec = (
27302 
  )
27303 
 
27304 
  def read(self, iprot):
27305 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27306 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27307 
      return
27308 
    iprot.readStructBegin()
27309 
    while True:
27310 
      (fname, ftype, fid) = iprot.readFieldBegin()
27311 
      if ftype == TType.STOP:
27312 
        break
27313 
      else:
27314 
        iprot.skip(ftype)
27315 
      iprot.readFieldEnd()
27316 
    iprot.readStructEnd()
27317 
 
27318 
  def write(self, oprot):
27319 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27320 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27321 
      return
27322 
    oprot.writeStructBegin('acceptOrderForItem_result')
27323 
    oprot.writeFieldStop()
27324 
    oprot.writeStructEnd()
27325 
 
27326 
  def validate(self):
27327 
    return
27328 
 
27329 
 
27330 
  def __repr__(self):
27331 
    L = ['%s=%r' % (key, value)
27332 
      for key, value in self.__dict__.iteritems()]
27333 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27334 
 
27335 
  def __eq__(self, other):
27336 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27337 
 
27338 
  def __ne__(self, other):
27339 
    return not (self == other)
6000 mandeep.dh 27340 
 
27341 
class createRechargeOrder_args:
27342 
  """
27343 
  Attributes:
27344 
   - rechargeOrder
27345 
  """
27346 
 
27347 
  thrift_spec = (
27348 
    None, # 0
27349 
    (1, TType.STRUCT, 'rechargeOrder', (RechargeOrder, RechargeOrder.thrift_spec), None, ), # 1
27350 
  )
27351 
 
27352 
  def __init__(self, rechargeOrder=None,):
27353 
    self.rechargeOrder = rechargeOrder
27354 
 
27355 
  def read(self, iprot):
27356 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27357 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27358 
      return
27359 
    iprot.readStructBegin()
27360 
    while True:
27361 
      (fname, ftype, fid) = iprot.readFieldBegin()
27362 
      if ftype == TType.STOP:
27363 
        break
27364 
      if fid == 1:
27365 
        if ftype == TType.STRUCT:
27366 
          self.rechargeOrder = RechargeOrder()
27367 
          self.rechargeOrder.read(iprot)
27368 
        else:
27369 
          iprot.skip(ftype)
27370 
      else:
27371 
        iprot.skip(ftype)
27372 
      iprot.readFieldEnd()
27373 
    iprot.readStructEnd()
27374 
 
27375 
  def write(self, oprot):
27376 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27377 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27378 
      return
27379 
    oprot.writeStructBegin('createRechargeOrder_args')
27380 
    if self.rechargeOrder is not None:
27381 
      oprot.writeFieldBegin('rechargeOrder', TType.STRUCT, 1)
27382 
      self.rechargeOrder.write(oprot)
27383 
      oprot.writeFieldEnd()
27384 
    oprot.writeFieldStop()
27385 
    oprot.writeStructEnd()
27386 
 
27387 
  def validate(self):
27388 
    return
27389 
 
27390 
 
27391 
  def __repr__(self):
27392 
    L = ['%s=%r' % (key, value)
27393 
      for key, value in self.__dict__.iteritems()]
27394 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27395 
 
27396 
  def __eq__(self, other):
27397 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27398 
 
27399 
  def __ne__(self, other):
27400 
    return not (self == other)
27401 
 
27402 
class createRechargeOrder_result:
27403 
  """
27404 
  Attributes:
27405 
   - success
27406 
   - ex
27407 
  """
27408 
 
27409 
  thrift_spec = (
27410 
    (0, TType.STRUCT, 'success', (RechargeOrder, RechargeOrder.thrift_spec), None, ), # 0
27411 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
27412 
  )
27413 
 
27414 
  def __init__(self, success=None, ex=None,):
27415 
    self.success = success
27416 
    self.ex = ex
27417 
 
27418 
  def read(self, iprot):
27419 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27420 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27421 
      return
27422 
    iprot.readStructBegin()
27423 
    while True:
27424 
      (fname, ftype, fid) = iprot.readFieldBegin()
27425 
      if ftype == TType.STOP:
27426 
        break
27427 
      if fid == 0:
27428 
        if ftype == TType.STRUCT:
27429 
          self.success = RechargeOrder()
27430 
          self.success.read(iprot)
27431 
        else:
27432 
          iprot.skip(ftype)
27433 
      elif fid == 1:
27434 
        if ftype == TType.STRUCT:
27435 
          self.ex = TransactionServiceException()
27436 
          self.ex.read(iprot)
27437 
        else:
27438 
          iprot.skip(ftype)
27439 
      else:
27440 
        iprot.skip(ftype)
27441 
      iprot.readFieldEnd()
27442 
    iprot.readStructEnd()
27443 
 
27444 
  def write(self, oprot):
27445 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27446 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27447 
      return
27448 
    oprot.writeStructBegin('createRechargeOrder_result')
27449 
    if self.success is not None:
27450 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
27451 
      self.success.write(oprot)
27452 
      oprot.writeFieldEnd()
27453 
    if self.ex is not None:
27454 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
27455 
      self.ex.write(oprot)
27456 
      oprot.writeFieldEnd()
27457 
    oprot.writeFieldStop()
27458 
    oprot.writeStructEnd()
27459 
 
27460 
  def validate(self):
27461 
    return
27462 
 
27463 
 
27464 
  def __repr__(self):
27465 
    L = ['%s=%r' % (key, value)
27466 
      for key, value in self.__dict__.iteritems()]
27467 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27468 
 
27469 
  def __eq__(self, other):
27470 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27471 
 
27472 
  def __ne__(self, other):
27473 
    return not (self == other)
27474 
 
6031 rajveer 27475 
class getRechargeOrder_args:
27476 
  """
27477 
  Attributes:
27478 
   - rechargeRrderId
27479 
  """
27480 
 
27481 
  thrift_spec = (
27482 
    None, # 0
27483 
    (1, TType.I64, 'rechargeRrderId', None, None, ), # 1
27484 
  )
27485 
 
27486 
  def __init__(self, rechargeRrderId=None,):
27487 
    self.rechargeRrderId = rechargeRrderId
27488 
 
27489 
  def read(self, iprot):
27490 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27491 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27492 
      return
27493 
    iprot.readStructBegin()
27494 
    while True:
27495 
      (fname, ftype, fid) = iprot.readFieldBegin()
27496 
      if ftype == TType.STOP:
27497 
        break
27498 
      if fid == 1:
27499 
        if ftype == TType.I64:
27500 
          self.rechargeRrderId = iprot.readI64();
27501 
        else:
27502 
          iprot.skip(ftype)
27503 
      else:
27504 
        iprot.skip(ftype)
27505 
      iprot.readFieldEnd()
27506 
    iprot.readStructEnd()
27507 
 
27508 
  def write(self, oprot):
27509 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27510 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27511 
      return
27512 
    oprot.writeStructBegin('getRechargeOrder_args')
27513 
    if self.rechargeRrderId is not None:
27514 
      oprot.writeFieldBegin('rechargeRrderId', TType.I64, 1)
27515 
      oprot.writeI64(self.rechargeRrderId)
27516 
      oprot.writeFieldEnd()
27517 
    oprot.writeFieldStop()
27518 
    oprot.writeStructEnd()
27519 
 
27520 
  def validate(self):
27521 
    return
27522 
 
27523 
 
27524 
  def __repr__(self):
27525 
    L = ['%s=%r' % (key, value)
27526 
      for key, value in self.__dict__.iteritems()]
27527 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27528 
 
27529 
  def __eq__(self, other):
27530 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27531 
 
27532 
  def __ne__(self, other):
27533 
    return not (self == other)
27534 
 
27535 
class getRechargeOrder_result:
27536 
  """
27537 
  Attributes:
27538 
   - success
27539 
   - ex
27540 
  """
27541 
 
27542 
  thrift_spec = (
27543 
    (0, TType.STRUCT, 'success', (RechargeOrder, RechargeOrder.thrift_spec), None, ), # 0
27544 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
27545 
  )
27546 
 
27547 
  def __init__(self, success=None, ex=None,):
27548 
    self.success = success
27549 
    self.ex = ex
27550 
 
27551 
  def read(self, iprot):
27552 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27553 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27554 
      return
27555 
    iprot.readStructBegin()
27556 
    while True:
27557 
      (fname, ftype, fid) = iprot.readFieldBegin()
27558 
      if ftype == TType.STOP:
27559 
        break
27560 
      if fid == 0:
27561 
        if ftype == TType.STRUCT:
27562 
          self.success = RechargeOrder()
27563 
          self.success.read(iprot)
27564 
        else:
27565 
          iprot.skip(ftype)
27566 
      elif fid == 1:
27567 
        if ftype == TType.STRUCT:
27568 
          self.ex = TransactionServiceException()
27569 
          self.ex.read(iprot)
27570 
        else:
27571 
          iprot.skip(ftype)
27572 
      else:
27573 
        iprot.skip(ftype)
27574 
      iprot.readFieldEnd()
27575 
    iprot.readStructEnd()
27576 
 
27577 
  def write(self, oprot):
27578 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27579 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27580 
      return
27581 
    oprot.writeStructBegin('getRechargeOrder_result')
27582 
    if self.success is not None:
27583 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
27584 
      self.success.write(oprot)
27585 
      oprot.writeFieldEnd()
27586 
    if self.ex is not None:
27587 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
27588 
      self.ex.write(oprot)
27589 
      oprot.writeFieldEnd()
27590 
    oprot.writeFieldStop()
27591 
    oprot.writeStructEnd()
27592 
 
27593 
  def validate(self):
27594 
    return
27595 
 
27596 
 
27597 
  def __repr__(self):
27598 
    L = ['%s=%r' % (key, value)
27599 
      for key, value in self.__dict__.iteritems()]
27600 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27601 
 
27602 
  def __eq__(self, other):
27603 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27604 
 
27605 
  def __ne__(self, other):
27606 
    return not (self == other)
27607 
 
27608 
class getRechargeOrders_args:
27609 
  """
27610 
  Attributes:
27611 
   - userId
27612 
  """
27613 
 
27614 
  thrift_spec = (
27615 
    None, # 0
27616 
    (1, TType.I64, 'userId', None, None, ), # 1
27617 
  )
27618 
 
27619 
  def __init__(self, userId=None,):
27620 
    self.userId = userId
27621 
 
27622 
  def read(self, iprot):
27623 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27624 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27625 
      return
27626 
    iprot.readStructBegin()
27627 
    while True:
27628 
      (fname, ftype, fid) = iprot.readFieldBegin()
27629 
      if ftype == TType.STOP:
27630 
        break
27631 
      if fid == 1:
27632 
        if ftype == TType.I64:
27633 
          self.userId = iprot.readI64();
27634 
        else:
27635 
          iprot.skip(ftype)
27636 
      else:
27637 
        iprot.skip(ftype)
27638 
      iprot.readFieldEnd()
27639 
    iprot.readStructEnd()
27640 
 
27641 
  def write(self, oprot):
27642 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27643 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27644 
      return
27645 
    oprot.writeStructBegin('getRechargeOrders_args')
27646 
    if self.userId is not None:
27647 
      oprot.writeFieldBegin('userId', TType.I64, 1)
27648 
      oprot.writeI64(self.userId)
27649 
      oprot.writeFieldEnd()
27650 
    oprot.writeFieldStop()
27651 
    oprot.writeStructEnd()
27652 
 
27653 
  def validate(self):
27654 
    return
27655 
 
27656 
 
27657 
  def __repr__(self):
27658 
    L = ['%s=%r' % (key, value)
27659 
      for key, value in self.__dict__.iteritems()]
27660 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27661 
 
27662 
  def __eq__(self, other):
27663 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27664 
 
27665 
  def __ne__(self, other):
27666 
    return not (self == other)
27667 
 
27668 
class getRechargeOrders_result:
27669 
  """
27670 
  Attributes:
27671 
   - success
27672 
  """
27673 
 
27674 
  thrift_spec = (
27675 
    (0, TType.LIST, 'success', (TType.STRUCT,(RechargeOrder, RechargeOrder.thrift_spec)), None, ), # 0
27676 
  )
27677 
 
27678 
  def __init__(self, success=None,):
27679 
    self.success = success
27680 
 
27681 
  def read(self, iprot):
27682 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27683 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27684 
      return
27685 
    iprot.readStructBegin()
27686 
    while True:
27687 
      (fname, ftype, fid) = iprot.readFieldBegin()
27688 
      if ftype == TType.STOP:
27689 
        break
27690 
      if fid == 0:
27691 
        if ftype == TType.LIST:
27692 
          self.success = []
6188 rajveer 27693 
          (_etype659, _size656) = iprot.readListBegin()
27694 
          for _i660 in xrange(_size656):
27695 
            _elem661 = RechargeOrder()
27696 
            _elem661.read(iprot)
27697 
            self.success.append(_elem661)
6031 rajveer 27698 
          iprot.readListEnd()
27699 
        else:
27700 
          iprot.skip(ftype)
27701 
      else:
27702 
        iprot.skip(ftype)
27703 
      iprot.readFieldEnd()
27704 
    iprot.readStructEnd()
27705 
 
27706 
  def write(self, oprot):
27707 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27708 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27709 
      return
27710 
    oprot.writeStructBegin('getRechargeOrders_result')
27711 
    if self.success is not None:
27712 
      oprot.writeFieldBegin('success', TType.LIST, 0)
27713 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 27714 
      for iter662 in self.success:
27715 
        iter662.write(oprot)
6031 rajveer 27716 
      oprot.writeListEnd()
27717 
      oprot.writeFieldEnd()
27718 
    oprot.writeFieldStop()
27719 
    oprot.writeStructEnd()
27720 
 
27721 
  def validate(self):
27722 
    return
27723 
 
27724 
 
27725 
  def __repr__(self):
27726 
    L = ['%s=%r' % (key, value)
27727 
      for key, value in self.__dict__.iteritems()]
27728 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27729 
 
27730 
  def __eq__(self, other):
27731 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27732 
 
27733 
  def __ne__(self, other):
27734 
    return not (self == other)
27735 
 
6000 mandeep.dh 27736 
class updateRechargeOrderStatus_args:
27737 
  """
27738 
  Attributes:
27739 
   - rechargeOrderId
27740 
   - rechargeOrderStatus
27741 
  """
27742 
 
27743 
  thrift_spec = (
27744 
    None, # 0
27745 
    (1, TType.I64, 'rechargeOrderId', None, None, ), # 1
27746 
    (2, TType.I32, 'rechargeOrderStatus', None, None, ), # 2
27747 
  )
27748 
 
27749 
  def __init__(self, rechargeOrderId=None, rechargeOrderStatus=None,):
27750 
    self.rechargeOrderId = rechargeOrderId
27751 
    self.rechargeOrderStatus = rechargeOrderStatus
27752 
 
27753 
  def read(self, iprot):
27754 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27755 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27756 
      return
27757 
    iprot.readStructBegin()
27758 
    while True:
27759 
      (fname, ftype, fid) = iprot.readFieldBegin()
27760 
      if ftype == TType.STOP:
27761 
        break
27762 
      if fid == 1:
27763 
        if ftype == TType.I64:
27764 
          self.rechargeOrderId = iprot.readI64();
27765 
        else:
27766 
          iprot.skip(ftype)
27767 
      elif fid == 2:
27768 
        if ftype == TType.I32:
27769 
          self.rechargeOrderStatus = iprot.readI32();
27770 
        else:
27771 
          iprot.skip(ftype)
27772 
      else:
27773 
        iprot.skip(ftype)
27774 
      iprot.readFieldEnd()
27775 
    iprot.readStructEnd()
27776 
 
27777 
  def write(self, oprot):
27778 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27779 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27780 
      return
27781 
    oprot.writeStructBegin('updateRechargeOrderStatus_args')
27782 
    if self.rechargeOrderId is not None:
27783 
      oprot.writeFieldBegin('rechargeOrderId', TType.I64, 1)
27784 
      oprot.writeI64(self.rechargeOrderId)
27785 
      oprot.writeFieldEnd()
27786 
    if self.rechargeOrderStatus is not None:
27787 
      oprot.writeFieldBegin('rechargeOrderStatus', TType.I32, 2)
27788 
      oprot.writeI32(self.rechargeOrderStatus)
27789 
      oprot.writeFieldEnd()
27790 
    oprot.writeFieldStop()
27791 
    oprot.writeStructEnd()
27792 
 
27793 
  def validate(self):
27794 
    return
27795 
 
27796 
 
27797 
  def __repr__(self):
27798 
    L = ['%s=%r' % (key, value)
27799 
      for key, value in self.__dict__.iteritems()]
27800 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27801 
 
27802 
  def __eq__(self, other):
27803 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27804 
 
27805 
  def __ne__(self, other):
27806 
    return not (self == other)
27807 
 
27808 
class updateRechargeOrderStatus_result:
27809 
  """
27810 
  Attributes:
6031 rajveer 27811 
   - success
6000 mandeep.dh 27812 
   - ex
27813 
  """
27814 
 
27815 
  thrift_spec = (
6031 rajveer 27816 
    (0, TType.BOOL, 'success', None, None, ), # 0
6000 mandeep.dh 27817 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
27818 
  )
27819 
 
6031 rajveer 27820 
  def __init__(self, success=None, ex=None,):
27821 
    self.success = success
6000 mandeep.dh 27822 
    self.ex = ex
27823 
 
27824 
  def read(self, iprot):
27825 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27826 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27827 
      return
27828 
    iprot.readStructBegin()
27829 
    while True:
27830 
      (fname, ftype, fid) = iprot.readFieldBegin()
27831 
      if ftype == TType.STOP:
27832 
        break
6031 rajveer 27833 
      if fid == 0:
27834 
        if ftype == TType.BOOL:
27835 
          self.success = iprot.readBool();
27836 
        else:
27837 
          iprot.skip(ftype)
27838 
      elif fid == 1:
6000 mandeep.dh 27839 
        if ftype == TType.STRUCT:
27840 
          self.ex = TransactionServiceException()
27841 
          self.ex.read(iprot)
27842 
        else:
27843 
          iprot.skip(ftype)
27844 
      else:
27845 
        iprot.skip(ftype)
27846 
      iprot.readFieldEnd()
27847 
    iprot.readStructEnd()
27848 
 
27849 
  def write(self, oprot):
27850 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27851 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27852 
      return
27853 
    oprot.writeStructBegin('updateRechargeOrderStatus_result')
6031 rajveer 27854 
    if self.success is not None:
27855 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
27856 
      oprot.writeBool(self.success)
27857 
      oprot.writeFieldEnd()
6000 mandeep.dh 27858 
    if self.ex is not None:
27859 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
27860 
      self.ex.write(oprot)
27861 
      oprot.writeFieldEnd()
27862 
    oprot.writeFieldStop()
27863 
    oprot.writeStructEnd()
27864 
 
27865 
  def validate(self):
27866 
    return
27867 
 
27868 
 
27869 
  def __repr__(self):
27870 
    L = ['%s=%r' % (key, value)
27871 
      for key, value in self.__dict__.iteritems()]
27872 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27873 
 
27874 
  def __eq__(self, other):
27875 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27876 
 
27877 
  def __ne__(self, other):
27878 
    return not (self == other)
27879 
 
27880 
class activateRechargeTxn_args:
27881 
  """
27882 
  Attributes:
6031 rajveer 27883 
   - rechargeOrderId
6000 mandeep.dh 27884 
  """
27885 
 
27886 
  thrift_spec = (
27887 
    None, # 0
6031 rajveer 27888 
    (1, TType.I64, 'rechargeOrderId', None, None, ), # 1
6000 mandeep.dh 27889 
  )
27890 
 
6031 rajveer 27891 
  def __init__(self, rechargeOrderId=None,):
27892 
    self.rechargeOrderId = rechargeOrderId
6000 mandeep.dh 27893 
 
27894 
  def read(self, iprot):
27895 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27896 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27897 
      return
27898 
    iprot.readStructBegin()
27899 
    while True:
27900 
      (fname, ftype, fid) = iprot.readFieldBegin()
27901 
      if ftype == TType.STOP:
27902 
        break
27903 
      if fid == 1:
6031 rajveer 27904 
        if ftype == TType.I64:
27905 
          self.rechargeOrderId = iprot.readI64();
6000 mandeep.dh 27906 
        else:
27907 
          iprot.skip(ftype)
27908 
      else:
27909 
        iprot.skip(ftype)
27910 
      iprot.readFieldEnd()
27911 
    iprot.readStructEnd()
27912 
 
27913 
  def write(self, oprot):
27914 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27915 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27916 
      return
27917 
    oprot.writeStructBegin('activateRechargeTxn_args')
6031 rajveer 27918 
    if self.rechargeOrderId is not None:
27919 
      oprot.writeFieldBegin('rechargeOrderId', TType.I64, 1)
27920 
      oprot.writeI64(self.rechargeOrderId)
6000 mandeep.dh 27921 
      oprot.writeFieldEnd()
27922 
    oprot.writeFieldStop()
27923 
    oprot.writeStructEnd()
27924 
 
27925 
  def validate(self):
27926 
    return
27927 
 
27928 
 
27929 
  def __repr__(self):
27930 
    L = ['%s=%r' % (key, value)
27931 
      for key, value in self.__dict__.iteritems()]
27932 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27933 
 
27934 
  def __eq__(self, other):
27935 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27936 
 
27937 
  def __ne__(self, other):
27938 
    return not (self == other)
27939 
 
27940 
class activateRechargeTxn_result:
27941 
  """
27942 
  Attributes:
27943 
   - success
27944 
   - ex
27945 
  """
27946 
 
27947 
  thrift_spec = (
6031 rajveer 27948 
    (0, TType.BOOL, 'success', None, None, ), # 0
6000 mandeep.dh 27949 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
27950 
  )
27951 
 
27952 
  def __init__(self, success=None, ex=None,):
27953 
    self.success = success
27954 
    self.ex = ex
27955 
 
27956 
  def read(self, iprot):
27957 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27958 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27959 
      return
27960 
    iprot.readStructBegin()
27961 
    while True:
27962 
      (fname, ftype, fid) = iprot.readFieldBegin()
27963 
      if ftype == TType.STOP:
27964 
        break
27965 
      if fid == 0:
6031 rajveer 27966 
        if ftype == TType.BOOL:
27967 
          self.success = iprot.readBool();
6000 mandeep.dh 27968 
        else:
27969 
          iprot.skip(ftype)
27970 
      elif fid == 1:
27971 
        if ftype == TType.STRUCT:
27972 
          self.ex = TransactionServiceException()
27973 
          self.ex.read(iprot)
27974 
        else:
27975 
          iprot.skip(ftype)
27976 
      else:
27977 
        iprot.skip(ftype)
27978 
      iprot.readFieldEnd()
27979 
    iprot.readStructEnd()
27980 
 
27981 
  def write(self, oprot):
27982 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27983 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27984 
      return
27985 
    oprot.writeStructBegin('activateRechargeTxn_result')
27986 
    if self.success is not None:
6031 rajveer 27987 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
27988 
      oprot.writeBool(self.success)
6000 mandeep.dh 27989 
      oprot.writeFieldEnd()
27990 
    if self.ex is not None:
27991 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
27992 
      self.ex.write(oprot)
27993 
      oprot.writeFieldEnd()
27994 
    oprot.writeFieldStop()
27995 
    oprot.writeStructEnd()
27996 
 
27997 
  def validate(self):
27998 
    return
27999 
 
28000 
 
28001 
  def __repr__(self):
28002 
    L = ['%s=%r' % (key, value)
28003 
      for key, value in self.__dict__.iteritems()]
28004 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28005 
 
28006 
  def __eq__(self, other):
28007 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28008 
 
28009 
  def __ne__(self, other):
28010 
    return not (self == other)
28011 
 
6031 rajveer 28012 
class getUserWallet_args:
6000 mandeep.dh 28013 
  """
28014 
  Attributes:
6031 rajveer 28015 
   - userId
6000 mandeep.dh 28016 
  """
28017 
 
28018 
  thrift_spec = (
28019 
    None, # 0
6031 rajveer 28020 
    (1, TType.I64, 'userId', None, None, ), # 1
6000 mandeep.dh 28021 
  )
28022 
 
6031 rajveer 28023 
  def __init__(self, userId=None,):
28024 
    self.userId = userId
6000 mandeep.dh 28025 
 
28026 
  def read(self, iprot):
28027 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28028 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28029 
      return
28030 
    iprot.readStructBegin()
28031 
    while True:
28032 
      (fname, ftype, fid) = iprot.readFieldBegin()
28033 
      if ftype == TType.STOP:
28034 
        break
28035 
      if fid == 1:
28036 
        if ftype == TType.I64:
6031 rajveer 28037 
          self.userId = iprot.readI64();
6000 mandeep.dh 28038 
        else:
28039 
          iprot.skip(ftype)
28040 
      else:
28041 
        iprot.skip(ftype)
28042 
      iprot.readFieldEnd()
28043 
    iprot.readStructEnd()
28044 
 
28045 
  def write(self, oprot):
28046 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28047 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28048 
      return
6031 rajveer 28049 
    oprot.writeStructBegin('getUserWallet_args')
28050 
    if self.userId is not None:
28051 
      oprot.writeFieldBegin('userId', TType.I64, 1)
28052 
      oprot.writeI64(self.userId)
6000 mandeep.dh 28053 
      oprot.writeFieldEnd()
28054 
    oprot.writeFieldStop()
28055 
    oprot.writeStructEnd()
28056 
 
28057 
  def validate(self):
28058 
    return
28059 
 
28060 
 
28061 
  def __repr__(self):
28062 
    L = ['%s=%r' % (key, value)
28063 
      for key, value in self.__dict__.iteritems()]
28064 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28065 
 
28066 
  def __eq__(self, other):
28067 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28068 
 
28069 
  def __ne__(self, other):
28070 
    return not (self == other)
28071 
 
6031 rajveer 28072 
class getUserWallet_result:
6000 mandeep.dh 28073 
  """
28074 
  Attributes:
28075 
   - success
28076 
  """
28077 
 
28078 
  thrift_spec = (
6031 rajveer 28079 
    (0, TType.STRUCT, 'success', (UserWallet, UserWallet.thrift_spec), None, ), # 0
6000 mandeep.dh 28080 
  )
28081 
 
28082 
  def __init__(self, success=None,):
28083 
    self.success = success
28084 
 
28085 
  def read(self, iprot):
28086 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28087 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28088 
      return
28089 
    iprot.readStructBegin()
28090 
    while True:
28091 
      (fname, ftype, fid) = iprot.readFieldBegin()
28092 
      if ftype == TType.STOP:
28093 
        break
28094 
      if fid == 0:
6031 rajveer 28095 
        if ftype == TType.STRUCT:
28096 
          self.success = UserWallet()
28097 
          self.success.read(iprot)
6000 mandeep.dh 28098 
        else:
28099 
          iprot.skip(ftype)
28100 
      else:
28101 
        iprot.skip(ftype)
28102 
      iprot.readFieldEnd()
28103 
    iprot.readStructEnd()
28104 
 
28105 
  def write(self, oprot):
28106 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28107 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28108 
      return
6031 rajveer 28109 
    oprot.writeStructBegin('getUserWallet_result')
6000 mandeep.dh 28110 
    if self.success is not None:
6031 rajveer 28111 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
28112 
      self.success.write(oprot)
6000 mandeep.dh 28113 
      oprot.writeFieldEnd()
28114 
    oprot.writeFieldStop()
28115 
    oprot.writeStructEnd()
28116 
 
28117 
  def validate(self):
28118 
    return
28119 
 
28120 
 
28121 
  def __repr__(self):
28122 
    L = ['%s=%r' % (key, value)
28123 
      for key, value in self.__dict__.iteritems()]
28124 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28125 
 
28126 
  def __eq__(self, other):
28127 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28128 
 
28129 
  def __ne__(self, other):
28130 
    return not (self == other)
28131 
 
6031 rajveer 28132 
class getUserWalletHistory_args:
6000 mandeep.dh 28133 
  """
28134 
  Attributes:
6031 rajveer 28135 
   - userId
6000 mandeep.dh 28136 
  """
28137 
 
28138 
  thrift_spec = (
28139 
    None, # 0
6031 rajveer 28140 
    (1, TType.I64, 'userId', None, None, ), # 1
6000 mandeep.dh 28141 
  )
28142 
 
6031 rajveer 28143 
  def __init__(self, userId=None,):
28144 
    self.userId = userId
6000 mandeep.dh 28145 
 
28146 
  def read(self, iprot):
28147 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28148 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28149 
      return
28150 
    iprot.readStructBegin()
28151 
    while True:
28152 
      (fname, ftype, fid) = iprot.readFieldBegin()
28153 
      if ftype == TType.STOP:
28154 
        break
28155 
      if fid == 1:
28156 
        if ftype == TType.I64:
6031 rajveer 28157 
          self.userId = iprot.readI64();
6000 mandeep.dh 28158 
        else:
28159 
          iprot.skip(ftype)
28160 
      else:
28161 
        iprot.skip(ftype)
28162 
      iprot.readFieldEnd()
28163 
    iprot.readStructEnd()
28164 
 
28165 
  def write(self, oprot):
28166 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28167 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28168 
      return
6031 rajveer 28169 
    oprot.writeStructBegin('getUserWalletHistory_args')
28170 
    if self.userId is not None:
28171 
      oprot.writeFieldBegin('userId', TType.I64, 1)
28172 
      oprot.writeI64(self.userId)
6000 mandeep.dh 28173 
      oprot.writeFieldEnd()
28174 
    oprot.writeFieldStop()
28175 
    oprot.writeStructEnd()
28176 
 
28177 
  def validate(self):
28178 
    return
28179 
 
28180 
 
28181 
  def __repr__(self):
28182 
    L = ['%s=%r' % (key, value)
28183 
      for key, value in self.__dict__.iteritems()]
28184 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28185 
 
28186 
  def __eq__(self, other):
28187 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28188 
 
28189 
  def __ne__(self, other):
28190 
    return not (self == other)
28191 
 
6031 rajveer 28192 
class getUserWalletHistory_result:
6000 mandeep.dh 28193 
  """
28194 
  Attributes:
28195 
   - success
28196 
  """
28197 
 
28198 
  thrift_spec = (
6031 rajveer 28199 
    (0, TType.LIST, 'success', (TType.STRUCT,(UserWalletHistory, UserWalletHistory.thrift_spec)), None, ), # 0
6000 mandeep.dh 28200 
  )
28201 
 
28202 
  def __init__(self, success=None,):
28203 
    self.success = success
28204 
 
28205 
  def read(self, iprot):
28206 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28207 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28208 
      return
28209 
    iprot.readStructBegin()
28210 
    while True:
28211 
      (fname, ftype, fid) = iprot.readFieldBegin()
28212 
      if ftype == TType.STOP:
28213 
        break
28214 
      if fid == 0:
28215 
        if ftype == TType.LIST:
28216 
          self.success = []
6188 rajveer 28217 
          (_etype666, _size663) = iprot.readListBegin()
28218 
          for _i667 in xrange(_size663):
28219 
            _elem668 = UserWalletHistory()
28220 
            _elem668.read(iprot)
28221 
            self.success.append(_elem668)
6000 mandeep.dh 28222 
          iprot.readListEnd()
28223 
        else:
28224 
          iprot.skip(ftype)
28225 
      else:
28226 
        iprot.skip(ftype)
28227 
      iprot.readFieldEnd()
28228 
    iprot.readStructEnd()
28229 
 
28230 
  def write(self, oprot):
28231 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28232 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28233 
      return
6031 rajveer 28234 
    oprot.writeStructBegin('getUserWalletHistory_result')
6000 mandeep.dh 28235 
    if self.success is not None:
28236 
      oprot.writeFieldBegin('success', TType.LIST, 0)
28237 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 28238 
      for iter669 in self.success:
28239 
        iter669.write(oprot)
6000 mandeep.dh 28240 
      oprot.writeListEnd()
28241 
      oprot.writeFieldEnd()
28242 
    oprot.writeFieldStop()
28243 
    oprot.writeStructEnd()
28244 
 
28245 
  def validate(self):
28246 
    return
28247 
 
28248 
 
28249 
  def __repr__(self):
28250 
    L = ['%s=%r' % (key, value)
28251 
      for key, value in self.__dict__.iteritems()]
28252 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28253 
 
28254 
  def __eq__(self, other):
28255 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28256 
 
28257 
  def __ne__(self, other):
28258 
    return not (self == other)
6048 rajveer 28259 
 
6050 anupam.sin 28260 
class getRechargeOrdersForTransaction_args:
28261 
  """
28262 
  Attributes:
28263 
   - txnId
28264 
  """
28265 
 
28266 
  thrift_spec = (
28267 
    None, # 0
28268 
    (1, TType.I64, 'txnId', None, None, ), # 1
28269 
  )
28270 
 
28271 
  def __init__(self, txnId=None,):
28272 
    self.txnId = txnId
28273 
 
28274 
  def read(self, iprot):
28275 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28276 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28277 
      return
28278 
    iprot.readStructBegin()
28279 
    while True:
28280 
      (fname, ftype, fid) = iprot.readFieldBegin()
28281 
      if ftype == TType.STOP:
28282 
        break
28283 
      if fid == 1:
28284 
        if ftype == TType.I64:
28285 
          self.txnId = iprot.readI64();
28286 
        else:
28287 
          iprot.skip(ftype)
28288 
      else:
28289 
        iprot.skip(ftype)
28290 
      iprot.readFieldEnd()
28291 
    iprot.readStructEnd()
28292 
 
28293 
  def write(self, oprot):
28294 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28295 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28296 
      return
28297 
    oprot.writeStructBegin('getRechargeOrdersForTransaction_args')
28298 
    if self.txnId is not None:
28299 
      oprot.writeFieldBegin('txnId', TType.I64, 1)
28300 
      oprot.writeI64(self.txnId)
28301 
      oprot.writeFieldEnd()
28302 
    oprot.writeFieldStop()
28303 
    oprot.writeStructEnd()
28304 
 
28305 
  def validate(self):
28306 
    return
28307 
 
28308 
 
28309 
  def __repr__(self):
28310 
    L = ['%s=%r' % (key, value)
28311 
      for key, value in self.__dict__.iteritems()]
28312 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28313 
 
28314 
  def __eq__(self, other):
28315 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28316 
 
28317 
  def __ne__(self, other):
28318 
    return not (self == other)
28319 
 
28320 
class getRechargeOrdersForTransaction_result:
28321 
  """
28322 
  Attributes:
28323 
   - success
28324 
   - ex
28325 
  """
28326 
 
28327 
  thrift_spec = (
28328 
    (0, TType.STRUCT, 'success', (RechargeOrder, RechargeOrder.thrift_spec), None, ), # 0
28329 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
28330 
  )
28331 
 
28332 
  def __init__(self, success=None, ex=None,):
28333 
    self.success = success
28334 
    self.ex = ex
28335 
 
28336 
  def read(self, iprot):
28337 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28338 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28339 
      return
28340 
    iprot.readStructBegin()
28341 
    while True:
28342 
      (fname, ftype, fid) = iprot.readFieldBegin()
28343 
      if ftype == TType.STOP:
28344 
        break
28345 
      if fid == 0:
28346 
        if ftype == TType.STRUCT:
28347 
          self.success = RechargeOrder()
28348 
          self.success.read(iprot)
28349 
        else:
28350 
          iprot.skip(ftype)
28351 
      elif fid == 1:
28352 
        if ftype == TType.STRUCT:
28353 
          self.ex = TransactionServiceException()
28354 
          self.ex.read(iprot)
28355 
        else:
28356 
          iprot.skip(ftype)
28357 
      else:
28358 
        iprot.skip(ftype)
28359 
      iprot.readFieldEnd()
28360 
    iprot.readStructEnd()
28361 
 
28362 
  def write(self, oprot):
28363 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28364 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28365 
      return
28366 
    oprot.writeStructBegin('getRechargeOrdersForTransaction_result')
28367 
    if self.success is not None:
28368 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
28369 
      self.success.write(oprot)
28370 
      oprot.writeFieldEnd()
28371 
    if self.ex is not None:
28372 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
28373 
      self.ex.write(oprot)
28374 
      oprot.writeFieldEnd()
28375 
    oprot.writeFieldStop()
28376 
    oprot.writeStructEnd()
28377 
 
28378 
  def validate(self):
28379 
    return
28380 
 
28381 
 
28382 
  def __repr__(self):
28383 
    L = ['%s=%r' % (key, value)
28384 
      for key, value in self.__dict__.iteritems()]
28385 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28386 
 
28387 
  def __eq__(self, other):
28388 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28389 
 
28390 
  def __ne__(self, other):
28391 
    return not (self == other)
28392 
 
6048 rajveer 28393 
class getServiceProviders_args:
28394 
  """
28395 
  Attributes:
28396 
   - rechargeType
6206 rajveer 28397 
   - onlyActive
6048 rajveer 28398 
  """
28399 
 
28400 
  thrift_spec = (
28401 
    None, # 0
28402 
    (1, TType.I32, 'rechargeType', None, None, ), # 1
6206 rajveer 28403 
    (2, TType.BOOL, 'onlyActive', None, None, ), # 2
6048 rajveer 28404 
  )
28405 
 
6206 rajveer 28406 
  def __init__(self, rechargeType=None, onlyActive=None,):
6048 rajveer 28407 
    self.rechargeType = rechargeType
6206 rajveer 28408 
    self.onlyActive = onlyActive
6048 rajveer 28409 
 
28410 
  def read(self, iprot):
28411 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28412 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28413 
      return
28414 
    iprot.readStructBegin()
28415 
    while True:
28416 
      (fname, ftype, fid) = iprot.readFieldBegin()
28417 
      if ftype == TType.STOP:
28418 
        break
28419 
      if fid == 1:
28420 
        if ftype == TType.I32:
28421 
          self.rechargeType = iprot.readI32();
28422 
        else:
28423 
          iprot.skip(ftype)
6206 rajveer 28424 
      elif fid == 2:
28425 
        if ftype == TType.BOOL:
28426 
          self.onlyActive = iprot.readBool();
28427 
        else:
28428 
          iprot.skip(ftype)
6048 rajveer 28429 
      else:
28430 
        iprot.skip(ftype)
28431 
      iprot.readFieldEnd()
28432 
    iprot.readStructEnd()
28433 
 
28434 
  def write(self, oprot):
28435 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28436 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28437 
      return
28438 
    oprot.writeStructBegin('getServiceProviders_args')
28439 
    if self.rechargeType is not None:
28440 
      oprot.writeFieldBegin('rechargeType', TType.I32, 1)
28441 
      oprot.writeI32(self.rechargeType)
28442 
      oprot.writeFieldEnd()
6206 rajveer 28443 
    if self.onlyActive is not None:
28444 
      oprot.writeFieldBegin('onlyActive', TType.BOOL, 2)
28445 
      oprot.writeBool(self.onlyActive)
28446 
      oprot.writeFieldEnd()
6048 rajveer 28447 
    oprot.writeFieldStop()
28448 
    oprot.writeStructEnd()
28449 
 
28450 
  def validate(self):
28451 
    return
28452 
 
28453 
 
28454 
  def __repr__(self):
28455 
    L = ['%s=%r' % (key, value)
28456 
      for key, value in self.__dict__.iteritems()]
28457 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28458 
 
28459 
  def __eq__(self, other):
28460 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28461 
 
28462 
  def __ne__(self, other):
28463 
    return not (self == other)
28464 
 
28465 
class getServiceProviders_result:
28466 
  """
28467 
  Attributes:
28468 
   - success
28469 
  """
28470 
 
28471 
  thrift_spec = (
28472 
    (0, TType.MAP, 'success', (TType.I64,None,TType.STRING,None), None, ), # 0
28473 
  )
28474 
 
28475 
  def __init__(self, success=None,):
28476 
    self.success = success
28477 
 
28478 
  def read(self, iprot):
28479 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28480 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28481 
      return
28482 
    iprot.readStructBegin()
28483 
    while True:
28484 
      (fname, ftype, fid) = iprot.readFieldBegin()
28485 
      if ftype == TType.STOP:
28486 
        break
28487 
      if fid == 0:
28488 
        if ftype == TType.MAP:
28489 
          self.success = {}
6188 rajveer 28490 
          (_ktype671, _vtype672, _size670 ) = iprot.readMapBegin()
28491 
          for _i674 in xrange(_size670):
28492 
            _key675 = iprot.readI64();
28493 
            _val676 = iprot.readString();
28494 
            self.success[_key675] = _val676
6048 rajveer 28495 
          iprot.readMapEnd()
28496 
        else:
28497 
          iprot.skip(ftype)
28498 
      else:
28499 
        iprot.skip(ftype)
28500 
      iprot.readFieldEnd()
28501 
    iprot.readStructEnd()
28502 
 
28503 
  def write(self, oprot):
28504 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28505 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28506 
      return
28507 
    oprot.writeStructBegin('getServiceProviders_result')
28508 
    if self.success is not None:
28509 
      oprot.writeFieldBegin('success', TType.MAP, 0)
28510 
      oprot.writeMapBegin(TType.I64, TType.STRING, len(self.success))
6188 rajveer 28511 
      for kiter677,viter678 in self.success.items():
28512 
        oprot.writeI64(kiter677)
28513 
        oprot.writeString(viter678)
6048 rajveer 28514 
      oprot.writeMapEnd()
28515 
      oprot.writeFieldEnd()
28516 
    oprot.writeFieldStop()
28517 
    oprot.writeStructEnd()
28518 
 
28519 
  def validate(self):
28520 
    return
28521 
 
28522 
 
28523 
  def __repr__(self):
28524 
    L = ['%s=%r' % (key, value)
28525 
      for key, value in self.__dict__.iteritems()]
28526 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28527 
 
28528 
  def __eq__(self, other):
28529 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28530 
 
28531 
  def __ne__(self, other):
28532 
    return not (self == other)
28533 
 
28534 
class getServiceProviderForDevice_args:
28535 
  """
28536 
  Attributes:
6049 rajveer 28537 
   - rechargeType
6048 rajveer 28538 
   - deviceNumber
28539 
  """
28540 
 
28541 
  thrift_spec = (
28542 
    None, # 0
6049 rajveer 28543 
    (1, TType.I32, 'rechargeType', None, None, ), # 1
28544 
    (2, TType.STRING, 'deviceNumber', None, None, ), # 2
6048 rajveer 28545 
  )
28546 
 
6049 rajveer 28547 
  def __init__(self, rechargeType=None, deviceNumber=None,):
28548 
    self.rechargeType = rechargeType
6048 rajveer 28549 
    self.deviceNumber = deviceNumber
28550 
 
28551 
  def read(self, iprot):
28552 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28553 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28554 
      return
28555 
    iprot.readStructBegin()
28556 
    while True:
28557 
      (fname, ftype, fid) = iprot.readFieldBegin()
28558 
      if ftype == TType.STOP:
28559 
        break
28560 
      if fid == 1:
6049 rajveer 28561 
        if ftype == TType.I32:
28562 
          self.rechargeType = iprot.readI32();
28563 
        else:
28564 
          iprot.skip(ftype)
28565 
      elif fid == 2:
6048 rajveer 28566 
        if ftype == TType.STRING:
28567 
          self.deviceNumber = iprot.readString();
28568 
        else:
28569 
          iprot.skip(ftype)
28570 
      else:
28571 
        iprot.skip(ftype)
28572 
      iprot.readFieldEnd()
28573 
    iprot.readStructEnd()
28574 
 
28575 
  def write(self, oprot):
28576 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28577 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28578 
      return
28579 
    oprot.writeStructBegin('getServiceProviderForDevice_args')
6049 rajveer 28580 
    if self.rechargeType is not None:
28581 
      oprot.writeFieldBegin('rechargeType', TType.I32, 1)
28582 
      oprot.writeI32(self.rechargeType)
28583 
      oprot.writeFieldEnd()
6048 rajveer 28584 
    if self.deviceNumber is not None:
6049 rajveer 28585 
      oprot.writeFieldBegin('deviceNumber', TType.STRING, 2)
6048 rajveer 28586 
      oprot.writeString(self.deviceNumber)
28587 
      oprot.writeFieldEnd()
28588 
    oprot.writeFieldStop()
28589 
    oprot.writeStructEnd()
28590 
 
28591 
  def validate(self):
28592 
    return
28593 
 
28594 
 
28595 
  def __repr__(self):
28596 
    L = ['%s=%r' % (key, value)
28597 
      for key, value in self.__dict__.iteritems()]
28598 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28599 
 
28600 
  def __eq__(self, other):
28601 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28602 
 
28603 
  def __ne__(self, other):
28604 
    return not (self == other)
28605 
 
28606 
class getServiceProviderForDevice_result:
28607 
  """
28608 
  Attributes:
28609 
   - success
28610 
  """
28611 
 
28612 
  thrift_spec = (
6289 anupam.sin 28613 
    (0, TType.STRUCT, 'success', (DeviceNumberInfo, DeviceNumberInfo.thrift_spec), None, ), # 0
6048 rajveer 28614 
  )
28615 
 
28616 
  def __init__(self, success=None,):
28617 
    self.success = success
28618 
 
28619 
  def read(self, iprot):
28620 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28621 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28622 
      return
28623 
    iprot.readStructBegin()
28624 
    while True:
28625 
      (fname, ftype, fid) = iprot.readFieldBegin()
28626 
      if ftype == TType.STOP:
28627 
        break
28628 
      if fid == 0:
6289 anupam.sin 28629 
        if ftype == TType.STRUCT:
28630 
          self.success = DeviceNumberInfo()
28631 
          self.success.read(iprot)
6048 rajveer 28632 
        else:
28633 
          iprot.skip(ftype)
28634 
      else:
28635 
        iprot.skip(ftype)
28636 
      iprot.readFieldEnd()
28637 
    iprot.readStructEnd()
28638 
 
28639 
  def write(self, oprot):
28640 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28641 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28642 
      return
28643 
    oprot.writeStructBegin('getServiceProviderForDevice_result')
28644 
    if self.success is not None:
6289 anupam.sin 28645 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
28646 
      self.success.write(oprot)
6048 rajveer 28647 
      oprot.writeFieldEnd()
28648 
    oprot.writeFieldStop()
28649 
    oprot.writeStructEnd()
28650 
 
28651 
  def validate(self):
28652 
    return
28653 
 
28654 
 
28655 
  def __repr__(self):
28656 
    L = ['%s=%r' % (key, value)
28657 
      for key, value in self.__dict__.iteritems()]
28658 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28659 
 
28660 
  def __eq__(self, other):
28661 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28662 
 
28663 
  def __ne__(self, other):
28664 
    return not (self == other)
6094 rajveer 28665 
 
6269 rajveer 28666 
class validateRecharge_args:
28667 
  """
28668 
  Attributes:
28669 
   - rechargeType
28670 
   - deviceNumber
6307 anupam.sin 28671 
   - userSelectedProviderId
6591 anupam.sin 28672 
   - clientAddress
6269 rajveer 28673 
  """
28674 
 
28675 
  thrift_spec = (
28676 
    None, # 0
28677 
    (1, TType.I32, 'rechargeType', None, None, ), # 1
28678 
    (2, TType.STRING, 'deviceNumber', None, None, ), # 2
6336 anupam.sin 28679 
    (3, TType.I64, 'userSelectedProviderId', None, None, ), # 3
6591 anupam.sin 28680 
    (4, TType.STRING, 'clientAddress', None, None, ), # 4
6269 rajveer 28681 
  )
28682 
 
6591 anupam.sin 28683 
  def __init__(self, rechargeType=None, deviceNumber=None, userSelectedProviderId=None, clientAddress=None,):
6269 rajveer 28684 
    self.rechargeType = rechargeType
28685 
    self.deviceNumber = deviceNumber
6307 anupam.sin 28686 
    self.userSelectedProviderId = userSelectedProviderId
6591 anupam.sin 28687 
    self.clientAddress = clientAddress
6269 rajveer 28688 
 
28689 
  def read(self, iprot):
28690 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28691 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28692 
      return
28693 
    iprot.readStructBegin()
28694 
    while True:
28695 
      (fname, ftype, fid) = iprot.readFieldBegin()
28696 
      if ftype == TType.STOP:
28697 
        break
28698 
      if fid == 1:
28699 
        if ftype == TType.I32:
28700 
          self.rechargeType = iprot.readI32();
28701 
        else:
28702 
          iprot.skip(ftype)
28703 
      elif fid == 2:
28704 
        if ftype == TType.STRING:
28705 
          self.deviceNumber = iprot.readString();
28706 
        else:
28707 
          iprot.skip(ftype)
6307 anupam.sin 28708 
      elif fid == 3:
28709 
        if ftype == TType.I64:
28710 
          self.userSelectedProviderId = iprot.readI64();
28711 
        else:
28712 
          iprot.skip(ftype)
6591 anupam.sin 28713 
      elif fid == 4:
28714 
        if ftype == TType.STRING:
28715 
          self.clientAddress = iprot.readString();
28716 
        else:
28717 
          iprot.skip(ftype)
6269 rajveer 28718 
      else:
28719 
        iprot.skip(ftype)
28720 
      iprot.readFieldEnd()
28721 
    iprot.readStructEnd()
28722 
 
28723 
  def write(self, oprot):
28724 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28725 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28726 
      return
28727 
    oprot.writeStructBegin('validateRecharge_args')
28728 
    if self.rechargeType is not None:
28729 
      oprot.writeFieldBegin('rechargeType', TType.I32, 1)
28730 
      oprot.writeI32(self.rechargeType)
28731 
      oprot.writeFieldEnd()
28732 
    if self.deviceNumber is not None:
28733 
      oprot.writeFieldBegin('deviceNumber', TType.STRING, 2)
28734 
      oprot.writeString(self.deviceNumber)
28735 
      oprot.writeFieldEnd()
6307 anupam.sin 28736 
    if self.userSelectedProviderId is not None:
6336 anupam.sin 28737 
      oprot.writeFieldBegin('userSelectedProviderId', TType.I64, 3)
6307 anupam.sin 28738 
      oprot.writeI64(self.userSelectedProviderId)
28739 
      oprot.writeFieldEnd()
6591 anupam.sin 28740 
    if self.clientAddress is not None:
28741 
      oprot.writeFieldBegin('clientAddress', TType.STRING, 4)
28742 
      oprot.writeString(self.clientAddress)
28743 
      oprot.writeFieldEnd()
6269 rajveer 28744 
    oprot.writeFieldStop()
28745 
    oprot.writeStructEnd()
28746 
 
28747 
  def validate(self):
28748 
    return
28749 
 
28750 
 
28751 
  def __repr__(self):
28752 
    L = ['%s=%r' % (key, value)
28753 
      for key, value in self.__dict__.iteritems()]
28754 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28755 
 
28756 
  def __eq__(self, other):
28757 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28758 
 
28759 
  def __ne__(self, other):
28760 
    return not (self == other)
28761 
 
28762 
class validateRecharge_result:
28763 
  """
28764 
  Attributes:
28765 
   - success
28766 
  """
28767 
 
28768 
  thrift_spec = (
28769 
    (0, TType.STRING, 'success', None, None, ), # 0
28770 
  )
28771 
 
28772 
  def __init__(self, success=None,):
28773 
    self.success = success
28774 
 
28775 
  def read(self, iprot):
28776 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28777 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28778 
      return
28779 
    iprot.readStructBegin()
28780 
    while True:
28781 
      (fname, ftype, fid) = iprot.readFieldBegin()
28782 
      if ftype == TType.STOP:
28783 
        break
28784 
      if fid == 0:
28785 
        if ftype == TType.STRING:
28786 
          self.success = iprot.readString();
28787 
        else:
28788 
          iprot.skip(ftype)
28789 
      else:
28790 
        iprot.skip(ftype)
28791 
      iprot.readFieldEnd()
28792 
    iprot.readStructEnd()
28793 
 
28794 
  def write(self, oprot):
28795 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28796 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28797 
      return
28798 
    oprot.writeStructBegin('validateRecharge_result')
28799 
    if self.success is not None:
28800 
      oprot.writeFieldBegin('success', TType.STRING, 0)
28801 
      oprot.writeString(self.success)
28802 
      oprot.writeFieldEnd()
28803 
    oprot.writeFieldStop()
28804 
    oprot.writeStructEnd()
28805 
 
28806 
  def validate(self):
28807 
    return
28808 
 
28809 
 
28810 
  def __repr__(self):
28811 
    L = ['%s=%r' % (key, value)
28812 
      for key, value in self.__dict__.iteritems()]
28813 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28814 
 
28815 
  def __eq__(self, other):
28816 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28817 
 
28818 
  def __ne__(self, other):
28819 
    return not (self == other)
28820 
 
6094 rajveer 28821 
class getRechargeOrdersForDevice_args:
28822 
  """
28823 
  Attributes:
28824 
   - deviceNumber
28825 
  """
28826 
 
28827 
  thrift_spec = (
28828 
    None, # 0
28829 
    (1, TType.STRING, 'deviceNumber', None, None, ), # 1
28830 
  )
28831 
 
28832 
  def __init__(self, deviceNumber=None,):
28833 
    self.deviceNumber = deviceNumber
28834 
 
28835 
  def read(self, iprot):
28836 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28837 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28838 
      return
28839 
    iprot.readStructBegin()
28840 
    while True:
28841 
      (fname, ftype, fid) = iprot.readFieldBegin()
28842 
      if ftype == TType.STOP:
28843 
        break
28844 
      if fid == 1:
28845 
        if ftype == TType.STRING:
28846 
          self.deviceNumber = iprot.readString();
28847 
        else:
28848 
          iprot.skip(ftype)
28849 
      else:
28850 
        iprot.skip(ftype)
28851 
      iprot.readFieldEnd()
28852 
    iprot.readStructEnd()
28853 
 
28854 
  def write(self, oprot):
28855 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28856 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28857 
      return
28858 
    oprot.writeStructBegin('getRechargeOrdersForDevice_args')
28859 
    if self.deviceNumber is not None:
28860 
      oprot.writeFieldBegin('deviceNumber', TType.STRING, 1)
28861 
      oprot.writeString(self.deviceNumber)
28862 
      oprot.writeFieldEnd()
28863 
    oprot.writeFieldStop()
28864 
    oprot.writeStructEnd()
28865 
 
28866 
  def validate(self):
28867 
    return
28868 
 
28869 
 
28870 
  def __repr__(self):
28871 
    L = ['%s=%r' % (key, value)
28872 
      for key, value in self.__dict__.iteritems()]
28873 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28874 
 
28875 
  def __eq__(self, other):
28876 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28877 
 
28878 
  def __ne__(self, other):
28879 
    return not (self == other)
28880 
 
28881 
class getRechargeOrdersForDevice_result:
28882 
  """
28883 
  Attributes:
28884 
   - success
28885 
  """
28886 
 
28887 
  thrift_spec = (
28888 
    (0, TType.LIST, 'success', (TType.STRUCT,(RechargeOrder, RechargeOrder.thrift_spec)), None, ), # 0
28889 
  )
28890 
 
28891 
  def __init__(self, success=None,):
28892 
    self.success = success
28893 
 
28894 
  def read(self, iprot):
28895 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28896 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28897 
      return
28898 
    iprot.readStructBegin()
28899 
    while True:
28900 
      (fname, ftype, fid) = iprot.readFieldBegin()
28901 
      if ftype == TType.STOP:
28902 
        break
28903 
      if fid == 0:
28904 
        if ftype == TType.LIST:
28905 
          self.success = []
6188 rajveer 28906 
          (_etype682, _size679) = iprot.readListBegin()
28907 
          for _i683 in xrange(_size679):
28908 
            _elem684 = RechargeOrder()
28909 
            _elem684.read(iprot)
28910 
            self.success.append(_elem684)
6094 rajveer 28911 
          iprot.readListEnd()
28912 
        else:
28913 
          iprot.skip(ftype)
28914 
      else:
28915 
        iprot.skip(ftype)
28916 
      iprot.readFieldEnd()
28917 
    iprot.readStructEnd()
28918 
 
28919 
  def write(self, oprot):
28920 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28921 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28922 
      return
28923 
    oprot.writeStructBegin('getRechargeOrdersForDevice_result')
28924 
    if self.success is not None:
28925 
      oprot.writeFieldBegin('success', TType.LIST, 0)
28926 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 28927 
      for iter685 in self.success:
28928 
        iter685.write(oprot)
6094 rajveer 28929 
      oprot.writeListEnd()
28930 
      oprot.writeFieldEnd()
28931 
    oprot.writeFieldStop()
28932 
    oprot.writeStructEnd()
28933 
 
28934 
  def validate(self):
28935 
    return
28936 
 
28937 
 
28938 
  def __repr__(self):
28939 
    L = ['%s=%r' % (key, value)
28940 
      for key, value in self.__dict__.iteritems()]
28941 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28942 
 
28943 
  def __eq__(self, other):
28944 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28945 
 
28946 
  def __ne__(self, other):
28947 
    return not (self == other)
28948 
 
28949 
class addAmountToWallet_args:
28950 
  """
28951 
  Attributes:
28952 
   - userId
28953 
   - orderId
28954 
   - amount
28955 
  """
28956 
 
28957 
  thrift_spec = (
28958 
    None, # 0
28959 
    (1, TType.I64, 'userId', None, None, ), # 1
28960 
    (2, TType.I64, 'orderId', None, None, ), # 2
28961 
    (3, TType.I64, 'amount', None, None, ), # 3
28962 
  )
28963 
 
28964 
  def __init__(self, userId=None, orderId=None, amount=None,):
28965 
    self.userId = userId
28966 
    self.orderId = orderId
28967 
    self.amount = amount
28968 
 
28969 
  def read(self, iprot):
28970 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28971 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28972 
      return
28973 
    iprot.readStructBegin()
28974 
    while True:
28975 
      (fname, ftype, fid) = iprot.readFieldBegin()
28976 
      if ftype == TType.STOP:
28977 
        break
28978 
      if fid == 1:
28979 
        if ftype == TType.I64:
28980 
          self.userId = iprot.readI64();
28981 
        else:
28982 
          iprot.skip(ftype)
28983 
      elif fid == 2:
28984 
        if ftype == TType.I64:
28985 
          self.orderId = iprot.readI64();
28986 
        else:
28987 
          iprot.skip(ftype)
28988 
      elif fid == 3:
28989 
        if ftype == TType.I64:
28990 
          self.amount = iprot.readI64();
28991 
        else:
28992 
          iprot.skip(ftype)
28993 
      else:
28994 
        iprot.skip(ftype)
28995 
      iprot.readFieldEnd()
28996 
    iprot.readStructEnd()
28997 
 
28998 
  def write(self, oprot):
28999 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
29000 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
29001 
      return
29002 
    oprot.writeStructBegin('addAmountToWallet_args')
29003 
    if self.userId is not None:
29004 
      oprot.writeFieldBegin('userId', TType.I64, 1)
29005 
      oprot.writeI64(self.userId)
29006 
      oprot.writeFieldEnd()
29007 
    if self.orderId is not None:
29008 
      oprot.writeFieldBegin('orderId', TType.I64, 2)
29009 
      oprot.writeI64(self.orderId)
29010 
      oprot.writeFieldEnd()
29011 
    if self.amount is not None:
29012 
      oprot.writeFieldBegin('amount', TType.I64, 3)
29013 
      oprot.writeI64(self.amount)
29014 
      oprot.writeFieldEnd()
29015 
    oprot.writeFieldStop()
29016 
    oprot.writeStructEnd()
29017 
 
29018 
  def validate(self):
29019 
    return
29020 
 
29021 
 
29022 
  def __repr__(self):
29023 
    L = ['%s=%r' % (key, value)
29024 
      for key, value in self.__dict__.iteritems()]
29025 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
29026 
 
29027 
  def __eq__(self, other):
29028 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
29029 
 
29030 
  def __ne__(self, other):
29031 
    return not (self == other)
29032 
 
29033 
class addAmountToWallet_result:
29034 
 
29035 
  thrift_spec = (
29036 
  )
29037 
 
29038 
  def read(self, iprot):
29039 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
29040 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
29041 
      return
29042 
    iprot.readStructBegin()
29043 
    while True:
29044 
      (fname, ftype, fid) = iprot.readFieldBegin()
29045 
      if ftype == TType.STOP:
29046 
        break
29047 
      else:
29048 
        iprot.skip(ftype)
29049 
      iprot.readFieldEnd()
29050 
    iprot.readStructEnd()
29051 
 
29052 
  def write(self, oprot):
29053 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
29054 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
29055 
      return
29056 
    oprot.writeStructBegin('addAmountToWallet_result')
29057 
    oprot.writeFieldStop()
29058 
    oprot.writeStructEnd()
29059 
 
29060 
  def validate(self):
29061 
    return
29062 
 
29063 
 
29064 
  def __repr__(self):
29065 
    L = ['%s=%r' % (key, value)
29066 
      for key, value in self.__dict__.iteritems()]
29067 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
29068 
 
29069 
  def __eq__(self, other):
29070 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
29071 
 
29072 
  def __ne__(self, other):
29073 
    return not (self == other)
6154 rajveer 29074 
 
6188 rajveer 29075 
class getRechargeStatistics_args:
29076 
 
29077 
  thrift_spec = (
29078 
  )
29079 
 
29080 
  def read(self, iprot):
29081 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
29082 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
29083 
      return
29084 
    iprot.readStructBegin()
29085 
    while True:
29086 
      (fname, ftype, fid) = iprot.readFieldBegin()
29087 
      if ftype == TType.STOP:
29088 
        break
29089 
      else:
29090 
        iprot.skip(ftype)
29091 
      iprot.readFieldEnd()
29092 
    iprot.readStructEnd()
29093 
 
29094 
  def write(self, oprot):
29095 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
29096 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
29097 
      return
29098 
    oprot.writeStructBegin('getRechargeStatistics_args')
29099 
    oprot.writeFieldStop()
29100 
    oprot.writeStructEnd()
29101 
 
29102 
  def validate(self):
29103 
    return
29104 
 
29105 
 
29106 
  def __repr__(self):
29107 
    L = ['%s=%r' % (key, value)
29108 
      for key, value in self.__dict__.iteritems()]
29109 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
29110 
 
29111 
  def __eq__(self, other):
29112 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
29113 
 
29114 
  def __ne__(self, other):
29115 
    return not (self == other)
29116 
 
29117 
class getRechargeStatistics_result:
29118 
  """
29119 
  Attributes:
29120 
   - success
29121 
  """
29122 
 
29123 
  thrift_spec = (
29124 
    (0, TType.STRUCT, 'success', (RechargeStatistics, RechargeStatistics.thrift_spec), None, ), # 0
29125 
  )
29126 
 
29127 
  def __init__(self, success=None,):
29128 
    self.success = success
29129 
 
29130 
  def read(self, iprot):
29131 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
29132 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
29133 
      return
29134 
    iprot.readStructBegin()
29135 
    while True:
29136 
      (fname, ftype, fid) = iprot.readFieldBegin()
29137 
      if ftype == TType.STOP:
29138 
        break
29139 
      if fid == 0:
29140 
        if ftype == TType.STRUCT:
29141 
          self.success = RechargeStatistics()
29142 
          self.success.read(iprot)
29143 
        else:
29144 
          iprot.skip(ftype)
29145 
      else:
29146 
        iprot.skip(ftype)
29147 
      iprot.readFieldEnd()
29148 
    iprot.readStructEnd()
29149 
 
29150 
  def write(self, oprot):
29151 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
29152 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
29153 
      return
29154 
    oprot.writeStructBegin('getRechargeStatistics_result')
29155 
    if self.success is not None:
29156 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
29157 
      self.success.write(oprot)
29158 
      oprot.writeFieldEnd()
29159 
    oprot.writeFieldStop()
29160 
    oprot.writeStructEnd()
29161 
 
29162 
  def validate(self):
29163 
    return
29164 
 
29165 
 
29166 
  def __repr__(self):
29167 
    L = ['%s=%r' % (key, value)
29168 
      for key, value in self.__dict__.iteritems()]
29169 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
29170 
 
29171 
  def __eq__(self, other):
29172 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
29173 
 
29174 
  def __ne__(self, other):
29175 
    return not (self == other)
29176 
 
6154 rajveer 29177 
class getRechargeOrdersForStatus_args:
29178 
  """
29179 
  Attributes:
29180 
   - status
29181 
  """
29182 
 
29183 
  thrift_spec = (
29184 
    None, # 0
29185 
    (1, TType.I64, 'status', None, None, ), # 1
29186 
  )
29187 
 
29188 
  def __init__(self, status=None,):
29189 
    self.status = status
29190 
 
29191 
  def read(self, iprot):
29192 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
29193 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
29194 
      return
29195 
    iprot.readStructBegin()
29196 
    while True:
29197 
      (fname, ftype, fid) = iprot.readFieldBegin()
29198 
      if ftype == TType.STOP:
29199 
        break
29200 
      if fid == 1:
29201 
        if ftype == TType.I64:
29202 
          self.status = iprot.readI64();
29203 
        else:
29204 
          iprot.skip(ftype)
29205 
      else:
29206 
        iprot.skip(ftype)
29207 
      iprot.readFieldEnd()
29208 
    iprot.readStructEnd()
29209 
 
29210 
  def write(self, oprot):
29211 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
29212 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
29213 
      return
29214 
    oprot.writeStructBegin('getRechargeOrdersForStatus_args')
29215 
    if self.status is not None:
29216 
      oprot.writeFieldBegin('status', TType.I64, 1)
29217 
      oprot.writeI64(self.status)
29218 
      oprot.writeFieldEnd()
29219 
    oprot.writeFieldStop()
29220 
    oprot.writeStructEnd()
29221 
 
29222 
  def validate(self):
29223 
    return
29224 
 
29225 
 
29226 
  def __repr__(self):
29227 
    L = ['%s=%r' % (key, value)
29228 
      for key, value in self.__dict__.iteritems()]
29229 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
29230 
 
29231 
  def __eq__(self, other):
29232 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
29233 
 
29234 
  def __ne__(self, other):
29235 
    return not (self == other)
29236 
 
29237 
class getRechargeOrdersForStatus_result:
29238 
  """
29239 
  Attributes:
29240 
   - success
29241 
  """
29242 
 
29243 
  thrift_spec = (
29244 
    (0, TType.LIST, 'success', (TType.STRUCT,(RechargeOrder, RechargeOrder.thrift_spec)), None, ), # 0
29245 
  )
29246 
 
29247 
  def __init__(self, success=None,):
29248 
    self.success = success
29249 
 
29250 
  def read(self, iprot):
29251 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
29252 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
29253 
      return
29254 
    iprot.readStructBegin()
29255 
    while True:
29256 
      (fname, ftype, fid) = iprot.readFieldBegin()
29257 
      if ftype == TType.STOP:
29258 
        break
29259 
      if fid == 0:
29260 
        if ftype == TType.LIST:
29261 
          self.success = []
6188 rajveer 29262 
          (_etype689, _size686) = iprot.readListBegin()
29263 
          for _i690 in xrange(_size686):
29264 
            _elem691 = RechargeOrder()
29265 
            _elem691.read(iprot)
29266 
            self.success.append(_elem691)
6154 rajveer 29267 
          iprot.readListEnd()
29268 
        else:
29269 
          iprot.skip(ftype)
29270 
      else:
29271 
        iprot.skip(ftype)
29272 
      iprot.readFieldEnd()
29273 
    iprot.readStructEnd()
29274 
 
29275 
  def write(self, oprot):
29276 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
29277 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
29278 
      return
29279 
    oprot.writeStructBegin('getRechargeOrdersForStatus_result')
29280 
    if self.success is not None:
29281 
      oprot.writeFieldBegin('success', TType.LIST, 0)
29282 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 29283 
      for iter692 in self.success:
29284 
        iter692.write(oprot)
6154 rajveer 29285 
      oprot.writeListEnd()
29286 
      oprot.writeFieldEnd()
29287 
    oprot.writeFieldStop()
29288 
    oprot.writeStructEnd()
29289 
 
29290 
  def validate(self):
29291 
    return
29292 
 
29293 
 
29294 
  def __repr__(self):
29295 
    L = ['%s=%r' % (key, value)
29296 
      for key, value in self.__dict__.iteritems()]
29297 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
29298 
 
29299 
  def __eq__(self, other):
29300 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
29301 
 
29302 
  def __ne__(self, other):
29303 
    return not (self == other)
6159 rajveer 29304 
 
29305 
class getPlansForOperator_args:
29306 
  """
29307 
  Attributes:
29308 
   - operatorId
29309 
  """
29310 
 
29311 
  thrift_spec = (
29312 
    None, # 0
29313 
    (1, TType.I64, 'operatorId', None, None, ), # 1
29314 
  )
29315 
 
29316 
  def __init__(self, operatorId=None,):
29317 
    self.operatorId = operatorId
29318 
 
29319 
  def read(self, iprot):
29320 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
29321 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
29322 
      return
29323 
    iprot.readStructBegin()
29324 
    while True:
29325 
      (fname, ftype, fid) = iprot.readFieldBegin()
29326 
      if ftype == TType.STOP:
29327 
        break
29328 
      if fid == 1:
29329 
        if ftype == TType.I64:
29330 
          self.operatorId = iprot.readI64();
29331 
        else:
29332 
          iprot.skip(ftype)
29333 
      else:
29334 
        iprot.skip(ftype)
29335 
      iprot.readFieldEnd()
29336 
    iprot.readStructEnd()
29337 
 
29338 
  def write(self, oprot):
29339 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
29340 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
29341 
      return
29342 
    oprot.writeStructBegin('getPlansForOperator_args')
29343 
    if self.operatorId is not None:
29344 
      oprot.writeFieldBegin('operatorId', TType.I64, 1)
29345 
      oprot.writeI64(self.operatorId)
29346 
      oprot.writeFieldEnd()
29347 
    oprot.writeFieldStop()
29348 
    oprot.writeStructEnd()
29349 
 
29350 
  def validate(self):
29351 
    return
29352 
 
29353 
 
29354 
  def __repr__(self):
29355 
    L = ['%s=%r' % (key, value)
29356 
      for key, value in self.__dict__.iteritems()]
29357 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
29358 
 
29359 
  def __eq__(self, other):
29360 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
29361 
 
29362 
  def __ne__(self, other):
29363 
    return not (self == other)
29364 
 
29365 
class getPlansForOperator_result:
29366 
  """
29367 
  Attributes:
29368 
   - success
29369 
  """
29370 
 
29371 
  thrift_spec = (
29372 
    (0, TType.LIST, 'success', (TType.STRUCT,(RechargePlan, RechargePlan.thrift_spec)), None, ), # 0
29373 
  )
29374 
 
29375 
  def __init__(self, success=None,):
29376 
    self.success = success
29377 
 
29378 
  def read(self, iprot):
29379 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
29380 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
29381 
      return
29382 
    iprot.readStructBegin()
29383 
    while True:
29384 
      (fname, ftype, fid) = iprot.readFieldBegin()
29385 
      if ftype == TType.STOP:
29386 
        break
29387 
      if fid == 0:
29388 
        if ftype == TType.LIST:
29389 
          self.success = []
6188 rajveer 29390 
          (_etype696, _size693) = iprot.readListBegin()
29391 
          for _i697 in xrange(_size693):
29392 
            _elem698 = RechargePlan()
29393 
            _elem698.read(iprot)
29394 
            self.success.append(_elem698)
6159 rajveer 29395 
          iprot.readListEnd()
29396 
        else:
29397 
          iprot.skip(ftype)
29398 
      else:
29399 
        iprot.skip(ftype)
29400 
      iprot.readFieldEnd()
29401 
    iprot.readStructEnd()
29402 
 
29403 
  def write(self, oprot):
29404 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
29405 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
29406 
      return
29407 
    oprot.writeStructBegin('getPlansForOperator_result')
29408 
    if self.success is not None:
29409 
      oprot.writeFieldBegin('success', TType.LIST, 0)
29410 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 29411 
      for iter699 in self.success:
29412 
        iter699.write(oprot)
6159 rajveer 29413 
      oprot.writeListEnd()
29414 
      oprot.writeFieldEnd()
29415 
    oprot.writeFieldStop()
29416 
    oprot.writeStructEnd()
29417 
 
29418 
  def validate(self):
29419 
    return
29420 
 
29421 
 
29422 
  def __repr__(self):
29423 
    L = ['%s=%r' % (key, value)
29424 
      for key, value in self.__dict__.iteritems()]
29425 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
29426 
 
29427 
  def __eq__(self, other):
29428 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
29429 
 
29430 
  def __ne__(self, other):
29431 
    return not (self == other)
6289 anupam.sin 29432 
 
29433 
class getRechargeDenominations_args:
29434 
  """
29435 
  Attributes:
29436 
   - operatorId
6307 anupam.sin 29437 
   - circleCode
6289 anupam.sin 29438 
   - denominationType
29439 
  """
29440 
 
29441 
  thrift_spec = (
29442 
    None, # 0
29443 
    (1, TType.I64, 'operatorId', None, None, ), # 1
6307 anupam.sin 29444 
    (2, TType.STRING, 'circleCode', None, None, ), # 2
6289 anupam.sin 29445 
    (3, TType.I32, 'denominationType', None, None, ), # 3
29446 
  )
29447 
 
6307 anupam.sin 29448 
  def __init__(self, operatorId=None, circleCode=None, denominationType=None,):
6289 anupam.sin 29449 
    self.operatorId = operatorId
6307 anupam.sin 29450 
    self.circleCode = circleCode
6289 anupam.sin 29451 
    self.denominationType = denominationType
29452 
 
29453 
  def read(self, iprot):
29454 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
29455 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
29456 
      return
29457 
    iprot.readStructBegin()
29458 
    while True:
29459 
      (fname, ftype, fid) = iprot.readFieldBegin()
29460 
      if ftype == TType.STOP:
29461 
        break
29462 
      if fid == 1:
29463 
        if ftype == TType.I64:
29464 
          self.operatorId = iprot.readI64();
29465 
        else:
29466 
          iprot.skip(ftype)
29467 
      elif fid == 2:
29468 
        if ftype == TType.STRING:
6307 anupam.sin 29469 
          self.circleCode = iprot.readString();
6289 anupam.sin 29470 
        else:
29471 
          iprot.skip(ftype)
29472 
      elif fid == 3:
29473 
        if ftype == TType.I32:
29474 
          self.denominationType = iprot.readI32();
29475 
        else:
29476 
          iprot.skip(ftype)
29477 
      else:
29478 
        iprot.skip(ftype)
29479 
      iprot.readFieldEnd()
29480 
    iprot.readStructEnd()
29481 
 
29482 
  def write(self, oprot):
29483 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
29484 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
29485 
      return
29486 
    oprot.writeStructBegin('getRechargeDenominations_args')
29487 
    if self.operatorId is not None:
29488 
      oprot.writeFieldBegin('operatorId', TType.I64, 1)
29489 
      oprot.writeI64(self.operatorId)
29490 
      oprot.writeFieldEnd()
6307 anupam.sin 29491 
    if self.circleCode is not None:
29492 
      oprot.writeFieldBegin('circleCode', TType.STRING, 2)
29493 
      oprot.writeString(self.circleCode)
6289 anupam.sin 29494 
      oprot.writeFieldEnd()
29495 
    if self.denominationType is not None:
29496 
      oprot.writeFieldBegin('denominationType', TType.I32, 3)
29497 
      oprot.writeI32(self.denominationType)
29498 
      oprot.writeFieldEnd()
29499 
    oprot.writeFieldStop()
29500 
    oprot.writeStructEnd()
29501 
 
29502 
  def validate(self):
29503 
    return
29504 
 
29505 
 
29506 
  def __repr__(self):
29507 
    L = ['%s=%r' % (key, value)
29508 
      for key, value in self.__dict__.iteritems()]
29509 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
29510 
 
29511 
  def __eq__(self, other):
29512 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
29513 
 
29514 
  def __ne__(self, other):
29515 
    return not (self == other)
29516 
 
29517 
class getRechargeDenominations_result:
29518 
  """
29519 
  Attributes:
29520 
   - success
29521 
   - ex
29522 
  """
29523 
 
29524 
  thrift_spec = (
29525 
    (0, TType.LIST, 'success', (TType.STRUCT,(RechargeDenomination, RechargeDenomination.thrift_spec)), None, ), # 0
29526 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
29527 
  )
29528 
 
29529 
  def __init__(self, success=None, ex=None,):
29530 
    self.success = success
29531 
    self.ex = ex
29532 
 
29533 
  def read(self, iprot):
29534 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
29535 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
29536 
      return
29537 
    iprot.readStructBegin()
29538 
    while True:
29539 
      (fname, ftype, fid) = iprot.readFieldBegin()
29540 
      if ftype == TType.STOP:
29541 
        break
29542 
      if fid == 0:
29543 
        if ftype == TType.LIST:
29544 
          self.success = []
29545 
          (_etype703, _size700) = iprot.readListBegin()
29546 
          for _i704 in xrange(_size700):
29547 
            _elem705 = RechargeDenomination()
29548 
            _elem705.read(iprot)
29549 
            self.success.append(_elem705)
29550 
          iprot.readListEnd()
29551 
        else:
29552 
          iprot.skip(ftype)
29553 
      elif fid == 1:
29554 
        if ftype == TType.STRUCT:
29555 
          self.ex = TransactionServiceException()
29556 
          self.ex.read(iprot)
29557 
        else:
29558 
          iprot.skip(ftype)
29559 
      else:
29560 
        iprot.skip(ftype)
29561 
      iprot.readFieldEnd()
29562 
    iprot.readStructEnd()
29563 
 
29564 
  def write(self, oprot):
29565 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
29566 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
29567 
      return
29568 
    oprot.writeStructBegin('getRechargeDenominations_result')
29569 
    if self.success is not None:
29570 
      oprot.writeFieldBegin('success', TType.LIST, 0)
29571 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
29572 
      for iter706 in self.success:
29573 
        iter706.write(oprot)
29574 
      oprot.writeListEnd()
29575 
      oprot.writeFieldEnd()
29576 
    if self.ex is not None:
29577 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
29578 
      self.ex.write(oprot)
29579 
      oprot.writeFieldEnd()
29580 
    oprot.writeFieldStop()
29581 
    oprot.writeStructEnd()
29582 
 
29583 
  def validate(self):
29584 
    return
29585 
 
29586 
 
29587 
  def __repr__(self):
29588 
    L = ['%s=%r' % (key, value)
29589 
      for key, value in self.__dict__.iteritems()]
29590 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
29591 
 
29592 
  def __eq__(self, other):
29593 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
29594 
 
29595 
  def __ne__(self, other):
29596 
    return not (self == other)
6371 rajveer 29597 
 
29598 
class updateAvailabilityStatus_args:
29599 
  """
29600 
  Attributes:
29601 
   - operatorId
29602 
   - circleId
29603 
   - isAvailable
29604 
  """
29605 
 
29606 
  thrift_spec = (
29607 
    None, # 0
29608 
    (1, TType.I64, 'operatorId', None, None, ), # 1
29609 
    (2, TType.I64, 'circleId', None, None, ), # 2
29610 
    (3, TType.BOOL, 'isAvailable', None, None, ), # 3
29611 
  )
29612 
 
29613 
  def __init__(self, operatorId=None, circleId=None, isAvailable=None,):
29614 
    self.operatorId = operatorId
29615 
    self.circleId = circleId
29616 
    self.isAvailable = isAvailable
29617 
 
29618 
  def read(self, iprot):
29619 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
29620 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
29621 
      return
29622 
    iprot.readStructBegin()
29623 
    while True:
29624 
      (fname, ftype, fid) = iprot.readFieldBegin()
29625 
      if ftype == TType.STOP:
29626 
        break
29627 
      if fid == 1:
29628 
        if ftype == TType.I64:
29629 
          self.operatorId = iprot.readI64();
29630 
        else:
29631 
          iprot.skip(ftype)
29632 
      elif fid == 2:
29633 
        if ftype == TType.I64:
29634 
          self.circleId = iprot.readI64();
29635 
        else:
29636 
          iprot.skip(ftype)
29637 
      elif fid == 3:
29638 
        if ftype == TType.BOOL:
29639 
          self.isAvailable = iprot.readBool();
29640 
        else:
29641 
          iprot.skip(ftype)
29642 
      else:
29643 
        iprot.skip(ftype)
29644 
      iprot.readFieldEnd()
29645 
    iprot.readStructEnd()
29646 
 
29647 
  def write(self, oprot):
29648 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
29649 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
29650 
      return
29651 
    oprot.writeStructBegin('updateAvailabilityStatus_args')
29652 
    if self.operatorId is not None:
29653 
      oprot.writeFieldBegin('operatorId', TType.I64, 1)
29654 
      oprot.writeI64(self.operatorId)
29655 
      oprot.writeFieldEnd()
29656 
    if self.circleId is not None:
29657 
      oprot.writeFieldBegin('circleId', TType.I64, 2)
29658 
      oprot.writeI64(self.circleId)
29659 
      oprot.writeFieldEnd()
29660 
    if self.isAvailable is not None:
29661 
      oprot.writeFieldBegin('isAvailable', TType.BOOL, 3)
29662 
      oprot.writeBool(self.isAvailable)
29663 
      oprot.writeFieldEnd()
29664 
    oprot.writeFieldStop()
29665 
    oprot.writeStructEnd()
29666 
 
29667 
  def validate(self):
29668 
    return
29669 
 
29670 
 
29671 
  def __repr__(self):
29672 
    L = ['%s=%r' % (key, value)
29673 
      for key, value in self.__dict__.iteritems()]
29674 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
29675 
 
29676 
  def __eq__(self, other):
29677 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
29678 
 
29679 
  def __ne__(self, other):
29680 
    return not (self == other)
29681 
 
29682 
class updateAvailabilityStatus_result:
29683 
 
29684 
  thrift_spec = (
29685 
  )
29686 
 
29687 
  def read(self, iprot):
29688 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
29689 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
29690 
      return
29691 
    iprot.readStructBegin()
29692 
    while True:
29693 
      (fname, ftype, fid) = iprot.readFieldBegin()
29694 
      if ftype == TType.STOP:
29695 
        break
29696 
      else:
29697 
        iprot.skip(ftype)
29698 
      iprot.readFieldEnd()
29699 
    iprot.readStructEnd()
29700 
 
29701 
  def write(self, oprot):
29702 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
29703 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
29704 
      return
29705 
    oprot.writeStructBegin('updateAvailabilityStatus_result')
29706 
    oprot.writeFieldStop()
29707 
    oprot.writeStructEnd()
29708 
 
29709 
  def validate(self):
29710 
    return
29711 
 
29712 
 
29713 
  def __repr__(self):
29714 
    L = ['%s=%r' % (key, value)
29715 
      for key, value in self.__dict__.iteritems()]
29716 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
29717 
 
29718 
  def __eq__(self, other):
29719 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
29720 
 
29721 
  def __ne__(self, other):
29722 
    return not (self == other)
6389 rajveer 29723 
 
29724 
class getAvailableEmiSchemes_args:
29725 
 
29726 
  thrift_spec = (
29727 
  )
29728 
 
29729 
  def read(self, iprot):
29730 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
29731 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
29732 
      return
29733 
    iprot.readStructBegin()
29734 
    while True:
29735 
      (fname, ftype, fid) = iprot.readFieldBegin()
29736 
      if ftype == TType.STOP:
29737 
        break
29738 
      else:
29739 
        iprot.skip(ftype)
29740 
      iprot.readFieldEnd()
29741 
    iprot.readStructEnd()
29742 
 
29743 
  def write(self, oprot):
29744 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
29745 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
29746 
      return
29747 
    oprot.writeStructBegin('getAvailableEmiSchemes_args')
29748 
    oprot.writeFieldStop()
29749 
    oprot.writeStructEnd()
29750 
 
29751 
  def validate(self):
29752 
    return
29753 
 
29754 
 
29755 
  def __repr__(self):
29756 
    L = ['%s=%r' % (key, value)
29757 
      for key, value in self.__dict__.iteritems()]
29758 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
29759 
 
29760 
  def __eq__(self, other):
29761 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
29762 
 
29763 
  def __ne__(self, other):
29764 
    return not (self == other)
29765 
 
29766 
class getAvailableEmiSchemes_result:
29767 
  """
29768 
  Attributes:
29769 
   - success
29770 
  """
29771 
 
29772 
  thrift_spec = (
29773 
    (0, TType.LIST, 'success', (TType.STRUCT,(EmiScheme, EmiScheme.thrift_spec)), None, ), # 0
29774 
  )
29775 
 
29776 
  def __init__(self, success=None,):
29777 
    self.success = success
29778 
 
29779 
  def read(self, iprot):
29780 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
29781 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
29782 
      return
29783 
    iprot.readStructBegin()
29784 
    while True:
29785 
      (fname, ftype, fid) = iprot.readFieldBegin()
29786 
      if ftype == TType.STOP:
29787 
        break
29788 
      if fid == 0:
29789 
        if ftype == TType.LIST:
29790 
          self.success = []
29791 
          (_etype710, _size707) = iprot.readListBegin()
29792 
          for _i711 in xrange(_size707):
29793 
            _elem712 = EmiScheme()
29794 
            _elem712.read(iprot)
29795 
            self.success.append(_elem712)
29796 
          iprot.readListEnd()
29797 
        else:
29798 
          iprot.skip(ftype)
29799 
      else:
29800 
        iprot.skip(ftype)
29801 
      iprot.readFieldEnd()
29802 
    iprot.readStructEnd()
29803 
 
29804 
  def write(self, oprot):
29805 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
29806 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
29807 
      return
29808 
    oprot.writeStructBegin('getAvailableEmiSchemes_result')
29809 
    if self.success is not None:
29810 
      oprot.writeFieldBegin('success', TType.LIST, 0)
29811 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
29812 
      for iter713 in self.success:
29813 
        iter713.write(oprot)
29814 
      oprot.writeListEnd()
29815 
      oprot.writeFieldEnd()
29816 
    oprot.writeFieldStop()
29817 
    oprot.writeStructEnd()
29818 
 
29819 
  def validate(self):
29820 
    return
29821 
 
29822 
 
29823 
  def __repr__(self):
29824 
    L = ['%s=%r' % (key, value)
29825 
      for key, value in self.__dict__.iteritems()]
29826 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
29827 
 
29828 
  def __eq__(self, other):
29829 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
29830 
 
29831 
  def __ne__(self, other):
29832 
    return not (self == other)
29833 
 
29834 
class getMiscCharges_args:
29835 
  """
29836 
  Attributes:
29837 
   - transactionId
29838 
  """
29839 
 
29840 
  thrift_spec = (
29841 
    None, # 0
29842 
    (1, TType.I64, 'transactionId', None, None, ), # 1
29843 
  )
29844 
 
29845 
  def __init__(self, transactionId=None,):
29846 
    self.transactionId = transactionId
29847 
 
29848 
  def read(self, iprot):
29849 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
29850 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
29851 
      return
29852 
    iprot.readStructBegin()
29853 
    while True:
29854 
      (fname, ftype, fid) = iprot.readFieldBegin()
29855 
      if ftype == TType.STOP:
29856 
        break
29857 
      if fid == 1:
29858 
        if ftype == TType.I64:
29859 
          self.transactionId = iprot.readI64();
29860 
        else:
29861 
          iprot.skip(ftype)
29862 
      else:
29863 
        iprot.skip(ftype)
29864 
      iprot.readFieldEnd()
29865 
    iprot.readStructEnd()
29866 
 
29867 
  def write(self, oprot):
29868 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
29869 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
29870 
      return
29871 
    oprot.writeStructBegin('getMiscCharges_args')
29872 
    if self.transactionId is not None:
29873 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
29874 
      oprot.writeI64(self.transactionId)
29875 
      oprot.writeFieldEnd()
29876 
    oprot.writeFieldStop()
29877 
    oprot.writeStructEnd()
29878 
 
29879 
  def validate(self):
29880 
    return
29881 
 
29882 
 
29883 
  def __repr__(self):
29884 
    L = ['%s=%r' % (key, value)
29885 
      for key, value in self.__dict__.iteritems()]
29886 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
29887 
 
29888 
  def __eq__(self, other):
29889 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
29890 
 
29891 
  def __ne__(self, other):
29892 
    return not (self == other)
29893 
 
29894 
class getMiscCharges_result:
29895 
  """
29896 
  Attributes:
29897 
   - success
29898 
  """
29899 
 
29900 
  thrift_spec = (
6412 rajveer 29901 
    (0, TType.MAP, 'success', (TType.I64,None,TType.DOUBLE,None), None, ), # 0
6389 rajveer 29902 
  )
29903 
 
29904 
  def __init__(self, success=None,):
29905 
    self.success = success
29906 
 
29907 
  def read(self, iprot):
29908 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
29909 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
29910 
      return
29911 
    iprot.readStructBegin()
29912 
    while True:
29913 
      (fname, ftype, fid) = iprot.readFieldBegin()
29914 
      if ftype == TType.STOP:
29915 
        break
29916 
      if fid == 0:
29917 
        if ftype == TType.MAP:
29918 
          self.success = {}
29919 
          (_ktype715, _vtype716, _size714 ) = iprot.readMapBegin()
29920 
          for _i718 in xrange(_size714):
29921 
            _key719 = iprot.readI64();
6412 rajveer 29922 
            _val720 = iprot.readDouble();
6389 rajveer 29923 
            self.success[_key719] = _val720
29924 
          iprot.readMapEnd()
29925 
        else:
29926 
          iprot.skip(ftype)
29927 
      else:
29928 
        iprot.skip(ftype)
29929 
      iprot.readFieldEnd()
29930 
    iprot.readStructEnd()
29931 
 
29932 
  def write(self, oprot):
29933 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
29934 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
29935 
      return
29936 
    oprot.writeStructBegin('getMiscCharges_result')
29937 
    if self.success is not None:
29938 
      oprot.writeFieldBegin('success', TType.MAP, 0)
6412 rajveer 29939 
      oprot.writeMapBegin(TType.I64, TType.DOUBLE, len(self.success))
6389 rajveer 29940 
      for kiter721,viter722 in self.success.items():
29941 
        oprot.writeI64(kiter721)
6412 rajveer 29942 
        oprot.writeDouble(viter722)
6389 rajveer 29943 
      oprot.writeMapEnd()
29944 
      oprot.writeFieldEnd()
29945 
    oprot.writeFieldStop()
29946 
    oprot.writeStructEnd()
29947 
 
29948 
  def validate(self):
29949 
    return
29950 
 
29951 
 
29952 
  def __repr__(self):
29953 
    L = ['%s=%r' % (key, value)
29954 
      for key, value in self.__dict__.iteritems()]
29955 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
29956 
 
29957 
  def __eq__(self, other):
29958 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
29959 
 
29960 
  def __ne__(self, other):
29961 
    return not (self == other)
6507 anupam.sin 29962 
 
29963 
class refundRechargeOrder_args:
29964 
  """
29965 
  Attributes:
29966 
   - rechargeOrderId
29967 
  """
29968 
 
29969 
  thrift_spec = (
29970 
    None, # 0
29971 
    (1, TType.I64, 'rechargeOrderId', None, None, ), # 1
29972 
  )
29973 
 
29974 
  def __init__(self, rechargeOrderId=None,):
29975 
    self.rechargeOrderId = rechargeOrderId
29976 
 
29977 
  def read(self, iprot):
29978 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
29979 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
29980 
      return
29981 
    iprot.readStructBegin()
29982 
    while True:
29983 
      (fname, ftype, fid) = iprot.readFieldBegin()
29984 
      if ftype == TType.STOP:
29985 
        break
29986 
      if fid == 1:
29987 
        if ftype == TType.I64:
29988 
          self.rechargeOrderId = iprot.readI64();
29989 
        else:
29990 
          iprot.skip(ftype)
29991 
      else:
29992 
        iprot.skip(ftype)
29993 
      iprot.readFieldEnd()
29994 
    iprot.readStructEnd()
29995 
 
29996 
  def write(self, oprot):
29997 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
29998 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
29999 
      return
30000 
    oprot.writeStructBegin('refundRechargeOrder_args')
30001 
    if self.rechargeOrderId is not None:
30002 
      oprot.writeFieldBegin('rechargeOrderId', TType.I64, 1)
30003 
      oprot.writeI64(self.rechargeOrderId)
30004 
      oprot.writeFieldEnd()
30005 
    oprot.writeFieldStop()
30006 
    oprot.writeStructEnd()
30007 
 
30008 
  def validate(self):
30009 
    return
30010 
 
30011 
 
30012 
  def __repr__(self):
30013 
    L = ['%s=%r' % (key, value)
30014 
      for key, value in self.__dict__.iteritems()]
30015 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
30016 
 
30017 
  def __eq__(self, other):
30018 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
30019 
 
30020 
  def __ne__(self, other):
30021 
    return not (self == other)
30022 
 
30023 
class refundRechargeOrder_result:
30024 
  """
30025 
  Attributes:
30026 
   - success
30027 
   - ex
30028 
  """
30029 
 
30030 
  thrift_spec = (
30031 
    (0, TType.BOOL, 'success', None, None, ), # 0
30032 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
30033 
  )
30034 
 
30035 
  def __init__(self, success=None, ex=None,):
30036 
    self.success = success
30037 
    self.ex = ex
30038 
 
30039 
  def read(self, iprot):
30040 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
30041 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
30042 
      return
30043 
    iprot.readStructBegin()
30044 
    while True:
30045 
      (fname, ftype, fid) = iprot.readFieldBegin()
30046 
      if ftype == TType.STOP:
30047 
        break
30048 
      if fid == 0:
30049 
        if ftype == TType.BOOL:
30050 
          self.success = iprot.readBool();
30051 
        else:
30052 
          iprot.skip(ftype)
30053 
      elif fid == 1:
30054 
        if ftype == TType.STRUCT:
30055 
          self.ex = TransactionServiceException()
30056 
          self.ex.read(iprot)
30057 
        else:
30058 
          iprot.skip(ftype)
30059 
      else:
30060 
        iprot.skip(ftype)
30061 
      iprot.readFieldEnd()
30062 
    iprot.readStructEnd()
30063 
 
30064 
  def write(self, oprot):
30065 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
30066 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
30067 
      return
30068 
    oprot.writeStructBegin('refundRechargeOrder_result')
30069 
    if self.success is not None:
30070 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
30071 
      oprot.writeBool(self.success)
30072 
      oprot.writeFieldEnd()
30073 
    if self.ex is not None:
30074 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
30075 
      self.ex.write(oprot)
30076 
      oprot.writeFieldEnd()
30077 
    oprot.writeFieldStop()
30078 
    oprot.writeStructEnd()
30079 
 
30080 
  def validate(self):
30081 
    return
30082 
 
30083 
 
30084 
  def __repr__(self):
30085 
    L = ['%s=%r' % (key, value)
30086 
      for key, value in self.__dict__.iteritems()]
30087 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
30088 
 
30089 
  def __eq__(self, other):
30090 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
30091 
 
30092 
  def __ne__(self, other):
30093 
    return not (self == other)
6821 amar.kumar 30094 
 
30095 
class getPhysicalOrders_args:
30096 
  """
30097 
  Attributes:
30098 
   - fromDate
30099 
   - toDate
30100 
  """
30101 
 
30102 
  thrift_spec = (
30103 
    None, # 0
30104 
    (1, TType.I64, 'fromDate', None, None, ), # 1
30105 
    (2, TType.I64, 'toDate', None, None, ), # 2
30106 
  )
30107 
 
30108 
  def __init__(self, fromDate=None, toDate=None,):
30109 
    self.fromDate = fromDate
30110 
    self.toDate = toDate
30111 
 
30112 
  def read(self, iprot):
30113 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
30114 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
30115 
      return
30116 
    iprot.readStructBegin()
30117 
    while True:
30118 
      (fname, ftype, fid) = iprot.readFieldBegin()
30119 
      if ftype == TType.STOP:
30120 
        break
30121 
      if fid == 1:
30122 
        if ftype == TType.I64:
30123 
          self.fromDate = iprot.readI64();
30124 
        else:
30125 
          iprot.skip(ftype)
30126 
      elif fid == 2:
30127 
        if ftype == TType.I64:
30128 
          self.toDate = iprot.readI64();
30129 
        else:
30130 
          iprot.skip(ftype)
30131 
      else:
30132 
        iprot.skip(ftype)
30133 
      iprot.readFieldEnd()
30134 
    iprot.readStructEnd()
30135 
 
30136 
  def write(self, oprot):
30137 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
30138 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
30139 
      return
30140 
    oprot.writeStructBegin('getPhysicalOrders_args')
30141 
    if self.fromDate is not None:
30142 
      oprot.writeFieldBegin('fromDate', TType.I64, 1)
30143 
      oprot.writeI64(self.fromDate)
30144 
      oprot.writeFieldEnd()
30145 
    if self.toDate is not None:
30146 
      oprot.writeFieldBegin('toDate', TType.I64, 2)
30147 
      oprot.writeI64(self.toDate)
30148 
      oprot.writeFieldEnd()
30149 
    oprot.writeFieldStop()
30150 
    oprot.writeStructEnd()
30151 
 
30152 
  def validate(self):
30153 
    return
30154 
 
30155 
 
30156 
  def __repr__(self):
30157 
    L = ['%s=%r' % (key, value)
30158 
      for key, value in self.__dict__.iteritems()]
30159 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
30160 
 
30161 
  def __eq__(self, other):
30162 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
30163 
 
30164 
  def __ne__(self, other):
30165 
    return not (self == other)
30166 
 
30167 
class getPhysicalOrders_result:
30168 
  """
30169 
  Attributes:
30170 
   - success
30171 
  """
30172 
 
30173 
  thrift_spec = (
30174 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
30175 
  )
30176 
 
30177 
  def __init__(self, success=None,):
30178 
    self.success = success
30179 
 
30180 
  def read(self, iprot):
30181 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
30182 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
30183 
      return
30184 
    iprot.readStructBegin()
30185 
    while True:
30186 
      (fname, ftype, fid) = iprot.readFieldBegin()
30187 
      if ftype == TType.STOP:
30188 
        break
30189 
      if fid == 0:
30190 
        if ftype == TType.LIST:
30191 
          self.success = []
30192 
          (_etype726, _size723) = iprot.readListBegin()
30193 
          for _i727 in xrange(_size723):
30194 
            _elem728 = Order()
30195 
            _elem728.read(iprot)
30196 
            self.success.append(_elem728)
30197 
          iprot.readListEnd()
30198 
        else:
30199 
          iprot.skip(ftype)
30200 
      else:
30201 
        iprot.skip(ftype)
30202 
      iprot.readFieldEnd()
30203 
    iprot.readStructEnd()
30204 
 
30205 
  def write(self, oprot):
30206 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
30207 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
30208 
      return
30209 
    oprot.writeStructBegin('getPhysicalOrders_result')
30210 
    if self.success is not None:
30211 
      oprot.writeFieldBegin('success', TType.LIST, 0)
30212 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
30213 
      for iter729 in self.success:
30214 
        iter729.write(oprot)
30215 
      oprot.writeListEnd()
30216 
      oprot.writeFieldEnd()
30217 
    oprot.writeFieldStop()
30218 
    oprot.writeStructEnd()
30219 
 
30220 
  def validate(self):
30221 
    return
30222 
 
30223 
 
30224 
  def __repr__(self):
30225 
    L = ['%s=%r' % (key, value)
30226 
      for key, value in self.__dict__.iteritems()]
30227 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
30228 
 
30229 
  def __eq__(self, other):
30230 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
30231 
 
30232 
  def __ne__(self, other):
30233 
    return not (self == other)
6906 rajveer 30234 
 
30235 
class getDocument_args:
30236 
  """
30237 
  Attributes:
30238 
   - docType
30239 
   - docSource
30240 
  """
30241 
 
30242 
  thrift_spec = (
30243 
    None, # 0
30244 
    (1, TType.I64, 'docType', None, None, ), # 1
30245 
    (2, TType.I64, 'docSource', None, None, ), # 2
30246 
  )
30247 
 
30248 
  def __init__(self, docType=None, docSource=None,):
30249 
    self.docType = docType
30250 
    self.docSource = docSource
30251 
 
30252 
  def read(self, iprot):
30253 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
30254 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
30255 
      return
30256 
    iprot.readStructBegin()
30257 
    while True:
30258 
      (fname, ftype, fid) = iprot.readFieldBegin()
30259 
      if ftype == TType.STOP:
30260 
        break
30261 
      if fid == 1:
30262 
        if ftype == TType.I64:
30263 
          self.docType = iprot.readI64();
30264 
        else:
30265 
          iprot.skip(ftype)
30266 
      elif fid == 2:
30267 
        if ftype == TType.I64:
30268 
          self.docSource = iprot.readI64();
30269 
        else:
30270 
          iprot.skip(ftype)
30271 
      else:
30272 
        iprot.skip(ftype)
30273 
      iprot.readFieldEnd()
30274 
    iprot.readStructEnd()
30275 
 
30276 
  def write(self, oprot):
30277 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
30278 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
30279 
      return
30280 
    oprot.writeStructBegin('getDocument_args')
30281 
    if self.docType is not None:
30282 
      oprot.writeFieldBegin('docType', TType.I64, 1)
30283 
      oprot.writeI64(self.docType)
30284 
      oprot.writeFieldEnd()
30285 
    if self.docSource is not None:
30286 
      oprot.writeFieldBegin('docSource', TType.I64, 2)
30287 
      oprot.writeI64(self.docSource)
30288 
      oprot.writeFieldEnd()
30289 
    oprot.writeFieldStop()
30290 
    oprot.writeStructEnd()
30291 
 
30292 
  def validate(self):
30293 
    return
30294 
 
30295 
 
30296 
  def __repr__(self):
30297 
    L = ['%s=%r' % (key, value)
30298 
      for key, value in self.__dict__.iteritems()]
30299 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
30300 
 
30301 
  def __eq__(self, other):
30302 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
30303 
 
30304 
  def __ne__(self, other):
30305 
    return not (self == other)
30306 
 
30307 
class getDocument_result:
30308 
  """
30309 
  Attributes:
30310 
   - success
30311 
  """
30312 
 
30313 
  thrift_spec = (
30314 
    (0, TType.STRING, 'success', None, None, ), # 0
30315 
  )
30316 
 
30317 
  def __init__(self, success=None,):
30318 
    self.success = success
30319 
 
30320 
  def read(self, iprot):
30321 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
30322 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
30323 
      return
30324 
    iprot.readStructBegin()
30325 
    while True:
30326 
      (fname, ftype, fid) = iprot.readFieldBegin()
30327 
      if ftype == TType.STOP:
30328 
        break
30329 
      if fid == 0:
30330 
        if ftype == TType.STRING:
30331 
          self.success = iprot.readString();
30332 
        else:
30333 
          iprot.skip(ftype)
30334 
      else:
30335 
        iprot.skip(ftype)
30336 
      iprot.readFieldEnd()
30337 
    iprot.readStructEnd()
30338 
 
30339 
  def write(self, oprot):
30340 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
30341 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
30342 
      return
30343 
    oprot.writeStructBegin('getDocument_result')
30344 
    if self.success is not None:
30345 
      oprot.writeFieldBegin('success', TType.STRING, 0)
30346 
      oprot.writeString(self.success)
30347 
      oprot.writeFieldEnd()
30348 
    oprot.writeFieldStop()
30349 
    oprot.writeStructEnd()
30350 
 
30351 
  def validate(self):
30352 
    return
30353 
 
30354 
 
30355 
  def __repr__(self):
30356 
    L = ['%s=%r' % (key, value)
30357 
      for key, value in self.__dict__.iteritems()]
30358 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
30359 
 
30360 
  def __eq__(self, other):
30361 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
30362 
 
30363 
  def __ne__(self, other):
30364 
    return not (self == other)
6985 anupam.sin 30365 
 
30366 
class changeShippingAddress_args:
30367 
  """
30368 
  Attributes:
30369 
   - orderId
30370 
   - line1
30371 
   - line2
30372 
   - city
30373 
   - state
30374 
   - pin
30375 
  """
30376 
 
30377 
  thrift_spec = (
30378 
    None, # 0
30379 
    (1, TType.I64, 'orderId', None, None, ), # 1
30380 
    (2, TType.STRING, 'line1', None, None, ), # 2
30381 
    (3, TType.STRING, 'line2', None, None, ), # 3
30382 
    (4, TType.STRING, 'city', None, None, ), # 4
30383 
    (5, TType.STRING, 'state', None, None, ), # 5
30384 
    (6, TType.STRING, 'pin', None, None, ), # 6
30385 
  )
30386 
 
30387 
  def __init__(self, orderId=None, line1=None, line2=None, city=None, state=None, pin=None,):
30388 
    self.orderId = orderId
30389 
    self.line1 = line1
30390 
    self.line2 = line2
30391 
    self.city = city
30392 
    self.state = state
30393 
    self.pin = pin
30394 
 
30395 
  def read(self, iprot):
30396 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
30397 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
30398 
      return
30399 
    iprot.readStructBegin()
30400 
    while True:
30401 
      (fname, ftype, fid) = iprot.readFieldBegin()
30402 
      if ftype == TType.STOP:
30403 
        break
30404 
      if fid == 1:
30405 
        if ftype == TType.I64:
30406 
          self.orderId = iprot.readI64();
30407 
        else:
30408 
          iprot.skip(ftype)
30409 
      elif fid == 2:
30410 
        if ftype == TType.STRING:
30411 
          self.line1 = iprot.readString();
30412 
        else:
30413 
          iprot.skip(ftype)
30414 
      elif fid == 3:
30415 
        if ftype == TType.STRING:
30416 
          self.line2 = iprot.readString();
30417 
        else:
30418 
          iprot.skip(ftype)
30419 
      elif fid == 4:
30420 
        if ftype == TType.STRING:
30421 
          self.city = iprot.readString();
30422 
        else:
30423 
          iprot.skip(ftype)
30424 
      elif fid == 5:
30425 
        if ftype == TType.STRING:
30426 
          self.state = iprot.readString();
30427 
        else:
30428 
          iprot.skip(ftype)
30429 
      elif fid == 6:
30430 
        if ftype == TType.STRING:
30431 
          self.pin = iprot.readString();
30432 
        else:
30433 
          iprot.skip(ftype)
30434 
      else:
30435 
        iprot.skip(ftype)
30436 
      iprot.readFieldEnd()
30437 
    iprot.readStructEnd()
30438 
 
30439 
  def write(self, oprot):
30440 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
30441 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
30442 
      return
30443 
    oprot.writeStructBegin('changeShippingAddress_args')
30444 
    if self.orderId is not None:
30445 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
30446 
      oprot.writeI64(self.orderId)
30447 
      oprot.writeFieldEnd()
30448 
    if self.line1 is not None:
30449 
      oprot.writeFieldBegin('line1', TType.STRING, 2)
30450 
      oprot.writeString(self.line1)
30451 
      oprot.writeFieldEnd()
30452 
    if self.line2 is not None:
30453 
      oprot.writeFieldBegin('line2', TType.STRING, 3)
30454 
      oprot.writeString(self.line2)
30455 
      oprot.writeFieldEnd()
30456 
    if self.city is not None:
30457 
      oprot.writeFieldBegin('city', TType.STRING, 4)
30458 
      oprot.writeString(self.city)
30459 
      oprot.writeFieldEnd()
30460 
    if self.state is not None:
30461 
      oprot.writeFieldBegin('state', TType.STRING, 5)
30462 
      oprot.writeString(self.state)
30463 
      oprot.writeFieldEnd()
30464 
    if self.pin is not None:
30465 
      oprot.writeFieldBegin('pin', TType.STRING, 6)
30466 
      oprot.writeString(self.pin)
30467 
      oprot.writeFieldEnd()
30468 
    oprot.writeFieldStop()
30469 
    oprot.writeStructEnd()
30470 
 
30471 
  def validate(self):
30472 
    return
30473 
 
30474 
 
30475 
  def __repr__(self):
30476 
    L = ['%s=%r' % (key, value)
30477 
      for key, value in self.__dict__.iteritems()]
30478 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
30479 
 
30480 
  def __eq__(self, other):
30481 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
30482 
 
30483 
  def __ne__(self, other):
30484 
    return not (self == other)
30485 
 
30486 
class changeShippingAddress_result:
30487 
  """
30488 
  Attributes:
30489 
   - success
30490 
  """
30491 
 
30492 
  thrift_spec = (
30493 
    (0, TType.BOOL, 'success', None, None, ), # 0
30494 
  )
30495 
 
30496 
  def __init__(self, success=None,):
30497 
    self.success = success
30498 
 
30499 
  def read(self, iprot):
30500 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
30501 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
30502 
      return
30503 
    iprot.readStructBegin()
30504 
    while True:
30505 
      (fname, ftype, fid) = iprot.readFieldBegin()
30506 
      if ftype == TType.STOP:
30507 
        break
30508 
      if fid == 0:
30509 
        if ftype == TType.BOOL:
30510 
          self.success = iprot.readBool();
30511 
        else:
30512 
          iprot.skip(ftype)
30513 
      else:
30514 
        iprot.skip(ftype)
30515 
      iprot.readFieldEnd()
30516 
    iprot.readStructEnd()
30517 
 
30518 
  def write(self, oprot):
30519 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
30520 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
30521 
      return
30522 
    oprot.writeStructBegin('changeShippingAddress_result')
30523 
    if self.success is not None:
30524 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
30525 
      oprot.writeBool(self.success)
30526 
      oprot.writeFieldEnd()
30527 
    oprot.writeFieldStop()
30528 
    oprot.writeStructEnd()
30529 
 
30530 
  def validate(self):
30531 
    return
30532 
 
30533 
 
30534 
  def __repr__(self):
30535 
    L = ['%s=%r' % (key, value)
30536 
      for key, value in self.__dict__.iteritems()]
30537 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
30538 
 
30539 
  def __eq__(self, other):
30540 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
30541 
 
30542 
  def __ne__(self, other):
30543 
    return not (self == other)
6988 rajveer 30544 
 
30545 
class retrieveInvoice_args:
30546 
  """
30547 
  Attributes:
30548 
   - orderId
7075 rajveer 30549 
   - userId
6988 rajveer 30550 
  """
30551 
 
30552 
  thrift_spec = (
30553 
    None, # 0
30554 
    (1, TType.I64, 'orderId', None, None, ), # 1
7075 rajveer 30555 
    (2, TType.I64, 'userId', None, None, ), # 2
6988 rajveer 30556 
  )
30557 
 
7075 rajveer 30558 
  def __init__(self, orderId=None, userId=None,):
6988 rajveer 30559 
    self.orderId = orderId
7075 rajveer 30560 
    self.userId = userId
6988 rajveer 30561 
 
30562 
  def read(self, iprot):
30563 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
30564 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
30565 
      return
30566 
    iprot.readStructBegin()
30567 
    while True:
30568 
      (fname, ftype, fid) = iprot.readFieldBegin()
30569 
      if ftype == TType.STOP:
30570 
        break
30571 
      if fid == 1:
30572 
        if ftype == TType.I64:
30573 
          self.orderId = iprot.readI64();
30574 
        else:
30575 
          iprot.skip(ftype)
7075 rajveer 30576 
      elif fid == 2:
30577 
        if ftype == TType.I64:
30578 
          self.userId = iprot.readI64();
30579 
        else:
30580 
          iprot.skip(ftype)
6988 rajveer 30581 
      else:
30582 
        iprot.skip(ftype)
30583 
      iprot.readFieldEnd()
30584 
    iprot.readStructEnd()
30585 
 
30586 
  def write(self, oprot):
30587 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
30588 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
30589 
      return
30590 
    oprot.writeStructBegin('retrieveInvoice_args')
30591 
    if self.orderId is not None:
30592 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
30593 
      oprot.writeI64(self.orderId)
30594 
      oprot.writeFieldEnd()
7075 rajveer 30595 
    if self.userId is not None:
30596 
      oprot.writeFieldBegin('userId', TType.I64, 2)
30597 
      oprot.writeI64(self.userId)
30598 
      oprot.writeFieldEnd()
6988 rajveer 30599 
    oprot.writeFieldStop()
30600 
    oprot.writeStructEnd()
30601 
 
30602 
  def validate(self):
30603 
    return
30604 
 
30605 
 
30606 
  def __repr__(self):
30607 
    L = ['%s=%r' % (key, value)
30608 
      for key, value in self.__dict__.iteritems()]
30609 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
30610 
 
30611 
  def __eq__(self, other):
30612 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
30613 
 
30614 
  def __ne__(self, other):
30615 
    return not (self == other)
30616 
 
30617 
class retrieveInvoice_result:
30618 
  """
30619 
  Attributes:
30620 
   - success
30621 
  """
30622 
 
30623 
  thrift_spec = (
30624 
    (0, TType.STRING, 'success', None, None, ), # 0
30625 
  )
30626 
 
30627 
  def __init__(self, success=None,):
30628 
    self.success = success
30629 
 
30630 
  def read(self, iprot):
30631 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
30632 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
30633 
      return
30634 
    iprot.readStructBegin()
30635 
    while True:
30636 
      (fname, ftype, fid) = iprot.readFieldBegin()
30637 
      if ftype == TType.STOP:
30638 
        break
30639 
      if fid == 0:
30640 
        if ftype == TType.STRING:
30641 
          self.success = iprot.readString();
30642 
        else:
30643 
          iprot.skip(ftype)
30644 
      else:
30645 
        iprot.skip(ftype)
30646 
      iprot.readFieldEnd()
30647 
    iprot.readStructEnd()
30648 
 
30649 
  def write(self, oprot):
30650 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
30651 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
30652 
      return
30653 
    oprot.writeStructBegin('retrieveInvoice_result')
30654 
    if self.success is not None:
30655 
      oprot.writeFieldBegin('success', TType.STRING, 0)
30656 
      oprot.writeString(self.success)
30657 
      oprot.writeFieldEnd()
30658 
    oprot.writeFieldStop()
30659 
    oprot.writeStructEnd()
30660 
 
30661 
  def validate(self):
30662 
    return
30663 
 
30664 
 
30665 
  def __repr__(self):
30666 
    L = ['%s=%r' % (key, value)
30667 
      for key, value in self.__dict__.iteritems()]
30668 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
30669 
 
30670 
  def __eq__(self, other):
30671 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
30672 
 
30673 
  def __ne__(self, other):
30674 
    return not (self == other)
7026 rajveer 30675 
 
30676 
class receiveUpdatesForRedExpress_args:
30677 
  """
30678 
  Attributes:
30679 
   - awbNumber
30680 
  """
30681 
 
30682 
  thrift_spec = (
30683 
    None, # 0
30684 
    (1, TType.STRING, 'awbNumber', None, None, ), # 1
30685 
  )
30686 
 
30687 
  def __init__(self, awbNumber=None,):
30688 
    self.awbNumber = awbNumber
30689 
 
30690 
  def read(self, iprot):
30691 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
30692 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
30693 
      return
30694 
    iprot.readStructBegin()
30695 
    while True:
30696 
      (fname, ftype, fid) = iprot.readFieldBegin()
30697 
      if ftype == TType.STOP:
30698 
        break
30699 
      if fid == 1:
30700 
        if ftype == TType.STRING:
30701 
          self.awbNumber = iprot.readString();
30702 
        else:
30703 
          iprot.skip(ftype)
30704 
      else:
30705 
        iprot.skip(ftype)
30706 
      iprot.readFieldEnd()
30707 
    iprot.readStructEnd()
30708 
 
30709 
  def write(self, oprot):
30710 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
30711 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
30712 
      return
30713 
    oprot.writeStructBegin('receiveUpdatesForRedExpress_args')
30714 
    if self.awbNumber is not None:
30715 
      oprot.writeFieldBegin('awbNumber', TType.STRING, 1)
30716 
      oprot.writeString(self.awbNumber)
30717 
      oprot.writeFieldEnd()
30718 
    oprot.writeFieldStop()
30719 
    oprot.writeStructEnd()
30720 
 
30721 
  def validate(self):
30722 
    return
30723 
 
30724 
 
30725 
  def __repr__(self):
30726 
    L = ['%s=%r' % (key, value)
30727 
      for key, value in self.__dict__.iteritems()]
30728 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
30729 
 
30730 
  def __eq__(self, other):
30731 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
30732 
 
30733 
  def __ne__(self, other):
30734 
    return not (self == other)
30735 
 
30736 
class receiveUpdatesForRedExpress_result:
30737 
  """
30738 
  Attributes:
30739 
   - success
30740 
  """
30741 
 
30742 
  thrift_spec = (
30743 
    (0, TType.LIST, 'success', (TType.STRING,None), None, ), # 0
30744 
  )
30745 
 
30746 
  def __init__(self, success=None,):
30747 
    self.success = success
30748 
 
30749 
  def read(self, iprot):
30750 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
30751 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
30752 
      return
30753 
    iprot.readStructBegin()
30754 
    while True:
30755 
      (fname, ftype, fid) = iprot.readFieldBegin()
30756 
      if ftype == TType.STOP:
30757 
        break
30758 
      if fid == 0:
30759 
        if ftype == TType.LIST:
30760 
          self.success = []
30761 
          (_etype733, _size730) = iprot.readListBegin()
30762 
          for _i734 in xrange(_size730):
30763 
            _elem735 = iprot.readString();
30764 
            self.success.append(_elem735)
30765 
          iprot.readListEnd()
30766 
        else:
30767 
          iprot.skip(ftype)
30768 
      else:
30769 
        iprot.skip(ftype)
30770 
      iprot.readFieldEnd()
30771 
    iprot.readStructEnd()
30772 
 
30773 
  def write(self, oprot):
30774 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
30775 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
30776 
      return
30777 
    oprot.writeStructBegin('receiveUpdatesForRedExpress_result')
30778 
    if self.success is not None:
30779 
      oprot.writeFieldBegin('success', TType.LIST, 0)
30780 
      oprot.writeListBegin(TType.STRING, len(self.success))
30781 
      for iter736 in self.success:
30782 
        oprot.writeString(iter736)
30783 
      oprot.writeListEnd()
30784 
      oprot.writeFieldEnd()
30785 
    oprot.writeFieldStop()
30786 
    oprot.writeStructEnd()
30787 
 
30788 
  def validate(self):
30789 
    return
30790 
 
30791 
 
30792 
  def __repr__(self):
30793 
    L = ['%s=%r' % (key, value)
30794 
      for key, value in self.__dict__.iteritems()]
30795 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
30796 
 
30797 
  def __eq__(self, other):
30798 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
30799 
 
30800 
  def __ne__(self, other):
30801 
    return not (self == other)
7073 anupam.sin 30802 
 
30803 
class createRechargeTransaction_args:
30804 
  """
30805 
  Attributes:
30806 
   - thriftRechargeTransaction
30807 
  """
30808 
 
30809 
  thrift_spec = (
30810 
    None, # 0
30811 
    (1, TType.STRUCT, 'thriftRechargeTransaction', (RechargeTransaction, RechargeTransaction.thrift_spec), None, ), # 1
30812 
  )
30813 
 
30814 
  def __init__(self, thriftRechargeTransaction=None,):
30815 
    self.thriftRechargeTransaction = thriftRechargeTransaction
30816 
 
30817 
  def read(self, iprot):
30818 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
30819 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
30820 
      return
30821 
    iprot.readStructBegin()
30822 
    while True:
30823 
      (fname, ftype, fid) = iprot.readFieldBegin()
30824 
      if ftype == TType.STOP:
30825 
        break
30826 
      if fid == 1:
30827 
        if ftype == TType.STRUCT:
30828 
          self.thriftRechargeTransaction = RechargeTransaction()
30829 
          self.thriftRechargeTransaction.read(iprot)
30830 
        else:
30831 
          iprot.skip(ftype)
30832 
      else:
30833 
        iprot.skip(ftype)
30834 
      iprot.readFieldEnd()
30835 
    iprot.readStructEnd()
30836 
 
30837 
  def write(self, oprot):
30838 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
30839 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
30840 
      return
30841 
    oprot.writeStructBegin('createRechargeTransaction_args')
30842 
    if self.thriftRechargeTransaction is not None:
30843 
      oprot.writeFieldBegin('thriftRechargeTransaction', TType.STRUCT, 1)
30844 
      self.thriftRechargeTransaction.write(oprot)
30845 
      oprot.writeFieldEnd()
30846 
    oprot.writeFieldStop()
30847 
    oprot.writeStructEnd()
30848 
 
30849 
  def validate(self):
30850 
    return
30851 
 
30852 
 
30853 
  def __repr__(self):
30854 
    L = ['%s=%r' % (key, value)
30855 
      for key, value in self.__dict__.iteritems()]
30856 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
30857 
 
30858 
  def __eq__(self, other):
30859 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
30860 
 
30861 
  def __ne__(self, other):
30862 
    return not (self == other)
30863 
 
30864 
class createRechargeTransaction_result:
30865 
  """
30866 
  Attributes:
30867 
   - success
30868 
  """
30869 
 
30870 
  thrift_spec = (
30871 
    (0, TType.STRUCT, 'success', (RechargeTransaction, RechargeTransaction.thrift_spec), None, ), # 0
30872 
  )
30873 
 
30874 
  def __init__(self, success=None,):
30875 
    self.success = success
30876 
 
30877 
  def read(self, iprot):
30878 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
30879 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
30880 
      return
30881 
    iprot.readStructBegin()
30882 
    while True:
30883 
      (fname, ftype, fid) = iprot.readFieldBegin()
30884 
      if ftype == TType.STOP:
30885 
        break
30886 
      if fid == 0:
30887 
        if ftype == TType.STRUCT:
30888 
          self.success = RechargeTransaction()
30889 
          self.success.read(iprot)
30890 
        else:
30891 
          iprot.skip(ftype)
30892 
      else:
30893 
        iprot.skip(ftype)
30894 
      iprot.readFieldEnd()
30895 
    iprot.readStructEnd()
30896 
 
30897 
  def write(self, oprot):
30898 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
30899 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
30900 
      return
30901 
    oprot.writeStructBegin('createRechargeTransaction_result')
30902 
    if self.success is not None:
30903 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
30904 
      self.success.write(oprot)
30905 
      oprot.writeFieldEnd()
30906 
    oprot.writeFieldStop()
30907 
    oprot.writeStructEnd()
30908 
 
30909 
  def validate(self):
30910 
    return
30911 
 
30912 
 
30913 
  def __repr__(self):
30914 
    L = ['%s=%r' % (key, value)
30915 
      for key, value in self.__dict__.iteritems()]
30916 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
30917 
 
30918 
  def __eq__(self, other):
30919 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
30920 
 
30921 
  def __ne__(self, other):
30922 
    return not (self == other)
7080 anupam.sin 30923 
 
7085 rajveer 30924 
class getRechargeTransactions_args:
30925 
  """
30926 
  Attributes:
30927 
   - storeId
30928 
  """
30929 
 
30930 
  thrift_spec = (
30931 
    None, # 0
30932 
    (1, TType.I64, 'storeId', None, None, ), # 1
30933 
  )
30934 
 
30935 
  def __init__(self, storeId=None,):
30936 
    self.storeId = storeId
30937 
 
30938 
  def read(self, iprot):
30939 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
30940 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
30941 
      return
30942 
    iprot.readStructBegin()
30943 
    while True:
30944 
      (fname, ftype, fid) = iprot.readFieldBegin()
30945 
      if ftype == TType.STOP:
30946 
        break
30947 
      if fid == 1:
30948 
        if ftype == TType.I64:
30949 
          self.storeId = iprot.readI64();
30950 
        else:
30951 
          iprot.skip(ftype)
30952 
      else:
30953 
        iprot.skip(ftype)
30954 
      iprot.readFieldEnd()
30955 
    iprot.readStructEnd()
30956 
 
30957 
  def write(self, oprot):
30958 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
30959 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
30960 
      return
30961 
    oprot.writeStructBegin('getRechargeTransactions_args')
30962 
    if self.storeId is not None:
30963 
      oprot.writeFieldBegin('storeId', TType.I64, 1)
30964 
      oprot.writeI64(self.storeId)
30965 
      oprot.writeFieldEnd()
30966 
    oprot.writeFieldStop()
30967 
    oprot.writeStructEnd()
30968 
 
30969 
  def validate(self):
30970 
    return
30971 
 
30972 
 
30973 
  def __repr__(self):
30974 
    L = ['%s=%r' % (key, value)
30975 
      for key, value in self.__dict__.iteritems()]
30976 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
30977 
 
30978 
  def __eq__(self, other):
30979 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
30980 
 
30981 
  def __ne__(self, other):
30982 
    return not (self == other)
30983 
 
30984 
class getRechargeTransactions_result:
30985 
  """
30986 
  Attributes:
30987 
   - success
30988 
  """
30989 
 
30990 
  thrift_spec = (
30991 
    (0, TType.LIST, 'success', (TType.STRUCT,(RechargeTransaction, RechargeTransaction.thrift_spec)), None, ), # 0
30992 
  )
30993 
 
30994 
  def __init__(self, success=None,):
30995 
    self.success = success
30996 
 
30997 
  def read(self, iprot):
30998 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
30999 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
31000 
      return
31001 
    iprot.readStructBegin()
31002 
    while True:
31003 
      (fname, ftype, fid) = iprot.readFieldBegin()
31004 
      if ftype == TType.STOP:
31005 
        break
31006 
      if fid == 0:
31007 
        if ftype == TType.LIST:
31008 
          self.success = []
31009 
          (_etype740, _size737) = iprot.readListBegin()
31010 
          for _i741 in xrange(_size737):
31011 
            _elem742 = RechargeTransaction()
31012 
            _elem742.read(iprot)
31013 
            self.success.append(_elem742)
31014 
          iprot.readListEnd()
31015 
        else:
31016 
          iprot.skip(ftype)
31017 
      else:
31018 
        iprot.skip(ftype)
31019 
      iprot.readFieldEnd()
31020 
    iprot.readStructEnd()
31021 
 
31022 
  def write(self, oprot):
31023 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
31024 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
31025 
      return
31026 
    oprot.writeStructBegin('getRechargeTransactions_result')
31027 
    if self.success is not None:
31028 
      oprot.writeFieldBegin('success', TType.LIST, 0)
31029 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
31030 
      for iter743 in self.success:
31031 
        iter743.write(oprot)
31032 
      oprot.writeListEnd()
31033 
      oprot.writeFieldEnd()
31034 
    oprot.writeFieldStop()
31035 
    oprot.writeStructEnd()
31036 
 
31037 
  def validate(self):
31038 
    return
31039 
 
31040 
 
31041 
  def __repr__(self):
31042 
    L = ['%s=%r' % (key, value)
31043 
      for key, value in self.__dict__.iteritems()]
31044 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
31045 
 
31046 
  def __eq__(self, other):
31047 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
31048 
 
31049 
  def __ne__(self, other):
31050 
    return not (self == other)
31051 
 
7080 anupam.sin 31052 
class getRechargeTransaction_args:
31053 
  """
31054 
  Attributes:
31055 
   - rechargeId
31056 
  """
31057 
 
31058 
  thrift_spec = (
31059 
    None, # 0
31060 
    (1, TType.I64, 'rechargeId', None, None, ), # 1
31061 
  )
31062 
 
31063 
  def __init__(self, rechargeId=None,):
31064 
    self.rechargeId = rechargeId
31065 
 
31066 
  def read(self, iprot):
31067 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
31068 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
31069 
      return
31070 
    iprot.readStructBegin()
31071 
    while True:
31072 
      (fname, ftype, fid) = iprot.readFieldBegin()
31073 
      if ftype == TType.STOP:
31074 
        break
31075 
      if fid == 1:
31076 
        if ftype == TType.I64:
31077 
          self.rechargeId = iprot.readI64();
31078 
        else:
31079 
          iprot.skip(ftype)
31080 
      else:
31081 
        iprot.skip(ftype)
31082 
      iprot.readFieldEnd()
31083 
    iprot.readStructEnd()
31084 
 
31085 
  def write(self, oprot):
31086 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
31087 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
31088 
      return
31089 
    oprot.writeStructBegin('getRechargeTransaction_args')
31090 
    if self.rechargeId is not None:
31091 
      oprot.writeFieldBegin('rechargeId', TType.I64, 1)
31092 
      oprot.writeI64(self.rechargeId)
31093 
      oprot.writeFieldEnd()
31094 
    oprot.writeFieldStop()
31095 
    oprot.writeStructEnd()
31096 
 
31097 
  def validate(self):
31098 
    return
31099 
 
31100 
 
31101 
  def __repr__(self):
31102 
    L = ['%s=%r' % (key, value)
31103 
      for key, value in self.__dict__.iteritems()]
31104 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
31105 
 
31106 
  def __eq__(self, other):
31107 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
31108 
 
31109 
  def __ne__(self, other):
31110 
    return not (self == other)
31111 
 
31112 
class getRechargeTransaction_result:
31113 
  """
31114 
  Attributes:
31115 
   - success
31116 
  """
31117 
 
31118 
  thrift_spec = (
31119 
    (0, TType.STRUCT, 'success', (RechargeTransaction, RechargeTransaction.thrift_spec), None, ), # 0
31120 
  )
31121 
 
31122 
  def __init__(self, success=None,):
31123 
    self.success = success
31124 
 
31125 
  def read(self, iprot):
31126 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
31127 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
31128 
      return
31129 
    iprot.readStructBegin()
31130 
    while True:
31131 
      (fname, ftype, fid) = iprot.readFieldBegin()
31132 
      if ftype == TType.STOP:
31133 
        break
31134 
      if fid == 0:
31135 
        if ftype == TType.STRUCT:
31136 
          self.success = RechargeTransaction()
31137 
          self.success.read(iprot)
31138 
        else:
31139 
          iprot.skip(ftype)
31140 
      else:
31141 
        iprot.skip(ftype)
31142 
      iprot.readFieldEnd()
31143 
    iprot.readStructEnd()
31144 
 
31145 
  def write(self, oprot):
31146 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
31147 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
31148 
      return
31149 
    oprot.writeStructBegin('getRechargeTransaction_result')
31150 
    if self.success is not None:
31151 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
31152 
      self.success.write(oprot)
31153 
      oprot.writeFieldEnd()
31154 
    oprot.writeFieldStop()
31155 
    oprot.writeStructEnd()
31156 
 
31157 
  def validate(self):
31158 
    return
31159 
 
31160 
 
31161 
  def __repr__(self):
31162 
    L = ['%s=%r' % (key, value)
31163 
      for key, value in self.__dict__.iteritems()]
31164 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
31165 
 
31166 
  def __eq__(self, other):
31167 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
31168 
 
31169 
  def __ne__(self, other):
31170 
    return not (self == other)
31171 
 
31172 
class getFRCs_args:
31173 
  """
31174 
  Attributes:
31175 
   - circleId
31176 
   - operatorId
31177 
  """
31178 
 
31179 
  thrift_spec = (
31180 
    None, # 0
31181 
    (1, TType.I64, 'circleId', None, None, ), # 1
31182 
    (2, TType.I64, 'operatorId', None, None, ), # 2
31183 
  )
31184 
 
31185 
  def __init__(self, circleId=None, operatorId=None,):
31186 
    self.circleId = circleId
31187 
    self.operatorId = operatorId
31188 
 
31189 
  def read(self, iprot):
31190 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
31191 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
31192 
      return
31193 
    iprot.readStructBegin()
31194 
    while True:
31195 
      (fname, ftype, fid) = iprot.readFieldBegin()
31196 
      if ftype == TType.STOP:
31197 
        break
31198 
      if fid == 1:
31199 
        if ftype == TType.I64:
31200 
          self.circleId = iprot.readI64();
31201 
        else:
31202 
          iprot.skip(ftype)
31203 
      elif fid == 2:
31204 
        if ftype == TType.I64:
31205 
          self.operatorId = iprot.readI64();
31206 
        else:
31207 
          iprot.skip(ftype)
31208 
      else:
31209 
        iprot.skip(ftype)
31210 
      iprot.readFieldEnd()
31211 
    iprot.readStructEnd()
31212 
 
31213 
  def write(self, oprot):
31214 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
31215 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
31216 
      return
31217 
    oprot.writeStructBegin('getFRCs_args')
31218 
    if self.circleId is not None:
31219 
      oprot.writeFieldBegin('circleId', TType.I64, 1)
31220 
      oprot.writeI64(self.circleId)
31221 
      oprot.writeFieldEnd()
31222 
    if self.operatorId is not None:
31223 
      oprot.writeFieldBegin('operatorId', TType.I64, 2)
31224 
      oprot.writeI64(self.operatorId)
31225 
      oprot.writeFieldEnd()
31226 
    oprot.writeFieldStop()
31227 
    oprot.writeStructEnd()
31228 
 
31229 
  def validate(self):
31230 
    return
31231 
 
31232 
 
31233 
  def __repr__(self):
31234 
    L = ['%s=%r' % (key, value)
31235 
      for key, value in self.__dict__.iteritems()]
31236 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
31237 
 
31238 
  def __eq__(self, other):
31239 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
31240 
 
31241 
  def __ne__(self, other):
31242 
    return not (self == other)
31243 
 
31244 
class getFRCs_result:
31245 
  """
31246 
  Attributes:
31247 
   - success
31248 
  """
31249 
 
31250 
  thrift_spec = (
31251 
    (0, TType.LIST, 'success', (TType.STRUCT,(FRC, FRC.thrift_spec)), None, ), # 0
31252 
  )
31253 
 
31254 
  def __init__(self, success=None,):
31255 
    self.success = success
31256 
 
31257 
  def read(self, iprot):
31258 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
31259 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
31260 
      return
31261 
    iprot.readStructBegin()
31262 
    while True:
31263 
      (fname, ftype, fid) = iprot.readFieldBegin()
31264 
      if ftype == TType.STOP:
31265 
        break
31266 
      if fid == 0:
31267 
        if ftype == TType.LIST:
31268 
          self.success = []
7085 rajveer 31269 
          (_etype747, _size744) = iprot.readListBegin()
31270 
          for _i748 in xrange(_size744):
31271 
            _elem749 = FRC()
31272 
            _elem749.read(iprot)
31273 
            self.success.append(_elem749)
7080 anupam.sin 31274 
          iprot.readListEnd()
31275 
        else:
31276 
          iprot.skip(ftype)
31277 
      else:
31278 
        iprot.skip(ftype)
31279 
      iprot.readFieldEnd()
31280 
    iprot.readStructEnd()
31281 
 
31282 
  def write(self, oprot):
31283 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
31284 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
31285 
      return
31286 
    oprot.writeStructBegin('getFRCs_result')
31287 
    if self.success is not None:
31288 
      oprot.writeFieldBegin('success', TType.LIST, 0)
31289 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
7085 rajveer 31290 
      for iter750 in self.success:
31291 
        iter750.write(oprot)
7080 anupam.sin 31292 
      oprot.writeListEnd()
31293 
      oprot.writeFieldEnd()
31294 
    oprot.writeFieldStop()
31295 
    oprot.writeStructEnd()
31296 
 
31297 
  def validate(self):
31298 
    return
31299 
 
31300 
 
31301 
  def __repr__(self):
31302 
    L = ['%s=%r' % (key, value)
31303 
      for key, value in self.__dict__.iteritems()]
31304 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
31305 
 
31306 
  def __eq__(self, other):
31307 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
31308 
 
31309 
  def __ne__(self, other):
31310 
    return not (self == other)
7096 anupam.sin 31311 
 
31312 
class getHotspotStore_args:
31313 
  """
31314 
  Attributes:
31315 
   - id
31316 
   - hotspotid
31317 
  """
31318 
 
31319 
  thrift_spec = (
31320 
    None, # 0
31321 
    (1, TType.I64, 'id', None, None, ), # 1
31322 
    (2, TType.STRING, 'hotspotid', None, None, ), # 2
31323 
  )
31324 
 
31325 
  def __init__(self, id=None, hotspotid=None,):
31326 
    self.id = id
31327 
    self.hotspotid = hotspotid
31328 
 
31329 
  def read(self, iprot):
31330 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
31331 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
31332 
      return
31333 
    iprot.readStructBegin()
31334 
    while True:
31335 
      (fname, ftype, fid) = iprot.readFieldBegin()
31336 
      if ftype == TType.STOP:
31337 
        break
31338 
      if fid == 1:
31339 
        if ftype == TType.I64:
31340 
          self.id = iprot.readI64();
31341 
        else:
31342 
          iprot.skip(ftype)
31343 
      elif fid == 2:
31344 
        if ftype == TType.STRING:
31345 
          self.hotspotid = iprot.readString();
31346 
        else:
31347 
          iprot.skip(ftype)
31348 
      else:
31349 
        iprot.skip(ftype)
31350 
      iprot.readFieldEnd()
31351 
    iprot.readStructEnd()
31352 
 
31353 
  def write(self, oprot):
31354 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
31355 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
31356 
      return
31357 
    oprot.writeStructBegin('getHotspotStore_args')
31358 
    if self.id is not None:
31359 
      oprot.writeFieldBegin('id', TType.I64, 1)
31360 
      oprot.writeI64(self.id)
31361 
      oprot.writeFieldEnd()
31362 
    if self.hotspotid is not None:
31363 
      oprot.writeFieldBegin('hotspotid', TType.STRING, 2)
31364 
      oprot.writeString(self.hotspotid)
31365 
      oprot.writeFieldEnd()
31366 
    oprot.writeFieldStop()
31367 
    oprot.writeStructEnd()
31368 
 
31369 
  def validate(self):
31370 
    return
31371 
 
31372 
 
31373 
  def __repr__(self):
31374 
    L = ['%s=%r' % (key, value)
31375 
      for key, value in self.__dict__.iteritems()]
31376 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
31377 
 
31378 
  def __eq__(self, other):
31379 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
31380 
 
31381 
  def __ne__(self, other):
31382 
    return not (self == other)
31383 
 
31384 
class getHotspotStore_result:
31385 
  """
31386 
  Attributes:
31387 
   - success
31388 
  """
31389 
 
31390 
  thrift_spec = (
31391 
    (0, TType.STRUCT, 'success', (HotspotStore, HotspotStore.thrift_spec), None, ), # 0
31392 
  )
31393 
 
31394 
  def __init__(self, success=None,):
31395 
    self.success = success
31396 
 
31397 
  def read(self, iprot):
31398 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
31399 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
31400 
      return
31401 
    iprot.readStructBegin()
31402 
    while True:
31403 
      (fname, ftype, fid) = iprot.readFieldBegin()
31404 
      if ftype == TType.STOP:
31405 
        break
31406 
      if fid == 0:
31407 
        if ftype == TType.STRUCT:
31408 
          self.success = HotspotStore()
31409 
          self.success.read(iprot)
31410 
        else:
31411 
          iprot.skip(ftype)
31412 
      else:
31413 
        iprot.skip(ftype)
31414 
      iprot.readFieldEnd()
31415 
    iprot.readStructEnd()
31416 
 
31417 
  def write(self, oprot):
31418 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
31419 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
31420 
      return
31421 
    oprot.writeStructBegin('getHotspotStore_result')
31422 
    if self.success is not None:
31423 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
31424 
      self.success.write(oprot)
31425 
      oprot.writeFieldEnd()
31426 
    oprot.writeFieldStop()
31427 
    oprot.writeStructEnd()
31428 
 
31429 
  def validate(self):
31430 
    return
31431 
 
31432 
 
31433 
  def __repr__(self):
31434 
    L = ['%s=%r' % (key, value)
31435 
      for key, value in self.__dict__.iteritems()]
31436 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
31437 
 
31438 
  def __eq__(self, other):
31439 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
31440 
 
31441 
  def __ne__(self, other):
31442 
    return not (self == other)
31443 
 
31444 
class getTelecomCircle_args:
31445 
  """
31446 
  Attributes:
31447 
   - id
31448 
   - code
31449 
  """
31450 
 
31451 
  thrift_spec = (
31452 
    None, # 0
31453 
    (1, TType.I64, 'id', None, None, ), # 1
31454 
    (2, TType.STRING, 'code', None, None, ), # 2
31455 
  )
31456 
 
31457 
  def __init__(self, id=None, code=None,):
31458 
    self.id = id
31459 
    self.code = code
31460 
 
31461 
  def read(self, iprot):
31462 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
31463 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
31464 
      return
31465 
    iprot.readStructBegin()
31466 
    while True:
31467 
      (fname, ftype, fid) = iprot.readFieldBegin()
31468 
      if ftype == TType.STOP:
31469 
        break
31470 
      if fid == 1:
31471 
        if ftype == TType.I64:
31472 
          self.id = iprot.readI64();
31473 
        else:
31474 
          iprot.skip(ftype)
31475 
      elif fid == 2:
31476 
        if ftype == TType.STRING:
31477 
          self.code = iprot.readString();
31478 
        else:
31479 
          iprot.skip(ftype)
31480 
      else:
31481 
        iprot.skip(ftype)
31482 
      iprot.readFieldEnd()
31483 
    iprot.readStructEnd()
31484 
 
31485 
  def write(self, oprot):
31486 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
31487 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
31488 
      return
31489 
    oprot.writeStructBegin('getTelecomCircle_args')
31490 
    if self.id is not None:
31491 
      oprot.writeFieldBegin('id', TType.I64, 1)
31492 
      oprot.writeI64(self.id)
31493 
      oprot.writeFieldEnd()
31494 
    if self.code is not None:
31495 
      oprot.writeFieldBegin('code', TType.STRING, 2)
31496 
      oprot.writeString(self.code)
31497 
      oprot.writeFieldEnd()
31498 
    oprot.writeFieldStop()
31499 
    oprot.writeStructEnd()
31500 
 
31501 
  def validate(self):
31502 
    return
31503 
 
31504 
 
31505 
  def __repr__(self):
31506 
    L = ['%s=%r' % (key, value)
31507 
      for key, value in self.__dict__.iteritems()]
31508 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
31509 
 
31510 
  def __eq__(self, other):
31511 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
31512 
 
31513 
  def __ne__(self, other):
31514 
    return not (self == other)
31515 
 
31516 
class getTelecomCircle_result:
31517 
  """
31518 
  Attributes:
31519 
   - success
31520 
  """
31521 
 
31522 
  thrift_spec = (
31523 
    (0, TType.STRUCT, 'success', (TelecomCircle, TelecomCircle.thrift_spec), None, ), # 0
31524 
  )
31525 
 
31526 
  def __init__(self, success=None,):
31527 
    self.success = success
31528 
 
31529 
  def read(self, iprot):
31530 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
31531 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
31532 
      return
31533 
    iprot.readStructBegin()
31534 
    while True:
31535 
      (fname, ftype, fid) = iprot.readFieldBegin()
31536 
      if ftype == TType.STOP:
31537 
        break
31538 
      if fid == 0:
31539 
        if ftype == TType.STRUCT:
31540 
          self.success = TelecomCircle()
31541 
          self.success.read(iprot)
31542 
        else:
31543 
          iprot.skip(ftype)
31544 
      else:
31545 
        iprot.skip(ftype)
31546 
      iprot.readFieldEnd()
31547 
    iprot.readStructEnd()
31548 
 
31549 
  def write(self, oprot):
31550 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
31551 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
31552 
      return
31553 
    oprot.writeStructBegin('getTelecomCircle_result')
31554 
    if self.success is not None:
31555 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
31556 
      self.success.write(oprot)
31557 
      oprot.writeFieldEnd()
31558 
    oprot.writeFieldStop()
31559 
    oprot.writeStructEnd()
31560 
 
31561 
  def validate(self):
31562 
    return
31563 
 
31564 
 
31565 
  def __repr__(self):
31566 
    L = ['%s=%r' % (key, value)
31567 
      for key, value in self.__dict__.iteritems()]
31568 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
31569 
 
31570 
  def __eq__(self, other):
31571 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
31572 
 
31573 
  def __ne__(self, other):
31574 
    return not (self == other)
7109 anupam.sin 31575 
 
31576 
class retrieveHotspotRechargeInvoice_args:
31577 
  """
31578 
  Attributes:
31579 
   - rechargeId
31580 
  """
31581 
 
31582 
  thrift_spec = (
31583 
    None, # 0
31584 
    (1, TType.I64, 'rechargeId', None, None, ), # 1
31585 
  )
31586 
 
31587 
  def __init__(self, rechargeId=None,):
31588 
    self.rechargeId = rechargeId
31589 
 
31590 
  def read(self, iprot):
31591 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
31592 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
31593 
      return
31594 
    iprot.readStructBegin()
31595 
    while True:
31596 
      (fname, ftype, fid) = iprot.readFieldBegin()
31597 
      if ftype == TType.STOP:
31598 
        break
31599 
      if fid == 1:
31600 
        if ftype == TType.I64:
31601 
          self.rechargeId = iprot.readI64();
31602 
        else:
31603 
          iprot.skip(ftype)
31604 
      else:
31605 
        iprot.skip(ftype)
31606 
      iprot.readFieldEnd()
31607 
    iprot.readStructEnd()
31608 
 
31609 
  def write(self, oprot):
31610 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
31611 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
31612 
      return
31613 
    oprot.writeStructBegin('retrieveHotspotRechargeInvoice_args')
31614 
    if self.rechargeId is not None:
31615 
      oprot.writeFieldBegin('rechargeId', TType.I64, 1)
31616 
      oprot.writeI64(self.rechargeId)
31617 
      oprot.writeFieldEnd()
31618 
    oprot.writeFieldStop()
31619 
    oprot.writeStructEnd()
31620 
 
31621 
  def validate(self):
31622 
    return
31623 
 
31624 
 
31625 
  def __repr__(self):
31626 
    L = ['%s=%r' % (key, value)
31627 
      for key, value in self.__dict__.iteritems()]
31628 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
31629 
 
31630 
  def __eq__(self, other):
31631 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
31632 
 
31633 
  def __ne__(self, other):
31634 
    return not (self == other)
31635 
 
31636 
class retrieveHotspotRechargeInvoice_result:
31637 
  """
31638 
  Attributes:
31639 
   - success
31640 
  """
31641 
 
31642 
  thrift_spec = (
31643 
    (0, TType.STRING, 'success', None, None, ), # 0
31644 
  )
31645 
 
31646 
  def __init__(self, success=None,):
31647 
    self.success = success
31648 
 
31649 
  def read(self, iprot):
31650 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
31651 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
31652 
      return
31653 
    iprot.readStructBegin()
31654 
    while True:
31655 
      (fname, ftype, fid) = iprot.readFieldBegin()
31656 
      if ftype == TType.STOP:
31657 
        break
31658 
      if fid == 0:
31659 
        if ftype == TType.STRING:
31660 
          self.success = iprot.readString();
31661 
        else:
31662 
          iprot.skip(ftype)
31663 
      else:
31664 
        iprot.skip(ftype)
31665 
      iprot.readFieldEnd()
31666 
    iprot.readStructEnd()
31667 
 
31668 
  def write(self, oprot):
31669 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
31670 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
31671 
      return
31672 
    oprot.writeStructBegin('retrieveHotspotRechargeInvoice_result')
31673 
    if self.success is not None:
31674 
      oprot.writeFieldBegin('success', TType.STRING, 0)
31675 
      oprot.writeString(self.success)
31676 
      oprot.writeFieldEnd()
31677 
    oprot.writeFieldStop()
31678 
    oprot.writeStructEnd()
31679 
 
31680 
  def validate(self):
31681 
    return
31682 
 
31683 
 
31684 
  def __repr__(self):
31685 
    L = ['%s=%r' % (key, value)
31686 
      for key, value in self.__dict__.iteritems()]
31687 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
31688 
 
31689 
  def __eq__(self, other):
31690 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
31691 
 
31692 
  def __ne__(self, other):
31693 
    return not (self == other)