Subversion Repositories SmartDukaan

Rev

Rev 7075 | Rev 7085 | 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 
 
7080 anupam.sin 1497 
  def getRechargeTransaction(self, rechargeId):
1498 
    """
1499 
    Parameters:
1500 
     - rechargeId
1501 
    """
1502 
    pass
7073 anupam.sin 1503 
 
7080 anupam.sin 1504 
  def getFRCs(self, circleId, operatorId):
1505 
    """
1506 
    Parameters:
1507 
     - circleId
1508 
     - operatorId
1509 
    """
1510 
    pass
1511 
 
1512 
 
3376 rajveer 1513 
class Client(shop2020.thriftpy.generic.GenericService.Client, Iface):
94 ashish 1514 
  def __init__(self, iprot, oprot=None):
3376 rajveer 1515 
    shop2020.thriftpy.generic.GenericService.Client.__init__(self, iprot, oprot)
94 ashish 1516 
 
1517 
  def createTransaction(self, transaction):
1518 
    """
1519 
    Parameters:
1520 
     - transaction
1521 
    """
1522 
    self.send_createTransaction(transaction)
132 ashish 1523 
    return self.recv_createTransaction()
94 ashish 1524 
 
1525 
  def send_createTransaction(self, transaction):
1526 
    self._oprot.writeMessageBegin('createTransaction', TMessageType.CALL, self._seqid)
1527 
    args = createTransaction_args()
1528 
    args.transaction = transaction
1529 
    args.write(self._oprot)
1530 
    self._oprot.writeMessageEnd()
1531 
    self._oprot.trans.flush()
1532 
 
1533 
  def recv_createTransaction(self, ):
1534 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1535 
    if mtype == TMessageType.EXCEPTION:
1536 
      x = TApplicationException()
1537 
      x.read(self._iprot)
1538 
      self._iprot.readMessageEnd()
1539 
      raise x
1540 
    result = createTransaction_result()
1541 
    result.read(self._iprot)
1542 
    self._iprot.readMessageEnd()
3431 rajveer 1543 
    if result.success is not None:
132 ashish 1544 
      return result.success
3431 rajveer 1545 
    if result.ex is not None:
94 ashish 1546 
      raise result.ex
132 ashish 1547 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createTransaction failed: unknown result");
94 ashish 1548 
 
1549 
  def getTransaction(self, id):
1550 
    """
1551 
    Parameters:
1552 
     - id
1553 
    """
1554 
    self.send_getTransaction(id)
1555 
    return self.recv_getTransaction()
1556 
 
1557 
  def send_getTransaction(self, id):
1558 
    self._oprot.writeMessageBegin('getTransaction', TMessageType.CALL, self._seqid)
1559 
    args = getTransaction_args()
1560 
    args.id = id
1561 
    args.write(self._oprot)
1562 
    self._oprot.writeMessageEnd()
1563 
    self._oprot.trans.flush()
1564 
 
1565 
  def recv_getTransaction(self, ):
1566 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1567 
    if mtype == TMessageType.EXCEPTION:
1568 
      x = TApplicationException()
1569 
      x.read(self._iprot)
1570 
      self._iprot.readMessageEnd()
1571 
      raise x
1572 
    result = getTransaction_result()
1573 
    result.read(self._iprot)
1574 
    self._iprot.readMessageEnd()
3431 rajveer 1575 
    if result.success is not None:
94 ashish 1576 
      return result.success
3431 rajveer 1577 
    if result.ex is not None:
94 ashish 1578 
      raise result.ex
1579 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransaction failed: unknown result");
1580 
 
1581 
  def getTransactionsForCustomer(self, customerId, from_date, to_date, status):
1582 
    """
1583 
    Parameters:
1584 
     - customerId
1585 
     - from_date
1586 
     - to_date
1587 
     - status
1588 
    """
1589 
    self.send_getTransactionsForCustomer(customerId, from_date, to_date, status)
1590 
    return self.recv_getTransactionsForCustomer()
1591 
 
1592 
  def send_getTransactionsForCustomer(self, customerId, from_date, to_date, status):
1593 
    self._oprot.writeMessageBegin('getTransactionsForCustomer', TMessageType.CALL, self._seqid)
1594 
    args = getTransactionsForCustomer_args()
1595 
    args.customerId = customerId
1596 
    args.from_date = from_date
1597 
    args.to_date = to_date
1598 
    args.status = status
1599 
    args.write(self._oprot)
1600 
    self._oprot.writeMessageEnd()
1601 
    self._oprot.trans.flush()
1602 
 
1603 
  def recv_getTransactionsForCustomer(self, ):
1604 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1605 
    if mtype == TMessageType.EXCEPTION:
1606 
      x = TApplicationException()
1607 
      x.read(self._iprot)
1608 
      self._iprot.readMessageEnd()
1609 
      raise x
1610 
    result = getTransactionsForCustomer_result()
1611 
    result.read(self._iprot)
1612 
    self._iprot.readMessageEnd()
3431 rajveer 1613 
    if result.success is not None:
94 ashish 1614 
      return result.success
3431 rajveer 1615 
    if result.ex is not None:
94 ashish 1616 
      raise result.ex
1617 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransactionsForCustomer failed: unknown result");
1618 
 
132 ashish 1619 
  def getTransactionsForShoppingCartId(self, shoppingCartId):
1620 
    """
1621 
    Parameters:
1622 
     - shoppingCartId
1623 
    """
1624 
    self.send_getTransactionsForShoppingCartId(shoppingCartId)
1625 
    return self.recv_getTransactionsForShoppingCartId()
1626 
 
1627 
  def send_getTransactionsForShoppingCartId(self, shoppingCartId):
1628 
    self._oprot.writeMessageBegin('getTransactionsForShoppingCartId', TMessageType.CALL, self._seqid)
1629 
    args = getTransactionsForShoppingCartId_args()
1630 
    args.shoppingCartId = shoppingCartId
1631 
    args.write(self._oprot)
1632 
    self._oprot.writeMessageEnd()
1633 
    self._oprot.trans.flush()
1634 
 
1635 
  def recv_getTransactionsForShoppingCartId(self, ):
1636 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1637 
    if mtype == TMessageType.EXCEPTION:
1638 
      x = TApplicationException()
1639 
      x.read(self._iprot)
1640 
      self._iprot.readMessageEnd()
1641 
      raise x
1642 
    result = getTransactionsForShoppingCartId_result()
1643 
    result.read(self._iprot)
1644 
    self._iprot.readMessageEnd()
3431 rajveer 1645 
    if result.success is not None:
132 ashish 1646 
      return result.success
3431 rajveer 1647 
    if result.ex is not None:
132 ashish 1648 
      raise result.ex
1649 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransactionsForShoppingCartId failed: unknown result");
1650 
 
94 ashish 1651 
  def getTransactionStatus(self, transactionId):
1652 
    """
1653 
    Parameters:
1654 
     - transactionId
1655 
    """
1656 
    self.send_getTransactionStatus(transactionId)
1657 
    return self.recv_getTransactionStatus()
1658 
 
1659 
  def send_getTransactionStatus(self, transactionId):
1660 
    self._oprot.writeMessageBegin('getTransactionStatus', TMessageType.CALL, self._seqid)
1661 
    args = getTransactionStatus_args()
1662 
    args.transactionId = transactionId
1663 
    args.write(self._oprot)
1664 
    self._oprot.writeMessageEnd()
1665 
    self._oprot.trans.flush()
1666 
 
1667 
  def recv_getTransactionStatus(self, ):
1668 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1669 
    if mtype == TMessageType.EXCEPTION:
1670 
      x = TApplicationException()
1671 
      x.read(self._iprot)
1672 
      self._iprot.readMessageEnd()
1673 
      raise x
1674 
    result = getTransactionStatus_result()
1675 
    result.read(self._iprot)
1676 
    self._iprot.readMessageEnd()
3431 rajveer 1677 
    if result.success is not None:
94 ashish 1678 
      return result.success
3431 rajveer 1679 
    if result.ex is not None:
94 ashish 1680 
      raise result.ex
1681 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransactionStatus failed: unknown result");
1682 
 
5527 anupam.sin 1683 
  def changeTransactionStatus(self, transactionId, status, description, pickUp, orderType):
94 ashish 1684 
    """
1685 
    Parameters:
1686 
     - transactionId
1687 
     - status
1688 
     - description
5527 anupam.sin 1689 
     - pickUp
1690 
     - orderType
94 ashish 1691 
    """
5527 anupam.sin 1692 
    self.send_changeTransactionStatus(transactionId, status, description, pickUp, orderType)
94 ashish 1693 
    return self.recv_changeTransactionStatus()
1694 
 
5527 anupam.sin 1695 
  def send_changeTransactionStatus(self, transactionId, status, description, pickUp, orderType):
94 ashish 1696 
    self._oprot.writeMessageBegin('changeTransactionStatus', TMessageType.CALL, self._seqid)
1697 
    args = changeTransactionStatus_args()
1698 
    args.transactionId = transactionId
1699 
    args.status = status
1700 
    args.description = description
5527 anupam.sin 1701 
    args.pickUp = pickUp
1702 
    args.orderType = orderType
94 ashish 1703 
    args.write(self._oprot)
1704 
    self._oprot.writeMessageEnd()
1705 
    self._oprot.trans.flush()
1706 
 
1707 
  def recv_changeTransactionStatus(self, ):
1708 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1709 
    if mtype == TMessageType.EXCEPTION:
1710 
      x = TApplicationException()
1711 
      x.read(self._iprot)
1712 
      self._iprot.readMessageEnd()
1713 
      raise x
1714 
    result = changeTransactionStatus_result()
1715 
    result.read(self._iprot)
1716 
    self._iprot.readMessageEnd()
3431 rajveer 1717 
    if result.success is not None:
94 ashish 1718 
      return result.success
3431 rajveer 1719 
    if result.ex is not None:
94 ashish 1720 
      raise result.ex
1721 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "changeTransactionStatus failed: unknown result");
1722 
 
1398 varun.gupt 1723 
  def enqueueTransactionInfoEmail(self, transactionId):
1382 varun.gupt 1724 
    """
1725 
    Parameters:
1726 
     - transactionId
1727 
    """
1398 varun.gupt 1728 
    self.send_enqueueTransactionInfoEmail(transactionId)
1729 
    return self.recv_enqueueTransactionInfoEmail()
1382 varun.gupt 1730 
 
1398 varun.gupt 1731 
  def send_enqueueTransactionInfoEmail(self, transactionId):
1732 
    self._oprot.writeMessageBegin('enqueueTransactionInfoEmail', TMessageType.CALL, self._seqid)
1733 
    args = enqueueTransactionInfoEmail_args()
1382 varun.gupt 1734 
    args.transactionId = transactionId
1735 
    args.write(self._oprot)
1736 
    self._oprot.writeMessageEnd()
1737 
    self._oprot.trans.flush()
1738 
 
1398 varun.gupt 1739 
  def recv_enqueueTransactionInfoEmail(self, ):
1382 varun.gupt 1740 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1741 
    if mtype == TMessageType.EXCEPTION:
1742 
      x = TApplicationException()
1743 
      x.read(self._iprot)
1744 
      self._iprot.readMessageEnd()
1745 
      raise x
1398 varun.gupt 1746 
    result = enqueueTransactionInfoEmail_result()
1382 varun.gupt 1747 
    result.read(self._iprot)
1748 
    self._iprot.readMessageEnd()
3431 rajveer 1749 
    if result.success is not None:
1382 varun.gupt 1750 
      return result.success
3431 rajveer 1751 
    if result.ex is not None:
1382 varun.gupt 1752 
      raise result.ex
1398 varun.gupt 1753 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "enqueueTransactionInfoEmail failed: unknown result");
1382 varun.gupt 1754 
 
4801 anupam.sin 1755 
  def getAllOrders(self, statuses, from_date, to_date, warehouse_id):
94 ashish 1756 
    """
1757 
    Parameters:
4801 anupam.sin 1758 
     - statuses
483 rajveer 1759 
     - from_date
1760 
     - to_date
1761 
     - warehouse_id
94 ashish 1762 
    """
4801 anupam.sin 1763 
    self.send_getAllOrders(statuses, from_date, to_date, warehouse_id)
483 rajveer 1764 
    return self.recv_getAllOrders()
94 ashish 1765 
 
4801 anupam.sin 1766 
  def send_getAllOrders(self, statuses, from_date, to_date, warehouse_id):
483 rajveer 1767 
    self._oprot.writeMessageBegin('getAllOrders', TMessageType.CALL, self._seqid)
1768 
    args = getAllOrders_args()
4801 anupam.sin 1769 
    args.statuses = statuses
483 rajveer 1770 
    args.from_date = from_date
1771 
    args.to_date = to_date
1772 
    args.warehouse_id = warehouse_id
94 ashish 1773 
    args.write(self._oprot)
1774 
    self._oprot.writeMessageEnd()
1775 
    self._oprot.trans.flush()
1776 
 
483 rajveer 1777 
  def recv_getAllOrders(self, ):
94 ashish 1778 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1779 
    if mtype == TMessageType.EXCEPTION:
1780 
      x = TApplicationException()
1781 
      x.read(self._iprot)
1782 
      self._iprot.readMessageEnd()
1783 
      raise x
483 rajveer 1784 
    result = getAllOrders_result()
94 ashish 1785 
    result.read(self._iprot)
1786 
    self._iprot.readMessageEnd()
3431 rajveer 1787 
    if result.success is not None:
94 ashish 1788 
      return result.success
3431 rajveer 1789 
    if result.ex is not None:
94 ashish 1790 
      raise result.ex
483 rajveer 1791 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllOrders failed: unknown result");
94 ashish 1792 
 
4133 chandransh 1793 
  def getOrdersInBatch(self, statuses, offset, limit, warehouse_id):
1794 
    """
1795 
    Returns at most 'limit' orders with the given statuses for the given warehouse starting from the given offset.
1796 
    Pass the status as null and the limit as 0 to ignore them.
1797 
 
1798 
    Parameters:
1799 
     - statuses
1800 
     - offset
1801 
     - limit
1802 
     - warehouse_id
1803 
    """
1804 
    self.send_getOrdersInBatch(statuses, offset, limit, warehouse_id)
1805 
    return self.recv_getOrdersInBatch()
1806 
 
1807 
  def send_getOrdersInBatch(self, statuses, offset, limit, warehouse_id):
1808 
    self._oprot.writeMessageBegin('getOrdersInBatch', TMessageType.CALL, self._seqid)
1809 
    args = getOrdersInBatch_args()
1810 
    args.statuses = statuses
1811 
    args.offset = offset
1812 
    args.limit = limit
1813 
    args.warehouse_id = warehouse_id
1814 
    args.write(self._oprot)
1815 
    self._oprot.writeMessageEnd()
1816 
    self._oprot.trans.flush()
1817 
 
1818 
  def recv_getOrdersInBatch(self, ):
1819 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1820 
    if mtype == TMessageType.EXCEPTION:
1821 
      x = TApplicationException()
1822 
      x.read(self._iprot)
1823 
      self._iprot.readMessageEnd()
1824 
      raise x
1825 
    result = getOrdersInBatch_result()
1826 
    result.read(self._iprot)
1827 
    self._iprot.readMessageEnd()
1828 
    if result.success is not None:
1829 
      return result.success
1830 
    if result.ex is not None:
1831 
      raise result.ex
1832 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersInBatch failed: unknown result");
1833 
 
1834 
  def getOrderCount(self, statuses, warehouseId):
1835 
    """
1836 
    Returns the count of orders with the given statuses assigned to the given warehouse.
1837 
 
1838 
    Parameters:
1839 
     - statuses
1840 
     - warehouseId
1841 
    """
1842 
    self.send_getOrderCount(statuses, warehouseId)
1843 
    return self.recv_getOrderCount()
1844 
 
1845 
  def send_getOrderCount(self, statuses, warehouseId):
1846 
    self._oprot.writeMessageBegin('getOrderCount', TMessageType.CALL, self._seqid)
1847 
    args = getOrderCount_args()
1848 
    args.statuses = statuses
1849 
    args.warehouseId = warehouseId
1850 
    args.write(self._oprot)
1851 
    self._oprot.writeMessageEnd()
1852 
    self._oprot.trans.flush()
1853 
 
1854 
  def recv_getOrderCount(self, ):
1855 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1856 
    if mtype == TMessageType.EXCEPTION:
1857 
      x = TApplicationException()
1858 
      x.read(self._iprot)
1859 
      self._iprot.readMessageEnd()
1860 
      raise x
1861 
    result = getOrderCount_result()
1862 
    result.read(self._iprot)
1863 
    self._iprot.readMessageEnd()
1864 
    if result.success is not None:
1865 
      return result.success
1866 
    if result.ex is not None:
1867 
      raise result.ex
1868 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderCount failed: unknown result");
1869 
 
999 varun.gupt 1870 
  def getOrdersByBillingDate(self, status, start_billing_date, end_billing_date, warehouse_id):
1871 
    """
1132 chandransh 1872 
    Returns orders within a range of their billing dates
3431 rajveer 1873 
 
999 varun.gupt 1874 
    Parameters:
1875 
     - status
1876 
     - start_billing_date
1877 
     - end_billing_date
1878 
     - warehouse_id
1879 
    """
1880 
    self.send_getOrdersByBillingDate(status, start_billing_date, end_billing_date, warehouse_id)
1881 
    return self.recv_getOrdersByBillingDate()
1882 
 
1883 
  def send_getOrdersByBillingDate(self, status, start_billing_date, end_billing_date, warehouse_id):
1884 
    self._oprot.writeMessageBegin('getOrdersByBillingDate', TMessageType.CALL, self._seqid)
1885 
    args = getOrdersByBillingDate_args()
1886 
    args.status = status
1887 
    args.start_billing_date = start_billing_date
1888 
    args.end_billing_date = end_billing_date
1889 
    args.warehouse_id = warehouse_id
1890 
    args.write(self._oprot)
1891 
    self._oprot.writeMessageEnd()
1892 
    self._oprot.trans.flush()
1893 
 
1894 
  def recv_getOrdersByBillingDate(self, ):
1895 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1896 
    if mtype == TMessageType.EXCEPTION:
1897 
      x = TApplicationException()
1898 
      x.read(self._iprot)
1899 
      self._iprot.readMessageEnd()
1900 
      raise x
1901 
    result = getOrdersByBillingDate_result()
1902 
    result.read(self._iprot)
1903 
    self._iprot.readMessageEnd()
3431 rajveer 1904 
    if result.success is not None:
999 varun.gupt 1905 
      return result.success
3431 rajveer 1906 
    if result.ex is not None:
999 varun.gupt 1907 
      raise result.ex
1908 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersByBillingDate failed: unknown result");
1909 
 
3451 chandransh 1910 
  def getOrdersByShippingDate(self, fromShippingDate, toShippingDate, providerId, warehouseId, cod):
3427 chandransh 1911 
    """
1912 
    Returns orders for a particular provider and warehouse which were shipped between the given dates.
3451 chandransh 1913 
    Returned orders comprise of COD orders if cod parameter is true. It comprises of prepaid orders otherwise.
1914 
    Pass providerId and warehouseId as -1 to ignore both these parameters.
3431 rajveer 1915 
 
3427 chandransh 1916 
    Parameters:
1917 
     - fromShippingDate
1918 
     - toShippingDate
1919 
     - providerId
1920 
     - warehouseId
3451 chandransh 1921 
     - cod
3427 chandransh 1922 
    """
3451 chandransh 1923 
    self.send_getOrdersByShippingDate(fromShippingDate, toShippingDate, providerId, warehouseId, cod)
3427 chandransh 1924 
    return self.recv_getOrdersByShippingDate()
1925 
 
3451 chandransh 1926 
  def send_getOrdersByShippingDate(self, fromShippingDate, toShippingDate, providerId, warehouseId, cod):
3427 chandransh 1927 
    self._oprot.writeMessageBegin('getOrdersByShippingDate', TMessageType.CALL, self._seqid)
1928 
    args = getOrdersByShippingDate_args()
1929 
    args.fromShippingDate = fromShippingDate
1930 
    args.toShippingDate = toShippingDate
1931 
    args.providerId = providerId
1932 
    args.warehouseId = warehouseId
3451 chandransh 1933 
    args.cod = cod
3427 chandransh 1934 
    args.write(self._oprot)
1935 
    self._oprot.writeMessageEnd()
1936 
    self._oprot.trans.flush()
1937 
 
1938 
  def recv_getOrdersByShippingDate(self, ):
1939 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1940 
    if mtype == TMessageType.EXCEPTION:
1941 
      x = TApplicationException()
1942 
      x.read(self._iprot)
1943 
      self._iprot.readMessageEnd()
1944 
      raise x
1945 
    result = getOrdersByShippingDate_result()
1946 
    result.read(self._iprot)
1947 
    self._iprot.readMessageEnd()
3431 rajveer 1948 
    if result.success is not None:
3427 chandransh 1949 
      return result.success
3431 rajveer 1950 
    if result.ex is not None:
3427 chandransh 1951 
      raise result.ex
1952 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersByShippingDate failed: unknown result");
1953 
 
1382 varun.gupt 1954 
  def getReturnableOrdersForCustomer(self, customer_id, limit):
1955 
    """
1956 
    Returns order ids for orders which can be returned
3431 rajveer 1957 
 
1382 varun.gupt 1958 
    Parameters:
1959 
     - customer_id
1960 
     - limit
1961 
    """
1962 
    self.send_getReturnableOrdersForCustomer(customer_id, limit)
1963 
    return self.recv_getReturnableOrdersForCustomer()
1964 
 
1965 
  def send_getReturnableOrdersForCustomer(self, customer_id, limit):
1966 
    self._oprot.writeMessageBegin('getReturnableOrdersForCustomer', TMessageType.CALL, self._seqid)
1967 
    args = getReturnableOrdersForCustomer_args()
1968 
    args.customer_id = customer_id
1969 
    args.limit = limit
1970 
    args.write(self._oprot)
1971 
    self._oprot.writeMessageEnd()
1972 
    self._oprot.trans.flush()
1973 
 
1974 
  def recv_getReturnableOrdersForCustomer(self, ):
1975 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1976 
    if mtype == TMessageType.EXCEPTION:
1977 
      x = TApplicationException()
1978 
      x.read(self._iprot)
1979 
      self._iprot.readMessageEnd()
1980 
      raise x
1981 
    result = getReturnableOrdersForCustomer_result()
1982 
    result.read(self._iprot)
1983 
    self._iprot.readMessageEnd()
3431 rajveer 1984 
    if result.success is not None:
1382 varun.gupt 1985 
      return result.success
3431 rajveer 1986 
    if result.ex is not None:
1382 varun.gupt 1987 
      raise result.ex
1988 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReturnableOrdersForCustomer failed: unknown result");
1989 
 
1990 
  def getCancellableOrdersForCustomer(self, customer_id, limit):
1991 
    """
1992 
    Returns order ids for orders which can be cancelled
3431 rajveer 1993 
 
1382 varun.gupt 1994 
    Parameters:
1995 
     - customer_id
1996 
     - limit
1997 
    """
1998 
    self.send_getCancellableOrdersForCustomer(customer_id, limit)
1999 
    return self.recv_getCancellableOrdersForCustomer()
2000 
 
2001 
  def send_getCancellableOrdersForCustomer(self, customer_id, limit):
2002 
    self._oprot.writeMessageBegin('getCancellableOrdersForCustomer', TMessageType.CALL, self._seqid)
2003 
    args = getCancellableOrdersForCustomer_args()
2004 
    args.customer_id = customer_id
2005 
    args.limit = limit
2006 
    args.write(self._oprot)
2007 
    self._oprot.writeMessageEnd()
2008 
    self._oprot.trans.flush()
2009 
 
2010 
  def recv_getCancellableOrdersForCustomer(self, ):
2011 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2012 
    if mtype == TMessageType.EXCEPTION:
2013 
      x = TApplicationException()
2014 
      x.read(self._iprot)
2015 
      self._iprot.readMessageEnd()
2016 
      raise x
2017 
    result = getCancellableOrdersForCustomer_result()
2018 
    result.read(self._iprot)
2019 
    self._iprot.readMessageEnd()
3431 rajveer 2020 
    if result.success is not None:
1382 varun.gupt 2021 
      return result.success
3431 rajveer 2022 
    if result.ex is not None:
1382 varun.gupt 2023 
      raise result.ex
2024 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCancellableOrdersForCustomer failed: unknown result");
2025 
 
483 rajveer 2026 
  def changeOrderStatus(self, orderId, status, description):
94 ashish 2027 
    """
2028 
    Parameters:
483 rajveer 2029 
     - orderId
2030 
     - status
2031 
     - description
94 ashish 2032 
    """
483 rajveer 2033 
    self.send_changeOrderStatus(orderId, status, description)
2034 
    return self.recv_changeOrderStatus()
94 ashish 2035 
 
483 rajveer 2036 
  def send_changeOrderStatus(self, orderId, status, description):
2037 
    self._oprot.writeMessageBegin('changeOrderStatus', TMessageType.CALL, self._seqid)
2038 
    args = changeOrderStatus_args()
2039 
    args.orderId = orderId
2040 
    args.status = status
2041 
    args.description = description
94 ashish 2042 
    args.write(self._oprot)
2043 
    self._oprot.writeMessageEnd()
2044 
    self._oprot.trans.flush()
2045 
 
483 rajveer 2046 
  def recv_changeOrderStatus(self, ):
94 ashish 2047 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2048 
    if mtype == TMessageType.EXCEPTION:
2049 
      x = TApplicationException()
2050 
      x.read(self._iprot)
2051 
      self._iprot.readMessageEnd()
2052 
      raise x
483 rajveer 2053 
    result = changeOrderStatus_result()
94 ashish 2054 
    result.read(self._iprot)
2055 
    self._iprot.readMessageEnd()
3431 rajveer 2056 
    if result.success is not None:
94 ashish 2057 
      return result.success
3431 rajveer 2058 
    if result.ex is not None:
94 ashish 2059 
      raise result.ex
483 rajveer 2060 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "changeOrderStatus failed: unknown result");
94 ashish 2061 
 
1528 ankur.sing 2062 
  def getOrdersForTransaction(self, transactionId, customerId):
94 ashish 2063 
    """
1528 ankur.sing 2064 
    Returns list of orders for given transaction Id. Also filters based on customer Id so that
2065 
    only user who owns the transaction can view its order details.
3431 rajveer 2066 
 
94 ashish 2067 
    Parameters:
2068 
     - transactionId
1528 ankur.sing 2069 
     - customerId
94 ashish 2070 
    """
1528 ankur.sing 2071 
    self.send_getOrdersForTransaction(transactionId, customerId)
483 rajveer 2072 
    return self.recv_getOrdersForTransaction()
94 ashish 2073 
 
1528 ankur.sing 2074 
  def send_getOrdersForTransaction(self, transactionId, customerId):
483 rajveer 2075 
    self._oprot.writeMessageBegin('getOrdersForTransaction', TMessageType.CALL, self._seqid)
2076 
    args = getOrdersForTransaction_args()
94 ashish 2077 
    args.transactionId = transactionId
1528 ankur.sing 2078 
    args.customerId = customerId
94 ashish 2079 
    args.write(self._oprot)
2080 
    self._oprot.writeMessageEnd()
2081 
    self._oprot.trans.flush()
2082 
 
483 rajveer 2083 
  def recv_getOrdersForTransaction(self, ):
94 ashish 2084 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2085 
    if mtype == TMessageType.EXCEPTION:
2086 
      x = TApplicationException()
2087 
      x.read(self._iprot)
2088 
      self._iprot.readMessageEnd()
2089 
      raise x
483 rajveer 2090 
    result = getOrdersForTransaction_result()
94 ashish 2091 
    result.read(self._iprot)
2092 
    self._iprot.readMessageEnd()
3431 rajveer 2093 
    if result.success is not None:
94 ashish 2094 
      return result.success
3431 rajveer 2095 
    if result.ex is not None:
94 ashish 2096 
      raise result.ex
483 rajveer 2097 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersForTransaction failed: unknown result");
94 ashish 2098 
 
3014 chandransh 2099 
  def getOrdersForCustomer(self, customerId, from_date, to_date, statuses):
94 ashish 2100 
    """
3014 chandransh 2101 
    Returns list of orders for the given customer created between the given dates and having the given statuses.
2102 
    Pass and empty list to ignore filtering on statuses.
3431 rajveer 2103 
 
94 ashish 2104 
    Parameters:
483 rajveer 2105 
     - customerId
2106 
     - from_date
2107 
     - to_date
3014 chandransh 2108 
     - statuses
94 ashish 2109 
    """
3014 chandransh 2110 
    self.send_getOrdersForCustomer(customerId, from_date, to_date, statuses)
483 rajveer 2111 
    return self.recv_getOrdersForCustomer()
94 ashish 2112 
 
3014 chandransh 2113 
  def send_getOrdersForCustomer(self, customerId, from_date, to_date, statuses):
483 rajveer 2114 
    self._oprot.writeMessageBegin('getOrdersForCustomer', TMessageType.CALL, self._seqid)
2115 
    args = getOrdersForCustomer_args()
2116 
    args.customerId = customerId
2117 
    args.from_date = from_date
2118 
    args.to_date = to_date
3014 chandransh 2119 
    args.statuses = statuses
94 ashish 2120 
    args.write(self._oprot)
2121 
    self._oprot.writeMessageEnd()
2122 
    self._oprot.trans.flush()
2123 
 
483 rajveer 2124 
  def recv_getOrdersForCustomer(self, ):
94 ashish 2125 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2126 
    if mtype == TMessageType.EXCEPTION:
2127 
      x = TApplicationException()
2128 
      x.read(self._iprot)
2129 
      self._iprot.readMessageEnd()
2130 
      raise x
483 rajveer 2131 
    result = getOrdersForCustomer_result()
94 ashish 2132 
    result.read(self._iprot)
2133 
    self._iprot.readMessageEnd()
3431 rajveer 2134 
    if result.success is not None:
94 ashish 2135 
      return result.success
3431 rajveer 2136 
    if result.ex is not None:
94 ashish 2137 
      raise result.ex
483 rajveer 2138 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersForCustomer failed: unknown result");
94 ashish 2139 
 
483 rajveer 2140 
  def createOrder(self, order):
94 ashish 2141 
    """
2142 
    Parameters:
483 rajveer 2143 
     - order
94 ashish 2144 
    """
483 rajveer 2145 
    self.send_createOrder(order)
2146 
    return self.recv_createOrder()
94 ashish 2147 
 
483 rajveer 2148 
  def send_createOrder(self, order):
2149 
    self._oprot.writeMessageBegin('createOrder', TMessageType.CALL, self._seqid)
2150 
    args = createOrder_args()
2151 
    args.order = order
94 ashish 2152 
    args.write(self._oprot)
2153 
    self._oprot.writeMessageEnd()
2154 
    self._oprot.trans.flush()
2155 
 
483 rajveer 2156 
  def recv_createOrder(self, ):
94 ashish 2157 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2158 
    if mtype == TMessageType.EXCEPTION:
2159 
      x = TApplicationException()
2160 
      x.read(self._iprot)
2161 
      self._iprot.readMessageEnd()
2162 
      raise x
483 rajveer 2163 
    result = createOrder_result()
94 ashish 2164 
    result.read(self._iprot)
2165 
    self._iprot.readMessageEnd()
3431 rajveer 2166 
    if result.success is not None:
94 ashish 2167 
      return result.success
3431 rajveer 2168 
    if result.ex is not None:
94 ashish 2169 
      raise result.ex
483 rajveer 2170 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createOrder failed: unknown result");
94 ashish 2171 
 
483 rajveer 2172 
  def getOrder(self, id):
94 ashish 2173 
    """
2174 
    Parameters:
483 rajveer 2175 
     - id
94 ashish 2176 
    """
483 rajveer 2177 
    self.send_getOrder(id)
2178 
    return self.recv_getOrder()
94 ashish 2179 
 
483 rajveer 2180 
  def send_getOrder(self, id):
2181 
    self._oprot.writeMessageBegin('getOrder', TMessageType.CALL, self._seqid)
2182 
    args = getOrder_args()
2183 
    args.id = id
94 ashish 2184 
    args.write(self._oprot)
2185 
    self._oprot.writeMessageEnd()
2186 
    self._oprot.trans.flush()
2187 
 
483 rajveer 2188 
  def recv_getOrder(self, ):
94 ashish 2189 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2190 
    if mtype == TMessageType.EXCEPTION:
2191 
      x = TApplicationException()
2192 
      x.read(self._iprot)
2193 
      self._iprot.readMessageEnd()
2194 
      raise x
483 rajveer 2195 
    result = getOrder_result()
94 ashish 2196 
    result.read(self._iprot)
2197 
    self._iprot.readMessageEnd()
3431 rajveer 2198 
    if result.success is not None:
94 ashish 2199 
      return result.success
3431 rajveer 2200 
    if result.ex is not None:
94 ashish 2201 
      raise result.ex
483 rajveer 2202 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrder failed: unknown result");
94 ashish 2203 
 
483 rajveer 2204 
  def getLineItemsForOrder(self, orderId):
94 ashish 2205 
    """
2206 
    Parameters:
483 rajveer 2207 
     - orderId
94 ashish 2208 
    """
483 rajveer 2209 
    self.send_getLineItemsForOrder(orderId)
2210 
    return self.recv_getLineItemsForOrder()
94 ashish 2211 
 
483 rajveer 2212 
  def send_getLineItemsForOrder(self, orderId):
2213 
    self._oprot.writeMessageBegin('getLineItemsForOrder', TMessageType.CALL, self._seqid)
2214 
    args = getLineItemsForOrder_args()
2215 
    args.orderId = orderId
94 ashish 2216 
    args.write(self._oprot)
2217 
    self._oprot.writeMessageEnd()
2218 
    self._oprot.trans.flush()
2219 
 
483 rajveer 2220 
  def recv_getLineItemsForOrder(self, ):
94 ashish 2221 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2222 
    if mtype == TMessageType.EXCEPTION:
2223 
      x = TApplicationException()
2224 
      x.read(self._iprot)
2225 
      self._iprot.readMessageEnd()
2226 
      raise x
483 rajveer 2227 
    result = getLineItemsForOrder_result()
94 ashish 2228 
    result.read(self._iprot)
2229 
    self._iprot.readMessageEnd()
3431 rajveer 2230 
    if result.success is not None:
94 ashish 2231 
      return result.success
3431 rajveer 2232 
    if result.ex is not None:
94 ashish 2233 
      raise result.ex
483 rajveer 2234 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getLineItemsForOrder failed: unknown result");
94 ashish 2235 
 
4999 phani.kuma 2236 
  def getOrderList(self, order_ids):
2237 
    """
2238 
    Parameters:
2239 
     - order_ids
2240 
    """
2241 
    self.send_getOrderList(order_ids)
2242 
    return self.recv_getOrderList()
2243 
 
2244 
  def send_getOrderList(self, order_ids):
2245 
    self._oprot.writeMessageBegin('getOrderList', TMessageType.CALL, self._seqid)
2246 
    args = getOrderList_args()
2247 
    args.order_ids = order_ids
2248 
    args.write(self._oprot)
2249 
    self._oprot.writeMessageEnd()
2250 
    self._oprot.trans.flush()
2251 
 
2252 
  def recv_getOrderList(self, ):
2253 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2254 
    if mtype == TMessageType.EXCEPTION:
2255 
      x = TApplicationException()
2256 
      x.read(self._iprot)
2257 
      self._iprot.readMessageEnd()
2258 
      raise x
2259 
    result = getOrderList_result()
2260 
    result.read(self._iprot)
2261 
    self._iprot.readMessageEnd()
2262 
    if result.success is not None:
2263 
      return result.success
2264 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderList failed: unknown result");
2265 
 
5386 phani.kuma 2266 
  def getOrderListForVendor(self, order_ids, vendorId):
2267 
    """
2268 
    Parameters:
2269 
     - order_ids
2270 
     - vendorId
2271 
    """
2272 
    self.send_getOrderListForVendor(order_ids, vendorId)
2273 
    return self.recv_getOrderListForVendor()
2274 
 
2275 
  def send_getOrderListForVendor(self, order_ids, vendorId):
2276 
    self._oprot.writeMessageBegin('getOrderListForVendor', TMessageType.CALL, self._seqid)
2277 
    args = getOrderListForVendor_args()
2278 
    args.order_ids = order_ids
2279 
    args.vendorId = vendorId
2280 
    args.write(self._oprot)
2281 
    self._oprot.writeMessageEnd()
2282 
    self._oprot.trans.flush()
2283 
 
2284 
  def recv_getOrderListForVendor(self, ):
2285 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2286 
    if mtype == TMessageType.EXCEPTION:
2287 
      x = TApplicationException()
2288 
      x.read(self._iprot)
2289 
      self._iprot.readMessageEnd()
2290 
      raise x
2291 
    result = getOrderListForVendor_result()
2292 
    result.read(self._iprot)
2293 
    self._iprot.readMessageEnd()
2294 
    if result.success is not None:
2295 
      return result.success
2296 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderListForVendor failed: unknown result");
2297 
 
1528 ankur.sing 2298 
  def getOrderForCustomer(self, orderId, customerId):
2299 
    """
2300 
    Returns an order for the order Id. Also checks if the order belongs to the customer whose Id is passed.
2301 
    Throws exception if either order Id is invalid or order does not below to the customer whose Id is passed.
3431 rajveer 2302 
 
1528 ankur.sing 2303 
    Parameters:
2304 
     - orderId
2305 
     - customerId
2306 
    """
2307 
    self.send_getOrderForCustomer(orderId, customerId)
2308 
    return self.recv_getOrderForCustomer()
2309 
 
2310 
  def send_getOrderForCustomer(self, orderId, customerId):
2311 
    self._oprot.writeMessageBegin('getOrderForCustomer', TMessageType.CALL, self._seqid)
2312 
    args = getOrderForCustomer_args()
2313 
    args.orderId = orderId
2314 
    args.customerId = customerId
2315 
    args.write(self._oprot)
2316 
    self._oprot.writeMessageEnd()
2317 
    self._oprot.trans.flush()
2318 
 
2319 
  def recv_getOrderForCustomer(self, ):
2320 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2321 
    if mtype == TMessageType.EXCEPTION:
2322 
      x = TApplicationException()
2323 
      x.read(self._iprot)
2324 
      self._iprot.readMessageEnd()
2325 
      raise x
2326 
    result = getOrderForCustomer_result()
2327 
    result.read(self._iprot)
2328 
    self._iprot.readMessageEnd()
3431 rajveer 2329 
    if result.success is not None:
1528 ankur.sing 2330 
      return result.success
3431 rajveer 2331 
    if result.ex is not None:
1528 ankur.sing 2332 
      raise result.ex
2333 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderForCustomer failed: unknown result");
2334 
 
4444 rajveer 2335 
  def getAlerts(self, type, warehouseId, status, timestamp):
3064 chandransh 2336 
    """
2337 
    Parameters:
4394 rajveer 2338 
     - type
4444 rajveer 2339 
     - warehouseId
4394 rajveer 2340 
     - status
2341 
     - timestamp
3064 chandransh 2342 
    """
4444 rajveer 2343 
    self.send_getAlerts(type, warehouseId, status, timestamp)
3064 chandransh 2344 
    return self.recv_getAlerts()
2345 
 
4444 rajveer 2346 
  def send_getAlerts(self, type, warehouseId, status, timestamp):
3064 chandransh 2347 
    self._oprot.writeMessageBegin('getAlerts', TMessageType.CALL, self._seqid)
2348 
    args = getAlerts_args()
4394 rajveer 2349 
    args.type = type
4444 rajveer 2350 
    args.warehouseId = warehouseId
4394 rajveer 2351 
    args.status = status
2352 
    args.timestamp = timestamp
3064 chandransh 2353 
    args.write(self._oprot)
2354 
    self._oprot.writeMessageEnd()
2355 
    self._oprot.trans.flush()
2356 
 
2357 
  def recv_getAlerts(self, ):
2358 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2359 
    if mtype == TMessageType.EXCEPTION:
2360 
      x = TApplicationException()
2361 
      x.read(self._iprot)
2362 
      self._iprot.readMessageEnd()
2363 
      raise x
2364 
    result = getAlerts_result()
2365 
    result.read(self._iprot)
2366 
    self._iprot.readMessageEnd()
3431 rajveer 2367 
    if result.success is not None:
3064 chandransh 2368 
      return result.success
2369 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAlerts failed: unknown result");
2370 
 
4444 rajveer 2371 
  def addAlert(self, type, warehouseId, description):
3064 chandransh 2372 
    """
2373 
    Parameters:
2374 
     - type
4444 rajveer 2375 
     - warehouseId
4394 rajveer 2376 
     - description
3064 chandransh 2377 
    """
4444 rajveer 2378 
    self.send_addAlert(type, warehouseId, description)
4394 rajveer 2379 
    self.recv_addAlert()
3064 chandransh 2380 
 
4444 rajveer 2381 
  def send_addAlert(self, type, warehouseId, description):
4394 rajveer 2382 
    self._oprot.writeMessageBegin('addAlert', TMessageType.CALL, self._seqid)
2383 
    args = addAlert_args()
3064 chandransh 2384 
    args.type = type
4444 rajveer 2385 
    args.warehouseId = warehouseId
4394 rajveer 2386 
    args.description = description
3064 chandransh 2387 
    args.write(self._oprot)
2388 
    self._oprot.writeMessageEnd()
2389 
    self._oprot.trans.flush()
2390 
 
4394 rajveer 2391 
  def recv_addAlert(self, ):
3064 chandransh 2392 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2393 
    if mtype == TMessageType.EXCEPTION:
2394 
      x = TApplicationException()
2395 
      x.read(self._iprot)
2396 
      self._iprot.readMessageEnd()
2397 
      raise x
4394 rajveer 2398 
    result = addAlert_result()
3064 chandransh 2399 
    result.read(self._iprot)
2400 
    self._iprot.readMessageEnd()
2401 
    return
2402 
 
4444 rajveer 2403 
  def markAlertsAsSeen(self, warehouseId):
2404 
    """
2405 
    Parameters:
2406 
     - warehouseId
2407 
    """
2408 
    self.send_markAlertsAsSeen(warehouseId)
2409 
    self.recv_markAlertsAsSeen()
2410 
 
2411 
  def send_markAlertsAsSeen(self, warehouseId):
2412 
    self._oprot.writeMessageBegin('markAlertsAsSeen', TMessageType.CALL, self._seqid)
2413 
    args = markAlertsAsSeen_args()
2414 
    args.warehouseId = warehouseId
2415 
    args.write(self._oprot)
2416 
    self._oprot.writeMessageEnd()
2417 
    self._oprot.trans.flush()
2418 
 
2419 
  def recv_markAlertsAsSeen(self, ):
2420 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2421 
    if mtype == TMessageType.EXCEPTION:
2422 
      x = TApplicationException()
2423 
      x.read(self._iprot)
2424 
      self._iprot.readMessageEnd()
2425 
      raise x
2426 
    result = markAlertsAsSeen_result()
2427 
    result.read(self._iprot)
2428 
    self._iprot.readMessageEnd()
2429 
    return
2430 
 
3064 chandransh 2431 
  def getValidOrderCount(self, ):
2432 
    """
2433 
    Return the number of valid orders. (OrderStatus >= OrderStatus.SUBMITTED_FOR_PROCESSING)
2434 
    """
2435 
    self.send_getValidOrderCount()
2436 
    return self.recv_getValidOrderCount()
2437 
 
2438 
  def send_getValidOrderCount(self, ):
2439 
    self._oprot.writeMessageBegin('getValidOrderCount', TMessageType.CALL, self._seqid)
2440 
    args = getValidOrderCount_args()
2441 
    args.write(self._oprot)
2442 
    self._oprot.writeMessageEnd()
2443 
    self._oprot.trans.flush()
2444 
 
2445 
  def recv_getValidOrderCount(self, ):
2446 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2447 
    if mtype == TMessageType.EXCEPTION:
2448 
      x = TApplicationException()
2449 
      x.read(self._iprot)
2450 
      self._iprot.readMessageEnd()
2451 
      raise x
2452 
    result = getValidOrderCount_result()
2453 
    result.read(self._iprot)
2454 
    self._iprot.readMessageEnd()
3431 rajveer 2455 
    if result.success is not None:
3064 chandransh 2456 
      return result.success
2457 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getValidOrderCount failed: unknown result");
2458 
 
2459 
  def getNoOfCustomersWithSuccessfulTransaction(self, ):
2460 
    """
2461 
    Returns the number of distinct customers who have done successful transactions
2462 
    """
2463 
    self.send_getNoOfCustomersWithSuccessfulTransaction()
2464 
    return self.recv_getNoOfCustomersWithSuccessfulTransaction()
2465 
 
2466 
  def send_getNoOfCustomersWithSuccessfulTransaction(self, ):
2467 
    self._oprot.writeMessageBegin('getNoOfCustomersWithSuccessfulTransaction', TMessageType.CALL, self._seqid)
2468 
    args = getNoOfCustomersWithSuccessfulTransaction_args()
2469 
    args.write(self._oprot)
2470 
    self._oprot.writeMessageEnd()
2471 
    self._oprot.trans.flush()
2472 
 
2473 
  def recv_getNoOfCustomersWithSuccessfulTransaction(self, ):
2474 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2475 
    if mtype == TMessageType.EXCEPTION:
2476 
      x = TApplicationException()
2477 
      x.read(self._iprot)
2478 
      self._iprot.readMessageEnd()
2479 
      raise x
2480 
    result = getNoOfCustomersWithSuccessfulTransaction_result()
2481 
    result.read(self._iprot)
2482 
    self._iprot.readMessageEnd()
3431 rajveer 2483 
    if result.success is not None:
3064 chandransh 2484 
      return result.success
2485 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getNoOfCustomersWithSuccessfulTransaction failed: unknown result");
2486 
 
2487 
  def getValidOrdersAmountRange(self, ):
2488 
    """
2489 
    Returns the minimum and maximum amounts of a valid order. (OrderStatus >= OrderStatus.SUBMITTED_FOR_PROCESSING)
2490 
    List contains two values, first minimum amount and second maximum amount.
2491 
    """
2492 
    self.send_getValidOrdersAmountRange()
2493 
    return self.recv_getValidOrdersAmountRange()
2494 
 
2495 
  def send_getValidOrdersAmountRange(self, ):
2496 
    self._oprot.writeMessageBegin('getValidOrdersAmountRange', TMessageType.CALL, self._seqid)
2497 
    args = getValidOrdersAmountRange_args()
2498 
    args.write(self._oprot)
2499 
    self._oprot.writeMessageEnd()
2500 
    self._oprot.trans.flush()
2501 
 
2502 
  def recv_getValidOrdersAmountRange(self, ):
2503 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2504 
    if mtype == TMessageType.EXCEPTION:
2505 
      x = TApplicationException()
2506 
      x.read(self._iprot)
2507 
      self._iprot.readMessageEnd()
2508 
      raise x
2509 
    result = getValidOrdersAmountRange_result()
2510 
    result.read(self._iprot)
2511 
    self._iprot.readMessageEnd()
3431 rajveer 2512 
    if result.success is not None:
3064 chandransh 2513 
      return result.success
2514 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getValidOrdersAmountRange failed: unknown result");
2515 
 
5874 rajveer 2516 
  def getValidOrders(self, limit, onlyStore):
3064 chandransh 2517 
    """
2518 
    Returns list of Orders in descending order by Order creation date. List is restricted to limit Orders.
2519 
    If limit is passed as 0, then all valid Orders are returned.
3431 rajveer 2520 
 
3064 chandransh 2521 
    Parameters:
2522 
     - limit
5874 rajveer 2523 
     - onlyStore
3064 chandransh 2524 
    """
5874 rajveer 2525 
    self.send_getValidOrders(limit, onlyStore)
3064 chandransh 2526 
    return self.recv_getValidOrders()
2527 
 
5874 rajveer 2528 
  def send_getValidOrders(self, limit, onlyStore):
3064 chandransh 2529 
    self._oprot.writeMessageBegin('getValidOrders', TMessageType.CALL, self._seqid)
2530 
    args = getValidOrders_args()
2531 
    args.limit = limit
5874 rajveer 2532 
    args.onlyStore = onlyStore
3064 chandransh 2533 
    args.write(self._oprot)
2534 
    self._oprot.writeMessageEnd()
2535 
    self._oprot.trans.flush()
2536 
 
2537 
  def recv_getValidOrders(self, ):
2538 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2539 
    if mtype == TMessageType.EXCEPTION:
2540 
      x = TApplicationException()
2541 
      x.read(self._iprot)
2542 
      self._iprot.readMessageEnd()
2543 
      raise x
2544 
    result = getValidOrders_result()
2545 
    result.read(self._iprot)
2546 
    self._iprot.readMessageEnd()
3431 rajveer 2547 
    if result.success is not None:
3064 chandransh 2548 
      return result.success
2549 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getValidOrders failed: unknown result");
2550 
 
1220 chandransh 2551 
  def batchOrders(self, warehouseId):
2552 
    """
2553 
    Create a batch of all the pending orders for the given warehouse.
2554 
    The returned list is orderd by created_timestamp.
2555 
    If there are no pending orders, an empty list is returned.
3431 rajveer 2556 
 
1220 chandransh 2557 
    Parameters:
2558 
     - warehouseId
2559 
    """
2560 
    self.send_batchOrders(warehouseId)
2561 
    return self.recv_batchOrders()
2562 
 
2563 
  def send_batchOrders(self, warehouseId):
2564 
    self._oprot.writeMessageBegin('batchOrders', TMessageType.CALL, self._seqid)
2565 
    args = batchOrders_args()
2566 
    args.warehouseId = warehouseId
2567 
    args.write(self._oprot)
2568 
    self._oprot.writeMessageEnd()
2569 
    self._oprot.trans.flush()
2570 
 
2571 
  def recv_batchOrders(self, ):
2572 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2573 
    if mtype == TMessageType.EXCEPTION:
2574 
      x = TApplicationException()
2575 
      x.read(self._iprot)
2576 
      self._iprot.readMessageEnd()
2577 
      raise x
2578 
    result = batchOrders_result()
2579 
    result.read(self._iprot)
2580 
    self._iprot.readMessageEnd()
3431 rajveer 2581 
    if result.success is not None:
1220 chandransh 2582 
      return result.success
3431 rajveer 2583 
    if result.ex is not None:
1220 chandransh 2584 
      raise result.ex
2585 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "batchOrders failed: unknown result");
2586 
 
1208 chandransh 2587 
  def markOrderAsOutOfStock(self, orderId):
2588 
    """
2589 
    Mark the given order as out of stock. Throws an exception if the order with the given Id couldn't be found.
3431 rajveer 2590 
 
1208 chandransh 2591 
    Parameters:
2592 
     - orderId
2593 
    """
2594 
    self.send_markOrderAsOutOfStock(orderId)
2595 
    return self.recv_markOrderAsOutOfStock()
2596 
 
2597 
  def send_markOrderAsOutOfStock(self, orderId):
2598 
    self._oprot.writeMessageBegin('markOrderAsOutOfStock', TMessageType.CALL, self._seqid)
2599 
    args = markOrderAsOutOfStock_args()
2600 
    args.orderId = orderId
2601 
    args.write(self._oprot)
2602 
    self._oprot.writeMessageEnd()
2603 
    self._oprot.trans.flush()
2604 
 
2605 
  def recv_markOrderAsOutOfStock(self, ):
2606 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2607 
    if mtype == TMessageType.EXCEPTION:
2608 
      x = TApplicationException()
2609 
      x.read(self._iprot)
2610 
      self._iprot.readMessageEnd()
2611 
      raise x
2612 
    result = markOrderAsOutOfStock_result()
2613 
    result.read(self._iprot)
2614 
    self._iprot.readMessageEnd()
3431 rajveer 2615 
    if result.success is not None:
1208 chandransh 2616 
      return result.success
3431 rajveer 2617 
    if result.ex is not None:
1208 chandransh 2618 
      raise result.ex
2619 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderAsOutOfStock failed: unknown result");
2620 
 
3064 chandransh 2621 
  def verifyOrder(self, orderId):
759 chandransh 2622 
    """
3064 chandransh 2623 
    Marks the given order as SUBMITTED_FOR_PROCESSING and updates the verified
2624 
    timestamp. It is intended to be used for COD orders but can be harmlessly
2625 
    used for all other orders as well.
2626 
    Throws an exception if no such order exists.
3431 rajveer 2627 
 
759 chandransh 2628 
    Parameters:
3064 chandransh 2629 
     - orderId
759 chandransh 2630 
    """
3064 chandransh 2631 
    self.send_verifyOrder(orderId)
2632 
    return self.recv_verifyOrder()
759 chandransh 2633 
 
3064 chandransh 2634 
  def send_verifyOrder(self, orderId):
2635 
    self._oprot.writeMessageBegin('verifyOrder', TMessageType.CALL, self._seqid)
2636 
    args = verifyOrder_args()
2637 
    args.orderId = orderId
759 chandransh 2638 
    args.write(self._oprot)
2639 
    self._oprot.writeMessageEnd()
2640 
    self._oprot.trans.flush()
2641 
 
3064 chandransh 2642 
  def recv_verifyOrder(self, ):
759 chandransh 2643 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2644 
    if mtype == TMessageType.EXCEPTION:
2645 
      x = TApplicationException()
2646 
      x.read(self._iprot)
2647 
      self._iprot.readMessageEnd()
2648 
      raise x
3064 chandransh 2649 
    result = verifyOrder_result()
759 chandransh 2650 
    result.read(self._iprot)
2651 
    self._iprot.readMessageEnd()
3431 rajveer 2652 
    if result.success is not None:
759 chandransh 2653 
      return result.success
3431 rajveer 2654 
    if result.ex is not None:
759 chandransh 2655 
      raise result.ex
3064 chandransh 2656 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "verifyOrder failed: unknown result");
759 chandransh 2657 
 
3064 chandransh 2658 
  def acceptOrder(self, orderId):
1113 chandransh 2659 
    """
3064 chandransh 2660 
    Marks the given order as ACCEPTED and updates the accepted timestamp. If the
2661 
    given order is not a COD order, it also captures the payment if the same has
2662 
    not been captured.
2663 
    Throws an exception if no such order exists.
3431 rajveer 2664 
 
1113 chandransh 2665 
    Parameters:
3064 chandransh 2666 
     - orderId
1113 chandransh 2667 
    """
3064 chandransh 2668 
    self.send_acceptOrder(orderId)
2669 
    return self.recv_acceptOrder()
1113 chandransh 2670 
 
3064 chandransh 2671 
  def send_acceptOrder(self, orderId):
2672 
    self._oprot.writeMessageBegin('acceptOrder', TMessageType.CALL, self._seqid)
2673 
    args = acceptOrder_args()
2674 
    args.orderId = orderId
1113 chandransh 2675 
    args.write(self._oprot)
2676 
    self._oprot.writeMessageEnd()
2677 
    self._oprot.trans.flush()
2678 
 
3064 chandransh 2679 
  def recv_acceptOrder(self, ):
1113 chandransh 2680 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2681 
    if mtype == TMessageType.EXCEPTION:
2682 
      x = TApplicationException()
2683 
      x.read(self._iprot)
2684 
      self._iprot.readMessageEnd()
2685 
      raise x
3064 chandransh 2686 
    result = acceptOrder_result()
1113 chandransh 2687 
    result.read(self._iprot)
2688 
    self._iprot.readMessageEnd()
3431 rajveer 2689 
    if result.success is not None:
1113 chandransh 2690 
      return result.success
3431 rajveer 2691 
    if result.ex is not None:
1113 chandransh 2692 
      raise result.ex
3064 chandransh 2693 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "acceptOrder failed: unknown result");
1113 chandransh 2694 
 
5110 mandeep.dh 2695 
  def addBillingDetails(self, orderId, invoice_number, serialNumber, itemNumber, billed_by, jacketNumber, billingType, fulfilmentWarehouseId, authorize):
1132 chandransh 2696 
    """
3064 chandransh 2697 
    Add billing details such as the bill number and the biller to the Order.
4658 mandeep.dh 2698 
    Adds jacket number, item number and Serial no. to the order. Doesn't update
4283 anupam.sin 2699 
    the IMEI no. if a -1 is supplied.
2700 
    Also, it generates an invoice number for the order, marks the order as
2701 
    BILLED and sets the billing timestamp.
2702 
    Returns false if it doesn't find the order with the given ID.
3431 rajveer 2703 
 
1135 chandransh 2704 
    Parameters:
3064 chandransh 2705 
     - orderId
2706 
     - invoice_number
4658 mandeep.dh 2707 
     - serialNumber
4283 anupam.sin 2708 
     - itemNumber
3064 chandransh 2709 
     - billed_by
4264 rajveer 2710 
     - jacketNumber
4283 anupam.sin 2711 
     - billingType
5110 mandeep.dh 2712 
     - fulfilmentWarehouseId
4763 rajveer 2713 
     - authorize
1135 chandransh 2714 
    """
5110 mandeep.dh 2715 
    self.send_addBillingDetails(orderId, invoice_number, serialNumber, itemNumber, billed_by, jacketNumber, billingType, fulfilmentWarehouseId, authorize)
3064 chandransh 2716 
    return self.recv_addBillingDetails()
1135 chandransh 2717 
 
5110 mandeep.dh 2718 
  def send_addBillingDetails(self, orderId, invoice_number, serialNumber, itemNumber, billed_by, jacketNumber, billingType, fulfilmentWarehouseId, authorize):
3064 chandransh 2719 
    self._oprot.writeMessageBegin('addBillingDetails', TMessageType.CALL, self._seqid)
2720 
    args = addBillingDetails_args()
2721 
    args.orderId = orderId
2722 
    args.invoice_number = invoice_number
4658 mandeep.dh 2723 
    args.serialNumber = serialNumber
4283 anupam.sin 2724 
    args.itemNumber = itemNumber
3064 chandransh 2725 
    args.billed_by = billed_by
4264 rajveer 2726 
    args.jacketNumber = jacketNumber
4283 anupam.sin 2727 
    args.billingType = billingType
5110 mandeep.dh 2728 
    args.fulfilmentWarehouseId = fulfilmentWarehouseId
4763 rajveer 2729 
    args.authorize = authorize
1135 chandransh 2730 
    args.write(self._oprot)
2731 
    self._oprot.writeMessageEnd()
2732 
    self._oprot.trans.flush()
2733 
 
3064 chandransh 2734 
  def recv_addBillingDetails(self, ):
1135 chandransh 2735 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2736 
    if mtype == TMessageType.EXCEPTION:
2737 
      x = TApplicationException()
2738 
      x.read(self._iprot)
2739 
      self._iprot.readMessageEnd()
2740 
      raise x
3064 chandransh 2741 
    result = addBillingDetails_result()
1135 chandransh 2742 
    result.read(self._iprot)
2743 
    self._iprot.readMessageEnd()
3431 rajveer 2744 
    if result.success is not None:
3064 chandransh 2745 
      return result.success
3431 rajveer 2746 
    if result.ex is not None:
1135 chandransh 2747 
      raise result.ex
3064 chandransh 2748 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addBillingDetails failed: unknown result");
1135 chandransh 2749 
 
6756 amar.kumar 2750 
  def addInvoiceNumber(self, orderId, invoiceNumber, color, serialNumber, itemNumber):
4579 rajveer 2751 
    """
2752 
    Add the invoice number to the order.
2753 
 
2754 
    Parameters:
2755 
     - orderId
2756 
     - invoiceNumber
4763 rajveer 2757 
     - color
6756 amar.kumar 2758 
     - serialNumber
2759 
     - itemNumber
4579 rajveer 2760 
    """
6756 amar.kumar 2761 
    self.send_addInvoiceNumber(orderId, invoiceNumber, color, serialNumber, itemNumber)
4579 rajveer 2762 
    self.recv_addInvoiceNumber()
2763 
 
6756 amar.kumar 2764 
  def send_addInvoiceNumber(self, orderId, invoiceNumber, color, serialNumber, itemNumber):
4579 rajveer 2765 
    self._oprot.writeMessageBegin('addInvoiceNumber', TMessageType.CALL, self._seqid)
2766 
    args = addInvoiceNumber_args()
2767 
    args.orderId = orderId
2768 
    args.invoiceNumber = invoiceNumber
4763 rajveer 2769 
    args.color = color
6756 amar.kumar 2770 
    args.serialNumber = serialNumber
2771 
    args.itemNumber = itemNumber
4579 rajveer 2772 
    args.write(self._oprot)
2773 
    self._oprot.writeMessageEnd()
2774 
    self._oprot.trans.flush()
2775 
 
2776 
  def recv_addInvoiceNumber(self, ):
2777 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2778 
    if mtype == TMessageType.EXCEPTION:
2779 
      x = TApplicationException()
2780 
      x.read(self._iprot)
2781 
      self._iprot.readMessageEnd()
2782 
      raise x
2783 
    result = addInvoiceNumber_result()
2784 
    result.read(self._iprot)
2785 
    self._iprot.readMessageEnd()
2786 
    if result.ex is not None:
2787 
      raise result.ex
2788 
    return
2789 
 
4910 phani.kuma 2790 
  def markOrdersAsShippedFromWarehouse(self, warehouseId, providerId, cod, orderIds):
1408 ankur.sing 2791 
    """
3064 chandransh 2792 
    Depending on the third parameter, marks either all prepaid or all cod orders BILLED by the
4910 phani.kuma 2793 
    given warehouse and were picked up by the given provider as SHIPPED_FROM_WH.
3431 rajveer 2794 
 
1408 ankur.sing 2795 
    Parameters:
3064 chandransh 2796 
     - warehouseId
1408 ankur.sing 2797 
     - providerId
3064 chandransh 2798 
     - cod
4910 phani.kuma 2799 
     - orderIds
1408 ankur.sing 2800 
    """
4910 phani.kuma 2801 
    self.send_markOrdersAsShippedFromWarehouse(warehouseId, providerId, cod, orderIds)
2802 
    return self.recv_markOrdersAsShippedFromWarehouse()
1408 ankur.sing 2803 
 
4910 phani.kuma 2804 
  def send_markOrdersAsShippedFromWarehouse(self, warehouseId, providerId, cod, orderIds):
2805 
    self._oprot.writeMessageBegin('markOrdersAsShippedFromWarehouse', TMessageType.CALL, self._seqid)
2806 
    args = markOrdersAsShippedFromWarehouse_args()
3064 chandransh 2807 
    args.warehouseId = warehouseId
1408 ankur.sing 2808 
    args.providerId = providerId
3064 chandransh 2809 
    args.cod = cod
4910 phani.kuma 2810 
    args.orderIds = orderIds
1408 ankur.sing 2811 
    args.write(self._oprot)
2812 
    self._oprot.writeMessageEnd()
2813 
    self._oprot.trans.flush()
2814 
 
4910 phani.kuma 2815 
  def recv_markOrdersAsShippedFromWarehouse(self, ):
1408 ankur.sing 2816 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2817 
    if mtype == TMessageType.EXCEPTION:
2818 
      x = TApplicationException()
2819 
      x.read(self._iprot)
2820 
      self._iprot.readMessageEnd()
2821 
      raise x
4910 phani.kuma 2822 
    result = markOrdersAsShippedFromWarehouse_result()
1408 ankur.sing 2823 
    result.read(self._iprot)
2824 
    self._iprot.readMessageEnd()
3431 rajveer 2825 
    if result.success is not None:
1408 ankur.sing 2826 
      return result.success
3431 rajveer 2827 
    if result.ex is not None:
3064 chandransh 2828 
      raise result.ex
4910 phani.kuma 2829 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrdersAsShippedFromWarehouse failed: unknown result");
1408 ankur.sing 2830 
 
5713 rajveer 2831 
  def markOrdersAsReturnedFromStore(self, providerId, orderIds, awbs):
5676 rajveer 2832 
    """
2833 
    Parameters:
2834 
     - providerId
2835 
     - orderIds
5713 rajveer 2836 
     - awbs
5676 rajveer 2837 
    """
5713 rajveer 2838 
    self.send_markOrdersAsReturnedFromStore(providerId, orderIds, awbs)
5676 rajveer 2839 
    return self.recv_markOrdersAsReturnedFromStore()
2840 
 
5713 rajveer 2841 
  def send_markOrdersAsReturnedFromStore(self, providerId, orderIds, awbs):
5676 rajveer 2842 
    self._oprot.writeMessageBegin('markOrdersAsReturnedFromStore', TMessageType.CALL, self._seqid)
2843 
    args = markOrdersAsReturnedFromStore_args()
2844 
    args.providerId = providerId
2845 
    args.orderIds = orderIds
5713 rajveer 2846 
    args.awbs = awbs
5676 rajveer 2847 
    args.write(self._oprot)
2848 
    self._oprot.writeMessageEnd()
2849 
    self._oprot.trans.flush()
2850 
 
2851 
  def recv_markOrdersAsReturnedFromStore(self, ):
2852 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2853 
    if mtype == TMessageType.EXCEPTION:
2854 
      x = TApplicationException()
2855 
      x.read(self._iprot)
2856 
      self._iprot.readMessageEnd()
2857 
      raise x
2858 
    result = markOrdersAsReturnedFromStore_result()
2859 
    result.read(self._iprot)
2860 
    self._iprot.readMessageEnd()
2861 
    if result.success is not None:
2862 
      return result.success
2863 
    if result.ex is not None:
2864 
      raise result.ex
2865 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrdersAsReturnedFromStore failed: unknown result");
2866 
 
4910 phani.kuma 2867 
  def markOrdersAsPickedUp(self, providerId, pickupDetails):
4410 rajveer 2868 
    """
4910 phani.kuma 2869 
    Marks all SHIPPED_FROM_WH orders of the previous day for a provider as SHIPPED_TO_LOGISTICS.
2870 
    Raises an exception if we encounter report for an AWB number that we did not ship.
4410 rajveer 2871 
 
2872 
    Parameters:
2873 
     - providerId
4910 phani.kuma 2874 
     - pickupDetails
4410 rajveer 2875 
    """
4910 phani.kuma 2876 
    self.send_markOrdersAsPickedUp(providerId, pickupDetails)
2877 
    self.recv_markOrdersAsPickedUp()
4410 rajveer 2878 
 
4910 phani.kuma 2879 
  def send_markOrdersAsPickedUp(self, providerId, pickupDetails):
2880 
    self._oprot.writeMessageBegin('markOrdersAsPickedUp', TMessageType.CALL, self._seqid)
2881 
    args = markOrdersAsPickedUp_args()
4410 rajveer 2882 
    args.providerId = providerId
4910 phani.kuma 2883 
    args.pickupDetails = pickupDetails
4410 rajveer 2884 
    args.write(self._oprot)
2885 
    self._oprot.writeMessageEnd()
2886 
    self._oprot.trans.flush()
2887 
 
4910 phani.kuma 2888 
  def recv_markOrdersAsPickedUp(self, ):
4410 rajveer 2889 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2890 
    if mtype == TMessageType.EXCEPTION:
2891 
      x = TApplicationException()
2892 
      x.read(self._iprot)
2893 
      self._iprot.readMessageEnd()
2894 
      raise x
4910 phani.kuma 2895 
    result = markOrdersAsPickedUp_result()
4410 rajveer 2896 
    result.read(self._iprot)
2897 
    self._iprot.readMessageEnd()
2898 
    if result.ex is not None:
2899 
      raise result.ex
4910 phani.kuma 2900 
    return
4410 rajveer 2901 
 
4910 phani.kuma 2902 
  def getOrdersNotPickedUp(self, providerId):
94 ashish 2903 
    """
3064 chandransh 2904 
    Returns a list of orders that were shipped from warehouse but did not appear in the pick-up report.
3431 rajveer 2905 
 
94 ashish 2906 
    Parameters:
3064 chandransh 2907 
     - providerId
304 ashish 2908 
    """
4910 phani.kuma 2909 
    self.send_getOrdersNotPickedUp(providerId)
2910 
    return self.recv_getOrdersNotPickedUp()
94 ashish 2911 
 
4910 phani.kuma 2912 
  def send_getOrdersNotPickedUp(self, providerId):
2913 
    self._oprot.writeMessageBegin('getOrdersNotPickedUp', TMessageType.CALL, self._seqid)
2914 
    args = getOrdersNotPickedUp_args()
3064 chandransh 2915 
    args.providerId = providerId
304 ashish 2916 
    args.write(self._oprot)
2917 
    self._oprot.writeMessageEnd()
2918 
    self._oprot.trans.flush()
2919 
 
4910 phani.kuma 2920 
  def recv_getOrdersNotPickedUp(self, ):
304 ashish 2921 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2922 
    if mtype == TMessageType.EXCEPTION:
2923 
      x = TApplicationException()
2924 
      x.read(self._iprot)
2925 
      self._iprot.readMessageEnd()
2926 
      raise x
4910 phani.kuma 2927 
    result = getOrdersNotPickedUp_result()
304 ashish 2928 
    result.read(self._iprot)
2929 
    self._iprot.readMessageEnd()
3431 rajveer 2930 
    if result.success is not None:
304 ashish 2931 
      return result.success
4910 phani.kuma 2932 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersNotPickedUp failed: unknown result");
304 ashish 2933 
 
3064 chandransh 2934 
  def markOrdersAsDelivered(self, providerId, deliveredOrders):
304 ashish 2935 
    """
3064 chandransh 2936 
    Marks all orders with AWBs in the given map as delivered. Also sets the delivery timestamp and
2937 
    the name of the receiver.
2938 
    Raises an exception if we encounter report for an AWB number that we did not ship.
3431 rajveer 2939 
 
304 ashish 2940 
    Parameters:
3064 chandransh 2941 
     - providerId
2942 
     - deliveredOrders
304 ashish 2943 
    """
3064 chandransh 2944 
    self.send_markOrdersAsDelivered(providerId, deliveredOrders)
2945 
    self.recv_markOrdersAsDelivered()
304 ashish 2946 
 
3064 chandransh 2947 
  def send_markOrdersAsDelivered(self, providerId, deliveredOrders):
2948 
    self._oprot.writeMessageBegin('markOrdersAsDelivered', TMessageType.CALL, self._seqid)
2949 
    args = markOrdersAsDelivered_args()
2950 
    args.providerId = providerId
2951 
    args.deliveredOrders = deliveredOrders
304 ashish 2952 
    args.write(self._oprot)
2953 
    self._oprot.writeMessageEnd()
2954 
    self._oprot.trans.flush()
2955 
 
3064 chandransh 2956 
  def recv_markOrdersAsDelivered(self, ):
304 ashish 2957 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2958 
    if mtype == TMessageType.EXCEPTION:
2959 
      x = TApplicationException()
2960 
      x.read(self._iprot)
2961 
      self._iprot.readMessageEnd()
2962 
      raise x
3064 chandransh 2963 
    result = markOrdersAsDelivered_result()
304 ashish 2964 
    result.read(self._iprot)
2965 
    self._iprot.readMessageEnd()
3431 rajveer 2966 
    if result.ex is not None:
3064 chandransh 2967 
      raise result.ex
304 ashish 2968 
    return
2969 
 
4910 phani.kuma 2970 
  def markAsRTOrders(self, providerId, returnedOrders):
1596 ankur.sing 2971 
    """
4910 phani.kuma 2972 
    Mark all orders with AWBs in the given map as RTO. Also sets the delivery timestamp.
3064 chandransh 2973 
    Raises an exception if we encounter report for an AWB number that we did not ship.
3431 rajveer 2974 
 
3064 chandransh 2975 
    Parameters:
2976 
     - providerId
2977 
     - returnedOrders
1596 ankur.sing 2978 
    """
4910 phani.kuma 2979 
    self.send_markAsRTOrders(providerId, returnedOrders)
2980 
    self.recv_markAsRTOrders()
304 ashish 2981 
 
4910 phani.kuma 2982 
  def send_markAsRTOrders(self, providerId, returnedOrders):
2983 
    self._oprot.writeMessageBegin('markAsRTOrders', TMessageType.CALL, self._seqid)
2984 
    args = markAsRTOrders_args()
3064 chandransh 2985 
    args.providerId = providerId
2986 
    args.returnedOrders = returnedOrders
1596 ankur.sing 2987 
    args.write(self._oprot)
2988 
    self._oprot.writeMessageEnd()
2989 
    self._oprot.trans.flush()
2990 
 
4910 phani.kuma 2991 
  def recv_markAsRTOrders(self, ):
1596 ankur.sing 2992 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2993 
    if mtype == TMessageType.EXCEPTION:
2994 
      x = TApplicationException()
2995 
      x.read(self._iprot)
2996 
      self._iprot.readMessageEnd()
2997 
      raise x
4910 phani.kuma 2998 
    result = markAsRTOrders_result()
1596 ankur.sing 2999 
    result.read(self._iprot)
3000 
    self._iprot.readMessageEnd()
3431 rajveer 3001 
    if result.ex is not None:
3064 chandransh 3002 
      raise result.ex
3003 
    return
1596 ankur.sing 3004 
 
4910 phani.kuma 3005 
  def getRTOrders(self, providerId):
3006 
    """
3007 
    Returns a list of orders that were returned by courier.
3008 
 
3009 
    Parameters:
3010 
     - providerId
3011 
    """
3012 
    self.send_getRTOrders(providerId)
3013 
    return self.recv_getRTOrders()
3014 
 
3015 
  def send_getRTOrders(self, providerId):
3016 
    self._oprot.writeMessageBegin('getRTOrders', TMessageType.CALL, self._seqid)
3017 
    args = getRTOrders_args()
3018 
    args.providerId = providerId
3019 
    args.write(self._oprot)
3020 
    self._oprot.writeMessageEnd()
3021 
    self._oprot.trans.flush()
3022 
 
3023 
  def recv_getRTOrders(self, ):
3024 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3025 
    if mtype == TMessageType.EXCEPTION:
3026 
      x = TApplicationException()
3027 
      x.read(self._iprot)
3028 
      self._iprot.readMessageEnd()
3029 
      raise x
3030 
    result = getRTOrders_result()
3031 
    result.read(self._iprot)
3032 
    self._iprot.readMessageEnd()
3033 
    if result.success is not None:
3034 
      return result.success
3035 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getRTOrders failed: unknown result");
3036 
 
3064 chandransh 3037 
  def updateNonDeliveryReason(self, providerId, undeliveredOrders):
1627 ankur.sing 3038 
    """
3064 chandransh 3039 
    Update the status description of orders whose AWB numbers are keys of the Map.
3431 rajveer 3040 
 
3064 chandransh 3041 
    Parameters:
3042 
     - providerId
3043 
     - undeliveredOrders
1627 ankur.sing 3044 
    """
3064 chandransh 3045 
    self.send_updateNonDeliveryReason(providerId, undeliveredOrders)
4910 phani.kuma 3046 
    self.recv_updateNonDeliveryReason()
1596 ankur.sing 3047 
 
3064 chandransh 3048 
  def send_updateNonDeliveryReason(self, providerId, undeliveredOrders):
3049 
    self._oprot.writeMessageBegin('updateNonDeliveryReason', TMessageType.CALL, self._seqid)
3050 
    args = updateNonDeliveryReason_args()
3051 
    args.providerId = providerId
3052 
    args.undeliveredOrders = undeliveredOrders
1627 ankur.sing 3053 
    args.write(self._oprot)
3054 
    self._oprot.writeMessageEnd()
3055 
    self._oprot.trans.flush()
3056 
 
3064 chandransh 3057 
  def recv_updateNonDeliveryReason(self, ):
1627 ankur.sing 3058 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3059 
    if mtype == TMessageType.EXCEPTION:
3060 
      x = TApplicationException()
3061 
      x.read(self._iprot)
3062 
      self._iprot.readMessageEnd()
3063 
      raise x
3064 chandransh 3064 
    result = updateNonDeliveryReason_result()
1627 ankur.sing 3065 
    result.read(self._iprot)
3066 
    self._iprot.readMessageEnd()
4910 phani.kuma 3067 
    if result.ex is not None:
3068 
      raise result.ex
3069 
    return
3070 
 
3071 
  def getNonDeliveredOrdersbyCourier(self, providerId):
3072 
    """
3073 
    Returns a list of orders that were picked up or shipped four days ago but did not get delivered.
3074 
 
3075 
    Parameters:
3076 
     - providerId
3077 
    """
3078 
    self.send_getNonDeliveredOrdersbyCourier(providerId)
3079 
    return self.recv_getNonDeliveredOrdersbyCourier()
3080 
 
3081 
  def send_getNonDeliveredOrdersbyCourier(self, providerId):
3082 
    self._oprot.writeMessageBegin('getNonDeliveredOrdersbyCourier', TMessageType.CALL, self._seqid)
3083 
    args = getNonDeliveredOrdersbyCourier_args()
3084 
    args.providerId = providerId
3085 
    args.write(self._oprot)
3086 
    self._oprot.writeMessageEnd()
3087 
    self._oprot.trans.flush()
3088 
 
3089 
  def recv_getNonDeliveredOrdersbyCourier(self, ):
3090 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3091 
    if mtype == TMessageType.EXCEPTION:
3092 
      x = TApplicationException()
3093 
      x.read(self._iprot)
3094 
      self._iprot.readMessageEnd()
3095 
      raise x
3096 
    result = getNonDeliveredOrdersbyCourier_result()
3097 
    result.read(self._iprot)
3098 
    self._iprot.readMessageEnd()
4581 phani.kuma 3099 
    if result.success is not None:
3100 
      return result.success
4910 phani.kuma 3101 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getNonDeliveredOrdersbyCourier failed: unknown result");
3102 
 
3103 
  def markOrdersAsLocalConnected(self, providerId, local_connected_orders):
3104 
    """
3105 
    Mark all orders with AWBs in the given map as local connected. Also sets the local connected timestamp.
3106 
 
3107 
    Parameters:
3108 
     - providerId
3109 
     - local_connected_orders
3110 
    """
3111 
    self.send_markOrdersAsLocalConnected(providerId, local_connected_orders)
3112 
    self.recv_markOrdersAsLocalConnected()
3113 
 
3114 
  def send_markOrdersAsLocalConnected(self, providerId, local_connected_orders):
3115 
    self._oprot.writeMessageBegin('markOrdersAsLocalConnected', TMessageType.CALL, self._seqid)
3116 
    args = markOrdersAsLocalConnected_args()
3117 
    args.providerId = providerId
3118 
    args.local_connected_orders = local_connected_orders
3119 
    args.write(self._oprot)
3120 
    self._oprot.writeMessageEnd()
3121 
    self._oprot.trans.flush()
3122 
 
3123 
  def recv_markOrdersAsLocalConnected(self, ):
3124 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3125 
    if mtype == TMessageType.EXCEPTION:
3126 
      x = TApplicationException()
3127 
      x.read(self._iprot)
3128 
      self._iprot.readMessageEnd()
3129 
      raise x
3130 
    result = markOrdersAsLocalConnected_result()
3131 
    result.read(self._iprot)
3132 
    self._iprot.readMessageEnd()
3431 rajveer 3133 
    if result.ex is not None:
3064 chandransh 3134 
      raise result.ex
4910 phani.kuma 3135 
    return
1627 ankur.sing 3136 
 
4910 phani.kuma 3137 
  def getOrdersNotLocalConnected(self, providerId):
3138 
    """
3139 
    Returns a list of orders that were picked up or shipped but pending local connection.
3140 
 
3141 
    Parameters:
3142 
     - providerId
3143 
    """
3144 
    self.send_getOrdersNotLocalConnected(providerId)
3145 
    return self.recv_getOrdersNotLocalConnected()
3146 
 
3147 
  def send_getOrdersNotLocalConnected(self, providerId):
3148 
    self._oprot.writeMessageBegin('getOrdersNotLocalConnected', TMessageType.CALL, self._seqid)
3149 
    args = getOrdersNotLocalConnected_args()
3150 
    args.providerId = providerId
3151 
    args.write(self._oprot)
3152 
    self._oprot.writeMessageEnd()
3153 
    self._oprot.trans.flush()
3154 
 
3155 
  def recv_getOrdersNotLocalConnected(self, ):
3156 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3157 
    if mtype == TMessageType.EXCEPTION:
3158 
      x = TApplicationException()
3159 
      x.read(self._iprot)
3160 
      self._iprot.readMessageEnd()
3161 
      raise x
3162 
    result = getOrdersNotLocalConnected_result()
3163 
    result.read(self._iprot)
3164 
    self._iprot.readMessageEnd()
3165 
    if result.success is not None:
3166 
      return result.success
3167 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersNotLocalConnected failed: unknown result");
3168 
 
3169 
  def markOrdersAsDestinationCityReached(self, providerId, destination_city_reached_orders):
3170 
    """
3171 
    Mark all orders with AWBs in the given map as reached destination city. Also sets the reached destination timestamp.
3172 
 
3173 
    Parameters:
3174 
     - providerId
3175 
     - destination_city_reached_orders
3176 
    """
3177 
    self.send_markOrdersAsDestinationCityReached(providerId, destination_city_reached_orders)
3178 
    self.recv_markOrdersAsDestinationCityReached()
3179 
 
3180 
  def send_markOrdersAsDestinationCityReached(self, providerId, destination_city_reached_orders):
3181 
    self._oprot.writeMessageBegin('markOrdersAsDestinationCityReached', TMessageType.CALL, self._seqid)
3182 
    args = markOrdersAsDestinationCityReached_args()
3183 
    args.providerId = providerId
3184 
    args.destination_city_reached_orders = destination_city_reached_orders
3185 
    args.write(self._oprot)
3186 
    self._oprot.writeMessageEnd()
3187 
    self._oprot.trans.flush()
3188 
 
3189 
  def recv_markOrdersAsDestinationCityReached(self, ):
3190 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3191 
    if mtype == TMessageType.EXCEPTION:
3192 
      x = TApplicationException()
3193 
      x.read(self._iprot)
3194 
      self._iprot.readMessageEnd()
3195 
      raise x
3196 
    result = markOrdersAsDestinationCityReached_result()
3197 
    result.read(self._iprot)
3198 
    self._iprot.readMessageEnd()
3199 
    if result.ex is not None:
3200 
      raise result.ex
3201 
    return
3202 
 
3203 
  def markOrdersAsFirstDeliveryAttempted(self, providerId, first_atdl_orders):
3204 
    """
3205 
    Mark all orders with AWBs in the given map as first delivery attempt made. Also sets the first delivery attempted timestamp.
3206 
 
3207 
    Parameters:
3208 
     - providerId
3209 
     - first_atdl_orders
3210 
    """
3211 
    self.send_markOrdersAsFirstDeliveryAttempted(providerId, first_atdl_orders)
3212 
    self.recv_markOrdersAsFirstDeliveryAttempted()
3213 
 
3214 
  def send_markOrdersAsFirstDeliveryAttempted(self, providerId, first_atdl_orders):
3215 
    self._oprot.writeMessageBegin('markOrdersAsFirstDeliveryAttempted', TMessageType.CALL, self._seqid)
3216 
    args = markOrdersAsFirstDeliveryAttempted_args()
3217 
    args.providerId = providerId
3218 
    args.first_atdl_orders = first_atdl_orders
3219 
    args.write(self._oprot)
3220 
    self._oprot.writeMessageEnd()
3221 
    self._oprot.trans.flush()
3222 
 
3223 
  def recv_markOrdersAsFirstDeliveryAttempted(self, ):
3224 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3225 
    if mtype == TMessageType.EXCEPTION:
3226 
      x = TApplicationException()
3227 
      x.read(self._iprot)
3228 
      self._iprot.readMessageEnd()
3229 
      raise x
3230 
    result = markOrdersAsFirstDeliveryAttempted_result()
3231 
    result.read(self._iprot)
3232 
    self._iprot.readMessageEnd()
3233 
    if result.ex is not None:
3234 
      raise result.ex
3235 
    return
3236 
 
3064 chandransh 3237 
  def getUndeliveredOrders(self, providerId, warehouseId):
1627 ankur.sing 3238 
    """
3064 chandransh 3239 
    Returns the list of orders whose delivery time has passed but have not been
3240 
    delivered yet for the given provider and warehouse. To get a complete list of
3241 
    undelivered orders, pass them as -1.
3242 
    Returns an empty list if no such orders exist.
3431 rajveer 3243 
 
1886 ankur.sing 3244 
    Parameters:
3064 chandransh 3245 
     - providerId
3246 
     - warehouseId
1886 ankur.sing 3247 
    """
3064 chandransh 3248 
    self.send_getUndeliveredOrders(providerId, warehouseId)
3249 
    return self.recv_getUndeliveredOrders()
1627 ankur.sing 3250 
 
3064 chandransh 3251 
  def send_getUndeliveredOrders(self, providerId, warehouseId):
3252 
    self._oprot.writeMessageBegin('getUndeliveredOrders', TMessageType.CALL, self._seqid)
3253 
    args = getUndeliveredOrders_args()
3254 
    args.providerId = providerId
3255 
    args.warehouseId = warehouseId
1886 ankur.sing 3256 
    args.write(self._oprot)
3257 
    self._oprot.writeMessageEnd()
3258 
    self._oprot.trans.flush()
3259 
 
3064 chandransh 3260 
  def recv_getUndeliveredOrders(self, ):
1886 ankur.sing 3261 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3262 
    if mtype == TMessageType.EXCEPTION:
3263 
      x = TApplicationException()
3264 
      x.read(self._iprot)
3265 
      self._iprot.readMessageEnd()
3266 
      raise x
3064 chandransh 3267 
    result = getUndeliveredOrders_result()
1886 ankur.sing 3268 
    result.read(self._iprot)
3269 
    self._iprot.readMessageEnd()
3431 rajveer 3270 
    if result.success is not None:
1886 ankur.sing 3271 
      return result.success
3064 chandransh 3272 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUndeliveredOrders failed: unknown result");
1886 ankur.sing 3273 
 
4783 phani.kuma 3274 
  def getUndeliveredOrdersExpectedDeliveryDateNotMet(self, ):
3275 
    """
3276 
    Returns the list of orders whose expected delivery date has passed but have not been
3277 
    delivered yet.
3278 
    Returns an empty list if no such orders exist.
3279 
    """
3280 
    self.send_getUndeliveredOrdersExpectedDeliveryDateNotMet()
3281 
    return self.recv_getUndeliveredOrdersExpectedDeliveryDateNotMet()
3282 
 
3283 
  def send_getUndeliveredOrdersExpectedDeliveryDateNotMet(self, ):
3284 
    self._oprot.writeMessageBegin('getUndeliveredOrdersExpectedDeliveryDateNotMet', TMessageType.CALL, self._seqid)
3285 
    args = getUndeliveredOrdersExpectedDeliveryDateNotMet_args()
3286 
    args.write(self._oprot)
3287 
    self._oprot.writeMessageEnd()
3288 
    self._oprot.trans.flush()
3289 
 
3290 
  def recv_getUndeliveredOrdersExpectedDeliveryDateNotMet(self, ):
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
3297 
    result = getUndeliveredOrdersExpectedDeliveryDateNotMet_result()
3298 
    result.read(self._iprot)
3299 
    self._iprot.readMessageEnd()
3300 
    if result.success is not None:
3301 
      return result.success
3302 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUndeliveredOrdersExpectedDeliveryDateNotMet failed: unknown result");
3303 
 
2536 chandransh 3304 
  def toggleDOAFlag(self, orderId):
3305 
    """
3306 
    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.
3307 
    Returns the final flag status.
3308 
    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 3309 
 
2536 chandransh 3310 
    Parameters:
3311 
     - orderId
3312 
    """
3313 
    self.send_toggleDOAFlag(orderId)
3314 
    return self.recv_toggleDOAFlag()
1886 ankur.sing 3315 
 
2536 chandransh 3316 
  def send_toggleDOAFlag(self, orderId):
3317 
    self._oprot.writeMessageBegin('toggleDOAFlag', TMessageType.CALL, self._seqid)
3318 
    args = toggleDOAFlag_args()
3319 
    args.orderId = orderId
3320 
    args.write(self._oprot)
3321 
    self._oprot.writeMessageEnd()
3322 
    self._oprot.trans.flush()
3323 
 
3324 
  def recv_toggleDOAFlag(self, ):
3325 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3326 
    if mtype == TMessageType.EXCEPTION:
3327 
      x = TApplicationException()
3328 
      x.read(self._iprot)
3329 
      self._iprot.readMessageEnd()
3330 
      raise x
3331 
    result = toggleDOAFlag_result()
3332 
    result.read(self._iprot)
3333 
    self._iprot.readMessageEnd()
3431 rajveer 3334 
    if result.success is not None:
2536 chandransh 3335 
      return result.success
3431 rajveer 3336 
    if result.ex is not None:
2536 chandransh 3337 
      raise result.ex
3338 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "toggleDOAFlag failed: unknown result");
3339 
 
4712 rajveer 3340 
  def markOrderAsDelivered(self, orderId, deliveryTimestamp, receiver):
3341 
    """
3342 
    Parameters:
3343 
     - orderId
3344 
     - deliveryTimestamp
3345 
     - receiver
3346 
    """
3347 
    self.send_markOrderAsDelivered(orderId, deliveryTimestamp, receiver)
3348 
    self.recv_markOrderAsDelivered()
3349 
 
3350 
  def send_markOrderAsDelivered(self, orderId, deliveryTimestamp, receiver):
3351 
    self._oprot.writeMessageBegin('markOrderAsDelivered', TMessageType.CALL, self._seqid)
3352 
    args = markOrderAsDelivered_args()
3353 
    args.orderId = orderId
3354 
    args.deliveryTimestamp = deliveryTimestamp
3355 
    args.receiver = receiver
3356 
    args.write(self._oprot)
3357 
    self._oprot.writeMessageEnd()
3358 
    self._oprot.trans.flush()
3359 
 
3360 
  def recv_markOrderAsDelivered(self, ):
3361 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3362 
    if mtype == TMessageType.EXCEPTION:
3363 
      x = TApplicationException()
3364 
      x.read(self._iprot)
3365 
      self._iprot.readMessageEnd()
3366 
      raise x
3367 
    result = markOrderAsDelivered_result()
3368 
    result.read(self._iprot)
3369 
    self._iprot.readMessageEnd()
3370 
    if result.ex is not None:
3371 
      raise result.ex
3372 
    return
3373 
 
5553 rajveer 3374 
  def markOrderAsReceivedAtStore(self, orderId, deliveryTimestamp):
3375 
    """
3376 
    Parameters:
3377 
     - orderId
3378 
     - deliveryTimestamp
3379 
    """
3380 
    self.send_markOrderAsReceivedAtStore(orderId, deliveryTimestamp)
3381 
    self.recv_markOrderAsReceivedAtStore()
3382 
 
3383 
  def send_markOrderAsReceivedAtStore(self, orderId, deliveryTimestamp):
3384 
    self._oprot.writeMessageBegin('markOrderAsReceivedAtStore', TMessageType.CALL, self._seqid)
3385 
    args = markOrderAsReceivedAtStore_args()
3386 
    args.orderId = orderId
3387 
    args.deliveryTimestamp = deliveryTimestamp
3388 
    args.write(self._oprot)
3389 
    self._oprot.writeMessageEnd()
3390 
    self._oprot.trans.flush()
3391 
 
3392 
  def recv_markOrderAsReceivedAtStore(self, ):
3393 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3394 
    if mtype == TMessageType.EXCEPTION:
3395 
      x = TApplicationException()
3396 
      x.read(self._iprot)
3397 
      self._iprot.readMessageEnd()
3398 
      raise x
3399 
    result = markOrderAsReceivedAtStore_result()
3400 
    result.read(self._iprot)
3401 
    self._iprot.readMessageEnd()
3402 
    if result.ex is not None:
3403 
      raise result.ex
3404 
    return
3405 
 
4454 rajveer 3406 
  def markOrderDoaRequestReceived(self, orderId):
3407 
    """
3408 
    Once user raise the request for a DOA, order status will be changed from DELVIERY_SUCCESS to DOA_REQUEST_RECEIVED
3409 
 
3410 
    Parameters:
3411 
     - orderId
3412 
    """
3413 
    self.send_markOrderDoaRequestReceived(orderId)
3414 
    return self.recv_markOrderDoaRequestReceived()
3415 
 
3416 
  def send_markOrderDoaRequestReceived(self, orderId):
3417 
    self._oprot.writeMessageBegin('markOrderDoaRequestReceived', TMessageType.CALL, self._seqid)
3418 
    args = markOrderDoaRequestReceived_args()
3419 
    args.orderId = orderId
3420 
    args.write(self._oprot)
3421 
    self._oprot.writeMessageEnd()
3422 
    self._oprot.trans.flush()
3423 
 
3424 
  def recv_markOrderDoaRequestReceived(self, ):
3425 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3426 
    if mtype == TMessageType.EXCEPTION:
3427 
      x = TApplicationException()
3428 
      x.read(self._iprot)
3429 
      self._iprot.readMessageEnd()
3430 
      raise x
3431 
    result = markOrderDoaRequestReceived_result()
3432 
    result.read(self._iprot)
3433 
    self._iprot.readMessageEnd()
3434 
    if result.success is not None:
3435 
      return result.success
3436 
    if result.ex is not None:
3437 
      raise result.ex
3438 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderDoaRequestReceived failed: unknown result");
3439 
 
3440 
  def markOrderDoaRequestAuthorized(self, orderId, isAuthorized):
3441 
    """
3442 
    CRM person can authorize or deny the request reised by customer. If he authorizes order will change from DOA_REQUEST_RECEIVED
3443 
    to DOA_REQUEST_AUTHORIZED. If he denies, status will be changed back to DELVIERY_SUCCESS.
3444 
 
3445 
    Parameters:
3446 
     - orderId
3447 
     - isAuthorized
3448 
    """
3449 
    self.send_markOrderDoaRequestAuthorized(orderId, isAuthorized)
3450 
    return self.recv_markOrderDoaRequestAuthorized()
3451 
 
3452 
  def send_markOrderDoaRequestAuthorized(self, orderId, isAuthorized):
3453 
    self._oprot.writeMessageBegin('markOrderDoaRequestAuthorized', TMessageType.CALL, self._seqid)
3454 
    args = markOrderDoaRequestAuthorized_args()
3455 
    args.orderId = orderId
3456 
    args.isAuthorized = isAuthorized
3457 
    args.write(self._oprot)
3458 
    self._oprot.writeMessageEnd()
3459 
    self._oprot.trans.flush()
3460 
 
3461 
  def recv_markOrderDoaRequestAuthorized(self, ):
3462 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3463 
    if mtype == TMessageType.EXCEPTION:
3464 
      x = TApplicationException()
3465 
      x.read(self._iprot)
3466 
      self._iprot.readMessageEnd()
3467 
      raise x
3468 
    result = markOrderDoaRequestAuthorized_result()
3469 
    result.read(self._iprot)
3470 
    self._iprot.readMessageEnd()
3471 
    if result.success is not None:
3472 
      return result.success
3473 
    if result.ex is not None:
3474 
      raise result.ex
3475 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderDoaRequestAuthorized failed: unknown result");
3476 
 
4488 rajveer 3477 
  def markOrderReturnRequestReceived(self, orderId):
3478 
    """
3479 
    Once user raise the request for a RET, order status will be changed from DELVIERY_SUCCESS to RET_REQUEST_RECEIVED
3480 
 
3481 
    Parameters:
3482 
     - orderId
3483 
    """
3484 
    self.send_markOrderReturnRequestReceived(orderId)
3485 
    return self.recv_markOrderReturnRequestReceived()
3486 
 
3487 
  def send_markOrderReturnRequestReceived(self, orderId):
3488 
    self._oprot.writeMessageBegin('markOrderReturnRequestReceived', TMessageType.CALL, self._seqid)
3489 
    args = markOrderReturnRequestReceived_args()
3490 
    args.orderId = orderId
3491 
    args.write(self._oprot)
3492 
    self._oprot.writeMessageEnd()
3493 
    self._oprot.trans.flush()
3494 
 
3495 
  def recv_markOrderReturnRequestReceived(self, ):
3496 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3497 
    if mtype == TMessageType.EXCEPTION:
3498 
      x = TApplicationException()
3499 
      x.read(self._iprot)
3500 
      self._iprot.readMessageEnd()
3501 
      raise x
3502 
    result = markOrderReturnRequestReceived_result()
3503 
    result.read(self._iprot)
3504 
    self._iprot.readMessageEnd()
3505 
    if result.success is not None:
3506 
      return result.success
3507 
    if result.ex is not None:
3508 
      raise result.ex
3509 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderReturnRequestReceived failed: unknown result");
3510 
 
3511 
  def markOrderReturnRequestAuthorized(self, orderId, isAuthorized):
3512 
    """
3513 
    CRM person can authorize or deny the request reised by customer. If he authorizes order will change from RET_REQUEST_RECEIVED
3514 
    to RET_REQUEST_AUTHORIZED. If he denies, status will be changed back to DELVIERY_SUCCESS.
3515 
 
3516 
    Parameters:
3517 
     - orderId
3518 
     - isAuthorized
3519 
    """
3520 
    self.send_markOrderReturnRequestAuthorized(orderId, isAuthorized)
3521 
    return self.recv_markOrderReturnRequestAuthorized()
3522 
 
3523 
  def send_markOrderReturnRequestAuthorized(self, orderId, isAuthorized):
3524 
    self._oprot.writeMessageBegin('markOrderReturnRequestAuthorized', TMessageType.CALL, self._seqid)
3525 
    args = markOrderReturnRequestAuthorized_args()
3526 
    args.orderId = orderId
3527 
    args.isAuthorized = isAuthorized
3528 
    args.write(self._oprot)
3529 
    self._oprot.writeMessageEnd()
3530 
    self._oprot.trans.flush()
3531 
 
3532 
  def recv_markOrderReturnRequestAuthorized(self, ):
3533 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3534 
    if mtype == TMessageType.EXCEPTION:
3535 
      x = TApplicationException()
3536 
      x.read(self._iprot)
3537 
      self._iprot.readMessageEnd()
3538 
      raise x
3539 
    result = markOrderReturnRequestAuthorized_result()
3540 
    result.read(self._iprot)
3541 
    self._iprot.readMessageEnd()
3542 
    if result.success is not None:
3543 
      return result.success
3544 
    if result.ex is not None:
3545 
      raise result.ex
3546 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderReturnRequestAuthorized failed: unknown result");
3547 
 
4579 rajveer 3548 
  def requestPickupNumber(self, orderId, providerId):
2536 chandransh 3549 
    """
3550 
    Sends out an email to the account manager of the original courier provider used to ship the order.
4452 rajveer 3551 
    If the order status was DELIVERY_SUCCESS, it is changed to be DOA_PICKUP_REQUEST_RAISED.
3552 
    If the order status was DOA_PICKUP_REQUEST_RAISED, it is left unchanged.
2536 chandransh 3553 
    For any other status, it returns false.
3554 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 3555 
 
2536 chandransh 3556 
    Parameters:
3557 
     - orderId
4579 rajveer 3558 
     - providerId
2536 chandransh 3559 
    """
4579 rajveer 3560 
    self.send_requestPickupNumber(orderId, providerId)
2536 chandransh 3561 
    return self.recv_requestPickupNumber()
3562 
 
4579 rajveer 3563 
  def send_requestPickupNumber(self, orderId, providerId):
2536 chandransh 3564 
    self._oprot.writeMessageBegin('requestPickupNumber', TMessageType.CALL, self._seqid)
3565 
    args = requestPickupNumber_args()
3566 
    args.orderId = orderId
4579 rajveer 3567 
    args.providerId = providerId
2536 chandransh 3568 
    args.write(self._oprot)
3569 
    self._oprot.writeMessageEnd()
3570 
    self._oprot.trans.flush()
3571 
 
3572 
  def recv_requestPickupNumber(self, ):
3573 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3574 
    if mtype == TMessageType.EXCEPTION:
3575 
      x = TApplicationException()
3576 
      x.read(self._iprot)
3577 
      self._iprot.readMessageEnd()
3578 
      raise x
3579 
    result = requestPickupNumber_result()
3580 
    result.read(self._iprot)
3581 
    self._iprot.readMessageEnd()
3431 rajveer 3582 
    if result.success is not None:
2536 chandransh 3583 
      return result.success
3431 rajveer 3584 
    if result.ex is not None:
2536 chandransh 3585 
      raise result.ex
3586 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "requestPickupNumber failed: unknown result");
3587 
 
4602 rajveer 3588 
  def authorizePickup(self, orderId, pickupNumber, providerId):
2536 chandransh 3589 
    """
4452 rajveer 3590 
    If the order status is DOA_PICKUP_REQUEST_RAISED, it does the following
2536 chandransh 3591 
    	1. Sends out an email to the customer with the dispatch advice that he has to print as an attachment.
3592 
    	2. Changes order status to be DOA_PICKUP_AUTHORIZED.
3593 
    	3. Returns true
2591 chandransh 3594 
    If the order is in any other status, it returns false.
2536 chandransh 3595 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 3596 
 
2536 chandransh 3597 
    Parameters:
3598 
     - orderId
3599 
     - pickupNumber
4602 rajveer 3600 
     - providerId
2536 chandransh 3601 
    """
4602 rajveer 3602 
    self.send_authorizePickup(orderId, pickupNumber, providerId)
2536 chandransh 3603 
    return self.recv_authorizePickup()
3604 
 
4602 rajveer 3605 
  def send_authorizePickup(self, orderId, pickupNumber, providerId):
2536 chandransh 3606 
    self._oprot.writeMessageBegin('authorizePickup', TMessageType.CALL, self._seqid)
3607 
    args = authorizePickup_args()
3608 
    args.orderId = orderId
3609 
    args.pickupNumber = pickupNumber
4602 rajveer 3610 
    args.providerId = providerId
2536 chandransh 3611 
    args.write(self._oprot)
3612 
    self._oprot.writeMessageEnd()
3613 
    self._oprot.trans.flush()
3614 
 
3615 
  def recv_authorizePickup(self, ):
3616 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3617 
    if mtype == TMessageType.EXCEPTION:
3618 
      x = TApplicationException()
3619 
      x.read(self._iprot)
3620 
      self._iprot.readMessageEnd()
3621 
      raise x
3622 
    result = authorizePickup_result()
3623 
    result.read(self._iprot)
3624 
    self._iprot.readMessageEnd()
3431 rajveer 3625 
    if result.success is not None:
2536 chandransh 3626 
      return result.success
3431 rajveer 3627 
    if result.ex is not None:
2536 chandransh 3628 
      raise result.ex
3629 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "authorizePickup failed: unknown result");
3630 
 
2764 chandransh 3631 
  def markDoasAsPickedUp(self, providerId, pickupDetails):
3632 
    """
3633 
    Marks all DOA_PICKUP_AUTHORIZED orders of the previous day for a provider as DOA_RETURN_IN_TRANSIT.
3431 rajveer 3634 
 
2764 chandransh 3635 
    Parameters:
3636 
     - providerId
3637 
     - pickupDetails
3638 
    """
3639 
    self.send_markDoasAsPickedUp(providerId, pickupDetails)
4910 phani.kuma 3640 
    self.recv_markDoasAsPickedUp()
2764 chandransh 3641 
 
3642 
  def send_markDoasAsPickedUp(self, providerId, pickupDetails):
3643 
    self._oprot.writeMessageBegin('markDoasAsPickedUp', TMessageType.CALL, self._seqid)
3644 
    args = markDoasAsPickedUp_args()
3645 
    args.providerId = providerId
3646 
    args.pickupDetails = pickupDetails
3647 
    args.write(self._oprot)
3648 
    self._oprot.writeMessageEnd()
3649 
    self._oprot.trans.flush()
3650 
 
3651 
  def recv_markDoasAsPickedUp(self, ):
3652 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3653 
    if mtype == TMessageType.EXCEPTION:
3654 
      x = TApplicationException()
3655 
      x.read(self._iprot)
3656 
      self._iprot.readMessageEnd()
3657 
      raise x
3658 
    result = markDoasAsPickedUp_result()
3659 
    result.read(self._iprot)
3660 
    self._iprot.readMessageEnd()
4910 phani.kuma 3661 
    return
3662 
 
3663 
  def getDoasNotPickedUp(self, providerId):
3664 
    """
3665 
    Returns a list of orders that were authorized for pickup but did not appear in the pick-up report.
3666 
 
3667 
    Parameters:
3668 
     - providerId
3669 
    """
3670 
    self.send_getDoasNotPickedUp(providerId)
3671 
    return self.recv_getDoasNotPickedUp()
3672 
 
3673 
  def send_getDoasNotPickedUp(self, providerId):
3674 
    self._oprot.writeMessageBegin('getDoasNotPickedUp', TMessageType.CALL, self._seqid)
3675 
    args = getDoasNotPickedUp_args()
3676 
    args.providerId = providerId
3677 
    args.write(self._oprot)
3678 
    self._oprot.writeMessageEnd()
3679 
    self._oprot.trans.flush()
3680 
 
3681 
  def recv_getDoasNotPickedUp(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 = getDoasNotPickedUp_result()
3689 
    result.read(self._iprot)
3690 
    self._iprot.readMessageEnd()
3431 rajveer 3691 
    if result.success is not None:
2764 chandransh 3692 
      return result.success
4910 phani.kuma 3693 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getDoasNotPickedUp failed: unknown result");
2764 chandransh 3694 
 
4741 phani.kuma 3695 
  def markReturnOrdersAsPickedUp(self, providerId, pickupDetails):
3696 
    """
3697 
    Marks all RET_PICKUP_CONFIRMED orders of the previous day for a provider as RET_RETURN_IN_TRANSIT.
3698 
 
3699 
    Parameters:
3700 
     - providerId
3701 
     - pickupDetails
3702 
    """
3703 
    self.send_markReturnOrdersAsPickedUp(providerId, pickupDetails)
4910 phani.kuma 3704 
    self.recv_markReturnOrdersAsPickedUp()
4741 phani.kuma 3705 
 
3706 
  def send_markReturnOrdersAsPickedUp(self, providerId, pickupDetails):
3707 
    self._oprot.writeMessageBegin('markReturnOrdersAsPickedUp', TMessageType.CALL, self._seqid)
3708 
    args = markReturnOrdersAsPickedUp_args()
3709 
    args.providerId = providerId
3710 
    args.pickupDetails = pickupDetails
3711 
    args.write(self._oprot)
3712 
    self._oprot.writeMessageEnd()
3713 
    self._oprot.trans.flush()
3714 
 
3715 
  def recv_markReturnOrdersAsPickedUp(self, ):
3716 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3717 
    if mtype == TMessageType.EXCEPTION:
3718 
      x = TApplicationException()
3719 
      x.read(self._iprot)
3720 
      self._iprot.readMessageEnd()
3721 
      raise x
3722 
    result = markReturnOrdersAsPickedUp_result()
3723 
    result.read(self._iprot)
3724 
    self._iprot.readMessageEnd()
4910 phani.kuma 3725 
    return
3726 
 
3727 
  def getReturnOrdersNotPickedUp(self, providerId):
3728 
    """
3729 
    Returns a list of orders that were authorized for pickup but did not appear in the pick-up report.
3730 
 
3731 
    Parameters:
3732 
     - providerId
3733 
    """
3734 
    self.send_getReturnOrdersNotPickedUp(providerId)
3735 
    return self.recv_getReturnOrdersNotPickedUp()
3736 
 
3737 
  def send_getReturnOrdersNotPickedUp(self, providerId):
3738 
    self._oprot.writeMessageBegin('getReturnOrdersNotPickedUp', TMessageType.CALL, self._seqid)
3739 
    args = getReturnOrdersNotPickedUp_args()
3740 
    args.providerId = providerId
3741 
    args.write(self._oprot)
3742 
    self._oprot.writeMessageEnd()
3743 
    self._oprot.trans.flush()
3744 
 
3745 
  def recv_getReturnOrdersNotPickedUp(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 = getReturnOrdersNotPickedUp_result()
3753 
    result.read(self._iprot)
3754 
    self._iprot.readMessageEnd()
4741 phani.kuma 3755 
    if result.success is not None:
3756 
      return result.success
4910 phani.kuma 3757 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReturnOrdersNotPickedUp failed: unknown result");
4741 phani.kuma 3758 
 
4479 rajveer 3759 
  def receiveReturn(self, orderId, receiveCondition):
2591 chandransh 3760 
    """
4452 rajveer 3761 
    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 3762 
    If the order status is RTO_IN_TRANSIT, marks the order status as RTO_RECEIVED_PRESTINE and returns true.
2591 chandransh 3763 
    If the order is in any other state, it returns false.
3764 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 3765 
 
2591 chandransh 3766 
    Parameters:
3767 
     - orderId
4479 rajveer 3768 
     - receiveCondition
2591 chandransh 3769 
    """
4479 rajveer 3770 
    self.send_receiveReturn(orderId, receiveCondition)
2616 chandransh 3771 
    return self.recv_receiveReturn()
2536 chandransh 3772 
 
4479 rajveer 3773 
  def send_receiveReturn(self, orderId, receiveCondition):
2616 chandransh 3774 
    self._oprot.writeMessageBegin('receiveReturn', TMessageType.CALL, self._seqid)
3775 
    args = receiveReturn_args()
2591 chandransh 3776 
    args.orderId = orderId
4479 rajveer 3777 
    args.receiveCondition = receiveCondition
2591 chandransh 3778 
    args.write(self._oprot)
3779 
    self._oprot.writeMessageEnd()
3780 
    self._oprot.trans.flush()
3781 
 
2616 chandransh 3782 
  def recv_receiveReturn(self, ):
2591 chandransh 3783 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3784 
    if mtype == TMessageType.EXCEPTION:
3785 
      x = TApplicationException()
3786 
      x.read(self._iprot)
3787 
      self._iprot.readMessageEnd()
3788 
      raise x
2616 chandransh 3789 
    result = receiveReturn_result()
2591 chandransh 3790 
    result.read(self._iprot)
3791 
    self._iprot.readMessageEnd()
3431 rajveer 3792 
    if result.success is not None:
2591 chandransh 3793 
      return result.success
3431 rajveer 3794 
    if result.ex is not None:
2591 chandransh 3795 
      raise result.ex
2616 chandransh 3796 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "receiveReturn failed: unknown result");
2591 chandransh 3797 
 
3798 
  def validateDoa(self, orderId, isValid):
3799 
    """
4452 rajveer 3800 
    Used to validate the DOA certificate for an order in the DOA_RECEIVED_PRESTINE state. If the certificate is valid,
2616 chandransh 3801 
    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 3802 
    If the order is in any other state, it returns false.
3803 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 3804 
 
2591 chandransh 3805 
    Parameters:
3806 
     - orderId
3807 
     - isValid
3808 
    """
3809 
    self.send_validateDoa(orderId, isValid)
3810 
    return self.recv_validateDoa()
3811 
 
3812 
  def send_validateDoa(self, orderId, isValid):
3813 
    self._oprot.writeMessageBegin('validateDoa', TMessageType.CALL, self._seqid)
3814 
    args = validateDoa_args()
3815 
    args.orderId = orderId
3816 
    args.isValid = isValid
3817 
    args.write(self._oprot)
3818 
    self._oprot.writeMessageEnd()
3819 
    self._oprot.trans.flush()
3820 
 
3821 
  def recv_validateDoa(self, ):
3822 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3823 
    if mtype == TMessageType.EXCEPTION:
3824 
      x = TApplicationException()
3825 
      x.read(self._iprot)
3826 
      self._iprot.readMessageEnd()
3827 
      raise x
3828 
    result = validateDoa_result()
3829 
    result.read(self._iprot)
3830 
    self._iprot.readMessageEnd()
3431 rajveer 3831 
    if result.success is not None:
2591 chandransh 3832 
      return result.success
3431 rajveer 3833 
    if result.ex is not None:
2591 chandransh 3834 
      raise result.ex
3835 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "validateDoa failed: unknown result");
3836 
 
4495 rajveer 3837 
  def validateReturnProduct(self, orderId, isUsable):
3838 
    """
3839 
    Parameters:
3840 
     - orderId
3841 
     - isUsable
3842 
    """
3843 
    self.send_validateReturnProduct(orderId, isUsable)
3844 
    return self.recv_validateReturnProduct()
3845 
 
3846 
  def send_validateReturnProduct(self, orderId, isUsable):
3847 
    self._oprot.writeMessageBegin('validateReturnProduct', TMessageType.CALL, self._seqid)
3848 
    args = validateReturnProduct_args()
3849 
    args.orderId = orderId
3850 
    args.isUsable = isUsable
3851 
    args.write(self._oprot)
3852 
    self._oprot.writeMessageEnd()
3853 
    self._oprot.trans.flush()
3854 
 
3855 
  def recv_validateReturnProduct(self, ):
3856 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3857 
    if mtype == TMessageType.EXCEPTION:
3858 
      x = TApplicationException()
3859 
      x.read(self._iprot)
3860 
      self._iprot.readMessageEnd()
3861 
      raise x
3862 
    result = validateReturnProduct_result()
3863 
    result.read(self._iprot)
3864 
    self._iprot.readMessageEnd()
3865 
    if result.success is not None:
3866 
      return result.success
3867 
    if result.ex is not None:
3868 
      raise result.ex
3869 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "validateReturnProduct failed: unknown result");
3870 
 
2616 chandransh 3871 
  def reshipOrder(self, orderId):
3872 
    """
4484 rajveer 3873 
    If the order is in RTO_RECEIVED_PRESTINE or DOA_CERT_INVALID state, it does the following:
2616 chandransh 3874 
    	1. Creates a new order for processing in the BILLED state. All billing information is saved.
4484 rajveer 3875 
    	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 3876 
 
3877 
    If the order is in DOA_CERT_VALID state, it does the following:
3878 
    	1. Creates a new order for processing in the SUBMITTED_FOR_PROCESSING state.
3879 
    	2. Creates a return order for the warehouse executive to return the DOA material.
4452 rajveer 3880 
    	3. Marks the current order as the final DOA_VALID_RESHIPPED state.
3431 rajveer 3881 
 
2616 chandransh 3882 
    Returns the id of the newly created order.
3431 rajveer 3883 
 
2616 chandransh 3884 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 3885 
 
2616 chandransh 3886 
    Parameters:
3887 
     - orderId
3888 
    """
3889 
    self.send_reshipOrder(orderId)
3890 
    return self.recv_reshipOrder()
2591 chandransh 3891 
 
2616 chandransh 3892 
  def send_reshipOrder(self, orderId):
3893 
    self._oprot.writeMessageBegin('reshipOrder', TMessageType.CALL, self._seqid)
3894 
    args = reshipOrder_args()
3895 
    args.orderId = orderId
3896 
    args.write(self._oprot)
3897 
    self._oprot.writeMessageEnd()
3898 
    self._oprot.trans.flush()
3899 
 
3900 
  def recv_reshipOrder(self, ):
3901 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3902 
    if mtype == TMessageType.EXCEPTION:
3903 
      x = TApplicationException()
3904 
      x.read(self._iprot)
3905 
      self._iprot.readMessageEnd()
3906 
      raise x
3907 
    result = reshipOrder_result()
3908 
    result.read(self._iprot)
3909 
    self._iprot.readMessageEnd()
3431 rajveer 3910 
    if result.success is not None:
2616 chandransh 3911 
      return result.success
3431 rajveer 3912 
    if result.ex is not None:
2616 chandransh 3913 
      raise result.ex
3914 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "reshipOrder failed: unknown result");
3915 
 
3226 chandransh 3916 
  def refundOrder(self, orderId, refundedBy, reason):
2616 chandransh 3917 
    """
4484 rajveer 3918 
    If the order is in RTO_RECEIVED_PRESTINE, DOA_CERT_VALID or DOA_CERT_INVALID state, it does the following:
2616 chandransh 3919 
    	1. Creates a refund request for batch processing.
3920 
    	2. Creates a return order for the warehouse executive to return the shipped material.
4484 rajveer 3921 
    	3. Marks the current order as RTO_REFUNDED, DOA_VALID_REFUNDED or DOA_INVALID_REFUNDED final states.
3431 rajveer 3922 
 
2616 chandransh 3923 
    If the order is in SUBMITTED_FOR_PROCESSING or INVENTORY_LOW state, it does the following:
3924 
    	1. Creates a refund request for batch processing.
3226 chandransh 3925 
    	2. Cancels the reservation of the item in the warehouse.
3926 
    	3. Marks the current order as the REFUNDED final state.
3431 rajveer 3927 
 
3226 chandransh 3928 
    For all COD orders, if the order is in INIT, SUBMITTED_FOR_PROCESSING or INVENTORY_LOW state, it does the following:
3929 
    	1. Cancels the reservation of the item in the warehouse.
3930 
    	2. Marks the current order as CANCELED.
3931 
 
3932 
    In all cases, it updates the reason for cancellation or refund and the person who performed the action.
3933 
 
2616 chandransh 3934 
    Returns True if it is successful, False otherwise.
3431 rajveer 3935 
 
2616 chandransh 3936 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 3937 
 
2616 chandransh 3938 
    Parameters:
3939 
     - orderId
3226 chandransh 3940 
     - refundedBy
3941 
     - reason
2616 chandransh 3942 
    """
3226 chandransh 3943 
    self.send_refundOrder(orderId, refundedBy, reason)
2616 chandransh 3944 
    return self.recv_refundOrder()
3945 
 
3226 chandransh 3946 
  def send_refundOrder(self, orderId, refundedBy, reason):
2616 chandransh 3947 
    self._oprot.writeMessageBegin('refundOrder', TMessageType.CALL, self._seqid)
3948 
    args = refundOrder_args()
3949 
    args.orderId = orderId
3226 chandransh 3950 
    args.refundedBy = refundedBy
3951 
    args.reason = reason
2616 chandransh 3952 
    args.write(self._oprot)
3953 
    self._oprot.writeMessageEnd()
3954 
    self._oprot.trans.flush()
3955 
 
3956 
  def recv_refundOrder(self, ):
3957 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3958 
    if mtype == TMessageType.EXCEPTION:
3959 
      x = TApplicationException()
3960 
      x.read(self._iprot)
3961 
      self._iprot.readMessageEnd()
3962 
      raise x
3963 
    result = refundOrder_result()
3964 
    result.read(self._iprot)
3965 
    self._iprot.readMessageEnd()
3431 rajveer 3966 
    if result.success is not None:
2616 chandransh 3967 
      return result.success
3431 rajveer 3968 
    if result.ex is not None:
2616 chandransh 3969 
      raise result.ex
3970 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "refundOrder failed: unknown result");
3971 
 
2690 chandransh 3972 
  def getReturnOrders(self, warehouseId, fromDate, toDate):
3973 
    """
3974 
    Get all return orders created between the from and to dates for the given warehouse.
3975 
    Ignores the warehouse if it is passed as -1.
3431 rajveer 3976 
 
2690 chandransh 3977 
    Parameters:
3978 
     - warehouseId
3979 
     - fromDate
3980 
     - toDate
3981 
    """
3982 
    self.send_getReturnOrders(warehouseId, fromDate, toDate)
3983 
    return self.recv_getReturnOrders()
2616 chandransh 3984 
 
2690 chandransh 3985 
  def send_getReturnOrders(self, warehouseId, fromDate, toDate):
3986 
    self._oprot.writeMessageBegin('getReturnOrders', TMessageType.CALL, self._seqid)
3987 
    args = getReturnOrders_args()
3988 
    args.warehouseId = warehouseId
3989 
    args.fromDate = fromDate
3990 
    args.toDate = toDate
3991 
    args.write(self._oprot)
3992 
    self._oprot.writeMessageEnd()
3993 
    self._oprot.trans.flush()
3994 
 
3995 
  def recv_getReturnOrders(self, ):
3996 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3997 
    if mtype == TMessageType.EXCEPTION:
3998 
      x = TApplicationException()
3999 
      x.read(self._iprot)
4000 
      self._iprot.readMessageEnd()
4001 
      raise x
4002 
    result = getReturnOrders_result()
4003 
    result.read(self._iprot)
4004 
    self._iprot.readMessageEnd()
3431 rajveer 4005 
    if result.success is not None:
2690 chandransh 4006 
      return result.success
4007 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReturnOrders failed: unknown result");
4008 
 
5481 phani.kuma 4009 
  def getAllReturnOrders(self, onlyNotProcessed, fromDate, toDate):
4010 
    """
4011 
    Get all return orders created between the from and to dates.
4012 
 
4013 
    Parameters:
4014 
     - onlyNotProcessed
4015 
     - fromDate
4016 
     - toDate
4017 
    """
4018 
    self.send_getAllReturnOrders(onlyNotProcessed, fromDate, toDate)
4019 
    return self.recv_getAllReturnOrders()
4020 
 
4021 
  def send_getAllReturnOrders(self, onlyNotProcessed, fromDate, toDate):
4022 
    self._oprot.writeMessageBegin('getAllReturnOrders', TMessageType.CALL, self._seqid)
4023 
    args = getAllReturnOrders_args()
4024 
    args.onlyNotProcessed = onlyNotProcessed
4025 
    args.fromDate = fromDate
4026 
    args.toDate = toDate
4027 
    args.write(self._oprot)
4028 
    self._oprot.writeMessageEnd()
4029 
    self._oprot.trans.flush()
4030 
 
4031 
  def recv_getAllReturnOrders(self, ):
4032 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4033 
    if mtype == TMessageType.EXCEPTION:
4034 
      x = TApplicationException()
4035 
      x.read(self._iprot)
4036 
      self._iprot.readMessageEnd()
4037 
      raise x
4038 
    result = getAllReturnOrders_result()
4039 
    result.read(self._iprot)
4040 
    self._iprot.readMessageEnd()
4041 
    if result.success is not None:
4042 
      return result.success
4043 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllReturnOrders failed: unknown result");
4044 
 
2700 chandransh 4045 
  def getReturnOrder(self, id):
4046 
    """
4047 
    Returns the ReturnOrder corresponding to the given id.
4048 
    Throws an exception if the return order with the given id couldn't be found.
3431 rajveer 4049 
 
2700 chandransh 4050 
    Parameters:
4051 
     - id
4052 
    """
4053 
    self.send_getReturnOrder(id)
4054 
    return self.recv_getReturnOrder()
4055 
 
4056 
  def send_getReturnOrder(self, id):
4057 
    self._oprot.writeMessageBegin('getReturnOrder', TMessageType.CALL, self._seqid)
4058 
    args = getReturnOrder_args()
4059 
    args.id = id
4060 
    args.write(self._oprot)
4061 
    self._oprot.writeMessageEnd()
4062 
    self._oprot.trans.flush()
4063 
 
4064 
  def recv_getReturnOrder(self, ):
4065 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4066 
    if mtype == TMessageType.EXCEPTION:
4067 
      x = TApplicationException()
4068 
      x.read(self._iprot)
4069 
      self._iprot.readMessageEnd()
4070 
      raise x
4071 
    result = getReturnOrder_result()
4072 
    result.read(self._iprot)
4073 
    self._iprot.readMessageEnd()
3431 rajveer 4074 
    if result.success is not None:
2700 chandransh 4075 
      return result.success
3431 rajveer 4076 
    if result.ex is not None:
2700 chandransh 4077 
      raise result.ex
4078 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReturnOrder failed: unknown result");
4079 
 
2690 chandransh 4080 
  def processReturn(self, returnOrderId):
4081 
    """
4082 
    Marks the return order with the given id as processed. Raises an exception if no such return order exists.
3431 rajveer 4083 
 
2690 chandransh 4084 
    Parameters:
4085 
     - returnOrderId
4086 
    """
4087 
    self.send_processReturn(returnOrderId)
4088 
    self.recv_processReturn()
4089 
 
4090 
  def send_processReturn(self, returnOrderId):
4091 
    self._oprot.writeMessageBegin('processReturn', TMessageType.CALL, self._seqid)
4092 
    args = processReturn_args()
4093 
    args.returnOrderId = returnOrderId
4094 
    args.write(self._oprot)
4095 
    self._oprot.writeMessageEnd()
4096 
    self._oprot.trans.flush()
4097 
 
4098 
  def recv_processReturn(self, ):
4099 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4100 
    if mtype == TMessageType.EXCEPTION:
4101 
      x = TApplicationException()
4102 
      x.read(self._iprot)
4103 
      self._iprot.readMessageEnd()
4104 
      raise x
4105 
    result = processReturn_result()
4106 
    result.read(self._iprot)
4107 
    self._iprot.readMessageEnd()
3431 rajveer 4108 
    if result.ex is not None:
2690 chandransh 4109 
      raise result.ex
4110 
    return
4111 
 
3451 chandransh 4112 
  def updateWeight(self, orderId, weight):
4113 
    """
4114 
    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 4115 
 
3451 chandransh 4116 
    Parameters:
4117 
     - orderId
4118 
     - weight
4119 
    """
4120 
    self.send_updateWeight(orderId, weight)
4121 
    return self.recv_updateWeight()
4122 
 
4123 
  def send_updateWeight(self, orderId, weight):
4124 
    self._oprot.writeMessageBegin('updateWeight', TMessageType.CALL, self._seqid)
4125 
    args = updateWeight_args()
4126 
    args.orderId = orderId
4127 
    args.weight = weight
4128 
    args.write(self._oprot)
4129 
    self._oprot.writeMessageEnd()
4130 
    self._oprot.trans.flush()
4131 
 
4132 
  def recv_updateWeight(self, ):
4133 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4134 
    if mtype == TMessageType.EXCEPTION:
4135 
      x = TApplicationException()
4136 
      x.read(self._iprot)
4137 
      self._iprot.readMessageEnd()
4138 
      raise x
4139 
    result = updateWeight_result()
4140 
    result.read(self._iprot)
4141 
    self._iprot.readMessageEnd()
4142 
    if result.success is not None:
4143 
      return result.success
4144 
    if result.ex is not None:
4145 
      raise result.ex
4146 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updateWeight failed: unknown result");
4147 
 
3469 chandransh 4148 
  def changeItem(self, orderId, itemId):
4149 
    """
4150 
    Change the item to be shipped for this order. Also adjusts the reservation in the inventory accordingly.
4151 
    Currently, it also ensures that only a different color of the given item is shipped.
3451 chandransh 4152 
 
3469 chandransh 4153 
    Parameters:
4154 
     - orderId
4155 
     - itemId
4156 
    """
4157 
    self.send_changeItem(orderId, itemId)
4158 
    return self.recv_changeItem()
4159 
 
4160 
  def send_changeItem(self, orderId, itemId):
4161 
    self._oprot.writeMessageBegin('changeItem', TMessageType.CALL, self._seqid)
4162 
    args = changeItem_args()
4163 
    args.orderId = orderId
4164 
    args.itemId = itemId
4165 
    args.write(self._oprot)
4166 
    self._oprot.writeMessageEnd()
4167 
    self._oprot.trans.flush()
4168 
 
4169 
  def recv_changeItem(self, ):
4170 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4171 
    if mtype == TMessageType.EXCEPTION:
4172 
      x = TApplicationException()
4173 
      x.read(self._iprot)
4174 
      self._iprot.readMessageEnd()
4175 
      raise x
4176 
    result = changeItem_result()
4177 
    result.read(self._iprot)
4178 
    self._iprot.readMessageEnd()
4179 
    if result.success is not None:
4180 
      return result.success
4181 
    if result.ex is not None:
4182 
      raise result.ex
4183 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "changeItem failed: unknown result");
4184 
 
4185 
  def shiftToWarehouse(self, orderId, warehouseId):
4186 
    """
4187 
    Moves the given order to the given warehouse. Also adjusts the inventory reservations accordingly.
4188 
 
4189 
    Parameters:
4190 
     - orderId
4191 
     - warehouseId
4192 
    """
4193 
    self.send_shiftToWarehouse(orderId, warehouseId)
4194 
    return self.recv_shiftToWarehouse()
4195 
 
4196 
  def send_shiftToWarehouse(self, orderId, warehouseId):
4197 
    self._oprot.writeMessageBegin('shiftToWarehouse', TMessageType.CALL, self._seqid)
4198 
    args = shiftToWarehouse_args()
4199 
    args.orderId = orderId
4200 
    args.warehouseId = warehouseId
4201 
    args.write(self._oprot)
4202 
    self._oprot.writeMessageEnd()
4203 
    self._oprot.trans.flush()
4204 
 
4205 
  def recv_shiftToWarehouse(self, ):
4206 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4207 
    if mtype == TMessageType.EXCEPTION:
4208 
      x = TApplicationException()
4209 
      x.read(self._iprot)
4210 
      self._iprot.readMessageEnd()
4211 
      raise x
4212 
    result = shiftToWarehouse_result()
4213 
    result.read(self._iprot)
4214 
    self._iprot.readMessageEnd()
4215 
    if result.success is not None:
4216 
      return result.success
4217 
    if result.ex is not None:
4218 
      raise result.ex
4219 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "shiftToWarehouse failed: unknown result");
4220 
 
4647 rajveer 4221 
  def addDelayReason(self, orderId, delayReason, furtherDelay, delayReasonText):
3553 chandransh 4222 
    """
4223 
    Adds the given delay reason to the given order.
3986 chandransh 4224 
    Increases the expected delivery time of the given order by the given no. of days.
3553 chandransh 4225 
    Raises an exception if no order with the given id can be found.
3469 chandransh 4226 
 
3553 chandransh 4227 
    Parameters:
4228 
     - orderId
4229 
     - delayReason
3986 chandransh 4230 
     - furtherDelay
4647 rajveer 4231 
     - delayReasonText
3553 chandransh 4232 
    """
4647 rajveer 4233 
    self.send_addDelayReason(orderId, delayReason, furtherDelay, delayReasonText)
3553 chandransh 4234 
    return self.recv_addDelayReason()
4235 
 
4647 rajveer 4236 
  def send_addDelayReason(self, orderId, delayReason, furtherDelay, delayReasonText):
3553 chandransh 4237 
    self._oprot.writeMessageBegin('addDelayReason', TMessageType.CALL, self._seqid)
4238 
    args = addDelayReason_args()
4239 
    args.orderId = orderId
4240 
    args.delayReason = delayReason
3986 chandransh 4241 
    args.furtherDelay = furtherDelay
4647 rajveer 4242 
    args.delayReasonText = delayReasonText
3553 chandransh 4243 
    args.write(self._oprot)
4244 
    self._oprot.writeMessageEnd()
4245 
    self._oprot.trans.flush()
4246 
 
4247 
  def recv_addDelayReason(self, ):
4248 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4249 
    if mtype == TMessageType.EXCEPTION:
4250 
      x = TApplicationException()
4251 
      x.read(self._iprot)
4252 
      self._iprot.readMessageEnd()
4253 
      raise x
4254 
    result = addDelayReason_result()
4255 
    result.read(self._iprot)
4256 
    self._iprot.readMessageEnd()
4257 
    if result.success is not None:
4258 
      return result.success
4259 
    if result.ex is not None:
4260 
      raise result.ex
4261 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addDelayReason failed: unknown result");
4262 
 
3956 chandransh 4263 
  def reconcileCodCollection(self, collectedAmountMap, xferBy, xferTxnId, xferDate):
4264 
    """
4265 
    Marks the COD orders with given AWB nos. as having been processed.
4266 
    Updates the captured amount for the corresponding payment.
3553 chandransh 4267 
 
3956 chandransh 4268 
    Returns a map of AWBs which were not processed and the associated reason. An AWB is not processed if:
4269 
    1. There is no order corresponding to an AWB number.
4270 
    2. The captured amount for a payment exceeds the total payment.
4271 
    3. The order corresponding to an AWB no. is in a state prior to DELIVERY_SUCCESS.
4272 
 
4273 
    Parameters:
4274 
     - collectedAmountMap
4275 
     - xferBy
4276 
     - xferTxnId
4277 
     - xferDate
4278 
    """
4279 
    self.send_reconcileCodCollection(collectedAmountMap, xferBy, xferTxnId, xferDate)
4280 
    return self.recv_reconcileCodCollection()
4281 
 
4282 
  def send_reconcileCodCollection(self, collectedAmountMap, xferBy, xferTxnId, xferDate):
4283 
    self._oprot.writeMessageBegin('reconcileCodCollection', TMessageType.CALL, self._seqid)
4284 
    args = reconcileCodCollection_args()
4285 
    args.collectedAmountMap = collectedAmountMap
4286 
    args.xferBy = xferBy
4287 
    args.xferTxnId = xferTxnId
4288 
    args.xferDate = xferDate
4289 
    args.write(self._oprot)
4290 
    self._oprot.writeMessageEnd()
4291 
    self._oprot.trans.flush()
4292 
 
4293 
  def recv_reconcileCodCollection(self, ):
4294 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4295 
    if mtype == TMessageType.EXCEPTION:
4296 
      x = TApplicationException()
4297 
      x.read(self._iprot)
4298 
      self._iprot.readMessageEnd()
4299 
      raise x
4300 
    result = reconcileCodCollection_result()
4301 
    result.read(self._iprot)
4302 
    self._iprot.readMessageEnd()
4303 
    if result.success is not None:
4304 
      return result.success
4305 
    if result.ex is not None:
4306 
      raise result.ex
4307 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "reconcileCodCollection failed: unknown result");
4308 
 
4008 mandeep.dh 4309 
  def getTransactionsRequiringExtraProcessing(self, category):
4310 
    """
4065 mandeep.dh 4311 
    Returns the list of transaction ids that require some extra processing and
4008 mandeep.dh 4312 
    which belong to a particular category. This is currently used by CRM
4065 mandeep.dh 4313 
    application. If no such transaction ids are present, it returns an empty list.
3956 chandransh 4314 
 
4008 mandeep.dh 4315 
    Parameters:
4316 
     - category
4317 
    """
4318 
    self.send_getTransactionsRequiringExtraProcessing(category)
4319 
    return self.recv_getTransactionsRequiringExtraProcessing()
4320 
 
4321 
  def send_getTransactionsRequiringExtraProcessing(self, category):
4322 
    self._oprot.writeMessageBegin('getTransactionsRequiringExtraProcessing', TMessageType.CALL, self._seqid)
4323 
    args = getTransactionsRequiringExtraProcessing_args()
4324 
    args.category = category
4325 
    args.write(self._oprot)
4326 
    self._oprot.writeMessageEnd()
4327 
    self._oprot.trans.flush()
4328 
 
4329 
  def recv_getTransactionsRequiringExtraProcessing(self, ):
4330 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4331 
    if mtype == TMessageType.EXCEPTION:
4332 
      x = TApplicationException()
4333 
      x.read(self._iprot)
4334 
      self._iprot.readMessageEnd()
4335 
      raise x
4336 
    result = getTransactionsRequiringExtraProcessing_result()
4337 
    result.read(self._iprot)
4338 
    self._iprot.readMessageEnd()
4339 
    if result.success is not None:
4340 
      return result.success
4341 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransactionsRequiringExtraProcessing failed: unknown result");
4342 
 
4343 
  def markTransactionAsProcessed(self, transactionId, category):
4344 
    """
4345 
    Marks a particular transaction as processed for a particular cateogory.
4065 mandeep.dh 4346 
    It essentially deletes the transaction id record for a particular
4347 
    processing type category (if present) from DB.
4348 
    This is currently used by CRM application.
4008 mandeep.dh 4349 
 
4350 
    Parameters:
4351 
     - transactionId
4352 
     - category
4353 
    """
4354 
    self.send_markTransactionAsProcessed(transactionId, category)
4355 
    self.recv_markTransactionAsProcessed()
4356 
 
4357 
  def send_markTransactionAsProcessed(self, transactionId, category):
4358 
    self._oprot.writeMessageBegin('markTransactionAsProcessed', TMessageType.CALL, self._seqid)
4359 
    args = markTransactionAsProcessed_args()
4360 
    args.transactionId = transactionId
4361 
    args.category = category
4362 
    args.write(self._oprot)
4363 
    self._oprot.writeMessageEnd()
4364 
    self._oprot.trans.flush()
4365 
 
4366 
  def recv_markTransactionAsProcessed(self, ):
4367 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4368 
    if mtype == TMessageType.EXCEPTION:
4369 
      x = TApplicationException()
4370 
      x.read(self._iprot)
4371 
      self._iprot.readMessageEnd()
4372 
      raise x
4373 
    result = markTransactionAsProcessed_result()
4374 
    result.read(self._iprot)
4375 
    self._iprot.readMessageEnd()
4376 
    return
4377 
 
4018 chandransh 4378 
  def getItemWiseRiskyOrdersCount(self, ):
4379 
    """
4380 
    Returns a map containing the number of risky orders keyed by item id. A risky order
4381 
    is defined as one whose shipping date is about to expire.
4382 
    """
4383 
    self.send_getItemWiseRiskyOrdersCount()
4384 
    return self.recv_getItemWiseRiskyOrdersCount()
4008 mandeep.dh 4385 
 
4018 chandransh 4386 
  def send_getItemWiseRiskyOrdersCount(self, ):
4387 
    self._oprot.writeMessageBegin('getItemWiseRiskyOrdersCount', TMessageType.CALL, self._seqid)
4388 
    args = getItemWiseRiskyOrdersCount_args()
4389 
    args.write(self._oprot)
4390 
    self._oprot.writeMessageEnd()
4391 
    self._oprot.trans.flush()
4392 
 
4393 
  def recv_getItemWiseRiskyOrdersCount(self, ):
4394 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4395 
    if mtype == TMessageType.EXCEPTION:
4396 
      x = TApplicationException()
4397 
      x.read(self._iprot)
4398 
      self._iprot.readMessageEnd()
4399 
      raise x
4400 
    result = getItemWiseRiskyOrdersCount_result()
4401 
    result.read(self._iprot)
4402 
    self._iprot.readMessageEnd()
4403 
    if result.success is not None:
4404 
      return result.success
4405 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItemWiseRiskyOrdersCount failed: unknown result");
4406 
 
4295 varun.gupt 4407 
  def getOrdersForItemIds(self, itemIds):
4408 
    """
4409 
    Returns a list of all orders which have items with given id
4410 
 
4411 
    Parameters:
4412 
     - itemIds
4413 
    """
4414 
    self.send_getOrdersForItemIds(itemIds)
4415 
    return self.recv_getOrdersForItemIds()
4416 
 
4417 
  def send_getOrdersForItemIds(self, itemIds):
4418 
    self._oprot.writeMessageBegin('getOrdersForItemIds', TMessageType.CALL, self._seqid)
4419 
    args = getOrdersForItemIds_args()
4420 
    args.itemIds = itemIds
4421 
    args.write(self._oprot)
4422 
    self._oprot.writeMessageEnd()
4423 
    self._oprot.trans.flush()
4424 
 
4425 
  def recv_getOrdersForItemIds(self, ):
4426 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4427 
    if mtype == TMessageType.EXCEPTION:
4428 
      x = TApplicationException()
4429 
      x.read(self._iprot)
4430 
      self._iprot.readMessageEnd()
4431 
      raise x
4432 
    result = getOrdersForItemIds_result()
4433 
    result.read(self._iprot)
4434 
    self._iprot.readMessageEnd()
4435 
    if result.success is not None:
4436 
      return result.success
4437 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersForItemIds failed: unknown result");
4438 
 
4247 rajveer 4439 
  def markOrderCancellationRequestReceived(self, orderId):
4440 
    """
4441 
    Mark order as cancellation request received. If customer sends request of cancellation of
4442 
    a particular order, this method will be called. It will just change status of the order
4443 
    depending on its current status. It also records the previous status, so that we can move
4444 
    back to that status if cancellation request is denied.
4018 chandransh 4445 
 
4247 rajveer 4446 
    Parameters:
4447 
     - orderId
4448 
    """
4449 
    self.send_markOrderCancellationRequestReceived(orderId)
4450 
    self.recv_markOrderCancellationRequestReceived()
4451 
 
4452 
  def send_markOrderCancellationRequestReceived(self, orderId):
4453 
    self._oprot.writeMessageBegin('markOrderCancellationRequestReceived', TMessageType.CALL, self._seqid)
4454 
    args = markOrderCancellationRequestReceived_args()
4455 
    args.orderId = orderId
4456 
    args.write(self._oprot)
4457 
    self._oprot.writeMessageEnd()
4458 
    self._oprot.trans.flush()
4459 
 
4460 
  def recv_markOrderCancellationRequestReceived(self, ):
4461 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4462 
    if mtype == TMessageType.EXCEPTION:
4463 
      x = TApplicationException()
4464 
      x.read(self._iprot)
4465 
      self._iprot.readMessageEnd()
4466 
      raise x
4467 
    result = markOrderCancellationRequestReceived_result()
4468 
    result.read(self._iprot)
4469 
    self._iprot.readMessageEnd()
4470 
    if result.ex is not None:
4471 
      raise result.ex
4472 
    return
4473 
 
4474 
  def markOrderCancellationRequestConfirmed(self, orderId):
4475 
    """
4476 
    If we decide to to cancel order, CRM will call this method to move the status of order to
4477 
    cancellation request confirmed. After this OM will be able to cancel the order.
4478 
 
4479 
    Parameters:
4480 
     - orderId
4481 
    """
4482 
    self.send_markOrderCancellationRequestConfirmed(orderId)
4483 
    self.recv_markOrderCancellationRequestConfirmed()
4484 
 
4485 
  def send_markOrderCancellationRequestConfirmed(self, orderId):
4486 
    self._oprot.writeMessageBegin('markOrderCancellationRequestConfirmed', TMessageType.CALL, self._seqid)
4487 
    args = markOrderCancellationRequestConfirmed_args()
4488 
    args.orderId = orderId
4489 
    args.write(self._oprot)
4490 
    self._oprot.writeMessageEnd()
4491 
    self._oprot.trans.flush()
4492 
 
4493 
  def recv_markOrderCancellationRequestConfirmed(self, ):
4494 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4495 
    if mtype == TMessageType.EXCEPTION:
4496 
      x = TApplicationException()
4497 
      x.read(self._iprot)
4498 
      self._iprot.readMessageEnd()
4499 
      raise x
4500 
    result = markOrderCancellationRequestConfirmed_result()
4501 
    result.read(self._iprot)
4502 
    self._iprot.readMessageEnd()
4503 
    if result.ex is not None:
4504 
      raise result.ex
4505 
    return
4506 
 
4507 
  def markOrderCancellationRequestDenied(self, orderId):
4508 
    """
4509 
    If we decide to not to cancel order, we will move the order ro previous status.
4510 
 
4511 
    Parameters:
4512 
     - orderId
4513 
    """
4514 
    self.send_markOrderCancellationRequestDenied(orderId)
4515 
    self.recv_markOrderCancellationRequestDenied()
4516 
 
4517 
  def send_markOrderCancellationRequestDenied(self, orderId):
4518 
    self._oprot.writeMessageBegin('markOrderCancellationRequestDenied', TMessageType.CALL, self._seqid)
4519 
    args = markOrderCancellationRequestDenied_args()
4520 
    args.orderId = orderId
4521 
    args.write(self._oprot)
4522 
    self._oprot.writeMessageEnd()
4523 
    self._oprot.trans.flush()
4524 
 
4525 
  def recv_markOrderCancellationRequestDenied(self, ):
4526 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4527 
    if mtype == TMessageType.EXCEPTION:
4528 
      x = TApplicationException()
4529 
      x.read(self._iprot)
4530 
      self._iprot.readMessageEnd()
4531 
      raise x
4532 
    result = markOrderCancellationRequestDenied_result()
4533 
    result.read(self._iprot)
4534 
    self._iprot.readMessageEnd()
4535 
    if result.ex is not None:
4536 
      raise result.ex
4537 
    return
4538 
 
4258 rajveer 4539 
  def markTransactionAsPaymentFlagRemoved(self, transactionId):
4247 rajveer 4540 
    """
4258 rajveer 4541 
    If we and/or payment gateway has decided to accept the payment, this method needs to be called.
4542 
    Changed transaction and all orders status to payment accepted.
4247 rajveer 4543 
 
4544 
    Parameters:
4258 rajveer 4545 
     - transactionId
4247 rajveer 4546 
    """
4258 rajveer 4547 
    self.send_markTransactionAsPaymentFlagRemoved(transactionId)
4548 
    self.recv_markTransactionAsPaymentFlagRemoved()
4247 rajveer 4549 
 
4258 rajveer 4550 
  def send_markTransactionAsPaymentFlagRemoved(self, transactionId):
4551 
    self._oprot.writeMessageBegin('markTransactionAsPaymentFlagRemoved', TMessageType.CALL, self._seqid)
4552 
    args = markTransactionAsPaymentFlagRemoved_args()
4553 
    args.transactionId = transactionId
4247 rajveer 4554 
    args.write(self._oprot)
4555 
    self._oprot.writeMessageEnd()
4556 
    self._oprot.trans.flush()
4557 
 
4258 rajveer 4558 
  def recv_markTransactionAsPaymentFlagRemoved(self, ):
4247 rajveer 4559 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4560 
    if mtype == TMessageType.EXCEPTION:
4561 
      x = TApplicationException()
4562 
      x.read(self._iprot)
4563 
      self._iprot.readMessageEnd()
4564 
      raise x
4258 rajveer 4565 
    result = markTransactionAsPaymentFlagRemoved_result()
4247 rajveer 4566 
    result.read(self._iprot)
4567 
    self._iprot.readMessageEnd()
4568 
    if result.ex is not None:
4569 
      raise result.ex
4570 
    return
4571 
 
4259 anupam.sin 4572 
  def refundTransaction(self, transactionId, refundedBy, reason):
4573 
    """
4574 
    This method is called when a flagged payment is deemed unserviceable and the corresponding orders
4575 
    need to be cancelled
4247 rajveer 4576 
 
4259 anupam.sin 4577 
    Parameters:
4578 
     - transactionId
4579 
     - refundedBy
4580 
     - reason
4581 
    """
4582 
    self.send_refundTransaction(transactionId, refundedBy, reason)
4583 
    self.recv_refundTransaction()
4584 
 
4585 
  def send_refundTransaction(self, transactionId, refundedBy, reason):
4586 
    self._oprot.writeMessageBegin('refundTransaction', TMessageType.CALL, self._seqid)
4587 
    args = refundTransaction_args()
4588 
    args.transactionId = transactionId
4589 
    args.refundedBy = refundedBy
4590 
    args.reason = reason
4591 
    args.write(self._oprot)
4592 
    self._oprot.writeMessageEnd()
4593 
    self._oprot.trans.flush()
4594 
 
4595 
  def recv_refundTransaction(self, ):
4596 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4597 
    if mtype == TMessageType.EXCEPTION:
4598 
      x = TApplicationException()
4599 
      x.read(self._iprot)
4600 
      self._iprot.readMessageEnd()
4601 
      raise x
4602 
    result = refundTransaction_result()
4603 
    result.read(self._iprot)
4604 
    self._iprot.readMessageEnd()
4605 
    if result.ex is not None:
4606 
      raise result.ex
4607 
    return
4608 
 
4324 mandeep.dh 4609 
  def updateShipmentAddress(self, orderId, addressId):
4610 
    """
4611 
    Updates shipment address of an order. Delivery and shipping date estimates
4612 
    etc. are also updated here.
4613 
 
4614 
    Throws TransactionServiceException in case address change is not
4615 
    possible due to certain reasons such as new pincode in address is
4616 
    not serviceable etc.
4617 
 
4618 
    Parameters:
4619 
     - orderId
4620 
     - addressId
4621 
    """
4622 
    self.send_updateShipmentAddress(orderId, addressId)
4623 
    self.recv_updateShipmentAddress()
4624 
 
4625 
  def send_updateShipmentAddress(self, orderId, addressId):
4626 
    self._oprot.writeMessageBegin('updateShipmentAddress', TMessageType.CALL, self._seqid)
4627 
    args = updateShipmentAddress_args()
4628 
    args.orderId = orderId
4629 
    args.addressId = addressId
4630 
    args.write(self._oprot)
4631 
    self._oprot.writeMessageEnd()
4632 
    self._oprot.trans.flush()
4633 
 
4634 
  def recv_updateShipmentAddress(self, ):
4635 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4636 
    if mtype == TMessageType.EXCEPTION:
4637 
      x = TApplicationException()
4638 
      x.read(self._iprot)
4639 
      self._iprot.readMessageEnd()
4640 
      raise x
4641 
    result = updateShipmentAddress_result()
4642 
    result.read(self._iprot)
4643 
    self._iprot.readMessageEnd()
4644 
    if result.ex is not None:
4645 
      raise result.ex
4646 
    return
4647 
 
4285 rajveer 4648 
  def acceptOrdersForItemId(self, itemId, inventory):
4649 
    """
4650 
    Marks the orders as ACCEPTED for the given itemId and inventory. It also updates the accepted timestamp. If the
4651 
    given order is not a COD order, it also captures the payment if the same has not been captured.
4259 anupam.sin 4652 
 
4285 rajveer 4653 
    Parameters:
4654 
     - itemId
4655 
     - inventory
4656 
    """
4657 
    self.send_acceptOrdersForItemId(itemId, inventory)
4658 
    return self.recv_acceptOrdersForItemId()
4659 
 
4660 
  def send_acceptOrdersForItemId(self, itemId, inventory):
4661 
    self._oprot.writeMessageBegin('acceptOrdersForItemId', TMessageType.CALL, self._seqid)
4662 
    args = acceptOrdersForItemId_args()
4663 
    args.itemId = itemId
4664 
    args.inventory = inventory
4665 
    args.write(self._oprot)
4666 
    self._oprot.writeMessageEnd()
4667 
    self._oprot.trans.flush()
4668 
 
4669 
  def recv_acceptOrdersForItemId(self, ):
4670 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4671 
    if mtype == TMessageType.EXCEPTION:
4672 
      x = TApplicationException()
4673 
      x.read(self._iprot)
4674 
      self._iprot.readMessageEnd()
4675 
      raise x
4676 
    result = acceptOrdersForItemId_result()
4677 
    result.read(self._iprot)
4678 
    self._iprot.readMessageEnd()
4679 
    if result.success is not None:
4680 
      return result.success
4681 
    if result.ex is not None:
4682 
      raise result.ex
4683 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "acceptOrdersForItemId failed: unknown result");
4684 
 
4369 rajveer 4685 
  def markOrdersAsPORaised(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 4686 
    """
4687 
    Parameters:
4688 
     - vendorId
4689 
     - itemId
4690 
     - quantity
4691 
     - estimate
4369 rajveer 4692 
     - isReminder
4303 rajveer 4693 
    """
4369 rajveer 4694 
    self.send_markOrdersAsPORaised(vendorId, itemId, quantity, estimate, isReminder)
4303 rajveer 4695 
    self.recv_markOrdersAsPORaised()
4285 rajveer 4696 
 
4369 rajveer 4697 
  def send_markOrdersAsPORaised(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 4698 
    self._oprot.writeMessageBegin('markOrdersAsPORaised', TMessageType.CALL, self._seqid)
4699 
    args = markOrdersAsPORaised_args()
4700 
    args.vendorId = vendorId
4701 
    args.itemId = itemId
4702 
    args.quantity = quantity
4703 
    args.estimate = estimate
4369 rajveer 4704 
    args.isReminder = isReminder
4303 rajveer 4705 
    args.write(self._oprot)
4706 
    self._oprot.writeMessageEnd()
4707 
    self._oprot.trans.flush()
4708 
 
4709 
  def recv_markOrdersAsPORaised(self, ):
4710 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4711 
    if mtype == TMessageType.EXCEPTION:
4712 
      x = TApplicationException()
4713 
      x.read(self._iprot)
4714 
      self._iprot.readMessageEnd()
4715 
      raise x
4716 
    result = markOrdersAsPORaised_result()
4717 
    result.read(self._iprot)
4718 
    self._iprot.readMessageEnd()
4719 
    if result.ex is not None:
4720 
      raise result.ex
4721 
    return
4722 
 
4369 rajveer 4723 
  def markOrdersAsReversalInitiated(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 4724 
    """
4725 
    Parameters:
4726 
     - vendorId
4727 
     - itemId
4728 
     - quantity
4729 
     - estimate
4369 rajveer 4730 
     - isReminder
4303 rajveer 4731 
    """
4369 rajveer 4732 
    self.send_markOrdersAsReversalInitiated(vendorId, itemId, quantity, estimate, isReminder)
4303 rajveer 4733 
    self.recv_markOrdersAsReversalInitiated()
4734 
 
4369 rajveer 4735 
  def send_markOrdersAsReversalInitiated(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 4736 
    self._oprot.writeMessageBegin('markOrdersAsReversalInitiated', TMessageType.CALL, self._seqid)
4737 
    args = markOrdersAsReversalInitiated_args()
4738 
    args.vendorId = vendorId
4739 
    args.itemId = itemId
4740 
    args.quantity = quantity
4741 
    args.estimate = estimate
4369 rajveer 4742 
    args.isReminder = isReminder
4303 rajveer 4743 
    args.write(self._oprot)
4744 
    self._oprot.writeMessageEnd()
4745 
    self._oprot.trans.flush()
4746 
 
4747 
  def recv_markOrdersAsReversalInitiated(self, ):
4748 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4749 
    if mtype == TMessageType.EXCEPTION:
4750 
      x = TApplicationException()
4751 
      x.read(self._iprot)
4752 
      self._iprot.readMessageEnd()
4753 
      raise x
4754 
    result = markOrdersAsReversalInitiated_result()
4755 
    result.read(self._iprot)
4756 
    self._iprot.readMessageEnd()
4757 
    if result.ex is not None:
4758 
      raise result.ex
4759 
    return
4760 
 
4369 rajveer 4761 
  def markOrdersAsNotAvailabke(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 4762 
    """
4763 
    Parameters:
4764 
     - vendorId
4765 
     - itemId
4766 
     - quantity
4767 
     - estimate
4369 rajveer 4768 
     - isReminder
4303 rajveer 4769 
    """
4369 rajveer 4770 
    self.send_markOrdersAsNotAvailabke(vendorId, itemId, quantity, estimate, isReminder)
4303 rajveer 4771 
    self.recv_markOrdersAsNotAvailabke()
4772 
 
4369 rajveer 4773 
  def send_markOrdersAsNotAvailabke(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 4774 
    self._oprot.writeMessageBegin('markOrdersAsNotAvailabke', TMessageType.CALL, self._seqid)
4775 
    args = markOrdersAsNotAvailabke_args()
4776 
    args.vendorId = vendorId
4777 
    args.itemId = itemId
4778 
    args.quantity = quantity
4779 
    args.estimate = estimate
4369 rajveer 4780 
    args.isReminder = isReminder
4303 rajveer 4781 
    args.write(self._oprot)
4782 
    self._oprot.writeMessageEnd()
4783 
    self._oprot.trans.flush()
4784 
 
4785 
  def recv_markOrdersAsNotAvailabke(self, ):
4786 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4787 
    if mtype == TMessageType.EXCEPTION:
4788 
      x = TApplicationException()
4789 
      x.read(self._iprot)
4790 
      self._iprot.readMessageEnd()
4791 
      raise x
4792 
    result = markOrdersAsNotAvailabke_result()
4793 
    result.read(self._iprot)
4794 
    self._iprot.readMessageEnd()
4795 
    if result.ex is not None:
4796 
      raise result.ex
4797 
    return
4798 
 
4369 rajveer 4799 
  def markOrdersAsTimeout(self, vendorId):
4800 
    """
4801 
    Parameters:
4802 
     - vendorId
4803 
    """
4804 
    self.send_markOrdersAsTimeout(vendorId)
4805 
    return self.recv_markOrdersAsTimeout()
4303 rajveer 4806 
 
4369 rajveer 4807 
  def send_markOrdersAsTimeout(self, vendorId):
4808 
    self._oprot.writeMessageBegin('markOrdersAsTimeout', TMessageType.CALL, self._seqid)
4809 
    args = markOrdersAsTimeout_args()
4810 
    args.vendorId = vendorId
4811 
    args.write(self._oprot)
4812 
    self._oprot.writeMessageEnd()
4813 
    self._oprot.trans.flush()
4814 
 
4815 
  def recv_markOrdersAsTimeout(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 = markOrdersAsTimeout_result()
4823 
    result.read(self._iprot)
4824 
    self._iprot.readMessageEnd()
4825 
    if result.success is not None:
4826 
      return result.success
4827 
    if result.ex is not None:
4828 
      raise result.ex
4829 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrdersAsTimeout failed: unknown result");
4830 
 
4662 rajveer 4831 
  def markOrderAsLostInTransit(self, orderId):
4832 
    """
4833 
    Mark order as LOST_IN_TRANSIT
4834 
 
4835 
    Parameters:
4836 
     - orderId
4837 
    """
4838 
    self.send_markOrderAsLostInTransit(orderId)
4839 
    return self.recv_markOrderAsLostInTransit()
4840 
 
4841 
  def send_markOrderAsLostInTransit(self, orderId):
4842 
    self._oprot.writeMessageBegin('markOrderAsLostInTransit', TMessageType.CALL, self._seqid)
4843 
    args = markOrderAsLostInTransit_args()
4844 
    args.orderId = orderId
4845 
    args.write(self._oprot)
4846 
    self._oprot.writeMessageEnd()
4847 
    self._oprot.trans.flush()
4848 
 
4849 
  def recv_markOrderAsLostInTransit(self, ):
4850 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4851 
    if mtype == TMessageType.EXCEPTION:
4852 
      x = TApplicationException()
4853 
      x.read(self._iprot)
4854 
      self._iprot.readMessageEnd()
4855 
      raise x
4856 
    result = markOrderAsLostInTransit_result()
4857 
    result.read(self._iprot)
4858 
    self._iprot.readMessageEnd()
4859 
    if result.success is not None:
4860 
      return result.success
4861 
    if result.ex is not None:
4862 
      raise result.ex
4863 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderAsLostInTransit failed: unknown result");
4864 
 
4386 anupam.sin 4865 
  def getOrderForAwb(self, awb):
4866 
    """
4867 
    Returns the order corresponding to an AWB number
4369 rajveer 4868 
 
4386 anupam.sin 4869 
    Parameters:
4870 
     - awb
4871 
    """
4872 
    self.send_getOrderForAwb(awb)
4873 
    return self.recv_getOrderForAwb()
4874 
 
4875 
  def send_getOrderForAwb(self, awb):
4876 
    self._oprot.writeMessageBegin('getOrderForAwb', TMessageType.CALL, self._seqid)
4877 
    args = getOrderForAwb_args()
4878 
    args.awb = awb
4879 
    args.write(self._oprot)
4880 
    self._oprot.writeMessageEnd()
4881 
    self._oprot.trans.flush()
4882 
 
4883 
  def recv_getOrderForAwb(self, ):
4884 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4885 
    if mtype == TMessageType.EXCEPTION:
4886 
      x = TApplicationException()
4887 
      x.read(self._iprot)
4888 
      self._iprot.readMessageEnd()
4889 
      raise x
4890 
    result = getOrderForAwb_result()
4891 
    result.read(self._iprot)
4892 
    self._iprot.readMessageEnd()
4893 
    if result.success is not None:
4894 
      return result.success
4895 
    if result.ex is not None:
4896 
      raise result.ex
4897 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderForAwb failed: unknown result");
4898 
 
4910 phani.kuma 4899 
  def getOrdersForProviderForStatus(self, logistics_provider_id, order_status_list):
4506 phani.kuma 4900 
    """
4910 phani.kuma 4901 
    Returns the order corresponding to a logistics provider id for a given list of order status
4386 anupam.sin 4902 
 
4506 phani.kuma 4903 
    Parameters:
4904 
     - logistics_provider_id
4910 phani.kuma 4905 
     - order_status_list
4506 phani.kuma 4906 
    """
4910 phani.kuma 4907 
    self.send_getOrdersForProviderForStatus(logistics_provider_id, order_status_list)
4506 phani.kuma 4908 
    return self.recv_getOrdersForProviderForStatus()
4909 
 
4910 phani.kuma 4910 
  def send_getOrdersForProviderForStatus(self, logistics_provider_id, order_status_list):
4506 phani.kuma 4911 
    self._oprot.writeMessageBegin('getOrdersForProviderForStatus', TMessageType.CALL, self._seqid)
4912 
    args = getOrdersForProviderForStatus_args()
4913 
    args.logistics_provider_id = logistics_provider_id
4910 phani.kuma 4914 
    args.order_status_list = order_status_list
4506 phani.kuma 4915 
    args.write(self._oprot)
4916 
    self._oprot.writeMessageEnd()
4917 
    self._oprot.trans.flush()
4918 
 
4919 
  def recv_getOrdersForProviderForStatus(self, ):
4920 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4921 
    if mtype == TMessageType.EXCEPTION:
4922 
      x = TApplicationException()
4923 
      x.read(self._iprot)
4924 
      self._iprot.readMessageEnd()
4925 
      raise x
4926 
    result = getOrdersForProviderForStatus_result()
4927 
    result.read(self._iprot)
4928 
    self._iprot.readMessageEnd()
4929 
    if result.success is not None:
4930 
      return result.success
4931 
    if result.ex is not None:
4932 
      raise result.ex
4933 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersForProviderForStatus failed: unknown result");
4934 
 
4600 varun.gupt 4935 
  def getBilledOrdersForVendor(self, vendorId, billingDateFrom, billingDateTo):
4936 
    """
4937 
    Returns list of orders fullfiled from a certain vendor and billed in a given date range
4506 phani.kuma 4938 
 
4600 varun.gupt 4939 
    Parameters:
4940 
     - vendorId
4941 
     - billingDateFrom
4942 
     - billingDateTo
4943 
    """
4944 
    self.send_getBilledOrdersForVendor(vendorId, billingDateFrom, billingDateTo)
4945 
    return self.recv_getBilledOrdersForVendor()
4946 
 
4947 
  def send_getBilledOrdersForVendor(self, vendorId, billingDateFrom, billingDateTo):
4948 
    self._oprot.writeMessageBegin('getBilledOrdersForVendor', TMessageType.CALL, self._seqid)
4949 
    args = getBilledOrdersForVendor_args()
4950 
    args.vendorId = vendorId
4951 
    args.billingDateFrom = billingDateFrom
4952 
    args.billingDateTo = billingDateTo
4953 
    args.write(self._oprot)
4954 
    self._oprot.writeMessageEnd()
4955 
    self._oprot.trans.flush()
4956 
 
4957 
  def recv_getBilledOrdersForVendor(self, ):
4958 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4959 
    if mtype == TMessageType.EXCEPTION:
4960 
      x = TApplicationException()
4961 
      x.read(self._iprot)
4962 
      self._iprot.readMessageEnd()
4963 
      raise x
4964 
    result = getBilledOrdersForVendor_result()
4965 
    result.read(self._iprot)
4966 
    self._iprot.readMessageEnd()
4967 
    if result.success is not None:
4968 
      return result.success
4969 
    if result.ex is not None:
4970 
      raise result.ex
4971 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBilledOrdersForVendor failed: unknown result");
4972 
 
4607 rajveer 4973 
  def getSlippedSippingDateOrders(self, ):
4974 
    self.send_getSlippedSippingDateOrders()
4975 
    return self.recv_getSlippedSippingDateOrders()
4976 
 
4977 
  def send_getSlippedSippingDateOrders(self, ):
4978 
    self._oprot.writeMessageBegin('getSlippedSippingDateOrders', TMessageType.CALL, self._seqid)
4979 
    args = getSlippedSippingDateOrders_args()
4980 
    args.write(self._oprot)
4981 
    self._oprot.writeMessageEnd()
4982 
    self._oprot.trans.flush()
4983 
 
4984 
  def recv_getSlippedSippingDateOrders(self, ):
4985 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4986 
    if mtype == TMessageType.EXCEPTION:
4987 
      x = TApplicationException()
4988 
      x.read(self._iprot)
4989 
      self._iprot.readMessageEnd()
4990 
      raise x
4991 
    result = getSlippedSippingDateOrders_result()
4992 
    result.read(self._iprot)
4993 
    self._iprot.readMessageEnd()
4994 
    if result.success is not None:
4995 
      return result.success
4996 
    if result.ex is not None:
4997 
      raise result.ex
4998 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getSlippedSippingDateOrders failed: unknown result");
4999 
 
4709 rajveer 5000 
  def getCancelledOrders(self, cancelDateFrom, cancelDateTo):
5001 
    """
5002 
    Parameters:
5003 
     - cancelDateFrom
5004 
     - cancelDateTo
5005 
    """
5006 
    self.send_getCancelledOrders(cancelDateFrom, cancelDateTo)
5007 
    return self.recv_getCancelledOrders()
5008 
 
5009 
  def send_getCancelledOrders(self, cancelDateFrom, cancelDateTo):
5010 
    self._oprot.writeMessageBegin('getCancelledOrders', TMessageType.CALL, self._seqid)
5011 
    args = getCancelledOrders_args()
5012 
    args.cancelDateFrom = cancelDateFrom
5013 
    args.cancelDateTo = cancelDateTo
5014 
    args.write(self._oprot)
5015 
    self._oprot.writeMessageEnd()
5016 
    self._oprot.trans.flush()
5017 
 
5018 
  def recv_getCancelledOrders(self, ):
5019 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5020 
    if mtype == TMessageType.EXCEPTION:
5021 
      x = TApplicationException()
5022 
      x.read(self._iprot)
5023 
      self._iprot.readMessageEnd()
5024 
      raise x
5025 
    result = getCancelledOrders_result()
5026 
    result.read(self._iprot)
5027 
    self._iprot.readMessageEnd()
5028 
    if result.success is not None:
5029 
      return result.success
5030 
    if result.ex is not None:
5031 
      raise result.ex
5032 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCancelledOrders failed: unknown result");
5033 
 
4600 varun.gupt 5034 
  def saveBluedartSettlements(self, mapAWBAndAmount):
5035 
    """
5036 
    Parameters:
5037 
     - mapAWBAndAmount
5038 
    """
5039 
    self.send_saveBluedartSettlements(mapAWBAndAmount)
5040 
    self.recv_saveBluedartSettlements()
5041 
 
5042 
  def send_saveBluedartSettlements(self, mapAWBAndAmount):
5043 
    self._oprot.writeMessageBegin('saveBluedartSettlements', TMessageType.CALL, self._seqid)
5044 
    args = saveBluedartSettlements_args()
5045 
    args.mapAWBAndAmount = mapAWBAndAmount
5046 
    args.write(self._oprot)
5047 
    self._oprot.writeMessageEnd()
5048 
    self._oprot.trans.flush()
5049 
 
5050 
  def recv_saveBluedartSettlements(self, ):
5051 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5052 
    if mtype == TMessageType.EXCEPTION:
5053 
      x = TApplicationException()
5054 
      x.read(self._iprot)
5055 
      self._iprot.readMessageEnd()
5056 
      raise x
5057 
    result = saveBluedartSettlements_result()
5058 
    result.read(self._iprot)
5059 
    self._iprot.readMessageEnd()
5060 
    if result.ex is not None:
5061 
      raise result.ex
5062 
    return
5063 
 
4905 varun.gupt 5064 
  def savePaymentSettlements(self, settlementDate, paymentGatewayId, referenceId, serviceTax, otherCharges, netCollection):
4600 varun.gupt 5065 
    """
5066 
    Parameters:
5067 
     - settlementDate
5068 
     - paymentGatewayId
4905 varun.gupt 5069 
     - referenceId
4600 varun.gupt 5070 
     - serviceTax
5071 
     - otherCharges
5072 
     - netCollection
5073 
    """
4905 varun.gupt 5074 
    self.send_savePaymentSettlements(settlementDate, paymentGatewayId, referenceId, serviceTax, otherCharges, netCollection)
4600 varun.gupt 5075 
    self.recv_savePaymentSettlements()
5076 
 
4905 varun.gupt 5077 
  def send_savePaymentSettlements(self, settlementDate, paymentGatewayId, referenceId, serviceTax, otherCharges, netCollection):
4600 varun.gupt 5078 
    self._oprot.writeMessageBegin('savePaymentSettlements', TMessageType.CALL, self._seqid)
5079 
    args = savePaymentSettlements_args()
5080 
    args.settlementDate = settlementDate
5081 
    args.paymentGatewayId = paymentGatewayId
4905 varun.gupt 5082 
    args.referenceId = referenceId
4600 varun.gupt 5083 
    args.serviceTax = serviceTax
5084 
    args.otherCharges = otherCharges
5085 
    args.netCollection = netCollection
5086 
    args.write(self._oprot)
5087 
    self._oprot.writeMessageEnd()
5088 
    self._oprot.trans.flush()
5089 
 
5090 
  def recv_savePaymentSettlements(self, ):
5091 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5092 
    if mtype == TMessageType.EXCEPTION:
5093 
      x = TApplicationException()
5094 
      x.read(self._iprot)
5095 
      self._iprot.readMessageEnd()
5096 
      raise x
5097 
    result = savePaymentSettlements_result()
5098 
    result.read(self._iprot)
5099 
    self._iprot.readMessageEnd()
5100 
    if result.ex is not None:
5101 
      raise result.ex
5102 
    return
5103 
 
5104 
  def saveEBSSettlementSummary(self, settlementId, settlementDate, transactionDateFrom, transactionDateTo, amount):
5105 
    """
5106 
    Parameters:
5107 
     - settlementId
5108 
     - settlementDate
5109 
     - transactionDateFrom
5110 
     - transactionDateTo
5111 
     - amount
5112 
    """
5113 
    self.send_saveEBSSettlementSummary(settlementId, settlementDate, transactionDateFrom, transactionDateTo, amount)
5114 
    self.recv_saveEBSSettlementSummary()
5115 
 
5116 
  def send_saveEBSSettlementSummary(self, settlementId, settlementDate, transactionDateFrom, transactionDateTo, amount):
5117 
    self._oprot.writeMessageBegin('saveEBSSettlementSummary', TMessageType.CALL, self._seqid)
5118 
    args = saveEBSSettlementSummary_args()
5119 
    args.settlementId = settlementId
5120 
    args.settlementDate = settlementDate
5121 
    args.transactionDateFrom = transactionDateFrom
5122 
    args.transactionDateTo = transactionDateTo
5123 
    args.amount = amount
5124 
    args.write(self._oprot)
5125 
    self._oprot.writeMessageEnd()
5126 
    self._oprot.trans.flush()
5127 
 
5128 
  def recv_saveEBSSettlementSummary(self, ):
5129 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5130 
    if mtype == TMessageType.EXCEPTION:
5131 
      x = TApplicationException()
5132 
      x.read(self._iprot)
5133 
      self._iprot.readMessageEnd()
5134 
      raise x
5135 
    result = saveEBSSettlementSummary_result()
5136 
    result.read(self._iprot)
5137 
    self._iprot.readMessageEnd()
5138 
    if result.ex is not None:
5139 
      raise result.ex
5140 
    return
5141 
 
5386 phani.kuma 5142 
  def getSettlementForPrepaid(self, referenceId, isRefund):
4600 varun.gupt 5143 
    """
5144 
    Parameters:
5189 varun.gupt 5145 
     - referenceId
5146 
     - isRefund
4600 varun.gupt 5147 
    """
5386 phani.kuma 5148 
    self.send_getSettlementForPrepaid(referenceId, isRefund)
5149 
    return self.recv_getSettlementForPrepaid()
4600 varun.gupt 5150 
 
5386 phani.kuma 5151 
  def send_getSettlementForPrepaid(self, referenceId, isRefund):
5152 
    self._oprot.writeMessageBegin('getSettlementForPrepaid', TMessageType.CALL, self._seqid)
5153 
    args = getSettlementForPrepaid_args()
5189 varun.gupt 5154 
    args.referenceId = referenceId
5155 
    args.isRefund = isRefund
4600 varun.gupt 5156 
    args.write(self._oprot)
5157 
    self._oprot.writeMessageEnd()
5158 
    self._oprot.trans.flush()
5159 
 
5386 phani.kuma 5160 
  def recv_getSettlementForPrepaid(self, ):
4600 varun.gupt 5161 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5162 
    if mtype == TMessageType.EXCEPTION:
5163 
      x = TApplicationException()
5164 
      x.read(self._iprot)
5165 
      self._iprot.readMessageEnd()
5166 
      raise x
5386 phani.kuma 5167 
    result = getSettlementForPrepaid_result()
4600 varun.gupt 5168 
    result.read(self._iprot)
5169 
    self._iprot.readMessageEnd()
5170 
    if result.success is not None:
5171 
      return result.success
5172 
    if result.ex is not None:
5173 
      raise result.ex
5386 phani.kuma 5174 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getSettlementForPrepaid failed: unknown result");
4600 varun.gupt 5175 
 
5386 phani.kuma 5176 
  def getSettlementForCod(self, orderId, isRefund):
5177 
    """
5178 
    Parameters:
5179 
     - orderId
5180 
     - isRefund
5181 
    """
5182 
    self.send_getSettlementForCod(orderId, isRefund)
5183 
    return self.recv_getSettlementForCod()
5184 
 
5185 
  def send_getSettlementForCod(self, orderId, isRefund):
5186 
    self._oprot.writeMessageBegin('getSettlementForCod', TMessageType.CALL, self._seqid)
5187 
    args = getSettlementForCod_args()
5188 
    args.orderId = orderId
5189 
    args.isRefund = isRefund
5190 
    args.write(self._oprot)
5191 
    self._oprot.writeMessageEnd()
5192 
    self._oprot.trans.flush()
5193 
 
5194 
  def recv_getSettlementForCod(self, ):
5195 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5196 
    if mtype == TMessageType.EXCEPTION:
5197 
      x = TApplicationException()
5198 
      x.read(self._iprot)
5199 
      self._iprot.readMessageEnd()
5200 
      raise x
5201 
    result = getSettlementForCod_result()
5202 
    result.read(self._iprot)
5203 
    self._iprot.readMessageEnd()
5204 
    if result.success is not None:
5205 
      return result.success
5206 
    if result.ex is not None:
5207 
      raise result.ex
5208 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getSettlementForCod failed: unknown result");
5209 
 
4600 varun.gupt 5210 
  def getEBSSettlementSummaries(self, ):
5211 
    self.send_getEBSSettlementSummaries()
5212 
    return self.recv_getEBSSettlementSummaries()
5213 
 
5214 
  def send_getEBSSettlementSummaries(self, ):
5215 
    self._oprot.writeMessageBegin('getEBSSettlementSummaries', TMessageType.CALL, self._seqid)
5216 
    args = getEBSSettlementSummaries_args()
5217 
    args.write(self._oprot)
5218 
    self._oprot.writeMessageEnd()
5219 
    self._oprot.trans.flush()
5220 
 
5221 
  def recv_getEBSSettlementSummaries(self, ):
5222 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5223 
    if mtype == TMessageType.EXCEPTION:
5224 
      x = TApplicationException()
5225 
      x.read(self._iprot)
5226 
      self._iprot.readMessageEnd()
5227 
      raise x
5228 
    result = getEBSSettlementSummaries_result()
5229 
    result.read(self._iprot)
5230 
    self._iprot.readMessageEnd()
5231 
    if result.success is not None:
5232 
      return result.success
5233 
    if result.ex is not None:
5234 
      raise result.ex
5235 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getEBSSettlementSummaries failed: unknown result");
5236 
 
5237 
  def markEBSSettlementUploaded(self, settlementId):
5238 
    """
5239 
    Parameters:
5240 
     - settlementId
5241 
    """
5242 
    self.send_markEBSSettlementUploaded(settlementId)
5243 
    self.recv_markEBSSettlementUploaded()
5244 
 
5245 
  def send_markEBSSettlementUploaded(self, settlementId):
5246 
    self._oprot.writeMessageBegin('markEBSSettlementUploaded', TMessageType.CALL, self._seqid)
5247 
    args = markEBSSettlementUploaded_args()
5248 
    args.settlementId = settlementId
5249 
    args.write(self._oprot)
5250 
    self._oprot.writeMessageEnd()
5251 
    self._oprot.trans.flush()
5252 
 
5253 
  def recv_markEBSSettlementUploaded(self, ):
5254 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5255 
    if mtype == TMessageType.EXCEPTION:
5256 
      x = TApplicationException()
5257 
      x.read(self._iprot)
5258 
      self._iprot.readMessageEnd()
5259 
      raise x
5260 
    result = markEBSSettlementUploaded_result()
5261 
    result.read(self._iprot)
5262 
    self._iprot.readMessageEnd()
5263 
    if result.ex is not None:
5264 
      raise result.ex
5265 
    return
5266 
 
5267 
  def getEBSSettlementDate(self, settlementId):
5268 
    """
5269 
    Parameters:
5270 
     - settlementId
5271 
    """
5272 
    self.send_getEBSSettlementDate(settlementId)
5273 
    return self.recv_getEBSSettlementDate()
5274 
 
5275 
  def send_getEBSSettlementDate(self, settlementId):
5276 
    self._oprot.writeMessageBegin('getEBSSettlementDate', TMessageType.CALL, self._seqid)
5277 
    args = getEBSSettlementDate_args()
5278 
    args.settlementId = settlementId
5279 
    args.write(self._oprot)
5280 
    self._oprot.writeMessageEnd()
5281 
    self._oprot.trans.flush()
5282 
 
5283 
  def recv_getEBSSettlementDate(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 = getEBSSettlementDate_result()
5291 
    result.read(self._iprot)
5292 
    self._iprot.readMessageEnd()
5293 
    if result.success is not None:
5294 
      return result.success
5295 
    if result.ex is not None:
5296 
      raise result.ex
5297 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getEBSSettlementDate failed: unknown result");
5298 
 
4715 varun.gupt 5299 
  def getSettlementsByDate(self, settlementDateFrom, settlementDateTo, isRefund):
5300 
    """
5301 
    Parameters:
5302 
     - settlementDateFrom
5303 
     - settlementDateTo
5304 
     - isRefund
5305 
    """
5306 
    self.send_getSettlementsByDate(settlementDateFrom, settlementDateTo, isRefund)
5307 
    return self.recv_getSettlementsByDate()
4600 varun.gupt 5308 
 
4715 varun.gupt 5309 
  def send_getSettlementsByDate(self, settlementDateFrom, settlementDateTo, isRefund):
5310 
    self._oprot.writeMessageBegin('getSettlementsByDate', TMessageType.CALL, self._seqid)
5311 
    args = getSettlementsByDate_args()
5312 
    args.settlementDateFrom = settlementDateFrom
5313 
    args.settlementDateTo = settlementDateTo
5314 
    args.isRefund = isRefund
5315 
    args.write(self._oprot)
5316 
    self._oprot.writeMessageEnd()
5317 
    self._oprot.trans.flush()
5318 
 
5319 
  def recv_getSettlementsByDate(self, ):
5320 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5321 
    if mtype == TMessageType.EXCEPTION:
5322 
      x = TApplicationException()
5323 
      x.read(self._iprot)
5324 
      self._iprot.readMessageEnd()
5325 
      raise x
5326 
    result = getSettlementsByDate_result()
5327 
    result.read(self._iprot)
5328 
    self._iprot.readMessageEnd()
5329 
    if result.success is not None:
5330 
      return result.success
5331 
    if result.ex is not None:
5332 
      raise result.ex
5333 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getSettlementsByDate failed: unknown result");
5334 
 
5335 
  def getReshippedOrderIds(self, orderIds):
5336 
    """
5337 
    Returns list of Order Ids, which belong to reshiped orders, shortlisted from a given list of Order Ids
5338 
 
5339 
    Parameters:
5340 
     - orderIds
5341 
    """
5342 
    self.send_getReshippedOrderIds(orderIds)
5343 
    return self.recv_getReshippedOrderIds()
5344 
 
5345 
  def send_getReshippedOrderIds(self, orderIds):
5346 
    self._oprot.writeMessageBegin('getReshippedOrderIds', TMessageType.CALL, self._seqid)
5347 
    args = getReshippedOrderIds_args()
5348 
    args.orderIds = orderIds
5349 
    args.write(self._oprot)
5350 
    self._oprot.writeMessageEnd()
5351 
    self._oprot.trans.flush()
5352 
 
5353 
  def recv_getReshippedOrderIds(self, ):
5354 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5355 
    if mtype == TMessageType.EXCEPTION:
5356 
      x = TApplicationException()
5357 
      x.read(self._iprot)
5358 
      self._iprot.readMessageEnd()
5359 
      raise x
5360 
    result = getReshippedOrderIds_result()
5361 
    result.read(self._iprot)
5362 
    self._iprot.readMessageEnd()
5363 
    if result.success is not None:
5364 
      return result.success
5365 
    if result.ex is not None:
5366 
      raise result.ex
5367 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReshippedOrderIds failed: unknown result");
5368 
 
5481 phani.kuma 5369 
  def getBilledOrders(self, vendorId, onlyVendorNotPaid, billingDateFrom, billingDateTo):
4875 varun.gupt 5370 
    """
5371 
    Parameters:
5372 
     - vendorId
5481 phani.kuma 5373 
     - onlyVendorNotPaid
5374 
     - billingDateFrom
5375 
     - billingDateTo
4875 varun.gupt 5376 
    """
5481 phani.kuma 5377 
    self.send_getBilledOrders(vendorId, onlyVendorNotPaid, billingDateFrom, billingDateTo)
5378 
    return self.recv_getBilledOrders()
4757 mandeep.dh 5379 
 
5481 phani.kuma 5380 
  def send_getBilledOrders(self, vendorId, onlyVendorNotPaid, billingDateFrom, billingDateTo):
5381 
    self._oprot.writeMessageBegin('getBilledOrders', TMessageType.CALL, self._seqid)
5382 
    args = getBilledOrders_args()
4875 varun.gupt 5383 
    args.vendorId = vendorId
5481 phani.kuma 5384 
    args.onlyVendorNotPaid = onlyVendorNotPaid
5385 
    args.billingDateFrom = billingDateFrom
5386 
    args.billingDateTo = billingDateTo
4875 varun.gupt 5387 
    args.write(self._oprot)
5388 
    self._oprot.writeMessageEnd()
5389 
    self._oprot.trans.flush()
5390 
 
5481 phani.kuma 5391 
  def recv_getBilledOrders(self, ):
4875 varun.gupt 5392 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5393 
    if mtype == TMessageType.EXCEPTION:
5394 
      x = TApplicationException()
5395 
      x.read(self._iprot)
5396 
      self._iprot.readMessageEnd()
5397 
      raise x
5481 phani.kuma 5398 
    result = getBilledOrders_result()
4875 varun.gupt 5399 
    result.read(self._iprot)
5400 
    self._iprot.readMessageEnd()
5401 
    if result.success is not None:
5402 
      return result.success
5403 
    if result.ex is not None:
5404 
      raise result.ex
5481 phani.kuma 5405 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBilledOrders failed: unknown result");
4875 varun.gupt 5406 
 
5031 varun.gupt 5407 
  def getStatusDistributionOfOrders(self, startDate, endDate):
5408 
    """
5409 
    Parameters:
5410 
     - startDate
5411 
     - endDate
5412 
    """
5413 
    self.send_getStatusDistributionOfOrders(startDate, endDate)
5414 
    return self.recv_getStatusDistributionOfOrders()
4875 varun.gupt 5415 
 
5031 varun.gupt 5416 
  def send_getStatusDistributionOfOrders(self, startDate, endDate):
5417 
    self._oprot.writeMessageBegin('getStatusDistributionOfOrders', TMessageType.CALL, self._seqid)
5418 
    args = getStatusDistributionOfOrders_args()
5419 
    args.startDate = startDate
5420 
    args.endDate = endDate
5421 
    args.write(self._oprot)
5422 
    self._oprot.writeMessageEnd()
5423 
    self._oprot.trans.flush()
5424 
 
5425 
  def recv_getStatusDistributionOfOrders(self, ):
5426 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5427 
    if mtype == TMessageType.EXCEPTION:
5428 
      x = TApplicationException()
5429 
      x.read(self._iprot)
5430 
      self._iprot.readMessageEnd()
5431 
      raise x
5432 
    result = getStatusDistributionOfOrders_result()
5433 
    result.read(self._iprot)
5434 
    self._iprot.readMessageEnd()
5435 
    if result.success is not None:
5436 
      return result.success
5437 
    if result.ex is not None:
5438 
      raise result.ex
5439 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getStatusDistributionOfOrders failed: unknown result");
5440 
 
5067 varun.gupt 5441 
  def getOrderIdsForStatus(self, status, startDatetime, endDatetime):
5442 
    """
5443 
    Parameters:
5444 
     - status
5445 
     - startDatetime
5446 
     - endDatetime
5447 
    """
5448 
    self.send_getOrderIdsForStatus(status, startDatetime, endDatetime)
5449 
    return self.recv_getOrderIdsForStatus()
5031 varun.gupt 5450 
 
5067 varun.gupt 5451 
  def send_getOrderIdsForStatus(self, status, startDatetime, endDatetime):
5452 
    self._oprot.writeMessageBegin('getOrderIdsForStatus', TMessageType.CALL, self._seqid)
5453 
    args = getOrderIdsForStatus_args()
5454 
    args.status = status
5455 
    args.startDatetime = startDatetime
5456 
    args.endDatetime = endDatetime
5457 
    args.write(self._oprot)
5458 
    self._oprot.writeMessageEnd()
5459 
    self._oprot.trans.flush()
5460 
 
5461 
  def recv_getOrderIdsForStatus(self, ):
5462 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5463 
    if mtype == TMessageType.EXCEPTION:
5464 
      x = TApplicationException()
5465 
      x.read(self._iprot)
5466 
      self._iprot.readMessageEnd()
5467 
      raise x
5468 
    result = getOrderIdsForStatus_result()
5469 
    result.read(self._iprot)
5470 
    self._iprot.readMessageEnd()
5471 
    if result.success is not None:
5472 
      return result.success
5473 
    if result.ex is not None:
5474 
      raise result.ex
5475 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderIdsForStatus failed: unknown result");
5476 
 
5348 anupam.sin 5477 
  def updateCODAgent(self, agent, orderId):
5478 
    """
5479 
    Updates the agent who handled the COD verification call
5480 
 
5481 
    Parameters:
5482 
     - agent
5483 
     - orderId
5484 
    """
5485 
    self.send_updateCODAgent(agent, orderId)
5486 
    self.recv_updateCODAgent()
5487 
 
5488 
  def send_updateCODAgent(self, agent, orderId):
5489 
    self._oprot.writeMessageBegin('updateCODAgent', TMessageType.CALL, self._seqid)
5490 
    args = updateCODAgent_args()
5491 
    args.agent = agent
5492 
    args.orderId = orderId
5493 
    args.write(self._oprot)
5494 
    self._oprot.writeMessageEnd()
5495 
    self._oprot.trans.flush()
5496 
 
5497 
  def recv_updateCODAgent(self, ):
5498 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5499 
    if mtype == TMessageType.EXCEPTION:
5500 
      x = TApplicationException()
5501 
      x.read(self._iprot)
5502 
      self._iprot.readMessageEnd()
5503 
      raise x
5504 
    result = updateCODAgent_result()
5505 
    result.read(self._iprot)
5506 
    self._iprot.readMessageEnd()
5507 
    if result.ex is not None:
5508 
      raise result.ex
5509 
    return
5510 
 
5099 varun.gupt 5511 
  def updateOrderAsPaidToVendor(self, orderId):
5512 
    """
5513 
    Parameters:
5514 
     - orderId
5515 
    """
5516 
    self.send_updateOrderAsPaidToVendor(orderId)
5517 
    self.recv_updateOrderAsPaidToVendor()
5067 varun.gupt 5518 
 
5099 varun.gupt 5519 
  def send_updateOrderAsPaidToVendor(self, orderId):
5520 
    self._oprot.writeMessageBegin('updateOrderAsPaidToVendor', TMessageType.CALL, self._seqid)
5521 
    args = updateOrderAsPaidToVendor_args()
5522 
    args.orderId = orderId
5523 
    args.write(self._oprot)
5524 
    self._oprot.writeMessageEnd()
5525 
    self._oprot.trans.flush()
5526 
 
5527 
  def recv_updateOrderAsPaidToVendor(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 = updateOrderAsPaidToVendor_result()
5535 
    result.read(self._iprot)
5536 
    self._iprot.readMessageEnd()
5537 
    if result.ex is not None:
5538 
      raise result.ex
5539 
    return
5540 
 
5386 phani.kuma 5541 
  def updateOrderOnlyAsPaidToVendor(self, orderId):
5542 
    """
5543 
    Parameters:
5544 
     - orderId
5545 
    """
5546 
    self.send_updateOrderOnlyAsPaidToVendor(orderId)
5547 
    self.recv_updateOrderOnlyAsPaidToVendor()
5548 
 
5549 
  def send_updateOrderOnlyAsPaidToVendor(self, orderId):
5550 
    self._oprot.writeMessageBegin('updateOrderOnlyAsPaidToVendor', TMessageType.CALL, self._seqid)
5551 
    args = updateOrderOnlyAsPaidToVendor_args()
5552 
    args.orderId = orderId
5553 
    args.write(self._oprot)
5554 
    self._oprot.writeMessageEnd()
5555 
    self._oprot.trans.flush()
5556 
 
5557 
  def recv_updateOrderOnlyAsPaidToVendor(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 = updateOrderOnlyAsPaidToVendor_result()
5565 
    result.read(self._iprot)
5566 
    self._iprot.readMessageEnd()
5567 
    if result.ex is not None:
5568 
      raise result.ex
5569 
    return
5570 
 
5208 varun.gupt 5571 
  def getRefundedOrdersMarkedPaid(self, ):
5572 
    self.send_getRefundedOrdersMarkedPaid()
5573 
    return self.recv_getRefundedOrdersMarkedPaid()
5099 varun.gupt 5574 
 
5208 varun.gupt 5575 
  def send_getRefundedOrdersMarkedPaid(self, ):
5576 
    self._oprot.writeMessageBegin('getRefundedOrdersMarkedPaid', TMessageType.CALL, self._seqid)
5577 
    args = getRefundedOrdersMarkedPaid_args()
5578 
    args.write(self._oprot)
5579 
    self._oprot.writeMessageEnd()
5580 
    self._oprot.trans.flush()
5581 
 
5582 
  def recv_getRefundedOrdersMarkedPaid(self, ):
5583 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5584 
    if mtype == TMessageType.EXCEPTION:
5585 
      x = TApplicationException()
5586 
      x.read(self._iprot)
5587 
      self._iprot.readMessageEnd()
5588 
      raise x
5589 
    result = getRefundedOrdersMarkedPaid_result()
5590 
    result.read(self._iprot)
5591 
    self._iprot.readMessageEnd()
5592 
    if result.success is not None:
5593 
      return result.success
5594 
    if result.ex is not None:
5595 
      raise result.ex
5596 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getRefundedOrdersMarkedPaid failed: unknown result");
5597 
 
5447 anupam.sin 5598 
  def getAllVerificationAgents(self, minOrderId, maxOrderId):
5599 
    """
5600 
    gets all COD Verification Agents for all orderIds from a minId to maxId
5208 varun.gupt 5601 
 
5447 anupam.sin 5602 
 
5603 
    Parameters:
5604 
     - minOrderId
5605 
     - maxOrderId
5606 
    """
5607 
    self.send_getAllVerificationAgents(minOrderId, maxOrderId)
5608 
    return self.recv_getAllVerificationAgents()
5609 
 
5610 
  def send_getAllVerificationAgents(self, minOrderId, maxOrderId):
5611 
    self._oprot.writeMessageBegin('getAllVerificationAgents', TMessageType.CALL, self._seqid)
5612 
    args = getAllVerificationAgents_args()
5613 
    args.minOrderId = minOrderId
5614 
    args.maxOrderId = maxOrderId
5615 
    args.write(self._oprot)
5616 
    self._oprot.writeMessageEnd()
5617 
    self._oprot.trans.flush()
5618 
 
5619 
  def recv_getAllVerificationAgents(self, ):
5620 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5621 
    if mtype == TMessageType.EXCEPTION:
5622 
      x = TApplicationException()
5623 
      x.read(self._iprot)
5624 
      self._iprot.readMessageEnd()
5625 
      raise x
5626 
    result = getAllVerificationAgents_result()
5627 
    result.read(self._iprot)
5628 
    self._iprot.readMessageEnd()
5629 
    if result.success is not None:
5630 
      return result.success
5631 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllVerificationAgents failed: unknown result");
5632 
 
5527 anupam.sin 5633 
  def getAllAttributesForOrderId(self, orderId):
5634 
    """
5635 
    gets all attributes for a given orderId
5447 anupam.sin 5636 
 
5527 anupam.sin 5637 
    Parameters:
5638 
     - orderId
5639 
    """
5640 
    self.send_getAllAttributesForOrderId(orderId)
5641 
    return self.recv_getAllAttributesForOrderId()
5642 
 
5643 
  def send_getAllAttributesForOrderId(self, orderId):
5644 
    self._oprot.writeMessageBegin('getAllAttributesForOrderId', TMessageType.CALL, self._seqid)
5645 
    args = getAllAttributesForOrderId_args()
5646 
    args.orderId = orderId
5647 
    args.write(self._oprot)
5648 
    self._oprot.writeMessageEnd()
5649 
    self._oprot.trans.flush()
5650 
 
5651 
  def recv_getAllAttributesForOrderId(self, ):
5652 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5653 
    if mtype == TMessageType.EXCEPTION:
5654 
      x = TApplicationException()
5655 
      x.read(self._iprot)
5656 
      self._iprot.readMessageEnd()
5657 
      raise x
5658 
    result = getAllAttributesForOrderId_result()
5659 
    result.read(self._iprot)
5660 
    self._iprot.readMessageEnd()
5661 
    if result.success is not None:
5662 
      return result.success
5663 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllAttributesForOrderId failed: unknown result");
5664 
 
5676 rajveer 5665 
  def setOrderAttributes(self, orderId, attributes):
5666 
    """
5667 
    sets attributes for an order
5668 
 
5669 
    Parameters:
5670 
     - orderId
5671 
     - attributes
5672 
    """
5673 
    self.send_setOrderAttributes(orderId, attributes)
5674 
    self.recv_setOrderAttributes()
5675 
 
5676 
  def send_setOrderAttributes(self, orderId, attributes):
5677 
    self._oprot.writeMessageBegin('setOrderAttributes', TMessageType.CALL, self._seqid)
5678 
    args = setOrderAttributes_args()
5679 
    args.orderId = orderId
5680 
    args.attributes = attributes
5681 
    args.write(self._oprot)
5682 
    self._oprot.writeMessageEnd()
5683 
    self._oprot.trans.flush()
5684 
 
5685 
  def recv_setOrderAttributes(self, ):
5686 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5687 
    if mtype == TMessageType.EXCEPTION:
5688 
      x = TApplicationException()
5689 
      x.read(self._iprot)
5690 
      self._iprot.readMessageEnd()
5691 
      raise x
5692 
    result = setOrderAttributes_result()
5693 
    result.read(self._iprot)
5694 
    self._iprot.readMessageEnd()
5695 
    return
5696 
 
5527 anupam.sin 5697 
  def setOrderAttributeForTransaction(self, transactionId, attribute):
5698 
    """
5699 
    sets attributes for all orders in a transaction
5700 
 
5701 
    Parameters:
5702 
     - transactionId
5703 
     - attribute
5704 
    """
5705 
    self.send_setOrderAttributeForTransaction(transactionId, attribute)
5706 
    self.recv_setOrderAttributeForTransaction()
5707 
 
5708 
  def send_setOrderAttributeForTransaction(self, transactionId, attribute):
5709 
    self._oprot.writeMessageBegin('setOrderAttributeForTransaction', TMessageType.CALL, self._seqid)
5710 
    args = setOrderAttributeForTransaction_args()
5711 
    args.transactionId = transactionId
5712 
    args.attribute = attribute
5713 
    args.write(self._oprot)
5714 
    self._oprot.writeMessageEnd()
5715 
    self._oprot.trans.flush()
5716 
 
5717 
  def recv_setOrderAttributeForTransaction(self, ):
5718 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5719 
    if mtype == TMessageType.EXCEPTION:
5720 
      x = TApplicationException()
5721 
      x.read(self._iprot)
5722 
      self._iprot.readMessageEnd()
5723 
      raise x
5724 
    result = setOrderAttributeForTransaction_result()
5725 
    result.read(self._iprot)
5726 
    self._iprot.readMessageEnd()
5727 
    return
5728 
 
5553 rajveer 5729 
  def getReceivePendingOrders(self, storeId):
5730 
    """
5731 
    Parameters:
5732 
     - storeId
5733 
    """
5734 
    self.send_getReceivePendingOrders(storeId)
5735 
    return self.recv_getReceivePendingOrders()
5527 anupam.sin 5736 
 
5553 rajveer 5737 
  def send_getReceivePendingOrders(self, storeId):
5738 
    self._oprot.writeMessageBegin('getReceivePendingOrders', TMessageType.CALL, self._seqid)
5739 
    args = getReceivePendingOrders_args()
5740 
    args.storeId = storeId
5741 
    args.write(self._oprot)
5742 
    self._oprot.writeMessageEnd()
5743 
    self._oprot.trans.flush()
5744 
 
5745 
  def recv_getReceivePendingOrders(self, ):
5746 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5747 
    if mtype == TMessageType.EXCEPTION:
5748 
      x = TApplicationException()
5749 
      x.read(self._iprot)
5750 
      self._iprot.readMessageEnd()
5751 
      raise x
5752 
    result = getReceivePendingOrders_result()
5753 
    result.read(self._iprot)
5754 
    self._iprot.readMessageEnd()
5755 
    if result.success is not None:
5756 
      return result.success
5757 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReceivePendingOrders failed: unknown result");
5758 
 
5759 
  def getReceivedAtStoreOrders(self, storeId):
5760 
    """
5761 
    Parameters:
5762 
     - storeId
5763 
    """
5764 
    self.send_getReceivedAtStoreOrders(storeId)
5765 
    return self.recv_getReceivedAtStoreOrders()
5766 
 
5767 
  def send_getReceivedAtStoreOrders(self, storeId):
5768 
    self._oprot.writeMessageBegin('getReceivedAtStoreOrders', TMessageType.CALL, self._seqid)
5769 
    args = getReceivedAtStoreOrders_args()
5770 
    args.storeId = storeId
5771 
    args.write(self._oprot)
5772 
    self._oprot.writeMessageEnd()
5773 
    self._oprot.trans.flush()
5774 
 
5775 
  def recv_getReceivedAtStoreOrders(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 = getReceivedAtStoreOrders_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, "getReceivedAtStoreOrders failed: unknown result");
5788 
 
5713 rajveer 5789 
  def getOrdersCollectionAtStore(self, storeId, fromDate, toDate, onlyCod):
5790 
    """
5791 
    Parameters:
5792 
     - storeId
5793 
     - fromDate
5794 
     - toDate
5795 
     - onlyCod
5796 
    """
5797 
    self.send_getOrdersCollectionAtStore(storeId, fromDate, toDate, onlyCod)
5798 
    return self.recv_getOrdersCollectionAtStore()
5799 
 
5800 
  def send_getOrdersCollectionAtStore(self, storeId, fromDate, toDate, onlyCod):
5801 
    self._oprot.writeMessageBegin('getOrdersCollectionAtStore', TMessageType.CALL, self._seqid)
5802 
    args = getOrdersCollectionAtStore_args()
5803 
    args.storeId = storeId
5804 
    args.fromDate = fromDate
5805 
    args.toDate = toDate
5806 
    args.onlyCod = onlyCod
5807 
    args.write(self._oprot)
5808 
    self._oprot.writeMessageEnd()
5809 
    self._oprot.trans.flush()
5810 
 
5811 
  def recv_getOrdersCollectionAtStore(self, ):
5812 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5813 
    if mtype == TMessageType.EXCEPTION:
5814 
      x = TApplicationException()
5815 
      x.read(self._iprot)
5816 
      self._iprot.readMessageEnd()
5817 
      raise x
5818 
    result = getOrdersCollectionAtStore_result()
5819 
    result.read(self._iprot)
5820 
    self._iprot.readMessageEnd()
5821 
    if result.success is not None:
5822 
      return result.success
5823 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersCollectionAtStore failed: unknown result");
5824 
 
5833 rajveer 5825 
  def getOrderAttributeValue(self, orderId, attributeName):
5826 
    """
5827 
    Parameters:
5828 
     - orderId
5829 
     - attributeName
5830 
    """
5831 
    self.send_getOrderAttributeValue(orderId, attributeName)
5832 
    return self.recv_getOrderAttributeValue()
5833 
 
5834 
  def send_getOrderAttributeValue(self, orderId, attributeName):
5835 
    self._oprot.writeMessageBegin('getOrderAttributeValue', TMessageType.CALL, self._seqid)
5836 
    args = getOrderAttributeValue_args()
5837 
    args.orderId = orderId
5838 
    args.attributeName = attributeName
5839 
    args.write(self._oprot)
5840 
    self._oprot.writeMessageEnd()
5841 
    self._oprot.trans.flush()
5842 
 
5843 
  def recv_getOrderAttributeValue(self, ):
5844 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5845 
    if mtype == TMessageType.EXCEPTION:
5846 
      x = TApplicationException()
5847 
      x.read(self._iprot)
5848 
      self._iprot.readMessageEnd()
5849 
      raise x
5850 
    result = getOrderAttributeValue_result()
5851 
    result.read(self._iprot)
5852 
    self._iprot.readMessageEnd()
5853 
    if result.success is not None:
5854 
      return result.success
5855 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderAttributeValue failed: unknown result");
5856 
 
6019 rajveer 5857 
  def changeJacketNumber(self, orderId, jacketNumber):
5858 
    """
5859 
    Parameters:
5860 
     - orderId
5861 
     - jacketNumber
5862 
    """
5863 
    self.send_changeJacketNumber(orderId, jacketNumber)
5864 
    return self.recv_changeJacketNumber()
5865 
 
5866 
  def send_changeJacketNumber(self, orderId, jacketNumber):
5867 
    self._oprot.writeMessageBegin('changeJacketNumber', TMessageType.CALL, self._seqid)
5868 
    args = changeJacketNumber_args()
5869 
    args.orderId = orderId
5870 
    args.jacketNumber = jacketNumber
5871 
    args.write(self._oprot)
5872 
    self._oprot.writeMessageEnd()
5873 
    self._oprot.trans.flush()
5874 
 
5875 
  def recv_changeJacketNumber(self, ):
5876 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5877 
    if mtype == TMessageType.EXCEPTION:
5878 
      x = TApplicationException()
5879 
      x.read(self._iprot)
5880 
      self._iprot.readMessageEnd()
5881 
      raise x
5882 
    result = changeJacketNumber_result()
5883 
    result.read(self._iprot)
5884 
    self._iprot.readMessageEnd()
5885 
    if result.success is not None:
5886 
      return result.success
5887 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "changeJacketNumber failed: unknown result");
5888 
 
5889 
  def markOrderAsRtoInTransit(self, orderId):
5890 
    """
5891 
    Parameters:
5892 
     - orderId
5893 
    """
5894 
    self.send_markOrderAsRtoInTransit(orderId)
5895 
    return self.recv_markOrderAsRtoInTransit()
5896 
 
5897 
  def send_markOrderAsRtoInTransit(self, orderId):
5898 
    self._oprot.writeMessageBegin('markOrderAsRtoInTransit', TMessageType.CALL, self._seqid)
5899 
    args = markOrderAsRtoInTransit_args()
5900 
    args.orderId = orderId
5901 
    args.write(self._oprot)
5902 
    self._oprot.writeMessageEnd()
5903 
    self._oprot.trans.flush()
5904 
 
5905 
  def recv_markOrderAsRtoInTransit(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 = markOrderAsRtoInTransit_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, "markOrderAsRtoInTransit failed: unknown result");
5918 
 
5593 mandeep.dh 5919 
  def acceptOrderForItem(self, itemId, quantity, fulfilmentWarehouseId, billingWarehouseId):
5920 
    """
5921 
    Accepts appropriate order for an item in a given billingWarehouse. Usually
5922 
    invoked while scanning IN of items.
5553 rajveer 5923 
 
5593 mandeep.dh 5924 
    Parameters:
5925 
     - itemId
5926 
     - quantity
5927 
     - fulfilmentWarehouseId
5928 
     - billingWarehouseId
5929 
    """
5930 
    self.send_acceptOrderForItem(itemId, quantity, fulfilmentWarehouseId, billingWarehouseId)
5931 
    self.recv_acceptOrderForItem()
5932 
 
5933 
  def send_acceptOrderForItem(self, itemId, quantity, fulfilmentWarehouseId, billingWarehouseId):
5934 
    self._oprot.writeMessageBegin('acceptOrderForItem', TMessageType.CALL, self._seqid)
5935 
    args = acceptOrderForItem_args()
5936 
    args.itemId = itemId
5937 
    args.quantity = quantity
5938 
    args.fulfilmentWarehouseId = fulfilmentWarehouseId
5939 
    args.billingWarehouseId = billingWarehouseId
5940 
    args.write(self._oprot)
5941 
    self._oprot.writeMessageEnd()
5942 
    self._oprot.trans.flush()
5943 
 
5944 
  def recv_acceptOrderForItem(self, ):
5945 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5946 
    if mtype == TMessageType.EXCEPTION:
5947 
      x = TApplicationException()
5948 
      x.read(self._iprot)
5949 
      self._iprot.readMessageEnd()
5950 
      raise x
5951 
    result = acceptOrderForItem_result()
5952 
    result.read(self._iprot)
5953 
    self._iprot.readMessageEnd()
5954 
    return
5955 
 
6000 mandeep.dh 5956 
  def createRechargeOrder(self, rechargeOrder):
5957 
    """
5958 
    Parameters:
5959 
     - rechargeOrder
5960 
    """
5961 
    self.send_createRechargeOrder(rechargeOrder)
5962 
    return self.recv_createRechargeOrder()
5593 mandeep.dh 5963 
 
6000 mandeep.dh 5964 
  def send_createRechargeOrder(self, rechargeOrder):
5965 
    self._oprot.writeMessageBegin('createRechargeOrder', TMessageType.CALL, self._seqid)
5966 
    args = createRechargeOrder_args()
5967 
    args.rechargeOrder = rechargeOrder
5968 
    args.write(self._oprot)
5969 
    self._oprot.writeMessageEnd()
5970 
    self._oprot.trans.flush()
5971 
 
5972 
  def recv_createRechargeOrder(self, ):
5973 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5974 
    if mtype == TMessageType.EXCEPTION:
5975 
      x = TApplicationException()
5976 
      x.read(self._iprot)
5977 
      self._iprot.readMessageEnd()
5978 
      raise x
5979 
    result = createRechargeOrder_result()
5980 
    result.read(self._iprot)
5981 
    self._iprot.readMessageEnd()
5982 
    if result.success is not None:
5983 
      return result.success
5984 
    if result.ex is not None:
5985 
      raise result.ex
5986 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createRechargeOrder failed: unknown result");
5987 
 
6031 rajveer 5988 
  def getRechargeOrder(self, rechargeRrderId):
5989 
    """
5990 
    Parameters:
5991 
     - rechargeRrderId
5992 
    """
5993 
    self.send_getRechargeOrder(rechargeRrderId)
5994 
    return self.recv_getRechargeOrder()
5995 
 
5996 
  def send_getRechargeOrder(self, rechargeRrderId):
5997 
    self._oprot.writeMessageBegin('getRechargeOrder', TMessageType.CALL, self._seqid)
5998 
    args = getRechargeOrder_args()
5999 
    args.rechargeRrderId = rechargeRrderId
6000 
    args.write(self._oprot)
6001 
    self._oprot.writeMessageEnd()
6002 
    self._oprot.trans.flush()
6003 
 
6004 
  def recv_getRechargeOrder(self, ):
6005 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6006 
    if mtype == TMessageType.EXCEPTION:
6007 
      x = TApplicationException()
6008 
      x.read(self._iprot)
6009 
      self._iprot.readMessageEnd()
6010 
      raise x
6011 
    result = getRechargeOrder_result()
6012 
    result.read(self._iprot)
6013 
    self._iprot.readMessageEnd()
6014 
    if result.success is not None:
6015 
      return result.success
6016 
    if result.ex is not None:
6017 
      raise result.ex
6018 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getRechargeOrder failed: unknown result");
6019 
 
6020 
  def getRechargeOrders(self, userId):
6021 
    """
6022 
    Parameters:
6023 
     - userId
6024 
    """
6025 
    self.send_getRechargeOrders(userId)
6026 
    return self.recv_getRechargeOrders()
6027 
 
6028 
  def send_getRechargeOrders(self, userId):
6029 
    self._oprot.writeMessageBegin('getRechargeOrders', TMessageType.CALL, self._seqid)
6030 
    args = getRechargeOrders_args()
6031 
    args.userId = userId
6032 
    args.write(self._oprot)
6033 
    self._oprot.writeMessageEnd()
6034 
    self._oprot.trans.flush()
6035 
 
6036 
  def recv_getRechargeOrders(self, ):
6037 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6038 
    if mtype == TMessageType.EXCEPTION:
6039 
      x = TApplicationException()
6040 
      x.read(self._iprot)
6041 
      self._iprot.readMessageEnd()
6042 
      raise x
6043 
    result = getRechargeOrders_result()
6044 
    result.read(self._iprot)
6045 
    self._iprot.readMessageEnd()
6046 
    if result.success is not None:
6047 
      return result.success
6048 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getRechargeOrders failed: unknown result");
6049 
 
6000 mandeep.dh 6050 
  def updateRechargeOrderStatus(self, rechargeOrderId, rechargeOrderStatus):
6051 
    """
6052 
    Parameters:
6053 
     - rechargeOrderId
6054 
     - rechargeOrderStatus
6055 
    """
6056 
    self.send_updateRechargeOrderStatus(rechargeOrderId, rechargeOrderStatus)
6031 rajveer 6057 
    return self.recv_updateRechargeOrderStatus()
6000 mandeep.dh 6058 
 
6059 
  def send_updateRechargeOrderStatus(self, rechargeOrderId, rechargeOrderStatus):
6060 
    self._oprot.writeMessageBegin('updateRechargeOrderStatus', TMessageType.CALL, self._seqid)
6061 
    args = updateRechargeOrderStatus_args()
6062 
    args.rechargeOrderId = rechargeOrderId
6063 
    args.rechargeOrderStatus = rechargeOrderStatus
6064 
    args.write(self._oprot)
6065 
    self._oprot.writeMessageEnd()
6066 
    self._oprot.trans.flush()
6067 
 
6068 
  def recv_updateRechargeOrderStatus(self, ):
6069 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6070 
    if mtype == TMessageType.EXCEPTION:
6071 
      x = TApplicationException()
6072 
      x.read(self._iprot)
6073 
      self._iprot.readMessageEnd()
6074 
      raise x
6075 
    result = updateRechargeOrderStatus_result()
6076 
    result.read(self._iprot)
6077 
    self._iprot.readMessageEnd()
6031 rajveer 6078 
    if result.success is not None:
6079 
      return result.success
6000 mandeep.dh 6080 
    if result.ex is not None:
6081 
      raise result.ex
6031 rajveer 6082 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updateRechargeOrderStatus failed: unknown result");
6000 mandeep.dh 6083 
 
6031 rajveer 6084 
  def activateRechargeTxn(self, rechargeOrderId):
6000 mandeep.dh 6085 
    """
6086 
    Parameters:
6031 rajveer 6087 
     - rechargeOrderId
6000 mandeep.dh 6088 
    """
6031 rajveer 6089 
    self.send_activateRechargeTxn(rechargeOrderId)
6000 mandeep.dh 6090 
    return self.recv_activateRechargeTxn()
6091 
 
6031 rajveer 6092 
  def send_activateRechargeTxn(self, rechargeOrderId):
6000 mandeep.dh 6093 
    self._oprot.writeMessageBegin('activateRechargeTxn', TMessageType.CALL, self._seqid)
6094 
    args = activateRechargeTxn_args()
6031 rajveer 6095 
    args.rechargeOrderId = rechargeOrderId
6000 mandeep.dh 6096 
    args.write(self._oprot)
6097 
    self._oprot.writeMessageEnd()
6098 
    self._oprot.trans.flush()
6099 
 
6100 
  def recv_activateRechargeTxn(self, ):
6101 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6102 
    if mtype == TMessageType.EXCEPTION:
6103 
      x = TApplicationException()
6104 
      x.read(self._iprot)
6105 
      self._iprot.readMessageEnd()
6106 
      raise x
6107 
    result = activateRechargeTxn_result()
6108 
    result.read(self._iprot)
6109 
    self._iprot.readMessageEnd()
6110 
    if result.success is not None:
6111 
      return result.success
6112 
    if result.ex is not None:
6113 
      raise result.ex
6114 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "activateRechargeTxn failed: unknown result");
6115 
 
6031 rajveer 6116 
  def getUserWallet(self, userId):
6000 mandeep.dh 6117 
    """
6118 
    Parameters:
6031 rajveer 6119 
     - userId
6000 mandeep.dh 6120 
    """
6031 rajveer 6121 
    self.send_getUserWallet(userId)
6122 
    return self.recv_getUserWallet()
6000 mandeep.dh 6123 
 
6031 rajveer 6124 
  def send_getUserWallet(self, userId):
6125 
    self._oprot.writeMessageBegin('getUserWallet', TMessageType.CALL, self._seqid)
6126 
    args = getUserWallet_args()
6127 
    args.userId = userId
6000 mandeep.dh 6128 
    args.write(self._oprot)
6129 
    self._oprot.writeMessageEnd()
6130 
    self._oprot.trans.flush()
6131 
 
6031 rajveer 6132 
  def recv_getUserWallet(self, ):
6000 mandeep.dh 6133 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6134 
    if mtype == TMessageType.EXCEPTION:
6135 
      x = TApplicationException()
6136 
      x.read(self._iprot)
6137 
      self._iprot.readMessageEnd()
6138 
      raise x
6031 rajveer 6139 
    result = getUserWallet_result()
6000 mandeep.dh 6140 
    result.read(self._iprot)
6141 
    self._iprot.readMessageEnd()
6142 
    if result.success is not None:
6143 
      return result.success
6031 rajveer 6144 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUserWallet failed: unknown result");
6000 mandeep.dh 6145 
 
6031 rajveer 6146 
  def getUserWalletHistory(self, userId):
6000 mandeep.dh 6147 
    """
6148 
    Parameters:
6031 rajveer 6149 
     - userId
6000 mandeep.dh 6150 
    """
6031 rajveer 6151 
    self.send_getUserWalletHistory(userId)
6152 
    return self.recv_getUserWalletHistory()
6000 mandeep.dh 6153 
 
6031 rajveer 6154 
  def send_getUserWalletHistory(self, userId):
6155 
    self._oprot.writeMessageBegin('getUserWalletHistory', TMessageType.CALL, self._seqid)
6156 
    args = getUserWalletHistory_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_getUserWalletHistory(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 = getUserWalletHistory_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, "getUserWalletHistory failed: unknown result");
6000 mandeep.dh 6175 
 
6050 anupam.sin 6176 
  def getRechargeOrdersForTransaction(self, txnId):
6177 
    """
6178 
    Returns a recharge order for a given transactionId
6179 
 
6180 
    Parameters:
6181 
     - txnId
6182 
    """
6183 
    self.send_getRechargeOrdersForTransaction(txnId)
6184 
    return self.recv_getRechargeOrdersForTransaction()
6185 
 
6186 
  def send_getRechargeOrdersForTransaction(self, txnId):
6187 
    self._oprot.writeMessageBegin('getRechargeOrdersForTransaction', TMessageType.CALL, self._seqid)
6188 
    args = getRechargeOrdersForTransaction_args()
6189 
    args.txnId = txnId
6190 
    args.write(self._oprot)
6191 
    self._oprot.writeMessageEnd()
6192 
    self._oprot.trans.flush()
6193 
 
6194 
  def recv_getRechargeOrdersForTransaction(self, ):
6195 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6196 
    if mtype == TMessageType.EXCEPTION:
6197 
      x = TApplicationException()
6198 
      x.read(self._iprot)
6199 
      self._iprot.readMessageEnd()
6200 
      raise x
6201 
    result = getRechargeOrdersForTransaction_result()
6202 
    result.read(self._iprot)
6203 
    self._iprot.readMessageEnd()
6204 
    if result.success is not None:
6205 
      return result.success
6206 
    if result.ex is not None:
6207 
      raise result.ex
6208 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getRechargeOrdersForTransaction failed: unknown result");
6209 
 
6206 rajveer 6210 
  def getServiceProviders(self, rechargeType, onlyActive):
6048 rajveer 6211 
    """
6212 
    Parameters:
6213 
     - rechargeType
6206 rajveer 6214 
     - onlyActive
6048 rajveer 6215 
    """
6206 rajveer 6216 
    self.send_getServiceProviders(rechargeType, onlyActive)
6048 rajveer 6217 
    return self.recv_getServiceProviders()
6000 mandeep.dh 6218 
 
6206 rajveer 6219 
  def send_getServiceProviders(self, rechargeType, onlyActive):
6048 rajveer 6220 
    self._oprot.writeMessageBegin('getServiceProviders', TMessageType.CALL, self._seqid)
6221 
    args = getServiceProviders_args()
6222 
    args.rechargeType = rechargeType
6206 rajveer 6223 
    args.onlyActive = onlyActive
6048 rajveer 6224 
    args.write(self._oprot)
6225 
    self._oprot.writeMessageEnd()
6226 
    self._oprot.trans.flush()
6227 
 
6228 
  def recv_getServiceProviders(self, ):
6229 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6230 
    if mtype == TMessageType.EXCEPTION:
6231 
      x = TApplicationException()
6232 
      x.read(self._iprot)
6233 
      self._iprot.readMessageEnd()
6234 
      raise x
6235 
    result = getServiceProviders_result()
6236 
    result.read(self._iprot)
6237 
    self._iprot.readMessageEnd()
6238 
    if result.success is not None:
6239 
      return result.success
6240 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getServiceProviders failed: unknown result");
6241 
 
6049 rajveer 6242 
  def getServiceProviderForDevice(self, rechargeType, deviceNumber):
6048 rajveer 6243 
    """
6244 
    Parameters:
6049 rajveer 6245 
     - rechargeType
6048 rajveer 6246 
     - deviceNumber
6247 
    """
6049 rajveer 6248 
    self.send_getServiceProviderForDevice(rechargeType, deviceNumber)
6048 rajveer 6249 
    return self.recv_getServiceProviderForDevice()
6250 
 
6049 rajveer 6251 
  def send_getServiceProviderForDevice(self, rechargeType, deviceNumber):
6048 rajveer 6252 
    self._oprot.writeMessageBegin('getServiceProviderForDevice', TMessageType.CALL, self._seqid)
6253 
    args = getServiceProviderForDevice_args()
6049 rajveer 6254 
    args.rechargeType = rechargeType
6048 rajveer 6255 
    args.deviceNumber = deviceNumber
6256 
    args.write(self._oprot)
6257 
    self._oprot.writeMessageEnd()
6258 
    self._oprot.trans.flush()
6259 
 
6260 
  def recv_getServiceProviderForDevice(self, ):
6261 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6262 
    if mtype == TMessageType.EXCEPTION:
6263 
      x = TApplicationException()
6264 
      x.read(self._iprot)
6265 
      self._iprot.readMessageEnd()
6266 
      raise x
6267 
    result = getServiceProviderForDevice_result()
6268 
    result.read(self._iprot)
6269 
    self._iprot.readMessageEnd()
6270 
    if result.success is not None:
6271 
      return result.success
6272 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getServiceProviderForDevice failed: unknown result");
6273 
 
6591 anupam.sin 6274 
  def validateRecharge(self, rechargeType, deviceNumber, userSelectedProviderId, clientAddress):
6269 rajveer 6275 
    """
6276 
    Parameters:
6277 
     - rechargeType
6278 
     - deviceNumber
6307 anupam.sin 6279 
     - userSelectedProviderId
6591 anupam.sin 6280 
     - clientAddress
6269 rajveer 6281 
    """
6591 anupam.sin 6282 
    self.send_validateRecharge(rechargeType, deviceNumber, userSelectedProviderId, clientAddress)
6269 rajveer 6283 
    return self.recv_validateRecharge()
6284 
 
6591 anupam.sin 6285 
  def send_validateRecharge(self, rechargeType, deviceNumber, userSelectedProviderId, clientAddress):
6269 rajveer 6286 
    self._oprot.writeMessageBegin('validateRecharge', TMessageType.CALL, self._seqid)
6287 
    args = validateRecharge_args()
6288 
    args.rechargeType = rechargeType
6289 
    args.deviceNumber = deviceNumber
6307 anupam.sin 6290 
    args.userSelectedProviderId = userSelectedProviderId
6591 anupam.sin 6291 
    args.clientAddress = clientAddress
6269 rajveer 6292 
    args.write(self._oprot)
6293 
    self._oprot.writeMessageEnd()
6294 
    self._oprot.trans.flush()
6295 
 
6296 
  def recv_validateRecharge(self, ):
6297 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6298 
    if mtype == TMessageType.EXCEPTION:
6299 
      x = TApplicationException()
6300 
      x.read(self._iprot)
6301 
      self._iprot.readMessageEnd()
6302 
      raise x
6303 
    result = validateRecharge_result()
6304 
    result.read(self._iprot)
6305 
    self._iprot.readMessageEnd()
6306 
    if result.success is not None:
6307 
      return result.success
6308 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "validateRecharge failed: unknown result");
6309 
 
6094 rajveer 6310 
  def getRechargeOrdersForDevice(self, deviceNumber):
6311 
    """
6312 
    Parameters:
6313 
     - deviceNumber
6314 
    """
6315 
    self.send_getRechargeOrdersForDevice(deviceNumber)
6316 
    return self.recv_getRechargeOrdersForDevice()
6048 rajveer 6317 
 
6094 rajveer 6318 
  def send_getRechargeOrdersForDevice(self, deviceNumber):
6319 
    self._oprot.writeMessageBegin('getRechargeOrdersForDevice', TMessageType.CALL, self._seqid)
6320 
    args = getRechargeOrdersForDevice_args()
6321 
    args.deviceNumber = deviceNumber
6322 
    args.write(self._oprot)
6323 
    self._oprot.writeMessageEnd()
6324 
    self._oprot.trans.flush()
6325 
 
6326 
  def recv_getRechargeOrdersForDevice(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 = getRechargeOrdersForDevice_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, "getRechargeOrdersForDevice failed: unknown result");
6339 
 
6340 
  def addAmountToWallet(self, userId, orderId, amount):
6341 
    """
6342 
    Parameters:
6343 
     - userId
6344 
     - orderId
6345 
     - amount
6346 
    """
6347 
    self.send_addAmountToWallet(userId, orderId, amount)
6348 
    self.recv_addAmountToWallet()
6349 
 
6350 
  def send_addAmountToWallet(self, userId, orderId, amount):
6351 
    self._oprot.writeMessageBegin('addAmountToWallet', TMessageType.CALL, self._seqid)
6352 
    args = addAmountToWallet_args()
6353 
    args.userId = userId
6354 
    args.orderId = orderId
6355 
    args.amount = amount
6356 
    args.write(self._oprot)
6357 
    self._oprot.writeMessageEnd()
6358 
    self._oprot.trans.flush()
6359 
 
6360 
  def recv_addAmountToWallet(self, ):
6361 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6362 
    if mtype == TMessageType.EXCEPTION:
6363 
      x = TApplicationException()
6364 
      x.read(self._iprot)
6365 
      self._iprot.readMessageEnd()
6366 
      raise x
6367 
    result = addAmountToWallet_result()
6368 
    result.read(self._iprot)
6369 
    self._iprot.readMessageEnd()
6370 
    return
6371 
 
6188 rajveer 6372 
  def getRechargeStatistics(self, ):
6373 
    self.send_getRechargeStatistics()
6374 
    return self.recv_getRechargeStatistics()
6375 
 
6376 
  def send_getRechargeStatistics(self, ):
6377 
    self._oprot.writeMessageBegin('getRechargeStatistics', TMessageType.CALL, self._seqid)
6378 
    args = getRechargeStatistics_args()
6379 
    args.write(self._oprot)
6380 
    self._oprot.writeMessageEnd()
6381 
    self._oprot.trans.flush()
6382 
 
6383 
  def recv_getRechargeStatistics(self, ):
6384 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6385 
    if mtype == TMessageType.EXCEPTION:
6386 
      x = TApplicationException()
6387 
      x.read(self._iprot)
6388 
      self._iprot.readMessageEnd()
6389 
      raise x
6390 
    result = getRechargeStatistics_result()
6391 
    result.read(self._iprot)
6392 
    self._iprot.readMessageEnd()
6393 
    if result.success is not None:
6394 
      return result.success
6395 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getRechargeStatistics failed: unknown result");
6396 
 
6154 rajveer 6397 
  def getRechargeOrdersForStatus(self, status):
6398 
    """
6399 
    Parameters:
6400 
     - status
6401 
    """
6402 
    self.send_getRechargeOrdersForStatus(status)
6403 
    return self.recv_getRechargeOrdersForStatus()
6094 rajveer 6404 
 
6154 rajveer 6405 
  def send_getRechargeOrdersForStatus(self, status):
6406 
    self._oprot.writeMessageBegin('getRechargeOrdersForStatus', TMessageType.CALL, self._seqid)
6407 
    args = getRechargeOrdersForStatus_args()
6408 
    args.status = status
6409 
    args.write(self._oprot)
6410 
    self._oprot.writeMessageEnd()
6411 
    self._oprot.trans.flush()
6412 
 
6413 
  def recv_getRechargeOrdersForStatus(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 = getRechargeOrdersForStatus_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, "getRechargeOrdersForStatus failed: unknown result");
6426 
 
6159 rajveer 6427 
  def getPlansForOperator(self, operatorId):
6428 
    """
6429 
    Parameters:
6430 
     - operatorId
6431 
    """
6432 
    self.send_getPlansForOperator(operatorId)
6433 
    return self.recv_getPlansForOperator()
6154 rajveer 6434 
 
6159 rajveer 6435 
  def send_getPlansForOperator(self, operatorId):
6436 
    self._oprot.writeMessageBegin('getPlansForOperator', TMessageType.CALL, self._seqid)
6437 
    args = getPlansForOperator_args()
6438 
    args.operatorId = operatorId
6439 
    args.write(self._oprot)
6440 
    self._oprot.writeMessageEnd()
6441 
    self._oprot.trans.flush()
6442 
 
6443 
  def recv_getPlansForOperator(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 = getPlansForOperator_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, "getPlansForOperator failed: unknown result");
6456 
 
6307 anupam.sin 6457 
  def getRechargeDenominations(self, operatorId, circleCode, denominationType):
6289 anupam.sin 6458 
    """
6459 
    Returns denominations for a given operator and circle
6159 rajveer 6460 
 
6289 anupam.sin 6461 
    Parameters:
6462 
     - operatorId
6307 anupam.sin 6463 
     - circleCode
6289 anupam.sin 6464 
     - denominationType
6465 
    """
6307 anupam.sin 6466 
    self.send_getRechargeDenominations(operatorId, circleCode, denominationType)
6289 anupam.sin 6467 
    return self.recv_getRechargeDenominations()
6468 
 
6307 anupam.sin 6469 
  def send_getRechargeDenominations(self, operatorId, circleCode, denominationType):
6289 anupam.sin 6470 
    self._oprot.writeMessageBegin('getRechargeDenominations', TMessageType.CALL, self._seqid)
6471 
    args = getRechargeDenominations_args()
6472 
    args.operatorId = operatorId
6307 anupam.sin 6473 
    args.circleCode = circleCode
6289 anupam.sin 6474 
    args.denominationType = denominationType
6475 
    args.write(self._oprot)
6476 
    self._oprot.writeMessageEnd()
6477 
    self._oprot.trans.flush()
6478 
 
6479 
  def recv_getRechargeDenominations(self, ):
6480 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6481 
    if mtype == TMessageType.EXCEPTION:
6482 
      x = TApplicationException()
6483 
      x.read(self._iprot)
6484 
      self._iprot.readMessageEnd()
6485 
      raise x
6486 
    result = getRechargeDenominations_result()
6487 
    result.read(self._iprot)
6488 
    self._iprot.readMessageEnd()
6489 
    if result.success is not None:
6490 
      return result.success
6491 
    if result.ex is not None:
6492 
      raise result.ex
6493 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getRechargeDenominations failed: unknown result");
6494 
 
6371 rajveer 6495 
  def updateAvailabilityStatus(self, operatorId, circleId, isAvailable):
6496 
    """
6497 
    Parameters:
6498 
     - operatorId
6499 
     - circleId
6500 
     - isAvailable
6501 
    """
6502 
    self.send_updateAvailabilityStatus(operatorId, circleId, isAvailable)
6503 
    self.recv_updateAvailabilityStatus()
6289 anupam.sin 6504 
 
6371 rajveer 6505 
  def send_updateAvailabilityStatus(self, operatorId, circleId, isAvailable):
6506 
    self._oprot.writeMessageBegin('updateAvailabilityStatus', TMessageType.CALL, self._seqid)
6507 
    args = updateAvailabilityStatus_args()
6508 
    args.operatorId = operatorId
6509 
    args.circleId = circleId
6510 
    args.isAvailable = isAvailable
6511 
    args.write(self._oprot)
6512 
    self._oprot.writeMessageEnd()
6513 
    self._oprot.trans.flush()
6514 
 
6515 
  def recv_updateAvailabilityStatus(self, ):
6516 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6517 
    if mtype == TMessageType.EXCEPTION:
6518 
      x = TApplicationException()
6519 
      x.read(self._iprot)
6520 
      self._iprot.readMessageEnd()
6521 
      raise x
6522 
    result = updateAvailabilityStatus_result()
6523 
    result.read(self._iprot)
6524 
    self._iprot.readMessageEnd()
6525 
    return
6526 
 
6389 rajveer 6527 
  def getAvailableEmiSchemes(self, ):
6528 
    self.send_getAvailableEmiSchemes()
6529 
    return self.recv_getAvailableEmiSchemes()
6371 rajveer 6530 
 
6389 rajveer 6531 
  def send_getAvailableEmiSchemes(self, ):
6532 
    self._oprot.writeMessageBegin('getAvailableEmiSchemes', TMessageType.CALL, self._seqid)
6533 
    args = getAvailableEmiSchemes_args()
6534 
    args.write(self._oprot)
6535 
    self._oprot.writeMessageEnd()
6536 
    self._oprot.trans.flush()
6537 
 
6538 
  def recv_getAvailableEmiSchemes(self, ):
6539 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6540 
    if mtype == TMessageType.EXCEPTION:
6541 
      x = TApplicationException()
6542 
      x.read(self._iprot)
6543 
      self._iprot.readMessageEnd()
6544 
      raise x
6545 
    result = getAvailableEmiSchemes_result()
6546 
    result.read(self._iprot)
6547 
    self._iprot.readMessageEnd()
6548 
    if result.success is not None:
6549 
      return result.success
6550 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAvailableEmiSchemes failed: unknown result");
6551 
 
6552 
  def getMiscCharges(self, transactionId):
6553 
    """
6554 
    Parameters:
6555 
     - transactionId
6556 
    """
6557 
    self.send_getMiscCharges(transactionId)
6558 
    return self.recv_getMiscCharges()
6559 
 
6560 
  def send_getMiscCharges(self, transactionId):
6561 
    self._oprot.writeMessageBegin('getMiscCharges', TMessageType.CALL, self._seqid)
6562 
    args = getMiscCharges_args()
6563 
    args.transactionId = transactionId
6564 
    args.write(self._oprot)
6565 
    self._oprot.writeMessageEnd()
6566 
    self._oprot.trans.flush()
6567 
 
6568 
  def recv_getMiscCharges(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 = getMiscCharges_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, "getMiscCharges failed: unknown result");
6581 
 
6507 anupam.sin 6582 
  def refundRechargeOrder(self, rechargeOrderId):
6583 
    """
6584 
    Parameters:
6585 
     - rechargeOrderId
6586 
    """
6587 
    self.send_refundRechargeOrder(rechargeOrderId)
6588 
    return self.recv_refundRechargeOrder()
6389 rajveer 6589 
 
6507 anupam.sin 6590 
  def send_refundRechargeOrder(self, rechargeOrderId):
6591 
    self._oprot.writeMessageBegin('refundRechargeOrder', TMessageType.CALL, self._seqid)
6592 
    args = refundRechargeOrder_args()
6593 
    args.rechargeOrderId = rechargeOrderId
6594 
    args.write(self._oprot)
6595 
    self._oprot.writeMessageEnd()
6596 
    self._oprot.trans.flush()
6597 
 
6598 
  def recv_refundRechargeOrder(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 = refundRechargeOrder_result()
6606 
    result.read(self._iprot)
6607 
    self._iprot.readMessageEnd()
6608 
    if result.success is not None:
6609 
      return result.success
6610 
    if result.ex is not None:
6611 
      raise result.ex
6612 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "refundRechargeOrder failed: unknown result");
6613 
 
6821 amar.kumar 6614 
  def getPhysicalOrders(self, fromDate, toDate):
6615 
    """
6616 
    Parameters:
6617 
     - fromDate
6618 
     - toDate
6619 
    """
6620 
    self.send_getPhysicalOrders(fromDate, toDate)
6621 
    return self.recv_getPhysicalOrders()
6507 anupam.sin 6622 
 
6821 amar.kumar 6623 
  def send_getPhysicalOrders(self, fromDate, toDate):
6624 
    self._oprot.writeMessageBegin('getPhysicalOrders', TMessageType.CALL, self._seqid)
6625 
    args = getPhysicalOrders_args()
6626 
    args.fromDate = fromDate
6627 
    args.toDate = toDate
6628 
    args.write(self._oprot)
6629 
    self._oprot.writeMessageEnd()
6630 
    self._oprot.trans.flush()
6631 
 
6632 
  def recv_getPhysicalOrders(self, ):
6633 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6634 
    if mtype == TMessageType.EXCEPTION:
6635 
      x = TApplicationException()
6636 
      x.read(self._iprot)
6637 
      self._iprot.readMessageEnd()
6638 
      raise x
6639 
    result = getPhysicalOrders_result()
6640 
    result.read(self._iprot)
6641 
    self._iprot.readMessageEnd()
6642 
    if result.success is not None:
6643 
      return result.success
6644 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getPhysicalOrders failed: unknown result");
6645 
 
6906 rajveer 6646 
  def getDocument(self, docType, docSource):
6647 
    """
6648 
    Parameters:
6649 
     - docType
6650 
     - docSource
6651 
    """
6652 
    self.send_getDocument(docType, docSource)
6653 
    return self.recv_getDocument()
6821 amar.kumar 6654 
 
6906 rajveer 6655 
  def send_getDocument(self, docType, docSource):
6656 
    self._oprot.writeMessageBegin('getDocument', TMessageType.CALL, self._seqid)
6657 
    args = getDocument_args()
6658 
    args.docType = docType
6659 
    args.docSource = docSource
6660 
    args.write(self._oprot)
6661 
    self._oprot.writeMessageEnd()
6662 
    self._oprot.trans.flush()
6663 
 
6664 
  def recv_getDocument(self, ):
6665 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6666 
    if mtype == TMessageType.EXCEPTION:
6667 
      x = TApplicationException()
6668 
      x.read(self._iprot)
6669 
      self._iprot.readMessageEnd()
6670 
      raise x
6671 
    result = getDocument_result()
6672 
    result.read(self._iprot)
6673 
    self._iprot.readMessageEnd()
6674 
    if result.success is not None:
6675 
      return result.success
6676 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getDocument failed: unknown result");
6677 
 
6985 anupam.sin 6678 
  def changeShippingAddress(self, orderId, line1, line2, city, state, pin):
6679 
    """
6680 
    Parameters:
6681 
     - orderId
6682 
     - line1
6683 
     - line2
6684 
     - city
6685 
     - state
6686 
     - pin
6687 
    """
6688 
    self.send_changeShippingAddress(orderId, line1, line2, city, state, pin)
6689 
    return self.recv_changeShippingAddress()
6906 rajveer 6690 
 
6985 anupam.sin 6691 
  def send_changeShippingAddress(self, orderId, line1, line2, city, state, pin):
6692 
    self._oprot.writeMessageBegin('changeShippingAddress', TMessageType.CALL, self._seqid)
6693 
    args = changeShippingAddress_args()
6694 
    args.orderId = orderId
6695 
    args.line1 = line1
6696 
    args.line2 = line2
6697 
    args.city = city
6698 
    args.state = state
6699 
    args.pin = pin
6700 
    args.write(self._oprot)
6701 
    self._oprot.writeMessageEnd()
6702 
    self._oprot.trans.flush()
6703 
 
6704 
  def recv_changeShippingAddress(self, ):
6705 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6706 
    if mtype == TMessageType.EXCEPTION:
6707 
      x = TApplicationException()
6708 
      x.read(self._iprot)
6709 
      self._iprot.readMessageEnd()
6710 
      raise x
6711 
    result = changeShippingAddress_result()
6712 
    result.read(self._iprot)
6713 
    self._iprot.readMessageEnd()
6714 
    if result.success is not None:
6715 
      return result.success
6716 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "changeShippingAddress failed: unknown result");
6717 
 
7075 rajveer 6718 
  def retrieveInvoice(self, orderId, userId):
6988 rajveer 6719 
    """
6720 
    Parameters:
6721 
     - orderId
7075 rajveer 6722 
     - userId
6988 rajveer 6723 
    """
7075 rajveer 6724 
    self.send_retrieveInvoice(orderId, userId)
6988 rajveer 6725 
    return self.recv_retrieveInvoice()
6985 anupam.sin 6726 
 
7075 rajveer 6727 
  def send_retrieveInvoice(self, orderId, userId):
6988 rajveer 6728 
    self._oprot.writeMessageBegin('retrieveInvoice', TMessageType.CALL, self._seqid)
6729 
    args = retrieveInvoice_args()
6730 
    args.orderId = orderId
7075 rajveer 6731 
    args.userId = userId
6988 rajveer 6732 
    args.write(self._oprot)
6733 
    self._oprot.writeMessageEnd()
6734 
    self._oprot.trans.flush()
6735 
 
6736 
  def recv_retrieveInvoice(self, ):
6737 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6738 
    if mtype == TMessageType.EXCEPTION:
6739 
      x = TApplicationException()
6740 
      x.read(self._iprot)
6741 
      self._iprot.readMessageEnd()
6742 
      raise x
6743 
    result = retrieveInvoice_result()
6744 
    result.read(self._iprot)
6745 
    self._iprot.readMessageEnd()
6746 
    if result.success is not None:
6747 
      return result.success
6748 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "retrieveInvoice failed: unknown result");
6749 
 
7026 rajveer 6750 
  def receiveUpdatesForRedExpress(self, awbNumber):
6751 
    """
6752 
    Parameters:
6753 
     - awbNumber
6754 
    """
6755 
    self.send_receiveUpdatesForRedExpress(awbNumber)
6756 
    return self.recv_receiveUpdatesForRedExpress()
6988 rajveer 6757 
 
7026 rajveer 6758 
  def send_receiveUpdatesForRedExpress(self, awbNumber):
6759 
    self._oprot.writeMessageBegin('receiveUpdatesForRedExpress', TMessageType.CALL, self._seqid)
6760 
    args = receiveUpdatesForRedExpress_args()
6761 
    args.awbNumber = awbNumber
6762 
    args.write(self._oprot)
6763 
    self._oprot.writeMessageEnd()
6764 
    self._oprot.trans.flush()
6765 
 
6766 
  def recv_receiveUpdatesForRedExpress(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 = receiveUpdatesForRedExpress_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, "receiveUpdatesForRedExpress failed: unknown result");
6779 
 
7073 anupam.sin 6780 
  def createRechargeTransaction(self, thriftRechargeTransaction):
6781 
    """
6782 
    Parameters:
6783 
     - thriftRechargeTransaction
6784 
    """
6785 
    self.send_createRechargeTransaction(thriftRechargeTransaction)
6786 
    return self.recv_createRechargeTransaction()
7026 rajveer 6787 
 
7073 anupam.sin 6788 
  def send_createRechargeTransaction(self, thriftRechargeTransaction):
6789 
    self._oprot.writeMessageBegin('createRechargeTransaction', TMessageType.CALL, self._seqid)
6790 
    args = createRechargeTransaction_args()
6791 
    args.thriftRechargeTransaction = thriftRechargeTransaction
6792 
    args.write(self._oprot)
6793 
    self._oprot.writeMessageEnd()
6794 
    self._oprot.trans.flush()
6795 
 
6796 
  def recv_createRechargeTransaction(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 = createRechargeTransaction_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, "createRechargeTransaction failed: unknown result");
6809 
 
7080 anupam.sin 6810 
  def getRechargeTransaction(self, rechargeId):
6811 
    """
6812 
    Parameters:
6813 
     - rechargeId
6814 
    """
6815 
    self.send_getRechargeTransaction(rechargeId)
6816 
    return self.recv_getRechargeTransaction()
7073 anupam.sin 6817 
 
7080 anupam.sin 6818 
  def send_getRechargeTransaction(self, rechargeId):
6819 
    self._oprot.writeMessageBegin('getRechargeTransaction', TMessageType.CALL, self._seqid)
6820 
    args = getRechargeTransaction_args()
6821 
    args.rechargeId = rechargeId
6822 
    args.write(self._oprot)
6823 
    self._oprot.writeMessageEnd()
6824 
    self._oprot.trans.flush()
6825 
 
6826 
  def recv_getRechargeTransaction(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 = getRechargeTransaction_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, "getRechargeTransaction failed: unknown result");
6839 
 
6840 
  def getFRCs(self, circleId, operatorId):
6841 
    """
6842 
    Parameters:
6843 
     - circleId
6844 
     - operatorId
6845 
    """
6846 
    self.send_getFRCs(circleId, operatorId)
6847 
    return self.recv_getFRCs()
6848 
 
6849 
  def send_getFRCs(self, circleId, operatorId):
6850 
    self._oprot.writeMessageBegin('getFRCs', TMessageType.CALL, self._seqid)
6851 
    args = getFRCs_args()
6852 
    args.circleId = circleId
6853 
    args.operatorId = operatorId
6854 
    args.write(self._oprot)
6855 
    self._oprot.writeMessageEnd()
6856 
    self._oprot.trans.flush()
6857 
 
6858 
  def recv_getFRCs(self, ):
6859 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6860 
    if mtype == TMessageType.EXCEPTION:
6861 
      x = TApplicationException()
6862 
      x.read(self._iprot)
6863 
      self._iprot.readMessageEnd()
6864 
      raise x
6865 
    result = getFRCs_result()
6866 
    result.read(self._iprot)
6867 
    self._iprot.readMessageEnd()
6868 
    if result.success is not None:
6869 
      return result.success
6870 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getFRCs failed: unknown result");
6871 
 
6872 
 
3376 rajveer 6873 
class Processor(shop2020.thriftpy.generic.GenericService.Processor, Iface, TProcessor):
94 ashish 6874 
  def __init__(self, handler):
3376 rajveer 6875 
    shop2020.thriftpy.generic.GenericService.Processor.__init__(self, handler)
94 ashish 6876 
    self._processMap["createTransaction"] = Processor.process_createTransaction
6877 
    self._processMap["getTransaction"] = Processor.process_getTransaction
6878 
    self._processMap["getTransactionsForCustomer"] = Processor.process_getTransactionsForCustomer
132 ashish 6879 
    self._processMap["getTransactionsForShoppingCartId"] = Processor.process_getTransactionsForShoppingCartId
94 ashish 6880 
    self._processMap["getTransactionStatus"] = Processor.process_getTransactionStatus
6881 
    self._processMap["changeTransactionStatus"] = Processor.process_changeTransactionStatus
1398 varun.gupt 6882 
    self._processMap["enqueueTransactionInfoEmail"] = Processor.process_enqueueTransactionInfoEmail
483 rajveer 6883 
    self._processMap["getAllOrders"] = Processor.process_getAllOrders
4133 chandransh 6884 
    self._processMap["getOrdersInBatch"] = Processor.process_getOrdersInBatch
6885 
    self._processMap["getOrderCount"] = Processor.process_getOrderCount
999 varun.gupt 6886 
    self._processMap["getOrdersByBillingDate"] = Processor.process_getOrdersByBillingDate
3427 chandransh 6887 
    self._processMap["getOrdersByShippingDate"] = Processor.process_getOrdersByShippingDate
1382 varun.gupt 6888 
    self._processMap["getReturnableOrdersForCustomer"] = Processor.process_getReturnableOrdersForCustomer
6889 
    self._processMap["getCancellableOrdersForCustomer"] = Processor.process_getCancellableOrdersForCustomer
483 rajveer 6890 
    self._processMap["changeOrderStatus"] = Processor.process_changeOrderStatus
6891 
    self._processMap["getOrdersForTransaction"] = Processor.process_getOrdersForTransaction
6892 
    self._processMap["getOrdersForCustomer"] = Processor.process_getOrdersForCustomer
6893 
    self._processMap["createOrder"] = Processor.process_createOrder
6894 
    self._processMap["getOrder"] = Processor.process_getOrder
6895 
    self._processMap["getLineItemsForOrder"] = Processor.process_getLineItemsForOrder
4999 phani.kuma 6896 
    self._processMap["getOrderList"] = Processor.process_getOrderList
5386 phani.kuma 6897 
    self._processMap["getOrderListForVendor"] = Processor.process_getOrderListForVendor
1528 ankur.sing 6898 
    self._processMap["getOrderForCustomer"] = Processor.process_getOrderForCustomer
3064 chandransh 6899 
    self._processMap["getAlerts"] = Processor.process_getAlerts
4394 rajveer 6900 
    self._processMap["addAlert"] = Processor.process_addAlert
4444 rajveer 6901 
    self._processMap["markAlertsAsSeen"] = Processor.process_markAlertsAsSeen
3064 chandransh 6902 
    self._processMap["getValidOrderCount"] = Processor.process_getValidOrderCount
6903 
    self._processMap["getNoOfCustomersWithSuccessfulTransaction"] = Processor.process_getNoOfCustomersWithSuccessfulTransaction
6904 
    self._processMap["getValidOrdersAmountRange"] = Processor.process_getValidOrdersAmountRange
6905 
    self._processMap["getValidOrders"] = Processor.process_getValidOrders
1220 chandransh 6906 
    self._processMap["batchOrders"] = Processor.process_batchOrders
1208 chandransh 6907 
    self._processMap["markOrderAsOutOfStock"] = Processor.process_markOrderAsOutOfStock
3064 chandransh 6908 
    self._processMap["verifyOrder"] = Processor.process_verifyOrder
6909 
    self._processMap["acceptOrder"] = Processor.process_acceptOrder
6910 
    self._processMap["addBillingDetails"] = Processor.process_addBillingDetails
4579 rajveer 6911 
    self._processMap["addInvoiceNumber"] = Processor.process_addInvoiceNumber
4410 rajveer 6912 
    self._processMap["markOrdersAsShippedFromWarehouse"] = Processor.process_markOrdersAsShippedFromWarehouse
5676 rajveer 6913 
    self._processMap["markOrdersAsReturnedFromStore"] = Processor.process_markOrdersAsReturnedFromStore
1113 chandransh 6914 
    self._processMap["markOrdersAsPickedUp"] = Processor.process_markOrdersAsPickedUp
4910 phani.kuma 6915 
    self._processMap["getOrdersNotPickedUp"] = Processor.process_getOrdersNotPickedUp
1132 chandransh 6916 
    self._processMap["markOrdersAsDelivered"] = Processor.process_markOrdersAsDelivered
4910 phani.kuma 6917 
    self._processMap["markAsRTOrders"] = Processor.process_markAsRTOrders
6918 
    self._processMap["getRTOrders"] = Processor.process_getRTOrders
1246 chandransh 6919 
    self._processMap["updateNonDeliveryReason"] = Processor.process_updateNonDeliveryReason
4910 phani.kuma 6920 
    self._processMap["getNonDeliveredOrdersbyCourier"] = Processor.process_getNonDeliveredOrdersbyCourier
6921 
    self._processMap["markOrdersAsLocalConnected"] = Processor.process_markOrdersAsLocalConnected
6922 
    self._processMap["getOrdersNotLocalConnected"] = Processor.process_getOrdersNotLocalConnected
6923 
    self._processMap["markOrdersAsDestinationCityReached"] = Processor.process_markOrdersAsDestinationCityReached
6924 
    self._processMap["markOrdersAsFirstDeliveryAttempted"] = Processor.process_markOrdersAsFirstDeliveryAttempted
1408 ankur.sing 6925 
    self._processMap["getUndeliveredOrders"] = Processor.process_getUndeliveredOrders
4783 phani.kuma 6926 
    self._processMap["getUndeliveredOrdersExpectedDeliveryDateNotMet"] = Processor.process_getUndeliveredOrdersExpectedDeliveryDateNotMet
2536 chandransh 6927 
    self._processMap["toggleDOAFlag"] = Processor.process_toggleDOAFlag
4712 rajveer 6928 
    self._processMap["markOrderAsDelivered"] = Processor.process_markOrderAsDelivered
5553 rajveer 6929 
    self._processMap["markOrderAsReceivedAtStore"] = Processor.process_markOrderAsReceivedAtStore
4454 rajveer 6930 
    self._processMap["markOrderDoaRequestReceived"] = Processor.process_markOrderDoaRequestReceived
6931 
    self._processMap["markOrderDoaRequestAuthorized"] = Processor.process_markOrderDoaRequestAuthorized
4488 rajveer 6932 
    self._processMap["markOrderReturnRequestReceived"] = Processor.process_markOrderReturnRequestReceived
6933 
    self._processMap["markOrderReturnRequestAuthorized"] = Processor.process_markOrderReturnRequestAuthorized
2536 chandransh 6934 
    self._processMap["requestPickupNumber"] = Processor.process_requestPickupNumber
6935 
    self._processMap["authorizePickup"] = Processor.process_authorizePickup
2764 chandransh 6936 
    self._processMap["markDoasAsPickedUp"] = Processor.process_markDoasAsPickedUp
4910 phani.kuma 6937 
    self._processMap["getDoasNotPickedUp"] = Processor.process_getDoasNotPickedUp
4741 phani.kuma 6938 
    self._processMap["markReturnOrdersAsPickedUp"] = Processor.process_markReturnOrdersAsPickedUp
4910 phani.kuma 6939 
    self._processMap["getReturnOrdersNotPickedUp"] = Processor.process_getReturnOrdersNotPickedUp
2616 chandransh 6940 
    self._processMap["receiveReturn"] = Processor.process_receiveReturn
2591 chandransh 6941 
    self._processMap["validateDoa"] = Processor.process_validateDoa
4495 rajveer 6942 
    self._processMap["validateReturnProduct"] = Processor.process_validateReturnProduct
2616 chandransh 6943 
    self._processMap["reshipOrder"] = Processor.process_reshipOrder
6944 
    self._processMap["refundOrder"] = Processor.process_refundOrder
2690 chandransh 6945 
    self._processMap["getReturnOrders"] = Processor.process_getReturnOrders
5481 phani.kuma 6946 
    self._processMap["getAllReturnOrders"] = Processor.process_getAllReturnOrders
2700 chandransh 6947 
    self._processMap["getReturnOrder"] = Processor.process_getReturnOrder
2690 chandransh 6948 
    self._processMap["processReturn"] = Processor.process_processReturn
3451 chandransh 6949 
    self._processMap["updateWeight"] = Processor.process_updateWeight
3469 chandransh 6950 
    self._processMap["changeItem"] = Processor.process_changeItem
6951 
    self._processMap["shiftToWarehouse"] = Processor.process_shiftToWarehouse
3553 chandransh 6952 
    self._processMap["addDelayReason"] = Processor.process_addDelayReason
3956 chandransh 6953 
    self._processMap["reconcileCodCollection"] = Processor.process_reconcileCodCollection
4008 mandeep.dh 6954 
    self._processMap["getTransactionsRequiringExtraProcessing"] = Processor.process_getTransactionsRequiringExtraProcessing
6955 
    self._processMap["markTransactionAsProcessed"] = Processor.process_markTransactionAsProcessed
4018 chandransh 6956 
    self._processMap["getItemWiseRiskyOrdersCount"] = Processor.process_getItemWiseRiskyOrdersCount
4295 varun.gupt 6957 
    self._processMap["getOrdersForItemIds"] = Processor.process_getOrdersForItemIds
4247 rajveer 6958 
    self._processMap["markOrderCancellationRequestReceived"] = Processor.process_markOrderCancellationRequestReceived
6959 
    self._processMap["markOrderCancellationRequestConfirmed"] = Processor.process_markOrderCancellationRequestConfirmed
6960 
    self._processMap["markOrderCancellationRequestDenied"] = Processor.process_markOrderCancellationRequestDenied
4258 rajveer 6961 
    self._processMap["markTransactionAsPaymentFlagRemoved"] = Processor.process_markTransactionAsPaymentFlagRemoved
4259 anupam.sin 6962 
    self._processMap["refundTransaction"] = Processor.process_refundTransaction
4324 mandeep.dh 6963 
    self._processMap["updateShipmentAddress"] = Processor.process_updateShipmentAddress
4285 rajveer 6964 
    self._processMap["acceptOrdersForItemId"] = Processor.process_acceptOrdersForItemId
4303 rajveer 6965 
    self._processMap["markOrdersAsPORaised"] = Processor.process_markOrdersAsPORaised
6966 
    self._processMap["markOrdersAsReversalInitiated"] = Processor.process_markOrdersAsReversalInitiated
6967 
    self._processMap["markOrdersAsNotAvailabke"] = Processor.process_markOrdersAsNotAvailabke
4369 rajveer 6968 
    self._processMap["markOrdersAsTimeout"] = Processor.process_markOrdersAsTimeout
4662 rajveer 6969 
    self._processMap["markOrderAsLostInTransit"] = Processor.process_markOrderAsLostInTransit
4386 anupam.sin 6970 
    self._processMap["getOrderForAwb"] = Processor.process_getOrderForAwb
4506 phani.kuma 6971 
    self._processMap["getOrdersForProviderForStatus"] = Processor.process_getOrdersForProviderForStatus
4600 varun.gupt 6972 
    self._processMap["getBilledOrdersForVendor"] = Processor.process_getBilledOrdersForVendor
4607 rajveer 6973 
    self._processMap["getSlippedSippingDateOrders"] = Processor.process_getSlippedSippingDateOrders
4709 rajveer 6974 
    self._processMap["getCancelledOrders"] = Processor.process_getCancelledOrders
4600 varun.gupt 6975 
    self._processMap["saveBluedartSettlements"] = Processor.process_saveBluedartSettlements
6976 
    self._processMap["savePaymentSettlements"] = Processor.process_savePaymentSettlements
6977 
    self._processMap["saveEBSSettlementSummary"] = Processor.process_saveEBSSettlementSummary
5386 phani.kuma 6978 
    self._processMap["getSettlementForPrepaid"] = Processor.process_getSettlementForPrepaid
6979 
    self._processMap["getSettlementForCod"] = Processor.process_getSettlementForCod
4600 varun.gupt 6980 
    self._processMap["getEBSSettlementSummaries"] = Processor.process_getEBSSettlementSummaries
6981 
    self._processMap["markEBSSettlementUploaded"] = Processor.process_markEBSSettlementUploaded
6982 
    self._processMap["getEBSSettlementDate"] = Processor.process_getEBSSettlementDate
4715 varun.gupt 6983 
    self._processMap["getSettlementsByDate"] = Processor.process_getSettlementsByDate
6984 
    self._processMap["getReshippedOrderIds"] = Processor.process_getReshippedOrderIds
5481 phani.kuma 6985 
    self._processMap["getBilledOrders"] = Processor.process_getBilledOrders
5031 varun.gupt 6986 
    self._processMap["getStatusDistributionOfOrders"] = Processor.process_getStatusDistributionOfOrders
5067 varun.gupt 6987 
    self._processMap["getOrderIdsForStatus"] = Processor.process_getOrderIdsForStatus
5348 anupam.sin 6988 
    self._processMap["updateCODAgent"] = Processor.process_updateCODAgent
5099 varun.gupt 6989 
    self._processMap["updateOrderAsPaidToVendor"] = Processor.process_updateOrderAsPaidToVendor
5386 phani.kuma 6990 
    self._processMap["updateOrderOnlyAsPaidToVendor"] = Processor.process_updateOrderOnlyAsPaidToVendor
5208 varun.gupt 6991 
    self._processMap["getRefundedOrdersMarkedPaid"] = Processor.process_getRefundedOrdersMarkedPaid
5447 anupam.sin 6992 
    self._processMap["getAllVerificationAgents"] = Processor.process_getAllVerificationAgents
5527 anupam.sin 6993 
    self._processMap["getAllAttributesForOrderId"] = Processor.process_getAllAttributesForOrderId
5676 rajveer 6994 
    self._processMap["setOrderAttributes"] = Processor.process_setOrderAttributes
5527 anupam.sin 6995 
    self._processMap["setOrderAttributeForTransaction"] = Processor.process_setOrderAttributeForTransaction
5553 rajveer 6996 
    self._processMap["getReceivePendingOrders"] = Processor.process_getReceivePendingOrders
6997 
    self._processMap["getReceivedAtStoreOrders"] = Processor.process_getReceivedAtStoreOrders
5713 rajveer 6998 
    self._processMap["getOrdersCollectionAtStore"] = Processor.process_getOrdersCollectionAtStore
5833 rajveer 6999 
    self._processMap["getOrderAttributeValue"] = Processor.process_getOrderAttributeValue
6019 rajveer 7000 
    self._processMap["changeJacketNumber"] = Processor.process_changeJacketNumber
7001 
    self._processMap["markOrderAsRtoInTransit"] = Processor.process_markOrderAsRtoInTransit
5593 mandeep.dh 7002 
    self._processMap["acceptOrderForItem"] = Processor.process_acceptOrderForItem
6000 mandeep.dh 7003 
    self._processMap["createRechargeOrder"] = Processor.process_createRechargeOrder
6031 rajveer 7004 
    self._processMap["getRechargeOrder"] = Processor.process_getRechargeOrder
7005 
    self._processMap["getRechargeOrders"] = Processor.process_getRechargeOrders
6000 mandeep.dh 7006 
    self._processMap["updateRechargeOrderStatus"] = Processor.process_updateRechargeOrderStatus
7007 
    self._processMap["activateRechargeTxn"] = Processor.process_activateRechargeTxn
6031 rajveer 7008 
    self._processMap["getUserWallet"] = Processor.process_getUserWallet
7009 
    self._processMap["getUserWalletHistory"] = Processor.process_getUserWalletHistory
6050 anupam.sin 7010 
    self._processMap["getRechargeOrdersForTransaction"] = Processor.process_getRechargeOrdersForTransaction
6048 rajveer 7011 
    self._processMap["getServiceProviders"] = Processor.process_getServiceProviders
7012 
    self._processMap["getServiceProviderForDevice"] = Processor.process_getServiceProviderForDevice
6269 rajveer 7013 
    self._processMap["validateRecharge"] = Processor.process_validateRecharge
6094 rajveer 7014 
    self._processMap["getRechargeOrdersForDevice"] = Processor.process_getRechargeOrdersForDevice
7015 
    self._processMap["addAmountToWallet"] = Processor.process_addAmountToWallet
6188 rajveer 7016 
    self._processMap["getRechargeStatistics"] = Processor.process_getRechargeStatistics
6154 rajveer 7017 
    self._processMap["getRechargeOrdersForStatus"] = Processor.process_getRechargeOrdersForStatus
6159 rajveer 7018 
    self._processMap["getPlansForOperator"] = Processor.process_getPlansForOperator
6289 anupam.sin 7019 
    self._processMap["getRechargeDenominations"] = Processor.process_getRechargeDenominations
6371 rajveer 7020 
    self._processMap["updateAvailabilityStatus"] = Processor.process_updateAvailabilityStatus
6389 rajveer 7021 
    self._processMap["getAvailableEmiSchemes"] = Processor.process_getAvailableEmiSchemes
7022 
    self._processMap["getMiscCharges"] = Processor.process_getMiscCharges
6507 anupam.sin 7023 
    self._processMap["refundRechargeOrder"] = Processor.process_refundRechargeOrder
6821 amar.kumar 7024 
    self._processMap["getPhysicalOrders"] = Processor.process_getPhysicalOrders
6906 rajveer 7025 
    self._processMap["getDocument"] = Processor.process_getDocument
6985 anupam.sin 7026 
    self._processMap["changeShippingAddress"] = Processor.process_changeShippingAddress
6988 rajveer 7027 
    self._processMap["retrieveInvoice"] = Processor.process_retrieveInvoice
7026 rajveer 7028 
    self._processMap["receiveUpdatesForRedExpress"] = Processor.process_receiveUpdatesForRedExpress
7073 anupam.sin 7029 
    self._processMap["createRechargeTransaction"] = Processor.process_createRechargeTransaction
7080 anupam.sin 7030 
    self._processMap["getRechargeTransaction"] = Processor.process_getRechargeTransaction
7031 
    self._processMap["getFRCs"] = Processor.process_getFRCs
94 ashish 7032 
 
7033 
  def process(self, iprot, oprot):
7034 
    (name, type, seqid) = iprot.readMessageBegin()
7035 
    if name not in self._processMap:
7036 
      iprot.skip(TType.STRUCT)
7037 
      iprot.readMessageEnd()
7038 
      x = TApplicationException(TApplicationException.UNKNOWN_METHOD, 'Unknown function %s' % (name))
7039 
      oprot.writeMessageBegin(name, TMessageType.EXCEPTION, seqid)
7040 
      x.write(oprot)
7041 
      oprot.writeMessageEnd()
7042 
      oprot.trans.flush()
7043 
      return
7044 
    else:
7045 
      self._processMap[name](self, seqid, iprot, oprot)
7046 
    return True
7047 
 
7048 
  def process_createTransaction(self, seqid, iprot, oprot):
7049 
    args = createTransaction_args()
7050 
    args.read(iprot)
7051 
    iprot.readMessageEnd()
7052 
    result = createTransaction_result()
7053 
    try:
132 ashish 7054 
      result.success = self._handler.createTransaction(args.transaction)
94 ashish 7055 
    except TransactionServiceException, ex:
7056 
      result.ex = ex
7057 
    oprot.writeMessageBegin("createTransaction", TMessageType.REPLY, seqid)
7058 
    result.write(oprot)
7059 
    oprot.writeMessageEnd()
7060 
    oprot.trans.flush()
7061 
 
7062 
  def process_getTransaction(self, seqid, iprot, oprot):
7063 
    args = getTransaction_args()
7064 
    args.read(iprot)
7065 
    iprot.readMessageEnd()
7066 
    result = getTransaction_result()
7067 
    try:
7068 
      result.success = self._handler.getTransaction(args.id)
7069 
    except TransactionServiceException, ex:
7070 
      result.ex = ex
7071 
    oprot.writeMessageBegin("getTransaction", TMessageType.REPLY, seqid)
7072 
    result.write(oprot)
7073 
    oprot.writeMessageEnd()
7074 
    oprot.trans.flush()
7075 
 
7076 
  def process_getTransactionsForCustomer(self, seqid, iprot, oprot):
7077 
    args = getTransactionsForCustomer_args()
7078 
    args.read(iprot)
7079 
    iprot.readMessageEnd()
7080 
    result = getTransactionsForCustomer_result()
7081 
    try:
7082 
      result.success = self._handler.getTransactionsForCustomer(args.customerId, args.from_date, args.to_date, args.status)
7083 
    except TransactionServiceException, ex:
7084 
      result.ex = ex
7085 
    oprot.writeMessageBegin("getTransactionsForCustomer", TMessageType.REPLY, seqid)
7086 
    result.write(oprot)
7087 
    oprot.writeMessageEnd()
7088 
    oprot.trans.flush()
7089 
 
132 ashish 7090 
  def process_getTransactionsForShoppingCartId(self, seqid, iprot, oprot):
7091 
    args = getTransactionsForShoppingCartId_args()
7092 
    args.read(iprot)
7093 
    iprot.readMessageEnd()
7094 
    result = getTransactionsForShoppingCartId_result()
7095 
    try:
7096 
      result.success = self._handler.getTransactionsForShoppingCartId(args.shoppingCartId)
7097 
    except TransactionServiceException, ex:
7098 
      result.ex = ex
7099 
    oprot.writeMessageBegin("getTransactionsForShoppingCartId", TMessageType.REPLY, seqid)
7100 
    result.write(oprot)
7101 
    oprot.writeMessageEnd()
7102 
    oprot.trans.flush()
7103 
 
94 ashish 7104 
  def process_getTransactionStatus(self, seqid, iprot, oprot):
7105 
    args = getTransactionStatus_args()
7106 
    args.read(iprot)
7107 
    iprot.readMessageEnd()
7108 
    result = getTransactionStatus_result()
7109 
    try:
7110 
      result.success = self._handler.getTransactionStatus(args.transactionId)
7111 
    except TransactionServiceException, ex:
7112 
      result.ex = ex
7113 
    oprot.writeMessageBegin("getTransactionStatus", TMessageType.REPLY, seqid)
7114 
    result.write(oprot)
7115 
    oprot.writeMessageEnd()
7116 
    oprot.trans.flush()
7117 
 
7118 
  def process_changeTransactionStatus(self, seqid, iprot, oprot):
7119 
    args = changeTransactionStatus_args()
7120 
    args.read(iprot)
7121 
    iprot.readMessageEnd()
7122 
    result = changeTransactionStatus_result()
7123 
    try:
5527 anupam.sin 7124 
      result.success = self._handler.changeTransactionStatus(args.transactionId, args.status, args.description, args.pickUp, args.orderType)
94 ashish 7125 
    except TransactionServiceException, ex:
7126 
      result.ex = ex
7127 
    oprot.writeMessageBegin("changeTransactionStatus", TMessageType.REPLY, seqid)
7128 
    result.write(oprot)
7129 
    oprot.writeMessageEnd()
7130 
    oprot.trans.flush()
7131 
 
1398 varun.gupt 7132 
  def process_enqueueTransactionInfoEmail(self, seqid, iprot, oprot):
7133 
    args = enqueueTransactionInfoEmail_args()
1382 varun.gupt 7134 
    args.read(iprot)
7135 
    iprot.readMessageEnd()
1398 varun.gupt 7136 
    result = enqueueTransactionInfoEmail_result()
1382 varun.gupt 7137 
    try:
1398 varun.gupt 7138 
      result.success = self._handler.enqueueTransactionInfoEmail(args.transactionId)
1382 varun.gupt 7139 
    except TransactionServiceException, ex:
7140 
      result.ex = ex
1398 varun.gupt 7141 
    oprot.writeMessageBegin("enqueueTransactionInfoEmail", TMessageType.REPLY, seqid)
1382 varun.gupt 7142 
    result.write(oprot)
7143 
    oprot.writeMessageEnd()
7144 
    oprot.trans.flush()
7145 
 
483 rajveer 7146 
  def process_getAllOrders(self, seqid, iprot, oprot):
7147 
    args = getAllOrders_args()
94 ashish 7148 
    args.read(iprot)
7149 
    iprot.readMessageEnd()
483 rajveer 7150 
    result = getAllOrders_result()
94 ashish 7151 
    try:
4801 anupam.sin 7152 
      result.success = self._handler.getAllOrders(args.statuses, args.from_date, args.to_date, args.warehouse_id)
94 ashish 7153 
    except TransactionServiceException, ex:
7154 
      result.ex = ex
483 rajveer 7155 
    oprot.writeMessageBegin("getAllOrders", TMessageType.REPLY, seqid)
94 ashish 7156 
    result.write(oprot)
7157 
    oprot.writeMessageEnd()
7158 
    oprot.trans.flush()
7159 
 
4133 chandransh 7160 
  def process_getOrdersInBatch(self, seqid, iprot, oprot):
7161 
    args = getOrdersInBatch_args()
7162 
    args.read(iprot)
7163 
    iprot.readMessageEnd()
7164 
    result = getOrdersInBatch_result()
7165 
    try:
7166 
      result.success = self._handler.getOrdersInBatch(args.statuses, args.offset, args.limit, args.warehouse_id)
7167 
    except TransactionServiceException, ex:
7168 
      result.ex = ex
7169 
    oprot.writeMessageBegin("getOrdersInBatch", TMessageType.REPLY, seqid)
7170 
    result.write(oprot)
7171 
    oprot.writeMessageEnd()
7172 
    oprot.trans.flush()
7173 
 
7174 
  def process_getOrderCount(self, seqid, iprot, oprot):
7175 
    args = getOrderCount_args()
7176 
    args.read(iprot)
7177 
    iprot.readMessageEnd()
7178 
    result = getOrderCount_result()
7179 
    try:
7180 
      result.success = self._handler.getOrderCount(args.statuses, args.warehouseId)
7181 
    except TransactionServiceException, ex:
7182 
      result.ex = ex
7183 
    oprot.writeMessageBegin("getOrderCount", TMessageType.REPLY, seqid)
7184 
    result.write(oprot)
7185 
    oprot.writeMessageEnd()
7186 
    oprot.trans.flush()
7187 
 
999 varun.gupt 7188 
  def process_getOrdersByBillingDate(self, seqid, iprot, oprot):
7189 
    args = getOrdersByBillingDate_args()
7190 
    args.read(iprot)
7191 
    iprot.readMessageEnd()
7192 
    result = getOrdersByBillingDate_result()
7193 
    try:
7194 
      result.success = self._handler.getOrdersByBillingDate(args.status, args.start_billing_date, args.end_billing_date, args.warehouse_id)
7195 
    except TransactionServiceException, ex:
7196 
      result.ex = ex
7197 
    oprot.writeMessageBegin("getOrdersByBillingDate", TMessageType.REPLY, seqid)
7198 
    result.write(oprot)
7199 
    oprot.writeMessageEnd()
7200 
    oprot.trans.flush()
7201 
 
3427 chandransh 7202 
  def process_getOrdersByShippingDate(self, seqid, iprot, oprot):
7203 
    args = getOrdersByShippingDate_args()
7204 
    args.read(iprot)
7205 
    iprot.readMessageEnd()
7206 
    result = getOrdersByShippingDate_result()
7207 
    try:
3451 chandransh 7208 
      result.success = self._handler.getOrdersByShippingDate(args.fromShippingDate, args.toShippingDate, args.providerId, args.warehouseId, args.cod)
3427 chandransh 7209 
    except TransactionServiceException, ex:
7210 
      result.ex = ex
7211 
    oprot.writeMessageBegin("getOrdersByShippingDate", TMessageType.REPLY, seqid)
7212 
    result.write(oprot)
7213 
    oprot.writeMessageEnd()
7214 
    oprot.trans.flush()
7215 
 
1382 varun.gupt 7216 
  def process_getReturnableOrdersForCustomer(self, seqid, iprot, oprot):
7217 
    args = getReturnableOrdersForCustomer_args()
7218 
    args.read(iprot)
7219 
    iprot.readMessageEnd()
7220 
    result = getReturnableOrdersForCustomer_result()
7221 
    try:
7222 
      result.success = self._handler.getReturnableOrdersForCustomer(args.customer_id, args.limit)
7223 
    except TransactionServiceException, ex:
7224 
      result.ex = ex
7225 
    oprot.writeMessageBegin("getReturnableOrdersForCustomer", TMessageType.REPLY, seqid)
7226 
    result.write(oprot)
7227 
    oprot.writeMessageEnd()
7228 
    oprot.trans.flush()
7229 
 
7230 
  def process_getCancellableOrdersForCustomer(self, seqid, iprot, oprot):
7231 
    args = getCancellableOrdersForCustomer_args()
7232 
    args.read(iprot)
7233 
    iprot.readMessageEnd()
7234 
    result = getCancellableOrdersForCustomer_result()
7235 
    try:
7236 
      result.success = self._handler.getCancellableOrdersForCustomer(args.customer_id, args.limit)
7237 
    except TransactionServiceException, ex:
7238 
      result.ex = ex
7239 
    oprot.writeMessageBegin("getCancellableOrdersForCustomer", TMessageType.REPLY, seqid)
7240 
    result.write(oprot)
7241 
    oprot.writeMessageEnd()
7242 
    oprot.trans.flush()
7243 
 
483 rajveer 7244 
  def process_changeOrderStatus(self, seqid, iprot, oprot):
7245 
    args = changeOrderStatus_args()
94 ashish 7246 
    args.read(iprot)
7247 
    iprot.readMessageEnd()
483 rajveer 7248 
    result = changeOrderStatus_result()
94 ashish 7249 
    try:
483 rajveer 7250 
      result.success = self._handler.changeOrderStatus(args.orderId, args.status, args.description)
94 ashish 7251 
    except TransactionServiceException, ex:
7252 
      result.ex = ex
483 rajveer 7253 
    oprot.writeMessageBegin("changeOrderStatus", TMessageType.REPLY, seqid)
94 ashish 7254 
    result.write(oprot)
7255 
    oprot.writeMessageEnd()
7256 
    oprot.trans.flush()
7257 
 
483 rajveer 7258 
  def process_getOrdersForTransaction(self, seqid, iprot, oprot):
7259 
    args = getOrdersForTransaction_args()
94 ashish 7260 
    args.read(iprot)
7261 
    iprot.readMessageEnd()
483 rajveer 7262 
    result = getOrdersForTransaction_result()
94 ashish 7263 
    try:
1528 ankur.sing 7264 
      result.success = self._handler.getOrdersForTransaction(args.transactionId, args.customerId)
94 ashish 7265 
    except TransactionServiceException, ex:
7266 
      result.ex = ex
483 rajveer 7267 
    oprot.writeMessageBegin("getOrdersForTransaction", TMessageType.REPLY, seqid)
94 ashish 7268 
    result.write(oprot)
7269 
    oprot.writeMessageEnd()
7270 
    oprot.trans.flush()
7271 
 
483 rajveer 7272 
  def process_getOrdersForCustomer(self, seqid, iprot, oprot):
7273 
    args = getOrdersForCustomer_args()
94 ashish 7274 
    args.read(iprot)
7275 
    iprot.readMessageEnd()
483 rajveer 7276 
    result = getOrdersForCustomer_result()
94 ashish 7277 
    try:
3014 chandransh 7278 
      result.success = self._handler.getOrdersForCustomer(args.customerId, args.from_date, args.to_date, args.statuses)
94 ashish 7279 
    except TransactionServiceException, ex:
7280 
      result.ex = ex
483 rajveer 7281 
    oprot.writeMessageBegin("getOrdersForCustomer", TMessageType.REPLY, seqid)
94 ashish 7282 
    result.write(oprot)
7283 
    oprot.writeMessageEnd()
7284 
    oprot.trans.flush()
7285 
 
483 rajveer 7286 
  def process_createOrder(self, seqid, iprot, oprot):
7287 
    args = createOrder_args()
94 ashish 7288 
    args.read(iprot)
7289 
    iprot.readMessageEnd()
483 rajveer 7290 
    result = createOrder_result()
94 ashish 7291 
    try:
483 rajveer 7292 
      result.success = self._handler.createOrder(args.order)
94 ashish 7293 
    except TransactionServiceException, ex:
7294 
      result.ex = ex
483 rajveer 7295 
    oprot.writeMessageBegin("createOrder", TMessageType.REPLY, seqid)
94 ashish 7296 
    result.write(oprot)
7297 
    oprot.writeMessageEnd()
7298 
    oprot.trans.flush()
7299 
 
483 rajveer 7300 
  def process_getOrder(self, seqid, iprot, oprot):
7301 
    args = getOrder_args()
94 ashish 7302 
    args.read(iprot)
7303 
    iprot.readMessageEnd()
483 rajveer 7304 
    result = getOrder_result()
94 ashish 7305 
    try:
483 rajveer 7306 
      result.success = self._handler.getOrder(args.id)
94 ashish 7307 
    except TransactionServiceException, ex:
7308 
      result.ex = ex
483 rajveer 7309 
    oprot.writeMessageBegin("getOrder", TMessageType.REPLY, seqid)
94 ashish 7310 
    result.write(oprot)
7311 
    oprot.writeMessageEnd()
7312 
    oprot.trans.flush()
7313 
 
483 rajveer 7314 
  def process_getLineItemsForOrder(self, seqid, iprot, oprot):
7315 
    args = getLineItemsForOrder_args()
94 ashish 7316 
    args.read(iprot)
7317 
    iprot.readMessageEnd()
483 rajveer 7318 
    result = getLineItemsForOrder_result()
94 ashish 7319 
    try:
483 rajveer 7320 
      result.success = self._handler.getLineItemsForOrder(args.orderId)
94 ashish 7321 
    except TransactionServiceException, ex:
7322 
      result.ex = ex
483 rajveer 7323 
    oprot.writeMessageBegin("getLineItemsForOrder", TMessageType.REPLY, seqid)
94 ashish 7324 
    result.write(oprot)
7325 
    oprot.writeMessageEnd()
7326 
    oprot.trans.flush()
7327 
 
4999 phani.kuma 7328 
  def process_getOrderList(self, seqid, iprot, oprot):
7329 
    args = getOrderList_args()
7330 
    args.read(iprot)
7331 
    iprot.readMessageEnd()
7332 
    result = getOrderList_result()
7333 
    result.success = self._handler.getOrderList(args.order_ids)
7334 
    oprot.writeMessageBegin("getOrderList", TMessageType.REPLY, seqid)
7335 
    result.write(oprot)
7336 
    oprot.writeMessageEnd()
7337 
    oprot.trans.flush()
7338 
 
5386 phani.kuma 7339 
  def process_getOrderListForVendor(self, seqid, iprot, oprot):
7340 
    args = getOrderListForVendor_args()
7341 
    args.read(iprot)
7342 
    iprot.readMessageEnd()
7343 
    result = getOrderListForVendor_result()
7344 
    result.success = self._handler.getOrderListForVendor(args.order_ids, args.vendorId)
7345 
    oprot.writeMessageBegin("getOrderListForVendor", TMessageType.REPLY, seqid)
7346 
    result.write(oprot)
7347 
    oprot.writeMessageEnd()
7348 
    oprot.trans.flush()
7349 
 
1528 ankur.sing 7350 
  def process_getOrderForCustomer(self, seqid, iprot, oprot):
7351 
    args = getOrderForCustomer_args()
7352 
    args.read(iprot)
7353 
    iprot.readMessageEnd()
7354 
    result = getOrderForCustomer_result()
7355 
    try:
7356 
      result.success = self._handler.getOrderForCustomer(args.orderId, args.customerId)
7357 
    except TransactionServiceException, ex:
7358 
      result.ex = ex
7359 
    oprot.writeMessageBegin("getOrderForCustomer", TMessageType.REPLY, seqid)
7360 
    result.write(oprot)
7361 
    oprot.writeMessageEnd()
7362 
    oprot.trans.flush()
7363 
 
3064 chandransh 7364 
  def process_getAlerts(self, seqid, iprot, oprot):
7365 
    args = getAlerts_args()
7366 
    args.read(iprot)
7367 
    iprot.readMessageEnd()
7368 
    result = getAlerts_result()
4444 rajveer 7369 
    result.success = self._handler.getAlerts(args.type, args.warehouseId, args.status, args.timestamp)
3064 chandransh 7370 
    oprot.writeMessageBegin("getAlerts", TMessageType.REPLY, seqid)
7371 
    result.write(oprot)
7372 
    oprot.writeMessageEnd()
7373 
    oprot.trans.flush()
7374 
 
4394 rajveer 7375 
  def process_addAlert(self, seqid, iprot, oprot):
7376 
    args = addAlert_args()
3064 chandransh 7377 
    args.read(iprot)
7378 
    iprot.readMessageEnd()
4394 rajveer 7379 
    result = addAlert_result()
4444 rajveer 7380 
    self._handler.addAlert(args.type, args.warehouseId, args.description)
4394 rajveer 7381 
    oprot.writeMessageBegin("addAlert", TMessageType.REPLY, seqid)
3064 chandransh 7382 
    result.write(oprot)
7383 
    oprot.writeMessageEnd()
7384 
    oprot.trans.flush()
7385 
 
4444 rajveer 7386 
  def process_markAlertsAsSeen(self, seqid, iprot, oprot):
7387 
    args = markAlertsAsSeen_args()
7388 
    args.read(iprot)
7389 
    iprot.readMessageEnd()
7390 
    result = markAlertsAsSeen_result()
7391 
    self._handler.markAlertsAsSeen(args.warehouseId)
7392 
    oprot.writeMessageBegin("markAlertsAsSeen", TMessageType.REPLY, seqid)
7393 
    result.write(oprot)
7394 
    oprot.writeMessageEnd()
7395 
    oprot.trans.flush()
7396 
 
3064 chandransh 7397 
  def process_getValidOrderCount(self, seqid, iprot, oprot):
7398 
    args = getValidOrderCount_args()
7399 
    args.read(iprot)
7400 
    iprot.readMessageEnd()
7401 
    result = getValidOrderCount_result()
7402 
    result.success = self._handler.getValidOrderCount()
7403 
    oprot.writeMessageBegin("getValidOrderCount", TMessageType.REPLY, seqid)
7404 
    result.write(oprot)
7405 
    oprot.writeMessageEnd()
7406 
    oprot.trans.flush()
7407 
 
7408 
  def process_getNoOfCustomersWithSuccessfulTransaction(self, seqid, iprot, oprot):
7409 
    args = getNoOfCustomersWithSuccessfulTransaction_args()
7410 
    args.read(iprot)
7411 
    iprot.readMessageEnd()
7412 
    result = getNoOfCustomersWithSuccessfulTransaction_result()
7413 
    result.success = self._handler.getNoOfCustomersWithSuccessfulTransaction()
7414 
    oprot.writeMessageBegin("getNoOfCustomersWithSuccessfulTransaction", TMessageType.REPLY, seqid)
7415 
    result.write(oprot)
7416 
    oprot.writeMessageEnd()
7417 
    oprot.trans.flush()
7418 
 
7419 
  def process_getValidOrdersAmountRange(self, seqid, iprot, oprot):
7420 
    args = getValidOrdersAmountRange_args()
7421 
    args.read(iprot)
7422 
    iprot.readMessageEnd()
7423 
    result = getValidOrdersAmountRange_result()
7424 
    result.success = self._handler.getValidOrdersAmountRange()
7425 
    oprot.writeMessageBegin("getValidOrdersAmountRange", TMessageType.REPLY, seqid)
7426 
    result.write(oprot)
7427 
    oprot.writeMessageEnd()
7428 
    oprot.trans.flush()
7429 
 
7430 
  def process_getValidOrders(self, seqid, iprot, oprot):
7431 
    args = getValidOrders_args()
7432 
    args.read(iprot)
7433 
    iprot.readMessageEnd()
7434 
    result = getValidOrders_result()
5874 rajveer 7435 
    result.success = self._handler.getValidOrders(args.limit, args.onlyStore)
3064 chandransh 7436 
    oprot.writeMessageBegin("getValidOrders", TMessageType.REPLY, seqid)
7437 
    result.write(oprot)
7438 
    oprot.writeMessageEnd()
7439 
    oprot.trans.flush()
7440 
 
1220 chandransh 7441 
  def process_batchOrders(self, seqid, iprot, oprot):
7442 
    args = batchOrders_args()
7443 
    args.read(iprot)
7444 
    iprot.readMessageEnd()
7445 
    result = batchOrders_result()
7446 
    try:
7447 
      result.success = self._handler.batchOrders(args.warehouseId)
7448 
    except TransactionServiceException, ex:
7449 
      result.ex = ex
7450 
    oprot.writeMessageBegin("batchOrders", TMessageType.REPLY, seqid)
7451 
    result.write(oprot)
7452 
    oprot.writeMessageEnd()
7453 
    oprot.trans.flush()
7454 
 
1208 chandransh 7455 
  def process_markOrderAsOutOfStock(self, seqid, iprot, oprot):
7456 
    args = markOrderAsOutOfStock_args()
7457 
    args.read(iprot)
7458 
    iprot.readMessageEnd()
7459 
    result = markOrderAsOutOfStock_result()
7460 
    try:
7461 
      result.success = self._handler.markOrderAsOutOfStock(args.orderId)
7462 
    except TransactionServiceException, ex:
7463 
      result.ex = ex
7464 
    oprot.writeMessageBegin("markOrderAsOutOfStock", TMessageType.REPLY, seqid)
7465 
    result.write(oprot)
7466 
    oprot.writeMessageEnd()
7467 
    oprot.trans.flush()
7468 
 
3064 chandransh 7469 
  def process_verifyOrder(self, seqid, iprot, oprot):
7470 
    args = verifyOrder_args()
759 chandransh 7471 
    args.read(iprot)
7472 
    iprot.readMessageEnd()
3064 chandransh 7473 
    result = verifyOrder_result()
759 chandransh 7474 
    try:
3064 chandransh 7475 
      result.success = self._handler.verifyOrder(args.orderId)
759 chandransh 7476 
    except TransactionServiceException, ex:
7477 
      result.ex = ex
3064 chandransh 7478 
    oprot.writeMessageBegin("verifyOrder", TMessageType.REPLY, seqid)
759 chandransh 7479 
    result.write(oprot)
7480 
    oprot.writeMessageEnd()
7481 
    oprot.trans.flush()
7482 
 
3064 chandransh 7483 
  def process_acceptOrder(self, seqid, iprot, oprot):
7484 
    args = acceptOrder_args()
1113 chandransh 7485 
    args.read(iprot)
7486 
    iprot.readMessageEnd()
3064 chandransh 7487 
    result = acceptOrder_result()
1113 chandransh 7488 
    try:
3064 chandransh 7489 
      result.success = self._handler.acceptOrder(args.orderId)
1113 chandransh 7490 
    except TransactionServiceException, ex:
7491 
      result.ex = ex
3064 chandransh 7492 
    oprot.writeMessageBegin("acceptOrder", TMessageType.REPLY, seqid)
1113 chandransh 7493 
    result.write(oprot)
7494 
    oprot.writeMessageEnd()
7495 
    oprot.trans.flush()
7496 
 
3064 chandransh 7497 
  def process_addBillingDetails(self, seqid, iprot, oprot):
7498 
    args = addBillingDetails_args()
1135 chandransh 7499 
    args.read(iprot)
7500 
    iprot.readMessageEnd()
3064 chandransh 7501 
    result = addBillingDetails_result()
1135 chandransh 7502 
    try:
5110 mandeep.dh 7503 
      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 7504 
    except TransactionServiceException, ex:
7505 
      result.ex = ex
3064 chandransh 7506 
    oprot.writeMessageBegin("addBillingDetails", TMessageType.REPLY, seqid)
1135 chandransh 7507 
    result.write(oprot)
7508 
    oprot.writeMessageEnd()
7509 
    oprot.trans.flush()
7510 
 
4579 rajveer 7511 
  def process_addInvoiceNumber(self, seqid, iprot, oprot):
7512 
    args = addInvoiceNumber_args()
7513 
    args.read(iprot)
7514 
    iprot.readMessageEnd()
7515 
    result = addInvoiceNumber_result()
7516 
    try:
6756 amar.kumar 7517 
      self._handler.addInvoiceNumber(args.orderId, args.invoiceNumber, args.color, args.serialNumber, args.itemNumber)
4579 rajveer 7518 
    except TransactionServiceException, ex:
7519 
      result.ex = ex
7520 
    oprot.writeMessageBegin("addInvoiceNumber", TMessageType.REPLY, seqid)
7521 
    result.write(oprot)
7522 
    oprot.writeMessageEnd()
7523 
    oprot.trans.flush()
7524 
 
4410 rajveer 7525 
  def process_markOrdersAsShippedFromWarehouse(self, seqid, iprot, oprot):
7526 
    args = markOrdersAsShippedFromWarehouse_args()
7527 
    args.read(iprot)
7528 
    iprot.readMessageEnd()
7529 
    result = markOrdersAsShippedFromWarehouse_result()
7530 
    try:
4789 rajveer 7531 
      result.success = self._handler.markOrdersAsShippedFromWarehouse(args.warehouseId, args.providerId, args.cod, args.orderIds)
4410 rajveer 7532 
    except TransactionServiceException, ex:
7533 
      result.ex = ex
7534 
    oprot.writeMessageBegin("markOrdersAsShippedFromWarehouse", TMessageType.REPLY, seqid)
7535 
    result.write(oprot)
7536 
    oprot.writeMessageEnd()
7537 
    oprot.trans.flush()
7538 
 
5676 rajveer 7539 
  def process_markOrdersAsReturnedFromStore(self, seqid, iprot, oprot):
7540 
    args = markOrdersAsReturnedFromStore_args()
7541 
    args.read(iprot)
7542 
    iprot.readMessageEnd()
7543 
    result = markOrdersAsReturnedFromStore_result()
7544 
    try:
5713 rajveer 7545 
      result.success = self._handler.markOrdersAsReturnedFromStore(args.providerId, args.orderIds, args.awbs)
5676 rajveer 7546 
    except TransactionServiceException, ex:
7547 
      result.ex = ex
7548 
    oprot.writeMessageBegin("markOrdersAsReturnedFromStore", TMessageType.REPLY, seqid)
7549 
    result.write(oprot)
7550 
    oprot.writeMessageEnd()
7551 
    oprot.trans.flush()
7552 
 
3064 chandransh 7553 
  def process_markOrdersAsPickedUp(self, seqid, iprot, oprot):
7554 
    args = markOrdersAsPickedUp_args()
304 ashish 7555 
    args.read(iprot)
7556 
    iprot.readMessageEnd()
3064 chandransh 7557 
    result = markOrdersAsPickedUp_result()
7558 
    try:
4910 phani.kuma 7559 
      self._handler.markOrdersAsPickedUp(args.providerId, args.pickupDetails)
3064 chandransh 7560 
    except TransactionServiceException, ex:
7561 
      result.ex = ex
7562 
    oprot.writeMessageBegin("markOrdersAsPickedUp", TMessageType.REPLY, seqid)
304 ashish 7563 
    result.write(oprot)
7564 
    oprot.writeMessageEnd()
7565 
    oprot.trans.flush()
94 ashish 7566 
 
4910 phani.kuma 7567 
  def process_getOrdersNotPickedUp(self, seqid, iprot, oprot):
7568 
    args = getOrdersNotPickedUp_args()
7569 
    args.read(iprot)
7570 
    iprot.readMessageEnd()
7571 
    result = getOrdersNotPickedUp_result()
7572 
    result.success = self._handler.getOrdersNotPickedUp(args.providerId)
7573 
    oprot.writeMessageBegin("getOrdersNotPickedUp", TMessageType.REPLY, seqid)
7574 
    result.write(oprot)
7575 
    oprot.writeMessageEnd()
7576 
    oprot.trans.flush()
7577 
 
3064 chandransh 7578 
  def process_markOrdersAsDelivered(self, seqid, iprot, oprot):
7579 
    args = markOrdersAsDelivered_args()
304 ashish 7580 
    args.read(iprot)
7581 
    iprot.readMessageEnd()
3064 chandransh 7582 
    result = markOrdersAsDelivered_result()
7583 
    try:
7584 
      self._handler.markOrdersAsDelivered(args.providerId, args.deliveredOrders)
7585 
    except TransactionServiceException, ex:
7586 
      result.ex = ex
7587 
    oprot.writeMessageBegin("markOrdersAsDelivered", TMessageType.REPLY, seqid)
304 ashish 7588 
    result.write(oprot)
7589 
    oprot.writeMessageEnd()
7590 
    oprot.trans.flush()
7591 
 
4910 phani.kuma 7592 
  def process_markAsRTOrders(self, seqid, iprot, oprot):
7593 
    args = markAsRTOrders_args()
1596 ankur.sing 7594 
    args.read(iprot)
7595 
    iprot.readMessageEnd()
4910 phani.kuma 7596 
    result = markAsRTOrders_result()
3064 chandransh 7597 
    try:
4910 phani.kuma 7598 
      self._handler.markAsRTOrders(args.providerId, args.returnedOrders)
3064 chandransh 7599 
    except TransactionServiceException, ex:
7600 
      result.ex = ex
4910 phani.kuma 7601 
    oprot.writeMessageBegin("markAsRTOrders", TMessageType.REPLY, seqid)
1596 ankur.sing 7602 
    result.write(oprot)
7603 
    oprot.writeMessageEnd()
7604 
    oprot.trans.flush()
304 ashish 7605 
 
4910 phani.kuma 7606 
  def process_getRTOrders(self, seqid, iprot, oprot):
7607 
    args = getRTOrders_args()
7608 
    args.read(iprot)
7609 
    iprot.readMessageEnd()
7610 
    result = getRTOrders_result()
7611 
    result.success = self._handler.getRTOrders(args.providerId)
7612 
    oprot.writeMessageBegin("getRTOrders", TMessageType.REPLY, seqid)
7613 
    result.write(oprot)
7614 
    oprot.writeMessageEnd()
7615 
    oprot.trans.flush()
7616 
 
3064 chandransh 7617 
  def process_updateNonDeliveryReason(self, seqid, iprot, oprot):
7618 
    args = updateNonDeliveryReason_args()
1627 ankur.sing 7619 
    args.read(iprot)
7620 
    iprot.readMessageEnd()
3064 chandransh 7621 
    result = updateNonDeliveryReason_result()
7622 
    try:
4910 phani.kuma 7623 
      self._handler.updateNonDeliveryReason(args.providerId, args.undeliveredOrders)
3064 chandransh 7624 
    except TransactionServiceException, ex:
7625 
      result.ex = ex
7626 
    oprot.writeMessageBegin("updateNonDeliveryReason", TMessageType.REPLY, seqid)
1627 ankur.sing 7627 
    result.write(oprot)
7628 
    oprot.writeMessageEnd()
7629 
    oprot.trans.flush()
1596 ankur.sing 7630 
 
4910 phani.kuma 7631 
  def process_getNonDeliveredOrdersbyCourier(self, seqid, iprot, oprot):
7632 
    args = getNonDeliveredOrdersbyCourier_args()
7633 
    args.read(iprot)
7634 
    iprot.readMessageEnd()
7635 
    result = getNonDeliveredOrdersbyCourier_result()
7636 
    result.success = self._handler.getNonDeliveredOrdersbyCourier(args.providerId)
7637 
    oprot.writeMessageBegin("getNonDeliveredOrdersbyCourier", TMessageType.REPLY, seqid)
7638 
    result.write(oprot)
7639 
    oprot.writeMessageEnd()
7640 
    oprot.trans.flush()
7641 
 
7642 
  def process_markOrdersAsLocalConnected(self, seqid, iprot, oprot):
7643 
    args = markOrdersAsLocalConnected_args()
7644 
    args.read(iprot)
7645 
    iprot.readMessageEnd()
7646 
    result = markOrdersAsLocalConnected_result()
7647 
    try:
7648 
      self._handler.markOrdersAsLocalConnected(args.providerId, args.local_connected_orders)
7649 
    except TransactionServiceException, ex:
7650 
      result.ex = ex
7651 
    oprot.writeMessageBegin("markOrdersAsLocalConnected", TMessageType.REPLY, seqid)
7652 
    result.write(oprot)
7653 
    oprot.writeMessageEnd()
7654 
    oprot.trans.flush()
7655 
 
7656 
  def process_getOrdersNotLocalConnected(self, seqid, iprot, oprot):
7657 
    args = getOrdersNotLocalConnected_args()
7658 
    args.read(iprot)
7659 
    iprot.readMessageEnd()
7660 
    result = getOrdersNotLocalConnected_result()
7661 
    result.success = self._handler.getOrdersNotLocalConnected(args.providerId)
7662 
    oprot.writeMessageBegin("getOrdersNotLocalConnected", TMessageType.REPLY, seqid)
7663 
    result.write(oprot)
7664 
    oprot.writeMessageEnd()
7665 
    oprot.trans.flush()
7666 
 
7667 
  def process_markOrdersAsDestinationCityReached(self, seqid, iprot, oprot):
7668 
    args = markOrdersAsDestinationCityReached_args()
7669 
    args.read(iprot)
7670 
    iprot.readMessageEnd()
7671 
    result = markOrdersAsDestinationCityReached_result()
7672 
    try:
7673 
      self._handler.markOrdersAsDestinationCityReached(args.providerId, args.destination_city_reached_orders)
7674 
    except TransactionServiceException, ex:
7675 
      result.ex = ex
7676 
    oprot.writeMessageBegin("markOrdersAsDestinationCityReached", TMessageType.REPLY, seqid)
7677 
    result.write(oprot)
7678 
    oprot.writeMessageEnd()
7679 
    oprot.trans.flush()
7680 
 
7681 
  def process_markOrdersAsFirstDeliveryAttempted(self, seqid, iprot, oprot):
7682 
    args = markOrdersAsFirstDeliveryAttempted_args()
7683 
    args.read(iprot)
7684 
    iprot.readMessageEnd()
7685 
    result = markOrdersAsFirstDeliveryAttempted_result()
7686 
    try:
7687 
      self._handler.markOrdersAsFirstDeliveryAttempted(args.providerId, args.first_atdl_orders)
7688 
    except TransactionServiceException, ex:
7689 
      result.ex = ex
7690 
    oprot.writeMessageBegin("markOrdersAsFirstDeliveryAttempted", TMessageType.REPLY, seqid)
7691 
    result.write(oprot)
7692 
    oprot.writeMessageEnd()
7693 
    oprot.trans.flush()
7694 
 
3064 chandransh 7695 
  def process_getUndeliveredOrders(self, seqid, iprot, oprot):
7696 
    args = getUndeliveredOrders_args()
1627 ankur.sing 7697 
    args.read(iprot)
7698 
    iprot.readMessageEnd()
3064 chandransh 7699 
    result = getUndeliveredOrders_result()
7700 
    result.success = self._handler.getUndeliveredOrders(args.providerId, args.warehouseId)
7701 
    oprot.writeMessageBegin("getUndeliveredOrders", TMessageType.REPLY, seqid)
1627 ankur.sing 7702 
    result.write(oprot)
7703 
    oprot.writeMessageEnd()
7704 
    oprot.trans.flush()
7705 
 
4783 phani.kuma 7706 
  def process_getUndeliveredOrdersExpectedDeliveryDateNotMet(self, seqid, iprot, oprot):
7707 
    args = getUndeliveredOrdersExpectedDeliveryDateNotMet_args()
7708 
    args.read(iprot)
7709 
    iprot.readMessageEnd()
7710 
    result = getUndeliveredOrdersExpectedDeliveryDateNotMet_result()
7711 
    result.success = self._handler.getUndeliveredOrdersExpectedDeliveryDateNotMet()
7712 
    oprot.writeMessageBegin("getUndeliveredOrdersExpectedDeliveryDateNotMet", TMessageType.REPLY, seqid)
7713 
    result.write(oprot)
7714 
    oprot.writeMessageEnd()
7715 
    oprot.trans.flush()
7716 
 
2536 chandransh 7717 
  def process_toggleDOAFlag(self, seqid, iprot, oprot):
7718 
    args = toggleDOAFlag_args()
7719 
    args.read(iprot)
7720 
    iprot.readMessageEnd()
7721 
    result = toggleDOAFlag_result()
7722 
    try:
7723 
      result.success = self._handler.toggleDOAFlag(args.orderId)
7724 
    except TransactionServiceException, ex:
7725 
      result.ex = ex
7726 
    oprot.writeMessageBegin("toggleDOAFlag", TMessageType.REPLY, seqid)
7727 
    result.write(oprot)
7728 
    oprot.writeMessageEnd()
7729 
    oprot.trans.flush()
1886 ankur.sing 7730 
 
4712 rajveer 7731 
  def process_markOrderAsDelivered(self, seqid, iprot, oprot):
7732 
    args = markOrderAsDelivered_args()
7733 
    args.read(iprot)
7734 
    iprot.readMessageEnd()
7735 
    result = markOrderAsDelivered_result()
7736 
    try:
7737 
      self._handler.markOrderAsDelivered(args.orderId, args.deliveryTimestamp, args.receiver)
7738 
    except TransactionServiceException, ex:
7739 
      result.ex = ex
7740 
    oprot.writeMessageBegin("markOrderAsDelivered", TMessageType.REPLY, seqid)
7741 
    result.write(oprot)
7742 
    oprot.writeMessageEnd()
7743 
    oprot.trans.flush()
7744 
 
5553 rajveer 7745 
  def process_markOrderAsReceivedAtStore(self, seqid, iprot, oprot):
7746 
    args = markOrderAsReceivedAtStore_args()
7747 
    args.read(iprot)
7748 
    iprot.readMessageEnd()
7749 
    result = markOrderAsReceivedAtStore_result()
7750 
    try:
7751 
      self._handler.markOrderAsReceivedAtStore(args.orderId, args.deliveryTimestamp)
7752 
    except TransactionServiceException, ex:
7753 
      result.ex = ex
7754 
    oprot.writeMessageBegin("markOrderAsReceivedAtStore", TMessageType.REPLY, seqid)
7755 
    result.write(oprot)
7756 
    oprot.writeMessageEnd()
7757 
    oprot.trans.flush()
7758 
 
4454 rajveer 7759 
  def process_markOrderDoaRequestReceived(self, seqid, iprot, oprot):
7760 
    args = markOrderDoaRequestReceived_args()
7761 
    args.read(iprot)
7762 
    iprot.readMessageEnd()
7763 
    result = markOrderDoaRequestReceived_result()
7764 
    try:
7765 
      result.success = self._handler.markOrderDoaRequestReceived(args.orderId)
7766 
    except TransactionServiceException, ex:
7767 
      result.ex = ex
7768 
    oprot.writeMessageBegin("markOrderDoaRequestReceived", TMessageType.REPLY, seqid)
7769 
    result.write(oprot)
7770 
    oprot.writeMessageEnd()
7771 
    oprot.trans.flush()
7772 
 
7773 
  def process_markOrderDoaRequestAuthorized(self, seqid, iprot, oprot):
7774 
    args = markOrderDoaRequestAuthorized_args()
7775 
    args.read(iprot)
7776 
    iprot.readMessageEnd()
7777 
    result = markOrderDoaRequestAuthorized_result()
7778 
    try:
7779 
      result.success = self._handler.markOrderDoaRequestAuthorized(args.orderId, args.isAuthorized)
7780 
    except TransactionServiceException, ex:
7781 
      result.ex = ex
7782 
    oprot.writeMessageBegin("markOrderDoaRequestAuthorized", TMessageType.REPLY, seqid)
7783 
    result.write(oprot)
7784 
    oprot.writeMessageEnd()
7785 
    oprot.trans.flush()
7786 
 
4488 rajveer 7787 
  def process_markOrderReturnRequestReceived(self, seqid, iprot, oprot):
7788 
    args = markOrderReturnRequestReceived_args()
7789 
    args.read(iprot)
7790 
    iprot.readMessageEnd()
7791 
    result = markOrderReturnRequestReceived_result()
7792 
    try:
7793 
      result.success = self._handler.markOrderReturnRequestReceived(args.orderId)
7794 
    except TransactionServiceException, ex:
7795 
      result.ex = ex
7796 
    oprot.writeMessageBegin("markOrderReturnRequestReceived", TMessageType.REPLY, seqid)
7797 
    result.write(oprot)
7798 
    oprot.writeMessageEnd()
7799 
    oprot.trans.flush()
7800 
 
7801 
  def process_markOrderReturnRequestAuthorized(self, seqid, iprot, oprot):
7802 
    args = markOrderReturnRequestAuthorized_args()
7803 
    args.read(iprot)
7804 
    iprot.readMessageEnd()
7805 
    result = markOrderReturnRequestAuthorized_result()
7806 
    try:
7807 
      result.success = self._handler.markOrderReturnRequestAuthorized(args.orderId, args.isAuthorized)
7808 
    except TransactionServiceException, ex:
7809 
      result.ex = ex
7810 
    oprot.writeMessageBegin("markOrderReturnRequestAuthorized", TMessageType.REPLY, seqid)
7811 
    result.write(oprot)
7812 
    oprot.writeMessageEnd()
7813 
    oprot.trans.flush()
7814 
 
2536 chandransh 7815 
  def process_requestPickupNumber(self, seqid, iprot, oprot):
7816 
    args = requestPickupNumber_args()
7817 
    args.read(iprot)
7818 
    iprot.readMessageEnd()
7819 
    result = requestPickupNumber_result()
7820 
    try:
4579 rajveer 7821 
      result.success = self._handler.requestPickupNumber(args.orderId, args.providerId)
2536 chandransh 7822 
    except TransactionServiceException, ex:
7823 
      result.ex = ex
7824 
    oprot.writeMessageBegin("requestPickupNumber", TMessageType.REPLY, seqid)
7825 
    result.write(oprot)
7826 
    oprot.writeMessageEnd()
7827 
    oprot.trans.flush()
7828 
 
7829 
  def process_authorizePickup(self, seqid, iprot, oprot):
7830 
    args = authorizePickup_args()
7831 
    args.read(iprot)
7832 
    iprot.readMessageEnd()
7833 
    result = authorizePickup_result()
7834 
    try:
4602 rajveer 7835 
      result.success = self._handler.authorizePickup(args.orderId, args.pickupNumber, args.providerId)
2536 chandransh 7836 
    except TransactionServiceException, ex:
7837 
      result.ex = ex
7838 
    oprot.writeMessageBegin("authorizePickup", TMessageType.REPLY, seqid)
7839 
    result.write(oprot)
7840 
    oprot.writeMessageEnd()
7841 
    oprot.trans.flush()
7842 
 
2764 chandransh 7843 
  def process_markDoasAsPickedUp(self, seqid, iprot, oprot):
7844 
    args = markDoasAsPickedUp_args()
7845 
    args.read(iprot)
7846 
    iprot.readMessageEnd()
7847 
    result = markDoasAsPickedUp_result()
4910 phani.kuma 7848 
    self._handler.markDoasAsPickedUp(args.providerId, args.pickupDetails)
2764 chandransh 7849 
    oprot.writeMessageBegin("markDoasAsPickedUp", TMessageType.REPLY, seqid)
7850 
    result.write(oprot)
7851 
    oprot.writeMessageEnd()
7852 
    oprot.trans.flush()
7853 
 
4910 phani.kuma 7854 
  def process_getDoasNotPickedUp(self, seqid, iprot, oprot):
7855 
    args = getDoasNotPickedUp_args()
7856 
    args.read(iprot)
7857 
    iprot.readMessageEnd()
7858 
    result = getDoasNotPickedUp_result()
7859 
    result.success = self._handler.getDoasNotPickedUp(args.providerId)
7860 
    oprot.writeMessageBegin("getDoasNotPickedUp", TMessageType.REPLY, seqid)
7861 
    result.write(oprot)
7862 
    oprot.writeMessageEnd()
7863 
    oprot.trans.flush()
7864 
 
4741 phani.kuma 7865 
  def process_markReturnOrdersAsPickedUp(self, seqid, iprot, oprot):
7866 
    args = markReturnOrdersAsPickedUp_args()
7867 
    args.read(iprot)
7868 
    iprot.readMessageEnd()
7869 
    result = markReturnOrdersAsPickedUp_result()
4910 phani.kuma 7870 
    self._handler.markReturnOrdersAsPickedUp(args.providerId, args.pickupDetails)
4741 phani.kuma 7871 
    oprot.writeMessageBegin("markReturnOrdersAsPickedUp", TMessageType.REPLY, seqid)
7872 
    result.write(oprot)
7873 
    oprot.writeMessageEnd()
7874 
    oprot.trans.flush()
7875 
 
4910 phani.kuma 7876 
  def process_getReturnOrdersNotPickedUp(self, seqid, iprot, oprot):
7877 
    args = getReturnOrdersNotPickedUp_args()
7878 
    args.read(iprot)
7879 
    iprot.readMessageEnd()
7880 
    result = getReturnOrdersNotPickedUp_result()
7881 
    result.success = self._handler.getReturnOrdersNotPickedUp(args.providerId)
7882 
    oprot.writeMessageBegin("getReturnOrdersNotPickedUp", TMessageType.REPLY, seqid)
7883 
    result.write(oprot)
7884 
    oprot.writeMessageEnd()
7885 
    oprot.trans.flush()
7886 
 
2616 chandransh 7887 
  def process_receiveReturn(self, seqid, iprot, oprot):
7888 
    args = receiveReturn_args()
2591 chandransh 7889 
    args.read(iprot)
7890 
    iprot.readMessageEnd()
2616 chandransh 7891 
    result = receiveReturn_result()
2591 chandransh 7892 
    try:
4479 rajveer 7893 
      result.success = self._handler.receiveReturn(args.orderId, args.receiveCondition)
2591 chandransh 7894 
    except TransactionServiceException, ex:
7895 
      result.ex = ex
2616 chandransh 7896 
    oprot.writeMessageBegin("receiveReturn", TMessageType.REPLY, seqid)
2591 chandransh 7897 
    result.write(oprot)
7898 
    oprot.writeMessageEnd()
7899 
    oprot.trans.flush()
2536 chandransh 7900 
 
2591 chandransh 7901 
  def process_validateDoa(self, seqid, iprot, oprot):
7902 
    args = validateDoa_args()
7903 
    args.read(iprot)
7904 
    iprot.readMessageEnd()
7905 
    result = validateDoa_result()
7906 
    try:
7907 
      result.success = self._handler.validateDoa(args.orderId, args.isValid)
7908 
    except TransactionServiceException, ex:
7909 
      result.ex = ex
7910 
    oprot.writeMessageBegin("validateDoa", TMessageType.REPLY, seqid)
7911 
    result.write(oprot)
7912 
    oprot.writeMessageEnd()
7913 
    oprot.trans.flush()
7914 
 
4495 rajveer 7915 
  def process_validateReturnProduct(self, seqid, iprot, oprot):
7916 
    args = validateReturnProduct_args()
7917 
    args.read(iprot)
7918 
    iprot.readMessageEnd()
7919 
    result = validateReturnProduct_result()
7920 
    try:
7921 
      result.success = self._handler.validateReturnProduct(args.orderId, args.isUsable)
7922 
    except TransactionServiceException, ex:
7923 
      result.ex = ex
7924 
    oprot.writeMessageBegin("validateReturnProduct", TMessageType.REPLY, seqid)
7925 
    result.write(oprot)
7926 
    oprot.writeMessageEnd()
7927 
    oprot.trans.flush()
7928 
 
2616 chandransh 7929 
  def process_reshipOrder(self, seqid, iprot, oprot):
7930 
    args = reshipOrder_args()
7931 
    args.read(iprot)
7932 
    iprot.readMessageEnd()
7933 
    result = reshipOrder_result()
7934 
    try:
7935 
      result.success = self._handler.reshipOrder(args.orderId)
7936 
    except TransactionServiceException, ex:
7937 
      result.ex = ex
7938 
    oprot.writeMessageBegin("reshipOrder", TMessageType.REPLY, seqid)
7939 
    result.write(oprot)
7940 
    oprot.writeMessageEnd()
7941 
    oprot.trans.flush()
2591 chandransh 7942 
 
2616 chandransh 7943 
  def process_refundOrder(self, seqid, iprot, oprot):
7944 
    args = refundOrder_args()
7945 
    args.read(iprot)
7946 
    iprot.readMessageEnd()
7947 
    result = refundOrder_result()
7948 
    try:
3226 chandransh 7949 
      result.success = self._handler.refundOrder(args.orderId, args.refundedBy, args.reason)
2616 chandransh 7950 
    except TransactionServiceException, ex:
7951 
      result.ex = ex
7952 
    oprot.writeMessageBegin("refundOrder", TMessageType.REPLY, seqid)
7953 
    result.write(oprot)
7954 
    oprot.writeMessageEnd()
7955 
    oprot.trans.flush()
7956 
 
2690 chandransh 7957 
  def process_getReturnOrders(self, seqid, iprot, oprot):
7958 
    args = getReturnOrders_args()
7959 
    args.read(iprot)
7960 
    iprot.readMessageEnd()
7961 
    result = getReturnOrders_result()
7962 
    result.success = self._handler.getReturnOrders(args.warehouseId, args.fromDate, args.toDate)
7963 
    oprot.writeMessageBegin("getReturnOrders", TMessageType.REPLY, seqid)
7964 
    result.write(oprot)
7965 
    oprot.writeMessageEnd()
7966 
    oprot.trans.flush()
2616 chandransh 7967 
 
5481 phani.kuma 7968 
  def process_getAllReturnOrders(self, seqid, iprot, oprot):
7969 
    args = getAllReturnOrders_args()
7970 
    args.read(iprot)
7971 
    iprot.readMessageEnd()
7972 
    result = getAllReturnOrders_result()
7973 
    result.success = self._handler.getAllReturnOrders(args.onlyNotProcessed, args.fromDate, args.toDate)
7974 
    oprot.writeMessageBegin("getAllReturnOrders", TMessageType.REPLY, seqid)
7975 
    result.write(oprot)
7976 
    oprot.writeMessageEnd()
7977 
    oprot.trans.flush()
7978 
 
2700 chandransh 7979 
  def process_getReturnOrder(self, seqid, iprot, oprot):
7980 
    args = getReturnOrder_args()
7981 
    args.read(iprot)
7982 
    iprot.readMessageEnd()
7983 
    result = getReturnOrder_result()
7984 
    try:
7985 
      result.success = self._handler.getReturnOrder(args.id)
7986 
    except TransactionServiceException, ex:
7987 
      result.ex = ex
7988 
    oprot.writeMessageBegin("getReturnOrder", TMessageType.REPLY, seqid)
7989 
    result.write(oprot)
7990 
    oprot.writeMessageEnd()
7991 
    oprot.trans.flush()
7992 
 
2690 chandransh 7993 
  def process_processReturn(self, seqid, iprot, oprot):
7994 
    args = processReturn_args()
7995 
    args.read(iprot)
7996 
    iprot.readMessageEnd()
7997 
    result = processReturn_result()
7998 
    try:
7999 
      self._handler.processReturn(args.returnOrderId)
8000 
    except TransactionServiceException, ex:
8001 
      result.ex = ex
8002 
    oprot.writeMessageBegin("processReturn", TMessageType.REPLY, seqid)
8003 
    result.write(oprot)
8004 
    oprot.writeMessageEnd()
8005 
    oprot.trans.flush()
8006 
 
3451 chandransh 8007 
  def process_updateWeight(self, seqid, iprot, oprot):
8008 
    args = updateWeight_args()
8009 
    args.read(iprot)
8010 
    iprot.readMessageEnd()
8011 
    result = updateWeight_result()
8012 
    try:
8013 
      result.success = self._handler.updateWeight(args.orderId, args.weight)
8014 
    except TransactionServiceException, ex:
8015 
      result.ex = ex
8016 
    oprot.writeMessageBegin("updateWeight", TMessageType.REPLY, seqid)
8017 
    result.write(oprot)
8018 
    oprot.writeMessageEnd()
8019 
    oprot.trans.flush()
2819 chandransh 8020 
 
3469 chandransh 8021 
  def process_changeItem(self, seqid, iprot, oprot):
8022 
    args = changeItem_args()
8023 
    args.read(iprot)
8024 
    iprot.readMessageEnd()
8025 
    result = changeItem_result()
8026 
    try:
8027 
      result.success = self._handler.changeItem(args.orderId, args.itemId)
8028 
    except TransactionServiceException, ex:
8029 
      result.ex = ex
8030 
    oprot.writeMessageBegin("changeItem", TMessageType.REPLY, seqid)
8031 
    result.write(oprot)
8032 
    oprot.writeMessageEnd()
8033 
    oprot.trans.flush()
3451 chandransh 8034 
 
3469 chandransh 8035 
  def process_shiftToWarehouse(self, seqid, iprot, oprot):
8036 
    args = shiftToWarehouse_args()
8037 
    args.read(iprot)
8038 
    iprot.readMessageEnd()
8039 
    result = shiftToWarehouse_result()
8040 
    try:
8041 
      result.success = self._handler.shiftToWarehouse(args.orderId, args.warehouseId)
8042 
    except TransactionServiceException, ex:
8043 
      result.ex = ex
8044 
    oprot.writeMessageBegin("shiftToWarehouse", TMessageType.REPLY, seqid)
8045 
    result.write(oprot)
8046 
    oprot.writeMessageEnd()
8047 
    oprot.trans.flush()
8048 
 
3553 chandransh 8049 
  def process_addDelayReason(self, seqid, iprot, oprot):
8050 
    args = addDelayReason_args()
8051 
    args.read(iprot)
8052 
    iprot.readMessageEnd()
8053 
    result = addDelayReason_result()
8054 
    try:
4647 rajveer 8055 
      result.success = self._handler.addDelayReason(args.orderId, args.delayReason, args.furtherDelay, args.delayReasonText)
3553 chandransh 8056 
    except TransactionServiceException, ex:
8057 
      result.ex = ex
8058 
    oprot.writeMessageBegin("addDelayReason", TMessageType.REPLY, seqid)
8059 
    result.write(oprot)
8060 
    oprot.writeMessageEnd()
8061 
    oprot.trans.flush()
3469 chandransh 8062 
 
3956 chandransh 8063 
  def process_reconcileCodCollection(self, seqid, iprot, oprot):
8064 
    args = reconcileCodCollection_args()
8065 
    args.read(iprot)
8066 
    iprot.readMessageEnd()
8067 
    result = reconcileCodCollection_result()
8068 
    try:
8069 
      result.success = self._handler.reconcileCodCollection(args.collectedAmountMap, args.xferBy, args.xferTxnId, args.xferDate)
8070 
    except TransactionServiceException, ex:
8071 
      result.ex = ex
8072 
    oprot.writeMessageBegin("reconcileCodCollection", TMessageType.REPLY, seqid)
8073 
    result.write(oprot)
8074 
    oprot.writeMessageEnd()
8075 
    oprot.trans.flush()
3553 chandransh 8076 
 
4008 mandeep.dh 8077 
  def process_getTransactionsRequiringExtraProcessing(self, seqid, iprot, oprot):
8078 
    args = getTransactionsRequiringExtraProcessing_args()
8079 
    args.read(iprot)
8080 
    iprot.readMessageEnd()
8081 
    result = getTransactionsRequiringExtraProcessing_result()
8082 
    result.success = self._handler.getTransactionsRequiringExtraProcessing(args.category)
8083 
    oprot.writeMessageBegin("getTransactionsRequiringExtraProcessing", TMessageType.REPLY, seqid)
8084 
    result.write(oprot)
8085 
    oprot.writeMessageEnd()
8086 
    oprot.trans.flush()
3956 chandransh 8087 
 
4008 mandeep.dh 8088 
  def process_markTransactionAsProcessed(self, seqid, iprot, oprot):
8089 
    args = markTransactionAsProcessed_args()
8090 
    args.read(iprot)
8091 
    iprot.readMessageEnd()
8092 
    result = markTransactionAsProcessed_result()
8093 
    self._handler.markTransactionAsProcessed(args.transactionId, args.category)
8094 
    oprot.writeMessageBegin("markTransactionAsProcessed", TMessageType.REPLY, seqid)
8095 
    result.write(oprot)
8096 
    oprot.writeMessageEnd()
8097 
    oprot.trans.flush()
8098 
 
4018 chandransh 8099 
  def process_getItemWiseRiskyOrdersCount(self, seqid, iprot, oprot):
8100 
    args = getItemWiseRiskyOrdersCount_args()
8101 
    args.read(iprot)
8102 
    iprot.readMessageEnd()
8103 
    result = getItemWiseRiskyOrdersCount_result()
8104 
    result.success = self._handler.getItemWiseRiskyOrdersCount()
8105 
    oprot.writeMessageBegin("getItemWiseRiskyOrdersCount", TMessageType.REPLY, seqid)
8106 
    result.write(oprot)
8107 
    oprot.writeMessageEnd()
8108 
    oprot.trans.flush()
4008 mandeep.dh 8109 
 
4295 varun.gupt 8110 
  def process_getOrdersForItemIds(self, seqid, iprot, oprot):
8111 
    args = getOrdersForItemIds_args()
8112 
    args.read(iprot)
8113 
    iprot.readMessageEnd()
8114 
    result = getOrdersForItemIds_result()
8115 
    result.success = self._handler.getOrdersForItemIds(args.itemIds)
8116 
    oprot.writeMessageBegin("getOrdersForItemIds", TMessageType.REPLY, seqid)
8117 
    result.write(oprot)
8118 
    oprot.writeMessageEnd()
8119 
    oprot.trans.flush()
8120 
 
4247 rajveer 8121 
  def process_markOrderCancellationRequestReceived(self, seqid, iprot, oprot):
8122 
    args = markOrderCancellationRequestReceived_args()
8123 
    args.read(iprot)
8124 
    iprot.readMessageEnd()
8125 
    result = markOrderCancellationRequestReceived_result()
8126 
    try:
8127 
      self._handler.markOrderCancellationRequestReceived(args.orderId)
8128 
    except TransactionServiceException, ex:
8129 
      result.ex = ex
8130 
    oprot.writeMessageBegin("markOrderCancellationRequestReceived", TMessageType.REPLY, seqid)
8131 
    result.write(oprot)
8132 
    oprot.writeMessageEnd()
8133 
    oprot.trans.flush()
4018 chandransh 8134 
 
4247 rajveer 8135 
  def process_markOrderCancellationRequestConfirmed(self, seqid, iprot, oprot):
8136 
    args = markOrderCancellationRequestConfirmed_args()
8137 
    args.read(iprot)
8138 
    iprot.readMessageEnd()
8139 
    result = markOrderCancellationRequestConfirmed_result()
8140 
    try:
8141 
      self._handler.markOrderCancellationRequestConfirmed(args.orderId)
8142 
    except TransactionServiceException, ex:
8143 
      result.ex = ex
8144 
    oprot.writeMessageBegin("markOrderCancellationRequestConfirmed", TMessageType.REPLY, seqid)
8145 
    result.write(oprot)
8146 
    oprot.writeMessageEnd()
8147 
    oprot.trans.flush()
8148 
 
8149 
  def process_markOrderCancellationRequestDenied(self, seqid, iprot, oprot):
8150 
    args = markOrderCancellationRequestDenied_args()
8151 
    args.read(iprot)
8152 
    iprot.readMessageEnd()
8153 
    result = markOrderCancellationRequestDenied_result()
8154 
    try:
8155 
      self._handler.markOrderCancellationRequestDenied(args.orderId)
8156 
    except TransactionServiceException, ex:
8157 
      result.ex = ex
8158 
    oprot.writeMessageBegin("markOrderCancellationRequestDenied", TMessageType.REPLY, seqid)
8159 
    result.write(oprot)
8160 
    oprot.writeMessageEnd()
8161 
    oprot.trans.flush()
8162 
 
4258 rajveer 8163 
  def process_markTransactionAsPaymentFlagRemoved(self, seqid, iprot, oprot):
8164 
    args = markTransactionAsPaymentFlagRemoved_args()
4247 rajveer 8165 
    args.read(iprot)
8166 
    iprot.readMessageEnd()
4258 rajveer 8167 
    result = markTransactionAsPaymentFlagRemoved_result()
4247 rajveer 8168 
    try:
4258 rajveer 8169 
      self._handler.markTransactionAsPaymentFlagRemoved(args.transactionId)
4247 rajveer 8170 
    except TransactionServiceException, ex:
8171 
      result.ex = ex
4258 rajveer 8172 
    oprot.writeMessageBegin("markTransactionAsPaymentFlagRemoved", TMessageType.REPLY, seqid)
4247 rajveer 8173 
    result.write(oprot)
8174 
    oprot.writeMessageEnd()
8175 
    oprot.trans.flush()
8176 
 
4259 anupam.sin 8177 
  def process_refundTransaction(self, seqid, iprot, oprot):
8178 
    args = refundTransaction_args()
8179 
    args.read(iprot)
8180 
    iprot.readMessageEnd()
8181 
    result = refundTransaction_result()
8182 
    try:
8183 
      self._handler.refundTransaction(args.transactionId, args.refundedBy, args.reason)
8184 
    except TransactionServiceException, ex:
8185 
      result.ex = ex
8186 
    oprot.writeMessageBegin("refundTransaction", TMessageType.REPLY, seqid)
8187 
    result.write(oprot)
8188 
    oprot.writeMessageEnd()
8189 
    oprot.trans.flush()
4247 rajveer 8190 
 
4324 mandeep.dh 8191 
  def process_updateShipmentAddress(self, seqid, iprot, oprot):
8192 
    args = updateShipmentAddress_args()
8193 
    args.read(iprot)
8194 
    iprot.readMessageEnd()
8195 
    result = updateShipmentAddress_result()
8196 
    try:
8197 
      self._handler.updateShipmentAddress(args.orderId, args.addressId)
8198 
    except TransactionServiceException, ex:
8199 
      result.ex = ex
8200 
    oprot.writeMessageBegin("updateShipmentAddress", TMessageType.REPLY, seqid)
8201 
    result.write(oprot)
8202 
    oprot.writeMessageEnd()
8203 
    oprot.trans.flush()
8204 
 
4285 rajveer 8205 
  def process_acceptOrdersForItemId(self, seqid, iprot, oprot):
8206 
    args = acceptOrdersForItemId_args()
8207 
    args.read(iprot)
8208 
    iprot.readMessageEnd()
8209 
    result = acceptOrdersForItemId_result()
8210 
    try:
8211 
      result.success = self._handler.acceptOrdersForItemId(args.itemId, args.inventory)
8212 
    except TransactionServiceException, ex:
8213 
      result.ex = ex
8214 
    oprot.writeMessageBegin("acceptOrdersForItemId", TMessageType.REPLY, seqid)
8215 
    result.write(oprot)
8216 
    oprot.writeMessageEnd()
8217 
    oprot.trans.flush()
4259 anupam.sin 8218 
 
4303 rajveer 8219 
  def process_markOrdersAsPORaised(self, seqid, iprot, oprot):
8220 
    args = markOrdersAsPORaised_args()
8221 
    args.read(iprot)
8222 
    iprot.readMessageEnd()
8223 
    result = markOrdersAsPORaised_result()
8224 
    try:
4369 rajveer 8225 
      self._handler.markOrdersAsPORaised(args.vendorId, args.itemId, args.quantity, args.estimate, args.isReminder)
4303 rajveer 8226 
    except TransactionServiceException, ex:
8227 
      result.ex = ex
8228 
    oprot.writeMessageBegin("markOrdersAsPORaised", TMessageType.REPLY, seqid)
8229 
    result.write(oprot)
8230 
    oprot.writeMessageEnd()
8231 
    oprot.trans.flush()
4285 rajveer 8232 
 
4303 rajveer 8233 
  def process_markOrdersAsReversalInitiated(self, seqid, iprot, oprot):
8234 
    args = markOrdersAsReversalInitiated_args()
8235 
    args.read(iprot)
8236 
    iprot.readMessageEnd()
8237 
    result = markOrdersAsReversalInitiated_result()
8238 
    try:
4369 rajveer 8239 
      self._handler.markOrdersAsReversalInitiated(args.vendorId, args.itemId, args.quantity, args.estimate, args.isReminder)
4303 rajveer 8240 
    except TransactionServiceException, ex:
8241 
      result.ex = ex
8242 
    oprot.writeMessageBegin("markOrdersAsReversalInitiated", TMessageType.REPLY, seqid)
8243 
    result.write(oprot)
8244 
    oprot.writeMessageEnd()
8245 
    oprot.trans.flush()
8246 
 
8247 
  def process_markOrdersAsNotAvailabke(self, seqid, iprot, oprot):
8248 
    args = markOrdersAsNotAvailabke_args()
8249 
    args.read(iprot)
8250 
    iprot.readMessageEnd()
8251 
    result = markOrdersAsNotAvailabke_result()
8252 
    try:
4369 rajveer 8253 
      self._handler.markOrdersAsNotAvailabke(args.vendorId, args.itemId, args.quantity, args.estimate, args.isReminder)
4303 rajveer 8254 
    except TransactionServiceException, ex:
8255 
      result.ex = ex
8256 
    oprot.writeMessageBegin("markOrdersAsNotAvailabke", TMessageType.REPLY, seqid)
8257 
    result.write(oprot)
8258 
    oprot.writeMessageEnd()
8259 
    oprot.trans.flush()
8260 
 
4369 rajveer 8261 
  def process_markOrdersAsTimeout(self, seqid, iprot, oprot):
8262 
    args = markOrdersAsTimeout_args()
8263 
    args.read(iprot)
8264 
    iprot.readMessageEnd()
8265 
    result = markOrdersAsTimeout_result()
8266 
    try:
8267 
      result.success = self._handler.markOrdersAsTimeout(args.vendorId)
8268 
    except TransactionServiceException, ex:
8269 
      result.ex = ex
8270 
    oprot.writeMessageBegin("markOrdersAsTimeout", TMessageType.REPLY, seqid)
8271 
    result.write(oprot)
8272 
    oprot.writeMessageEnd()
8273 
    oprot.trans.flush()
4303 rajveer 8274 
 
4662 rajveer 8275 
  def process_markOrderAsLostInTransit(self, seqid, iprot, oprot):
8276 
    args = markOrderAsLostInTransit_args()
8277 
    args.read(iprot)
8278 
    iprot.readMessageEnd()
8279 
    result = markOrderAsLostInTransit_result()
8280 
    try:
8281 
      result.success = self._handler.markOrderAsLostInTransit(args.orderId)
8282 
    except TransactionServiceException, ex:
8283 
      result.ex = ex
8284 
    oprot.writeMessageBegin("markOrderAsLostInTransit", TMessageType.REPLY, seqid)
8285 
    result.write(oprot)
8286 
    oprot.writeMessageEnd()
8287 
    oprot.trans.flush()
8288 
 
4386 anupam.sin 8289 
  def process_getOrderForAwb(self, seqid, iprot, oprot):
8290 
    args = getOrderForAwb_args()
8291 
    args.read(iprot)
8292 
    iprot.readMessageEnd()
8293 
    result = getOrderForAwb_result()
8294 
    try:
8295 
      result.success = self._handler.getOrderForAwb(args.awb)
8296 
    except TransactionServiceException, ex:
8297 
      result.ex = ex
8298 
    oprot.writeMessageBegin("getOrderForAwb", TMessageType.REPLY, seqid)
8299 
    result.write(oprot)
8300 
    oprot.writeMessageEnd()
8301 
    oprot.trans.flush()
4369 rajveer 8302 
 
4506 phani.kuma 8303 
  def process_getOrdersForProviderForStatus(self, seqid, iprot, oprot):
8304 
    args = getOrdersForProviderForStatus_args()
8305 
    args.read(iprot)
8306 
    iprot.readMessageEnd()
8307 
    result = getOrdersForProviderForStatus_result()
8308 
    try:
4910 phani.kuma 8309 
      result.success = self._handler.getOrdersForProviderForStatus(args.logistics_provider_id, args.order_status_list)
4506 phani.kuma 8310 
    except TransactionServiceException, ex:
8311 
      result.ex = ex
8312 
    oprot.writeMessageBegin("getOrdersForProviderForStatus", TMessageType.REPLY, seqid)
8313 
    result.write(oprot)
8314 
    oprot.writeMessageEnd()
8315 
    oprot.trans.flush()
4386 anupam.sin 8316 
 
4600 varun.gupt 8317 
  def process_getBilledOrdersForVendor(self, seqid, iprot, oprot):
8318 
    args = getBilledOrdersForVendor_args()
8319 
    args.read(iprot)
8320 
    iprot.readMessageEnd()
8321 
    result = getBilledOrdersForVendor_result()
8322 
    try:
8323 
      result.success = self._handler.getBilledOrdersForVendor(args.vendorId, args.billingDateFrom, args.billingDateTo)
8324 
    except TransactionServiceException, ex:
8325 
      result.ex = ex
8326 
    oprot.writeMessageBegin("getBilledOrdersForVendor", TMessageType.REPLY, seqid)
8327 
    result.write(oprot)
8328 
    oprot.writeMessageEnd()
8329 
    oprot.trans.flush()
4506 phani.kuma 8330 
 
4607 rajveer 8331 
  def process_getSlippedSippingDateOrders(self, seqid, iprot, oprot):
8332 
    args = getSlippedSippingDateOrders_args()
8333 
    args.read(iprot)
8334 
    iprot.readMessageEnd()
8335 
    result = getSlippedSippingDateOrders_result()
8336 
    try:
8337 
      result.success = self._handler.getSlippedSippingDateOrders()
8338 
    except TransactionServiceException, ex:
8339 
      result.ex = ex
8340 
    oprot.writeMessageBegin("getSlippedSippingDateOrders", TMessageType.REPLY, seqid)
8341 
    result.write(oprot)
8342 
    oprot.writeMessageEnd()
8343 
    oprot.trans.flush()
8344 
 
4709 rajveer 8345 
  def process_getCancelledOrders(self, seqid, iprot, oprot):
8346 
    args = getCancelledOrders_args()
8347 
    args.read(iprot)
8348 
    iprot.readMessageEnd()
8349 
    result = getCancelledOrders_result()
8350 
    try:
8351 
      result.success = self._handler.getCancelledOrders(args.cancelDateFrom, args.cancelDateTo)
8352 
    except TransactionServiceException, ex:
8353 
      result.ex = ex
8354 
    oprot.writeMessageBegin("getCancelledOrders", TMessageType.REPLY, seqid)
8355 
    result.write(oprot)
8356 
    oprot.writeMessageEnd()
8357 
    oprot.trans.flush()
8358 
 
4600 varun.gupt 8359 
  def process_saveBluedartSettlements(self, seqid, iprot, oprot):
8360 
    args = saveBluedartSettlements_args()
8361 
    args.read(iprot)
8362 
    iprot.readMessageEnd()
8363 
    result = saveBluedartSettlements_result()
8364 
    try:
8365 
      self._handler.saveBluedartSettlements(args.mapAWBAndAmount)
8366 
    except TransactionServiceException, ex:
8367 
      result.ex = ex
8368 
    oprot.writeMessageBegin("saveBluedartSettlements", TMessageType.REPLY, seqid)
8369 
    result.write(oprot)
8370 
    oprot.writeMessageEnd()
8371 
    oprot.trans.flush()
8372 
 
8373 
  def process_savePaymentSettlements(self, seqid, iprot, oprot):
8374 
    args = savePaymentSettlements_args()
8375 
    args.read(iprot)
8376 
    iprot.readMessageEnd()
8377 
    result = savePaymentSettlements_result()
8378 
    try:
4905 varun.gupt 8379 
      self._handler.savePaymentSettlements(args.settlementDate, args.paymentGatewayId, args.referenceId, args.serviceTax, args.otherCharges, args.netCollection)
4600 varun.gupt 8380 
    except TransactionServiceException, ex:
8381 
      result.ex = ex
8382 
    oprot.writeMessageBegin("savePaymentSettlements", TMessageType.REPLY, seqid)
8383 
    result.write(oprot)
8384 
    oprot.writeMessageEnd()
8385 
    oprot.trans.flush()
8386 
 
8387 
  def process_saveEBSSettlementSummary(self, seqid, iprot, oprot):
8388 
    args = saveEBSSettlementSummary_args()
8389 
    args.read(iprot)
8390 
    iprot.readMessageEnd()
8391 
    result = saveEBSSettlementSummary_result()
8392 
    try:
8393 
      self._handler.saveEBSSettlementSummary(args.settlementId, args.settlementDate, args.transactionDateFrom, args.transactionDateTo, args.amount)
8394 
    except TransactionServiceException, ex:
8395 
      result.ex = ex
8396 
    oprot.writeMessageBegin("saveEBSSettlementSummary", TMessageType.REPLY, seqid)
8397 
    result.write(oprot)
8398 
    oprot.writeMessageEnd()
8399 
    oprot.trans.flush()
8400 
 
5386 phani.kuma 8401 
  def process_getSettlementForPrepaid(self, seqid, iprot, oprot):
8402 
    args = getSettlementForPrepaid_args()
4600 varun.gupt 8403 
    args.read(iprot)
8404 
    iprot.readMessageEnd()
5386 phani.kuma 8405 
    result = getSettlementForPrepaid_result()
4600 varun.gupt 8406 
    try:
5386 phani.kuma 8407 
      result.success = self._handler.getSettlementForPrepaid(args.referenceId, args.isRefund)
4600 varun.gupt 8408 
    except TransactionServiceException, ex:
8409 
      result.ex = ex
5386 phani.kuma 8410 
    oprot.writeMessageBegin("getSettlementForPrepaid", TMessageType.REPLY, seqid)
4600 varun.gupt 8411 
    result.write(oprot)
8412 
    oprot.writeMessageEnd()
8413 
    oprot.trans.flush()
8414 
 
5386 phani.kuma 8415 
  def process_getSettlementForCod(self, seqid, iprot, oprot):
8416 
    args = getSettlementForCod_args()
8417 
    args.read(iprot)
8418 
    iprot.readMessageEnd()
8419 
    result = getSettlementForCod_result()
8420 
    try:
8421 
      result.success = self._handler.getSettlementForCod(args.orderId, args.isRefund)
8422 
    except TransactionServiceException, ex:
8423 
      result.ex = ex
8424 
    oprot.writeMessageBegin("getSettlementForCod", TMessageType.REPLY, seqid)
8425 
    result.write(oprot)
8426 
    oprot.writeMessageEnd()
8427 
    oprot.trans.flush()
8428 
 
4600 varun.gupt 8429 
  def process_getEBSSettlementSummaries(self, seqid, iprot, oprot):
8430 
    args = getEBSSettlementSummaries_args()
8431 
    args.read(iprot)
8432 
    iprot.readMessageEnd()
8433 
    result = getEBSSettlementSummaries_result()
8434 
    try:
8435 
      result.success = self._handler.getEBSSettlementSummaries()
8436 
    except TransactionServiceException, ex:
8437 
      result.ex = ex
8438 
    oprot.writeMessageBegin("getEBSSettlementSummaries", TMessageType.REPLY, seqid)
8439 
    result.write(oprot)
8440 
    oprot.writeMessageEnd()
8441 
    oprot.trans.flush()
8442 
 
8443 
  def process_markEBSSettlementUploaded(self, seqid, iprot, oprot):
8444 
    args = markEBSSettlementUploaded_args()
8445 
    args.read(iprot)
8446 
    iprot.readMessageEnd()
8447 
    result = markEBSSettlementUploaded_result()
8448 
    try:
8449 
      self._handler.markEBSSettlementUploaded(args.settlementId)
8450 
    except TransactionServiceException, ex:
8451 
      result.ex = ex
8452 
    oprot.writeMessageBegin("markEBSSettlementUploaded", TMessageType.REPLY, seqid)
8453 
    result.write(oprot)
8454 
    oprot.writeMessageEnd()
8455 
    oprot.trans.flush()
8456 
 
8457 
  def process_getEBSSettlementDate(self, seqid, iprot, oprot):
8458 
    args = getEBSSettlementDate_args()
8459 
    args.read(iprot)
8460 
    iprot.readMessageEnd()
8461 
    result = getEBSSettlementDate_result()
8462 
    try:
8463 
      result.success = self._handler.getEBSSettlementDate(args.settlementId)
8464 
    except TransactionServiceException, ex:
8465 
      result.ex = ex
8466 
    oprot.writeMessageBegin("getEBSSettlementDate", TMessageType.REPLY, seqid)
8467 
    result.write(oprot)
8468 
    oprot.writeMessageEnd()
8469 
    oprot.trans.flush()
8470 
 
4715 varun.gupt 8471 
  def process_getSettlementsByDate(self, seqid, iprot, oprot):
8472 
    args = getSettlementsByDate_args()
8473 
    args.read(iprot)
8474 
    iprot.readMessageEnd()
8475 
    result = getSettlementsByDate_result()
8476 
    try:
8477 
      result.success = self._handler.getSettlementsByDate(args.settlementDateFrom, args.settlementDateTo, args.isRefund)
8478 
    except TransactionServiceException, ex:
8479 
      result.ex = ex
8480 
    oprot.writeMessageBegin("getSettlementsByDate", TMessageType.REPLY, seqid)
8481 
    result.write(oprot)
8482 
    oprot.writeMessageEnd()
8483 
    oprot.trans.flush()
4600 varun.gupt 8484 
 
4715 varun.gupt 8485 
  def process_getReshippedOrderIds(self, seqid, iprot, oprot):
8486 
    args = getReshippedOrderIds_args()
8487 
    args.read(iprot)
8488 
    iprot.readMessageEnd()
8489 
    result = getReshippedOrderIds_result()
8490 
    try:
8491 
      result.success = self._handler.getReshippedOrderIds(args.orderIds)
8492 
    except TransactionServiceException, ex:
8493 
      result.ex = ex
8494 
    oprot.writeMessageBegin("getReshippedOrderIds", TMessageType.REPLY, seqid)
8495 
    result.write(oprot)
8496 
    oprot.writeMessageEnd()
8497 
    oprot.trans.flush()
8498 
 
5481 phani.kuma 8499 
  def process_getBilledOrders(self, seqid, iprot, oprot):
8500 
    args = getBilledOrders_args()
4875 varun.gupt 8501 
    args.read(iprot)
8502 
    iprot.readMessageEnd()
5481 phani.kuma 8503 
    result = getBilledOrders_result()
4875 varun.gupt 8504 
    try:
5481 phani.kuma 8505 
      result.success = self._handler.getBilledOrders(args.vendorId, args.onlyVendorNotPaid, args.billingDateFrom, args.billingDateTo)
4875 varun.gupt 8506 
    except TransactionServiceException, ex:
8507 
      result.ex = ex
5481 phani.kuma 8508 
    oprot.writeMessageBegin("getBilledOrders", TMessageType.REPLY, seqid)
4875 varun.gupt 8509 
    result.write(oprot)
8510 
    oprot.writeMessageEnd()
8511 
    oprot.trans.flush()
4757 mandeep.dh 8512 
 
5031 varun.gupt 8513 
  def process_getStatusDistributionOfOrders(self, seqid, iprot, oprot):
8514 
    args = getStatusDistributionOfOrders_args()
8515 
    args.read(iprot)
8516 
    iprot.readMessageEnd()
8517 
    result = getStatusDistributionOfOrders_result()
8518 
    try:
8519 
      result.success = self._handler.getStatusDistributionOfOrders(args.startDate, args.endDate)
8520 
    except TransactionServiceException, ex:
8521 
      result.ex = ex
8522 
    oprot.writeMessageBegin("getStatusDistributionOfOrders", TMessageType.REPLY, seqid)
8523 
    result.write(oprot)
8524 
    oprot.writeMessageEnd()
8525 
    oprot.trans.flush()
4875 varun.gupt 8526 
 
5067 varun.gupt 8527 
  def process_getOrderIdsForStatus(self, seqid, iprot, oprot):
8528 
    args = getOrderIdsForStatus_args()
8529 
    args.read(iprot)
8530 
    iprot.readMessageEnd()
8531 
    result = getOrderIdsForStatus_result()
8532 
    try:
8533 
      result.success = self._handler.getOrderIdsForStatus(args.status, args.startDatetime, args.endDatetime)
8534 
    except TransactionServiceException, ex:
8535 
      result.ex = ex
8536 
    oprot.writeMessageBegin("getOrderIdsForStatus", TMessageType.REPLY, seqid)
8537 
    result.write(oprot)
8538 
    oprot.writeMessageEnd()
8539 
    oprot.trans.flush()
5031 varun.gupt 8540 
 
5348 anupam.sin 8541 
  def process_updateCODAgent(self, seqid, iprot, oprot):
8542 
    args = updateCODAgent_args()
8543 
    args.read(iprot)
8544 
    iprot.readMessageEnd()
8545 
    result = updateCODAgent_result()
8546 
    try:
8547 
      self._handler.updateCODAgent(args.agent, args.orderId)
8548 
    except TransactionServiceException, ex:
8549 
      result.ex = ex
8550 
    oprot.writeMessageBegin("updateCODAgent", TMessageType.REPLY, seqid)
8551 
    result.write(oprot)
8552 
    oprot.writeMessageEnd()
8553 
    oprot.trans.flush()
8554 
 
5099 varun.gupt 8555 
  def process_updateOrderAsPaidToVendor(self, seqid, iprot, oprot):
8556 
    args = updateOrderAsPaidToVendor_args()
8557 
    args.read(iprot)
8558 
    iprot.readMessageEnd()
8559 
    result = updateOrderAsPaidToVendor_result()
8560 
    try:
8561 
      self._handler.updateOrderAsPaidToVendor(args.orderId)
8562 
    except TransactionServiceException, ex:
8563 
      result.ex = ex
8564 
    oprot.writeMessageBegin("updateOrderAsPaidToVendor", TMessageType.REPLY, seqid)
8565 
    result.write(oprot)
8566 
    oprot.writeMessageEnd()
8567 
    oprot.trans.flush()
5067 varun.gupt 8568 
 
5386 phani.kuma 8569 
  def process_updateOrderOnlyAsPaidToVendor(self, seqid, iprot, oprot):
8570 
    args = updateOrderOnlyAsPaidToVendor_args()
8571 
    args.read(iprot)
8572 
    iprot.readMessageEnd()
8573 
    result = updateOrderOnlyAsPaidToVendor_result()
8574 
    try:
8575 
      self._handler.updateOrderOnlyAsPaidToVendor(args.orderId)
8576 
    except TransactionServiceException, ex:
8577 
      result.ex = ex
8578 
    oprot.writeMessageBegin("updateOrderOnlyAsPaidToVendor", TMessageType.REPLY, seqid)
8579 
    result.write(oprot)
8580 
    oprot.writeMessageEnd()
8581 
    oprot.trans.flush()
8582 
 
5208 varun.gupt 8583 
  def process_getRefundedOrdersMarkedPaid(self, seqid, iprot, oprot):
8584 
    args = getRefundedOrdersMarkedPaid_args()
8585 
    args.read(iprot)
8586 
    iprot.readMessageEnd()
8587 
    result = getRefundedOrdersMarkedPaid_result()
8588 
    try:
8589 
      result.success = self._handler.getRefundedOrdersMarkedPaid()
8590 
    except TransactionServiceException, ex:
8591 
      result.ex = ex
8592 
    oprot.writeMessageBegin("getRefundedOrdersMarkedPaid", TMessageType.REPLY, seqid)
8593 
    result.write(oprot)
8594 
    oprot.writeMessageEnd()
8595 
    oprot.trans.flush()
5099 varun.gupt 8596 
 
5447 anupam.sin 8597 
  def process_getAllVerificationAgents(self, seqid, iprot, oprot):
8598 
    args = getAllVerificationAgents_args()
8599 
    args.read(iprot)
8600 
    iprot.readMessageEnd()
8601 
    result = getAllVerificationAgents_result()
8602 
    result.success = self._handler.getAllVerificationAgents(args.minOrderId, args.maxOrderId)
8603 
    oprot.writeMessageBegin("getAllVerificationAgents", TMessageType.REPLY, seqid)
8604 
    result.write(oprot)
8605 
    oprot.writeMessageEnd()
8606 
    oprot.trans.flush()
5208 varun.gupt 8607 
 
5527 anupam.sin 8608 
  def process_getAllAttributesForOrderId(self, seqid, iprot, oprot):
8609 
    args = getAllAttributesForOrderId_args()
8610 
    args.read(iprot)
8611 
    iprot.readMessageEnd()
8612 
    result = getAllAttributesForOrderId_result()
8613 
    result.success = self._handler.getAllAttributesForOrderId(args.orderId)
8614 
    oprot.writeMessageBegin("getAllAttributesForOrderId", TMessageType.REPLY, seqid)
8615 
    result.write(oprot)
8616 
    oprot.writeMessageEnd()
8617 
    oprot.trans.flush()
5447 anupam.sin 8618 
 
5676 rajveer 8619 
  def process_setOrderAttributes(self, seqid, iprot, oprot):
8620 
    args = setOrderAttributes_args()
8621 
    args.read(iprot)
8622 
    iprot.readMessageEnd()
8623 
    result = setOrderAttributes_result()
8624 
    self._handler.setOrderAttributes(args.orderId, args.attributes)
8625 
    oprot.writeMessageBegin("setOrderAttributes", TMessageType.REPLY, seqid)
8626 
    result.write(oprot)
8627 
    oprot.writeMessageEnd()
8628 
    oprot.trans.flush()
8629 
 
5527 anupam.sin 8630 
  def process_setOrderAttributeForTransaction(self, seqid, iprot, oprot):
8631 
    args = setOrderAttributeForTransaction_args()
8632 
    args.read(iprot)
8633 
    iprot.readMessageEnd()
8634 
    result = setOrderAttributeForTransaction_result()
8635 
    self._handler.setOrderAttributeForTransaction(args.transactionId, args.attribute)
8636 
    oprot.writeMessageBegin("setOrderAttributeForTransaction", TMessageType.REPLY, seqid)
8637 
    result.write(oprot)
8638 
    oprot.writeMessageEnd()
8639 
    oprot.trans.flush()
8640 
 
5553 rajveer 8641 
  def process_getReceivePendingOrders(self, seqid, iprot, oprot):
8642 
    args = getReceivePendingOrders_args()
8643 
    args.read(iprot)
8644 
    iprot.readMessageEnd()
8645 
    result = getReceivePendingOrders_result()
8646 
    result.success = self._handler.getReceivePendingOrders(args.storeId)
8647 
    oprot.writeMessageBegin("getReceivePendingOrders", TMessageType.REPLY, seqid)
8648 
    result.write(oprot)
8649 
    oprot.writeMessageEnd()
8650 
    oprot.trans.flush()
5527 anupam.sin 8651 
 
5553 rajveer 8652 
  def process_getReceivedAtStoreOrders(self, seqid, iprot, oprot):
8653 
    args = getReceivedAtStoreOrders_args()
8654 
    args.read(iprot)
8655 
    iprot.readMessageEnd()
8656 
    result = getReceivedAtStoreOrders_result()
8657 
    result.success = self._handler.getReceivedAtStoreOrders(args.storeId)
8658 
    oprot.writeMessageBegin("getReceivedAtStoreOrders", TMessageType.REPLY, seqid)
8659 
    result.write(oprot)
8660 
    oprot.writeMessageEnd()
8661 
    oprot.trans.flush()
8662 
 
5713 rajveer 8663 
  def process_getOrdersCollectionAtStore(self, seqid, iprot, oprot):
8664 
    args = getOrdersCollectionAtStore_args()
8665 
    args.read(iprot)
8666 
    iprot.readMessageEnd()
8667 
    result = getOrdersCollectionAtStore_result()
8668 
    result.success = self._handler.getOrdersCollectionAtStore(args.storeId, args.fromDate, args.toDate, args.onlyCod)
8669 
    oprot.writeMessageBegin("getOrdersCollectionAtStore", TMessageType.REPLY, seqid)
8670 
    result.write(oprot)
8671 
    oprot.writeMessageEnd()
8672 
    oprot.trans.flush()
8673 
 
5833 rajveer 8674 
  def process_getOrderAttributeValue(self, seqid, iprot, oprot):
8675 
    args = getOrderAttributeValue_args()
8676 
    args.read(iprot)
8677 
    iprot.readMessageEnd()
8678 
    result = getOrderAttributeValue_result()
8679 
    result.success = self._handler.getOrderAttributeValue(args.orderId, args.attributeName)
8680 
    oprot.writeMessageBegin("getOrderAttributeValue", TMessageType.REPLY, seqid)
8681 
    result.write(oprot)
8682 
    oprot.writeMessageEnd()
8683 
    oprot.trans.flush()
8684 
 
6019 rajveer 8685 
  def process_changeJacketNumber(self, seqid, iprot, oprot):
8686 
    args = changeJacketNumber_args()
8687 
    args.read(iprot)
8688 
    iprot.readMessageEnd()
8689 
    result = changeJacketNumber_result()
8690 
    result.success = self._handler.changeJacketNumber(args.orderId, args.jacketNumber)
8691 
    oprot.writeMessageBegin("changeJacketNumber", TMessageType.REPLY, seqid)
8692 
    result.write(oprot)
8693 
    oprot.writeMessageEnd()
8694 
    oprot.trans.flush()
8695 
 
8696 
  def process_markOrderAsRtoInTransit(self, seqid, iprot, oprot):
8697 
    args = markOrderAsRtoInTransit_args()
8698 
    args.read(iprot)
8699 
    iprot.readMessageEnd()
8700 
    result = markOrderAsRtoInTransit_result()
8701 
    result.success = self._handler.markOrderAsRtoInTransit(args.orderId)
8702 
    oprot.writeMessageBegin("markOrderAsRtoInTransit", TMessageType.REPLY, seqid)
8703 
    result.write(oprot)
8704 
    oprot.writeMessageEnd()
8705 
    oprot.trans.flush()
8706 
 
5593 mandeep.dh 8707 
  def process_acceptOrderForItem(self, seqid, iprot, oprot):
8708 
    args = acceptOrderForItem_args()
8709 
    args.read(iprot)
8710 
    iprot.readMessageEnd()
8711 
    result = acceptOrderForItem_result()
8712 
    self._handler.acceptOrderForItem(args.itemId, args.quantity, args.fulfilmentWarehouseId, args.billingWarehouseId)
8713 
    oprot.writeMessageBegin("acceptOrderForItem", TMessageType.REPLY, seqid)
8714 
    result.write(oprot)
8715 
    oprot.writeMessageEnd()
8716 
    oprot.trans.flush()
5553 rajveer 8717 
 
6000 mandeep.dh 8718 
  def process_createRechargeOrder(self, seqid, iprot, oprot):
8719 
    args = createRechargeOrder_args()
8720 
    args.read(iprot)
8721 
    iprot.readMessageEnd()
8722 
    result = createRechargeOrder_result()
8723 
    try:
8724 
      result.success = self._handler.createRechargeOrder(args.rechargeOrder)
8725 
    except TransactionServiceException, ex:
8726 
      result.ex = ex
8727 
    oprot.writeMessageBegin("createRechargeOrder", TMessageType.REPLY, seqid)
8728 
    result.write(oprot)
8729 
    oprot.writeMessageEnd()
8730 
    oprot.trans.flush()
5593 mandeep.dh 8731 
 
6031 rajveer 8732 
  def process_getRechargeOrder(self, seqid, iprot, oprot):
8733 
    args = getRechargeOrder_args()
8734 
    args.read(iprot)
8735 
    iprot.readMessageEnd()
8736 
    result = getRechargeOrder_result()
8737 
    try:
8738 
      result.success = self._handler.getRechargeOrder(args.rechargeRrderId)
8739 
    except TransactionServiceException, ex:
8740 
      result.ex = ex
8741 
    oprot.writeMessageBegin("getRechargeOrder", TMessageType.REPLY, seqid)
8742 
    result.write(oprot)
8743 
    oprot.writeMessageEnd()
8744 
    oprot.trans.flush()
8745 
 
8746 
  def process_getRechargeOrders(self, seqid, iprot, oprot):
8747 
    args = getRechargeOrders_args()
8748 
    args.read(iprot)
8749 
    iprot.readMessageEnd()
8750 
    result = getRechargeOrders_result()
8751 
    result.success = self._handler.getRechargeOrders(args.userId)
8752 
    oprot.writeMessageBegin("getRechargeOrders", TMessageType.REPLY, seqid)
8753 
    result.write(oprot)
8754 
    oprot.writeMessageEnd()
8755 
    oprot.trans.flush()
8756 
 
6000 mandeep.dh 8757 
  def process_updateRechargeOrderStatus(self, seqid, iprot, oprot):
8758 
    args = updateRechargeOrderStatus_args()
8759 
    args.read(iprot)
8760 
    iprot.readMessageEnd()
8761 
    result = updateRechargeOrderStatus_result()
8762 
    try:
6031 rajveer 8763 
      result.success = self._handler.updateRechargeOrderStatus(args.rechargeOrderId, args.rechargeOrderStatus)
6000 mandeep.dh 8764 
    except TransactionServiceException, ex:
8765 
      result.ex = ex
8766 
    oprot.writeMessageBegin("updateRechargeOrderStatus", TMessageType.REPLY, seqid)
8767 
    result.write(oprot)
8768 
    oprot.writeMessageEnd()
8769 
    oprot.trans.flush()
8770 
 
8771 
  def process_activateRechargeTxn(self, seqid, iprot, oprot):
8772 
    args = activateRechargeTxn_args()
8773 
    args.read(iprot)
8774 
    iprot.readMessageEnd()
8775 
    result = activateRechargeTxn_result()
8776 
    try:
6031 rajveer 8777 
      result.success = self._handler.activateRechargeTxn(args.rechargeOrderId)
6000 mandeep.dh 8778 
    except TransactionServiceException, ex:
8779 
      result.ex = ex
8780 
    oprot.writeMessageBegin("activateRechargeTxn", TMessageType.REPLY, seqid)
8781 
    result.write(oprot)
8782 
    oprot.writeMessageEnd()
8783 
    oprot.trans.flush()
8784 
 
6031 rajveer 8785 
  def process_getUserWallet(self, seqid, iprot, oprot):
8786 
    args = getUserWallet_args()
6000 mandeep.dh 8787 
    args.read(iprot)
8788 
    iprot.readMessageEnd()
6031 rajveer 8789 
    result = getUserWallet_result()
8790 
    result.success = self._handler.getUserWallet(args.userId)
8791 
    oprot.writeMessageBegin("getUserWallet", TMessageType.REPLY, seqid)
6000 mandeep.dh 8792 
    result.write(oprot)
8793 
    oprot.writeMessageEnd()
8794 
    oprot.trans.flush()
8795 
 
6031 rajveer 8796 
  def process_getUserWalletHistory(self, seqid, iprot, oprot):
8797 
    args = getUserWalletHistory_args()
6000 mandeep.dh 8798 
    args.read(iprot)
8799 
    iprot.readMessageEnd()
6031 rajveer 8800 
    result = getUserWalletHistory_result()
8801 
    result.success = self._handler.getUserWalletHistory(args.userId)
8802 
    oprot.writeMessageBegin("getUserWalletHistory", TMessageType.REPLY, seqid)
6000 mandeep.dh 8803 
    result.write(oprot)
8804 
    oprot.writeMessageEnd()
8805 
    oprot.trans.flush()
8806 
 
6050 anupam.sin 8807 
  def process_getRechargeOrdersForTransaction(self, seqid, iprot, oprot):
8808 
    args = getRechargeOrdersForTransaction_args()
8809 
    args.read(iprot)
8810 
    iprot.readMessageEnd()
8811 
    result = getRechargeOrdersForTransaction_result()
8812 
    try:
8813 
      result.success = self._handler.getRechargeOrdersForTransaction(args.txnId)
8814 
    except TransactionServiceException, ex:
8815 
      result.ex = ex
8816 
    oprot.writeMessageBegin("getRechargeOrdersForTransaction", TMessageType.REPLY, seqid)
8817 
    result.write(oprot)
8818 
    oprot.writeMessageEnd()
8819 
    oprot.trans.flush()
8820 
 
6048 rajveer 8821 
  def process_getServiceProviders(self, seqid, iprot, oprot):
8822 
    args = getServiceProviders_args()
8823 
    args.read(iprot)
8824 
    iprot.readMessageEnd()
8825 
    result = getServiceProviders_result()
6206 rajveer 8826 
    result.success = self._handler.getServiceProviders(args.rechargeType, args.onlyActive)
6048 rajveer 8827 
    oprot.writeMessageBegin("getServiceProviders", TMessageType.REPLY, seqid)
8828 
    result.write(oprot)
8829 
    oprot.writeMessageEnd()
8830 
    oprot.trans.flush()
6000 mandeep.dh 8831 
 
6048 rajveer 8832 
  def process_getServiceProviderForDevice(self, seqid, iprot, oprot):
8833 
    args = getServiceProviderForDevice_args()
8834 
    args.read(iprot)
8835 
    iprot.readMessageEnd()
8836 
    result = getServiceProviderForDevice_result()
6049 rajveer 8837 
    result.success = self._handler.getServiceProviderForDevice(args.rechargeType, args.deviceNumber)
6048 rajveer 8838 
    oprot.writeMessageBegin("getServiceProviderForDevice", TMessageType.REPLY, seqid)
8839 
    result.write(oprot)
8840 
    oprot.writeMessageEnd()
8841 
    oprot.trans.flush()
8842 
 
6269 rajveer 8843 
  def process_validateRecharge(self, seqid, iprot, oprot):
8844 
    args = validateRecharge_args()
8845 
    args.read(iprot)
8846 
    iprot.readMessageEnd()
8847 
    result = validateRecharge_result()
6591 anupam.sin 8848 
    result.success = self._handler.validateRecharge(args.rechargeType, args.deviceNumber, args.userSelectedProviderId, args.clientAddress)
6269 rajveer 8849 
    oprot.writeMessageBegin("validateRecharge", TMessageType.REPLY, seqid)
8850 
    result.write(oprot)
8851 
    oprot.writeMessageEnd()
8852 
    oprot.trans.flush()
8853 
 
6094 rajveer 8854 
  def process_getRechargeOrdersForDevice(self, seqid, iprot, oprot):
8855 
    args = getRechargeOrdersForDevice_args()
8856 
    args.read(iprot)
8857 
    iprot.readMessageEnd()
8858 
    result = getRechargeOrdersForDevice_result()
8859 
    result.success = self._handler.getRechargeOrdersForDevice(args.deviceNumber)
8860 
    oprot.writeMessageBegin("getRechargeOrdersForDevice", TMessageType.REPLY, seqid)
8861 
    result.write(oprot)
8862 
    oprot.writeMessageEnd()
8863 
    oprot.trans.flush()
6048 rajveer 8864 
 
6094 rajveer 8865 
  def process_addAmountToWallet(self, seqid, iprot, oprot):
8866 
    args = addAmountToWallet_args()
8867 
    args.read(iprot)
8868 
    iprot.readMessageEnd()
8869 
    result = addAmountToWallet_result()
8870 
    self._handler.addAmountToWallet(args.userId, args.orderId, args.amount)
8871 
    oprot.writeMessageBegin("addAmountToWallet", TMessageType.REPLY, seqid)
8872 
    result.write(oprot)
8873 
    oprot.writeMessageEnd()
8874 
    oprot.trans.flush()
8875 
 
6188 rajveer 8876 
  def process_getRechargeStatistics(self, seqid, iprot, oprot):
8877 
    args = getRechargeStatistics_args()
8878 
    args.read(iprot)
8879 
    iprot.readMessageEnd()
8880 
    result = getRechargeStatistics_result()
8881 
    result.success = self._handler.getRechargeStatistics()
8882 
    oprot.writeMessageBegin("getRechargeStatistics", TMessageType.REPLY, seqid)
8883 
    result.write(oprot)
8884 
    oprot.writeMessageEnd()
8885 
    oprot.trans.flush()
8886 
 
6154 rajveer 8887 
  def process_getRechargeOrdersForStatus(self, seqid, iprot, oprot):
8888 
    args = getRechargeOrdersForStatus_args()
8889 
    args.read(iprot)
8890 
    iprot.readMessageEnd()
8891 
    result = getRechargeOrdersForStatus_result()
8892 
    result.success = self._handler.getRechargeOrdersForStatus(args.status)
8893 
    oprot.writeMessageBegin("getRechargeOrdersForStatus", TMessageType.REPLY, seqid)
8894 
    result.write(oprot)
8895 
    oprot.writeMessageEnd()
8896 
    oprot.trans.flush()
6094 rajveer 8897 
 
6159 rajveer 8898 
  def process_getPlansForOperator(self, seqid, iprot, oprot):
8899 
    args = getPlansForOperator_args()
8900 
    args.read(iprot)
8901 
    iprot.readMessageEnd()
8902 
    result = getPlansForOperator_result()
8903 
    result.success = self._handler.getPlansForOperator(args.operatorId)
8904 
    oprot.writeMessageBegin("getPlansForOperator", TMessageType.REPLY, seqid)
8905 
    result.write(oprot)
8906 
    oprot.writeMessageEnd()
8907 
    oprot.trans.flush()
6154 rajveer 8908 
 
6289 anupam.sin 8909 
  def process_getRechargeDenominations(self, seqid, iprot, oprot):
8910 
    args = getRechargeDenominations_args()
8911 
    args.read(iprot)
8912 
    iprot.readMessageEnd()
8913 
    result = getRechargeDenominations_result()
8914 
    try:
6307 anupam.sin 8915 
      result.success = self._handler.getRechargeDenominations(args.operatorId, args.circleCode, args.denominationType)
6289 anupam.sin 8916 
    except TransactionServiceException, ex:
8917 
      result.ex = ex
8918 
    oprot.writeMessageBegin("getRechargeDenominations", TMessageType.REPLY, seqid)
8919 
    result.write(oprot)
8920 
    oprot.writeMessageEnd()
8921 
    oprot.trans.flush()
6159 rajveer 8922 
 
6371 rajveer 8923 
  def process_updateAvailabilityStatus(self, seqid, iprot, oprot):
8924 
    args = updateAvailabilityStatus_args()
8925 
    args.read(iprot)
8926 
    iprot.readMessageEnd()
8927 
    result = updateAvailabilityStatus_result()
8928 
    self._handler.updateAvailabilityStatus(args.operatorId, args.circleId, args.isAvailable)
8929 
    oprot.writeMessageBegin("updateAvailabilityStatus", TMessageType.REPLY, seqid)
8930 
    result.write(oprot)
8931 
    oprot.writeMessageEnd()
8932 
    oprot.trans.flush()
6289 anupam.sin 8933 
 
6389 rajveer 8934 
  def process_getAvailableEmiSchemes(self, seqid, iprot, oprot):
8935 
    args = getAvailableEmiSchemes_args()
8936 
    args.read(iprot)
8937 
    iprot.readMessageEnd()
8938 
    result = getAvailableEmiSchemes_result()
8939 
    result.success = self._handler.getAvailableEmiSchemes()
8940 
    oprot.writeMessageBegin("getAvailableEmiSchemes", TMessageType.REPLY, seqid)
8941 
    result.write(oprot)
8942 
    oprot.writeMessageEnd()
8943 
    oprot.trans.flush()
6371 rajveer 8944 
 
6389 rajveer 8945 
  def process_getMiscCharges(self, seqid, iprot, oprot):
8946 
    args = getMiscCharges_args()
8947 
    args.read(iprot)
8948 
    iprot.readMessageEnd()
8949 
    result = getMiscCharges_result()
8950 
    result.success = self._handler.getMiscCharges(args.transactionId)
8951 
    oprot.writeMessageBegin("getMiscCharges", TMessageType.REPLY, seqid)
8952 
    result.write(oprot)
8953 
    oprot.writeMessageEnd()
8954 
    oprot.trans.flush()
8955 
 
6507 anupam.sin 8956 
  def process_refundRechargeOrder(self, seqid, iprot, oprot):
8957 
    args = refundRechargeOrder_args()
8958 
    args.read(iprot)
8959 
    iprot.readMessageEnd()
8960 
    result = refundRechargeOrder_result()
8961 
    try:
8962 
      result.success = self._handler.refundRechargeOrder(args.rechargeOrderId)
8963 
    except TransactionServiceException, ex:
8964 
      result.ex = ex
8965 
    oprot.writeMessageBegin("refundRechargeOrder", TMessageType.REPLY, seqid)
8966 
    result.write(oprot)
8967 
    oprot.writeMessageEnd()
8968 
    oprot.trans.flush()
6389 rajveer 8969 
 
6821 amar.kumar 8970 
  def process_getPhysicalOrders(self, seqid, iprot, oprot):
8971 
    args = getPhysicalOrders_args()
8972 
    args.read(iprot)
8973 
    iprot.readMessageEnd()
8974 
    result = getPhysicalOrders_result()
8975 
    result.success = self._handler.getPhysicalOrders(args.fromDate, args.toDate)
8976 
    oprot.writeMessageBegin("getPhysicalOrders", TMessageType.REPLY, seqid)
8977 
    result.write(oprot)
8978 
    oprot.writeMessageEnd()
8979 
    oprot.trans.flush()
6507 anupam.sin 8980 
 
6906 rajveer 8981 
  def process_getDocument(self, seqid, iprot, oprot):
8982 
    args = getDocument_args()
8983 
    args.read(iprot)
8984 
    iprot.readMessageEnd()
8985 
    result = getDocument_result()
8986 
    result.success = self._handler.getDocument(args.docType, args.docSource)
8987 
    oprot.writeMessageBegin("getDocument", TMessageType.REPLY, seqid)
8988 
    result.write(oprot)
8989 
    oprot.writeMessageEnd()
8990 
    oprot.trans.flush()
6821 amar.kumar 8991 
 
6985 anupam.sin 8992 
  def process_changeShippingAddress(self, seqid, iprot, oprot):
8993 
    args = changeShippingAddress_args()
8994 
    args.read(iprot)
8995 
    iprot.readMessageEnd()
8996 
    result = changeShippingAddress_result()
8997 
    result.success = self._handler.changeShippingAddress(args.orderId, args.line1, args.line2, args.city, args.state, args.pin)
8998 
    oprot.writeMessageBegin("changeShippingAddress", TMessageType.REPLY, seqid)
8999 
    result.write(oprot)
9000 
    oprot.writeMessageEnd()
9001 
    oprot.trans.flush()
6906 rajveer 9002 
 
6988 rajveer 9003 
  def process_retrieveInvoice(self, seqid, iprot, oprot):
9004 
    args = retrieveInvoice_args()
9005 
    args.read(iprot)
9006 
    iprot.readMessageEnd()
9007 
    result = retrieveInvoice_result()
7075 rajveer 9008 
    result.success = self._handler.retrieveInvoice(args.orderId, args.userId)
6988 rajveer 9009 
    oprot.writeMessageBegin("retrieveInvoice", TMessageType.REPLY, seqid)
9010 
    result.write(oprot)
9011 
    oprot.writeMessageEnd()
9012 
    oprot.trans.flush()
6985 anupam.sin 9013 
 
7026 rajveer 9014 
  def process_receiveUpdatesForRedExpress(self, seqid, iprot, oprot):
9015 
    args = receiveUpdatesForRedExpress_args()
9016 
    args.read(iprot)
9017 
    iprot.readMessageEnd()
9018 
    result = receiveUpdatesForRedExpress_result()
9019 
    result.success = self._handler.receiveUpdatesForRedExpress(args.awbNumber)
9020 
    oprot.writeMessageBegin("receiveUpdatesForRedExpress", TMessageType.REPLY, seqid)
9021 
    result.write(oprot)
9022 
    oprot.writeMessageEnd()
9023 
    oprot.trans.flush()
6988 rajveer 9024 
 
7073 anupam.sin 9025 
  def process_createRechargeTransaction(self, seqid, iprot, oprot):
9026 
    args = createRechargeTransaction_args()
9027 
    args.read(iprot)
9028 
    iprot.readMessageEnd()
9029 
    result = createRechargeTransaction_result()
9030 
    result.success = self._handler.createRechargeTransaction(args.thriftRechargeTransaction)
9031 
    oprot.writeMessageBegin("createRechargeTransaction", TMessageType.REPLY, seqid)
9032 
    result.write(oprot)
9033 
    oprot.writeMessageEnd()
9034 
    oprot.trans.flush()
7026 rajveer 9035 
 
7080 anupam.sin 9036 
  def process_getRechargeTransaction(self, seqid, iprot, oprot):
9037 
    args = getRechargeTransaction_args()
9038 
    args.read(iprot)
9039 
    iprot.readMessageEnd()
9040 
    result = getRechargeTransaction_result()
9041 
    result.success = self._handler.getRechargeTransaction(args.rechargeId)
9042 
    oprot.writeMessageBegin("getRechargeTransaction", TMessageType.REPLY, seqid)
9043 
    result.write(oprot)
9044 
    oprot.writeMessageEnd()
9045 
    oprot.trans.flush()
7073 anupam.sin 9046 
 
7080 anupam.sin 9047 
  def process_getFRCs(self, seqid, iprot, oprot):
9048 
    args = getFRCs_args()
9049 
    args.read(iprot)
9050 
    iprot.readMessageEnd()
9051 
    result = getFRCs_result()
9052 
    result.success = self._handler.getFRCs(args.circleId, args.operatorId)
9053 
    oprot.writeMessageBegin("getFRCs", TMessageType.REPLY, seqid)
9054 
    result.write(oprot)
9055 
    oprot.writeMessageEnd()
9056 
    oprot.trans.flush()
9057 
 
9058 
 
94 ashish 9059 
# HELPER FUNCTIONS AND STRUCTURES
9060 
 
9061 
class createTransaction_args:
9062 
  """
9063 
  Attributes:
9064 
   - transaction
9065 
  """
9066 
 
9067 
  thrift_spec = (
9068 
    None, # 0
9069 
    (1, TType.STRUCT, 'transaction', (Transaction, Transaction.thrift_spec), None, ), # 1
9070 
  )
9071 
 
9072 
  def __init__(self, transaction=None,):
9073 
    self.transaction = transaction
9074 
 
9075 
  def read(self, iprot):
9076 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9077 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9078 
      return
9079 
    iprot.readStructBegin()
9080 
    while True:
9081 
      (fname, ftype, fid) = iprot.readFieldBegin()
9082 
      if ftype == TType.STOP:
9083 
        break
9084 
      if fid == 1:
9085 
        if ftype == TType.STRUCT:
9086 
          self.transaction = Transaction()
9087 
          self.transaction.read(iprot)
9088 
        else:
9089 
          iprot.skip(ftype)
9090 
      else:
9091 
        iprot.skip(ftype)
9092 
      iprot.readFieldEnd()
9093 
    iprot.readStructEnd()
9094 
 
9095 
  def write(self, oprot):
9096 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9097 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9098 
      return
9099 
    oprot.writeStructBegin('createTransaction_args')
3431 rajveer 9100 
    if self.transaction is not None:
94 ashish 9101 
      oprot.writeFieldBegin('transaction', TType.STRUCT, 1)
9102 
      self.transaction.write(oprot)
9103 
      oprot.writeFieldEnd()
9104 
    oprot.writeFieldStop()
9105 
    oprot.writeStructEnd()
9106 
 
3431 rajveer 9107 
  def validate(self):
9108 
    return
9109 
 
9110 
 
94 ashish 9111 
  def __repr__(self):
9112 
    L = ['%s=%r' % (key, value)
9113 
      for key, value in self.__dict__.iteritems()]
9114 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9115 
 
9116 
  def __eq__(self, other):
9117 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9118 
 
9119 
  def __ne__(self, other):
9120 
    return not (self == other)
9121 
 
9122 
class createTransaction_result:
9123 
  """
9124 
  Attributes:
132 ashish 9125 
   - success
94 ashish 9126 
   - ex
9127 
  """
9128 
 
9129 
  thrift_spec = (
132 ashish 9130 
    (0, TType.I64, 'success', None, None, ), # 0
94 ashish 9131 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
9132 
  )
9133 
 
132 ashish 9134 
  def __init__(self, success=None, ex=None,):
9135 
    self.success = success
94 ashish 9136 
    self.ex = ex
9137 
 
9138 
  def read(self, iprot):
9139 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9140 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9141 
      return
9142 
    iprot.readStructBegin()
9143 
    while True:
9144 
      (fname, ftype, fid) = iprot.readFieldBegin()
9145 
      if ftype == TType.STOP:
9146 
        break
132 ashish 9147 
      if fid == 0:
9148 
        if ftype == TType.I64:
9149 
          self.success = iprot.readI64();
9150 
        else:
9151 
          iprot.skip(ftype)
9152 
      elif fid == 1:
94 ashish 9153 
        if ftype == TType.STRUCT:
9154 
          self.ex = TransactionServiceException()
9155 
          self.ex.read(iprot)
9156 
        else:
9157 
          iprot.skip(ftype)
9158 
      else:
9159 
        iprot.skip(ftype)
9160 
      iprot.readFieldEnd()
9161 
    iprot.readStructEnd()
9162 
 
9163 
  def write(self, oprot):
9164 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9165 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9166 
      return
9167 
    oprot.writeStructBegin('createTransaction_result')
3431 rajveer 9168 
    if self.success is not None:
132 ashish 9169 
      oprot.writeFieldBegin('success', TType.I64, 0)
9170 
      oprot.writeI64(self.success)
9171 
      oprot.writeFieldEnd()
3431 rajveer 9172 
    if self.ex is not None:
94 ashish 9173 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9174 
      self.ex.write(oprot)
9175 
      oprot.writeFieldEnd()
9176 
    oprot.writeFieldStop()
9177 
    oprot.writeStructEnd()
9178 
 
3431 rajveer 9179 
  def validate(self):
9180 
    return
9181 
 
9182 
 
94 ashish 9183 
  def __repr__(self):
9184 
    L = ['%s=%r' % (key, value)
9185 
      for key, value in self.__dict__.iteritems()]
9186 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9187 
 
9188 
  def __eq__(self, other):
9189 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9190 
 
9191 
  def __ne__(self, other):
9192 
    return not (self == other)
9193 
 
9194 
class getTransaction_args:
9195 
  """
9196 
  Attributes:
9197 
   - id
9198 
  """
9199 
 
9200 
  thrift_spec = (
9201 
    None, # 0
9202 
    (1, TType.I64, 'id', None, None, ), # 1
9203 
  )
9204 
 
9205 
  def __init__(self, id=None,):
9206 
    self.id = id
9207 
 
9208 
  def read(self, iprot):
9209 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9210 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9211 
      return
9212 
    iprot.readStructBegin()
9213 
    while True:
9214 
      (fname, ftype, fid) = iprot.readFieldBegin()
9215 
      if ftype == TType.STOP:
9216 
        break
9217 
      if fid == 1:
9218 
        if ftype == TType.I64:
9219 
          self.id = iprot.readI64();
9220 
        else:
9221 
          iprot.skip(ftype)
9222 
      else:
9223 
        iprot.skip(ftype)
9224 
      iprot.readFieldEnd()
9225 
    iprot.readStructEnd()
9226 
 
9227 
  def write(self, oprot):
9228 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9229 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9230 
      return
9231 
    oprot.writeStructBegin('getTransaction_args')
3431 rajveer 9232 
    if self.id is not None:
94 ashish 9233 
      oprot.writeFieldBegin('id', TType.I64, 1)
9234 
      oprot.writeI64(self.id)
9235 
      oprot.writeFieldEnd()
9236 
    oprot.writeFieldStop()
9237 
    oprot.writeStructEnd()
9238 
 
3431 rajveer 9239 
  def validate(self):
9240 
    return
9241 
 
9242 
 
94 ashish 9243 
  def __repr__(self):
9244 
    L = ['%s=%r' % (key, value)
9245 
      for key, value in self.__dict__.iteritems()]
9246 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9247 
 
9248 
  def __eq__(self, other):
9249 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9250 
 
9251 
  def __ne__(self, other):
9252 
    return not (self == other)
9253 
 
9254 
class getTransaction_result:
9255 
  """
9256 
  Attributes:
9257 
   - success
9258 
   - ex
9259 
  """
9260 
 
9261 
  thrift_spec = (
9262 
    (0, TType.STRUCT, 'success', (Transaction, Transaction.thrift_spec), None, ), # 0
9263 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
9264 
  )
9265 
 
9266 
  def __init__(self, success=None, ex=None,):
9267 
    self.success = success
9268 
    self.ex = ex
9269 
 
9270 
  def read(self, iprot):
9271 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9272 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9273 
      return
9274 
    iprot.readStructBegin()
9275 
    while True:
9276 
      (fname, ftype, fid) = iprot.readFieldBegin()
9277 
      if ftype == TType.STOP:
9278 
        break
9279 
      if fid == 0:
9280 
        if ftype == TType.STRUCT:
9281 
          self.success = Transaction()
9282 
          self.success.read(iprot)
9283 
        else:
9284 
          iprot.skip(ftype)
9285 
      elif fid == 1:
9286 
        if ftype == TType.STRUCT:
9287 
          self.ex = TransactionServiceException()
9288 
          self.ex.read(iprot)
9289 
        else:
9290 
          iprot.skip(ftype)
9291 
      else:
9292 
        iprot.skip(ftype)
9293 
      iprot.readFieldEnd()
9294 
    iprot.readStructEnd()
9295 
 
9296 
  def write(self, oprot):
9297 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9298 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9299 
      return
9300 
    oprot.writeStructBegin('getTransaction_result')
3431 rajveer 9301 
    if self.success is not None:
94 ashish 9302 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
9303 
      self.success.write(oprot)
9304 
      oprot.writeFieldEnd()
3431 rajveer 9305 
    if self.ex is not None:
94 ashish 9306 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9307 
      self.ex.write(oprot)
9308 
      oprot.writeFieldEnd()
9309 
    oprot.writeFieldStop()
9310 
    oprot.writeStructEnd()
9311 
 
3431 rajveer 9312 
  def validate(self):
9313 
    return
9314 
 
9315 
 
94 ashish 9316 
  def __repr__(self):
9317 
    L = ['%s=%r' % (key, value)
9318 
      for key, value in self.__dict__.iteritems()]
9319 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9320 
 
9321 
  def __eq__(self, other):
9322 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9323 
 
9324 
  def __ne__(self, other):
9325 
    return not (self == other)
9326 
 
9327 
class getTransactionsForCustomer_args:
9328 
  """
9329 
  Attributes:
9330 
   - customerId
9331 
   - from_date
9332 
   - to_date
9333 
   - status
9334 
  """
9335 
 
9336 
  thrift_spec = (
9337 
    None, # 0
9338 
    (1, TType.I64, 'customerId', None, None, ), # 1
9339 
    (2, TType.I64, 'from_date', None, None, ), # 2
9340 
    (3, TType.I64, 'to_date', None, None, ), # 3
9341 
    (4, TType.I32, 'status', None, None, ), # 4
9342 
  )
9343 
 
9344 
  def __init__(self, customerId=None, from_date=None, to_date=None, status=None,):
9345 
    self.customerId = customerId
9346 
    self.from_date = from_date
9347 
    self.to_date = to_date
9348 
    self.status = status
9349 
 
9350 
  def read(self, iprot):
9351 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9352 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9353 
      return
9354 
    iprot.readStructBegin()
9355 
    while True:
9356 
      (fname, ftype, fid) = iprot.readFieldBegin()
9357 
      if ftype == TType.STOP:
9358 
        break
9359 
      if fid == 1:
9360 
        if ftype == TType.I64:
9361 
          self.customerId = iprot.readI64();
9362 
        else:
9363 
          iprot.skip(ftype)
9364 
      elif fid == 2:
9365 
        if ftype == TType.I64:
9366 
          self.from_date = iprot.readI64();
9367 
        else:
9368 
          iprot.skip(ftype)
9369 
      elif fid == 3:
9370 
        if ftype == TType.I64:
9371 
          self.to_date = iprot.readI64();
9372 
        else:
9373 
          iprot.skip(ftype)
9374 
      elif fid == 4:
9375 
        if ftype == TType.I32:
9376 
          self.status = iprot.readI32();
9377 
        else:
9378 
          iprot.skip(ftype)
9379 
      else:
9380 
        iprot.skip(ftype)
9381 
      iprot.readFieldEnd()
9382 
    iprot.readStructEnd()
9383 
 
9384 
  def write(self, oprot):
9385 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9386 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9387 
      return
9388 
    oprot.writeStructBegin('getTransactionsForCustomer_args')
3431 rajveer 9389 
    if self.customerId is not None:
94 ashish 9390 
      oprot.writeFieldBegin('customerId', TType.I64, 1)
9391 
      oprot.writeI64(self.customerId)
9392 
      oprot.writeFieldEnd()
3431 rajveer 9393 
    if self.from_date is not None:
94 ashish 9394 
      oprot.writeFieldBegin('from_date', TType.I64, 2)
9395 
      oprot.writeI64(self.from_date)
9396 
      oprot.writeFieldEnd()
3431 rajveer 9397 
    if self.to_date is not None:
94 ashish 9398 
      oprot.writeFieldBegin('to_date', TType.I64, 3)
9399 
      oprot.writeI64(self.to_date)
9400 
      oprot.writeFieldEnd()
3431 rajveer 9401 
    if self.status is not None:
94 ashish 9402 
      oprot.writeFieldBegin('status', TType.I32, 4)
9403 
      oprot.writeI32(self.status)
9404 
      oprot.writeFieldEnd()
9405 
    oprot.writeFieldStop()
9406 
    oprot.writeStructEnd()
9407 
 
3431 rajveer 9408 
  def validate(self):
9409 
    return
9410 
 
9411 
 
94 ashish 9412 
  def __repr__(self):
9413 
    L = ['%s=%r' % (key, value)
9414 
      for key, value in self.__dict__.iteritems()]
9415 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9416 
 
9417 
  def __eq__(self, other):
9418 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9419 
 
9420 
  def __ne__(self, other):
9421 
    return not (self == other)
9422 
 
9423 
class getTransactionsForCustomer_result:
9424 
  """
9425 
  Attributes:
9426 
   - success
9427 
   - ex
9428 
  """
9429 
 
9430 
  thrift_spec = (
9431 
    (0, TType.LIST, 'success', (TType.STRUCT,(Transaction, Transaction.thrift_spec)), None, ), # 0
9432 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
9433 
  )
9434 
 
9435 
  def __init__(self, success=None, ex=None,):
9436 
    self.success = success
9437 
    self.ex = ex
9438 
 
9439 
  def read(self, iprot):
9440 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9441 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9442 
      return
9443 
    iprot.readStructBegin()
9444 
    while True:
9445 
      (fname, ftype, fid) = iprot.readFieldBegin()
9446 
      if ftype == TType.STOP:
9447 
        break
9448 
      if fid == 0:
9449 
        if ftype == TType.LIST:
9450 
          self.success = []
6188 rajveer 9451 
          (_etype109, _size106) = iprot.readListBegin()
9452 
          for _i110 in xrange(_size106):
9453 
            _elem111 = Transaction()
9454 
            _elem111.read(iprot)
9455 
            self.success.append(_elem111)
94 ashish 9456 
          iprot.readListEnd()
9457 
        else:
9458 
          iprot.skip(ftype)
9459 
      elif fid == 1:
9460 
        if ftype == TType.STRUCT:
9461 
          self.ex = TransactionServiceException()
9462 
          self.ex.read(iprot)
9463 
        else:
9464 
          iprot.skip(ftype)
9465 
      else:
9466 
        iprot.skip(ftype)
9467 
      iprot.readFieldEnd()
9468 
    iprot.readStructEnd()
9469 
 
9470 
  def write(self, oprot):
9471 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9472 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9473 
      return
9474 
    oprot.writeStructBegin('getTransactionsForCustomer_result')
3431 rajveer 9475 
    if self.success is not None:
94 ashish 9476 
      oprot.writeFieldBegin('success', TType.LIST, 0)
9477 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 9478 
      for iter112 in self.success:
9479 
        iter112.write(oprot)
94 ashish 9480 
      oprot.writeListEnd()
9481 
      oprot.writeFieldEnd()
3431 rajveer 9482 
    if self.ex is not None:
94 ashish 9483 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9484 
      self.ex.write(oprot)
9485 
      oprot.writeFieldEnd()
9486 
    oprot.writeFieldStop()
9487 
    oprot.writeStructEnd()
9488 
 
3431 rajveer 9489 
  def validate(self):
9490 
    return
9491 
 
9492 
 
94 ashish 9493 
  def __repr__(self):
9494 
    L = ['%s=%r' % (key, value)
9495 
      for key, value in self.__dict__.iteritems()]
9496 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9497 
 
9498 
  def __eq__(self, other):
9499 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9500 
 
9501 
  def __ne__(self, other):
9502 
    return not (self == other)
9503 
 
132 ashish 9504 
class getTransactionsForShoppingCartId_args:
9505 
  """
9506 
  Attributes:
9507 
   - shoppingCartId
9508 
  """
9509 
 
9510 
  thrift_spec = (
9511 
    None, # 0
9512 
    (1, TType.I64, 'shoppingCartId', None, None, ), # 1
9513 
  )
9514 
 
9515 
  def __init__(self, shoppingCartId=None,):
9516 
    self.shoppingCartId = shoppingCartId
9517 
 
9518 
  def read(self, iprot):
9519 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9520 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9521 
      return
9522 
    iprot.readStructBegin()
9523 
    while True:
9524 
      (fname, ftype, fid) = iprot.readFieldBegin()
9525 
      if ftype == TType.STOP:
9526 
        break
9527 
      if fid == 1:
9528 
        if ftype == TType.I64:
9529 
          self.shoppingCartId = iprot.readI64();
9530 
        else:
9531 
          iprot.skip(ftype)
9532 
      else:
9533 
        iprot.skip(ftype)
9534 
      iprot.readFieldEnd()
9535 
    iprot.readStructEnd()
9536 
 
9537 
  def write(self, oprot):
9538 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9539 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9540 
      return
9541 
    oprot.writeStructBegin('getTransactionsForShoppingCartId_args')
3431 rajveer 9542 
    if self.shoppingCartId is not None:
132 ashish 9543 
      oprot.writeFieldBegin('shoppingCartId', TType.I64, 1)
9544 
      oprot.writeI64(self.shoppingCartId)
9545 
      oprot.writeFieldEnd()
9546 
    oprot.writeFieldStop()
9547 
    oprot.writeStructEnd()
9548 
 
3431 rajveer 9549 
  def validate(self):
9550 
    return
9551 
 
9552 
 
132 ashish 9553 
  def __repr__(self):
9554 
    L = ['%s=%r' % (key, value)
9555 
      for key, value in self.__dict__.iteritems()]
9556 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9557 
 
9558 
  def __eq__(self, other):
9559 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9560 
 
9561 
  def __ne__(self, other):
9562 
    return not (self == other)
9563 
 
9564 
class getTransactionsForShoppingCartId_result:
9565 
  """
9566 
  Attributes:
9567 
   - success
9568 
   - ex
9569 
  """
9570 
 
9571 
  thrift_spec = (
9572 
    (0, TType.LIST, 'success', (TType.STRUCT,(Transaction, Transaction.thrift_spec)), None, ), # 0
9573 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
9574 
  )
9575 
 
9576 
  def __init__(self, success=None, ex=None,):
9577 
    self.success = success
9578 
    self.ex = ex
9579 
 
9580 
  def read(self, iprot):
9581 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9582 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9583 
      return
9584 
    iprot.readStructBegin()
9585 
    while True:
9586 
      (fname, ftype, fid) = iprot.readFieldBegin()
9587 
      if ftype == TType.STOP:
9588 
        break
9589 
      if fid == 0:
9590 
        if ftype == TType.LIST:
9591 
          self.success = []
6188 rajveer 9592 
          (_etype116, _size113) = iprot.readListBegin()
9593 
          for _i117 in xrange(_size113):
9594 
            _elem118 = Transaction()
9595 
            _elem118.read(iprot)
9596 
            self.success.append(_elem118)
132 ashish 9597 
          iprot.readListEnd()
9598 
        else:
9599 
          iprot.skip(ftype)
9600 
      elif fid == 1:
9601 
        if ftype == TType.STRUCT:
9602 
          self.ex = TransactionServiceException()
9603 
          self.ex.read(iprot)
9604 
        else:
9605 
          iprot.skip(ftype)
9606 
      else:
9607 
        iprot.skip(ftype)
9608 
      iprot.readFieldEnd()
9609 
    iprot.readStructEnd()
9610 
 
9611 
  def write(self, oprot):
9612 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9613 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9614 
      return
9615 
    oprot.writeStructBegin('getTransactionsForShoppingCartId_result')
3431 rajveer 9616 
    if self.success is not None:
132 ashish 9617 
      oprot.writeFieldBegin('success', TType.LIST, 0)
9618 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 9619 
      for iter119 in self.success:
9620 
        iter119.write(oprot)
132 ashish 9621 
      oprot.writeListEnd()
9622 
      oprot.writeFieldEnd()
3431 rajveer 9623 
    if self.ex is not None:
132 ashish 9624 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9625 
      self.ex.write(oprot)
9626 
      oprot.writeFieldEnd()
9627 
    oprot.writeFieldStop()
9628 
    oprot.writeStructEnd()
9629 
 
3431 rajveer 9630 
  def validate(self):
9631 
    return
9632 
 
9633 
 
132 ashish 9634 
  def __repr__(self):
9635 
    L = ['%s=%r' % (key, value)
9636 
      for key, value in self.__dict__.iteritems()]
9637 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9638 
 
9639 
  def __eq__(self, other):
9640 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9641 
 
9642 
  def __ne__(self, other):
9643 
    return not (self == other)
9644 
 
94 ashish 9645 
class getTransactionStatus_args:
9646 
  """
9647 
  Attributes:
9648 
   - transactionId
9649 
  """
9650 
 
9651 
  thrift_spec = (
9652 
    None, # 0
9653 
    (1, TType.I64, 'transactionId', None, None, ), # 1
9654 
  )
9655 
 
9656 
  def __init__(self, transactionId=None,):
9657 
    self.transactionId = transactionId
9658 
 
9659 
  def read(self, iprot):
9660 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9661 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9662 
      return
9663 
    iprot.readStructBegin()
9664 
    while True:
9665 
      (fname, ftype, fid) = iprot.readFieldBegin()
9666 
      if ftype == TType.STOP:
9667 
        break
9668 
      if fid == 1:
9669 
        if ftype == TType.I64:
9670 
          self.transactionId = iprot.readI64();
9671 
        else:
9672 
          iprot.skip(ftype)
9673 
      else:
9674 
        iprot.skip(ftype)
9675 
      iprot.readFieldEnd()
9676 
    iprot.readStructEnd()
9677 
 
9678 
  def write(self, oprot):
9679 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9680 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9681 
      return
9682 
    oprot.writeStructBegin('getTransactionStatus_args')
3431 rajveer 9683 
    if self.transactionId is not None:
94 ashish 9684 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
9685 
      oprot.writeI64(self.transactionId)
9686 
      oprot.writeFieldEnd()
9687 
    oprot.writeFieldStop()
9688 
    oprot.writeStructEnd()
9689 
 
3431 rajveer 9690 
  def validate(self):
9691 
    return
9692 
 
9693 
 
94 ashish 9694 
  def __repr__(self):
9695 
    L = ['%s=%r' % (key, value)
9696 
      for key, value in self.__dict__.iteritems()]
9697 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9698 
 
9699 
  def __eq__(self, other):
9700 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9701 
 
9702 
  def __ne__(self, other):
9703 
    return not (self == other)
9704 
 
9705 
class getTransactionStatus_result:
9706 
  """
9707 
  Attributes:
9708 
   - success
9709 
   - ex
9710 
  """
9711 
 
9712 
  thrift_spec = (
9713 
    (0, TType.I32, 'success', None, None, ), # 0
9714 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
9715 
  )
9716 
 
9717 
  def __init__(self, success=None, ex=None,):
9718 
    self.success = success
9719 
    self.ex = ex
9720 
 
9721 
  def read(self, iprot):
9722 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9723 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9724 
      return
9725 
    iprot.readStructBegin()
9726 
    while True:
9727 
      (fname, ftype, fid) = iprot.readFieldBegin()
9728 
      if ftype == TType.STOP:
9729 
        break
9730 
      if fid == 0:
9731 
        if ftype == TType.I32:
9732 
          self.success = iprot.readI32();
9733 
        else:
9734 
          iprot.skip(ftype)
9735 
      elif fid == 1:
9736 
        if ftype == TType.STRUCT:
9737 
          self.ex = TransactionServiceException()
9738 
          self.ex.read(iprot)
9739 
        else:
9740 
          iprot.skip(ftype)
9741 
      else:
9742 
        iprot.skip(ftype)
9743 
      iprot.readFieldEnd()
9744 
    iprot.readStructEnd()
9745 
 
9746 
  def write(self, oprot):
9747 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9748 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9749 
      return
9750 
    oprot.writeStructBegin('getTransactionStatus_result')
3431 rajveer 9751 
    if self.success is not None:
94 ashish 9752 
      oprot.writeFieldBegin('success', TType.I32, 0)
9753 
      oprot.writeI32(self.success)
9754 
      oprot.writeFieldEnd()
3431 rajveer 9755 
    if self.ex is not None:
94 ashish 9756 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9757 
      self.ex.write(oprot)
9758 
      oprot.writeFieldEnd()
9759 
    oprot.writeFieldStop()
9760 
    oprot.writeStructEnd()
9761 
 
3431 rajveer 9762 
  def validate(self):
9763 
    return
9764 
 
9765 
 
94 ashish 9766 
  def __repr__(self):
9767 
    L = ['%s=%r' % (key, value)
9768 
      for key, value in self.__dict__.iteritems()]
9769 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9770 
 
9771 
  def __eq__(self, other):
9772 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9773 
 
9774 
  def __ne__(self, other):
9775 
    return not (self == other)
9776 
 
9777 
class changeTransactionStatus_args:
9778 
  """
9779 
  Attributes:
9780 
   - transactionId
9781 
   - status
9782 
   - description
5527 anupam.sin 9783 
   - pickUp
9784 
   - orderType
94 ashish 9785 
  """
9786 
 
9787 
  thrift_spec = (
9788 
    None, # 0
9789 
    (1, TType.I64, 'transactionId', None, None, ), # 1
9790 
    (2, TType.I32, 'status', None, None, ), # 2
9791 
    (3, TType.STRING, 'description', None, None, ), # 3
5527 anupam.sin 9792 
    (4, TType.I64, 'pickUp', None, None, ), # 4
9793 
    (5, TType.I32, 'orderType', None, None, ), # 5
94 ashish 9794 
  )
9795 
 
5527 anupam.sin 9796 
  def __init__(self, transactionId=None, status=None, description=None, pickUp=None, orderType=None,):
94 ashish 9797 
    self.transactionId = transactionId
9798 
    self.status = status
9799 
    self.description = description
5527 anupam.sin 9800 
    self.pickUp = pickUp
9801 
    self.orderType = orderType
94 ashish 9802 
 
9803 
  def read(self, iprot):
9804 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9805 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9806 
      return
9807 
    iprot.readStructBegin()
9808 
    while True:
9809 
      (fname, ftype, fid) = iprot.readFieldBegin()
9810 
      if ftype == TType.STOP:
9811 
        break
9812 
      if fid == 1:
9813 
        if ftype == TType.I64:
9814 
          self.transactionId = iprot.readI64();
9815 
        else:
9816 
          iprot.skip(ftype)
9817 
      elif fid == 2:
9818 
        if ftype == TType.I32:
9819 
          self.status = iprot.readI32();
9820 
        else:
9821 
          iprot.skip(ftype)
9822 
      elif fid == 3:
9823 
        if ftype == TType.STRING:
9824 
          self.description = iprot.readString();
9825 
        else:
9826 
          iprot.skip(ftype)
5387 rajveer 9827 
      elif fid == 4:
5527 anupam.sin 9828 
        if ftype == TType.I64:
9829 
          self.pickUp = iprot.readI64();
5387 rajveer 9830 
        else:
9831 
          iprot.skip(ftype)
5527 anupam.sin 9832 
      elif fid == 5:
9833 
        if ftype == TType.I32:
9834 
          self.orderType = iprot.readI32();
9835 
        else:
9836 
          iprot.skip(ftype)
94 ashish 9837 
      else:
9838 
        iprot.skip(ftype)
9839 
      iprot.readFieldEnd()
9840 
    iprot.readStructEnd()
9841 
 
9842 
  def write(self, oprot):
9843 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9844 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9845 
      return
9846 
    oprot.writeStructBegin('changeTransactionStatus_args')
3431 rajveer 9847 
    if self.transactionId is not None:
94 ashish 9848 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
9849 
      oprot.writeI64(self.transactionId)
9850 
      oprot.writeFieldEnd()
3431 rajveer 9851 
    if self.status is not None:
94 ashish 9852 
      oprot.writeFieldBegin('status', TType.I32, 2)
9853 
      oprot.writeI32(self.status)
9854 
      oprot.writeFieldEnd()
3431 rajveer 9855 
    if self.description is not None:
94 ashish 9856 
      oprot.writeFieldBegin('description', TType.STRING, 3)
9857 
      oprot.writeString(self.description)
9858 
      oprot.writeFieldEnd()
5527 anupam.sin 9859 
    if self.pickUp is not None:
9860 
      oprot.writeFieldBegin('pickUp', TType.I64, 4)
9861 
      oprot.writeI64(self.pickUp)
5387 rajveer 9862 
      oprot.writeFieldEnd()
5527 anupam.sin 9863 
    if self.orderType is not None:
9864 
      oprot.writeFieldBegin('orderType', TType.I32, 5)
9865 
      oprot.writeI32(self.orderType)
9866 
      oprot.writeFieldEnd()
94 ashish 9867 
    oprot.writeFieldStop()
9868 
    oprot.writeStructEnd()
9869 
 
3431 rajveer 9870 
  def validate(self):
9871 
    return
9872 
 
9873 
 
94 ashish 9874 
  def __repr__(self):
9875 
    L = ['%s=%r' % (key, value)
9876 
      for key, value in self.__dict__.iteritems()]
9877 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9878 
 
9879 
  def __eq__(self, other):
9880 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9881 
 
9882 
  def __ne__(self, other):
9883 
    return not (self == other)
9884 
 
9885 
class changeTransactionStatus_result:
9886 
  """
9887 
  Attributes:
9888 
   - success
9889 
   - ex
9890 
  """
9891 
 
9892 
  thrift_spec = (
9893 
    (0, TType.BOOL, 'success', None, None, ), # 0
9894 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
9895 
  )
9896 
 
9897 
  def __init__(self, success=None, ex=None,):
9898 
    self.success = success
9899 
    self.ex = ex
9900 
 
9901 
  def read(self, iprot):
9902 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9903 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9904 
      return
9905 
    iprot.readStructBegin()
9906 
    while True:
9907 
      (fname, ftype, fid) = iprot.readFieldBegin()
9908 
      if ftype == TType.STOP:
9909 
        break
9910 
      if fid == 0:
9911 
        if ftype == TType.BOOL:
9912 
          self.success = iprot.readBool();
9913 
        else:
9914 
          iprot.skip(ftype)
9915 
      elif fid == 1:
9916 
        if ftype == TType.STRUCT:
9917 
          self.ex = TransactionServiceException()
9918 
          self.ex.read(iprot)
9919 
        else:
9920 
          iprot.skip(ftype)
9921 
      else:
9922 
        iprot.skip(ftype)
9923 
      iprot.readFieldEnd()
9924 
    iprot.readStructEnd()
9925 
 
9926 
  def write(self, oprot):
9927 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9928 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9929 
      return
9930 
    oprot.writeStructBegin('changeTransactionStatus_result')
3431 rajveer 9931 
    if self.success is not None:
94 ashish 9932 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
9933 
      oprot.writeBool(self.success)
9934 
      oprot.writeFieldEnd()
3431 rajveer 9935 
    if self.ex is not None:
94 ashish 9936 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9937 
      self.ex.write(oprot)
9938 
      oprot.writeFieldEnd()
9939 
    oprot.writeFieldStop()
9940 
    oprot.writeStructEnd()
9941 
 
3431 rajveer 9942 
  def validate(self):
9943 
    return
9944 
 
9945 
 
94 ashish 9946 
  def __repr__(self):
9947 
    L = ['%s=%r' % (key, value)
9948 
      for key, value in self.__dict__.iteritems()]
9949 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9950 
 
9951 
  def __eq__(self, other):
9952 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9953 
 
9954 
  def __ne__(self, other):
9955 
    return not (self == other)
9956 
 
1398 varun.gupt 9957 
class enqueueTransactionInfoEmail_args:
1382 varun.gupt 9958 
  """
9959 
  Attributes:
9960 
   - transactionId
9961 
  """
9962 
 
9963 
  thrift_spec = (
9964 
    None, # 0
9965 
    (1, TType.I64, 'transactionId', None, None, ), # 1
9966 
  )
9967 
 
9968 
  def __init__(self, transactionId=None,):
9969 
    self.transactionId = transactionId
9970 
 
9971 
  def read(self, iprot):
9972 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9973 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9974 
      return
9975 
    iprot.readStructBegin()
9976 
    while True:
9977 
      (fname, ftype, fid) = iprot.readFieldBegin()
9978 
      if ftype == TType.STOP:
9979 
        break
9980 
      if fid == 1:
9981 
        if ftype == TType.I64:
9982 
          self.transactionId = iprot.readI64();
9983 
        else:
9984 
          iprot.skip(ftype)
9985 
      else:
9986 
        iprot.skip(ftype)
9987 
      iprot.readFieldEnd()
9988 
    iprot.readStructEnd()
9989 
 
9990 
  def write(self, oprot):
9991 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9992 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9993 
      return
1398 varun.gupt 9994 
    oprot.writeStructBegin('enqueueTransactionInfoEmail_args')
3431 rajveer 9995 
    if self.transactionId is not None:
1382 varun.gupt 9996 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
9997 
      oprot.writeI64(self.transactionId)
9998 
      oprot.writeFieldEnd()
9999 
    oprot.writeFieldStop()
10000 
    oprot.writeStructEnd()
10001 
 
3431 rajveer 10002 
  def validate(self):
10003 
    return
10004 
 
10005 
 
1382 varun.gupt 10006 
  def __repr__(self):
10007 
    L = ['%s=%r' % (key, value)
10008 
      for key, value in self.__dict__.iteritems()]
10009 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10010 
 
10011 
  def __eq__(self, other):
10012 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10013 
 
10014 
  def __ne__(self, other):
10015 
    return not (self == other)
10016 
 
1398 varun.gupt 10017 
class enqueueTransactionInfoEmail_result:
1382 varun.gupt 10018 
  """
10019 
  Attributes:
10020 
   - success
10021 
   - ex
10022 
  """
10023 
 
10024 
  thrift_spec = (
10025 
    (0, TType.BOOL, 'success', None, None, ), # 0
10026 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
10027 
  )
10028 
 
10029 
  def __init__(self, success=None, ex=None,):
10030 
    self.success = success
10031 
    self.ex = ex
10032 
 
10033 
  def read(self, iprot):
10034 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10035 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10036 
      return
10037 
    iprot.readStructBegin()
10038 
    while True:
10039 
      (fname, ftype, fid) = iprot.readFieldBegin()
10040 
      if ftype == TType.STOP:
10041 
        break
10042 
      if fid == 0:
10043 
        if ftype == TType.BOOL:
10044 
          self.success = iprot.readBool();
10045 
        else:
10046 
          iprot.skip(ftype)
10047 
      elif fid == 1:
10048 
        if ftype == TType.STRUCT:
10049 
          self.ex = TransactionServiceException()
10050 
          self.ex.read(iprot)
10051 
        else:
10052 
          iprot.skip(ftype)
10053 
      else:
10054 
        iprot.skip(ftype)
10055 
      iprot.readFieldEnd()
10056 
    iprot.readStructEnd()
10057 
 
10058 
  def write(self, oprot):
10059 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10060 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10061 
      return
1398 varun.gupt 10062 
    oprot.writeStructBegin('enqueueTransactionInfoEmail_result')
3431 rajveer 10063 
    if self.success is not None:
1382 varun.gupt 10064 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
10065 
      oprot.writeBool(self.success)
10066 
      oprot.writeFieldEnd()
3431 rajveer 10067 
    if self.ex is not None:
1382 varun.gupt 10068 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10069 
      self.ex.write(oprot)
10070 
      oprot.writeFieldEnd()
10071 
    oprot.writeFieldStop()
10072 
    oprot.writeStructEnd()
10073 
 
3431 rajveer 10074 
  def validate(self):
10075 
    return
10076 
 
10077 
 
1382 varun.gupt 10078 
  def __repr__(self):
10079 
    L = ['%s=%r' % (key, value)
10080 
      for key, value in self.__dict__.iteritems()]
10081 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10082 
 
10083 
  def __eq__(self, other):
10084 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10085 
 
10086 
  def __ne__(self, other):
10087 
    return not (self == other)
10088 
 
483 rajveer 10089 
class getAllOrders_args:
94 ashish 10090 
  """
10091 
  Attributes:
4801 anupam.sin 10092 
   - statuses
483 rajveer 10093 
   - from_date
10094 
   - to_date
10095 
   - warehouse_id
94 ashish 10096 
  """
10097 
 
10098 
  thrift_spec = (
10099 
    None, # 0
4801 anupam.sin 10100 
    (1, TType.LIST, 'statuses', (TType.I32,None), None, ), # 1
483 rajveer 10101 
    (2, TType.I64, 'from_date', None, None, ), # 2
10102 
    (3, TType.I64, 'to_date', None, None, ), # 3
10103 
    (4, TType.I64, 'warehouse_id', None, None, ), # 4
94 ashish 10104 
  )
10105 
 
4801 anupam.sin 10106 
  def __init__(self, statuses=None, from_date=None, to_date=None, warehouse_id=None,):
10107 
    self.statuses = statuses
483 rajveer 10108 
    self.from_date = from_date
10109 
    self.to_date = to_date
10110 
    self.warehouse_id = warehouse_id
94 ashish 10111 
 
10112 
  def read(self, iprot):
10113 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10114 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10115 
      return
10116 
    iprot.readStructBegin()
10117 
    while True:
10118 
      (fname, ftype, fid) = iprot.readFieldBegin()
10119 
      if ftype == TType.STOP:
10120 
        break
10121 
      if fid == 1:
4801 anupam.sin 10122 
        if ftype == TType.LIST:
10123 
          self.statuses = []
6188 rajveer 10124 
          (_etype123, _size120) = iprot.readListBegin()
10125 
          for _i124 in xrange(_size120):
10126 
            _elem125 = iprot.readI32();
10127 
            self.statuses.append(_elem125)
4801 anupam.sin 10128 
          iprot.readListEnd()
94 ashish 10129 
        else:
10130 
          iprot.skip(ftype)
483 rajveer 10131 
      elif fid == 2:
10132 
        if ftype == TType.I64:
10133 
          self.from_date = iprot.readI64();
94 ashish 10134 
        else:
10135 
          iprot.skip(ftype)
483 rajveer 10136 
      elif fid == 3:
10137 
        if ftype == TType.I64:
10138 
          self.to_date = iprot.readI64();
94 ashish 10139 
        else:
10140 
          iprot.skip(ftype)
483 rajveer 10141 
      elif fid == 4:
94 ashish 10142 
        if ftype == TType.I64:
483 rajveer 10143 
          self.warehouse_id = iprot.readI64();
94 ashish 10144 
        else:
10145 
          iprot.skip(ftype)
10146 
      else:
10147 
        iprot.skip(ftype)
10148 
      iprot.readFieldEnd()
10149 
    iprot.readStructEnd()
10150 
 
10151 
  def write(self, oprot):
10152 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10153 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10154 
      return
483 rajveer 10155 
    oprot.writeStructBegin('getAllOrders_args')
4801 anupam.sin 10156 
    if self.statuses is not None:
10157 
      oprot.writeFieldBegin('statuses', TType.LIST, 1)
10158 
      oprot.writeListBegin(TType.I32, len(self.statuses))
6188 rajveer 10159 
      for iter126 in self.statuses:
10160 
        oprot.writeI32(iter126)
4801 anupam.sin 10161 
      oprot.writeListEnd()
94 ashish 10162 
      oprot.writeFieldEnd()
3431 rajveer 10163 
    if self.from_date is not None:
483 rajveer 10164 
      oprot.writeFieldBegin('from_date', TType.I64, 2)
10165 
      oprot.writeI64(self.from_date)
94 ashish 10166 
      oprot.writeFieldEnd()
3431 rajveer 10167 
    if self.to_date is not None:
483 rajveer 10168 
      oprot.writeFieldBegin('to_date', TType.I64, 3)
10169 
      oprot.writeI64(self.to_date)
94 ashish 10170 
      oprot.writeFieldEnd()
3431 rajveer 10171 
    if self.warehouse_id is not None:
483 rajveer 10172 
      oprot.writeFieldBegin('warehouse_id', TType.I64, 4)
10173 
      oprot.writeI64(self.warehouse_id)
94 ashish 10174 
      oprot.writeFieldEnd()
10175 
    oprot.writeFieldStop()
10176 
    oprot.writeStructEnd()
10177 
 
3431 rajveer 10178 
  def validate(self):
10179 
    return
10180 
 
10181 
 
94 ashish 10182 
  def __repr__(self):
10183 
    L = ['%s=%r' % (key, value)
10184 
      for key, value in self.__dict__.iteritems()]
10185 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10186 
 
10187 
  def __eq__(self, other):
10188 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10189 
 
10190 
  def __ne__(self, other):
10191 
    return not (self == other)
10192 
 
483 rajveer 10193 
class getAllOrders_result:
94 ashish 10194 
  """
10195 
  Attributes:
10196 
   - success
10197 
   - ex
10198 
  """
10199 
 
10200 
  thrift_spec = (
483 rajveer 10201 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
94 ashish 10202 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
10203 
  )
10204 
 
10205 
  def __init__(self, success=None, ex=None,):
10206 
    self.success = success
10207 
    self.ex = ex
10208 
 
10209 
  def read(self, iprot):
10210 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10211 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10212 
      return
10213 
    iprot.readStructBegin()
10214 
    while True:
10215 
      (fname, ftype, fid) = iprot.readFieldBegin()
10216 
      if ftype == TType.STOP:
10217 
        break
10218 
      if fid == 0:
483 rajveer 10219 
        if ftype == TType.LIST:
10220 
          self.success = []
6188 rajveer 10221 
          (_etype130, _size127) = iprot.readListBegin()
10222 
          for _i131 in xrange(_size127):
10223 
            _elem132 = Order()
10224 
            _elem132.read(iprot)
10225 
            self.success.append(_elem132)
483 rajveer 10226 
          iprot.readListEnd()
94 ashish 10227 
        else:
10228 
          iprot.skip(ftype)
10229 
      elif fid == 1:
10230 
        if ftype == TType.STRUCT:
10231 
          self.ex = TransactionServiceException()
10232 
          self.ex.read(iprot)
10233 
        else:
10234 
          iprot.skip(ftype)
10235 
      else:
10236 
        iprot.skip(ftype)
10237 
      iprot.readFieldEnd()
10238 
    iprot.readStructEnd()
10239 
 
10240 
  def write(self, oprot):
10241 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10242 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10243 
      return
483 rajveer 10244 
    oprot.writeStructBegin('getAllOrders_result')
3431 rajveer 10245 
    if self.success is not None:
483 rajveer 10246 
      oprot.writeFieldBegin('success', TType.LIST, 0)
10247 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 10248 
      for iter133 in self.success:
10249 
        iter133.write(oprot)
483 rajveer 10250 
      oprot.writeListEnd()
94 ashish 10251 
      oprot.writeFieldEnd()
3431 rajveer 10252 
    if self.ex is not None:
94 ashish 10253 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10254 
      self.ex.write(oprot)
10255 
      oprot.writeFieldEnd()
10256 
    oprot.writeFieldStop()
10257 
    oprot.writeStructEnd()
10258 
 
3431 rajveer 10259 
  def validate(self):
10260 
    return
10261 
 
10262 
 
94 ashish 10263 
  def __repr__(self):
10264 
    L = ['%s=%r' % (key, value)
10265 
      for key, value in self.__dict__.iteritems()]
10266 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10267 
 
10268 
  def __eq__(self, other):
10269 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10270 
 
10271 
  def __ne__(self, other):
10272 
    return not (self == other)
10273 
 
4133 chandransh 10274 
class getOrdersInBatch_args:
10275 
  """
10276 
  Attributes:
10277 
   - statuses
10278 
   - offset
10279 
   - limit
10280 
   - warehouse_id
10281 
  """
10282 
 
10283 
  thrift_spec = (
10284 
    None, # 0
10285 
    (1, TType.LIST, 'statuses', (TType.I32,None), None, ), # 1
10286 
    (2, TType.I64, 'offset', None, None, ), # 2
10287 
    (3, TType.I64, 'limit', None, None, ), # 3
10288 
    (4, TType.I64, 'warehouse_id', None, None, ), # 4
10289 
  )
10290 
 
10291 
  def __init__(self, statuses=None, offset=None, limit=None, warehouse_id=None,):
10292 
    self.statuses = statuses
10293 
    self.offset = offset
10294 
    self.limit = limit
10295 
    self.warehouse_id = warehouse_id
10296 
 
10297 
  def read(self, iprot):
10298 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10299 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10300 
      return
10301 
    iprot.readStructBegin()
10302 
    while True:
10303 
      (fname, ftype, fid) = iprot.readFieldBegin()
10304 
      if ftype == TType.STOP:
10305 
        break
10306 
      if fid == 1:
10307 
        if ftype == TType.LIST:
10308 
          self.statuses = []
6188 rajveer 10309 
          (_etype137, _size134) = iprot.readListBegin()
10310 
          for _i138 in xrange(_size134):
10311 
            _elem139 = iprot.readI32();
10312 
            self.statuses.append(_elem139)
4133 chandransh 10313 
          iprot.readListEnd()
10314 
        else:
10315 
          iprot.skip(ftype)
10316 
      elif fid == 2:
10317 
        if ftype == TType.I64:
10318 
          self.offset = iprot.readI64();
10319 
        else:
10320 
          iprot.skip(ftype)
10321 
      elif fid == 3:
10322 
        if ftype == TType.I64:
10323 
          self.limit = iprot.readI64();
10324 
        else:
10325 
          iprot.skip(ftype)
10326 
      elif fid == 4:
10327 
        if ftype == TType.I64:
10328 
          self.warehouse_id = iprot.readI64();
10329 
        else:
10330 
          iprot.skip(ftype)
10331 
      else:
10332 
        iprot.skip(ftype)
10333 
      iprot.readFieldEnd()
10334 
    iprot.readStructEnd()
10335 
 
10336 
  def write(self, oprot):
10337 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10338 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10339 
      return
10340 
    oprot.writeStructBegin('getOrdersInBatch_args')
10341 
    if self.statuses is not None:
10342 
      oprot.writeFieldBegin('statuses', TType.LIST, 1)
10343 
      oprot.writeListBegin(TType.I32, len(self.statuses))
6188 rajveer 10344 
      for iter140 in self.statuses:
10345 
        oprot.writeI32(iter140)
4133 chandransh 10346 
      oprot.writeListEnd()
10347 
      oprot.writeFieldEnd()
10348 
    if self.offset is not None:
10349 
      oprot.writeFieldBegin('offset', TType.I64, 2)
10350 
      oprot.writeI64(self.offset)
10351 
      oprot.writeFieldEnd()
10352 
    if self.limit is not None:
10353 
      oprot.writeFieldBegin('limit', TType.I64, 3)
10354 
      oprot.writeI64(self.limit)
10355 
      oprot.writeFieldEnd()
10356 
    if self.warehouse_id is not None:
10357 
      oprot.writeFieldBegin('warehouse_id', TType.I64, 4)
10358 
      oprot.writeI64(self.warehouse_id)
10359 
      oprot.writeFieldEnd()
10360 
    oprot.writeFieldStop()
10361 
    oprot.writeStructEnd()
10362 
 
10363 
  def validate(self):
10364 
    return
10365 
 
10366 
 
10367 
  def __repr__(self):
10368 
    L = ['%s=%r' % (key, value)
10369 
      for key, value in self.__dict__.iteritems()]
10370 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10371 
 
10372 
  def __eq__(self, other):
10373 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10374 
 
10375 
  def __ne__(self, other):
10376 
    return not (self == other)
10377 
 
10378 
class getOrdersInBatch_result:
10379 
  """
10380 
  Attributes:
10381 
   - success
10382 
   - ex
10383 
  """
10384 
 
10385 
  thrift_spec = (
10386 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
10387 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
10388 
  )
10389 
 
10390 
  def __init__(self, success=None, ex=None,):
10391 
    self.success = success
10392 
    self.ex = ex
10393 
 
10394 
  def read(self, iprot):
10395 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10396 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10397 
      return
10398 
    iprot.readStructBegin()
10399 
    while True:
10400 
      (fname, ftype, fid) = iprot.readFieldBegin()
10401 
      if ftype == TType.STOP:
10402 
        break
10403 
      if fid == 0:
10404 
        if ftype == TType.LIST:
10405 
          self.success = []
6188 rajveer 10406 
          (_etype144, _size141) = iprot.readListBegin()
10407 
          for _i145 in xrange(_size141):
10408 
            _elem146 = Order()
10409 
            _elem146.read(iprot)
10410 
            self.success.append(_elem146)
4133 chandransh 10411 
          iprot.readListEnd()
10412 
        else:
10413 
          iprot.skip(ftype)
10414 
      elif fid == 1:
10415 
        if ftype == TType.STRUCT:
10416 
          self.ex = TransactionServiceException()
10417 
          self.ex.read(iprot)
10418 
        else:
10419 
          iprot.skip(ftype)
10420 
      else:
10421 
        iprot.skip(ftype)
10422 
      iprot.readFieldEnd()
10423 
    iprot.readStructEnd()
10424 
 
10425 
  def write(self, oprot):
10426 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10427 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10428 
      return
10429 
    oprot.writeStructBegin('getOrdersInBatch_result')
10430 
    if self.success is not None:
10431 
      oprot.writeFieldBegin('success', TType.LIST, 0)
10432 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 10433 
      for iter147 in self.success:
10434 
        iter147.write(oprot)
4133 chandransh 10435 
      oprot.writeListEnd()
10436 
      oprot.writeFieldEnd()
10437 
    if self.ex is not None:
10438 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10439 
      self.ex.write(oprot)
10440 
      oprot.writeFieldEnd()
10441 
    oprot.writeFieldStop()
10442 
    oprot.writeStructEnd()
10443 
 
10444 
  def validate(self):
10445 
    return
10446 
 
10447 
 
10448 
  def __repr__(self):
10449 
    L = ['%s=%r' % (key, value)
10450 
      for key, value in self.__dict__.iteritems()]
10451 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10452 
 
10453 
  def __eq__(self, other):
10454 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10455 
 
10456 
  def __ne__(self, other):
10457 
    return not (self == other)
10458 
 
10459 
class getOrderCount_args:
10460 
  """
10461 
  Attributes:
10462 
   - statuses
10463 
   - warehouseId
10464 
  """
10465 
 
10466 
  thrift_spec = (
10467 
    None, # 0
10468 
    (1, TType.LIST, 'statuses', (TType.I32,None), None, ), # 1
10469 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
10470 
  )
10471 
 
10472 
  def __init__(self, statuses=None, warehouseId=None,):
10473 
    self.statuses = statuses
10474 
    self.warehouseId = warehouseId
10475 
 
10476 
  def read(self, iprot):
10477 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10478 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10479 
      return
10480 
    iprot.readStructBegin()
10481 
    while True:
10482 
      (fname, ftype, fid) = iprot.readFieldBegin()
10483 
      if ftype == TType.STOP:
10484 
        break
10485 
      if fid == 1:
10486 
        if ftype == TType.LIST:
10487 
          self.statuses = []
6188 rajveer 10488 
          (_etype151, _size148) = iprot.readListBegin()
10489 
          for _i152 in xrange(_size148):
10490 
            _elem153 = iprot.readI32();
10491 
            self.statuses.append(_elem153)
4133 chandransh 10492 
          iprot.readListEnd()
10493 
        else:
10494 
          iprot.skip(ftype)
10495 
      elif fid == 2:
10496 
        if ftype == TType.I64:
10497 
          self.warehouseId = iprot.readI64();
10498 
        else:
10499 
          iprot.skip(ftype)
10500 
      else:
10501 
        iprot.skip(ftype)
10502 
      iprot.readFieldEnd()
10503 
    iprot.readStructEnd()
10504 
 
10505 
  def write(self, oprot):
10506 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10507 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10508 
      return
10509 
    oprot.writeStructBegin('getOrderCount_args')
10510 
    if self.statuses is not None:
10511 
      oprot.writeFieldBegin('statuses', TType.LIST, 1)
10512 
      oprot.writeListBegin(TType.I32, len(self.statuses))
6188 rajveer 10513 
      for iter154 in self.statuses:
10514 
        oprot.writeI32(iter154)
4133 chandransh 10515 
      oprot.writeListEnd()
10516 
      oprot.writeFieldEnd()
10517 
    if self.warehouseId is not None:
10518 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
10519 
      oprot.writeI64(self.warehouseId)
10520 
      oprot.writeFieldEnd()
10521 
    oprot.writeFieldStop()
10522 
    oprot.writeStructEnd()
10523 
 
10524 
  def validate(self):
10525 
    return
10526 
 
10527 
 
10528 
  def __repr__(self):
10529 
    L = ['%s=%r' % (key, value)
10530 
      for key, value in self.__dict__.iteritems()]
10531 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10532 
 
10533 
  def __eq__(self, other):
10534 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10535 
 
10536 
  def __ne__(self, other):
10537 
    return not (self == other)
10538 
 
10539 
class getOrderCount_result:
10540 
  """
10541 
  Attributes:
10542 
   - success
10543 
   - ex
10544 
  """
10545 
 
10546 
  thrift_spec = (
10547 
    (0, TType.I32, 'success', None, None, ), # 0
10548 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
10549 
  )
10550 
 
10551 
  def __init__(self, success=None, ex=None,):
10552 
    self.success = success
10553 
    self.ex = ex
10554 
 
10555 
  def read(self, iprot):
10556 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10557 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10558 
      return
10559 
    iprot.readStructBegin()
10560 
    while True:
10561 
      (fname, ftype, fid) = iprot.readFieldBegin()
10562 
      if ftype == TType.STOP:
10563 
        break
10564 
      if fid == 0:
10565 
        if ftype == TType.I32:
10566 
          self.success = iprot.readI32();
10567 
        else:
10568 
          iprot.skip(ftype)
10569 
      elif fid == 1:
10570 
        if ftype == TType.STRUCT:
10571 
          self.ex = TransactionServiceException()
10572 
          self.ex.read(iprot)
10573 
        else:
10574 
          iprot.skip(ftype)
10575 
      else:
10576 
        iprot.skip(ftype)
10577 
      iprot.readFieldEnd()
10578 
    iprot.readStructEnd()
10579 
 
10580 
  def write(self, oprot):
10581 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10582 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10583 
      return
10584 
    oprot.writeStructBegin('getOrderCount_result')
10585 
    if self.success is not None:
10586 
      oprot.writeFieldBegin('success', TType.I32, 0)
10587 
      oprot.writeI32(self.success)
10588 
      oprot.writeFieldEnd()
10589 
    if self.ex is not None:
10590 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10591 
      self.ex.write(oprot)
10592 
      oprot.writeFieldEnd()
10593 
    oprot.writeFieldStop()
10594 
    oprot.writeStructEnd()
10595 
 
10596 
  def validate(self):
10597 
    return
10598 
 
10599 
 
10600 
  def __repr__(self):
10601 
    L = ['%s=%r' % (key, value)
10602 
      for key, value in self.__dict__.iteritems()]
10603 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10604 
 
10605 
  def __eq__(self, other):
10606 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10607 
 
10608 
  def __ne__(self, other):
10609 
    return not (self == other)
10610 
 
999 varun.gupt 10611 
class getOrdersByBillingDate_args:
10612 
  """
10613 
  Attributes:
10614 
   - status
10615 
   - start_billing_date
10616 
   - end_billing_date
10617 
   - warehouse_id
10618 
  """
10619 
 
10620 
  thrift_spec = (
10621 
    None, # 0
10622 
    (1, TType.I32, 'status', None, None, ), # 1
10623 
    (2, TType.I64, 'start_billing_date', None, None, ), # 2
10624 
    (3, TType.I64, 'end_billing_date', None, None, ), # 3
10625 
    (4, TType.I64, 'warehouse_id', None, None, ), # 4
10626 
  )
10627 
 
10628 
  def __init__(self, status=None, start_billing_date=None, end_billing_date=None, warehouse_id=None,):
10629 
    self.status = status
10630 
    self.start_billing_date = start_billing_date
10631 
    self.end_billing_date = end_billing_date
10632 
    self.warehouse_id = warehouse_id
10633 
 
10634 
  def read(self, iprot):
10635 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10636 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10637 
      return
10638 
    iprot.readStructBegin()
10639 
    while True:
10640 
      (fname, ftype, fid) = iprot.readFieldBegin()
10641 
      if ftype == TType.STOP:
10642 
        break
10643 
      if fid == 1:
10644 
        if ftype == TType.I32:
10645 
          self.status = iprot.readI32();
10646 
        else:
10647 
          iprot.skip(ftype)
10648 
      elif fid == 2:
10649 
        if ftype == TType.I64:
10650 
          self.start_billing_date = iprot.readI64();
10651 
        else:
10652 
          iprot.skip(ftype)
10653 
      elif fid == 3:
10654 
        if ftype == TType.I64:
10655 
          self.end_billing_date = iprot.readI64();
10656 
        else:
10657 
          iprot.skip(ftype)
10658 
      elif fid == 4:
10659 
        if ftype == TType.I64:
10660 
          self.warehouse_id = iprot.readI64();
10661 
        else:
10662 
          iprot.skip(ftype)
10663 
      else:
10664 
        iprot.skip(ftype)
10665 
      iprot.readFieldEnd()
10666 
    iprot.readStructEnd()
10667 
 
10668 
  def write(self, oprot):
10669 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10670 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10671 
      return
10672 
    oprot.writeStructBegin('getOrdersByBillingDate_args')
3431 rajveer 10673 
    if self.status is not None:
999 varun.gupt 10674 
      oprot.writeFieldBegin('status', TType.I32, 1)
10675 
      oprot.writeI32(self.status)
10676 
      oprot.writeFieldEnd()
3431 rajveer 10677 
    if self.start_billing_date is not None:
999 varun.gupt 10678 
      oprot.writeFieldBegin('start_billing_date', TType.I64, 2)
10679 
      oprot.writeI64(self.start_billing_date)
10680 
      oprot.writeFieldEnd()
3431 rajveer 10681 
    if self.end_billing_date is not None:
999 varun.gupt 10682 
      oprot.writeFieldBegin('end_billing_date', TType.I64, 3)
10683 
      oprot.writeI64(self.end_billing_date)
10684 
      oprot.writeFieldEnd()
3431 rajveer 10685 
    if self.warehouse_id is not None:
999 varun.gupt 10686 
      oprot.writeFieldBegin('warehouse_id', TType.I64, 4)
10687 
      oprot.writeI64(self.warehouse_id)
10688 
      oprot.writeFieldEnd()
10689 
    oprot.writeFieldStop()
10690 
    oprot.writeStructEnd()
10691 
 
3431 rajveer 10692 
  def validate(self):
10693 
    return
10694 
 
10695 
 
999 varun.gupt 10696 
  def __repr__(self):
10697 
    L = ['%s=%r' % (key, value)
10698 
      for key, value in self.__dict__.iteritems()]
10699 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10700 
 
10701 
  def __eq__(self, other):
10702 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10703 
 
10704 
  def __ne__(self, other):
10705 
    return not (self == other)
10706 
 
10707 
class getOrdersByBillingDate_result:
10708 
  """
10709 
  Attributes:
10710 
   - success
10711 
   - ex
10712 
  """
10713 
 
10714 
  thrift_spec = (
10715 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
10716 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
10717 
  )
10718 
 
10719 
  def __init__(self, success=None, ex=None,):
10720 
    self.success = success
10721 
    self.ex = ex
10722 
 
10723 
  def read(self, iprot):
10724 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10725 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10726 
      return
10727 
    iprot.readStructBegin()
10728 
    while True:
10729 
      (fname, ftype, fid) = iprot.readFieldBegin()
10730 
      if ftype == TType.STOP:
10731 
        break
10732 
      if fid == 0:
10733 
        if ftype == TType.LIST:
10734 
          self.success = []
6188 rajveer 10735 
          (_etype158, _size155) = iprot.readListBegin()
10736 
          for _i159 in xrange(_size155):
10737 
            _elem160 = Order()
10738 
            _elem160.read(iprot)
10739 
            self.success.append(_elem160)
999 varun.gupt 10740 
          iprot.readListEnd()
10741 
        else:
10742 
          iprot.skip(ftype)
10743 
      elif fid == 1:
10744 
        if ftype == TType.STRUCT:
10745 
          self.ex = TransactionServiceException()
10746 
          self.ex.read(iprot)
10747 
        else:
10748 
          iprot.skip(ftype)
10749 
      else:
10750 
        iprot.skip(ftype)
10751 
      iprot.readFieldEnd()
10752 
    iprot.readStructEnd()
10753 
 
10754 
  def write(self, oprot):
10755 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10756 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10757 
      return
10758 
    oprot.writeStructBegin('getOrdersByBillingDate_result')
3431 rajveer 10759 
    if self.success is not None:
999 varun.gupt 10760 
      oprot.writeFieldBegin('success', TType.LIST, 0)
10761 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 10762 
      for iter161 in self.success:
10763 
        iter161.write(oprot)
999 varun.gupt 10764 
      oprot.writeListEnd()
10765 
      oprot.writeFieldEnd()
3431 rajveer 10766 
    if self.ex is not None:
999 varun.gupt 10767 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10768 
      self.ex.write(oprot)
10769 
      oprot.writeFieldEnd()
10770 
    oprot.writeFieldStop()
10771 
    oprot.writeStructEnd()
10772 
 
3431 rajveer 10773 
  def validate(self):
10774 
    return
10775 
 
10776 
 
999 varun.gupt 10777 
  def __repr__(self):
10778 
    L = ['%s=%r' % (key, value)
10779 
      for key, value in self.__dict__.iteritems()]
10780 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10781 
 
10782 
  def __eq__(self, other):
10783 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10784 
 
10785 
  def __ne__(self, other):
10786 
    return not (self == other)
10787 
 
3427 chandransh 10788 
class getOrdersByShippingDate_args:
10789 
  """
10790 
  Attributes:
10791 
   - fromShippingDate
10792 
   - toShippingDate
10793 
   - providerId
10794 
   - warehouseId
3451 chandransh 10795 
   - cod
3427 chandransh 10796 
  """
10797 
 
10798 
  thrift_spec = (
10799 
    None, # 0
10800 
    (1, TType.I64, 'fromShippingDate', None, None, ), # 1
10801 
    (2, TType.I64, 'toShippingDate', None, None, ), # 2
10802 
    (3, TType.I64, 'providerId', None, None, ), # 3
10803 
    (4, TType.I64, 'warehouseId', None, None, ), # 4
3451 chandransh 10804 
    (5, TType.BOOL, 'cod', None, None, ), # 5
3427 chandransh 10805 
  )
10806 
 
3451 chandransh 10807 
  def __init__(self, fromShippingDate=None, toShippingDate=None, providerId=None, warehouseId=None, cod=None,):
3427 chandransh 10808 
    self.fromShippingDate = fromShippingDate
10809 
    self.toShippingDate = toShippingDate
10810 
    self.providerId = providerId
10811 
    self.warehouseId = warehouseId
3451 chandransh 10812 
    self.cod = cod
3427 chandransh 10813 
 
10814 
  def read(self, iprot):
10815 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10816 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10817 
      return
10818 
    iprot.readStructBegin()
10819 
    while True:
10820 
      (fname, ftype, fid) = iprot.readFieldBegin()
10821 
      if ftype == TType.STOP:
10822 
        break
10823 
      if fid == 1:
10824 
        if ftype == TType.I64:
10825 
          self.fromShippingDate = iprot.readI64();
10826 
        else:
10827 
          iprot.skip(ftype)
10828 
      elif fid == 2:
10829 
        if ftype == TType.I64:
10830 
          self.toShippingDate = iprot.readI64();
10831 
        else:
10832 
          iprot.skip(ftype)
10833 
      elif fid == 3:
10834 
        if ftype == TType.I64:
10835 
          self.providerId = iprot.readI64();
10836 
        else:
10837 
          iprot.skip(ftype)
10838 
      elif fid == 4:
10839 
        if ftype == TType.I64:
10840 
          self.warehouseId = iprot.readI64();
10841 
        else:
10842 
          iprot.skip(ftype)
3451 chandransh 10843 
      elif fid == 5:
10844 
        if ftype == TType.BOOL:
10845 
          self.cod = iprot.readBool();
10846 
        else:
10847 
          iprot.skip(ftype)
3427 chandransh 10848 
      else:
10849 
        iprot.skip(ftype)
10850 
      iprot.readFieldEnd()
10851 
    iprot.readStructEnd()
10852 
 
10853 
  def write(self, oprot):
10854 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10855 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10856 
      return
10857 
    oprot.writeStructBegin('getOrdersByShippingDate_args')
3431 rajveer 10858 
    if self.fromShippingDate is not None:
3427 chandransh 10859 
      oprot.writeFieldBegin('fromShippingDate', TType.I64, 1)
10860 
      oprot.writeI64(self.fromShippingDate)
10861 
      oprot.writeFieldEnd()
3431 rajveer 10862 
    if self.toShippingDate is not None:
3427 chandransh 10863 
      oprot.writeFieldBegin('toShippingDate', TType.I64, 2)
10864 
      oprot.writeI64(self.toShippingDate)
10865 
      oprot.writeFieldEnd()
3431 rajveer 10866 
    if self.providerId is not None:
3427 chandransh 10867 
      oprot.writeFieldBegin('providerId', TType.I64, 3)
10868 
      oprot.writeI64(self.providerId)
10869 
      oprot.writeFieldEnd()
3431 rajveer 10870 
    if self.warehouseId is not None:
3427 chandransh 10871 
      oprot.writeFieldBegin('warehouseId', TType.I64, 4)
10872 
      oprot.writeI64(self.warehouseId)
10873 
      oprot.writeFieldEnd()
3451 chandransh 10874 
    if self.cod is not None:
10875 
      oprot.writeFieldBegin('cod', TType.BOOL, 5)
10876 
      oprot.writeBool(self.cod)
10877 
      oprot.writeFieldEnd()
3427 chandransh 10878 
    oprot.writeFieldStop()
10879 
    oprot.writeStructEnd()
10880 
 
3431 rajveer 10881 
  def validate(self):
10882 
    return
10883 
 
10884 
 
3427 chandransh 10885 
  def __repr__(self):
10886 
    L = ['%s=%r' % (key, value)
10887 
      for key, value in self.__dict__.iteritems()]
10888 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10889 
 
10890 
  def __eq__(self, other):
10891 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10892 
 
10893 
  def __ne__(self, other):
10894 
    return not (self == other)
10895 
 
10896 
class getOrdersByShippingDate_result:
10897 
  """
10898 
  Attributes:
10899 
   - success
10900 
   - ex
10901 
  """
10902 
 
10903 
  thrift_spec = (
10904 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
10905 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
10906 
  )
10907 
 
10908 
  def __init__(self, success=None, ex=None,):
10909 
    self.success = success
10910 
    self.ex = ex
10911 
 
10912 
  def read(self, iprot):
10913 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10914 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10915 
      return
10916 
    iprot.readStructBegin()
10917 
    while True:
10918 
      (fname, ftype, fid) = iprot.readFieldBegin()
10919 
      if ftype == TType.STOP:
10920 
        break
10921 
      if fid == 0:
10922 
        if ftype == TType.LIST:
10923 
          self.success = []
6188 rajveer 10924 
          (_etype165, _size162) = iprot.readListBegin()
10925 
          for _i166 in xrange(_size162):
10926 
            _elem167 = Order()
10927 
            _elem167.read(iprot)
10928 
            self.success.append(_elem167)
3427 chandransh 10929 
          iprot.readListEnd()
10930 
        else:
10931 
          iprot.skip(ftype)
10932 
      elif fid == 1:
10933 
        if ftype == TType.STRUCT:
10934 
          self.ex = TransactionServiceException()
10935 
          self.ex.read(iprot)
10936 
        else:
10937 
          iprot.skip(ftype)
10938 
      else:
10939 
        iprot.skip(ftype)
10940 
      iprot.readFieldEnd()
10941 
    iprot.readStructEnd()
10942 
 
10943 
  def write(self, oprot):
10944 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10945 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10946 
      return
10947 
    oprot.writeStructBegin('getOrdersByShippingDate_result')
3431 rajveer 10948 
    if self.success is not None:
3427 chandransh 10949 
      oprot.writeFieldBegin('success', TType.LIST, 0)
10950 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 10951 
      for iter168 in self.success:
10952 
        iter168.write(oprot)
3427 chandransh 10953 
      oprot.writeListEnd()
10954 
      oprot.writeFieldEnd()
3431 rajveer 10955 
    if self.ex is not None:
3427 chandransh 10956 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10957 
      self.ex.write(oprot)
10958 
      oprot.writeFieldEnd()
10959 
    oprot.writeFieldStop()
10960 
    oprot.writeStructEnd()
10961 
 
3431 rajveer 10962 
  def validate(self):
10963 
    return
10964 
 
10965 
 
3427 chandransh 10966 
  def __repr__(self):
10967 
    L = ['%s=%r' % (key, value)
10968 
      for key, value in self.__dict__.iteritems()]
10969 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10970 
 
10971 
  def __eq__(self, other):
10972 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10973 
 
10974 
  def __ne__(self, other):
10975 
    return not (self == other)
10976 
 
1382 varun.gupt 10977 
class getReturnableOrdersForCustomer_args:
10978 
  """
10979 
  Attributes:
10980 
   - customer_id
10981 
   - limit
10982 
  """
10983 
 
10984 
  thrift_spec = (
10985 
    None, # 0
10986 
    (1, TType.I64, 'customer_id', None, None, ), # 1
10987 
    (2, TType.I64, 'limit', None, None, ), # 2
10988 
  )
10989 
 
10990 
  def __init__(self, customer_id=None, limit=None,):
10991 
    self.customer_id = customer_id
10992 
    self.limit = limit
10993 
 
10994 
  def read(self, iprot):
10995 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10996 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10997 
      return
10998 
    iprot.readStructBegin()
10999 
    while True:
11000 
      (fname, ftype, fid) = iprot.readFieldBegin()
11001 
      if ftype == TType.STOP:
11002 
        break
11003 
      if fid == 1:
11004 
        if ftype == TType.I64:
11005 
          self.customer_id = iprot.readI64();
11006 
        else:
11007 
          iprot.skip(ftype)
11008 
      elif fid == 2:
11009 
        if ftype == TType.I64:
11010 
          self.limit = iprot.readI64();
11011 
        else:
11012 
          iprot.skip(ftype)
11013 
      else:
11014 
        iprot.skip(ftype)
11015 
      iprot.readFieldEnd()
11016 
    iprot.readStructEnd()
11017 
 
11018 
  def write(self, oprot):
11019 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11020 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11021 
      return
11022 
    oprot.writeStructBegin('getReturnableOrdersForCustomer_args')
3431 rajveer 11023 
    if self.customer_id is not None:
1382 varun.gupt 11024 
      oprot.writeFieldBegin('customer_id', TType.I64, 1)
11025 
      oprot.writeI64(self.customer_id)
11026 
      oprot.writeFieldEnd()
3431 rajveer 11027 
    if self.limit is not None:
1382 varun.gupt 11028 
      oprot.writeFieldBegin('limit', TType.I64, 2)
11029 
      oprot.writeI64(self.limit)
11030 
      oprot.writeFieldEnd()
11031 
    oprot.writeFieldStop()
11032 
    oprot.writeStructEnd()
11033 
 
3431 rajveer 11034 
  def validate(self):
11035 
    return
11036 
 
11037 
 
1382 varun.gupt 11038 
  def __repr__(self):
11039 
    L = ['%s=%r' % (key, value)
11040 
      for key, value in self.__dict__.iteritems()]
11041 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11042 
 
11043 
  def __eq__(self, other):
11044 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11045 
 
11046 
  def __ne__(self, other):
11047 
    return not (self == other)
11048 
 
11049 
class getReturnableOrdersForCustomer_result:
11050 
  """
11051 
  Attributes:
11052 
   - success
11053 
   - ex
11054 
  """
11055 
 
11056 
  thrift_spec = (
11057 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
11058 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
11059 
  )
11060 
 
11061 
  def __init__(self, success=None, ex=None,):
11062 
    self.success = success
11063 
    self.ex = ex
11064 
 
11065 
  def read(self, iprot):
11066 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11067 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11068 
      return
11069 
    iprot.readStructBegin()
11070 
    while True:
11071 
      (fname, ftype, fid) = iprot.readFieldBegin()
11072 
      if ftype == TType.STOP:
11073 
        break
11074 
      if fid == 0:
11075 
        if ftype == TType.LIST:
11076 
          self.success = []
6188 rajveer 11077 
          (_etype172, _size169) = iprot.readListBegin()
11078 
          for _i173 in xrange(_size169):
11079 
            _elem174 = iprot.readI64();
11080 
            self.success.append(_elem174)
1382 varun.gupt 11081 
          iprot.readListEnd()
11082 
        else:
11083 
          iprot.skip(ftype)
11084 
      elif fid == 1:
11085 
        if ftype == TType.STRUCT:
11086 
          self.ex = TransactionServiceException()
11087 
          self.ex.read(iprot)
11088 
        else:
11089 
          iprot.skip(ftype)
11090 
      else:
11091 
        iprot.skip(ftype)
11092 
      iprot.readFieldEnd()
11093 
    iprot.readStructEnd()
11094 
 
11095 
  def write(self, oprot):
11096 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11097 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11098 
      return
11099 
    oprot.writeStructBegin('getReturnableOrdersForCustomer_result')
3431 rajveer 11100 
    if self.success is not None:
1382 varun.gupt 11101 
      oprot.writeFieldBegin('success', TType.LIST, 0)
11102 
      oprot.writeListBegin(TType.I64, len(self.success))
6188 rajveer 11103 
      for iter175 in self.success:
11104 
        oprot.writeI64(iter175)
1382 varun.gupt 11105 
      oprot.writeListEnd()
11106 
      oprot.writeFieldEnd()
3431 rajveer 11107 
    if self.ex is not None:
1382 varun.gupt 11108 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11109 
      self.ex.write(oprot)
11110 
      oprot.writeFieldEnd()
11111 
    oprot.writeFieldStop()
11112 
    oprot.writeStructEnd()
11113 
 
3431 rajveer 11114 
  def validate(self):
11115 
    return
11116 
 
11117 
 
1382 varun.gupt 11118 
  def __repr__(self):
11119 
    L = ['%s=%r' % (key, value)
11120 
      for key, value in self.__dict__.iteritems()]
11121 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11122 
 
11123 
  def __eq__(self, other):
11124 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11125 
 
11126 
  def __ne__(self, other):
11127 
    return not (self == other)
11128 
 
11129 
class getCancellableOrdersForCustomer_args:
11130 
  """
11131 
  Attributes:
11132 
   - customer_id
11133 
   - limit
11134 
  """
11135 
 
11136 
  thrift_spec = (
11137 
    None, # 0
11138 
    (1, TType.I64, 'customer_id', None, None, ), # 1
11139 
    (2, TType.I64, 'limit', None, None, ), # 2
11140 
  )
11141 
 
11142 
  def __init__(self, customer_id=None, limit=None,):
11143 
    self.customer_id = customer_id
11144 
    self.limit = limit
11145 
 
11146 
  def read(self, iprot):
11147 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11148 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11149 
      return
11150 
    iprot.readStructBegin()
11151 
    while True:
11152 
      (fname, ftype, fid) = iprot.readFieldBegin()
11153 
      if ftype == TType.STOP:
11154 
        break
11155 
      if fid == 1:
11156 
        if ftype == TType.I64:
11157 
          self.customer_id = iprot.readI64();
11158 
        else:
11159 
          iprot.skip(ftype)
11160 
      elif fid == 2:
11161 
        if ftype == TType.I64:
11162 
          self.limit = iprot.readI64();
11163 
        else:
11164 
          iprot.skip(ftype)
11165 
      else:
11166 
        iprot.skip(ftype)
11167 
      iprot.readFieldEnd()
11168 
    iprot.readStructEnd()
11169 
 
11170 
  def write(self, oprot):
11171 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11172 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11173 
      return
11174 
    oprot.writeStructBegin('getCancellableOrdersForCustomer_args')
3431 rajveer 11175 
    if self.customer_id is not None:
1382 varun.gupt 11176 
      oprot.writeFieldBegin('customer_id', TType.I64, 1)
11177 
      oprot.writeI64(self.customer_id)
11178 
      oprot.writeFieldEnd()
3431 rajveer 11179 
    if self.limit is not None:
1382 varun.gupt 11180 
      oprot.writeFieldBegin('limit', TType.I64, 2)
11181 
      oprot.writeI64(self.limit)
11182 
      oprot.writeFieldEnd()
11183 
    oprot.writeFieldStop()
11184 
    oprot.writeStructEnd()
11185 
 
3431 rajveer 11186 
  def validate(self):
11187 
    return
11188 
 
11189 
 
1382 varun.gupt 11190 
  def __repr__(self):
11191 
    L = ['%s=%r' % (key, value)
11192 
      for key, value in self.__dict__.iteritems()]
11193 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11194 
 
11195 
  def __eq__(self, other):
11196 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11197 
 
11198 
  def __ne__(self, other):
11199 
    return not (self == other)
11200 
 
11201 
class getCancellableOrdersForCustomer_result:
11202 
  """
11203 
  Attributes:
11204 
   - success
11205 
   - ex
11206 
  """
11207 
 
11208 
  thrift_spec = (
11209 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
11210 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
11211 
  )
11212 
 
11213 
  def __init__(self, success=None, ex=None,):
11214 
    self.success = success
11215 
    self.ex = ex
11216 
 
11217 
  def read(self, iprot):
11218 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11219 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11220 
      return
11221 
    iprot.readStructBegin()
11222 
    while True:
11223 
      (fname, ftype, fid) = iprot.readFieldBegin()
11224 
      if ftype == TType.STOP:
11225 
        break
11226 
      if fid == 0:
11227 
        if ftype == TType.LIST:
11228 
          self.success = []
6188 rajveer 11229 
          (_etype179, _size176) = iprot.readListBegin()
11230 
          for _i180 in xrange(_size176):
11231 
            _elem181 = iprot.readI64();
11232 
            self.success.append(_elem181)
1382 varun.gupt 11233 
          iprot.readListEnd()
11234 
        else:
11235 
          iprot.skip(ftype)
11236 
      elif fid == 1:
11237 
        if ftype == TType.STRUCT:
11238 
          self.ex = TransactionServiceException()
11239 
          self.ex.read(iprot)
11240 
        else:
11241 
          iprot.skip(ftype)
11242 
      else:
11243 
        iprot.skip(ftype)
11244 
      iprot.readFieldEnd()
11245 
    iprot.readStructEnd()
11246 
 
11247 
  def write(self, oprot):
11248 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11249 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11250 
      return
11251 
    oprot.writeStructBegin('getCancellableOrdersForCustomer_result')
3431 rajveer 11252 
    if self.success is not None:
1382 varun.gupt 11253 
      oprot.writeFieldBegin('success', TType.LIST, 0)
11254 
      oprot.writeListBegin(TType.I64, len(self.success))
6188 rajveer 11255 
      for iter182 in self.success:
11256 
        oprot.writeI64(iter182)
1382 varun.gupt 11257 
      oprot.writeListEnd()
11258 
      oprot.writeFieldEnd()
3431 rajveer 11259 
    if self.ex is not None:
1382 varun.gupt 11260 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11261 
      self.ex.write(oprot)
11262 
      oprot.writeFieldEnd()
11263 
    oprot.writeFieldStop()
11264 
    oprot.writeStructEnd()
11265 
 
3431 rajveer 11266 
  def validate(self):
11267 
    return
11268 
 
11269 
 
1382 varun.gupt 11270 
  def __repr__(self):
11271 
    L = ['%s=%r' % (key, value)
11272 
      for key, value in self.__dict__.iteritems()]
11273 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11274 
 
11275 
  def __eq__(self, other):
11276 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11277 
 
11278 
  def __ne__(self, other):
11279 
    return not (self == other)
11280 
 
483 rajveer 11281 
class changeOrderStatus_args:
94 ashish 11282 
  """
11283 
  Attributes:
483 rajveer 11284 
   - orderId
11285 
   - status
11286 
   - description
94 ashish 11287 
  """
11288 
 
11289 
  thrift_spec = (
11290 
    None, # 0
483 rajveer 11291 
    (1, TType.I64, 'orderId', None, None, ), # 1
11292 
    (2, TType.I32, 'status', None, None, ), # 2
11293 
    (3, TType.STRING, 'description', None, None, ), # 3
94 ashish 11294 
  )
11295 
 
483 rajveer 11296 
  def __init__(self, orderId=None, status=None, description=None,):
11297 
    self.orderId = orderId
11298 
    self.status = status
11299 
    self.description = description
94 ashish 11300 
 
11301 
  def read(self, iprot):
11302 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11303 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11304 
      return
11305 
    iprot.readStructBegin()
11306 
    while True:
11307 
      (fname, ftype, fid) = iprot.readFieldBegin()
11308 
      if ftype == TType.STOP:
11309 
        break
11310 
      if fid == 1:
11311 
        if ftype == TType.I64:
483 rajveer 11312 
          self.orderId = iprot.readI64();
94 ashish 11313 
        else:
11314 
          iprot.skip(ftype)
11315 
      elif fid == 2:
483 rajveer 11316 
        if ftype == TType.I32:
11317 
          self.status = iprot.readI32();
94 ashish 11318 
        else:
11319 
          iprot.skip(ftype)
483 rajveer 11320 
      elif fid == 3:
11321 
        if ftype == TType.STRING:
11322 
          self.description = iprot.readString();
11323 
        else:
11324 
          iprot.skip(ftype)
94 ashish 11325 
      else:
11326 
        iprot.skip(ftype)
11327 
      iprot.readFieldEnd()
11328 
    iprot.readStructEnd()
11329 
 
11330 
  def write(self, oprot):
11331 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11332 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11333 
      return
483 rajveer 11334 
    oprot.writeStructBegin('changeOrderStatus_args')
3431 rajveer 11335 
    if self.orderId is not None:
483 rajveer 11336 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
11337 
      oprot.writeI64(self.orderId)
94 ashish 11338 
      oprot.writeFieldEnd()
3431 rajveer 11339 
    if self.status is not None:
483 rajveer 11340 
      oprot.writeFieldBegin('status', TType.I32, 2)
11341 
      oprot.writeI32(self.status)
94 ashish 11342 
      oprot.writeFieldEnd()
3431 rajveer 11343 
    if self.description is not None:
483 rajveer 11344 
      oprot.writeFieldBegin('description', TType.STRING, 3)
11345 
      oprot.writeString(self.description)
11346 
      oprot.writeFieldEnd()
94 ashish 11347 
    oprot.writeFieldStop()
11348 
    oprot.writeStructEnd()
11349 
 
3431 rajveer 11350 
  def validate(self):
11351 
    return
11352 
 
11353 
 
94 ashish 11354 
  def __repr__(self):
11355 
    L = ['%s=%r' % (key, value)
11356 
      for key, value in self.__dict__.iteritems()]
11357 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11358 
 
11359 
  def __eq__(self, other):
11360 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11361 
 
11362 
  def __ne__(self, other):
11363 
    return not (self == other)
11364 
 
483 rajveer 11365 
class changeOrderStatus_result:
94 ashish 11366 
  """
11367 
  Attributes:
11368 
   - success
11369 
   - ex
11370 
  """
11371 
 
11372 
  thrift_spec = (
11373 
    (0, TType.BOOL, 'success', None, None, ), # 0
11374 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
11375 
  )
11376 
 
11377 
  def __init__(self, success=None, ex=None,):
11378 
    self.success = success
11379 
    self.ex = ex
11380 
 
11381 
  def read(self, iprot):
11382 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11383 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11384 
      return
11385 
    iprot.readStructBegin()
11386 
    while True:
11387 
      (fname, ftype, fid) = iprot.readFieldBegin()
11388 
      if ftype == TType.STOP:
11389 
        break
11390 
      if fid == 0:
11391 
        if ftype == TType.BOOL:
11392 
          self.success = iprot.readBool();
11393 
        else:
11394 
          iprot.skip(ftype)
11395 
      elif fid == 1:
11396 
        if ftype == TType.STRUCT:
11397 
          self.ex = TransactionServiceException()
11398 
          self.ex.read(iprot)
11399 
        else:
11400 
          iprot.skip(ftype)
11401 
      else:
11402 
        iprot.skip(ftype)
11403 
      iprot.readFieldEnd()
11404 
    iprot.readStructEnd()
11405 
 
11406 
  def write(self, oprot):
11407 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11408 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11409 
      return
483 rajveer 11410 
    oprot.writeStructBegin('changeOrderStatus_result')
3431 rajveer 11411 
    if self.success is not None:
94 ashish 11412 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
11413 
      oprot.writeBool(self.success)
11414 
      oprot.writeFieldEnd()
3431 rajveer 11415 
    if self.ex is not None:
94 ashish 11416 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11417 
      self.ex.write(oprot)
11418 
      oprot.writeFieldEnd()
11419 
    oprot.writeFieldStop()
11420 
    oprot.writeStructEnd()
11421 
 
3431 rajveer 11422 
  def validate(self):
11423 
    return
11424 
 
11425 
 
94 ashish 11426 
  def __repr__(self):
11427 
    L = ['%s=%r' % (key, value)
11428 
      for key, value in self.__dict__.iteritems()]
11429 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11430 
 
11431 
  def __eq__(self, other):
11432 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11433 
 
11434 
  def __ne__(self, other):
11435 
    return not (self == other)
11436 
 
3064 chandransh 11437 
class getOrdersForTransaction_args:
494 rajveer 11438 
  """
11439 
  Attributes:
3064 chandransh 11440 
   - transactionId
11441 
   - customerId
494 rajveer 11442 
  """
11443 
 
11444 
  thrift_spec = (
11445 
    None, # 0
3064 chandransh 11446 
    (1, TType.I64, 'transactionId', None, None, ), # 1
11447 
    (2, TType.I64, 'customerId', None, None, ), # 2
494 rajveer 11448 
  )
11449 
 
3064 chandransh 11450 
  def __init__(self, transactionId=None, customerId=None,):
11451 
    self.transactionId = transactionId
11452 
    self.customerId = customerId
494 rajveer 11453 
 
11454 
  def read(self, iprot):
11455 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11456 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11457 
      return
11458 
    iprot.readStructBegin()
11459 
    while True:
11460 
      (fname, ftype, fid) = iprot.readFieldBegin()
11461 
      if ftype == TType.STOP:
11462 
        break
11463 
      if fid == 1:
11464 
        if ftype == TType.I64:
3064 chandransh 11465 
          self.transactionId = iprot.readI64();
494 rajveer 11466 
        else:
11467 
          iprot.skip(ftype)
11468 
      elif fid == 2:
3064 chandransh 11469 
        if ftype == TType.I64:
11470 
          self.customerId = iprot.readI64();
494 rajveer 11471 
        else:
11472 
          iprot.skip(ftype)
11473 
      else:
11474 
        iprot.skip(ftype)
11475 
      iprot.readFieldEnd()
11476 
    iprot.readStructEnd()
11477 
 
11478 
  def write(self, oprot):
11479 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11480 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11481 
      return
3064 chandransh 11482 
    oprot.writeStructBegin('getOrdersForTransaction_args')
3431 rajveer 11483 
    if self.transactionId is not None:
3064 chandransh 11484 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
11485 
      oprot.writeI64(self.transactionId)
494 rajveer 11486 
      oprot.writeFieldEnd()
3431 rajveer 11487 
    if self.customerId is not None:
3064 chandransh 11488 
      oprot.writeFieldBegin('customerId', TType.I64, 2)
11489 
      oprot.writeI64(self.customerId)
494 rajveer 11490 
      oprot.writeFieldEnd()
11491 
    oprot.writeFieldStop()
11492 
    oprot.writeStructEnd()
11493 
 
3431 rajveer 11494 
  def validate(self):
11495 
    return
11496 
 
11497 
 
494 rajveer 11498 
  def __repr__(self):
11499 
    L = ['%s=%r' % (key, value)
11500 
      for key, value in self.__dict__.iteritems()]
11501 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11502 
 
11503 
  def __eq__(self, other):
11504 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11505 
 
11506 
  def __ne__(self, other):
11507 
    return not (self == other)
11508 
 
3064 chandransh 11509 
class getOrdersForTransaction_result:
494 rajveer 11510 
  """
11511 
  Attributes:
11512 
   - success
11513 
   - ex
11514 
  """
11515 
 
11516 
  thrift_spec = (
3064 chandransh 11517 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
494 rajveer 11518 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
11519 
  )
11520 
 
11521 
  def __init__(self, success=None, ex=None,):
11522 
    self.success = success
11523 
    self.ex = ex
11524 
 
11525 
  def read(self, iprot):
11526 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11527 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11528 
      return
11529 
    iprot.readStructBegin()
11530 
    while True:
11531 
      (fname, ftype, fid) = iprot.readFieldBegin()
11532 
      if ftype == TType.STOP:
11533 
        break
11534 
      if fid == 0:
3064 chandransh 11535 
        if ftype == TType.LIST:
11536 
          self.success = []
6188 rajveer 11537 
          (_etype186, _size183) = iprot.readListBegin()
11538 
          for _i187 in xrange(_size183):
11539 
            _elem188 = Order()
11540 
            _elem188.read(iprot)
11541 
            self.success.append(_elem188)
3064 chandransh 11542 
          iprot.readListEnd()
494 rajveer 11543 
        else:
11544 
          iprot.skip(ftype)
11545 
      elif fid == 1:
11546 
        if ftype == TType.STRUCT:
11547 
          self.ex = TransactionServiceException()
11548 
          self.ex.read(iprot)
11549 
        else:
11550 
          iprot.skip(ftype)
11551 
      else:
11552 
        iprot.skip(ftype)
11553 
      iprot.readFieldEnd()
11554 
    iprot.readStructEnd()
11555 
 
11556 
  def write(self, oprot):
11557 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11558 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11559 
      return
3064 chandransh 11560 
    oprot.writeStructBegin('getOrdersForTransaction_result')
3431 rajveer 11561 
    if self.success is not None:
3064 chandransh 11562 
      oprot.writeFieldBegin('success', TType.LIST, 0)
11563 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 11564 
      for iter189 in self.success:
11565 
        iter189.write(oprot)
3064 chandransh 11566 
      oprot.writeListEnd()
494 rajveer 11567 
      oprot.writeFieldEnd()
3431 rajveer 11568 
    if self.ex is not None:
494 rajveer 11569 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11570 
      self.ex.write(oprot)
11571 
      oprot.writeFieldEnd()
11572 
    oprot.writeFieldStop()
11573 
    oprot.writeStructEnd()
11574 
 
3431 rajveer 11575 
  def validate(self):
11576 
    return
11577 
 
11578 
 
494 rajveer 11579 
  def __repr__(self):
11580 
    L = ['%s=%r' % (key, value)
11581 
      for key, value in self.__dict__.iteritems()]
11582 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11583 
 
11584 
  def __eq__(self, other):
11585 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11586 
 
11587 
  def __ne__(self, other):
11588 
    return not (self == other)
11589 
 
3064 chandransh 11590 
class getOrdersForCustomer_args:
1149 chandransh 11591 
  """
11592 
  Attributes:
3064 chandransh 11593 
   - customerId
11594 
   - from_date
11595 
   - to_date
11596 
   - statuses
1149 chandransh 11597 
  """
11598 
 
11599 
  thrift_spec = (
11600 
    None, # 0
3064 chandransh 11601 
    (1, TType.I64, 'customerId', None, None, ), # 1
11602 
    (2, TType.I64, 'from_date', None, None, ), # 2
11603 
    (3, TType.I64, 'to_date', None, None, ), # 3
11604 
    (4, TType.LIST, 'statuses', (TType.I32,None), None, ), # 4
1149 chandransh 11605 
  )
11606 
 
3064 chandransh 11607 
  def __init__(self, customerId=None, from_date=None, to_date=None, statuses=None,):
11608 
    self.customerId = customerId
11609 
    self.from_date = from_date
11610 
    self.to_date = to_date
11611 
    self.statuses = statuses
1149 chandransh 11612 
 
11613 
  def read(self, iprot):
11614 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11615 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11616 
      return
11617 
    iprot.readStructBegin()
11618 
    while True:
11619 
      (fname, ftype, fid) = iprot.readFieldBegin()
11620 
      if ftype == TType.STOP:
11621 
        break
11622 
      if fid == 1:
11623 
        if ftype == TType.I64:
3064 chandransh 11624 
          self.customerId = iprot.readI64();
1149 chandransh 11625 
        else:
11626 
          iprot.skip(ftype)
11627 
      elif fid == 2:
11628 
        if ftype == TType.I64:
3064 chandransh 11629 
          self.from_date = iprot.readI64();
1149 chandransh 11630 
        else:
11631 
          iprot.skip(ftype)
2783 chandransh 11632 
      elif fid == 3:
11633 
        if ftype == TType.I64:
3064 chandransh 11634 
          self.to_date = iprot.readI64();
2783 chandransh 11635 
        else:
11636 
          iprot.skip(ftype)
11637 
      elif fid == 4:
3064 chandransh 11638 
        if ftype == TType.LIST:
11639 
          self.statuses = []
6188 rajveer 11640 
          (_etype193, _size190) = iprot.readListBegin()
11641 
          for _i194 in xrange(_size190):
11642 
            _elem195 = iprot.readI32();
11643 
            self.statuses.append(_elem195)
3064 chandransh 11644 
          iprot.readListEnd()
2783 chandransh 11645 
        else:
11646 
          iprot.skip(ftype)
1149 chandransh 11647 
      else:
11648 
        iprot.skip(ftype)
11649 
      iprot.readFieldEnd()
11650 
    iprot.readStructEnd()
11651 
 
11652 
  def write(self, oprot):
11653 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11654 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11655 
      return
3064 chandransh 11656 
    oprot.writeStructBegin('getOrdersForCustomer_args')
3431 rajveer 11657 
    if self.customerId is not None:
3064 chandransh 11658 
      oprot.writeFieldBegin('customerId', TType.I64, 1)
11659 
      oprot.writeI64(self.customerId)
1149 chandransh 11660 
      oprot.writeFieldEnd()
3431 rajveer 11661 
    if self.from_date is not None:
3064 chandransh 11662 
      oprot.writeFieldBegin('from_date', TType.I64, 2)
11663 
      oprot.writeI64(self.from_date)
1149 chandransh 11664 
      oprot.writeFieldEnd()
3431 rajveer 11665 
    if self.to_date is not None:
3064 chandransh 11666 
      oprot.writeFieldBegin('to_date', TType.I64, 3)
11667 
      oprot.writeI64(self.to_date)
2783 chandransh 11668 
      oprot.writeFieldEnd()
3431 rajveer 11669 
    if self.statuses is not None:
3064 chandransh 11670 
      oprot.writeFieldBegin('statuses', TType.LIST, 4)
11671 
      oprot.writeListBegin(TType.I32, len(self.statuses))
6188 rajveer 11672 
      for iter196 in self.statuses:
11673 
        oprot.writeI32(iter196)
3064 chandransh 11674 
      oprot.writeListEnd()
2783 chandransh 11675 
      oprot.writeFieldEnd()
1149 chandransh 11676 
    oprot.writeFieldStop()
11677 
    oprot.writeStructEnd()
11678 
 
3431 rajveer 11679 
  def validate(self):
11680 
    return
11681 
 
11682 
 
1149 chandransh 11683 
  def __repr__(self):
11684 
    L = ['%s=%r' % (key, value)
11685 
      for key, value in self.__dict__.iteritems()]
11686 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11687 
 
11688 
  def __eq__(self, other):
11689 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11690 
 
11691 
  def __ne__(self, other):
11692 
    return not (self == other)
11693 
 
3064 chandransh 11694 
class getOrdersForCustomer_result:
1149 chandransh 11695 
  """
11696 
  Attributes:
11697 
   - success
11698 
   - ex
11699 
  """
11700 
 
11701 
  thrift_spec = (
3064 chandransh 11702 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
1149 chandransh 11703 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
11704 
  )
11705 
 
11706 
  def __init__(self, success=None, ex=None,):
11707 
    self.success = success
11708 
    self.ex = ex
11709 
 
11710 
  def read(self, iprot):
11711 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11712 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11713 
      return
11714 
    iprot.readStructBegin()
11715 
    while True:
11716 
      (fname, ftype, fid) = iprot.readFieldBegin()
11717 
      if ftype == TType.STOP:
11718 
        break
11719 
      if fid == 0:
3064 chandransh 11720 
        if ftype == TType.LIST:
11721 
          self.success = []
6188 rajveer 11722 
          (_etype200, _size197) = iprot.readListBegin()
11723 
          for _i201 in xrange(_size197):
11724 
            _elem202 = Order()
11725 
            _elem202.read(iprot)
11726 
            self.success.append(_elem202)
3064 chandransh 11727 
          iprot.readListEnd()
1149 chandransh 11728 
        else:
11729 
          iprot.skip(ftype)
11730 
      elif fid == 1:
11731 
        if ftype == TType.STRUCT:
11732 
          self.ex = TransactionServiceException()
11733 
          self.ex.read(iprot)
11734 
        else:
11735 
          iprot.skip(ftype)
11736 
      else:
11737 
        iprot.skip(ftype)
11738 
      iprot.readFieldEnd()
11739 
    iprot.readStructEnd()
11740 
 
11741 
  def write(self, oprot):
11742 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11743 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11744 
      return
3064 chandransh 11745 
    oprot.writeStructBegin('getOrdersForCustomer_result')
3431 rajveer 11746 
    if self.success is not None:
3064 chandransh 11747 
      oprot.writeFieldBegin('success', TType.LIST, 0)
11748 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 11749 
      for iter203 in self.success:
11750 
        iter203.write(oprot)
3064 chandransh 11751 
      oprot.writeListEnd()
1149 chandransh 11752 
      oprot.writeFieldEnd()
3431 rajveer 11753 
    if self.ex is not None:
1149 chandransh 11754 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11755 
      self.ex.write(oprot)
11756 
      oprot.writeFieldEnd()
11757 
    oprot.writeFieldStop()
11758 
    oprot.writeStructEnd()
11759 
 
3431 rajveer 11760 
  def validate(self):
11761 
    return
11762 
 
11763 
 
1149 chandransh 11764 
  def __repr__(self):
11765 
    L = ['%s=%r' % (key, value)
11766 
      for key, value in self.__dict__.iteritems()]
11767 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11768 
 
11769 
  def __eq__(self, other):
11770 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11771 
 
11772 
  def __ne__(self, other):
11773 
    return not (self == other)
11774 
 
3064 chandransh 11775 
class createOrder_args:
921 rajveer 11776 
  """
11777 
  Attributes:
3064 chandransh 11778 
   - order
921 rajveer 11779 
  """
11780 
 
11781 
  thrift_spec = (
11782 
    None, # 0
3064 chandransh 11783 
    (1, TType.STRUCT, 'order', (Order, Order.thrift_spec), None, ), # 1
921 rajveer 11784 
  )
11785 
 
3064 chandransh 11786 
  def __init__(self, order=None,):
11787 
    self.order = order
921 rajveer 11788 
 
11789 
  def read(self, iprot):
11790 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11791 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11792 
      return
11793 
    iprot.readStructBegin()
11794 
    while True:
11795 
      (fname, ftype, fid) = iprot.readFieldBegin()
11796 
      if ftype == TType.STOP:
11797 
        break
11798 
      if fid == 1:
3064 chandransh 11799 
        if ftype == TType.STRUCT:
11800 
          self.order = Order()
11801 
          self.order.read(iprot)
921 rajveer 11802 
        else:
11803 
          iprot.skip(ftype)
11804 
      else:
11805 
        iprot.skip(ftype)
11806 
      iprot.readFieldEnd()
11807 
    iprot.readStructEnd()
11808 
 
11809 
  def write(self, oprot):
11810 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11811 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11812 
      return
3064 chandransh 11813 
    oprot.writeStructBegin('createOrder_args')
3431 rajveer 11814 
    if self.order is not None:
3064 chandransh 11815 
      oprot.writeFieldBegin('order', TType.STRUCT, 1)
11816 
      self.order.write(oprot)
921 rajveer 11817 
      oprot.writeFieldEnd()
11818 
    oprot.writeFieldStop()
11819 
    oprot.writeStructEnd()
11820 
 
3431 rajveer 11821 
  def validate(self):
11822 
    return
11823 
 
11824 
 
921 rajveer 11825 
  def __repr__(self):
11826 
    L = ['%s=%r' % (key, value)
11827 
      for key, value in self.__dict__.iteritems()]
11828 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11829 
 
11830 
  def __eq__(self, other):
11831 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11832 
 
11833 
  def __ne__(self, other):
11834 
    return not (self == other)
11835 
 
3064 chandransh 11836 
class createOrder_result:
921 rajveer 11837 
  """
11838 
  Attributes:
11839 
   - success
11840 
   - ex
11841 
  """
11842 
 
11843 
  thrift_spec = (
3064 chandransh 11844 
    (0, TType.I64, 'success', None, None, ), # 0
921 rajveer 11845 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
11846 
  )
11847 
 
11848 
  def __init__(self, success=None, ex=None,):
11849 
    self.success = success
11850 
    self.ex = ex
11851 
 
11852 
  def read(self, iprot):
11853 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11854 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11855 
      return
11856 
    iprot.readStructBegin()
11857 
    while True:
11858 
      (fname, ftype, fid) = iprot.readFieldBegin()
11859 
      if ftype == TType.STOP:
11860 
        break
11861 
      if fid == 0:
3064 chandransh 11862 
        if ftype == TType.I64:
11863 
          self.success = iprot.readI64();
921 rajveer 11864 
        else:
11865 
          iprot.skip(ftype)
11866 
      elif fid == 1:
11867 
        if ftype == TType.STRUCT:
11868 
          self.ex = TransactionServiceException()
11869 
          self.ex.read(iprot)
11870 
        else:
11871 
          iprot.skip(ftype)
11872 
      else:
11873 
        iprot.skip(ftype)
11874 
      iprot.readFieldEnd()
11875 
    iprot.readStructEnd()
11876 
 
11877 
  def write(self, oprot):
11878 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11879 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11880 
      return
3064 chandransh 11881 
    oprot.writeStructBegin('createOrder_result')
3431 rajveer 11882 
    if self.success is not None:
3064 chandransh 11883 
      oprot.writeFieldBegin('success', TType.I64, 0)
11884 
      oprot.writeI64(self.success)
921 rajveer 11885 
      oprot.writeFieldEnd()
3431 rajveer 11886 
    if self.ex is not None:
921 rajveer 11887 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11888 
      self.ex.write(oprot)
11889 
      oprot.writeFieldEnd()
11890 
    oprot.writeFieldStop()
11891 
    oprot.writeStructEnd()
11892 
 
3431 rajveer 11893 
  def validate(self):
11894 
    return
11895 
 
11896 
 
921 rajveer 11897 
  def __repr__(self):
11898 
    L = ['%s=%r' % (key, value)
11899 
      for key, value in self.__dict__.iteritems()]
11900 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11901 
 
11902 
  def __eq__(self, other):
11903 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11904 
 
11905 
  def __ne__(self, other):
11906 
    return not (self == other)
11907 
 
3064 chandransh 11908 
class getOrder_args:
921 rajveer 11909 
  """
11910 
  Attributes:
3064 chandransh 11911 
   - id
921 rajveer 11912 
  """
11913 
 
11914 
  thrift_spec = (
11915 
    None, # 0
3064 chandransh 11916 
    (1, TType.I64, 'id', None, None, ), # 1
921 rajveer 11917 
  )
11918 
 
3064 chandransh 11919 
  def __init__(self, id=None,):
11920 
    self.id = id
921 rajveer 11921 
 
11922 
  def read(self, iprot):
11923 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11924 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11925 
      return
11926 
    iprot.readStructBegin()
11927 
    while True:
11928 
      (fname, ftype, fid) = iprot.readFieldBegin()
11929 
      if ftype == TType.STOP:
11930 
        break
11931 
      if fid == 1:
11932 
        if ftype == TType.I64:
3064 chandransh 11933 
          self.id = iprot.readI64();
921 rajveer 11934 
        else:
11935 
          iprot.skip(ftype)
11936 
      else:
11937 
        iprot.skip(ftype)
11938 
      iprot.readFieldEnd()
11939 
    iprot.readStructEnd()
11940 
 
11941 
  def write(self, oprot):
11942 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11943 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11944 
      return
3064 chandransh 11945 
    oprot.writeStructBegin('getOrder_args')
3431 rajveer 11946 
    if self.id is not None:
3064 chandransh 11947 
      oprot.writeFieldBegin('id', TType.I64, 1)
11948 
      oprot.writeI64(self.id)
921 rajveer 11949 
      oprot.writeFieldEnd()
11950 
    oprot.writeFieldStop()
11951 
    oprot.writeStructEnd()
11952 
 
3431 rajveer 11953 
  def validate(self):
11954 
    return
11955 
 
11956 
 
921 rajveer 11957 
  def __repr__(self):
11958 
    L = ['%s=%r' % (key, value)
11959 
      for key, value in self.__dict__.iteritems()]
11960 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11961 
 
11962 
  def __eq__(self, other):
11963 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11964 
 
11965 
  def __ne__(self, other):
11966 
    return not (self == other)
11967 
 
3064 chandransh 11968 
class getOrder_result:
921 rajveer 11969 
  """
11970 
  Attributes:
11971 
   - success
11972 
   - ex
11973 
  """
11974 
 
11975 
  thrift_spec = (
3064 chandransh 11976 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
921 rajveer 11977 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
11978 
  )
11979 
 
11980 
  def __init__(self, success=None, ex=None,):
11981 
    self.success = success
11982 
    self.ex = ex
11983 
 
11984 
  def read(self, iprot):
11985 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11986 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11987 
      return
11988 
    iprot.readStructBegin()
11989 
    while True:
11990 
      (fname, ftype, fid) = iprot.readFieldBegin()
11991 
      if ftype == TType.STOP:
11992 
        break
11993 
      if fid == 0:
3064 chandransh 11994 
        if ftype == TType.STRUCT:
11995 
          self.success = Order()
11996 
          self.success.read(iprot)
921 rajveer 11997 
        else:
11998 
          iprot.skip(ftype)
11999 
      elif fid == 1:
12000 
        if ftype == TType.STRUCT:
12001 
          self.ex = TransactionServiceException()
12002 
          self.ex.read(iprot)
12003 
        else:
12004 
          iprot.skip(ftype)
12005 
      else:
12006 
        iprot.skip(ftype)
12007 
      iprot.readFieldEnd()
12008 
    iprot.readStructEnd()
12009 
 
12010 
  def write(self, oprot):
12011 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12012 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12013 
      return
3064 chandransh 12014 
    oprot.writeStructBegin('getOrder_result')
3431 rajveer 12015 
    if self.success is not None:
3064 chandransh 12016 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
12017 
      self.success.write(oprot)
921 rajveer 12018 
      oprot.writeFieldEnd()
3431 rajveer 12019 
    if self.ex is not None:
921 rajveer 12020 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
12021 
      self.ex.write(oprot)
12022 
      oprot.writeFieldEnd()
12023 
    oprot.writeFieldStop()
12024 
    oprot.writeStructEnd()
12025 
 
3431 rajveer 12026 
  def validate(self):
12027 
    return
12028 
 
12029 
 
921 rajveer 12030 
  def __repr__(self):
12031 
    L = ['%s=%r' % (key, value)
12032 
      for key, value in self.__dict__.iteritems()]
12033 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12034 
 
12035 
  def __eq__(self, other):
12036 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12037 
 
12038 
  def __ne__(self, other):
12039 
    return not (self == other)
12040 
 
3064 chandransh 12041 
class getLineItemsForOrder_args:
94 ashish 12042 
  """
12043 
  Attributes:
3064 chandransh 12044 
   - orderId
94 ashish 12045 
  """
12046 
 
12047 
  thrift_spec = (
12048 
    None, # 0
3064 chandransh 12049 
    (1, TType.I64, 'orderId', None, None, ), # 1
94 ashish 12050 
  )
12051 
 
3064 chandransh 12052 
  def __init__(self, orderId=None,):
12053 
    self.orderId = orderId
94 ashish 12054 
 
12055 
  def read(self, iprot):
12056 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12057 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12058 
      return
12059 
    iprot.readStructBegin()
12060 
    while True:
12061 
      (fname, ftype, fid) = iprot.readFieldBegin()
12062 
      if ftype == TType.STOP:
12063 
        break
12064 
      if fid == 1:
12065 
        if ftype == TType.I64:
3064 chandransh 12066 
          self.orderId = iprot.readI64();
94 ashish 12067 
        else:
12068 
          iprot.skip(ftype)
12069 
      else:
12070 
        iprot.skip(ftype)
12071 
      iprot.readFieldEnd()
12072 
    iprot.readStructEnd()
12073 
 
12074 
  def write(self, oprot):
12075 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12076 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12077 
      return
3064 chandransh 12078 
    oprot.writeStructBegin('getLineItemsForOrder_args')
3431 rajveer 12079 
    if self.orderId is not None:
3064 chandransh 12080 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
12081 
      oprot.writeI64(self.orderId)
94 ashish 12082 
      oprot.writeFieldEnd()
12083 
    oprot.writeFieldStop()
12084 
    oprot.writeStructEnd()
12085 
 
3431 rajveer 12086 
  def validate(self):
12087 
    return
12088 
 
12089 
 
94 ashish 12090 
  def __repr__(self):
12091 
    L = ['%s=%r' % (key, value)
12092 
      for key, value in self.__dict__.iteritems()]
12093 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12094 
 
12095 
  def __eq__(self, other):
12096 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12097 
 
12098 
  def __ne__(self, other):
12099 
    return not (self == other)
12100 
 
3064 chandransh 12101 
class getLineItemsForOrder_result:
94 ashish 12102 
  """
12103 
  Attributes:
12104 
   - success
12105 
   - ex
12106 
  """
12107 
 
12108 
  thrift_spec = (
3064 chandransh 12109 
    (0, TType.LIST, 'success', (TType.STRUCT,(LineItem, LineItem.thrift_spec)), None, ), # 0
94 ashish 12110 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
12111 
  )
12112 
 
12113 
  def __init__(self, success=None, ex=None,):
12114 
    self.success = success
12115 
    self.ex = ex
12116 
 
12117 
  def read(self, iprot):
12118 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12119 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12120 
      return
12121 
    iprot.readStructBegin()
12122 
    while True:
12123 
      (fname, ftype, fid) = iprot.readFieldBegin()
12124 
      if ftype == TType.STOP:
12125 
        break
12126 
      if fid == 0:
483 rajveer 12127 
        if ftype == TType.LIST:
12128 
          self.success = []
6188 rajveer 12129 
          (_etype207, _size204) = iprot.readListBegin()
12130 
          for _i208 in xrange(_size204):
12131 
            _elem209 = LineItem()
12132 
            _elem209.read(iprot)
12133 
            self.success.append(_elem209)
483 rajveer 12134 
          iprot.readListEnd()
94 ashish 12135 
        else:
12136 
          iprot.skip(ftype)
12137 
      elif fid == 1:
12138 
        if ftype == TType.STRUCT:
12139 
          self.ex = TransactionServiceException()
12140 
          self.ex.read(iprot)
12141 
        else:
12142 
          iprot.skip(ftype)
12143 
      else:
12144 
        iprot.skip(ftype)
12145 
      iprot.readFieldEnd()
12146 
    iprot.readStructEnd()
12147 
 
12148 
  def write(self, oprot):
12149 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12150 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12151 
      return
3064 chandransh 12152 
    oprot.writeStructBegin('getLineItemsForOrder_result')
3431 rajveer 12153 
    if self.success is not None:
483 rajveer 12154 
      oprot.writeFieldBegin('success', TType.LIST, 0)
12155 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 12156 
      for iter210 in self.success:
12157 
        iter210.write(oprot)
483 rajveer 12158 
      oprot.writeListEnd()
94 ashish 12159 
      oprot.writeFieldEnd()
3431 rajveer 12160 
    if self.ex is not None:
94 ashish 12161 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
12162 
      self.ex.write(oprot)
12163 
      oprot.writeFieldEnd()
12164 
    oprot.writeFieldStop()
12165 
    oprot.writeStructEnd()
12166 
 
3431 rajveer 12167 
  def validate(self):
12168 
    return
12169 
 
12170 
 
94 ashish 12171 
  def __repr__(self):
12172 
    L = ['%s=%r' % (key, value)
12173 
      for key, value in self.__dict__.iteritems()]
12174 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12175 
 
12176 
  def __eq__(self, other):
12177 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12178 
 
12179 
  def __ne__(self, other):
12180 
    return not (self == other)
12181 
 
4999 phani.kuma 12182 
class getOrderList_args:
12183 
  """
12184 
  Attributes:
12185 
   - order_ids
12186 
  """
12187 
 
12188 
  thrift_spec = (
12189 
    None, # 0
12190 
    (1, TType.LIST, 'order_ids', (TType.I64,None), None, ), # 1
12191 
  )
12192 
 
12193 
  def __init__(self, order_ids=None,):
12194 
    self.order_ids = order_ids
12195 
 
12196 
  def read(self, iprot):
12197 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12198 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12199 
      return
12200 
    iprot.readStructBegin()
12201 
    while True:
12202 
      (fname, ftype, fid) = iprot.readFieldBegin()
12203 
      if ftype == TType.STOP:
12204 
        break
12205 
      if fid == 1:
12206 
        if ftype == TType.LIST:
12207 
          self.order_ids = []
6188 rajveer 12208 
          (_etype214, _size211) = iprot.readListBegin()
12209 
          for _i215 in xrange(_size211):
12210 
            _elem216 = iprot.readI64();
12211 
            self.order_ids.append(_elem216)
4999 phani.kuma 12212 
          iprot.readListEnd()
12213 
        else:
12214 
          iprot.skip(ftype)
12215 
      else:
12216 
        iprot.skip(ftype)
12217 
      iprot.readFieldEnd()
12218 
    iprot.readStructEnd()
12219 
 
12220 
  def write(self, oprot):
12221 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12222 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12223 
      return
12224 
    oprot.writeStructBegin('getOrderList_args')
12225 
    if self.order_ids is not None:
12226 
      oprot.writeFieldBegin('order_ids', TType.LIST, 1)
12227 
      oprot.writeListBegin(TType.I64, len(self.order_ids))
6188 rajveer 12228 
      for iter217 in self.order_ids:
12229 
        oprot.writeI64(iter217)
4999 phani.kuma 12230 
      oprot.writeListEnd()
12231 
      oprot.writeFieldEnd()
12232 
    oprot.writeFieldStop()
12233 
    oprot.writeStructEnd()
12234 
 
12235 
  def validate(self):
12236 
    return
12237 
 
12238 
 
12239 
  def __repr__(self):
12240 
    L = ['%s=%r' % (key, value)
12241 
      for key, value in self.__dict__.iteritems()]
12242 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12243 
 
12244 
  def __eq__(self, other):
12245 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12246 
 
12247 
  def __ne__(self, other):
12248 
    return not (self == other)
12249 
 
12250 
class getOrderList_result:
12251 
  """
12252 
  Attributes:
12253 
   - success
12254 
  """
12255 
 
12256 
  thrift_spec = (
12257 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
12258 
  )
12259 
 
12260 
  def __init__(self, success=None,):
12261 
    self.success = success
12262 
 
12263 
  def read(self, iprot):
12264 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12265 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12266 
      return
12267 
    iprot.readStructBegin()
12268 
    while True:
12269 
      (fname, ftype, fid) = iprot.readFieldBegin()
12270 
      if ftype == TType.STOP:
12271 
        break
12272 
      if fid == 0:
12273 
        if ftype == TType.LIST:
12274 
          self.success = []
6188 rajveer 12275 
          (_etype221, _size218) = iprot.readListBegin()
12276 
          for _i222 in xrange(_size218):
12277 
            _elem223 = Order()
12278 
            _elem223.read(iprot)
12279 
            self.success.append(_elem223)
4999 phani.kuma 12280 
          iprot.readListEnd()
12281 
        else:
12282 
          iprot.skip(ftype)
12283 
      else:
12284 
        iprot.skip(ftype)
12285 
      iprot.readFieldEnd()
12286 
    iprot.readStructEnd()
12287 
 
12288 
  def write(self, oprot):
12289 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12290 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12291 
      return
12292 
    oprot.writeStructBegin('getOrderList_result')
12293 
    if self.success is not None:
12294 
      oprot.writeFieldBegin('success', TType.LIST, 0)
12295 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 12296 
      for iter224 in self.success:
12297 
        iter224.write(oprot)
4999 phani.kuma 12298 
      oprot.writeListEnd()
12299 
      oprot.writeFieldEnd()
12300 
    oprot.writeFieldStop()
12301 
    oprot.writeStructEnd()
12302 
 
12303 
  def validate(self):
12304 
    return
12305 
 
12306 
 
12307 
  def __repr__(self):
12308 
    L = ['%s=%r' % (key, value)
12309 
      for key, value in self.__dict__.iteritems()]
12310 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12311 
 
12312 
  def __eq__(self, other):
12313 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12314 
 
12315 
  def __ne__(self, other):
12316 
    return not (self == other)
12317 
 
5386 phani.kuma 12318 
class getOrderListForVendor_args:
12319 
  """
12320 
  Attributes:
12321 
   - order_ids
12322 
   - vendorId
12323 
  """
12324 
 
12325 
  thrift_spec = (
12326 
    None, # 0
12327 
    (1, TType.LIST, 'order_ids', (TType.I64,None), None, ), # 1
12328 
    (2, TType.I64, 'vendorId', None, None, ), # 2
12329 
  )
12330 
 
12331 
  def __init__(self, order_ids=None, vendorId=None,):
12332 
    self.order_ids = order_ids
12333 
    self.vendorId = vendorId
12334 
 
12335 
  def read(self, iprot):
12336 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12337 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12338 
      return
12339 
    iprot.readStructBegin()
12340 
    while True:
12341 
      (fname, ftype, fid) = iprot.readFieldBegin()
12342 
      if ftype == TType.STOP:
12343 
        break
12344 
      if fid == 1:
12345 
        if ftype == TType.LIST:
12346 
          self.order_ids = []
6188 rajveer 12347 
          (_etype228, _size225) = iprot.readListBegin()
12348 
          for _i229 in xrange(_size225):
12349 
            _elem230 = iprot.readI64();
12350 
            self.order_ids.append(_elem230)
5386 phani.kuma 12351 
          iprot.readListEnd()
12352 
        else:
12353 
          iprot.skip(ftype)
12354 
      elif fid == 2:
12355 
        if ftype == TType.I64:
12356 
          self.vendorId = iprot.readI64();
12357 
        else:
12358 
          iprot.skip(ftype)
12359 
      else:
12360 
        iprot.skip(ftype)
12361 
      iprot.readFieldEnd()
12362 
    iprot.readStructEnd()
12363 
 
12364 
  def write(self, oprot):
12365 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12366 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12367 
      return
12368 
    oprot.writeStructBegin('getOrderListForVendor_args')
12369 
    if self.order_ids is not None:
12370 
      oprot.writeFieldBegin('order_ids', TType.LIST, 1)
12371 
      oprot.writeListBegin(TType.I64, len(self.order_ids))
6188 rajveer 12372 
      for iter231 in self.order_ids:
12373 
        oprot.writeI64(iter231)
5386 phani.kuma 12374 
      oprot.writeListEnd()
12375 
      oprot.writeFieldEnd()
12376 
    if self.vendorId is not None:
12377 
      oprot.writeFieldBegin('vendorId', TType.I64, 2)
12378 
      oprot.writeI64(self.vendorId)
12379 
      oprot.writeFieldEnd()
12380 
    oprot.writeFieldStop()
12381 
    oprot.writeStructEnd()
12382 
 
12383 
  def validate(self):
12384 
    return
12385 
 
12386 
 
12387 
  def __repr__(self):
12388 
    L = ['%s=%r' % (key, value)
12389 
      for key, value in self.__dict__.iteritems()]
12390 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12391 
 
12392 
  def __eq__(self, other):
12393 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12394 
 
12395 
  def __ne__(self, other):
12396 
    return not (self == other)
12397 
 
12398 
class getOrderListForVendor_result:
12399 
  """
12400 
  Attributes:
12401 
   - success
12402 
  """
12403 
 
12404 
  thrift_spec = (
12405 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
12406 
  )
12407 
 
12408 
  def __init__(self, success=None,):
12409 
    self.success = success
12410 
 
12411 
  def read(self, iprot):
12412 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12413 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12414 
      return
12415 
    iprot.readStructBegin()
12416 
    while True:
12417 
      (fname, ftype, fid) = iprot.readFieldBegin()
12418 
      if ftype == TType.STOP:
12419 
        break
12420 
      if fid == 0:
12421 
        if ftype == TType.LIST:
12422 
          self.success = []
6188 rajveer 12423 
          (_etype235, _size232) = iprot.readListBegin()
12424 
          for _i236 in xrange(_size232):
12425 
            _elem237 = Order()
12426 
            _elem237.read(iprot)
12427 
            self.success.append(_elem237)
5386 phani.kuma 12428 
          iprot.readListEnd()
12429 
        else:
12430 
          iprot.skip(ftype)
12431 
      else:
12432 
        iprot.skip(ftype)
12433 
      iprot.readFieldEnd()
12434 
    iprot.readStructEnd()
12435 
 
12436 
  def write(self, oprot):
12437 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12438 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12439 
      return
12440 
    oprot.writeStructBegin('getOrderListForVendor_result')
12441 
    if self.success is not None:
12442 
      oprot.writeFieldBegin('success', TType.LIST, 0)
12443 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 12444 
      for iter238 in self.success:
12445 
        iter238.write(oprot)
5386 phani.kuma 12446 
      oprot.writeListEnd()
12447 
      oprot.writeFieldEnd()
12448 
    oprot.writeFieldStop()
12449 
    oprot.writeStructEnd()
12450 
 
12451 
  def validate(self):
12452 
    return
12453 
 
12454 
 
12455 
  def __repr__(self):
12456 
    L = ['%s=%r' % (key, value)
12457 
      for key, value in self.__dict__.iteritems()]
12458 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12459 
 
12460 
  def __eq__(self, other):
12461 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12462 
 
12463 
  def __ne__(self, other):
12464 
    return not (self == other)
12465 
 
3064 chandransh 12466 
class getOrderForCustomer_args:
94 ashish 12467 
  """
12468 
  Attributes:
3064 chandransh 12469 
   - orderId
483 rajveer 12470 
   - customerId
94 ashish 12471 
  """
12472 
 
12473 
  thrift_spec = (
12474 
    None, # 0
3064 chandransh 12475 
    (1, TType.I64, 'orderId', None, None, ), # 1
12476 
    (2, TType.I64, 'customerId', None, None, ), # 2
94 ashish 12477 
  )
12478 
 
3064 chandransh 12479 
  def __init__(self, orderId=None, customerId=None,):
12480 
    self.orderId = orderId
483 rajveer 12481 
    self.customerId = customerId
94 ashish 12482 
 
12483 
  def read(self, iprot):
12484 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12485 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12486 
      return
12487 
    iprot.readStructBegin()
12488 
    while True:
12489 
      (fname, ftype, fid) = iprot.readFieldBegin()
12490 
      if ftype == TType.STOP:
12491 
        break
12492 
      if fid == 1:
12493 
        if ftype == TType.I64:
3064 chandransh 12494 
          self.orderId = iprot.readI64();
94 ashish 12495 
        else:
12496 
          iprot.skip(ftype)
12497 
      elif fid == 2:
12498 
        if ftype == TType.I64:
3064 chandransh 12499 
          self.customerId = iprot.readI64();
94 ashish 12500 
        else:
12501 
          iprot.skip(ftype)
12502 
      else:
12503 
        iprot.skip(ftype)
12504 
      iprot.readFieldEnd()
12505 
    iprot.readStructEnd()
12506 
 
12507 
  def write(self, oprot):
12508 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12509 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12510 
      return
3064 chandransh 12511 
    oprot.writeStructBegin('getOrderForCustomer_args')
3431 rajveer 12512 
    if self.orderId is not None:
3064 chandransh 12513 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
12514 
      oprot.writeI64(self.orderId)
12515 
      oprot.writeFieldEnd()
3431 rajveer 12516 
    if self.customerId is not None:
3064 chandransh 12517 
      oprot.writeFieldBegin('customerId', TType.I64, 2)
483 rajveer 12518 
      oprot.writeI64(self.customerId)
94 ashish 12519 
      oprot.writeFieldEnd()
12520 
    oprot.writeFieldStop()
12521 
    oprot.writeStructEnd()
12522 
 
3431 rajveer 12523 
  def validate(self):
12524 
    return
12525 
 
12526 
 
94 ashish 12527 
  def __repr__(self):
12528 
    L = ['%s=%r' % (key, value)
12529 
      for key, value in self.__dict__.iteritems()]
12530 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12531 
 
12532 
  def __eq__(self, other):
12533 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12534 
 
12535 
  def __ne__(self, other):
12536 
    return not (self == other)
12537 
 
3064 chandransh 12538 
class getOrderForCustomer_result:
94 ashish 12539 
  """
12540 
  Attributes:
12541 
   - success
12542 
   - ex
12543 
  """
12544 
 
12545 
  thrift_spec = (
3064 chandransh 12546 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
94 ashish 12547 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
12548 
  )
12549 
 
12550 
  def __init__(self, success=None, ex=None,):
12551 
    self.success = success
12552 
    self.ex = ex
12553 
 
12554 
  def read(self, iprot):
12555 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12556 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12557 
      return
12558 
    iprot.readStructBegin()
12559 
    while True:
12560 
      (fname, ftype, fid) = iprot.readFieldBegin()
12561 
      if ftype == TType.STOP:
12562 
        break
12563 
      if fid == 0:
3064 chandransh 12564 
        if ftype == TType.STRUCT:
12565 
          self.success = Order()
12566 
          self.success.read(iprot)
94 ashish 12567 
        else:
12568 
          iprot.skip(ftype)
12569 
      elif fid == 1:
12570 
        if ftype == TType.STRUCT:
12571 
          self.ex = TransactionServiceException()
12572 
          self.ex.read(iprot)
12573 
        else:
12574 
          iprot.skip(ftype)
12575 
      else:
12576 
        iprot.skip(ftype)
12577 
      iprot.readFieldEnd()
12578 
    iprot.readStructEnd()
12579 
 
12580 
  def write(self, oprot):
12581 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12582 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12583 
      return
3064 chandransh 12584 
    oprot.writeStructBegin('getOrderForCustomer_result')
3431 rajveer 12585 
    if self.success is not None:
3064 chandransh 12586 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
12587 
      self.success.write(oprot)
94 ashish 12588 
      oprot.writeFieldEnd()
3431 rajveer 12589 
    if self.ex is not None:
94 ashish 12590 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
12591 
      self.ex.write(oprot)
12592 
      oprot.writeFieldEnd()
12593 
    oprot.writeFieldStop()
12594 
    oprot.writeStructEnd()
12595 
 
3431 rajveer 12596 
  def validate(self):
12597 
    return
12598 
 
12599 
 
94 ashish 12600 
  def __repr__(self):
12601 
    L = ['%s=%r' % (key, value)
12602 
      for key, value in self.__dict__.iteritems()]
12603 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12604 
 
12605 
  def __eq__(self, other):
12606 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12607 
 
12608 
  def __ne__(self, other):
12609 
    return not (self == other)
12610 
 
3064 chandransh 12611 
class getAlerts_args:
94 ashish 12612 
  """
12613 
  Attributes:
4394 rajveer 12614 
   - type
4444 rajveer 12615 
   - warehouseId
4394 rajveer 12616 
   - status
12617 
   - timestamp
94 ashish 12618 
  """
12619 
 
12620 
  thrift_spec = (
12621 
    None, # 0
4394 rajveer 12622 
    (1, TType.I64, 'type', None, None, ), # 1
4444 rajveer 12623 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
12624 
    (3, TType.I64, 'status', None, None, ), # 3
12625 
    (4, TType.I64, 'timestamp', None, None, ), # 4
94 ashish 12626 
  )
12627 
 
4444 rajveer 12628 
  def __init__(self, type=None, warehouseId=None, status=None, timestamp=None,):
4394 rajveer 12629 
    self.type = type
4444 rajveer 12630 
    self.warehouseId = warehouseId
4394 rajveer 12631 
    self.status = status
12632 
    self.timestamp = timestamp
94 ashish 12633 
 
12634 
  def read(self, iprot):
12635 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12636 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12637 
      return
12638 
    iprot.readStructBegin()
12639 
    while True:
12640 
      (fname, ftype, fid) = iprot.readFieldBegin()
12641 
      if ftype == TType.STOP:
12642 
        break
12643 
      if fid == 1:
3064 chandransh 12644 
        if ftype == TType.I64:
4394 rajveer 12645 
          self.type = iprot.readI64();
94 ashish 12646 
        else:
12647 
          iprot.skip(ftype)
3064 chandransh 12648 
      elif fid == 2:
4394 rajveer 12649 
        if ftype == TType.I64:
4444 rajveer 12650 
          self.warehouseId = iprot.readI64();
3064 chandransh 12651 
        else:
12652 
          iprot.skip(ftype)
4394 rajveer 12653 
      elif fid == 3:
12654 
        if ftype == TType.I64:
4444 rajveer 12655 
          self.status = iprot.readI64();
12656 
        else:
12657 
          iprot.skip(ftype)
12658 
      elif fid == 4:
12659 
        if ftype == TType.I64:
4394 rajveer 12660 
          self.timestamp = iprot.readI64();
12661 
        else:
12662 
          iprot.skip(ftype)
94 ashish 12663 
      else:
12664 
        iprot.skip(ftype)
12665 
      iprot.readFieldEnd()
12666 
    iprot.readStructEnd()
12667 
 
12668 
  def write(self, oprot):
12669 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12670 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12671 
      return
3064 chandransh 12672 
    oprot.writeStructBegin('getAlerts_args')
4394 rajveer 12673 
    if self.type is not None:
12674 
      oprot.writeFieldBegin('type', TType.I64, 1)
12675 
      oprot.writeI64(self.type)
94 ashish 12676 
      oprot.writeFieldEnd()
4444 rajveer 12677 
    if self.warehouseId is not None:
12678 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
12679 
      oprot.writeI64(self.warehouseId)
12680 
      oprot.writeFieldEnd()
4394 rajveer 12681 
    if self.status is not None:
4444 rajveer 12682 
      oprot.writeFieldBegin('status', TType.I64, 3)
4394 rajveer 12683 
      oprot.writeI64(self.status)
3064 chandransh 12684 
      oprot.writeFieldEnd()
4394 rajveer 12685 
    if self.timestamp is not None:
4444 rajveer 12686 
      oprot.writeFieldBegin('timestamp', TType.I64, 4)
4394 rajveer 12687 
      oprot.writeI64(self.timestamp)
12688 
      oprot.writeFieldEnd()
94 ashish 12689 
    oprot.writeFieldStop()
12690 
    oprot.writeStructEnd()
12691 
 
3431 rajveer 12692 
  def validate(self):
12693 
    return
12694 
 
12695 
 
94 ashish 12696 
  def __repr__(self):
12697 
    L = ['%s=%r' % (key, value)
12698 
      for key, value in self.__dict__.iteritems()]
12699 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12700 
 
12701 
  def __eq__(self, other):
12702 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12703 
 
12704 
  def __ne__(self, other):
12705 
    return not (self == other)
12706 
 
3064 chandransh 12707 
class getAlerts_result:
94 ashish 12708 
  """
12709 
  Attributes:
12710 
   - success
12711 
  """
12712 
 
12713 
  thrift_spec = (
3064 chandransh 12714 
    (0, TType.LIST, 'success', (TType.STRUCT,(Alert, Alert.thrift_spec)), None, ), # 0
94 ashish 12715 
  )
12716 
 
3064 chandransh 12717 
  def __init__(self, success=None,):
94 ashish 12718 
    self.success = success
12719 
 
12720 
  def read(self, iprot):
12721 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12722 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12723 
      return
12724 
    iprot.readStructBegin()
12725 
    while True:
12726 
      (fname, ftype, fid) = iprot.readFieldBegin()
12727 
      if ftype == TType.STOP:
12728 
        break
12729 
      if fid == 0:
3064 chandransh 12730 
        if ftype == TType.LIST:
12731 
          self.success = []
6188 rajveer 12732 
          (_etype242, _size239) = iprot.readListBegin()
12733 
          for _i243 in xrange(_size239):
12734 
            _elem244 = Alert()
12735 
            _elem244.read(iprot)
12736 
            self.success.append(_elem244)
3064 chandransh 12737 
          iprot.readListEnd()
94 ashish 12738 
        else:
12739 
          iprot.skip(ftype)
12740 
      else:
12741 
        iprot.skip(ftype)
12742 
      iprot.readFieldEnd()
12743 
    iprot.readStructEnd()
12744 
 
12745 
  def write(self, oprot):
12746 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12747 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12748 
      return
3064 chandransh 12749 
    oprot.writeStructBegin('getAlerts_result')
3431 rajveer 12750 
    if self.success is not None:
3064 chandransh 12751 
      oprot.writeFieldBegin('success', TType.LIST, 0)
12752 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 12753 
      for iter245 in self.success:
12754 
        iter245.write(oprot)
3064 chandransh 12755 
      oprot.writeListEnd()
94 ashish 12756 
      oprot.writeFieldEnd()
12757 
    oprot.writeFieldStop()
12758 
    oprot.writeStructEnd()
12759 
 
3431 rajveer 12760 
  def validate(self):
12761 
    return
12762 
 
12763 
 
94 ashish 12764 
  def __repr__(self):
12765 
    L = ['%s=%r' % (key, value)
12766 
      for key, value in self.__dict__.iteritems()]
12767 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12768 
 
12769 
  def __eq__(self, other):
12770 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12771 
 
12772 
  def __ne__(self, other):
12773 
    return not (self == other)
12774 
 
4394 rajveer 12775 
class addAlert_args:
94 ashish 12776 
  """
12777 
  Attributes:
3064 chandransh 12778 
   - type
4444 rajveer 12779 
   - warehouseId
4394 rajveer 12780 
   - description
94 ashish 12781 
  """
12782 
 
12783 
  thrift_spec = (
12784 
    None, # 0
4394 rajveer 12785 
    (1, TType.I64, 'type', None, None, ), # 1
4444 rajveer 12786 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
12787 
    (3, TType.STRING, 'description', None, None, ), # 3
94 ashish 12788 
  )
12789 
 
4444 rajveer 12790 
  def __init__(self, type=None, warehouseId=None, description=None,):
3064 chandransh 12791 
    self.type = type
4444 rajveer 12792 
    self.warehouseId = warehouseId
4394 rajveer 12793 
    self.description = description
94 ashish 12794 
 
12795 
  def read(self, iprot):
12796 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12797 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12798 
      return
12799 
    iprot.readStructBegin()
12800 
    while True:
12801 
      (fname, ftype, fid) = iprot.readFieldBegin()
12802 
      if ftype == TType.STOP:
12803 
        break
12804 
      if fid == 1:
12805 
        if ftype == TType.I64:
4394 rajveer 12806 
          self.type = iprot.readI64();
94 ashish 12807 
        else:
12808 
          iprot.skip(ftype)
3064 chandransh 12809 
      elif fid == 2:
4444 rajveer 12810 
        if ftype == TType.I64:
12811 
          self.warehouseId = iprot.readI64();
12812 
        else:
12813 
          iprot.skip(ftype)
12814 
      elif fid == 3:
3064 chandransh 12815 
        if ftype == TType.STRING:
4394 rajveer 12816 
          self.description = iprot.readString();
3064 chandransh 12817 
        else:
12818 
          iprot.skip(ftype)
94 ashish 12819 
      else:
12820 
        iprot.skip(ftype)
12821 
      iprot.readFieldEnd()
12822 
    iprot.readStructEnd()
12823 
 
12824 
  def write(self, oprot):
12825 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12826 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12827 
      return
4394 rajveer 12828 
    oprot.writeStructBegin('addAlert_args')
3431 rajveer 12829 
    if self.type is not None:
4394 rajveer 12830 
      oprot.writeFieldBegin('type', TType.I64, 1)
3064 chandransh 12831 
      oprot.writeI64(self.type)
12832 
      oprot.writeFieldEnd()
4444 rajveer 12833 
    if self.warehouseId is not None:
12834 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
12835 
      oprot.writeI64(self.warehouseId)
12836 
      oprot.writeFieldEnd()
4394 rajveer 12837 
    if self.description is not None:
4444 rajveer 12838 
      oprot.writeFieldBegin('description', TType.STRING, 3)
4394 rajveer 12839 
      oprot.writeString(self.description)
3064 chandransh 12840 
      oprot.writeFieldEnd()
94 ashish 12841 
    oprot.writeFieldStop()
12842 
    oprot.writeStructEnd()
12843 
 
3431 rajveer 12844 
  def validate(self):
12845 
    return
12846 
 
12847 
 
94 ashish 12848 
  def __repr__(self):
12849 
    L = ['%s=%r' % (key, value)
12850 
      for key, value in self.__dict__.iteritems()]
12851 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12852 
 
12853 
  def __eq__(self, other):
12854 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12855 
 
12856 
  def __ne__(self, other):
12857 
    return not (self == other)
12858 
 
4394 rajveer 12859 
class addAlert_result:
3064 chandransh 12860 
 
12861 
  thrift_spec = (
12862 
  )
12863 
 
12864 
  def read(self, iprot):
12865 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12866 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12867 
      return
12868 
    iprot.readStructBegin()
12869 
    while True:
12870 
      (fname, ftype, fid) = iprot.readFieldBegin()
12871 
      if ftype == TType.STOP:
12872 
        break
12873 
      else:
12874 
        iprot.skip(ftype)
12875 
      iprot.readFieldEnd()
12876 
    iprot.readStructEnd()
12877 
 
12878 
  def write(self, oprot):
12879 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12880 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12881 
      return
4394 rajveer 12882 
    oprot.writeStructBegin('addAlert_result')
3064 chandransh 12883 
    oprot.writeFieldStop()
12884 
    oprot.writeStructEnd()
12885 
 
3431 rajveer 12886 
  def validate(self):
12887 
    return
12888 
 
12889 
 
3064 chandransh 12890 
  def __repr__(self):
12891 
    L = ['%s=%r' % (key, value)
12892 
      for key, value in self.__dict__.iteritems()]
12893 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12894 
 
12895 
  def __eq__(self, other):
12896 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12897 
 
12898 
  def __ne__(self, other):
12899 
    return not (self == other)
12900 
 
4444 rajveer 12901 
class markAlertsAsSeen_args:
12902 
  """
12903 
  Attributes:
12904 
   - warehouseId
12905 
  """
12906 
 
12907 
  thrift_spec = (
12908 
    None, # 0
12909 
    (1, TType.I64, 'warehouseId', None, None, ), # 1
12910 
  )
12911 
 
12912 
  def __init__(self, warehouseId=None,):
12913 
    self.warehouseId = warehouseId
12914 
 
12915 
  def read(self, iprot):
12916 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12917 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12918 
      return
12919 
    iprot.readStructBegin()
12920 
    while True:
12921 
      (fname, ftype, fid) = iprot.readFieldBegin()
12922 
      if ftype == TType.STOP:
12923 
        break
12924 
      if fid == 1:
12925 
        if ftype == TType.I64:
12926 
          self.warehouseId = iprot.readI64();
12927 
        else:
12928 
          iprot.skip(ftype)
12929 
      else:
12930 
        iprot.skip(ftype)
12931 
      iprot.readFieldEnd()
12932 
    iprot.readStructEnd()
12933 
 
12934 
  def write(self, oprot):
12935 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12936 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12937 
      return
12938 
    oprot.writeStructBegin('markAlertsAsSeen_args')
12939 
    if self.warehouseId is not None:
12940 
      oprot.writeFieldBegin('warehouseId', TType.I64, 1)
12941 
      oprot.writeI64(self.warehouseId)
12942 
      oprot.writeFieldEnd()
12943 
    oprot.writeFieldStop()
12944 
    oprot.writeStructEnd()
12945 
 
12946 
  def validate(self):
12947 
    return
12948 
 
12949 
 
12950 
  def __repr__(self):
12951 
    L = ['%s=%r' % (key, value)
12952 
      for key, value in self.__dict__.iteritems()]
12953 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12954 
 
12955 
  def __eq__(self, other):
12956 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12957 
 
12958 
  def __ne__(self, other):
12959 
    return not (self == other)
12960 
 
12961 
class markAlertsAsSeen_result:
12962 
 
12963 
  thrift_spec = (
12964 
  )
12965 
 
12966 
  def read(self, iprot):
12967 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12968 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12969 
      return
12970 
    iprot.readStructBegin()
12971 
    while True:
12972 
      (fname, ftype, fid) = iprot.readFieldBegin()
12973 
      if ftype == TType.STOP:
12974 
        break
12975 
      else:
12976 
        iprot.skip(ftype)
12977 
      iprot.readFieldEnd()
12978 
    iprot.readStructEnd()
12979 
 
12980 
  def write(self, oprot):
12981 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12982 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12983 
      return
12984 
    oprot.writeStructBegin('markAlertsAsSeen_result')
12985 
    oprot.writeFieldStop()
12986 
    oprot.writeStructEnd()
12987 
 
12988 
  def validate(self):
12989 
    return
12990 
 
12991 
 
12992 
  def __repr__(self):
12993 
    L = ['%s=%r' % (key, value)
12994 
      for key, value in self.__dict__.iteritems()]
12995 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12996 
 
12997 
  def __eq__(self, other):
12998 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12999 
 
13000 
  def __ne__(self, other):
13001 
    return not (self == other)
13002 
 
3064 chandransh 13003 
class getValidOrderCount_args:
13004 
 
13005 
  thrift_spec = (
13006 
  )
13007 
 
13008 
  def read(self, iprot):
13009 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13010 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13011 
      return
13012 
    iprot.readStructBegin()
13013 
    while True:
13014 
      (fname, ftype, fid) = iprot.readFieldBegin()
13015 
      if ftype == TType.STOP:
13016 
        break
13017 
      else:
13018 
        iprot.skip(ftype)
13019 
      iprot.readFieldEnd()
13020 
    iprot.readStructEnd()
13021 
 
13022 
  def write(self, oprot):
13023 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13024 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13025 
      return
13026 
    oprot.writeStructBegin('getValidOrderCount_args')
13027 
    oprot.writeFieldStop()
13028 
    oprot.writeStructEnd()
13029 
 
3431 rajveer 13030 
  def validate(self):
13031 
    return
13032 
 
13033 
 
3064 chandransh 13034 
  def __repr__(self):
13035 
    L = ['%s=%r' % (key, value)
13036 
      for key, value in self.__dict__.iteritems()]
13037 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13038 
 
13039 
  def __eq__(self, other):
13040 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13041 
 
13042 
  def __ne__(self, other):
13043 
    return not (self == other)
13044 
 
13045 
class getValidOrderCount_result:
94 ashish 13046 
  """
13047 
  Attributes:
13048 
   - success
13049 
  """
13050 
 
13051 
  thrift_spec = (
3064 chandransh 13052 
    (0, TType.I64, 'success', None, None, ), # 0
94 ashish 13053 
  )
13054 
 
3064 chandransh 13055 
  def __init__(self, success=None,):
94 ashish 13056 
    self.success = success
13057 
 
13058 
  def read(self, iprot):
13059 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13060 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13061 
      return
13062 
    iprot.readStructBegin()
13063 
    while True:
13064 
      (fname, ftype, fid) = iprot.readFieldBegin()
13065 
      if ftype == TType.STOP:
13066 
        break
13067 
      if fid == 0:
3064 chandransh 13068 
        if ftype == TType.I64:
13069 
          self.success = iprot.readI64();
94 ashish 13070 
        else:
13071 
          iprot.skip(ftype)
13072 
      else:
13073 
        iprot.skip(ftype)
13074 
      iprot.readFieldEnd()
13075 
    iprot.readStructEnd()
13076 
 
13077 
  def write(self, oprot):
13078 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13079 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13080 
      return
3064 chandransh 13081 
    oprot.writeStructBegin('getValidOrderCount_result')
3431 rajveer 13082 
    if self.success is not None:
3064 chandransh 13083 
      oprot.writeFieldBegin('success', TType.I64, 0)
13084 
      oprot.writeI64(self.success)
94 ashish 13085 
      oprot.writeFieldEnd()
13086 
    oprot.writeFieldStop()
13087 
    oprot.writeStructEnd()
13088 
 
3431 rajveer 13089 
  def validate(self):
13090 
    return
13091 
 
13092 
 
94 ashish 13093 
  def __repr__(self):
13094 
    L = ['%s=%r' % (key, value)
13095 
      for key, value in self.__dict__.iteritems()]
13096 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13097 
 
13098 
  def __eq__(self, other):
13099 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13100 
 
13101 
  def __ne__(self, other):
13102 
    return not (self == other)
13103 
 
3064 chandransh 13104 
class getNoOfCustomersWithSuccessfulTransaction_args:
13105 
 
13106 
  thrift_spec = (
13107 
  )
13108 
 
13109 
  def read(self, iprot):
13110 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13111 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13112 
      return
13113 
    iprot.readStructBegin()
13114 
    while True:
13115 
      (fname, ftype, fid) = iprot.readFieldBegin()
13116 
      if ftype == TType.STOP:
13117 
        break
13118 
      else:
13119 
        iprot.skip(ftype)
13120 
      iprot.readFieldEnd()
13121 
    iprot.readStructEnd()
13122 
 
13123 
  def write(self, oprot):
13124 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13125 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13126 
      return
13127 
    oprot.writeStructBegin('getNoOfCustomersWithSuccessfulTransaction_args')
13128 
    oprot.writeFieldStop()
13129 
    oprot.writeStructEnd()
13130 
 
3431 rajveer 13131 
  def validate(self):
13132 
    return
13133 
 
13134 
 
3064 chandransh 13135 
  def __repr__(self):
13136 
    L = ['%s=%r' % (key, value)
13137 
      for key, value in self.__dict__.iteritems()]
13138 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13139 
 
13140 
  def __eq__(self, other):
13141 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13142 
 
13143 
  def __ne__(self, other):
13144 
    return not (self == other)
13145 
 
13146 
class getNoOfCustomersWithSuccessfulTransaction_result:
94 ashish 13147 
  """
13148 
  Attributes:
3064 chandransh 13149 
   - success
94 ashish 13150 
  """
13151 
 
13152 
  thrift_spec = (
3064 chandransh 13153 
    (0, TType.I64, 'success', None, None, ), # 0
94 ashish 13154 
  )
13155 
 
3064 chandransh 13156 
  def __init__(self, success=None,):
13157 
    self.success = success
94 ashish 13158 
 
13159 
  def read(self, iprot):
13160 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13161 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13162 
      return
13163 
    iprot.readStructBegin()
13164 
    while True:
13165 
      (fname, ftype, fid) = iprot.readFieldBegin()
13166 
      if ftype == TType.STOP:
13167 
        break
3064 chandransh 13168 
      if fid == 0:
94 ashish 13169 
        if ftype == TType.I64:
3064 chandransh 13170 
          self.success = iprot.readI64();
94 ashish 13171 
        else:
13172 
          iprot.skip(ftype)
13173 
      else:
13174 
        iprot.skip(ftype)
13175 
      iprot.readFieldEnd()
13176 
    iprot.readStructEnd()
13177 
 
13178 
  def write(self, oprot):
13179 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13180 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13181 
      return
3064 chandransh 13182 
    oprot.writeStructBegin('getNoOfCustomersWithSuccessfulTransaction_result')
3431 rajveer 13183 
    if self.success is not None:
3064 chandransh 13184 
      oprot.writeFieldBegin('success', TType.I64, 0)
13185 
      oprot.writeI64(self.success)
94 ashish 13186 
      oprot.writeFieldEnd()
13187 
    oprot.writeFieldStop()
13188 
    oprot.writeStructEnd()
13189 
 
3431 rajveer 13190 
  def validate(self):
13191 
    return
13192 
 
13193 
 
94 ashish 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 getValidOrdersAmountRange_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('getValidOrdersAmountRange_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 getValidOrdersAmountRange_result:
94 ashish 13248 
  """
13249 
  Attributes:
13250 
   - success
13251 
  """
13252 
 
13253 
  thrift_spec = (
3064 chandransh 13254 
    (0, TType.LIST, 'success', (TType.DOUBLE,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:
483 rajveer 13270 
        if ftype == TType.LIST:
13271 
          self.success = []
6188 rajveer 13272 
          (_etype249, _size246) = iprot.readListBegin()
13273 
          for _i250 in xrange(_size246):
13274 
            _elem251 = iprot.readDouble();
13275 
            self.success.append(_elem251)
483 rajveer 13276 
          iprot.readListEnd()
94 ashish 13277 
        else:
13278 
          iprot.skip(ftype)
13279 
      else:
13280 
        iprot.skip(ftype)
13281 
      iprot.readFieldEnd()
13282 
    iprot.readStructEnd()
13283 
 
13284 
  def write(self, oprot):
13285 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13286 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13287 
      return
3064 chandransh 13288 
    oprot.writeStructBegin('getValidOrdersAmountRange_result')
3431 rajveer 13289 
    if self.success is not None:
483 rajveer 13290 
      oprot.writeFieldBegin('success', TType.LIST, 0)
3064 chandransh 13291 
      oprot.writeListBegin(TType.DOUBLE, len(self.success))
6188 rajveer 13292 
      for iter252 in self.success:
13293 
        oprot.writeDouble(iter252)
483 rajveer 13294 
      oprot.writeListEnd()
94 ashish 13295 
      oprot.writeFieldEnd()
13296 
    oprot.writeFieldStop()
13297 
    oprot.writeStructEnd()
13298 
 
3431 rajveer 13299 
  def validate(self):
13300 
    return
13301 
 
13302 
 
94 ashish 13303 
  def __repr__(self):
13304 
    L = ['%s=%r' % (key, value)
13305 
      for key, value in self.__dict__.iteritems()]
13306 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13307 
 
13308 
  def __eq__(self, other):
13309 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13310 
 
13311 
  def __ne__(self, other):
13312 
    return not (self == other)
13313 
 
3064 chandransh 13314 
class getValidOrders_args:
1528 ankur.sing 13315 
  """
13316 
  Attributes:
3064 chandransh 13317 
   - limit
5874 rajveer 13318 
   - onlyStore
1528 ankur.sing 13319 
  """
13320 
 
13321 
  thrift_spec = (
13322 
    None, # 0
3064 chandransh 13323 
    (1, TType.I64, 'limit', None, None, ), # 1
5874 rajveer 13324 
    (2, TType.BOOL, 'onlyStore', None, None, ), # 2
1528 ankur.sing 13325 
  )
13326 
 
5874 rajveer 13327 
  def __init__(self, limit=None, onlyStore=None,):
3064 chandransh 13328 
    self.limit = limit
5874 rajveer 13329 
    self.onlyStore = onlyStore
1528 ankur.sing 13330 
 
13331 
  def read(self, iprot):
13332 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13333 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13334 
      return
13335 
    iprot.readStructBegin()
13336 
    while True:
13337 
      (fname, ftype, fid) = iprot.readFieldBegin()
13338 
      if ftype == TType.STOP:
13339 
        break
13340 
      if fid == 1:
13341 
        if ftype == TType.I64:
3064 chandransh 13342 
          self.limit = iprot.readI64();
1528 ankur.sing 13343 
        else:
13344 
          iprot.skip(ftype)
5874 rajveer 13345 
      elif fid == 2:
13346 
        if ftype == TType.BOOL:
13347 
          self.onlyStore = iprot.readBool();
13348 
        else:
13349 
          iprot.skip(ftype)
1528 ankur.sing 13350 
      else:
13351 
        iprot.skip(ftype)
13352 
      iprot.readFieldEnd()
13353 
    iprot.readStructEnd()
13354 
 
13355 
  def write(self, oprot):
13356 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13357 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13358 
      return
3064 chandransh 13359 
    oprot.writeStructBegin('getValidOrders_args')
3431 rajveer 13360 
    if self.limit is not None:
3064 chandransh 13361 
      oprot.writeFieldBegin('limit', TType.I64, 1)
13362 
      oprot.writeI64(self.limit)
1528 ankur.sing 13363 
      oprot.writeFieldEnd()
5874 rajveer 13364 
    if self.onlyStore is not None:
13365 
      oprot.writeFieldBegin('onlyStore', TType.BOOL, 2)
13366 
      oprot.writeBool(self.onlyStore)
13367 
      oprot.writeFieldEnd()
1528 ankur.sing 13368 
    oprot.writeFieldStop()
13369 
    oprot.writeStructEnd()
13370 
 
3431 rajveer 13371 
  def validate(self):
13372 
    return
13373 
 
13374 
 
1528 ankur.sing 13375 
  def __repr__(self):
13376 
    L = ['%s=%r' % (key, value)
13377 
      for key, value in self.__dict__.iteritems()]
13378 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13379 
 
13380 
  def __eq__(self, other):
13381 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13382 
 
13383 
  def __ne__(self, other):
13384 
    return not (self == other)
13385 
 
3064 chandransh 13386 
class getValidOrders_result:
1528 ankur.sing 13387 
  """
13388 
  Attributes:
13389 
   - success
13390 
  """
13391 
 
13392 
  thrift_spec = (
3064 chandransh 13393 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
1528 ankur.sing 13394 
  )
13395 
 
3064 chandransh 13396 
  def __init__(self, success=None,):
1528 ankur.sing 13397 
    self.success = success
13398 
 
13399 
  def read(self, iprot):
13400 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13401 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13402 
      return
13403 
    iprot.readStructBegin()
13404 
    while True:
13405 
      (fname, ftype, fid) = iprot.readFieldBegin()
13406 
      if ftype == TType.STOP:
13407 
        break
13408 
      if fid == 0:
3064 chandransh 13409 
        if ftype == TType.LIST:
13410 
          self.success = []
6188 rajveer 13411 
          (_etype256, _size253) = iprot.readListBegin()
13412 
          for _i257 in xrange(_size253):
13413 
            _elem258 = Order()
13414 
            _elem258.read(iprot)
13415 
            self.success.append(_elem258)
3064 chandransh 13416 
          iprot.readListEnd()
1528 ankur.sing 13417 
        else:
13418 
          iprot.skip(ftype)
13419 
      else:
13420 
        iprot.skip(ftype)
13421 
      iprot.readFieldEnd()
13422 
    iprot.readStructEnd()
13423 
 
13424 
  def write(self, oprot):
13425 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13426 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13427 
      return
3064 chandransh 13428 
    oprot.writeStructBegin('getValidOrders_result')
3431 rajveer 13429 
    if self.success is not None:
3064 chandransh 13430 
      oprot.writeFieldBegin('success', TType.LIST, 0)
13431 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 13432 
      for iter259 in self.success:
13433 
        iter259.write(oprot)
3064 chandransh 13434 
      oprot.writeListEnd()
1528 ankur.sing 13435 
      oprot.writeFieldEnd()
13436 
    oprot.writeFieldStop()
13437 
    oprot.writeStructEnd()
13438 
 
3431 rajveer 13439 
  def validate(self):
13440 
    return
13441 
 
13442 
 
1528 ankur.sing 13443 
  def __repr__(self):
13444 
    L = ['%s=%r' % (key, value)
13445 
      for key, value in self.__dict__.iteritems()]
13446 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13447 
 
13448 
  def __eq__(self, other):
13449 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13450 
 
13451 
  def __ne__(self, other):
13452 
    return not (self == other)
13453 
 
1220 chandransh 13454 
class batchOrders_args:
13455 
  """
13456 
  Attributes:
13457 
   - warehouseId
13458 
  """
13459 
 
13460 
  thrift_spec = (
13461 
    None, # 0
13462 
    (1, TType.I64, 'warehouseId', None, None, ), # 1
13463 
  )
13464 
 
13465 
  def __init__(self, warehouseId=None,):
13466 
    self.warehouseId = warehouseId
13467 
 
13468 
  def read(self, iprot):
13469 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13470 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13471 
      return
13472 
    iprot.readStructBegin()
13473 
    while True:
13474 
      (fname, ftype, fid) = iprot.readFieldBegin()
13475 
      if ftype == TType.STOP:
13476 
        break
13477 
      if fid == 1:
13478 
        if ftype == TType.I64:
13479 
          self.warehouseId = iprot.readI64();
13480 
        else:
13481 
          iprot.skip(ftype)
13482 
      else:
13483 
        iprot.skip(ftype)
13484 
      iprot.readFieldEnd()
13485 
    iprot.readStructEnd()
13486 
 
13487 
  def write(self, oprot):
13488 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13489 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13490 
      return
13491 
    oprot.writeStructBegin('batchOrders_args')
3431 rajveer 13492 
    if self.warehouseId is not None:
1220 chandransh 13493 
      oprot.writeFieldBegin('warehouseId', TType.I64, 1)
13494 
      oprot.writeI64(self.warehouseId)
13495 
      oprot.writeFieldEnd()
13496 
    oprot.writeFieldStop()
13497 
    oprot.writeStructEnd()
13498 
 
3431 rajveer 13499 
  def validate(self):
13500 
    return
13501 
 
13502 
 
1220 chandransh 13503 
  def __repr__(self):
13504 
    L = ['%s=%r' % (key, value)
13505 
      for key, value in self.__dict__.iteritems()]
13506 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13507 
 
13508 
  def __eq__(self, other):
13509 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13510 
 
13511 
  def __ne__(self, other):
13512 
    return not (self == other)
13513 
 
13514 
class batchOrders_result:
13515 
  """
13516 
  Attributes:
13517 
   - success
13518 
   - ex
13519 
  """
13520 
 
13521 
  thrift_spec = (
13522 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
13523 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
13524 
  )
13525 
 
13526 
  def __init__(self, success=None, ex=None,):
13527 
    self.success = success
13528 
    self.ex = ex
13529 
 
13530 
  def read(self, iprot):
13531 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13532 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13533 
      return
13534 
    iprot.readStructBegin()
13535 
    while True:
13536 
      (fname, ftype, fid) = iprot.readFieldBegin()
13537 
      if ftype == TType.STOP:
13538 
        break
13539 
      if fid == 0:
13540 
        if ftype == TType.LIST:
13541 
          self.success = []
6188 rajveer 13542 
          (_etype263, _size260) = iprot.readListBegin()
13543 
          for _i264 in xrange(_size260):
13544 
            _elem265 = Order()
13545 
            _elem265.read(iprot)
13546 
            self.success.append(_elem265)
1220 chandransh 13547 
          iprot.readListEnd()
13548 
        else:
13549 
          iprot.skip(ftype)
13550 
      elif fid == 1:
13551 
        if ftype == TType.STRUCT:
13552 
          self.ex = TransactionServiceException()
13553 
          self.ex.read(iprot)
13554 
        else:
13555 
          iprot.skip(ftype)
13556 
      else:
13557 
        iprot.skip(ftype)
13558 
      iprot.readFieldEnd()
13559 
    iprot.readStructEnd()
13560 
 
13561 
  def write(self, oprot):
13562 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13563 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13564 
      return
13565 
    oprot.writeStructBegin('batchOrders_result')
3431 rajveer 13566 
    if self.success is not None:
1220 chandransh 13567 
      oprot.writeFieldBegin('success', TType.LIST, 0)
13568 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 13569 
      for iter266 in self.success:
13570 
        iter266.write(oprot)
1220 chandransh 13571 
      oprot.writeListEnd()
13572 
      oprot.writeFieldEnd()
3431 rajveer 13573 
    if self.ex is not None:
1220 chandransh 13574 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
13575 
      self.ex.write(oprot)
13576 
      oprot.writeFieldEnd()
13577 
    oprot.writeFieldStop()
13578 
    oprot.writeStructEnd()
13579 
 
3431 rajveer 13580 
  def validate(self):
13581 
    return
13582 
 
13583 
 
1220 chandransh 13584 
  def __repr__(self):
13585 
    L = ['%s=%r' % (key, value)
13586 
      for key, value in self.__dict__.iteritems()]
13587 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13588 
 
13589 
  def __eq__(self, other):
13590 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13591 
 
13592 
  def __ne__(self, other):
13593 
    return not (self == other)
13594 
 
1208 chandransh 13595 
class markOrderAsOutOfStock_args:
13596 
  """
13597 
  Attributes:
13598 
   - orderId
13599 
  """
13600 
 
13601 
  thrift_spec = (
13602 
    None, # 0
13603 
    (1, TType.I64, 'orderId', None, None, ), # 1
13604 
  )
13605 
 
13606 
  def __init__(self, orderId=None,):
13607 
    self.orderId = orderId
13608 
 
13609 
  def read(self, iprot):
13610 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13611 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13612 
      return
13613 
    iprot.readStructBegin()
13614 
    while True:
13615 
      (fname, ftype, fid) = iprot.readFieldBegin()
13616 
      if ftype == TType.STOP:
13617 
        break
13618 
      if fid == 1:
13619 
        if ftype == TType.I64:
13620 
          self.orderId = iprot.readI64();
13621 
        else:
13622 
          iprot.skip(ftype)
13623 
      else:
13624 
        iprot.skip(ftype)
13625 
      iprot.readFieldEnd()
13626 
    iprot.readStructEnd()
13627 
 
13628 
  def write(self, oprot):
13629 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13630 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13631 
      return
13632 
    oprot.writeStructBegin('markOrderAsOutOfStock_args')
3431 rajveer 13633 
    if self.orderId is not None:
1208 chandransh 13634 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
13635 
      oprot.writeI64(self.orderId)
13636 
      oprot.writeFieldEnd()
13637 
    oprot.writeFieldStop()
13638 
    oprot.writeStructEnd()
13639 
 
3431 rajveer 13640 
  def validate(self):
13641 
    return
13642 
 
13643 
 
1208 chandransh 13644 
  def __repr__(self):
13645 
    L = ['%s=%r' % (key, value)
13646 
      for key, value in self.__dict__.iteritems()]
13647 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13648 
 
13649 
  def __eq__(self, other):
13650 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13651 
 
13652 
  def __ne__(self, other):
13653 
    return not (self == other)
13654 
 
13655 
class markOrderAsOutOfStock_result:
13656 
  """
13657 
  Attributes:
13658 
   - success
13659 
   - ex
13660 
  """
13661 
 
13662 
  thrift_spec = (
13663 
    (0, TType.BOOL, 'success', None, None, ), # 0
13664 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
13665 
  )
13666 
 
13667 
  def __init__(self, success=None, ex=None,):
13668 
    self.success = success
13669 
    self.ex = ex
13670 
 
13671 
  def read(self, iprot):
13672 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13673 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13674 
      return
13675 
    iprot.readStructBegin()
13676 
    while True:
13677 
      (fname, ftype, fid) = iprot.readFieldBegin()
13678 
      if ftype == TType.STOP:
13679 
        break
13680 
      if fid == 0:
13681 
        if ftype == TType.BOOL:
13682 
          self.success = iprot.readBool();
13683 
        else:
13684 
          iprot.skip(ftype)
13685 
      elif fid == 1:
13686 
        if ftype == TType.STRUCT:
13687 
          self.ex = TransactionServiceException()
13688 
          self.ex.read(iprot)
13689 
        else:
13690 
          iprot.skip(ftype)
13691 
      else:
13692 
        iprot.skip(ftype)
13693 
      iprot.readFieldEnd()
13694 
    iprot.readStructEnd()
13695 
 
13696 
  def write(self, oprot):
13697 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13698 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13699 
      return
13700 
    oprot.writeStructBegin('markOrderAsOutOfStock_result')
3431 rajveer 13701 
    if self.success is not None:
1208 chandransh 13702 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
13703 
      oprot.writeBool(self.success)
13704 
      oprot.writeFieldEnd()
3431 rajveer 13705 
    if self.ex is not None:
1208 chandransh 13706 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
13707 
      self.ex.write(oprot)
13708 
      oprot.writeFieldEnd()
13709 
    oprot.writeFieldStop()
13710 
    oprot.writeStructEnd()
13711 
 
3431 rajveer 13712 
  def validate(self):
13713 
    return
13714 
 
13715 
 
1208 chandransh 13716 
  def __repr__(self):
13717 
    L = ['%s=%r' % (key, value)
13718 
      for key, value in self.__dict__.iteritems()]
13719 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13720 
 
13721 
  def __eq__(self, other):
13722 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13723 
 
13724 
  def __ne__(self, other):
13725 
    return not (self == other)
13726 
 
3064 chandransh 13727 
class verifyOrder_args:
759 chandransh 13728 
  """
13729 
  Attributes:
3064 chandransh 13730 
   - orderId
759 chandransh 13731 
  """
13732 
 
13733 
  thrift_spec = (
13734 
    None, # 0
3064 chandransh 13735 
    (1, TType.I64, 'orderId', None, None, ), # 1
759 chandransh 13736 
  )
13737 
 
3064 chandransh 13738 
  def __init__(self, orderId=None,):
13739 
    self.orderId = orderId
759 chandransh 13740 
 
13741 
  def read(self, iprot):
13742 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13743 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13744 
      return
13745 
    iprot.readStructBegin()
13746 
    while True:
13747 
      (fname, ftype, fid) = iprot.readFieldBegin()
13748 
      if ftype == TType.STOP:
13749 
        break
13750 
      if fid == 1:
13751 
        if ftype == TType.I64:
3064 chandransh 13752 
          self.orderId = iprot.readI64();
759 chandransh 13753 
        else:
13754 
          iprot.skip(ftype)
13755 
      else:
13756 
        iprot.skip(ftype)
13757 
      iprot.readFieldEnd()
13758 
    iprot.readStructEnd()
13759 
 
13760 
  def write(self, oprot):
13761 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13762 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13763 
      return
3064 chandransh 13764 
    oprot.writeStructBegin('verifyOrder_args')
3431 rajveer 13765 
    if self.orderId is not None:
3064 chandransh 13766 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
13767 
      oprot.writeI64(self.orderId)
759 chandransh 13768 
      oprot.writeFieldEnd()
13769 
    oprot.writeFieldStop()
13770 
    oprot.writeStructEnd()
13771 
 
3431 rajveer 13772 
  def validate(self):
13773 
    return
13774 
 
13775 
 
759 chandransh 13776 
  def __repr__(self):
13777 
    L = ['%s=%r' % (key, value)
13778 
      for key, value in self.__dict__.iteritems()]
13779 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13780 
 
13781 
  def __eq__(self, other):
13782 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13783 
 
13784 
  def __ne__(self, other):
13785 
    return not (self == other)
13786 
 
3064 chandransh 13787 
class verifyOrder_result:
759 chandransh 13788 
  """
13789 
  Attributes:
13790 
   - success
13791 
   - ex
13792 
  """
13793 
 
13794 
  thrift_spec = (
13795 
    (0, TType.BOOL, 'success', None, None, ), # 0
13796 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
13797 
  )
13798 
 
13799 
  def __init__(self, success=None, ex=None,):
13800 
    self.success = success
13801 
    self.ex = ex
13802 
 
13803 
  def read(self, iprot):
13804 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13805 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13806 
      return
13807 
    iprot.readStructBegin()
13808 
    while True:
13809 
      (fname, ftype, fid) = iprot.readFieldBegin()
13810 
      if ftype == TType.STOP:
13811 
        break
13812 
      if fid == 0:
13813 
        if ftype == TType.BOOL:
13814 
          self.success = iprot.readBool();
13815 
        else:
13816 
          iprot.skip(ftype)
13817 
      elif fid == 1:
13818 
        if ftype == TType.STRUCT:
13819 
          self.ex = TransactionServiceException()
13820 
          self.ex.read(iprot)
13821 
        else:
13822 
          iprot.skip(ftype)
13823 
      else:
13824 
        iprot.skip(ftype)
13825 
      iprot.readFieldEnd()
13826 
    iprot.readStructEnd()
13827 
 
13828 
  def write(self, oprot):
13829 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13830 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13831 
      return
3064 chandransh 13832 
    oprot.writeStructBegin('verifyOrder_result')
3431 rajveer 13833 
    if self.success is not None:
759 chandransh 13834 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
13835 
      oprot.writeBool(self.success)
13836 
      oprot.writeFieldEnd()
3431 rajveer 13837 
    if self.ex is not None:
759 chandransh 13838 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
13839 
      self.ex.write(oprot)
13840 
      oprot.writeFieldEnd()
13841 
    oprot.writeFieldStop()
13842 
    oprot.writeStructEnd()
13843 
 
3431 rajveer 13844 
  def validate(self):
13845 
    return
13846 
 
13847 
 
759 chandransh 13848 
  def __repr__(self):
13849 
    L = ['%s=%r' % (key, value)
13850 
      for key, value in self.__dict__.iteritems()]
13851 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13852 
 
13853 
  def __eq__(self, other):
13854 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13855 
 
13856 
  def __ne__(self, other):
13857 
    return not (self == other)
13858 
 
3064 chandransh 13859 
class acceptOrder_args:
1113 chandransh 13860 
  """
13861 
  Attributes:
3064 chandransh 13862 
   - orderId
1113 chandransh 13863 
  """
13864 
 
13865 
  thrift_spec = (
13866 
    None, # 0
3064 chandransh 13867 
    (1, TType.I64, 'orderId', None, None, ), # 1
1113 chandransh 13868 
  )
13869 
 
3064 chandransh 13870 
  def __init__(self, orderId=None,):
13871 
    self.orderId = orderId
1113 chandransh 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 == 1:
13883 
        if ftype == TType.I64:
3064 chandransh 13884 
          self.orderId = iprot.readI64();
1113 chandransh 13885 
        else:
13886 
          iprot.skip(ftype)
13887 
      else:
13888 
        iprot.skip(ftype)
13889 
      iprot.readFieldEnd()
13890 
    iprot.readStructEnd()
13891 
 
13892 
  def write(self, oprot):
13893 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13894 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13895 
      return
3064 chandransh 13896 
    oprot.writeStructBegin('acceptOrder_args')
3431 rajveer 13897 
    if self.orderId is not None:
3064 chandransh 13898 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
13899 
      oprot.writeI64(self.orderId)
1113 chandransh 13900 
      oprot.writeFieldEnd()
13901 
    oprot.writeFieldStop()
13902 
    oprot.writeStructEnd()
13903 
 
3431 rajveer 13904 
  def validate(self):
13905 
    return
13906 
 
13907 
 
1113 chandransh 13908 
  def __repr__(self):
13909 
    L = ['%s=%r' % (key, value)
13910 
      for key, value in self.__dict__.iteritems()]
13911 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13912 
 
13913 
  def __eq__(self, other):
13914 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13915 
 
13916 
  def __ne__(self, other):
13917 
    return not (self == other)
13918 
 
3064 chandransh 13919 
class acceptOrder_result:
1113 chandransh 13920 
  """
13921 
  Attributes:
13922 
   - success
13923 
   - ex
13924 
  """
13925 
 
13926 
  thrift_spec = (
3064 chandransh 13927 
    (0, TType.BOOL, 'success', None, None, ), # 0
1113 chandransh 13928 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
13929 
  )
13930 
 
13931 
  def __init__(self, success=None, ex=None,):
13932 
    self.success = success
13933 
    self.ex = ex
13934 
 
13935 
  def read(self, iprot):
13936 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13937 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13938 
      return
13939 
    iprot.readStructBegin()
13940 
    while True:
13941 
      (fname, ftype, fid) = iprot.readFieldBegin()
13942 
      if ftype == TType.STOP:
13943 
        break
13944 
      if fid == 0:
3064 chandransh 13945 
        if ftype == TType.BOOL:
13946 
          self.success = iprot.readBool();
1113 chandransh 13947 
        else:
13948 
          iprot.skip(ftype)
13949 
      elif fid == 1:
13950 
        if ftype == TType.STRUCT:
13951 
          self.ex = TransactionServiceException()
13952 
          self.ex.read(iprot)
13953 
        else:
13954 
          iprot.skip(ftype)
13955 
      else:
13956 
        iprot.skip(ftype)
13957 
      iprot.readFieldEnd()
13958 
    iprot.readStructEnd()
13959 
 
13960 
  def write(self, oprot):
13961 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13962 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13963 
      return
3064 chandransh 13964 
    oprot.writeStructBegin('acceptOrder_result')
3431 rajveer 13965 
    if self.success is not None:
3064 chandransh 13966 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
13967 
      oprot.writeBool(self.success)
1113 chandransh 13968 
      oprot.writeFieldEnd()
3431 rajveer 13969 
    if self.ex is not None:
1113 chandransh 13970 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
13971 
      self.ex.write(oprot)
13972 
      oprot.writeFieldEnd()
13973 
    oprot.writeFieldStop()
13974 
    oprot.writeStructEnd()
13975 
 
3431 rajveer 13976 
  def validate(self):
13977 
    return
13978 
 
13979 
 
1113 chandransh 13980 
  def __repr__(self):
13981 
    L = ['%s=%r' % (key, value)
13982 
      for key, value in self.__dict__.iteritems()]
13983 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13984 
 
13985 
  def __eq__(self, other):
13986 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13987 
 
13988 
  def __ne__(self, other):
13989 
    return not (self == other)
13990 
 
3064 chandransh 13991 
class addBillingDetails_args:
1135 chandransh 13992 
  """
13993 
  Attributes:
3064 chandransh 13994 
   - orderId
13995 
   - invoice_number
4658 mandeep.dh 13996 
   - serialNumber
4283 anupam.sin 13997 
   - itemNumber
3064 chandransh 13998 
   - billed_by
4264 rajveer 13999 
   - jacketNumber
4283 anupam.sin 14000 
   - billingType
5110 mandeep.dh 14001 
   - fulfilmentWarehouseId
4763 rajveer 14002 
   - authorize
1135 chandransh 14003 
  """
14004 
 
14005 
  thrift_spec = (
14006 
    None, # 0
3064 chandransh 14007 
    (1, TType.I64, 'orderId', None, None, ), # 1
14008 
    (2, TType.STRING, 'invoice_number', None, None, ), # 2
5411 rajveer 14009 
    (3, TType.LIST, 'serialNumber', (TType.STRING,None), None, ), # 3
14010 
    (4, TType.LIST, 'itemNumber', (TType.STRING,None), None, ), # 4
4283 anupam.sin 14011 
    (5, TType.STRING, 'billed_by', None, None, ), # 5
14012 
    (6, TType.I64, 'jacketNumber', None, None, ), # 6
14013 
    (7, TType.I64, 'billingType', None, None, ), # 7
5110 mandeep.dh 14014 
    (8, TType.I64, 'fulfilmentWarehouseId', None, None, ), # 8
4763 rajveer 14015 
    (9, TType.BOOL, 'authorize', None, None, ), # 9
1135 chandransh 14016 
  )
14017 
 
5110 mandeep.dh 14018 
  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 14019 
    self.orderId = orderId
14020 
    self.invoice_number = invoice_number
4658 mandeep.dh 14021 
    self.serialNumber = serialNumber
4283 anupam.sin 14022 
    self.itemNumber = itemNumber
3064 chandransh 14023 
    self.billed_by = billed_by
4264 rajveer 14024 
    self.jacketNumber = jacketNumber
4283 anupam.sin 14025 
    self.billingType = billingType
5110 mandeep.dh 14026 
    self.fulfilmentWarehouseId = fulfilmentWarehouseId
4763 rajveer 14027 
    self.authorize = authorize
1135 chandransh 14028 
 
14029 
  def read(self, iprot):
14030 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14031 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14032 
      return
14033 
    iprot.readStructBegin()
14034 
    while True:
14035 
      (fname, ftype, fid) = iprot.readFieldBegin()
14036 
      if ftype == TType.STOP:
14037 
        break
14038 
      if fid == 1:
14039 
        if ftype == TType.I64:
3064 chandransh 14040 
          self.orderId = iprot.readI64();
1135 chandransh 14041 
        else:
14042 
          iprot.skip(ftype)
14043 
      elif fid == 2:
3064 chandransh 14044 
        if ftype == TType.STRING:
14045 
          self.invoice_number = iprot.readString();
1135 chandransh 14046 
        else:
14047 
          iprot.skip(ftype)
3064 chandransh 14048 
      elif fid == 3:
5411 rajveer 14049 
        if ftype == TType.LIST:
14050 
          self.serialNumber = []
6188 rajveer 14051 
          (_etype270, _size267) = iprot.readListBegin()
14052 
          for _i271 in xrange(_size267):
14053 
            _elem272 = iprot.readString();
14054 
            self.serialNumber.append(_elem272)
5411 rajveer 14055 
          iprot.readListEnd()
3064 chandransh 14056 
        else:
14057 
          iprot.skip(ftype)
14058 
      elif fid == 4:
5411 rajveer 14059 
        if ftype == TType.LIST:
14060 
          self.itemNumber = []
6188 rajveer 14061 
          (_etype276, _size273) = iprot.readListBegin()
14062 
          for _i277 in xrange(_size273):
14063 
            _elem278 = iprot.readString();
14064 
            self.itemNumber.append(_elem278)
5411 rajveer 14065 
          iprot.readListEnd()
3064 chandransh 14066 
        else:
14067 
          iprot.skip(ftype)
14068 
      elif fid == 5:
14069 
        if ftype == TType.STRING:
4283 anupam.sin 14070 
          self.billed_by = iprot.readString();
3064 chandransh 14071 
        else:
14072 
          iprot.skip(ftype)
14073 
      elif fid == 6:
14074 
        if ftype == TType.I64:
4283 anupam.sin 14075 
          self.jacketNumber = iprot.readI64();
14076 
        else:
14077 
          iprot.skip(ftype)
14078 
      elif fid == 7:
14079 
        if ftype == TType.I64:
3064 chandransh 14080 
          self.billingType = iprot.readI64();
14081 
        else:
14082 
          iprot.skip(ftype)
4283 anupam.sin 14083 
      elif fid == 8:
14084 
        if ftype == TType.I64:
5110 mandeep.dh 14085 
          self.fulfilmentWarehouseId = iprot.readI64();
4283 anupam.sin 14086 
        else:
14087 
          iprot.skip(ftype)
4763 rajveer 14088 
      elif fid == 9:
14089 
        if ftype == TType.BOOL:
14090 
          self.authorize = iprot.readBool();
14091 
        else:
14092 
          iprot.skip(ftype)
1246 chandransh 14093 
      else:
14094 
        iprot.skip(ftype)
14095 
      iprot.readFieldEnd()
14096 
    iprot.readStructEnd()
14097 
 
14098 
  def write(self, oprot):
14099 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14100 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14101 
      return
4283 anupam.sin 14102 
    oprot.writeStructBegin('addBillingDetails_args')
3431 rajveer 14103 
    if self.orderId is not None:
3064 chandransh 14104 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
14105 
      oprot.writeI64(self.orderId)
1246 chandransh 14106 
      oprot.writeFieldEnd()
4283 anupam.sin 14107 
    if self.invoice_number is not None:
14108 
      oprot.writeFieldBegin('invoice_number', TType.STRING, 2)
14109 
      oprot.writeString(self.invoice_number)
1246 chandransh 14110 
      oprot.writeFieldEnd()
4658 mandeep.dh 14111 
    if self.serialNumber is not None:
5411 rajveer 14112 
      oprot.writeFieldBegin('serialNumber', TType.LIST, 3)
14113 
      oprot.writeListBegin(TType.STRING, len(self.serialNumber))
6188 rajveer 14114 
      for iter279 in self.serialNumber:
14115 
        oprot.writeString(iter279)
5411 rajveer 14116 
      oprot.writeListEnd()
3064 chandransh 14117 
      oprot.writeFieldEnd()
3431 rajveer 14118 
    if self.itemNumber is not None:
5411 rajveer 14119 
      oprot.writeFieldBegin('itemNumber', TType.LIST, 4)
14120 
      oprot.writeListBegin(TType.STRING, len(self.itemNumber))
6188 rajveer 14121 
      for iter280 in self.itemNumber:
14122 
        oprot.writeString(iter280)
5411 rajveer 14123 
      oprot.writeListEnd()
3064 chandransh 14124 
      oprot.writeFieldEnd()
4283 anupam.sin 14125 
    if self.billed_by is not None:
14126 
      oprot.writeFieldBegin('billed_by', TType.STRING, 5)
14127 
      oprot.writeString(self.billed_by)
3064 chandransh 14128 
      oprot.writeFieldEnd()
4283 anupam.sin 14129 
    if self.jacketNumber is not None:
14130 
      oprot.writeFieldBegin('jacketNumber', TType.I64, 6)
14131 
      oprot.writeI64(self.jacketNumber)
14132 
      oprot.writeFieldEnd()
3431 rajveer 14133 
    if self.billingType is not None:
4283 anupam.sin 14134 
      oprot.writeFieldBegin('billingType', TType.I64, 7)
3064 chandransh 14135 
      oprot.writeI64(self.billingType)
14136 
      oprot.writeFieldEnd()
5110 mandeep.dh 14137 
    if self.fulfilmentWarehouseId is not None:
14138 
      oprot.writeFieldBegin('fulfilmentWarehouseId', TType.I64, 8)
14139 
      oprot.writeI64(self.fulfilmentWarehouseId)
4283 anupam.sin 14140 
      oprot.writeFieldEnd()
4763 rajveer 14141 
    if self.authorize is not None:
14142 
      oprot.writeFieldBegin('authorize', TType.BOOL, 9)
14143 
      oprot.writeBool(self.authorize)
14144 
      oprot.writeFieldEnd()
1246 chandransh 14145 
    oprot.writeFieldStop()
14146 
    oprot.writeStructEnd()
14147 
 
3431 rajveer 14148 
  def validate(self):
14149 
    return
14150 
 
14151 
 
1246 chandransh 14152 
  def __repr__(self):
14153 
    L = ['%s=%r' % (key, value)
14154 
      for key, value in self.__dict__.iteritems()]
14155 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14156 
 
14157 
  def __eq__(self, other):
14158 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14159 
 
14160 
  def __ne__(self, other):
14161 
    return not (self == other)
14162 
 
4283 anupam.sin 14163 
class addBillingDetails_result:
1246 chandransh 14164 
  """
14165 
  Attributes:
3064 chandransh 14166 
   - success
1246 chandransh 14167 
   - ex
14168 
  """
14169 
 
14170 
  thrift_spec = (
3064 chandransh 14171 
    (0, TType.BOOL, 'success', None, None, ), # 0
1246 chandransh 14172 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
14173 
  )
14174 
 
3064 chandransh 14175 
  def __init__(self, success=None, ex=None,):
14176 
    self.success = success
1246 chandransh 14177 
    self.ex = ex
14178 
 
14179 
  def read(self, iprot):
14180 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14181 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14182 
      return
14183 
    iprot.readStructBegin()
14184 
    while True:
14185 
      (fname, ftype, fid) = iprot.readFieldBegin()
14186 
      if ftype == TType.STOP:
14187 
        break
3064 chandransh 14188 
      if fid == 0:
14189 
        if ftype == TType.BOOL:
14190 
          self.success = iprot.readBool();
14191 
        else:
14192 
          iprot.skip(ftype)
14193 
      elif fid == 1:
1246 chandransh 14194 
        if ftype == TType.STRUCT:
14195 
          self.ex = TransactionServiceException()
14196 
          self.ex.read(iprot)
14197 
        else:
14198 
          iprot.skip(ftype)
14199 
      else:
14200 
        iprot.skip(ftype)
14201 
      iprot.readFieldEnd()
14202 
    iprot.readStructEnd()
14203 
 
14204 
  def write(self, oprot):
14205 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14206 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14207 
      return
4283 anupam.sin 14208 
    oprot.writeStructBegin('addBillingDetails_result')
3431 rajveer 14209 
    if self.success is not None:
3064 chandransh 14210 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
14211 
      oprot.writeBool(self.success)
14212 
      oprot.writeFieldEnd()
3431 rajveer 14213 
    if self.ex is not None:
1246 chandransh 14214 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
14215 
      self.ex.write(oprot)
14216 
      oprot.writeFieldEnd()
14217 
    oprot.writeFieldStop()
14218 
    oprot.writeStructEnd()
14219 
 
3431 rajveer 14220 
  def validate(self):
14221 
    return
14222 
 
14223 
 
1246 chandransh 14224 
  def __repr__(self):
14225 
    L = ['%s=%r' % (key, value)
14226 
      for key, value in self.__dict__.iteritems()]
14227 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14228 
 
14229 
  def __eq__(self, other):
14230 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14231 
 
14232 
  def __ne__(self, other):
14233 
    return not (self == other)
14234 
 
4579 rajveer 14235 
class addInvoiceNumber_args:
14236 
  """
14237 
  Attributes:
14238 
   - orderId
14239 
   - invoiceNumber
4763 rajveer 14240 
   - color
6756 amar.kumar 14241 
   - serialNumber
14242 
   - itemNumber
4579 rajveer 14243 
  """
14244 
 
14245 
  thrift_spec = (
14246 
    None, # 0
14247 
    (1, TType.I64, 'orderId', None, None, ), # 1
14248 
    (2, TType.STRING, 'invoiceNumber', None, None, ), # 2
4763 rajveer 14249 
    (3, TType.STRING, 'color', None, None, ), # 3
6756 amar.kumar 14250 
    (4, TType.STRING, 'serialNumber', None, None, ), # 4
14251 
    (5, TType.STRING, 'itemNumber', None, None, ), # 5
4579 rajveer 14252 
  )
14253 
 
6756 amar.kumar 14254 
  def __init__(self, orderId=None, invoiceNumber=None, color=None, serialNumber=None, itemNumber=None,):
4579 rajveer 14255 
    self.orderId = orderId
14256 
    self.invoiceNumber = invoiceNumber
4763 rajveer 14257 
    self.color = color
6756 amar.kumar 14258 
    self.serialNumber = serialNumber
14259 
    self.itemNumber = itemNumber
4579 rajveer 14260 
 
14261 
  def read(self, iprot):
14262 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14263 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14264 
      return
14265 
    iprot.readStructBegin()
14266 
    while True:
14267 
      (fname, ftype, fid) = iprot.readFieldBegin()
14268 
      if ftype == TType.STOP:
14269 
        break
14270 
      if fid == 1:
14271 
        if ftype == TType.I64:
14272 
          self.orderId = iprot.readI64();
14273 
        else:
14274 
          iprot.skip(ftype)
14275 
      elif fid == 2:
14276 
        if ftype == TType.STRING:
14277 
          self.invoiceNumber = iprot.readString();
14278 
        else:
14279 
          iprot.skip(ftype)
4763 rajveer 14280 
      elif fid == 3:
14281 
        if ftype == TType.STRING:
14282 
          self.color = iprot.readString();
14283 
        else:
14284 
          iprot.skip(ftype)
6756 amar.kumar 14285 
      elif fid == 4:
14286 
        if ftype == TType.STRING:
14287 
          self.serialNumber = iprot.readString();
14288 
        else:
14289 
          iprot.skip(ftype)
14290 
      elif fid == 5:
14291 
        if ftype == TType.STRING:
14292 
          self.itemNumber = iprot.readString();
14293 
        else:
14294 
          iprot.skip(ftype)
4579 rajveer 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
14304 
    oprot.writeStructBegin('addInvoiceNumber_args')
14305 
    if self.orderId is not None:
14306 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
14307 
      oprot.writeI64(self.orderId)
14308 
      oprot.writeFieldEnd()
14309 
    if self.invoiceNumber is not None:
14310 
      oprot.writeFieldBegin('invoiceNumber', TType.STRING, 2)
14311 
      oprot.writeString(self.invoiceNumber)
14312 
      oprot.writeFieldEnd()
4763 rajveer 14313 
    if self.color is not None:
14314 
      oprot.writeFieldBegin('color', TType.STRING, 3)
14315 
      oprot.writeString(self.color)
14316 
      oprot.writeFieldEnd()
6756 amar.kumar 14317 
    if self.serialNumber is not None:
14318 
      oprot.writeFieldBegin('serialNumber', TType.STRING, 4)
14319 
      oprot.writeString(self.serialNumber)
14320 
      oprot.writeFieldEnd()
14321 
    if self.itemNumber is not None:
14322 
      oprot.writeFieldBegin('itemNumber', TType.STRING, 5)
14323 
      oprot.writeString(self.itemNumber)
14324 
      oprot.writeFieldEnd()
4579 rajveer 14325 
    oprot.writeFieldStop()
14326 
    oprot.writeStructEnd()
14327 
 
14328 
  def validate(self):
14329 
    return
14330 
 
14331 
 
14332 
  def __repr__(self):
14333 
    L = ['%s=%r' % (key, value)
14334 
      for key, value in self.__dict__.iteritems()]
14335 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14336 
 
14337 
  def __eq__(self, other):
14338 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14339 
 
14340 
  def __ne__(self, other):
14341 
    return not (self == other)
14342 
 
14343 
class addInvoiceNumber_result:
14344 
  """
14345 
  Attributes:
14346 
   - ex
14347 
  """
14348 
 
14349 
  thrift_spec = (
14350 
    None, # 0
14351 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
14352 
  )
14353 
 
14354 
  def __init__(self, ex=None,):
14355 
    self.ex = ex
14356 
 
14357 
  def read(self, iprot):
14358 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14359 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14360 
      return
14361 
    iprot.readStructBegin()
14362 
    while True:
14363 
      (fname, ftype, fid) = iprot.readFieldBegin()
14364 
      if ftype == TType.STOP:
14365 
        break
14366 
      if fid == 1:
14367 
        if ftype == TType.STRUCT:
14368 
          self.ex = TransactionServiceException()
14369 
          self.ex.read(iprot)
14370 
        else:
14371 
          iprot.skip(ftype)
14372 
      else:
14373 
        iprot.skip(ftype)
14374 
      iprot.readFieldEnd()
14375 
    iprot.readStructEnd()
14376 
 
14377 
  def write(self, oprot):
14378 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14379 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14380 
      return
14381 
    oprot.writeStructBegin('addInvoiceNumber_result')
14382 
    if self.ex is not None:
14383 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
14384 
      self.ex.write(oprot)
14385 
      oprot.writeFieldEnd()
14386 
    oprot.writeFieldStop()
14387 
    oprot.writeStructEnd()
14388 
 
14389 
  def validate(self):
14390 
    return
14391 
 
14392 
 
14393 
  def __repr__(self):
14394 
    L = ['%s=%r' % (key, value)
14395 
      for key, value in self.__dict__.iteritems()]
14396 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14397 
 
14398 
  def __eq__(self, other):
14399 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14400 
 
14401 
  def __ne__(self, other):
14402 
    return not (self == other)
14403 
 
4910 phani.kuma 14404 
class markOrdersAsShippedFromWarehouse_args:
1408 ankur.sing 14405 
  """
14406 
  Attributes:
3064 chandransh 14407 
   - warehouseId
1408 ankur.sing 14408 
   - providerId
3064 chandransh 14409 
   - cod
4910 phani.kuma 14410 
   - orderIds
1408 ankur.sing 14411 
  """
14412 
 
14413 
  thrift_spec = (
14414 
    None, # 0
3064 chandransh 14415 
    (1, TType.I64, 'warehouseId', None, None, ), # 1
14416 
    (2, TType.I64, 'providerId', None, None, ), # 2
14417 
    (3, TType.BOOL, 'cod', None, None, ), # 3
4910 phani.kuma 14418 
    (4, TType.LIST, 'orderIds', (TType.I64,None), None, ), # 4
1408 ankur.sing 14419 
  )
14420 
 
4910 phani.kuma 14421 
  def __init__(self, warehouseId=None, providerId=None, cod=None, orderIds=None,):
3064 chandransh 14422 
    self.warehouseId = warehouseId
1408 ankur.sing 14423 
    self.providerId = providerId
3064 chandransh 14424 
    self.cod = cod
4910 phani.kuma 14425 
    self.orderIds = orderIds
1408 ankur.sing 14426 
 
14427 
  def read(self, iprot):
14428 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14429 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14430 
      return
14431 
    iprot.readStructBegin()
14432 
    while True:
14433 
      (fname, ftype, fid) = iprot.readFieldBegin()
14434 
      if ftype == TType.STOP:
14435 
        break
14436 
      if fid == 1:
14437 
        if ftype == TType.I64:
3064 chandransh 14438 
          self.warehouseId = iprot.readI64();
1408 ankur.sing 14439 
        else:
14440 
          iprot.skip(ftype)
14441 
      elif fid == 2:
14442 
        if ftype == TType.I64:
3064 chandransh 14443 
          self.providerId = iprot.readI64();
1408 ankur.sing 14444 
        else:
14445 
          iprot.skip(ftype)
3064 chandransh 14446 
      elif fid == 3:
14447 
        if ftype == TType.BOOL:
14448 
          self.cod = iprot.readBool();
14449 
        else:
14450 
          iprot.skip(ftype)
4910 phani.kuma 14451 
      elif fid == 4:
14452 
        if ftype == TType.LIST:
14453 
          self.orderIds = []
6188 rajveer 14454 
          (_etype284, _size281) = iprot.readListBegin()
14455 
          for _i285 in xrange(_size281):
14456 
            _elem286 = iprot.readI64();
14457 
            self.orderIds.append(_elem286)
4910 phani.kuma 14458 
          iprot.readListEnd()
14459 
        else:
14460 
          iprot.skip(ftype)
1408 ankur.sing 14461 
      else:
14462 
        iprot.skip(ftype)
14463 
      iprot.readFieldEnd()
14464 
    iprot.readStructEnd()
14465 
 
14466 
  def write(self, oprot):
14467 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14468 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14469 
      return
4910 phani.kuma 14470 
    oprot.writeStructBegin('markOrdersAsShippedFromWarehouse_args')
3431 rajveer 14471 
    if self.warehouseId is not None:
3064 chandransh 14472 
      oprot.writeFieldBegin('warehouseId', TType.I64, 1)
14473 
      oprot.writeI64(self.warehouseId)
14474 
      oprot.writeFieldEnd()
3431 rajveer 14475 
    if self.providerId is not None:
3064 chandransh 14476 
      oprot.writeFieldBegin('providerId', TType.I64, 2)
1408 ankur.sing 14477 
      oprot.writeI64(self.providerId)
14478 
      oprot.writeFieldEnd()
3431 rajveer 14479 
    if self.cod is not None:
3064 chandransh 14480 
      oprot.writeFieldBegin('cod', TType.BOOL, 3)
14481 
      oprot.writeBool(self.cod)
1408 ankur.sing 14482 
      oprot.writeFieldEnd()
4910 phani.kuma 14483 
    if self.orderIds is not None:
14484 
      oprot.writeFieldBegin('orderIds', TType.LIST, 4)
14485 
      oprot.writeListBegin(TType.I64, len(self.orderIds))
6188 rajveer 14486 
      for iter287 in self.orderIds:
14487 
        oprot.writeI64(iter287)
4910 phani.kuma 14488 
      oprot.writeListEnd()
14489 
      oprot.writeFieldEnd()
1408 ankur.sing 14490 
    oprot.writeFieldStop()
14491 
    oprot.writeStructEnd()
14492 
 
3431 rajveer 14493 
  def validate(self):
14494 
    return
14495 
 
14496 
 
1408 ankur.sing 14497 
  def __repr__(self):
14498 
    L = ['%s=%r' % (key, value)
14499 
      for key, value in self.__dict__.iteritems()]
14500 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14501 
 
14502 
  def __eq__(self, other):
14503 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14504 
 
14505 
  def __ne__(self, other):
14506 
    return not (self == other)
14507 
 
4910 phani.kuma 14508 
class markOrdersAsShippedFromWarehouse_result:
1408 ankur.sing 14509 
  """
14510 
  Attributes:
14511 
   - success
3064 chandransh 14512 
   - ex
1408 ankur.sing 14513 
  """
14514 
 
14515 
  thrift_spec = (
3064 chandransh 14516 
    (0, TType.BOOL, 'success', None, None, ), # 0
14517 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
1408 ankur.sing 14518 
  )
14519 
 
3064 chandransh 14520 
  def __init__(self, success=None, ex=None,):
1408 ankur.sing 14521 
    self.success = success
3064 chandransh 14522 
    self.ex = ex
1408 ankur.sing 14523 
 
14524 
  def read(self, iprot):
14525 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14526 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14527 
      return
14528 
    iprot.readStructBegin()
14529 
    while True:
14530 
      (fname, ftype, fid) = iprot.readFieldBegin()
14531 
      if ftype == TType.STOP:
14532 
        break
14533 
      if fid == 0:
3064 chandransh 14534 
        if ftype == TType.BOOL:
14535 
          self.success = iprot.readBool();
1408 ankur.sing 14536 
        else:
14537 
          iprot.skip(ftype)
3064 chandransh 14538 
      elif fid == 1:
14539 
        if ftype == TType.STRUCT:
14540 
          self.ex = TransactionServiceException()
14541 
          self.ex.read(iprot)
14542 
        else:
14543 
          iprot.skip(ftype)
1408 ankur.sing 14544 
      else:
14545 
        iprot.skip(ftype)
14546 
      iprot.readFieldEnd()
14547 
    iprot.readStructEnd()
14548 
 
14549 
  def write(self, oprot):
14550 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14551 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14552 
      return
4910 phani.kuma 14553 
    oprot.writeStructBegin('markOrdersAsShippedFromWarehouse_result')
3431 rajveer 14554 
    if self.success is not None:
3064 chandransh 14555 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
14556 
      oprot.writeBool(self.success)
1408 ankur.sing 14557 
      oprot.writeFieldEnd()
3431 rajveer 14558 
    if self.ex is not None:
3064 chandransh 14559 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
14560 
      self.ex.write(oprot)
14561 
      oprot.writeFieldEnd()
1408 ankur.sing 14562 
    oprot.writeFieldStop()
14563 
    oprot.writeStructEnd()
14564 
 
3431 rajveer 14565 
  def validate(self):
14566 
    return
14567 
 
14568 
 
1408 ankur.sing 14569 
  def __repr__(self):
14570 
    L = ['%s=%r' % (key, value)
14571 
      for key, value in self.__dict__.iteritems()]
14572 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14573 
 
14574 
  def __eq__(self, other):
14575 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14576 
 
14577 
  def __ne__(self, other):
14578 
    return not (self == other)
14579 
 
5676 rajveer 14580 
class markOrdersAsReturnedFromStore_args:
14581 
  """
14582 
  Attributes:
14583 
   - providerId
14584 
   - orderIds
5713 rajveer 14585 
   - awbs
5676 rajveer 14586 
  """
14587 
 
14588 
  thrift_spec = (
14589 
    None, # 0
14590 
    (1, TType.I64, 'providerId', None, None, ), # 1
14591 
    (2, TType.LIST, 'orderIds', (TType.I64,None), None, ), # 2
5713 rajveer 14592 
    (3, TType.LIST, 'awbs', (TType.STRING,None), None, ), # 3
5676 rajveer 14593 
  )
14594 
 
5713 rajveer 14595 
  def __init__(self, providerId=None, orderIds=None, awbs=None,):
5676 rajveer 14596 
    self.providerId = providerId
14597 
    self.orderIds = orderIds
5713 rajveer 14598 
    self.awbs = awbs
5676 rajveer 14599 
 
14600 
  def read(self, iprot):
14601 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14602 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14603 
      return
14604 
    iprot.readStructBegin()
14605 
    while True:
14606 
      (fname, ftype, fid) = iprot.readFieldBegin()
14607 
      if ftype == TType.STOP:
14608 
        break
14609 
      if fid == 1:
14610 
        if ftype == TType.I64:
14611 
          self.providerId = iprot.readI64();
14612 
        else:
14613 
          iprot.skip(ftype)
14614 
      elif fid == 2:
14615 
        if ftype == TType.LIST:
14616 
          self.orderIds = []
6188 rajveer 14617 
          (_etype291, _size288) = iprot.readListBegin()
14618 
          for _i292 in xrange(_size288):
14619 
            _elem293 = iprot.readI64();
14620 
            self.orderIds.append(_elem293)
5676 rajveer 14621 
          iprot.readListEnd()
14622 
        else:
14623 
          iprot.skip(ftype)
5713 rajveer 14624 
      elif fid == 3:
14625 
        if ftype == TType.LIST:
14626 
          self.awbs = []
6188 rajveer 14627 
          (_etype297, _size294) = iprot.readListBegin()
14628 
          for _i298 in xrange(_size294):
14629 
            _elem299 = iprot.readString();
14630 
            self.awbs.append(_elem299)
5713 rajveer 14631 
          iprot.readListEnd()
14632 
        else:
14633 
          iprot.skip(ftype)
5676 rajveer 14634 
      else:
14635 
        iprot.skip(ftype)
14636 
      iprot.readFieldEnd()
14637 
    iprot.readStructEnd()
14638 
 
14639 
  def write(self, oprot):
14640 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14641 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14642 
      return
14643 
    oprot.writeStructBegin('markOrdersAsReturnedFromStore_args')
14644 
    if self.providerId is not None:
14645 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
14646 
      oprot.writeI64(self.providerId)
14647 
      oprot.writeFieldEnd()
14648 
    if self.orderIds is not None:
14649 
      oprot.writeFieldBegin('orderIds', TType.LIST, 2)
14650 
      oprot.writeListBegin(TType.I64, len(self.orderIds))
6188 rajveer 14651 
      for iter300 in self.orderIds:
14652 
        oprot.writeI64(iter300)
5676 rajveer 14653 
      oprot.writeListEnd()
14654 
      oprot.writeFieldEnd()
5713 rajveer 14655 
    if self.awbs is not None:
14656 
      oprot.writeFieldBegin('awbs', TType.LIST, 3)
14657 
      oprot.writeListBegin(TType.STRING, len(self.awbs))
6188 rajveer 14658 
      for iter301 in self.awbs:
14659 
        oprot.writeString(iter301)
5713 rajveer 14660 
      oprot.writeListEnd()
14661 
      oprot.writeFieldEnd()
5676 rajveer 14662 
    oprot.writeFieldStop()
14663 
    oprot.writeStructEnd()
14664 
 
14665 
  def validate(self):
14666 
    return
14667 
 
14668 
 
14669 
  def __repr__(self):
14670 
    L = ['%s=%r' % (key, value)
14671 
      for key, value in self.__dict__.iteritems()]
14672 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14673 
 
14674 
  def __eq__(self, other):
14675 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14676 
 
14677 
  def __ne__(self, other):
14678 
    return not (self == other)
14679 
 
14680 
class markOrdersAsReturnedFromStore_result:
14681 
  """
14682 
  Attributes:
14683 
   - success
14684 
   - ex
14685 
  """
14686 
 
14687 
  thrift_spec = (
14688 
    (0, TType.BOOL, 'success', None, None, ), # 0
14689 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
14690 
  )
14691 
 
14692 
  def __init__(self, success=None, ex=None,):
14693 
    self.success = success
14694 
    self.ex = ex
14695 
 
14696 
  def read(self, iprot):
14697 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14698 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14699 
      return
14700 
    iprot.readStructBegin()
14701 
    while True:
14702 
      (fname, ftype, fid) = iprot.readFieldBegin()
14703 
      if ftype == TType.STOP:
14704 
        break
14705 
      if fid == 0:
14706 
        if ftype == TType.BOOL:
14707 
          self.success = iprot.readBool();
14708 
        else:
14709 
          iprot.skip(ftype)
14710 
      elif fid == 1:
14711 
        if ftype == TType.STRUCT:
14712 
          self.ex = TransactionServiceException()
14713 
          self.ex.read(iprot)
14714 
        else:
14715 
          iprot.skip(ftype)
14716 
      else:
14717 
        iprot.skip(ftype)
14718 
      iprot.readFieldEnd()
14719 
    iprot.readStructEnd()
14720 
 
14721 
  def write(self, oprot):
14722 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14723 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14724 
      return
14725 
    oprot.writeStructBegin('markOrdersAsReturnedFromStore_result')
14726 
    if self.success is not None:
14727 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
14728 
      oprot.writeBool(self.success)
14729 
      oprot.writeFieldEnd()
14730 
    if self.ex is not None:
14731 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
14732 
      self.ex.write(oprot)
14733 
      oprot.writeFieldEnd()
14734 
    oprot.writeFieldStop()
14735 
    oprot.writeStructEnd()
14736 
 
14737 
  def validate(self):
14738 
    return
14739 
 
14740 
 
14741 
  def __repr__(self):
14742 
    L = ['%s=%r' % (key, value)
14743 
      for key, value in self.__dict__.iteritems()]
14744 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14745 
 
14746 
  def __eq__(self, other):
14747 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14748 
 
14749 
  def __ne__(self, other):
14750 
    return not (self == other)
14751 
 
4910 phani.kuma 14752 
class markOrdersAsPickedUp_args:
4410 rajveer 14753 
  """
14754 
  Attributes:
14755 
   - providerId
4910 phani.kuma 14756 
   - pickupDetails
4410 rajveer 14757 
  """
14758 
 
14759 
  thrift_spec = (
14760 
    None, # 0
4910 phani.kuma 14761 
    (1, TType.I64, 'providerId', None, None, ), # 1
14762 
    (2, TType.MAP, 'pickupDetails', (TType.STRING,None,TType.STRING,None), None, ), # 2
4410 rajveer 14763 
  )
14764 
 
4910 phani.kuma 14765 
  def __init__(self, providerId=None, pickupDetails=None,):
4410 rajveer 14766 
    self.providerId = providerId
4910 phani.kuma 14767 
    self.pickupDetails = pickupDetails
4410 rajveer 14768 
 
14769 
  def read(self, iprot):
14770 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14771 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14772 
      return
14773 
    iprot.readStructBegin()
14774 
    while True:
14775 
      (fname, ftype, fid) = iprot.readFieldBegin()
14776 
      if ftype == TType.STOP:
14777 
        break
14778 
      if fid == 1:
14779 
        if ftype == TType.I64:
4910 phani.kuma 14780 
          self.providerId = iprot.readI64();
4410 rajveer 14781 
        else:
14782 
          iprot.skip(ftype)
14783 
      elif fid == 2:
4910 phani.kuma 14784 
        if ftype == TType.MAP:
14785 
          self.pickupDetails = {}
6188 rajveer 14786 
          (_ktype303, _vtype304, _size302 ) = iprot.readMapBegin()
14787 
          for _i306 in xrange(_size302):
14788 
            _key307 = iprot.readString();
14789 
            _val308 = iprot.readString();
14790 
            self.pickupDetails[_key307] = _val308
4910 phani.kuma 14791 
          iprot.readMapEnd()
4410 rajveer 14792 
        else:
14793 
          iprot.skip(ftype)
14794 
      else:
14795 
        iprot.skip(ftype)
14796 
      iprot.readFieldEnd()
14797 
    iprot.readStructEnd()
14798 
 
14799 
  def write(self, oprot):
14800 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14801 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14802 
      return
4910 phani.kuma 14803 
    oprot.writeStructBegin('markOrdersAsPickedUp_args')
4410 rajveer 14804 
    if self.providerId is not None:
4910 phani.kuma 14805 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
4410 rajveer 14806 
      oprot.writeI64(self.providerId)
14807 
      oprot.writeFieldEnd()
4910 phani.kuma 14808 
    if self.pickupDetails is not None:
14809 
      oprot.writeFieldBegin('pickupDetails', TType.MAP, 2)
14810 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.pickupDetails))
6188 rajveer 14811 
      for kiter309,viter310 in self.pickupDetails.items():
14812 
        oprot.writeString(kiter309)
14813 
        oprot.writeString(viter310)
4910 phani.kuma 14814 
      oprot.writeMapEnd()
4410 rajveer 14815 
      oprot.writeFieldEnd()
14816 
    oprot.writeFieldStop()
14817 
    oprot.writeStructEnd()
14818 
 
14819 
  def validate(self):
14820 
    return
14821 
 
14822 
 
14823 
  def __repr__(self):
14824 
    L = ['%s=%r' % (key, value)
14825 
      for key, value in self.__dict__.iteritems()]
14826 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14827 
 
14828 
  def __eq__(self, other):
14829 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14830 
 
14831 
  def __ne__(self, other):
14832 
    return not (self == other)
14833 
 
4910 phani.kuma 14834 
class markOrdersAsPickedUp_result:
4410 rajveer 14835 
  """
14836 
  Attributes:
14837 
   - ex
14838 
  """
14839 
 
14840 
  thrift_spec = (
4910 phani.kuma 14841 
    None, # 0
4410 rajveer 14842 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
14843 
  )
14844 
 
4910 phani.kuma 14845 
  def __init__(self, ex=None,):
4410 rajveer 14846 
    self.ex = ex
14847 
 
14848 
  def read(self, iprot):
14849 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14850 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14851 
      return
14852 
    iprot.readStructBegin()
14853 
    while True:
14854 
      (fname, ftype, fid) = iprot.readFieldBegin()
14855 
      if ftype == TType.STOP:
14856 
        break
4910 phani.kuma 14857 
      if fid == 1:
4410 rajveer 14858 
        if ftype == TType.STRUCT:
14859 
          self.ex = TransactionServiceException()
14860 
          self.ex.read(iprot)
14861 
        else:
14862 
          iprot.skip(ftype)
14863 
      else:
14864 
        iprot.skip(ftype)
14865 
      iprot.readFieldEnd()
14866 
    iprot.readStructEnd()
14867 
 
14868 
  def write(self, oprot):
14869 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14870 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14871 
      return
4910 phani.kuma 14872 
    oprot.writeStructBegin('markOrdersAsPickedUp_result')
4410 rajveer 14873 
    if self.ex is not None:
14874 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
14875 
      self.ex.write(oprot)
14876 
      oprot.writeFieldEnd()
14877 
    oprot.writeFieldStop()
14878 
    oprot.writeStructEnd()
14879 
 
14880 
  def validate(self):
14881 
    return
14882 
 
14883 
 
14884 
  def __repr__(self):
14885 
    L = ['%s=%r' % (key, value)
14886 
      for key, value in self.__dict__.iteritems()]
14887 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14888 
 
14889 
  def __eq__(self, other):
14890 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14891 
 
14892 
  def __ne__(self, other):
14893 
    return not (self == other)
14894 
 
4910 phani.kuma 14895 
class getOrdersNotPickedUp_args:
304 ashish 14896 
  """
14897 
  Attributes:
3064 chandransh 14898 
   - providerId
304 ashish 14899 
  """
94 ashish 14900 
 
304 ashish 14901 
  thrift_spec = (
14902 
    None, # 0
3064 chandransh 14903 
    (1, TType.I64, 'providerId', None, None, ), # 1
304 ashish 14904 
  )
14905 
 
4910 phani.kuma 14906 
  def __init__(self, providerId=None,):
3064 chandransh 14907 
    self.providerId = providerId
304 ashish 14908 
 
14909 
  def read(self, iprot):
14910 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14911 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14912 
      return
14913 
    iprot.readStructBegin()
14914 
    while True:
14915 
      (fname, ftype, fid) = iprot.readFieldBegin()
14916 
      if ftype == TType.STOP:
14917 
        break
14918 
      if fid == 1:
14919 
        if ftype == TType.I64:
3064 chandransh 14920 
          self.providerId = iprot.readI64();
304 ashish 14921 
        else:
14922 
          iprot.skip(ftype)
14923 
      else:
14924 
        iprot.skip(ftype)
14925 
      iprot.readFieldEnd()
14926 
    iprot.readStructEnd()
14927 
 
14928 
  def write(self, oprot):
14929 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14930 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14931 
      return
4910 phani.kuma 14932 
    oprot.writeStructBegin('getOrdersNotPickedUp_args')
3431 rajveer 14933 
    if self.providerId is not None:
3064 chandransh 14934 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
14935 
      oprot.writeI64(self.providerId)
304 ashish 14936 
      oprot.writeFieldEnd()
14937 
    oprot.writeFieldStop()
14938 
    oprot.writeStructEnd()
14939 
 
3431 rajveer 14940 
  def validate(self):
14941 
    return
14942 
 
14943 
 
304 ashish 14944 
  def __repr__(self):
14945 
    L = ['%s=%r' % (key, value)
14946 
      for key, value in self.__dict__.iteritems()]
14947 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14948 
 
14949 
  def __eq__(self, other):
14950 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14951 
 
14952 
  def __ne__(self, other):
14953 
    return not (self == other)
14954 
 
4910 phani.kuma 14955 
class getOrdersNotPickedUp_result:
304 ashish 14956 
  """
14957 
  Attributes:
14958 
   - success
14959 
  """
14960 
 
14961 
  thrift_spec = (
3064 chandransh 14962 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
304 ashish 14963 
  )
14964 
 
4910 phani.kuma 14965 
  def __init__(self, success=None,):
304 ashish 14966 
    self.success = success
14967 
 
14968 
  def read(self, iprot):
14969 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14970 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14971 
      return
14972 
    iprot.readStructBegin()
14973 
    while True:
14974 
      (fname, ftype, fid) = iprot.readFieldBegin()
14975 
      if ftype == TType.STOP:
14976 
        break
14977 
      if fid == 0:
14978 
        if ftype == TType.LIST:
14979 
          self.success = []
6188 rajveer 14980 
          (_etype314, _size311) = iprot.readListBegin()
14981 
          for _i315 in xrange(_size311):
14982 
            _elem316 = Order()
14983 
            _elem316.read(iprot)
14984 
            self.success.append(_elem316)
304 ashish 14985 
          iprot.readListEnd()
14986 
        else:
14987 
          iprot.skip(ftype)
14988 
      else:
14989 
        iprot.skip(ftype)
14990 
      iprot.readFieldEnd()
14991 
    iprot.readStructEnd()
14992 
 
14993 
  def write(self, oprot):
14994 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14995 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14996 
      return
4910 phani.kuma 14997 
    oprot.writeStructBegin('getOrdersNotPickedUp_result')
3431 rajveer 14998 
    if self.success is not None:
304 ashish 14999 
      oprot.writeFieldBegin('success', TType.LIST, 0)
15000 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 15001 
      for iter317 in self.success:
15002 
        iter317.write(oprot)
304 ashish 15003 
      oprot.writeListEnd()
15004 
      oprot.writeFieldEnd()
15005 
    oprot.writeFieldStop()
15006 
    oprot.writeStructEnd()
15007 
 
3431 rajveer 15008 
  def validate(self):
15009 
    return
15010 
 
15011 
 
304 ashish 15012 
  def __repr__(self):
15013 
    L = ['%s=%r' % (key, value)
15014 
      for key, value in self.__dict__.iteritems()]
15015 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15016 
 
15017 
  def __eq__(self, other):
15018 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15019 
 
15020 
  def __ne__(self, other):
15021 
    return not (self == other)
15022 
 
3064 chandransh 15023 
class markOrdersAsDelivered_args:
304 ashish 15024 
  """
15025 
  Attributes:
3064 chandransh 15026 
   - providerId
15027 
   - deliveredOrders
304 ashish 15028 
  """
15029 
 
15030 
  thrift_spec = (
15031 
    None, # 0
3064 chandransh 15032 
    (1, TType.I64, 'providerId', None, None, ), # 1
15033 
    (2, TType.MAP, 'deliveredOrders', (TType.STRING,None,TType.STRING,None), None, ), # 2
304 ashish 15034 
  )
15035 
 
3064 chandransh 15036 
  def __init__(self, providerId=None, deliveredOrders=None,):
15037 
    self.providerId = providerId
15038 
    self.deliveredOrders = deliveredOrders
304 ashish 15039 
 
15040 
  def read(self, iprot):
15041 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15042 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15043 
      return
15044 
    iprot.readStructBegin()
15045 
    while True:
15046 
      (fname, ftype, fid) = iprot.readFieldBegin()
15047 
      if ftype == TType.STOP:
15048 
        break
15049 
      if fid == 1:
15050 
        if ftype == TType.I64:
3064 chandransh 15051 
          self.providerId = iprot.readI64();
304 ashish 15052 
        else:
15053 
          iprot.skip(ftype)
15054 
      elif fid == 2:
3064 chandransh 15055 
        if ftype == TType.MAP:
15056 
          self.deliveredOrders = {}
6188 rajveer 15057 
          (_ktype319, _vtype320, _size318 ) = iprot.readMapBegin()
15058 
          for _i322 in xrange(_size318):
15059 
            _key323 = iprot.readString();
15060 
            _val324 = iprot.readString();
15061 
            self.deliveredOrders[_key323] = _val324
3064 chandransh 15062 
          iprot.readMapEnd()
304 ashish 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
3064 chandransh 15074 
    oprot.writeStructBegin('markOrdersAsDelivered_args')
3431 rajveer 15075 
    if self.providerId is not None:
3064 chandransh 15076 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
15077 
      oprot.writeI64(self.providerId)
304 ashish 15078 
      oprot.writeFieldEnd()
3431 rajveer 15079 
    if self.deliveredOrders is not None:
3064 chandransh 15080 
      oprot.writeFieldBegin('deliveredOrders', TType.MAP, 2)
15081 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.deliveredOrders))
6188 rajveer 15082 
      for kiter325,viter326 in self.deliveredOrders.items():
15083 
        oprot.writeString(kiter325)
15084 
        oprot.writeString(viter326)
3064 chandransh 15085 
      oprot.writeMapEnd()
304 ashish 15086 
      oprot.writeFieldEnd()
15087 
    oprot.writeFieldStop()
15088 
    oprot.writeStructEnd()
15089 
 
3431 rajveer 15090 
  def validate(self):
15091 
    return
15092 
 
15093 
 
304 ashish 15094 
  def __repr__(self):
15095 
    L = ['%s=%r' % (key, value)
15096 
      for key, value in self.__dict__.iteritems()]
15097 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15098 
 
15099 
  def __eq__(self, other):
15100 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15101 
 
15102 
  def __ne__(self, other):
15103 
    return not (self == other)
15104 
 
3064 chandransh 15105 
class markOrdersAsDelivered_result:
15106 
  """
15107 
  Attributes:
15108 
   - ex
15109 
  """
304 ashish 15110 
 
15111 
  thrift_spec = (
3064 chandransh 15112 
    None, # 0
15113 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
304 ashish 15114 
  )
15115 
 
3064 chandransh 15116 
  def __init__(self, ex=None,):
15117 
    self.ex = ex
304 ashish 15118 
 
1596 ankur.sing 15119 
  def read(self, iprot):
15120 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15121 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15122 
      return
15123 
    iprot.readStructBegin()
15124 
    while True:
15125 
      (fname, ftype, fid) = iprot.readFieldBegin()
15126 
      if ftype == TType.STOP:
15127 
        break
3064 chandransh 15128 
      if fid == 1:
15129 
        if ftype == TType.STRUCT:
15130 
          self.ex = TransactionServiceException()
15131 
          self.ex.read(iprot)
15132 
        else:
15133 
          iprot.skip(ftype)
1596 ankur.sing 15134 
      else:
15135 
        iprot.skip(ftype)
15136 
      iprot.readFieldEnd()
15137 
    iprot.readStructEnd()
15138 
 
15139 
  def write(self, oprot):
15140 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15141 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15142 
      return
3064 chandransh 15143 
    oprot.writeStructBegin('markOrdersAsDelivered_result')
3431 rajveer 15144 
    if self.ex is not None:
3064 chandransh 15145 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
15146 
      self.ex.write(oprot)
15147 
      oprot.writeFieldEnd()
1596 ankur.sing 15148 
    oprot.writeFieldStop()
15149 
    oprot.writeStructEnd()
15150 
 
3431 rajveer 15151 
  def validate(self):
15152 
    return
15153 
 
15154 
 
1596 ankur.sing 15155 
  def __repr__(self):
15156 
    L = ['%s=%r' % (key, value)
15157 
      for key, value in self.__dict__.iteritems()]
15158 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15159 
 
15160 
  def __eq__(self, other):
15161 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15162 
 
15163 
  def __ne__(self, other):
15164 
    return not (self == other)
15165 
 
4910 phani.kuma 15166 
class markAsRTOrders_args:
1596 ankur.sing 15167 
  """
15168 
  Attributes:
3064 chandransh 15169 
   - providerId
15170 
   - returnedOrders
1596 ankur.sing 15171 
  """
15172 
 
15173 
  thrift_spec = (
3064 chandransh 15174 
    None, # 0
15175 
    (1, TType.I64, 'providerId', None, None, ), # 1
15176 
    (2, TType.MAP, 'returnedOrders', (TType.STRING,None,TType.STRING,None), None, ), # 2
1596 ankur.sing 15177 
  )
15178 
 
3064 chandransh 15179 
  def __init__(self, providerId=None, returnedOrders=None,):
15180 
    self.providerId = providerId
15181 
    self.returnedOrders = returnedOrders
1596 ankur.sing 15182 
 
15183 
  def read(self, iprot):
15184 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15185 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15186 
      return
15187 
    iprot.readStructBegin()
15188 
    while True:
15189 
      (fname, ftype, fid) = iprot.readFieldBegin()
15190 
      if ftype == TType.STOP:
15191 
        break
3064 chandransh 15192 
      if fid == 1:
1596 ankur.sing 15193 
        if ftype == TType.I64:
3064 chandransh 15194 
          self.providerId = iprot.readI64();
1596 ankur.sing 15195 
        else:
15196 
          iprot.skip(ftype)
3064 chandransh 15197 
      elif fid == 2:
15198 
        if ftype == TType.MAP:
15199 
          self.returnedOrders = {}
6188 rajveer 15200 
          (_ktype328, _vtype329, _size327 ) = iprot.readMapBegin()
15201 
          for _i331 in xrange(_size327):
15202 
            _key332 = iprot.readString();
15203 
            _val333 = iprot.readString();
15204 
            self.returnedOrders[_key332] = _val333
3064 chandransh 15205 
          iprot.readMapEnd()
15206 
        else:
15207 
          iprot.skip(ftype)
1596 ankur.sing 15208 
      else:
15209 
        iprot.skip(ftype)
15210 
      iprot.readFieldEnd()
15211 
    iprot.readStructEnd()
15212 
 
15213 
  def write(self, oprot):
15214 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15215 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15216 
      return
4910 phani.kuma 15217 
    oprot.writeStructBegin('markAsRTOrders_args')
3431 rajveer 15218 
    if self.providerId is not None:
3064 chandransh 15219 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
15220 
      oprot.writeI64(self.providerId)
1596 ankur.sing 15221 
      oprot.writeFieldEnd()
3431 rajveer 15222 
    if self.returnedOrders is not None:
3064 chandransh 15223 
      oprot.writeFieldBegin('returnedOrders', TType.MAP, 2)
15224 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.returnedOrders))
6188 rajveer 15225 
      for kiter334,viter335 in self.returnedOrders.items():
15226 
        oprot.writeString(kiter334)
15227 
        oprot.writeString(viter335)
3064 chandransh 15228 
      oprot.writeMapEnd()
15229 
      oprot.writeFieldEnd()
1596 ankur.sing 15230 
    oprot.writeFieldStop()
15231 
    oprot.writeStructEnd()
15232 
 
3431 rajveer 15233 
  def validate(self):
15234 
    return
15235 
 
15236 
 
1596 ankur.sing 15237 
  def __repr__(self):
15238 
    L = ['%s=%r' % (key, value)
15239 
      for key, value in self.__dict__.iteritems()]
15240 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15241 
 
15242 
  def __eq__(self, other):
15243 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15244 
 
15245 
  def __ne__(self, other):
15246 
    return not (self == other)
15247 
 
4910 phani.kuma 15248 
class markAsRTOrders_result:
3064 chandransh 15249 
  """
15250 
  Attributes:
15251 
   - ex
15252 
  """
1596 ankur.sing 15253 
 
1627 ankur.sing 15254 
  thrift_spec = (
3064 chandransh 15255 
    None, # 0
15256 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
1627 ankur.sing 15257 
  )
15258 
 
3064 chandransh 15259 
  def __init__(self, ex=None,):
15260 
    self.ex = ex
15261 
 
1627 ankur.sing 15262 
  def read(self, iprot):
15263 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15264 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15265 
      return
15266 
    iprot.readStructBegin()
15267 
    while True:
15268 
      (fname, ftype, fid) = iprot.readFieldBegin()
15269 
      if ftype == TType.STOP:
15270 
        break
3064 chandransh 15271 
      if fid == 1:
15272 
        if ftype == TType.STRUCT:
15273 
          self.ex = TransactionServiceException()
15274 
          self.ex.read(iprot)
15275 
        else:
15276 
          iprot.skip(ftype)
1627 ankur.sing 15277 
      else:
15278 
        iprot.skip(ftype)
15279 
      iprot.readFieldEnd()
15280 
    iprot.readStructEnd()
15281 
 
15282 
  def write(self, oprot):
15283 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15284 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15285 
      return
4910 phani.kuma 15286 
    oprot.writeStructBegin('markAsRTOrders_result')
3431 rajveer 15287 
    if self.ex is not None:
3064 chandransh 15288 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
15289 
      self.ex.write(oprot)
15290 
      oprot.writeFieldEnd()
1627 ankur.sing 15291 
    oprot.writeFieldStop()
15292 
    oprot.writeStructEnd()
15293 
 
3431 rajveer 15294 
  def validate(self):
15295 
    return
15296 
 
15297 
 
1627 ankur.sing 15298 
  def __repr__(self):
15299 
    L = ['%s=%r' % (key, value)
15300 
      for key, value in self.__dict__.iteritems()]
15301 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15302 
 
15303 
  def __eq__(self, other):
15304 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15305 
 
15306 
  def __ne__(self, other):
15307 
    return not (self == other)
15308 
 
4910 phani.kuma 15309 
class getRTOrders_args:
15310 
  """
15311 
  Attributes:
15312 
   - providerId
15313 
  """
15314 
 
15315 
  thrift_spec = (
15316 
    None, # 0
15317 
    (1, TType.I64, 'providerId', None, None, ), # 1
15318 
  )
15319 
 
15320 
  def __init__(self, providerId=None,):
15321 
    self.providerId = providerId
15322 
 
15323 
  def read(self, iprot):
15324 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15325 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15326 
      return
15327 
    iprot.readStructBegin()
15328 
    while True:
15329 
      (fname, ftype, fid) = iprot.readFieldBegin()
15330 
      if ftype == TType.STOP:
15331 
        break
15332 
      if fid == 1:
15333 
        if ftype == TType.I64:
15334 
          self.providerId = iprot.readI64();
15335 
        else:
15336 
          iprot.skip(ftype)
15337 
      else:
15338 
        iprot.skip(ftype)
15339 
      iprot.readFieldEnd()
15340 
    iprot.readStructEnd()
15341 
 
15342 
  def write(self, oprot):
15343 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15344 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15345 
      return
15346 
    oprot.writeStructBegin('getRTOrders_args')
15347 
    if self.providerId is not None:
15348 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
15349 
      oprot.writeI64(self.providerId)
15350 
      oprot.writeFieldEnd()
15351 
    oprot.writeFieldStop()
15352 
    oprot.writeStructEnd()
15353 
 
15354 
  def validate(self):
15355 
    return
15356 
 
15357 
 
15358 
  def __repr__(self):
15359 
    L = ['%s=%r' % (key, value)
15360 
      for key, value in self.__dict__.iteritems()]
15361 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15362 
 
15363 
  def __eq__(self, other):
15364 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15365 
 
15366 
  def __ne__(self, other):
15367 
    return not (self == other)
15368 
 
15369 
class getRTOrders_result:
15370 
  """
15371 
  Attributes:
15372 
   - success
15373 
  """
15374 
 
15375 
  thrift_spec = (
15376 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
15377 
  )
15378 
 
15379 
  def __init__(self, success=None,):
15380 
    self.success = success
15381 
 
15382 
  def read(self, iprot):
15383 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15384 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15385 
      return
15386 
    iprot.readStructBegin()
15387 
    while True:
15388 
      (fname, ftype, fid) = iprot.readFieldBegin()
15389 
      if ftype == TType.STOP:
15390 
        break
15391 
      if fid == 0:
15392 
        if ftype == TType.LIST:
15393 
          self.success = []
6188 rajveer 15394 
          (_etype339, _size336) = iprot.readListBegin()
15395 
          for _i340 in xrange(_size336):
15396 
            _elem341 = Order()
15397 
            _elem341.read(iprot)
15398 
            self.success.append(_elem341)
4910 phani.kuma 15399 
          iprot.readListEnd()
15400 
        else:
15401 
          iprot.skip(ftype)
15402 
      else:
15403 
        iprot.skip(ftype)
15404 
      iprot.readFieldEnd()
15405 
    iprot.readStructEnd()
15406 
 
15407 
  def write(self, oprot):
15408 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15409 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15410 
      return
15411 
    oprot.writeStructBegin('getRTOrders_result')
15412 
    if self.success is not None:
15413 
      oprot.writeFieldBegin('success', TType.LIST, 0)
15414 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 15415 
      for iter342 in self.success:
15416 
        iter342.write(oprot)
4910 phani.kuma 15417 
      oprot.writeListEnd()
15418 
      oprot.writeFieldEnd()
15419 
    oprot.writeFieldStop()
15420 
    oprot.writeStructEnd()
15421 
 
15422 
  def validate(self):
15423 
    return
15424 
 
15425 
 
15426 
  def __repr__(self):
15427 
    L = ['%s=%r' % (key, value)
15428 
      for key, value in self.__dict__.iteritems()]
15429 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15430 
 
15431 
  def __eq__(self, other):
15432 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15433 
 
15434 
  def __ne__(self, other):
15435 
    return not (self == other)
15436 
 
3064 chandransh 15437 
class updateNonDeliveryReason_args:
1627 ankur.sing 15438 
  """
15439 
  Attributes:
3064 chandransh 15440 
   - providerId
15441 
   - undeliveredOrders
1627 ankur.sing 15442 
  """
15443 
 
15444 
  thrift_spec = (
3064 chandransh 15445 
    None, # 0
15446 
    (1, TType.I64, 'providerId', None, None, ), # 1
15447 
    (2, TType.MAP, 'undeliveredOrders', (TType.STRING,None,TType.STRING,None), None, ), # 2
1627 ankur.sing 15448 
  )
15449 
 
3064 chandransh 15450 
  def __init__(self, providerId=None, undeliveredOrders=None,):
15451 
    self.providerId = providerId
15452 
    self.undeliveredOrders = undeliveredOrders
1627 ankur.sing 15453 
 
15454 
  def read(self, iprot):
15455 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15456 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15457 
      return
15458 
    iprot.readStructBegin()
15459 
    while True:
15460 
      (fname, ftype, fid) = iprot.readFieldBegin()
15461 
      if ftype == TType.STOP:
15462 
        break
3064 chandransh 15463 
      if fid == 1:
1627 ankur.sing 15464 
        if ftype == TType.I64:
3064 chandransh 15465 
          self.providerId = iprot.readI64();
1627 ankur.sing 15466 
        else:
15467 
          iprot.skip(ftype)
3064 chandransh 15468 
      elif fid == 2:
15469 
        if ftype == TType.MAP:
15470 
          self.undeliveredOrders = {}
6188 rajveer 15471 
          (_ktype344, _vtype345, _size343 ) = iprot.readMapBegin()
15472 
          for _i347 in xrange(_size343):
15473 
            _key348 = iprot.readString();
15474 
            _val349 = iprot.readString();
15475 
            self.undeliveredOrders[_key348] = _val349
3064 chandransh 15476 
          iprot.readMapEnd()
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
3064 chandransh 15488 
    oprot.writeStructBegin('updateNonDeliveryReason_args')
3431 rajveer 15489 
    if self.providerId is not None:
3064 chandransh 15490 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
15491 
      oprot.writeI64(self.providerId)
1627 ankur.sing 15492 
      oprot.writeFieldEnd()
3431 rajveer 15493 
    if self.undeliveredOrders is not None:
3064 chandransh 15494 
      oprot.writeFieldBegin('undeliveredOrders', TType.MAP, 2)
15495 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.undeliveredOrders))
6188 rajveer 15496 
      for kiter350,viter351 in self.undeliveredOrders.items():
15497 
        oprot.writeString(kiter350)
15498 
        oprot.writeString(viter351)
3064 chandransh 15499 
      oprot.writeMapEnd()
15500 
      oprot.writeFieldEnd()
1627 ankur.sing 15501 
    oprot.writeFieldStop()
15502 
    oprot.writeStructEnd()
15503 
 
3431 rajveer 15504 
  def validate(self):
15505 
    return
15506 
 
15507 
 
1627 ankur.sing 15508 
  def __repr__(self):
15509 
    L = ['%s=%r' % (key, value)
15510 
      for key, value in self.__dict__.iteritems()]
15511 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15512 
 
15513 
  def __eq__(self, other):
15514 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15515 
 
15516 
  def __ne__(self, other):
15517 
    return not (self == other)
15518 
 
3064 chandransh 15519 
class updateNonDeliveryReason_result:
1627 ankur.sing 15520 
  """
15521 
  Attributes:
3064 chandransh 15522 
   - ex
1627 ankur.sing 15523 
  """
15524 
 
15525 
  thrift_spec = (
4910 phani.kuma 15526 
    None, # 0
3064 chandransh 15527 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
1627 ankur.sing 15528 
  )
15529 
 
4910 phani.kuma 15530 
  def __init__(self, ex=None,):
3064 chandransh 15531 
    self.ex = ex
1627 ankur.sing 15532 
 
15533 
  def read(self, iprot):
15534 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15535 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15536 
      return
15537 
    iprot.readStructBegin()
15538 
    while True:
15539 
      (fname, ftype, fid) = iprot.readFieldBegin()
15540 
      if ftype == TType.STOP:
15541 
        break
4910 phani.kuma 15542 
      if fid == 1:
15543 
        if ftype == TType.STRUCT:
15544 
          self.ex = TransactionServiceException()
15545 
          self.ex.read(iprot)
15546 
        else:
15547 
          iprot.skip(ftype)
15548 
      else:
15549 
        iprot.skip(ftype)
15550 
      iprot.readFieldEnd()
15551 
    iprot.readStructEnd()
15552 
 
15553 
  def write(self, oprot):
15554 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15555 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15556 
      return
15557 
    oprot.writeStructBegin('updateNonDeliveryReason_result')
15558 
    if self.ex is not None:
15559 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
15560 
      self.ex.write(oprot)
15561 
      oprot.writeFieldEnd()
15562 
    oprot.writeFieldStop()
15563 
    oprot.writeStructEnd()
15564 
 
15565 
  def validate(self):
15566 
    return
15567 
 
15568 
 
15569 
  def __repr__(self):
15570 
    L = ['%s=%r' % (key, value)
15571 
      for key, value in self.__dict__.iteritems()]
15572 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15573 
 
15574 
  def __eq__(self, other):
15575 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15576 
 
15577 
  def __ne__(self, other):
15578 
    return not (self == other)
15579 
 
15580 
class getNonDeliveredOrdersbyCourier_args:
15581 
  """
15582 
  Attributes:
15583 
   - providerId
15584 
  """
15585 
 
15586 
  thrift_spec = (
15587 
    None, # 0
15588 
    (1, TType.I64, 'providerId', None, None, ), # 1
15589 
  )
15590 
 
15591 
  def __init__(self, providerId=None,):
15592 
    self.providerId = providerId
15593 
 
15594 
  def read(self, iprot):
15595 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15596 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15597 
      return
15598 
    iprot.readStructBegin()
15599 
    while True:
15600 
      (fname, ftype, fid) = iprot.readFieldBegin()
15601 
      if ftype == TType.STOP:
15602 
        break
15603 
      if fid == 1:
15604 
        if ftype == TType.I64:
15605 
          self.providerId = iprot.readI64();
15606 
        else:
15607 
          iprot.skip(ftype)
15608 
      else:
15609 
        iprot.skip(ftype)
15610 
      iprot.readFieldEnd()
15611 
    iprot.readStructEnd()
15612 
 
15613 
  def write(self, oprot):
15614 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15615 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15616 
      return
15617 
    oprot.writeStructBegin('getNonDeliveredOrdersbyCourier_args')
15618 
    if self.providerId is not None:
15619 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
15620 
      oprot.writeI64(self.providerId)
15621 
      oprot.writeFieldEnd()
15622 
    oprot.writeFieldStop()
15623 
    oprot.writeStructEnd()
15624 
 
15625 
  def validate(self):
15626 
    return
15627 
 
15628 
 
15629 
  def __repr__(self):
15630 
    L = ['%s=%r' % (key, value)
15631 
      for key, value in self.__dict__.iteritems()]
15632 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15633 
 
15634 
  def __eq__(self, other):
15635 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15636 
 
15637 
  def __ne__(self, other):
15638 
    return not (self == other)
15639 
 
15640 
class getNonDeliveredOrdersbyCourier_result:
15641 
  """
15642 
  Attributes:
15643 
   - success
15644 
  """
15645 
 
15646 
  thrift_spec = (
15647 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
15648 
  )
15649 
 
15650 
  def __init__(self, success=None,):
15651 
    self.success = success
15652 
 
15653 
  def read(self, iprot):
15654 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15655 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15656 
      return
15657 
    iprot.readStructBegin()
15658 
    while True:
15659 
      (fname, ftype, fid) = iprot.readFieldBegin()
15660 
      if ftype == TType.STOP:
15661 
        break
4581 phani.kuma 15662 
      if fid == 0:
15663 
        if ftype == TType.LIST:
15664 
          self.success = []
6188 rajveer 15665 
          (_etype355, _size352) = iprot.readListBegin()
15666 
          for _i356 in xrange(_size352):
15667 
            _elem357 = Order()
15668 
            _elem357.read(iprot)
15669 
            self.success.append(_elem357)
4581 phani.kuma 15670 
          iprot.readListEnd()
15671 
        else:
15672 
          iprot.skip(ftype)
4910 phani.kuma 15673 
      else:
15674 
        iprot.skip(ftype)
15675 
      iprot.readFieldEnd()
15676 
    iprot.readStructEnd()
15677 
 
15678 
  def write(self, oprot):
15679 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15680 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15681 
      return
15682 
    oprot.writeStructBegin('getNonDeliveredOrdersbyCourier_result')
15683 
    if self.success is not None:
15684 
      oprot.writeFieldBegin('success', TType.LIST, 0)
15685 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 15686 
      for iter358 in self.success:
15687 
        iter358.write(oprot)
4910 phani.kuma 15688 
      oprot.writeListEnd()
15689 
      oprot.writeFieldEnd()
15690 
    oprot.writeFieldStop()
15691 
    oprot.writeStructEnd()
15692 
 
15693 
  def validate(self):
15694 
    return
15695 
 
15696 
 
15697 
  def __repr__(self):
15698 
    L = ['%s=%r' % (key, value)
15699 
      for key, value in self.__dict__.iteritems()]
15700 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15701 
 
15702 
  def __eq__(self, other):
15703 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15704 
 
15705 
  def __ne__(self, other):
15706 
    return not (self == other)
15707 
 
15708 
class markOrdersAsLocalConnected_args:
15709 
  """
15710 
  Attributes:
15711 
   - providerId
15712 
   - local_connected_orders
15713 
  """
15714 
 
15715 
  thrift_spec = (
15716 
    None, # 0
15717 
    (1, TType.I64, 'providerId', None, None, ), # 1
15718 
    (2, TType.MAP, 'local_connected_orders', (TType.STRING,None,TType.STRING,None), None, ), # 2
15719 
  )
15720 
 
15721 
  def __init__(self, providerId=None, local_connected_orders=None,):
15722 
    self.providerId = providerId
15723 
    self.local_connected_orders = local_connected_orders
15724 
 
15725 
  def read(self, iprot):
15726 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15727 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15728 
      return
15729 
    iprot.readStructBegin()
15730 
    while True:
15731 
      (fname, ftype, fid) = iprot.readFieldBegin()
15732 
      if ftype == TType.STOP:
15733 
        break
15734 
      if fid == 1:
15735 
        if ftype == TType.I64:
15736 
          self.providerId = iprot.readI64();
15737 
        else:
15738 
          iprot.skip(ftype)
15739 
      elif fid == 2:
15740 
        if ftype == TType.MAP:
15741 
          self.local_connected_orders = {}
6188 rajveer 15742 
          (_ktype360, _vtype361, _size359 ) = iprot.readMapBegin()
15743 
          for _i363 in xrange(_size359):
15744 
            _key364 = iprot.readString();
15745 
            _val365 = iprot.readString();
15746 
            self.local_connected_orders[_key364] = _val365
4910 phani.kuma 15747 
          iprot.readMapEnd()
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('markOrdersAsLocalConnected_args')
15760 
    if self.providerId is not None:
15761 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
15762 
      oprot.writeI64(self.providerId)
15763 
      oprot.writeFieldEnd()
15764 
    if self.local_connected_orders is not None:
15765 
      oprot.writeFieldBegin('local_connected_orders', TType.MAP, 2)
15766 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.local_connected_orders))
6188 rajveer 15767 
      for kiter366,viter367 in self.local_connected_orders.items():
15768 
        oprot.writeString(kiter366)
15769 
        oprot.writeString(viter367)
4910 phani.kuma 15770 
      oprot.writeMapEnd()
15771 
      oprot.writeFieldEnd()
15772 
    oprot.writeFieldStop()
15773 
    oprot.writeStructEnd()
15774 
 
15775 
  def validate(self):
15776 
    return
15777 
 
15778 
 
15779 
  def __repr__(self):
15780 
    L = ['%s=%r' % (key, value)
15781 
      for key, value in self.__dict__.iteritems()]
15782 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15783 
 
15784 
  def __eq__(self, other):
15785 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15786 
 
15787 
  def __ne__(self, other):
15788 
    return not (self == other)
15789 
 
15790 
class markOrdersAsLocalConnected_result:
15791 
  """
15792 
  Attributes:
15793 
   - ex
15794 
  """
15795 
 
15796 
  thrift_spec = (
15797 
    None, # 0
15798 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
15799 
  )
15800 
 
15801 
  def __init__(self, ex=None,):
15802 
    self.ex = ex
15803 
 
15804 
  def read(self, iprot):
15805 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15806 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15807 
      return
15808 
    iprot.readStructBegin()
15809 
    while True:
15810 
      (fname, ftype, fid) = iprot.readFieldBegin()
15811 
      if ftype == TType.STOP:
15812 
        break
15813 
      if fid == 1:
3064 chandransh 15814 
        if ftype == TType.STRUCT:
15815 
          self.ex = TransactionServiceException()
15816 
          self.ex.read(iprot)
1627 ankur.sing 15817 
        else:
15818 
          iprot.skip(ftype)
15819 
      else:
15820 
        iprot.skip(ftype)
15821 
      iprot.readFieldEnd()
15822 
    iprot.readStructEnd()
15823 
 
15824 
  def write(self, oprot):
15825 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15826 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15827 
      return
4910 phani.kuma 15828 
    oprot.writeStructBegin('markOrdersAsLocalConnected_result')
15829 
    if self.ex is not None:
15830 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
15831 
      self.ex.write(oprot)
15832 
      oprot.writeFieldEnd()
15833 
    oprot.writeFieldStop()
15834 
    oprot.writeStructEnd()
15835 
 
15836 
  def validate(self):
15837 
    return
15838 
 
15839 
 
15840 
  def __repr__(self):
15841 
    L = ['%s=%r' % (key, value)
15842 
      for key, value in self.__dict__.iteritems()]
15843 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15844 
 
15845 
  def __eq__(self, other):
15846 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15847 
 
15848 
  def __ne__(self, other):
15849 
    return not (self == other)
15850 
 
15851 
class getOrdersNotLocalConnected_args:
15852 
  """
15853 
  Attributes:
15854 
   - providerId
15855 
  """
15856 
 
15857 
  thrift_spec = (
15858 
    None, # 0
15859 
    (1, TType.I64, 'providerId', None, None, ), # 1
15860 
  )
15861 
 
15862 
  def __init__(self, providerId=None,):
15863 
    self.providerId = providerId
15864 
 
15865 
  def read(self, iprot):
15866 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15867 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15868 
      return
15869 
    iprot.readStructBegin()
15870 
    while True:
15871 
      (fname, ftype, fid) = iprot.readFieldBegin()
15872 
      if ftype == TType.STOP:
15873 
        break
15874 
      if fid == 1:
15875 
        if ftype == TType.I64:
15876 
          self.providerId = iprot.readI64();
15877 
        else:
15878 
          iprot.skip(ftype)
15879 
      else:
15880 
        iprot.skip(ftype)
15881 
      iprot.readFieldEnd()
15882 
    iprot.readStructEnd()
15883 
 
15884 
  def write(self, oprot):
15885 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15886 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15887 
      return
15888 
    oprot.writeStructBegin('getOrdersNotLocalConnected_args')
15889 
    if self.providerId is not None:
15890 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
15891 
      oprot.writeI64(self.providerId)
15892 
      oprot.writeFieldEnd()
15893 
    oprot.writeFieldStop()
15894 
    oprot.writeStructEnd()
15895 
 
15896 
  def validate(self):
15897 
    return
15898 
 
15899 
 
15900 
  def __repr__(self):
15901 
    L = ['%s=%r' % (key, value)
15902 
      for key, value in self.__dict__.iteritems()]
15903 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15904 
 
15905 
  def __eq__(self, other):
15906 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15907 
 
15908 
  def __ne__(self, other):
15909 
    return not (self == other)
15910 
 
15911 
class getOrdersNotLocalConnected_result:
15912 
  """
15913 
  Attributes:
15914 
   - success
15915 
  """
15916 
 
15917 
  thrift_spec = (
15918 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
15919 
  )
15920 
 
15921 
  def __init__(self, success=None,):
15922 
    self.success = success
15923 
 
15924 
  def read(self, iprot):
15925 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15926 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15927 
      return
15928 
    iprot.readStructBegin()
15929 
    while True:
15930 
      (fname, ftype, fid) = iprot.readFieldBegin()
15931 
      if ftype == TType.STOP:
15932 
        break
15933 
      if fid == 0:
15934 
        if ftype == TType.LIST:
15935 
          self.success = []
6188 rajveer 15936 
          (_etype371, _size368) = iprot.readListBegin()
15937 
          for _i372 in xrange(_size368):
15938 
            _elem373 = Order()
15939 
            _elem373.read(iprot)
15940 
            self.success.append(_elem373)
4910 phani.kuma 15941 
          iprot.readListEnd()
15942 
        else:
15943 
          iprot.skip(ftype)
15944 
      else:
15945 
        iprot.skip(ftype)
15946 
      iprot.readFieldEnd()
15947 
    iprot.readStructEnd()
15948 
 
15949 
  def write(self, oprot):
15950 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15951 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15952 
      return
15953 
    oprot.writeStructBegin('getOrdersNotLocalConnected_result')
4581 phani.kuma 15954 
    if self.success is not None:
15955 
      oprot.writeFieldBegin('success', TType.LIST, 0)
15956 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 15957 
      for iter374 in self.success:
15958 
        iter374.write(oprot)
4581 phani.kuma 15959 
      oprot.writeListEnd()
15960 
      oprot.writeFieldEnd()
4910 phani.kuma 15961 
    oprot.writeFieldStop()
15962 
    oprot.writeStructEnd()
15963 
 
15964 
  def validate(self):
15965 
    return
15966 
 
15967 
 
15968 
  def __repr__(self):
15969 
    L = ['%s=%r' % (key, value)
15970 
      for key, value in self.__dict__.iteritems()]
15971 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15972 
 
15973 
  def __eq__(self, other):
15974 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15975 
 
15976 
  def __ne__(self, other):
15977 
    return not (self == other)
15978 
 
15979 
class markOrdersAsDestinationCityReached_args:
15980 
  """
15981 
  Attributes:
15982 
   - providerId
15983 
   - destination_city_reached_orders
15984 
  """
15985 
 
15986 
  thrift_spec = (
15987 
    None, # 0
15988 
    (1, TType.I64, 'providerId', None, None, ), # 1
15989 
    (2, TType.MAP, 'destination_city_reached_orders', (TType.STRING,None,TType.STRING,None), None, ), # 2
15990 
  )
15991 
 
15992 
  def __init__(self, providerId=None, destination_city_reached_orders=None,):
15993 
    self.providerId = providerId
15994 
    self.destination_city_reached_orders = destination_city_reached_orders
15995 
 
15996 
  def read(self, iprot):
15997 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15998 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15999 
      return
16000 
    iprot.readStructBegin()
16001 
    while True:
16002 
      (fname, ftype, fid) = iprot.readFieldBegin()
16003 
      if ftype == TType.STOP:
16004 
        break
16005 
      if fid == 1:
16006 
        if ftype == TType.I64:
16007 
          self.providerId = iprot.readI64();
16008 
        else:
16009 
          iprot.skip(ftype)
16010 
      elif fid == 2:
16011 
        if ftype == TType.MAP:
16012 
          self.destination_city_reached_orders = {}
6188 rajveer 16013 
          (_ktype376, _vtype377, _size375 ) = iprot.readMapBegin()
16014 
          for _i379 in xrange(_size375):
16015 
            _key380 = iprot.readString();
16016 
            _val381 = iprot.readString();
16017 
            self.destination_city_reached_orders[_key380] = _val381
4910 phani.kuma 16018 
          iprot.readMapEnd()
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
16030 
    oprot.writeStructBegin('markOrdersAsDestinationCityReached_args')
16031 
    if self.providerId is not None:
16032 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
16033 
      oprot.writeI64(self.providerId)
16034 
      oprot.writeFieldEnd()
16035 
    if self.destination_city_reached_orders is not None:
16036 
      oprot.writeFieldBegin('destination_city_reached_orders', TType.MAP, 2)
16037 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.destination_city_reached_orders))
6188 rajveer 16038 
      for kiter382,viter383 in self.destination_city_reached_orders.items():
16039 
        oprot.writeString(kiter382)
16040 
        oprot.writeString(viter383)
4910 phani.kuma 16041 
      oprot.writeMapEnd()
16042 
      oprot.writeFieldEnd()
16043 
    oprot.writeFieldStop()
16044 
    oprot.writeStructEnd()
16045 
 
16046 
  def validate(self):
16047 
    return
16048 
 
16049 
 
16050 
  def __repr__(self):
16051 
    L = ['%s=%r' % (key, value)
16052 
      for key, value in self.__dict__.iteritems()]
16053 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16054 
 
16055 
  def __eq__(self, other):
16056 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16057 
 
16058 
  def __ne__(self, other):
16059 
    return not (self == other)
16060 
 
16061 
class markOrdersAsDestinationCityReached_result:
16062 
  """
16063 
  Attributes:
16064 
   - ex
16065 
  """
16066 
 
16067 
  thrift_spec = (
16068 
    None, # 0
16069 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
16070 
  )
16071 
 
16072 
  def __init__(self, ex=None,):
16073 
    self.ex = ex
16074 
 
16075 
  def read(self, iprot):
16076 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16077 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16078 
      return
16079 
    iprot.readStructBegin()
16080 
    while True:
16081 
      (fname, ftype, fid) = iprot.readFieldBegin()
16082 
      if ftype == TType.STOP:
16083 
        break
16084 
      if fid == 1:
16085 
        if ftype == TType.STRUCT:
16086 
          self.ex = TransactionServiceException()
16087 
          self.ex.read(iprot)
16088 
        else:
16089 
          iprot.skip(ftype)
16090 
      else:
16091 
        iprot.skip(ftype)
16092 
      iprot.readFieldEnd()
16093 
    iprot.readStructEnd()
16094 
 
16095 
  def write(self, oprot):
16096 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16097 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16098 
      return
16099 
    oprot.writeStructBegin('markOrdersAsDestinationCityReached_result')
3431 rajveer 16100 
    if self.ex is not None:
3064 chandransh 16101 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
16102 
      self.ex.write(oprot)
1627 ankur.sing 16103 
      oprot.writeFieldEnd()
16104 
    oprot.writeFieldStop()
16105 
    oprot.writeStructEnd()
16106 
 
3431 rajveer 16107 
  def validate(self):
16108 
    return
16109 
 
16110 
 
1627 ankur.sing 16111 
  def __repr__(self):
16112 
    L = ['%s=%r' % (key, value)
16113 
      for key, value in self.__dict__.iteritems()]
16114 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16115 
 
16116 
  def __eq__(self, other):
16117 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16118 
 
16119 
  def __ne__(self, other):
16120 
    return not (self == other)
16121 
 
4910 phani.kuma 16122 
class markOrdersAsFirstDeliveryAttempted_args:
16123 
  """
16124 
  Attributes:
16125 
   - providerId
16126 
   - first_atdl_orders
16127 
  """
16128 
 
16129 
  thrift_spec = (
16130 
    None, # 0
16131 
    (1, TType.I64, 'providerId', None, None, ), # 1
16132 
    (2, TType.MAP, 'first_atdl_orders', (TType.STRING,None,TType.STRING,None), None, ), # 2
16133 
  )
16134 
 
16135 
  def __init__(self, providerId=None, first_atdl_orders=None,):
16136 
    self.providerId = providerId
16137 
    self.first_atdl_orders = first_atdl_orders
16138 
 
16139 
  def read(self, iprot):
16140 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16141 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16142 
      return
16143 
    iprot.readStructBegin()
16144 
    while True:
16145 
      (fname, ftype, fid) = iprot.readFieldBegin()
16146 
      if ftype == TType.STOP:
16147 
        break
16148 
      if fid == 1:
16149 
        if ftype == TType.I64:
16150 
          self.providerId = iprot.readI64();
16151 
        else:
16152 
          iprot.skip(ftype)
16153 
      elif fid == 2:
16154 
        if ftype == TType.MAP:
16155 
          self.first_atdl_orders = {}
6188 rajveer 16156 
          (_ktype385, _vtype386, _size384 ) = iprot.readMapBegin()
16157 
          for _i388 in xrange(_size384):
16158 
            _key389 = iprot.readString();
16159 
            _val390 = iprot.readString();
16160 
            self.first_atdl_orders[_key389] = _val390
4910 phani.kuma 16161 
          iprot.readMapEnd()
16162 
        else:
16163 
          iprot.skip(ftype)
16164 
      else:
16165 
        iprot.skip(ftype)
16166 
      iprot.readFieldEnd()
16167 
    iprot.readStructEnd()
16168 
 
16169 
  def write(self, oprot):
16170 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16171 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16172 
      return
16173 
    oprot.writeStructBegin('markOrdersAsFirstDeliveryAttempted_args')
16174 
    if self.providerId is not None:
16175 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
16176 
      oprot.writeI64(self.providerId)
16177 
      oprot.writeFieldEnd()
16178 
    if self.first_atdl_orders is not None:
16179 
      oprot.writeFieldBegin('first_atdl_orders', TType.MAP, 2)
16180 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.first_atdl_orders))
6188 rajveer 16181 
      for kiter391,viter392 in self.first_atdl_orders.items():
16182 
        oprot.writeString(kiter391)
16183 
        oprot.writeString(viter392)
4910 phani.kuma 16184 
      oprot.writeMapEnd()
16185 
      oprot.writeFieldEnd()
16186 
    oprot.writeFieldStop()
16187 
    oprot.writeStructEnd()
16188 
 
16189 
  def validate(self):
16190 
    return
16191 
 
16192 
 
16193 
  def __repr__(self):
16194 
    L = ['%s=%r' % (key, value)
16195 
      for key, value in self.__dict__.iteritems()]
16196 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16197 
 
16198 
  def __eq__(self, other):
16199 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16200 
 
16201 
  def __ne__(self, other):
16202 
    return not (self == other)
16203 
 
16204 
class markOrdersAsFirstDeliveryAttempted_result:
16205 
  """
16206 
  Attributes:
16207 
   - ex
16208 
  """
16209 
 
16210 
  thrift_spec = (
16211 
    None, # 0
16212 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
16213 
  )
16214 
 
16215 
  def __init__(self, ex=None,):
16216 
    self.ex = ex
16217 
 
16218 
  def read(self, iprot):
16219 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16220 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16221 
      return
16222 
    iprot.readStructBegin()
16223 
    while True:
16224 
      (fname, ftype, fid) = iprot.readFieldBegin()
16225 
      if ftype == TType.STOP:
16226 
        break
16227 
      if fid == 1:
16228 
        if ftype == TType.STRUCT:
16229 
          self.ex = TransactionServiceException()
16230 
          self.ex.read(iprot)
16231 
        else:
16232 
          iprot.skip(ftype)
16233 
      else:
16234 
        iprot.skip(ftype)
16235 
      iprot.readFieldEnd()
16236 
    iprot.readStructEnd()
16237 
 
16238 
  def write(self, oprot):
16239 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16240 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16241 
      return
16242 
    oprot.writeStructBegin('markOrdersAsFirstDeliveryAttempted_result')
16243 
    if self.ex is not None:
16244 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
16245 
      self.ex.write(oprot)
16246 
      oprot.writeFieldEnd()
16247 
    oprot.writeFieldStop()
16248 
    oprot.writeStructEnd()
16249 
 
16250 
  def validate(self):
16251 
    return
16252 
 
16253 
 
16254 
  def __repr__(self):
16255 
    L = ['%s=%r' % (key, value)
16256 
      for key, value in self.__dict__.iteritems()]
16257 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16258 
 
16259 
  def __eq__(self, other):
16260 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16261 
 
16262 
  def __ne__(self, other):
16263 
    return not (self == other)
16264 
 
3064 chandransh 16265 
class getUndeliveredOrders_args:
1886 ankur.sing 16266 
  """
16267 
  Attributes:
3064 chandransh 16268 
   - providerId
16269 
   - warehouseId
1886 ankur.sing 16270 
  """
1627 ankur.sing 16271 
 
1886 ankur.sing 16272 
  thrift_spec = (
16273 
    None, # 0
3064 chandransh 16274 
    (1, TType.I64, 'providerId', None, None, ), # 1
16275 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
1886 ankur.sing 16276 
  )
16277 
 
3064 chandransh 16278 
  def __init__(self, providerId=None, warehouseId=None,):
16279 
    self.providerId = providerId
16280 
    self.warehouseId = warehouseId
1886 ankur.sing 16281 
 
16282 
  def read(self, iprot):
16283 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16284 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16285 
      return
16286 
    iprot.readStructBegin()
16287 
    while True:
16288 
      (fname, ftype, fid) = iprot.readFieldBegin()
16289 
      if ftype == TType.STOP:
16290 
        break
16291 
      if fid == 1:
16292 
        if ftype == TType.I64:
3064 chandransh 16293 
          self.providerId = iprot.readI64();
1886 ankur.sing 16294 
        else:
16295 
          iprot.skip(ftype)
3064 chandransh 16296 
      elif fid == 2:
16297 
        if ftype == TType.I64:
16298 
          self.warehouseId = iprot.readI64();
16299 
        else:
16300 
          iprot.skip(ftype)
1886 ankur.sing 16301 
      else:
16302 
        iprot.skip(ftype)
16303 
      iprot.readFieldEnd()
16304 
    iprot.readStructEnd()
16305 
 
16306 
  def write(self, oprot):
16307 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16308 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16309 
      return
3064 chandransh 16310 
    oprot.writeStructBegin('getUndeliveredOrders_args')
3431 rajveer 16311 
    if self.providerId is not None:
3064 chandransh 16312 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
16313 
      oprot.writeI64(self.providerId)
1886 ankur.sing 16314 
      oprot.writeFieldEnd()
3431 rajveer 16315 
    if self.warehouseId is not None:
3064 chandransh 16316 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
16317 
      oprot.writeI64(self.warehouseId)
16318 
      oprot.writeFieldEnd()
1886 ankur.sing 16319 
    oprot.writeFieldStop()
16320 
    oprot.writeStructEnd()
16321 
 
3431 rajveer 16322 
  def validate(self):
16323 
    return
16324 
 
16325 
 
1886 ankur.sing 16326 
  def __repr__(self):
16327 
    L = ['%s=%r' % (key, value)
16328 
      for key, value in self.__dict__.iteritems()]
16329 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16330 
 
16331 
  def __eq__(self, other):
16332 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16333 
 
16334 
  def __ne__(self, other):
16335 
    return not (self == other)
16336 
 
3064 chandransh 16337 
class getUndeliveredOrders_result:
1886 ankur.sing 16338 
  """
16339 
  Attributes:
16340 
   - success
16341 
  """
16342 
 
16343 
  thrift_spec = (
16344 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
16345 
  )
16346 
 
16347 
  def __init__(self, success=None,):
16348 
    self.success = success
16349 
 
16350 
  def read(self, iprot):
16351 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16352 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16353 
      return
16354 
    iprot.readStructBegin()
16355 
    while True:
16356 
      (fname, ftype, fid) = iprot.readFieldBegin()
16357 
      if ftype == TType.STOP:
16358 
        break
16359 
      if fid == 0:
16360 
        if ftype == TType.LIST:
16361 
          self.success = []
6188 rajveer 16362 
          (_etype396, _size393) = iprot.readListBegin()
16363 
          for _i397 in xrange(_size393):
16364 
            _elem398 = Order()
16365 
            _elem398.read(iprot)
16366 
            self.success.append(_elem398)
1886 ankur.sing 16367 
          iprot.readListEnd()
16368 
        else:
16369 
          iprot.skip(ftype)
16370 
      else:
16371 
        iprot.skip(ftype)
16372 
      iprot.readFieldEnd()
16373 
    iprot.readStructEnd()
16374 
 
16375 
  def write(self, oprot):
16376 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16377 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16378 
      return
3064 chandransh 16379 
    oprot.writeStructBegin('getUndeliveredOrders_result')
3431 rajveer 16380 
    if self.success is not None:
1886 ankur.sing 16381 
      oprot.writeFieldBegin('success', TType.LIST, 0)
16382 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 16383 
      for iter399 in self.success:
16384 
        iter399.write(oprot)
1886 ankur.sing 16385 
      oprot.writeListEnd()
16386 
      oprot.writeFieldEnd()
16387 
    oprot.writeFieldStop()
16388 
    oprot.writeStructEnd()
16389 
 
3431 rajveer 16390 
  def validate(self):
16391 
    return
16392 
 
16393 
 
1886 ankur.sing 16394 
  def __repr__(self):
16395 
    L = ['%s=%r' % (key, value)
16396 
      for key, value in self.__dict__.iteritems()]
16397 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16398 
 
16399 
  def __eq__(self, other):
16400 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16401 
 
16402 
  def __ne__(self, other):
16403 
    return not (self == other)
16404 
 
4783 phani.kuma 16405 
class getUndeliveredOrdersExpectedDeliveryDateNotMet_args:
16406 
 
16407 
  thrift_spec = (
16408 
  )
16409 
 
16410 
  def read(self, iprot):
16411 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16412 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16413 
      return
16414 
    iprot.readStructBegin()
16415 
    while True:
16416 
      (fname, ftype, fid) = iprot.readFieldBegin()
16417 
      if ftype == TType.STOP:
16418 
        break
16419 
      else:
16420 
        iprot.skip(ftype)
16421 
      iprot.readFieldEnd()
16422 
    iprot.readStructEnd()
16423 
 
16424 
  def write(self, oprot):
16425 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16426 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16427 
      return
16428 
    oprot.writeStructBegin('getUndeliveredOrdersExpectedDeliveryDateNotMet_args')
16429 
    oprot.writeFieldStop()
16430 
    oprot.writeStructEnd()
16431 
 
16432 
  def validate(self):
16433 
    return
16434 
 
16435 
 
16436 
  def __repr__(self):
16437 
    L = ['%s=%r' % (key, value)
16438 
      for key, value in self.__dict__.iteritems()]
16439 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16440 
 
16441 
  def __eq__(self, other):
16442 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16443 
 
16444 
  def __ne__(self, other):
16445 
    return not (self == other)
16446 
 
16447 
class getUndeliveredOrdersExpectedDeliveryDateNotMet_result:
16448 
  """
16449 
  Attributes:
16450 
   - success
16451 
  """
16452 
 
16453 
  thrift_spec = (
16454 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
16455 
  )
16456 
 
16457 
  def __init__(self, success=None,):
16458 
    self.success = success
16459 
 
16460 
  def read(self, iprot):
16461 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16462 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16463 
      return
16464 
    iprot.readStructBegin()
16465 
    while True:
16466 
      (fname, ftype, fid) = iprot.readFieldBegin()
16467 
      if ftype == TType.STOP:
16468 
        break
16469 
      if fid == 0:
16470 
        if ftype == TType.LIST:
16471 
          self.success = []
6188 rajveer 16472 
          (_etype403, _size400) = iprot.readListBegin()
16473 
          for _i404 in xrange(_size400):
16474 
            _elem405 = Order()
16475 
            _elem405.read(iprot)
16476 
            self.success.append(_elem405)
4783 phani.kuma 16477 
          iprot.readListEnd()
16478 
        else:
16479 
          iprot.skip(ftype)
16480 
      else:
16481 
        iprot.skip(ftype)
16482 
      iprot.readFieldEnd()
16483 
    iprot.readStructEnd()
16484 
 
16485 
  def write(self, oprot):
16486 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16487 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16488 
      return
16489 
    oprot.writeStructBegin('getUndeliveredOrdersExpectedDeliveryDateNotMet_result')
16490 
    if self.success is not None:
16491 
      oprot.writeFieldBegin('success', TType.LIST, 0)
16492 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 16493 
      for iter406 in self.success:
16494 
        iter406.write(oprot)
4783 phani.kuma 16495 
      oprot.writeListEnd()
16496 
      oprot.writeFieldEnd()
16497 
    oprot.writeFieldStop()
16498 
    oprot.writeStructEnd()
16499 
 
16500 
  def validate(self):
16501 
    return
16502 
 
16503 
 
16504 
  def __repr__(self):
16505 
    L = ['%s=%r' % (key, value)
16506 
      for key, value in self.__dict__.iteritems()]
16507 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16508 
 
16509 
  def __eq__(self, other):
16510 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16511 
 
16512 
  def __ne__(self, other):
16513 
    return not (self == other)
16514 
 
2536 chandransh 16515 
class toggleDOAFlag_args:
16516 
  """
16517 
  Attributes:
16518 
   - orderId
16519 
  """
1886 ankur.sing 16520 
 
2536 chandransh 16521 
  thrift_spec = (
16522 
    None, # 0
16523 
    (1, TType.I64, 'orderId', None, None, ), # 1
16524 
  )
16525 
 
16526 
  def __init__(self, orderId=None,):
16527 
    self.orderId = orderId
16528 
 
16529 
  def read(self, iprot):
16530 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16531 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16532 
      return
16533 
    iprot.readStructBegin()
16534 
    while True:
16535 
      (fname, ftype, fid) = iprot.readFieldBegin()
16536 
      if ftype == TType.STOP:
16537 
        break
16538 
      if fid == 1:
16539 
        if ftype == TType.I64:
16540 
          self.orderId = iprot.readI64();
16541 
        else:
16542 
          iprot.skip(ftype)
16543 
      else:
16544 
        iprot.skip(ftype)
16545 
      iprot.readFieldEnd()
16546 
    iprot.readStructEnd()
16547 
 
16548 
  def write(self, oprot):
16549 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16550 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16551 
      return
16552 
    oprot.writeStructBegin('toggleDOAFlag_args')
3431 rajveer 16553 
    if self.orderId is not None:
2536 chandransh 16554 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
16555 
      oprot.writeI64(self.orderId)
16556 
      oprot.writeFieldEnd()
16557 
    oprot.writeFieldStop()
16558 
    oprot.writeStructEnd()
16559 
 
3431 rajveer 16560 
  def validate(self):
16561 
    return
16562 
 
16563 
 
2536 chandransh 16564 
  def __repr__(self):
16565 
    L = ['%s=%r' % (key, value)
16566 
      for key, value in self.__dict__.iteritems()]
16567 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16568 
 
16569 
  def __eq__(self, other):
16570 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16571 
 
16572 
  def __ne__(self, other):
16573 
    return not (self == other)
16574 
 
16575 
class toggleDOAFlag_result:
16576 
  """
16577 
  Attributes:
16578 
   - success
16579 
   - ex
16580 
  """
16581 
 
16582 
  thrift_spec = (
16583 
    (0, TType.BOOL, 'success', None, None, ), # 0
16584 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
16585 
  )
16586 
 
16587 
  def __init__(self, success=None, ex=None,):
16588 
    self.success = success
16589 
    self.ex = ex
16590 
 
16591 
  def read(self, iprot):
16592 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16593 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16594 
      return
16595 
    iprot.readStructBegin()
16596 
    while True:
16597 
      (fname, ftype, fid) = iprot.readFieldBegin()
16598 
      if ftype == TType.STOP:
16599 
        break
16600 
      if fid == 0:
16601 
        if ftype == TType.BOOL:
16602 
          self.success = iprot.readBool();
16603 
        else:
16604 
          iprot.skip(ftype)
16605 
      elif fid == 1:
16606 
        if ftype == TType.STRUCT:
16607 
          self.ex = TransactionServiceException()
16608 
          self.ex.read(iprot)
16609 
        else:
16610 
          iprot.skip(ftype)
16611 
      else:
16612 
        iprot.skip(ftype)
16613 
      iprot.readFieldEnd()
16614 
    iprot.readStructEnd()
16615 
 
16616 
  def write(self, oprot):
16617 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16618 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16619 
      return
16620 
    oprot.writeStructBegin('toggleDOAFlag_result')
3431 rajveer 16621 
    if self.success is not None:
2536 chandransh 16622 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
16623 
      oprot.writeBool(self.success)
16624 
      oprot.writeFieldEnd()
3431 rajveer 16625 
    if self.ex is not None:
2536 chandransh 16626 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
16627 
      self.ex.write(oprot)
16628 
      oprot.writeFieldEnd()
16629 
    oprot.writeFieldStop()
16630 
    oprot.writeStructEnd()
16631 
 
3431 rajveer 16632 
  def validate(self):
16633 
    return
16634 
 
16635 
 
2536 chandransh 16636 
  def __repr__(self):
16637 
    L = ['%s=%r' % (key, value)
16638 
      for key, value in self.__dict__.iteritems()]
16639 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16640 
 
16641 
  def __eq__(self, other):
16642 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16643 
 
16644 
  def __ne__(self, other):
16645 
    return not (self == other)
16646 
 
4712 rajveer 16647 
class markOrderAsDelivered_args:
16648 
  """
16649 
  Attributes:
16650 
   - orderId
16651 
   - deliveryTimestamp
16652 
   - receiver
16653 
  """
16654 
 
16655 
  thrift_spec = None
16656 
  def __init__(self, orderId=None, deliveryTimestamp=None, receiver=None,):
16657 
    self.orderId = orderId
16658 
    self.deliveryTimestamp = deliveryTimestamp
16659 
    self.receiver = receiver
16660 
 
16661 
  def read(self, iprot):
16662 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16663 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16664 
      return
16665 
    iprot.readStructBegin()
16666 
    while True:
16667 
      (fname, ftype, fid) = iprot.readFieldBegin()
16668 
      if ftype == TType.STOP:
16669 
        break
16670 
      if fid == 1:
16671 
        if ftype == TType.I64:
16672 
          self.orderId = iprot.readI64();
16673 
        else:
16674 
          iprot.skip(ftype)
16675 
      elif fid == 2:
16676 
        if ftype == TType.I64:
16677 
          self.deliveryTimestamp = iprot.readI64();
16678 
        else:
16679 
          iprot.skip(ftype)
16680 
      elif fid == -1:
16681 
        if ftype == TType.STRING:
16682 
          self.receiver = iprot.readString();
16683 
        else:
16684 
          iprot.skip(ftype)
16685 
      else:
16686 
        iprot.skip(ftype)
16687 
      iprot.readFieldEnd()
16688 
    iprot.readStructEnd()
16689 
 
16690 
  def write(self, oprot):
16691 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16692 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16693 
      return
16694 
    oprot.writeStructBegin('markOrderAsDelivered_args')
16695 
    if self.receiver is not None:
16696 
      oprot.writeFieldBegin('receiver', TType.STRING, -1)
16697 
      oprot.writeString(self.receiver)
16698 
      oprot.writeFieldEnd()
16699 
    if self.orderId is not None:
16700 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
16701 
      oprot.writeI64(self.orderId)
16702 
      oprot.writeFieldEnd()
16703 
    if self.deliveryTimestamp is not None:
16704 
      oprot.writeFieldBegin('deliveryTimestamp', TType.I64, 2)
16705 
      oprot.writeI64(self.deliveryTimestamp)
16706 
      oprot.writeFieldEnd()
16707 
    oprot.writeFieldStop()
16708 
    oprot.writeStructEnd()
16709 
 
16710 
  def validate(self):
16711 
    return
16712 
 
16713 
 
16714 
  def __repr__(self):
16715 
    L = ['%s=%r' % (key, value)
16716 
      for key, value in self.__dict__.iteritems()]
16717 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16718 
 
16719 
  def __eq__(self, other):
16720 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16721 
 
16722 
  def __ne__(self, other):
16723 
    return not (self == other)
16724 
 
16725 
class markOrderAsDelivered_result:
16726 
  """
16727 
  Attributes:
16728 
   - ex
16729 
  """
16730 
 
16731 
  thrift_spec = (
16732 
    None, # 0
16733 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
16734 
  )
16735 
 
16736 
  def __init__(self, ex=None,):
16737 
    self.ex = ex
16738 
 
16739 
  def read(self, iprot):
16740 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16741 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16742 
      return
16743 
    iprot.readStructBegin()
16744 
    while True:
16745 
      (fname, ftype, fid) = iprot.readFieldBegin()
16746 
      if ftype == TType.STOP:
16747 
        break
16748 
      if fid == 1:
16749 
        if ftype == TType.STRUCT:
16750 
          self.ex = TransactionServiceException()
16751 
          self.ex.read(iprot)
16752 
        else:
16753 
          iprot.skip(ftype)
16754 
      else:
16755 
        iprot.skip(ftype)
16756 
      iprot.readFieldEnd()
16757 
    iprot.readStructEnd()
16758 
 
16759 
  def write(self, oprot):
16760 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16761 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16762 
      return
16763 
    oprot.writeStructBegin('markOrderAsDelivered_result')
16764 
    if self.ex is not None:
16765 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
16766 
      self.ex.write(oprot)
16767 
      oprot.writeFieldEnd()
16768 
    oprot.writeFieldStop()
16769 
    oprot.writeStructEnd()
16770 
 
16771 
  def validate(self):
16772 
    return
16773 
 
16774 
 
16775 
  def __repr__(self):
16776 
    L = ['%s=%r' % (key, value)
16777 
      for key, value in self.__dict__.iteritems()]
16778 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16779 
 
16780 
  def __eq__(self, other):
16781 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16782 
 
16783 
  def __ne__(self, other):
16784 
    return not (self == other)
16785 
 
5553 rajveer 16786 
class markOrderAsReceivedAtStore_args:
16787 
  """
16788 
  Attributes:
16789 
   - orderId
16790 
   - deliveryTimestamp
16791 
  """
16792 
 
16793 
  thrift_spec = (
16794 
    None, # 0
16795 
    (1, TType.I64, 'orderId', None, None, ), # 1
16796 
    (2, TType.I64, 'deliveryTimestamp', None, None, ), # 2
16797 
  )
16798 
 
16799 
  def __init__(self, orderId=None, deliveryTimestamp=None,):
16800 
    self.orderId = orderId
16801 
    self.deliveryTimestamp = deliveryTimestamp
16802 
 
16803 
  def read(self, iprot):
16804 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16805 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16806 
      return
16807 
    iprot.readStructBegin()
16808 
    while True:
16809 
      (fname, ftype, fid) = iprot.readFieldBegin()
16810 
      if ftype == TType.STOP:
16811 
        break
16812 
      if fid == 1:
16813 
        if ftype == TType.I64:
16814 
          self.orderId = iprot.readI64();
16815 
        else:
16816 
          iprot.skip(ftype)
16817 
      elif fid == 2:
16818 
        if ftype == TType.I64:
16819 
          self.deliveryTimestamp = iprot.readI64();
16820 
        else:
16821 
          iprot.skip(ftype)
16822 
      else:
16823 
        iprot.skip(ftype)
16824 
      iprot.readFieldEnd()
16825 
    iprot.readStructEnd()
16826 
 
16827 
  def write(self, oprot):
16828 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16829 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16830 
      return
16831 
    oprot.writeStructBegin('markOrderAsReceivedAtStore_args')
16832 
    if self.orderId is not None:
16833 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
16834 
      oprot.writeI64(self.orderId)
16835 
      oprot.writeFieldEnd()
16836 
    if self.deliveryTimestamp is not None:
16837 
      oprot.writeFieldBegin('deliveryTimestamp', TType.I64, 2)
16838 
      oprot.writeI64(self.deliveryTimestamp)
16839 
      oprot.writeFieldEnd()
16840 
    oprot.writeFieldStop()
16841 
    oprot.writeStructEnd()
16842 
 
16843 
  def validate(self):
16844 
    return
16845 
 
16846 
 
16847 
  def __repr__(self):
16848 
    L = ['%s=%r' % (key, value)
16849 
      for key, value in self.__dict__.iteritems()]
16850 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16851 
 
16852 
  def __eq__(self, other):
16853 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16854 
 
16855 
  def __ne__(self, other):
16856 
    return not (self == other)
16857 
 
16858 
class markOrderAsReceivedAtStore_result:
16859 
  """
16860 
  Attributes:
16861 
   - ex
16862 
  """
16863 
 
16864 
  thrift_spec = (
16865 
    None, # 0
16866 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
16867 
  )
16868 
 
16869 
  def __init__(self, ex=None,):
16870 
    self.ex = ex
16871 
 
16872 
  def read(self, iprot):
16873 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16874 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16875 
      return
16876 
    iprot.readStructBegin()
16877 
    while True:
16878 
      (fname, ftype, fid) = iprot.readFieldBegin()
16879 
      if ftype == TType.STOP:
16880 
        break
16881 
      if fid == 1:
16882 
        if ftype == TType.STRUCT:
16883 
          self.ex = TransactionServiceException()
16884 
          self.ex.read(iprot)
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('markOrderAsReceivedAtStore_result')
16897 
    if self.ex is not None:
16898 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
16899 
      self.ex.write(oprot)
16900 
      oprot.writeFieldEnd()
16901 
    oprot.writeFieldStop()
16902 
    oprot.writeStructEnd()
16903 
 
16904 
  def validate(self):
16905 
    return
16906 
 
16907 
 
16908 
  def __repr__(self):
16909 
    L = ['%s=%r' % (key, value)
16910 
      for key, value in self.__dict__.iteritems()]
16911 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16912 
 
16913 
  def __eq__(self, other):
16914 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16915 
 
16916 
  def __ne__(self, other):
16917 
    return not (self == other)
16918 
 
4454 rajveer 16919 
class markOrderDoaRequestReceived_args:
16920 
  """
16921 
  Attributes:
16922 
   - orderId
16923 
  """
16924 
 
16925 
  thrift_spec = (
16926 
    None, # 0
16927 
    (1, TType.I64, 'orderId', None, None, ), # 1
16928 
  )
16929 
 
16930 
  def __init__(self, orderId=None,):
16931 
    self.orderId = orderId
16932 
 
16933 
  def read(self, iprot):
16934 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16935 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16936 
      return
16937 
    iprot.readStructBegin()
16938 
    while True:
16939 
      (fname, ftype, fid) = iprot.readFieldBegin()
16940 
      if ftype == TType.STOP:
16941 
        break
16942 
      if fid == 1:
16943 
        if ftype == TType.I64:
16944 
          self.orderId = iprot.readI64();
16945 
        else:
16946 
          iprot.skip(ftype)
16947 
      else:
16948 
        iprot.skip(ftype)
16949 
      iprot.readFieldEnd()
16950 
    iprot.readStructEnd()
16951 
 
16952 
  def write(self, oprot):
16953 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16954 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16955 
      return
16956 
    oprot.writeStructBegin('markOrderDoaRequestReceived_args')
16957 
    if self.orderId is not None:
16958 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
16959 
      oprot.writeI64(self.orderId)
16960 
      oprot.writeFieldEnd()
16961 
    oprot.writeFieldStop()
16962 
    oprot.writeStructEnd()
16963 
 
16964 
  def validate(self):
16965 
    return
16966 
 
16967 
 
16968 
  def __repr__(self):
16969 
    L = ['%s=%r' % (key, value)
16970 
      for key, value in self.__dict__.iteritems()]
16971 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16972 
 
16973 
  def __eq__(self, other):
16974 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16975 
 
16976 
  def __ne__(self, other):
16977 
    return not (self == other)
16978 
 
16979 
class markOrderDoaRequestReceived_result:
16980 
  """
16981 
  Attributes:
16982 
   - success
16983 
   - ex
16984 
  """
16985 
 
16986 
  thrift_spec = (
16987 
    (0, TType.BOOL, 'success', None, None, ), # 0
16988 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
16989 
  )
16990 
 
16991 
  def __init__(self, success=None, ex=None,):
16992 
    self.success = success
16993 
    self.ex = ex
16994 
 
16995 
  def read(self, iprot):
16996 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16997 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16998 
      return
16999 
    iprot.readStructBegin()
17000 
    while True:
17001 
      (fname, ftype, fid) = iprot.readFieldBegin()
17002 
      if ftype == TType.STOP:
17003 
        break
17004 
      if fid == 0:
17005 
        if ftype == TType.BOOL:
17006 
          self.success = iprot.readBool();
17007 
        else:
17008 
          iprot.skip(ftype)
17009 
      elif fid == 1:
17010 
        if ftype == TType.STRUCT:
17011 
          self.ex = TransactionServiceException()
17012 
          self.ex.read(iprot)
17013 
        else:
17014 
          iprot.skip(ftype)
17015 
      else:
17016 
        iprot.skip(ftype)
17017 
      iprot.readFieldEnd()
17018 
    iprot.readStructEnd()
17019 
 
17020 
  def write(self, oprot):
17021 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17022 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17023 
      return
17024 
    oprot.writeStructBegin('markOrderDoaRequestReceived_result')
17025 
    if self.success is not None:
17026 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
17027 
      oprot.writeBool(self.success)
17028 
      oprot.writeFieldEnd()
17029 
    if self.ex is not None:
17030 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
17031 
      self.ex.write(oprot)
17032 
      oprot.writeFieldEnd()
17033 
    oprot.writeFieldStop()
17034 
    oprot.writeStructEnd()
17035 
 
17036 
  def validate(self):
17037 
    return
17038 
 
17039 
 
17040 
  def __repr__(self):
17041 
    L = ['%s=%r' % (key, value)
17042 
      for key, value in self.__dict__.iteritems()]
17043 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17044 
 
17045 
  def __eq__(self, other):
17046 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17047 
 
17048 
  def __ne__(self, other):
17049 
    return not (self == other)
17050 
 
17051 
class markOrderDoaRequestAuthorized_args:
17052 
  """
17053 
  Attributes:
17054 
   - orderId
17055 
   - isAuthorized
17056 
  """
17057 
 
17058 
  thrift_spec = (
17059 
    None, # 0
17060 
    (1, TType.I64, 'orderId', None, None, ), # 1
17061 
    (2, TType.BOOL, 'isAuthorized', None, None, ), # 2
17062 
  )
17063 
 
17064 
  def __init__(self, orderId=None, isAuthorized=None,):
17065 
    self.orderId = orderId
17066 
    self.isAuthorized = isAuthorized
17067 
 
17068 
  def read(self, iprot):
17069 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17070 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17071 
      return
17072 
    iprot.readStructBegin()
17073 
    while True:
17074 
      (fname, ftype, fid) = iprot.readFieldBegin()
17075 
      if ftype == TType.STOP:
17076 
        break
17077 
      if fid == 1:
17078 
        if ftype == TType.I64:
17079 
          self.orderId = iprot.readI64();
17080 
        else:
17081 
          iprot.skip(ftype)
17082 
      elif fid == 2:
17083 
        if ftype == TType.BOOL:
17084 
          self.isAuthorized = iprot.readBool();
17085 
        else:
17086 
          iprot.skip(ftype)
17087 
      else:
17088 
        iprot.skip(ftype)
17089 
      iprot.readFieldEnd()
17090 
    iprot.readStructEnd()
17091 
 
17092 
  def write(self, oprot):
17093 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17094 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17095 
      return
17096 
    oprot.writeStructBegin('markOrderDoaRequestAuthorized_args')
17097 
    if self.orderId is not None:
17098 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
17099 
      oprot.writeI64(self.orderId)
17100 
      oprot.writeFieldEnd()
17101 
    if self.isAuthorized is not None:
17102 
      oprot.writeFieldBegin('isAuthorized', TType.BOOL, 2)
17103 
      oprot.writeBool(self.isAuthorized)
17104 
      oprot.writeFieldEnd()
17105 
    oprot.writeFieldStop()
17106 
    oprot.writeStructEnd()
17107 
 
17108 
  def validate(self):
17109 
    return
17110 
 
17111 
 
17112 
  def __repr__(self):
17113 
    L = ['%s=%r' % (key, value)
17114 
      for key, value in self.__dict__.iteritems()]
17115 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17116 
 
17117 
  def __eq__(self, other):
17118 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17119 
 
17120 
  def __ne__(self, other):
17121 
    return not (self == other)
17122 
 
17123 
class markOrderDoaRequestAuthorized_result:
17124 
  """
17125 
  Attributes:
17126 
   - success
17127 
   - ex
17128 
  """
17129 
 
17130 
  thrift_spec = (
17131 
    (0, TType.BOOL, 'success', None, None, ), # 0
17132 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
17133 
  )
17134 
 
17135 
  def __init__(self, success=None, ex=None,):
17136 
    self.success = success
17137 
    self.ex = ex
17138 
 
17139 
  def read(self, iprot):
17140 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17141 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17142 
      return
17143 
    iprot.readStructBegin()
17144 
    while True:
17145 
      (fname, ftype, fid) = iprot.readFieldBegin()
17146 
      if ftype == TType.STOP:
17147 
        break
17148 
      if fid == 0:
17149 
        if ftype == TType.BOOL:
17150 
          self.success = iprot.readBool();
17151 
        else:
17152 
          iprot.skip(ftype)
17153 
      elif fid == 1:
17154 
        if ftype == TType.STRUCT:
17155 
          self.ex = TransactionServiceException()
17156 
          self.ex.read(iprot)
17157 
        else:
17158 
          iprot.skip(ftype)
17159 
      else:
17160 
        iprot.skip(ftype)
17161 
      iprot.readFieldEnd()
17162 
    iprot.readStructEnd()
17163 
 
17164 
  def write(self, oprot):
17165 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17166 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17167 
      return
17168 
    oprot.writeStructBegin('markOrderDoaRequestAuthorized_result')
17169 
    if self.success is not None:
17170 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
17171 
      oprot.writeBool(self.success)
17172 
      oprot.writeFieldEnd()
17173 
    if self.ex is not None:
17174 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
17175 
      self.ex.write(oprot)
17176 
      oprot.writeFieldEnd()
17177 
    oprot.writeFieldStop()
17178 
    oprot.writeStructEnd()
17179 
 
17180 
  def validate(self):
17181 
    return
17182 
 
17183 
 
17184 
  def __repr__(self):
17185 
    L = ['%s=%r' % (key, value)
17186 
      for key, value in self.__dict__.iteritems()]
17187 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17188 
 
17189 
  def __eq__(self, other):
17190 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17191 
 
17192 
  def __ne__(self, other):
17193 
    return not (self == other)
17194 
 
4488 rajveer 17195 
class markOrderReturnRequestReceived_args:
17196 
  """
17197 
  Attributes:
17198 
   - orderId
17199 
  """
17200 
 
17201 
  thrift_spec = (
17202 
    None, # 0
17203 
    (1, TType.I64, 'orderId', None, None, ), # 1
17204 
  )
17205 
 
17206 
  def __init__(self, orderId=None,):
17207 
    self.orderId = orderId
17208 
 
17209 
  def read(self, iprot):
17210 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17211 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17212 
      return
17213 
    iprot.readStructBegin()
17214 
    while True:
17215 
      (fname, ftype, fid) = iprot.readFieldBegin()
17216 
      if ftype == TType.STOP:
17217 
        break
17218 
      if fid == 1:
17219 
        if ftype == TType.I64:
17220 
          self.orderId = iprot.readI64();
17221 
        else:
17222 
          iprot.skip(ftype)
17223 
      else:
17224 
        iprot.skip(ftype)
17225 
      iprot.readFieldEnd()
17226 
    iprot.readStructEnd()
17227 
 
17228 
  def write(self, oprot):
17229 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17230 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17231 
      return
17232 
    oprot.writeStructBegin('markOrderReturnRequestReceived_args')
17233 
    if self.orderId is not None:
17234 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
17235 
      oprot.writeI64(self.orderId)
17236 
      oprot.writeFieldEnd()
17237 
    oprot.writeFieldStop()
17238 
    oprot.writeStructEnd()
17239 
 
17240 
  def validate(self):
17241 
    return
17242 
 
17243 
 
17244 
  def __repr__(self):
17245 
    L = ['%s=%r' % (key, value)
17246 
      for key, value in self.__dict__.iteritems()]
17247 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17248 
 
17249 
  def __eq__(self, other):
17250 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17251 
 
17252 
  def __ne__(self, other):
17253 
    return not (self == other)
17254 
 
17255 
class markOrderReturnRequestReceived_result:
17256 
  """
17257 
  Attributes:
17258 
   - success
17259 
   - ex
17260 
  """
17261 
 
17262 
  thrift_spec = (
17263 
    (0, TType.BOOL, 'success', None, None, ), # 0
17264 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
17265 
  )
17266 
 
17267 
  def __init__(self, success=None, ex=None,):
17268 
    self.success = success
17269 
    self.ex = ex
17270 
 
17271 
  def read(self, iprot):
17272 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17273 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17274 
      return
17275 
    iprot.readStructBegin()
17276 
    while True:
17277 
      (fname, ftype, fid) = iprot.readFieldBegin()
17278 
      if ftype == TType.STOP:
17279 
        break
17280 
      if fid == 0:
17281 
        if ftype == TType.BOOL:
17282 
          self.success = iprot.readBool();
17283 
        else:
17284 
          iprot.skip(ftype)
17285 
      elif fid == 1:
17286 
        if ftype == TType.STRUCT:
17287 
          self.ex = TransactionServiceException()
17288 
          self.ex.read(iprot)
17289 
        else:
17290 
          iprot.skip(ftype)
17291 
      else:
17292 
        iprot.skip(ftype)
17293 
      iprot.readFieldEnd()
17294 
    iprot.readStructEnd()
17295 
 
17296 
  def write(self, oprot):
17297 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17298 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17299 
      return
17300 
    oprot.writeStructBegin('markOrderReturnRequestReceived_result')
17301 
    if self.success is not None:
17302 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
17303 
      oprot.writeBool(self.success)
17304 
      oprot.writeFieldEnd()
17305 
    if self.ex is not None:
17306 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
17307 
      self.ex.write(oprot)
17308 
      oprot.writeFieldEnd()
17309 
    oprot.writeFieldStop()
17310 
    oprot.writeStructEnd()
17311 
 
17312 
  def validate(self):
17313 
    return
17314 
 
17315 
 
17316 
  def __repr__(self):
17317 
    L = ['%s=%r' % (key, value)
17318 
      for key, value in self.__dict__.iteritems()]
17319 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17320 
 
17321 
  def __eq__(self, other):
17322 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17323 
 
17324 
  def __ne__(self, other):
17325 
    return not (self == other)
17326 
 
17327 
class markOrderReturnRequestAuthorized_args:
17328 
  """
17329 
  Attributes:
17330 
   - orderId
17331 
   - isAuthorized
17332 
  """
17333 
 
17334 
  thrift_spec = (
17335 
    None, # 0
17336 
    (1, TType.I64, 'orderId', None, None, ), # 1
17337 
    (2, TType.BOOL, 'isAuthorized', None, None, ), # 2
17338 
  )
17339 
 
17340 
  def __init__(self, orderId=None, isAuthorized=None,):
17341 
    self.orderId = orderId
17342 
    self.isAuthorized = isAuthorized
17343 
 
17344 
  def read(self, iprot):
17345 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17346 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17347 
      return
17348 
    iprot.readStructBegin()
17349 
    while True:
17350 
      (fname, ftype, fid) = iprot.readFieldBegin()
17351 
      if ftype == TType.STOP:
17352 
        break
17353 
      if fid == 1:
17354 
        if ftype == TType.I64:
17355 
          self.orderId = iprot.readI64();
17356 
        else:
17357 
          iprot.skip(ftype)
17358 
      elif fid == 2:
17359 
        if ftype == TType.BOOL:
17360 
          self.isAuthorized = iprot.readBool();
17361 
        else:
17362 
          iprot.skip(ftype)
17363 
      else:
17364 
        iprot.skip(ftype)
17365 
      iprot.readFieldEnd()
17366 
    iprot.readStructEnd()
17367 
 
17368 
  def write(self, oprot):
17369 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17370 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17371 
      return
17372 
    oprot.writeStructBegin('markOrderReturnRequestAuthorized_args')
17373 
    if self.orderId is not None:
17374 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
17375 
      oprot.writeI64(self.orderId)
17376 
      oprot.writeFieldEnd()
17377 
    if self.isAuthorized is not None:
17378 
      oprot.writeFieldBegin('isAuthorized', TType.BOOL, 2)
17379 
      oprot.writeBool(self.isAuthorized)
17380 
      oprot.writeFieldEnd()
17381 
    oprot.writeFieldStop()
17382 
    oprot.writeStructEnd()
17383 
 
17384 
  def validate(self):
17385 
    return
17386 
 
17387 
 
17388 
  def __repr__(self):
17389 
    L = ['%s=%r' % (key, value)
17390 
      for key, value in self.__dict__.iteritems()]
17391 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17392 
 
17393 
  def __eq__(self, other):
17394 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17395 
 
17396 
  def __ne__(self, other):
17397 
    return not (self == other)
17398 
 
17399 
class markOrderReturnRequestAuthorized_result:
17400 
  """
17401 
  Attributes:
17402 
   - success
17403 
   - ex
17404 
  """
17405 
 
17406 
  thrift_spec = (
17407 
    (0, TType.BOOL, 'success', None, None, ), # 0
17408 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
17409 
  )
17410 
 
17411 
  def __init__(self, success=None, ex=None,):
17412 
    self.success = success
17413 
    self.ex = ex
17414 
 
17415 
  def read(self, iprot):
17416 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17417 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17418 
      return
17419 
    iprot.readStructBegin()
17420 
    while True:
17421 
      (fname, ftype, fid) = iprot.readFieldBegin()
17422 
      if ftype == TType.STOP:
17423 
        break
17424 
      if fid == 0:
17425 
        if ftype == TType.BOOL:
17426 
          self.success = iprot.readBool();
17427 
        else:
17428 
          iprot.skip(ftype)
17429 
      elif fid == 1:
17430 
        if ftype == TType.STRUCT:
17431 
          self.ex = TransactionServiceException()
17432 
          self.ex.read(iprot)
17433 
        else:
17434 
          iprot.skip(ftype)
17435 
      else:
17436 
        iprot.skip(ftype)
17437 
      iprot.readFieldEnd()
17438 
    iprot.readStructEnd()
17439 
 
17440 
  def write(self, oprot):
17441 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17442 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17443 
      return
17444 
    oprot.writeStructBegin('markOrderReturnRequestAuthorized_result')
17445 
    if self.success is not None:
17446 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
17447 
      oprot.writeBool(self.success)
17448 
      oprot.writeFieldEnd()
17449 
    if self.ex is not None:
17450 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
17451 
      self.ex.write(oprot)
17452 
      oprot.writeFieldEnd()
17453 
    oprot.writeFieldStop()
17454 
    oprot.writeStructEnd()
17455 
 
17456 
  def validate(self):
17457 
    return
17458 
 
17459 
 
17460 
  def __repr__(self):
17461 
    L = ['%s=%r' % (key, value)
17462 
      for key, value in self.__dict__.iteritems()]
17463 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17464 
 
17465 
  def __eq__(self, other):
17466 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17467 
 
17468 
  def __ne__(self, other):
17469 
    return not (self == other)
17470 
 
2536 chandransh 17471 
class requestPickupNumber_args:
17472 
  """
17473 
  Attributes:
17474 
   - orderId
4579 rajveer 17475 
   - providerId
2536 chandransh 17476 
  """
17477 
 
17478 
  thrift_spec = (
17479 
    None, # 0
17480 
    (1, TType.I64, 'orderId', None, None, ), # 1
4579 rajveer 17481 
    (2, TType.I64, 'providerId', None, None, ), # 2
2536 chandransh 17482 
  )
17483 
 
4579 rajveer 17484 
  def __init__(self, orderId=None, providerId=None,):
2536 chandransh 17485 
    self.orderId = orderId
4579 rajveer 17486 
    self.providerId = providerId
2536 chandransh 17487 
 
17488 
  def read(self, iprot):
17489 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17490 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17491 
      return
17492 
    iprot.readStructBegin()
17493 
    while True:
17494 
      (fname, ftype, fid) = iprot.readFieldBegin()
17495 
      if ftype == TType.STOP:
17496 
        break
17497 
      if fid == 1:
17498 
        if ftype == TType.I64:
17499 
          self.orderId = iprot.readI64();
17500 
        else:
17501 
          iprot.skip(ftype)
4579 rajveer 17502 
      elif fid == 2:
17503 
        if ftype == TType.I64:
17504 
          self.providerId = iprot.readI64();
17505 
        else:
17506 
          iprot.skip(ftype)
2536 chandransh 17507 
      else:
17508 
        iprot.skip(ftype)
17509 
      iprot.readFieldEnd()
17510 
    iprot.readStructEnd()
17511 
 
17512 
  def write(self, oprot):
17513 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17514 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17515 
      return
17516 
    oprot.writeStructBegin('requestPickupNumber_args')
3431 rajveer 17517 
    if self.orderId is not None:
2536 chandransh 17518 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
17519 
      oprot.writeI64(self.orderId)
17520 
      oprot.writeFieldEnd()
4579 rajveer 17521 
    if self.providerId is not None:
17522 
      oprot.writeFieldBegin('providerId', TType.I64, 2)
17523 
      oprot.writeI64(self.providerId)
17524 
      oprot.writeFieldEnd()
2536 chandransh 17525 
    oprot.writeFieldStop()
17526 
    oprot.writeStructEnd()
17527 
 
3431 rajveer 17528 
  def validate(self):
17529 
    return
17530 
 
17531 
 
2536 chandransh 17532 
  def __repr__(self):
17533 
    L = ['%s=%r' % (key, value)
17534 
      for key, value in self.__dict__.iteritems()]
17535 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17536 
 
17537 
  def __eq__(self, other):
17538 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17539 
 
17540 
  def __ne__(self, other):
17541 
    return not (self == other)
17542 
 
17543 
class requestPickupNumber_result:
17544 
  """
17545 
  Attributes:
17546 
   - success
17547 
   - ex
17548 
  """
17549 
 
17550 
  thrift_spec = (
17551 
    (0, TType.BOOL, 'success', None, None, ), # 0
17552 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
17553 
  )
17554 
 
17555 
  def __init__(self, success=None, ex=None,):
17556 
    self.success = success
17557 
    self.ex = ex
17558 
 
17559 
  def read(self, iprot):
17560 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17561 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17562 
      return
17563 
    iprot.readStructBegin()
17564 
    while True:
17565 
      (fname, ftype, fid) = iprot.readFieldBegin()
17566 
      if ftype == TType.STOP:
17567 
        break
17568 
      if fid == 0:
17569 
        if ftype == TType.BOOL:
17570 
          self.success = iprot.readBool();
17571 
        else:
17572 
          iprot.skip(ftype)
17573 
      elif fid == 1:
17574 
        if ftype == TType.STRUCT:
17575 
          self.ex = TransactionServiceException()
17576 
          self.ex.read(iprot)
17577 
        else:
17578 
          iprot.skip(ftype)
17579 
      else:
17580 
        iprot.skip(ftype)
17581 
      iprot.readFieldEnd()
17582 
    iprot.readStructEnd()
17583 
 
17584 
  def write(self, oprot):
17585 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17586 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17587 
      return
17588 
    oprot.writeStructBegin('requestPickupNumber_result')
3431 rajveer 17589 
    if self.success is not None:
2536 chandransh 17590 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
17591 
      oprot.writeBool(self.success)
17592 
      oprot.writeFieldEnd()
3431 rajveer 17593 
    if self.ex is not None:
2536 chandransh 17594 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
17595 
      self.ex.write(oprot)
17596 
      oprot.writeFieldEnd()
17597 
    oprot.writeFieldStop()
17598 
    oprot.writeStructEnd()
17599 
 
3431 rajveer 17600 
  def validate(self):
17601 
    return
17602 
 
17603 
 
2536 chandransh 17604 
  def __repr__(self):
17605 
    L = ['%s=%r' % (key, value)
17606 
      for key, value in self.__dict__.iteritems()]
17607 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17608 
 
17609 
  def __eq__(self, other):
17610 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17611 
 
17612 
  def __ne__(self, other):
17613 
    return not (self == other)
17614 
 
17615 
class authorizePickup_args:
17616 
  """
17617 
  Attributes:
17618 
   - orderId
17619 
   - pickupNumber
4602 rajveer 17620 
   - providerId
2536 chandransh 17621 
  """
17622 
 
17623 
  thrift_spec = (
17624 
    None, # 0
17625 
    (1, TType.I64, 'orderId', None, None, ), # 1
17626 
    (2, TType.STRING, 'pickupNumber', None, None, ), # 2
4602 rajveer 17627 
    (3, TType.I64, 'providerId', None, None, ), # 3
2536 chandransh 17628 
  )
17629 
 
4602 rajveer 17630 
  def __init__(self, orderId=None, pickupNumber=None, providerId=None,):
2536 chandransh 17631 
    self.orderId = orderId
17632 
    self.pickupNumber = pickupNumber
4602 rajveer 17633 
    self.providerId = providerId
2536 chandransh 17634 
 
17635 
  def read(self, iprot):
17636 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17637 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17638 
      return
17639 
    iprot.readStructBegin()
17640 
    while True:
17641 
      (fname, ftype, fid) = iprot.readFieldBegin()
17642 
      if ftype == TType.STOP:
17643 
        break
17644 
      if fid == 1:
17645 
        if ftype == TType.I64:
17646 
          self.orderId = iprot.readI64();
17647 
        else:
17648 
          iprot.skip(ftype)
17649 
      elif fid == 2:
17650 
        if ftype == TType.STRING:
17651 
          self.pickupNumber = iprot.readString();
17652 
        else:
17653 
          iprot.skip(ftype)
4602 rajveer 17654 
      elif fid == 3:
17655 
        if ftype == TType.I64:
17656 
          self.providerId = iprot.readI64();
17657 
        else:
17658 
          iprot.skip(ftype)
2536 chandransh 17659 
      else:
17660 
        iprot.skip(ftype)
17661 
      iprot.readFieldEnd()
17662 
    iprot.readStructEnd()
17663 
 
17664 
  def write(self, oprot):
17665 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17666 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17667 
      return
17668 
    oprot.writeStructBegin('authorizePickup_args')
3431 rajveer 17669 
    if self.orderId is not None:
2536 chandransh 17670 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
17671 
      oprot.writeI64(self.orderId)
17672 
      oprot.writeFieldEnd()
3431 rajveer 17673 
    if self.pickupNumber is not None:
2536 chandransh 17674 
      oprot.writeFieldBegin('pickupNumber', TType.STRING, 2)
17675 
      oprot.writeString(self.pickupNumber)
17676 
      oprot.writeFieldEnd()
4602 rajveer 17677 
    if self.providerId is not None:
17678 
      oprot.writeFieldBegin('providerId', TType.I64, 3)
17679 
      oprot.writeI64(self.providerId)
17680 
      oprot.writeFieldEnd()
2536 chandransh 17681 
    oprot.writeFieldStop()
17682 
    oprot.writeStructEnd()
17683 
 
3431 rajveer 17684 
  def validate(self):
17685 
    return
17686 
 
17687 
 
2536 chandransh 17688 
  def __repr__(self):
17689 
    L = ['%s=%r' % (key, value)
17690 
      for key, value in self.__dict__.iteritems()]
17691 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17692 
 
17693 
  def __eq__(self, other):
17694 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17695 
 
17696 
  def __ne__(self, other):
17697 
    return not (self == other)
17698 
 
17699 
class authorizePickup_result:
17700 
  """
17701 
  Attributes:
17702 
   - success
17703 
   - ex
17704 
  """
17705 
 
17706 
  thrift_spec = (
17707 
    (0, TType.BOOL, 'success', None, None, ), # 0
17708 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
17709 
  )
17710 
 
17711 
  def __init__(self, success=None, ex=None,):
17712 
    self.success = success
17713 
    self.ex = ex
17714 
 
17715 
  def read(self, iprot):
17716 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17717 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17718 
      return
17719 
    iprot.readStructBegin()
17720 
    while True:
17721 
      (fname, ftype, fid) = iprot.readFieldBegin()
17722 
      if ftype == TType.STOP:
17723 
        break
17724 
      if fid == 0:
17725 
        if ftype == TType.BOOL:
17726 
          self.success = iprot.readBool();
17727 
        else:
17728 
          iprot.skip(ftype)
17729 
      elif fid == 1:
17730 
        if ftype == TType.STRUCT:
17731 
          self.ex = TransactionServiceException()
17732 
          self.ex.read(iprot)
17733 
        else:
17734 
          iprot.skip(ftype)
17735 
      else:
17736 
        iprot.skip(ftype)
17737 
      iprot.readFieldEnd()
17738 
    iprot.readStructEnd()
17739 
 
17740 
  def write(self, oprot):
17741 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17742 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17743 
      return
17744 
    oprot.writeStructBegin('authorizePickup_result')
3431 rajveer 17745 
    if self.success is not None:
2536 chandransh 17746 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
17747 
      oprot.writeBool(self.success)
17748 
      oprot.writeFieldEnd()
3431 rajveer 17749 
    if self.ex is not None:
2536 chandransh 17750 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
17751 
      self.ex.write(oprot)
17752 
      oprot.writeFieldEnd()
17753 
    oprot.writeFieldStop()
17754 
    oprot.writeStructEnd()
17755 
 
3431 rajveer 17756 
  def validate(self):
17757 
    return
17758 
 
17759 
 
2536 chandransh 17760 
  def __repr__(self):
17761 
    L = ['%s=%r' % (key, value)
17762 
      for key, value in self.__dict__.iteritems()]
17763 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17764 
 
17765 
  def __eq__(self, other):
17766 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17767 
 
17768 
  def __ne__(self, other):
17769 
    return not (self == other)
17770 
 
2764 chandransh 17771 
class markDoasAsPickedUp_args:
17772 
  """
17773 
  Attributes:
17774 
   - providerId
17775 
   - pickupDetails
17776 
  """
17777 
 
17778 
  thrift_spec = (
17779 
    None, # 0
17780 
    (1, TType.I64, 'providerId', None, None, ), # 1
17781 
    (2, TType.MAP, 'pickupDetails', (TType.STRING,None,TType.STRING,None), None, ), # 2
17782 
  )
17783 
 
17784 
  def __init__(self, providerId=None, pickupDetails=None,):
17785 
    self.providerId = providerId
17786 
    self.pickupDetails = pickupDetails
17787 
 
17788 
  def read(self, iprot):
17789 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17790 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17791 
      return
17792 
    iprot.readStructBegin()
17793 
    while True:
17794 
      (fname, ftype, fid) = iprot.readFieldBegin()
17795 
      if ftype == TType.STOP:
17796 
        break
17797 
      if fid == 1:
17798 
        if ftype == TType.I64:
17799 
          self.providerId = iprot.readI64();
17800 
        else:
17801 
          iprot.skip(ftype)
17802 
      elif fid == 2:
17803 
        if ftype == TType.MAP:
17804 
          self.pickupDetails = {}
6188 rajveer 17805 
          (_ktype408, _vtype409, _size407 ) = iprot.readMapBegin()
17806 
          for _i411 in xrange(_size407):
17807 
            _key412 = iprot.readString();
17808 
            _val413 = iprot.readString();
17809 
            self.pickupDetails[_key412] = _val413
2764 chandransh 17810 
          iprot.readMapEnd()
17811 
        else:
17812 
          iprot.skip(ftype)
17813 
      else:
17814 
        iprot.skip(ftype)
17815 
      iprot.readFieldEnd()
17816 
    iprot.readStructEnd()
17817 
 
17818 
  def write(self, oprot):
17819 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17820 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17821 
      return
17822 
    oprot.writeStructBegin('markDoasAsPickedUp_args')
3431 rajveer 17823 
    if self.providerId is not None:
2764 chandransh 17824 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
17825 
      oprot.writeI64(self.providerId)
17826 
      oprot.writeFieldEnd()
3431 rajveer 17827 
    if self.pickupDetails is not None:
2764 chandransh 17828 
      oprot.writeFieldBegin('pickupDetails', TType.MAP, 2)
17829 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.pickupDetails))
6188 rajveer 17830 
      for kiter414,viter415 in self.pickupDetails.items():
17831 
        oprot.writeString(kiter414)
17832 
        oprot.writeString(viter415)
2764 chandransh 17833 
      oprot.writeMapEnd()
17834 
      oprot.writeFieldEnd()
17835 
    oprot.writeFieldStop()
17836 
    oprot.writeStructEnd()
17837 
 
3431 rajveer 17838 
  def validate(self):
17839 
    return
17840 
 
17841 
 
2764 chandransh 17842 
  def __repr__(self):
17843 
    L = ['%s=%r' % (key, value)
17844 
      for key, value in self.__dict__.iteritems()]
17845 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17846 
 
17847 
  def __eq__(self, other):
17848 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17849 
 
17850 
  def __ne__(self, other):
17851 
    return not (self == other)
17852 
 
17853 
class markDoasAsPickedUp_result:
4910 phani.kuma 17854 
 
17855 
  thrift_spec = (
17856 
  )
17857 
 
17858 
  def read(self, iprot):
17859 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17860 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17861 
      return
17862 
    iprot.readStructBegin()
17863 
    while True:
17864 
      (fname, ftype, fid) = iprot.readFieldBegin()
17865 
      if ftype == TType.STOP:
17866 
        break
17867 
      else:
17868 
        iprot.skip(ftype)
17869 
      iprot.readFieldEnd()
17870 
    iprot.readStructEnd()
17871 
 
17872 
  def write(self, oprot):
17873 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17874 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17875 
      return
17876 
    oprot.writeStructBegin('markDoasAsPickedUp_result')
17877 
    oprot.writeFieldStop()
17878 
    oprot.writeStructEnd()
17879 
 
17880 
  def validate(self):
17881 
    return
17882 
 
17883 
 
17884 
  def __repr__(self):
17885 
    L = ['%s=%r' % (key, value)
17886 
      for key, value in self.__dict__.iteritems()]
17887 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17888 
 
17889 
  def __eq__(self, other):
17890 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17891 
 
17892 
  def __ne__(self, other):
17893 
    return not (self == other)
17894 
 
17895 
class getDoasNotPickedUp_args:
2764 chandransh 17896 
  """
17897 
  Attributes:
4910 phani.kuma 17898 
   - providerId
17899 
  """
17900 
 
17901 
  thrift_spec = (
17902 
    None, # 0
17903 
    (1, TType.I64, 'providerId', None, None, ), # 1
17904 
  )
17905 
 
17906 
  def __init__(self, providerId=None,):
17907 
    self.providerId = providerId
17908 
 
17909 
  def read(self, iprot):
17910 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17911 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17912 
      return
17913 
    iprot.readStructBegin()
17914 
    while True:
17915 
      (fname, ftype, fid) = iprot.readFieldBegin()
17916 
      if ftype == TType.STOP:
17917 
        break
17918 
      if fid == 1:
17919 
        if ftype == TType.I64:
17920 
          self.providerId = iprot.readI64();
17921 
        else:
17922 
          iprot.skip(ftype)
17923 
      else:
17924 
        iprot.skip(ftype)
17925 
      iprot.readFieldEnd()
17926 
    iprot.readStructEnd()
17927 
 
17928 
  def write(self, oprot):
17929 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17930 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17931 
      return
17932 
    oprot.writeStructBegin('getDoasNotPickedUp_args')
17933 
    if self.providerId is not None:
17934 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
17935 
      oprot.writeI64(self.providerId)
17936 
      oprot.writeFieldEnd()
17937 
    oprot.writeFieldStop()
17938 
    oprot.writeStructEnd()
17939 
 
17940 
  def validate(self):
17941 
    return
17942 
 
17943 
 
17944 
  def __repr__(self):
17945 
    L = ['%s=%r' % (key, value)
17946 
      for key, value in self.__dict__.iteritems()]
17947 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17948 
 
17949 
  def __eq__(self, other):
17950 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17951 
 
17952 
  def __ne__(self, other):
17953 
    return not (self == other)
17954 
 
17955 
class getDoasNotPickedUp_result:
17956 
  """
17957 
  Attributes:
2764 chandransh 17958 
   - success
17959 
  """
17960 
 
17961 
  thrift_spec = (
17962 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
17963 
  )
17964 
 
17965 
  def __init__(self, success=None,):
17966 
    self.success = success
17967 
 
17968 
  def read(self, iprot):
17969 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17970 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17971 
      return
17972 
    iprot.readStructBegin()
17973 
    while True:
17974 
      (fname, ftype, fid) = iprot.readFieldBegin()
17975 
      if ftype == TType.STOP:
17976 
        break
17977 
      if fid == 0:
17978 
        if ftype == TType.LIST:
17979 
          self.success = []
6188 rajveer 17980 
          (_etype419, _size416) = iprot.readListBegin()
17981 
          for _i420 in xrange(_size416):
17982 
            _elem421 = Order()
17983 
            _elem421.read(iprot)
17984 
            self.success.append(_elem421)
2764 chandransh 17985 
          iprot.readListEnd()
17986 
        else:
17987 
          iprot.skip(ftype)
17988 
      else:
17989 
        iprot.skip(ftype)
17990 
      iprot.readFieldEnd()
17991 
    iprot.readStructEnd()
17992 
 
17993 
  def write(self, oprot):
17994 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17995 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17996 
      return
4910 phani.kuma 17997 
    oprot.writeStructBegin('getDoasNotPickedUp_result')
3431 rajveer 17998 
    if self.success is not None:
2764 chandransh 17999 
      oprot.writeFieldBegin('success', TType.LIST, 0)
18000 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 18001 
      for iter422 in self.success:
18002 
        iter422.write(oprot)
2764 chandransh 18003 
      oprot.writeListEnd()
18004 
      oprot.writeFieldEnd()
18005 
    oprot.writeFieldStop()
18006 
    oprot.writeStructEnd()
18007 
 
3431 rajveer 18008 
  def validate(self):
18009 
    return
18010 
 
18011 
 
2764 chandransh 18012 
  def __repr__(self):
18013 
    L = ['%s=%r' % (key, value)
18014 
      for key, value in self.__dict__.iteritems()]
18015 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18016 
 
18017 
  def __eq__(self, other):
18018 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18019 
 
18020 
  def __ne__(self, other):
18021 
    return not (self == other)
18022 
 
4741 phani.kuma 18023 
class markReturnOrdersAsPickedUp_args:
18024 
  """
18025 
  Attributes:
18026 
   - providerId
18027 
   - pickupDetails
18028 
  """
18029 
 
18030 
  thrift_spec = (
18031 
    None, # 0
18032 
    (1, TType.I64, 'providerId', None, None, ), # 1
18033 
    (2, TType.MAP, 'pickupDetails', (TType.STRING,None,TType.STRING,None), None, ), # 2
18034 
  )
18035 
 
18036 
  def __init__(self, providerId=None, pickupDetails=None,):
18037 
    self.providerId = providerId
18038 
    self.pickupDetails = pickupDetails
18039 
 
18040 
  def read(self, iprot):
18041 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18042 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18043 
      return
18044 
    iprot.readStructBegin()
18045 
    while True:
18046 
      (fname, ftype, fid) = iprot.readFieldBegin()
18047 
      if ftype == TType.STOP:
18048 
        break
18049 
      if fid == 1:
18050 
        if ftype == TType.I64:
18051 
          self.providerId = iprot.readI64();
18052 
        else:
18053 
          iprot.skip(ftype)
18054 
      elif fid == 2:
18055 
        if ftype == TType.MAP:
18056 
          self.pickupDetails = {}
6188 rajveer 18057 
          (_ktype424, _vtype425, _size423 ) = iprot.readMapBegin()
18058 
          for _i427 in xrange(_size423):
18059 
            _key428 = iprot.readString();
18060 
            _val429 = iprot.readString();
18061 
            self.pickupDetails[_key428] = _val429
4741 phani.kuma 18062 
          iprot.readMapEnd()
18063 
        else:
18064 
          iprot.skip(ftype)
18065 
      else:
18066 
        iprot.skip(ftype)
18067 
      iprot.readFieldEnd()
18068 
    iprot.readStructEnd()
18069 
 
18070 
  def write(self, oprot):
18071 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18072 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18073 
      return
18074 
    oprot.writeStructBegin('markReturnOrdersAsPickedUp_args')
18075 
    if self.providerId is not None:
18076 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
18077 
      oprot.writeI64(self.providerId)
18078 
      oprot.writeFieldEnd()
18079 
    if self.pickupDetails is not None:
18080 
      oprot.writeFieldBegin('pickupDetails', TType.MAP, 2)
18081 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.pickupDetails))
6188 rajveer 18082 
      for kiter430,viter431 in self.pickupDetails.items():
18083 
        oprot.writeString(kiter430)
18084 
        oprot.writeString(viter431)
4741 phani.kuma 18085 
      oprot.writeMapEnd()
18086 
      oprot.writeFieldEnd()
18087 
    oprot.writeFieldStop()
18088 
    oprot.writeStructEnd()
18089 
 
18090 
  def validate(self):
18091 
    return
18092 
 
18093 
 
18094 
  def __repr__(self):
18095 
    L = ['%s=%r' % (key, value)
18096 
      for key, value in self.__dict__.iteritems()]
18097 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18098 
 
18099 
  def __eq__(self, other):
18100 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18101 
 
18102 
  def __ne__(self, other):
18103 
    return not (self == other)
18104 
 
18105 
class markReturnOrdersAsPickedUp_result:
4910 phani.kuma 18106 
 
18107 
  thrift_spec = (
18108 
  )
18109 
 
18110 
  def read(self, iprot):
18111 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18112 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18113 
      return
18114 
    iprot.readStructBegin()
18115 
    while True:
18116 
      (fname, ftype, fid) = iprot.readFieldBegin()
18117 
      if ftype == TType.STOP:
18118 
        break
18119 
      else:
18120 
        iprot.skip(ftype)
18121 
      iprot.readFieldEnd()
18122 
    iprot.readStructEnd()
18123 
 
18124 
  def write(self, oprot):
18125 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18126 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18127 
      return
18128 
    oprot.writeStructBegin('markReturnOrdersAsPickedUp_result')
18129 
    oprot.writeFieldStop()
18130 
    oprot.writeStructEnd()
18131 
 
18132 
  def validate(self):
18133 
    return
18134 
 
18135 
 
18136 
  def __repr__(self):
18137 
    L = ['%s=%r' % (key, value)
18138 
      for key, value in self.__dict__.iteritems()]
18139 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18140 
 
18141 
  def __eq__(self, other):
18142 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18143 
 
18144 
  def __ne__(self, other):
18145 
    return not (self == other)
18146 
 
18147 
class getReturnOrdersNotPickedUp_args:
4741 phani.kuma 18148 
  """
18149 
  Attributes:
4910 phani.kuma 18150 
   - providerId
18151 
  """
18152 
 
18153 
  thrift_spec = (
18154 
    None, # 0
18155 
    (1, TType.I64, 'providerId', None, None, ), # 1
18156 
  )
18157 
 
18158 
  def __init__(self, providerId=None,):
18159 
    self.providerId = providerId
18160 
 
18161 
  def read(self, iprot):
18162 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18163 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18164 
      return
18165 
    iprot.readStructBegin()
18166 
    while True:
18167 
      (fname, ftype, fid) = iprot.readFieldBegin()
18168 
      if ftype == TType.STOP:
18169 
        break
18170 
      if fid == 1:
18171 
        if ftype == TType.I64:
18172 
          self.providerId = iprot.readI64();
18173 
        else:
18174 
          iprot.skip(ftype)
18175 
      else:
18176 
        iprot.skip(ftype)
18177 
      iprot.readFieldEnd()
18178 
    iprot.readStructEnd()
18179 
 
18180 
  def write(self, oprot):
18181 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18182 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18183 
      return
18184 
    oprot.writeStructBegin('getReturnOrdersNotPickedUp_args')
18185 
    if self.providerId is not None:
18186 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
18187 
      oprot.writeI64(self.providerId)
18188 
      oprot.writeFieldEnd()
18189 
    oprot.writeFieldStop()
18190 
    oprot.writeStructEnd()
18191 
 
18192 
  def validate(self):
18193 
    return
18194 
 
18195 
 
18196 
  def __repr__(self):
18197 
    L = ['%s=%r' % (key, value)
18198 
      for key, value in self.__dict__.iteritems()]
18199 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18200 
 
18201 
  def __eq__(self, other):
18202 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18203 
 
18204 
  def __ne__(self, other):
18205 
    return not (self == other)
18206 
 
18207 
class getReturnOrdersNotPickedUp_result:
18208 
  """
18209 
  Attributes:
4741 phani.kuma 18210 
   - success
18211 
  """
18212 
 
18213 
  thrift_spec = (
18214 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
18215 
  )
18216 
 
18217 
  def __init__(self, success=None,):
18218 
    self.success = success
18219 
 
18220 
  def read(self, iprot):
18221 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18222 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18223 
      return
18224 
    iprot.readStructBegin()
18225 
    while True:
18226 
      (fname, ftype, fid) = iprot.readFieldBegin()
18227 
      if ftype == TType.STOP:
18228 
        break
18229 
      if fid == 0:
18230 
        if ftype == TType.LIST:
18231 
          self.success = []
6188 rajveer 18232 
          (_etype435, _size432) = iprot.readListBegin()
18233 
          for _i436 in xrange(_size432):
18234 
            _elem437 = Order()
18235 
            _elem437.read(iprot)
18236 
            self.success.append(_elem437)
4741 phani.kuma 18237 
          iprot.readListEnd()
18238 
        else:
18239 
          iprot.skip(ftype)
18240 
      else:
18241 
        iprot.skip(ftype)
18242 
      iprot.readFieldEnd()
18243 
    iprot.readStructEnd()
18244 
 
18245 
  def write(self, oprot):
18246 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18247 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18248 
      return
4910 phani.kuma 18249 
    oprot.writeStructBegin('getReturnOrdersNotPickedUp_result')
4741 phani.kuma 18250 
    if self.success is not None:
18251 
      oprot.writeFieldBegin('success', TType.LIST, 0)
18252 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 18253 
      for iter438 in self.success:
18254 
        iter438.write(oprot)
4741 phani.kuma 18255 
      oprot.writeListEnd()
18256 
      oprot.writeFieldEnd()
18257 
    oprot.writeFieldStop()
18258 
    oprot.writeStructEnd()
18259 
 
18260 
  def validate(self):
18261 
    return
18262 
 
18263 
 
18264 
  def __repr__(self):
18265 
    L = ['%s=%r' % (key, value)
18266 
      for key, value in self.__dict__.iteritems()]
18267 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18268 
 
18269 
  def __eq__(self, other):
18270 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18271 
 
18272 
  def __ne__(self, other):
18273 
    return not (self == other)
18274 
 
2616 chandransh 18275 
class receiveReturn_args:
2591 chandransh 18276 
  """
18277 
  Attributes:
18278 
   - orderId
4479 rajveer 18279 
   - receiveCondition
2591 chandransh 18280 
  """
2536 chandransh 18281 
 
2591 chandransh 18282 
  thrift_spec = (
18283 
    None, # 0
18284 
    (1, TType.I64, 'orderId', None, None, ), # 1
4479 rajveer 18285 
    (2, TType.I64, 'receiveCondition', None, None, ), # 2
2591 chandransh 18286 
  )
18287 
 
4479 rajveer 18288 
  def __init__(self, orderId=None, receiveCondition=None,):
2591 chandransh 18289 
    self.orderId = orderId
4479 rajveer 18290 
    self.receiveCondition = receiveCondition
2591 chandransh 18291 
 
18292 
  def read(self, iprot):
18293 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18294 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18295 
      return
18296 
    iprot.readStructBegin()
18297 
    while True:
18298 
      (fname, ftype, fid) = iprot.readFieldBegin()
18299 
      if ftype == TType.STOP:
18300 
        break
18301 
      if fid == 1:
18302 
        if ftype == TType.I64:
18303 
          self.orderId = iprot.readI64();
18304 
        else:
18305 
          iprot.skip(ftype)
4479 rajveer 18306 
      elif fid == 2:
18307 
        if ftype == TType.I64:
18308 
          self.receiveCondition = iprot.readI64();
18309 
        else:
18310 
          iprot.skip(ftype)
2591 chandransh 18311 
      else:
18312 
        iprot.skip(ftype)
18313 
      iprot.readFieldEnd()
18314 
    iprot.readStructEnd()
18315 
 
18316 
  def write(self, oprot):
18317 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18318 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18319 
      return
2616 chandransh 18320 
    oprot.writeStructBegin('receiveReturn_args')
3431 rajveer 18321 
    if self.orderId is not None:
2591 chandransh 18322 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
18323 
      oprot.writeI64(self.orderId)
18324 
      oprot.writeFieldEnd()
4479 rajveer 18325 
    if self.receiveCondition is not None:
18326 
      oprot.writeFieldBegin('receiveCondition', TType.I64, 2)
18327 
      oprot.writeI64(self.receiveCondition)
18328 
      oprot.writeFieldEnd()
2591 chandransh 18329 
    oprot.writeFieldStop()
18330 
    oprot.writeStructEnd()
18331 
 
3431 rajveer 18332 
  def validate(self):
18333 
    return
18334 
 
18335 
 
2591 chandransh 18336 
  def __repr__(self):
18337 
    L = ['%s=%r' % (key, value)
18338 
      for key, value in self.__dict__.iteritems()]
18339 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18340 
 
18341 
  def __eq__(self, other):
18342 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18343 
 
18344 
  def __ne__(self, other):
18345 
    return not (self == other)
18346 
 
2616 chandransh 18347 
class receiveReturn_result:
2591 chandransh 18348 
  """
18349 
  Attributes:
18350 
   - success
18351 
   - ex
18352 
  """
18353 
 
18354 
  thrift_spec = (
18355 
    (0, TType.BOOL, 'success', None, None, ), # 0
18356 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
18357 
  )
18358 
 
18359 
  def __init__(self, success=None, ex=None,):
18360 
    self.success = success
18361 
    self.ex = ex
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 == 0:
18373 
        if ftype == TType.BOOL:
18374 
          self.success = iprot.readBool();
18375 
        else:
18376 
          iprot.skip(ftype)
18377 
      elif fid == 1:
18378 
        if ftype == TType.STRUCT:
18379 
          self.ex = TransactionServiceException()
18380 
          self.ex.read(iprot)
18381 
        else:
18382 
          iprot.skip(ftype)
18383 
      else:
18384 
        iprot.skip(ftype)
18385 
      iprot.readFieldEnd()
18386 
    iprot.readStructEnd()
18387 
 
18388 
  def write(self, oprot):
18389 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18390 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18391 
      return
2616 chandransh 18392 
    oprot.writeStructBegin('receiveReturn_result')
3431 rajveer 18393 
    if self.success is not None:
2591 chandransh 18394 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
18395 
      oprot.writeBool(self.success)
18396 
      oprot.writeFieldEnd()
3431 rajveer 18397 
    if self.ex is not None:
2591 chandransh 18398 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
18399 
      self.ex.write(oprot)
18400 
      oprot.writeFieldEnd()
18401 
    oprot.writeFieldStop()
18402 
    oprot.writeStructEnd()
18403 
 
3431 rajveer 18404 
  def validate(self):
18405 
    return
18406 
 
18407 
 
2591 chandransh 18408 
  def __repr__(self):
18409 
    L = ['%s=%r' % (key, value)
18410 
      for key, value in self.__dict__.iteritems()]
18411 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18412 
 
18413 
  def __eq__(self, other):
18414 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18415 
 
18416 
  def __ne__(self, other):
18417 
    return not (self == other)
18418 
 
18419 
class validateDoa_args:
18420 
  """
18421 
  Attributes:
18422 
   - orderId
18423 
   - isValid
18424 
  """
18425 
 
18426 
  thrift_spec = (
18427 
    None, # 0
18428 
    (1, TType.I64, 'orderId', None, None, ), # 1
18429 
    (2, TType.BOOL, 'isValid', None, None, ), # 2
18430 
  )
18431 
 
18432 
  def __init__(self, orderId=None, isValid=None,):
18433 
    self.orderId = orderId
18434 
    self.isValid = isValid
18435 
 
18436 
  def read(self, iprot):
18437 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18438 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18439 
      return
18440 
    iprot.readStructBegin()
18441 
    while True:
18442 
      (fname, ftype, fid) = iprot.readFieldBegin()
18443 
      if ftype == TType.STOP:
18444 
        break
18445 
      if fid == 1:
18446 
        if ftype == TType.I64:
18447 
          self.orderId = iprot.readI64();
18448 
        else:
18449 
          iprot.skip(ftype)
18450 
      elif fid == 2:
18451 
        if ftype == TType.BOOL:
18452 
          self.isValid = iprot.readBool();
18453 
        else:
18454 
          iprot.skip(ftype)
18455 
      else:
18456 
        iprot.skip(ftype)
18457 
      iprot.readFieldEnd()
18458 
    iprot.readStructEnd()
18459 
 
18460 
  def write(self, oprot):
18461 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18462 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18463 
      return
18464 
    oprot.writeStructBegin('validateDoa_args')
3431 rajveer 18465 
    if self.orderId is not None:
2591 chandransh 18466 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
18467 
      oprot.writeI64(self.orderId)
18468 
      oprot.writeFieldEnd()
3431 rajveer 18469 
    if self.isValid is not None:
2591 chandransh 18470 
      oprot.writeFieldBegin('isValid', TType.BOOL, 2)
18471 
      oprot.writeBool(self.isValid)
18472 
      oprot.writeFieldEnd()
18473 
    oprot.writeFieldStop()
18474 
    oprot.writeStructEnd()
18475 
 
3431 rajveer 18476 
  def validate(self):
18477 
    return
18478 
 
18479 
 
2591 chandransh 18480 
  def __repr__(self):
18481 
    L = ['%s=%r' % (key, value)
18482 
      for key, value in self.__dict__.iteritems()]
18483 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18484 
 
18485 
  def __eq__(self, other):
18486 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18487 
 
18488 
  def __ne__(self, other):
18489 
    return not (self == other)
18490 
 
18491 
class validateDoa_result:
18492 
  """
18493 
  Attributes:
18494 
   - success
18495 
   - ex
18496 
  """
18497 
 
18498 
  thrift_spec = (
18499 
    (0, TType.BOOL, 'success', None, None, ), # 0
18500 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
18501 
  )
18502 
 
18503 
  def __init__(self, success=None, ex=None,):
18504 
    self.success = success
18505 
    self.ex = ex
18506 
 
18507 
  def read(self, iprot):
18508 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18509 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18510 
      return
18511 
    iprot.readStructBegin()
18512 
    while True:
18513 
      (fname, ftype, fid) = iprot.readFieldBegin()
18514 
      if ftype == TType.STOP:
18515 
        break
18516 
      if fid == 0:
18517 
        if ftype == TType.BOOL:
18518 
          self.success = iprot.readBool();
18519 
        else:
18520 
          iprot.skip(ftype)
18521 
      elif fid == 1:
18522 
        if ftype == TType.STRUCT:
18523 
          self.ex = TransactionServiceException()
18524 
          self.ex.read(iprot)
18525 
        else:
18526 
          iprot.skip(ftype)
18527 
      else:
18528 
        iprot.skip(ftype)
18529 
      iprot.readFieldEnd()
18530 
    iprot.readStructEnd()
18531 
 
18532 
  def write(self, oprot):
18533 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18534 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18535 
      return
18536 
    oprot.writeStructBegin('validateDoa_result')
3431 rajveer 18537 
    if self.success is not None:
2591 chandransh 18538 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
18539 
      oprot.writeBool(self.success)
18540 
      oprot.writeFieldEnd()
3431 rajveer 18541 
    if self.ex is not None:
2591 chandransh 18542 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
18543 
      self.ex.write(oprot)
18544 
      oprot.writeFieldEnd()
18545 
    oprot.writeFieldStop()
18546 
    oprot.writeStructEnd()
18547 
 
3431 rajveer 18548 
  def validate(self):
18549 
    return
18550 
 
18551 
 
2591 chandransh 18552 
  def __repr__(self):
18553 
    L = ['%s=%r' % (key, value)
18554 
      for key, value in self.__dict__.iteritems()]
18555 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18556 
 
18557 
  def __eq__(self, other):
18558 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18559 
 
18560 
  def __ne__(self, other):
18561 
    return not (self == other)
18562 
 
4495 rajveer 18563 
class validateReturnProduct_args:
18564 
  """
18565 
  Attributes:
18566 
   - orderId
18567 
   - isUsable
18568 
  """
18569 
 
18570 
  thrift_spec = (
18571 
    None, # 0
18572 
    (1, TType.I64, 'orderId', None, None, ), # 1
18573 
    (2, TType.BOOL, 'isUsable', None, None, ), # 2
18574 
  )
18575 
 
18576 
  def __init__(self, orderId=None, isUsable=None,):
18577 
    self.orderId = orderId
18578 
    self.isUsable = isUsable
18579 
 
18580 
  def read(self, iprot):
18581 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18582 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18583 
      return
18584 
    iprot.readStructBegin()
18585 
    while True:
18586 
      (fname, ftype, fid) = iprot.readFieldBegin()
18587 
      if ftype == TType.STOP:
18588 
        break
18589 
      if fid == 1:
18590 
        if ftype == TType.I64:
18591 
          self.orderId = iprot.readI64();
18592 
        else:
18593 
          iprot.skip(ftype)
18594 
      elif fid == 2:
18595 
        if ftype == TType.BOOL:
18596 
          self.isUsable = iprot.readBool();
18597 
        else:
18598 
          iprot.skip(ftype)
18599 
      else:
18600 
        iprot.skip(ftype)
18601 
      iprot.readFieldEnd()
18602 
    iprot.readStructEnd()
18603 
 
18604 
  def write(self, oprot):
18605 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18606 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18607 
      return
18608 
    oprot.writeStructBegin('validateReturnProduct_args')
18609 
    if self.orderId is not None:
18610 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
18611 
      oprot.writeI64(self.orderId)
18612 
      oprot.writeFieldEnd()
18613 
    if self.isUsable is not None:
18614 
      oprot.writeFieldBegin('isUsable', TType.BOOL, 2)
18615 
      oprot.writeBool(self.isUsable)
18616 
      oprot.writeFieldEnd()
18617 
    oprot.writeFieldStop()
18618 
    oprot.writeStructEnd()
18619 
 
18620 
  def validate(self):
18621 
    return
18622 
 
18623 
 
18624 
  def __repr__(self):
18625 
    L = ['%s=%r' % (key, value)
18626 
      for key, value in self.__dict__.iteritems()]
18627 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18628 
 
18629 
  def __eq__(self, other):
18630 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18631 
 
18632 
  def __ne__(self, other):
18633 
    return not (self == other)
18634 
 
18635 
class validateReturnProduct_result:
18636 
  """
18637 
  Attributes:
18638 
   - success
18639 
   - ex
18640 
  """
18641 
 
18642 
  thrift_spec = (
18643 
    (0, TType.BOOL, 'success', None, None, ), # 0
18644 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
18645 
  )
18646 
 
18647 
  def __init__(self, success=None, ex=None,):
18648 
    self.success = success
18649 
    self.ex = ex
18650 
 
18651 
  def read(self, iprot):
18652 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18653 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18654 
      return
18655 
    iprot.readStructBegin()
18656 
    while True:
18657 
      (fname, ftype, fid) = iprot.readFieldBegin()
18658 
      if ftype == TType.STOP:
18659 
        break
18660 
      if fid == 0:
18661 
        if ftype == TType.BOOL:
18662 
          self.success = iprot.readBool();
18663 
        else:
18664 
          iprot.skip(ftype)
18665 
      elif fid == 1:
18666 
        if ftype == TType.STRUCT:
18667 
          self.ex = TransactionServiceException()
18668 
          self.ex.read(iprot)
18669 
        else:
18670 
          iprot.skip(ftype)
18671 
      else:
18672 
        iprot.skip(ftype)
18673 
      iprot.readFieldEnd()
18674 
    iprot.readStructEnd()
18675 
 
18676 
  def write(self, oprot):
18677 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18678 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18679 
      return
18680 
    oprot.writeStructBegin('validateReturnProduct_result')
18681 
    if self.success is not None:
18682 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
18683 
      oprot.writeBool(self.success)
18684 
      oprot.writeFieldEnd()
18685 
    if self.ex is not None:
18686 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
18687 
      self.ex.write(oprot)
18688 
      oprot.writeFieldEnd()
18689 
    oprot.writeFieldStop()
18690 
    oprot.writeStructEnd()
18691 
 
18692 
  def validate(self):
18693 
    return
18694 
 
18695 
 
18696 
  def __repr__(self):
18697 
    L = ['%s=%r' % (key, value)
18698 
      for key, value in self.__dict__.iteritems()]
18699 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18700 
 
18701 
  def __eq__(self, other):
18702 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18703 
 
18704 
  def __ne__(self, other):
18705 
    return not (self == other)
18706 
 
2616 chandransh 18707 
class reshipOrder_args:
18708 
  """
18709 
  Attributes:
18710 
   - orderId
18711 
  """
2591 chandransh 18712 
 
2616 chandransh 18713 
  thrift_spec = (
18714 
    None, # 0
18715 
    (1, TType.I64, 'orderId', None, None, ), # 1
18716 
  )
18717 
 
18718 
  def __init__(self, orderId=None,):
18719 
    self.orderId = orderId
18720 
 
18721 
  def read(self, iprot):
18722 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18723 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18724 
      return
18725 
    iprot.readStructBegin()
18726 
    while True:
18727 
      (fname, ftype, fid) = iprot.readFieldBegin()
18728 
      if ftype == TType.STOP:
18729 
        break
18730 
      if fid == 1:
18731 
        if ftype == TType.I64:
18732 
          self.orderId = iprot.readI64();
18733 
        else:
18734 
          iprot.skip(ftype)
18735 
      else:
18736 
        iprot.skip(ftype)
18737 
      iprot.readFieldEnd()
18738 
    iprot.readStructEnd()
18739 
 
18740 
  def write(self, oprot):
18741 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18742 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18743 
      return
18744 
    oprot.writeStructBegin('reshipOrder_args')
3431 rajveer 18745 
    if self.orderId is not None:
2616 chandransh 18746 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
18747 
      oprot.writeI64(self.orderId)
18748 
      oprot.writeFieldEnd()
18749 
    oprot.writeFieldStop()
18750 
    oprot.writeStructEnd()
18751 
 
3431 rajveer 18752 
  def validate(self):
18753 
    return
18754 
 
18755 
 
2616 chandransh 18756 
  def __repr__(self):
18757 
    L = ['%s=%r' % (key, value)
18758 
      for key, value in self.__dict__.iteritems()]
18759 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18760 
 
18761 
  def __eq__(self, other):
18762 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18763 
 
18764 
  def __ne__(self, other):
18765 
    return not (self == other)
18766 
 
18767 
class reshipOrder_result:
18768 
  """
18769 
  Attributes:
18770 
   - success
18771 
   - ex
18772 
  """
18773 
 
18774 
  thrift_spec = (
18775 
    (0, TType.I64, 'success', None, None, ), # 0
18776 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
18777 
  )
18778 
 
18779 
  def __init__(self, success=None, ex=None,):
18780 
    self.success = success
18781 
    self.ex = ex
18782 
 
18783 
  def read(self, iprot):
18784 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18785 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18786 
      return
18787 
    iprot.readStructBegin()
18788 
    while True:
18789 
      (fname, ftype, fid) = iprot.readFieldBegin()
18790 
      if ftype == TType.STOP:
18791 
        break
18792 
      if fid == 0:
18793 
        if ftype == TType.I64:
18794 
          self.success = iprot.readI64();
18795 
        else:
18796 
          iprot.skip(ftype)
18797 
      elif fid == 1:
18798 
        if ftype == TType.STRUCT:
18799 
          self.ex = TransactionServiceException()
18800 
          self.ex.read(iprot)
18801 
        else:
18802 
          iprot.skip(ftype)
18803 
      else:
18804 
        iprot.skip(ftype)
18805 
      iprot.readFieldEnd()
18806 
    iprot.readStructEnd()
18807 
 
18808 
  def write(self, oprot):
18809 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18810 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18811 
      return
18812 
    oprot.writeStructBegin('reshipOrder_result')
3431 rajveer 18813 
    if self.success is not None:
2616 chandransh 18814 
      oprot.writeFieldBegin('success', TType.I64, 0)
18815 
      oprot.writeI64(self.success)
18816 
      oprot.writeFieldEnd()
3431 rajveer 18817 
    if self.ex is not None:
2616 chandransh 18818 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
18819 
      self.ex.write(oprot)
18820 
      oprot.writeFieldEnd()
18821 
    oprot.writeFieldStop()
18822 
    oprot.writeStructEnd()
18823 
 
3431 rajveer 18824 
  def validate(self):
18825 
    return
18826 
 
18827 
 
2616 chandransh 18828 
  def __repr__(self):
18829 
    L = ['%s=%r' % (key, value)
18830 
      for key, value in self.__dict__.iteritems()]
18831 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18832 
 
18833 
  def __eq__(self, other):
18834 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18835 
 
18836 
  def __ne__(self, other):
18837 
    return not (self == other)
18838 
 
18839 
class refundOrder_args:
18840 
  """
18841 
  Attributes:
18842 
   - orderId
3226 chandransh 18843 
   - refundedBy
18844 
   - reason
2616 chandransh 18845 
  """
18846 
 
18847 
  thrift_spec = (
18848 
    None, # 0
18849 
    (1, TType.I64, 'orderId', None, None, ), # 1
3226 chandransh 18850 
    (2, TType.STRING, 'refundedBy', None, None, ), # 2
18851 
    (3, TType.STRING, 'reason', None, None, ), # 3
2616 chandransh 18852 
  )
18853 
 
3226 chandransh 18854 
  def __init__(self, orderId=None, refundedBy=None, reason=None,):
2616 chandransh 18855 
    self.orderId = orderId
3226 chandransh 18856 
    self.refundedBy = refundedBy
18857 
    self.reason = reason
2616 chandransh 18858 
 
18859 
  def read(self, iprot):
18860 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18861 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18862 
      return
18863 
    iprot.readStructBegin()
18864 
    while True:
18865 
      (fname, ftype, fid) = iprot.readFieldBegin()
18866 
      if ftype == TType.STOP:
18867 
        break
18868 
      if fid == 1:
18869 
        if ftype == TType.I64:
18870 
          self.orderId = iprot.readI64();
18871 
        else:
18872 
          iprot.skip(ftype)
3226 chandransh 18873 
      elif fid == 2:
18874 
        if ftype == TType.STRING:
18875 
          self.refundedBy = iprot.readString();
18876 
        else:
18877 
          iprot.skip(ftype)
18878 
      elif fid == 3:
18879 
        if ftype == TType.STRING:
18880 
          self.reason = iprot.readString();
18881 
        else:
18882 
          iprot.skip(ftype)
2616 chandransh 18883 
      else:
18884 
        iprot.skip(ftype)
18885 
      iprot.readFieldEnd()
18886 
    iprot.readStructEnd()
18887 
 
18888 
  def write(self, oprot):
18889 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18890 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18891 
      return
18892 
    oprot.writeStructBegin('refundOrder_args')
3431 rajveer 18893 
    if self.orderId is not None:
2616 chandransh 18894 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
18895 
      oprot.writeI64(self.orderId)
18896 
      oprot.writeFieldEnd()
3431 rajveer 18897 
    if self.refundedBy is not None:
3226 chandransh 18898 
      oprot.writeFieldBegin('refundedBy', TType.STRING, 2)
18899 
      oprot.writeString(self.refundedBy)
18900 
      oprot.writeFieldEnd()
3431 rajveer 18901 
    if self.reason is not None:
3226 chandransh 18902 
      oprot.writeFieldBegin('reason', TType.STRING, 3)
18903 
      oprot.writeString(self.reason)
18904 
      oprot.writeFieldEnd()
2616 chandransh 18905 
    oprot.writeFieldStop()
18906 
    oprot.writeStructEnd()
18907 
 
3431 rajveer 18908 
  def validate(self):
18909 
    return
18910 
 
18911 
 
2616 chandransh 18912 
  def __repr__(self):
18913 
    L = ['%s=%r' % (key, value)
18914 
      for key, value in self.__dict__.iteritems()]
18915 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18916 
 
18917 
  def __eq__(self, other):
18918 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18919 
 
18920 
  def __ne__(self, other):
18921 
    return not (self == other)
18922 
 
18923 
class refundOrder_result:
18924 
  """
18925 
  Attributes:
18926 
   - success
18927 
   - ex
18928 
  """
18929 
 
18930 
  thrift_spec = (
18931 
    (0, TType.BOOL, 'success', None, None, ), # 0
18932 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
18933 
  )
18934 
 
18935 
  def __init__(self, success=None, ex=None,):
18936 
    self.success = success
18937 
    self.ex = ex
18938 
 
18939 
  def read(self, iprot):
18940 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18941 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18942 
      return
18943 
    iprot.readStructBegin()
18944 
    while True:
18945 
      (fname, ftype, fid) = iprot.readFieldBegin()
18946 
      if ftype == TType.STOP:
18947 
        break
18948 
      if fid == 0:
18949 
        if ftype == TType.BOOL:
18950 
          self.success = iprot.readBool();
18951 
        else:
18952 
          iprot.skip(ftype)
18953 
      elif fid == 1:
18954 
        if ftype == TType.STRUCT:
18955 
          self.ex = TransactionServiceException()
18956 
          self.ex.read(iprot)
18957 
        else:
18958 
          iprot.skip(ftype)
18959 
      else:
18960 
        iprot.skip(ftype)
18961 
      iprot.readFieldEnd()
18962 
    iprot.readStructEnd()
18963 
 
18964 
  def write(self, oprot):
18965 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18966 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18967 
      return
18968 
    oprot.writeStructBegin('refundOrder_result')
3431 rajveer 18969 
    if self.success is not None:
2616 chandransh 18970 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
18971 
      oprot.writeBool(self.success)
18972 
      oprot.writeFieldEnd()
3431 rajveer 18973 
    if self.ex is not None:
2616 chandransh 18974 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
18975 
      self.ex.write(oprot)
18976 
      oprot.writeFieldEnd()
18977 
    oprot.writeFieldStop()
18978 
    oprot.writeStructEnd()
18979 
 
3431 rajveer 18980 
  def validate(self):
18981 
    return
18982 
 
18983 
 
2616 chandransh 18984 
  def __repr__(self):
18985 
    L = ['%s=%r' % (key, value)
18986 
      for key, value in self.__dict__.iteritems()]
18987 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18988 
 
18989 
  def __eq__(self, other):
18990 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18991 
 
18992 
  def __ne__(self, other):
18993 
    return not (self == other)
18994 
 
2690 chandransh 18995 
class getReturnOrders_args:
18996 
  """
18997 
  Attributes:
18998 
   - warehouseId
18999 
   - fromDate
19000 
   - toDate
19001 
  """
2616 chandransh 19002 
 
2690 chandransh 19003 
  thrift_spec = (
19004 
    None, # 0
19005 
    (1, TType.I64, 'warehouseId', None, None, ), # 1
19006 
    (2, TType.I64, 'fromDate', None, None, ), # 2
19007 
    (3, TType.I64, 'toDate', None, None, ), # 3
19008 
  )
19009 
 
19010 
  def __init__(self, warehouseId=None, fromDate=None, toDate=None,):
19011 
    self.warehouseId = warehouseId
19012 
    self.fromDate = fromDate
19013 
    self.toDate = toDate
19014 
 
19015 
  def read(self, iprot):
19016 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19017 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19018 
      return
19019 
    iprot.readStructBegin()
19020 
    while True:
19021 
      (fname, ftype, fid) = iprot.readFieldBegin()
19022 
      if ftype == TType.STOP:
19023 
        break
19024 
      if fid == 1:
19025 
        if ftype == TType.I64:
19026 
          self.warehouseId = iprot.readI64();
19027 
        else:
19028 
          iprot.skip(ftype)
19029 
      elif fid == 2:
19030 
        if ftype == TType.I64:
19031 
          self.fromDate = iprot.readI64();
19032 
        else:
19033 
          iprot.skip(ftype)
19034 
      elif fid == 3:
19035 
        if ftype == TType.I64:
19036 
          self.toDate = iprot.readI64();
19037 
        else:
19038 
          iprot.skip(ftype)
19039 
      else:
19040 
        iprot.skip(ftype)
19041 
      iprot.readFieldEnd()
19042 
    iprot.readStructEnd()
19043 
 
19044 
  def write(self, oprot):
19045 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19046 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19047 
      return
19048 
    oprot.writeStructBegin('getReturnOrders_args')
3431 rajveer 19049 
    if self.warehouseId is not None:
2690 chandransh 19050 
      oprot.writeFieldBegin('warehouseId', TType.I64, 1)
19051 
      oprot.writeI64(self.warehouseId)
19052 
      oprot.writeFieldEnd()
3431 rajveer 19053 
    if self.fromDate is not None:
2690 chandransh 19054 
      oprot.writeFieldBegin('fromDate', TType.I64, 2)
19055 
      oprot.writeI64(self.fromDate)
19056 
      oprot.writeFieldEnd()
3431 rajveer 19057 
    if self.toDate is not None:
2690 chandransh 19058 
      oprot.writeFieldBegin('toDate', TType.I64, 3)
19059 
      oprot.writeI64(self.toDate)
19060 
      oprot.writeFieldEnd()
19061 
    oprot.writeFieldStop()
19062 
    oprot.writeStructEnd()
19063 
 
3431 rajveer 19064 
  def validate(self):
19065 
    return
19066 
 
19067 
 
2690 chandransh 19068 
  def __repr__(self):
19069 
    L = ['%s=%r' % (key, value)
19070 
      for key, value in self.__dict__.iteritems()]
19071 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19072 
 
19073 
  def __eq__(self, other):
19074 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19075 
 
19076 
  def __ne__(self, other):
19077 
    return not (self == other)
19078 
 
19079 
class getReturnOrders_result:
19080 
  """
19081 
  Attributes:
19082 
   - success
19083 
  """
19084 
 
19085 
  thrift_spec = (
19086 
    (0, TType.LIST, 'success', (TType.STRUCT,(ReturnOrder, ReturnOrder.thrift_spec)), None, ), # 0
19087 
  )
19088 
 
19089 
  def __init__(self, success=None,):
19090 
    self.success = success
19091 
 
19092 
  def read(self, iprot):
19093 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19094 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19095 
      return
19096 
    iprot.readStructBegin()
19097 
    while True:
19098 
      (fname, ftype, fid) = iprot.readFieldBegin()
19099 
      if ftype == TType.STOP:
19100 
        break
19101 
      if fid == 0:
19102 
        if ftype == TType.LIST:
19103 
          self.success = []
6188 rajveer 19104 
          (_etype442, _size439) = iprot.readListBegin()
19105 
          for _i443 in xrange(_size439):
19106 
            _elem444 = ReturnOrder()
19107 
            _elem444.read(iprot)
19108 
            self.success.append(_elem444)
2690 chandransh 19109 
          iprot.readListEnd()
19110 
        else:
19111 
          iprot.skip(ftype)
19112 
      else:
19113 
        iprot.skip(ftype)
19114 
      iprot.readFieldEnd()
19115 
    iprot.readStructEnd()
19116 
 
19117 
  def write(self, oprot):
19118 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19119 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19120 
      return
19121 
    oprot.writeStructBegin('getReturnOrders_result')
3431 rajveer 19122 
    if self.success is not None:
2690 chandransh 19123 
      oprot.writeFieldBegin('success', TType.LIST, 0)
19124 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 19125 
      for iter445 in self.success:
19126 
        iter445.write(oprot)
2690 chandransh 19127 
      oprot.writeListEnd()
19128 
      oprot.writeFieldEnd()
19129 
    oprot.writeFieldStop()
19130 
    oprot.writeStructEnd()
19131 
 
3431 rajveer 19132 
  def validate(self):
19133 
    return
19134 
 
19135 
 
2690 chandransh 19136 
  def __repr__(self):
19137 
    L = ['%s=%r' % (key, value)
19138 
      for key, value in self.__dict__.iteritems()]
19139 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19140 
 
19141 
  def __eq__(self, other):
19142 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19143 
 
19144 
  def __ne__(self, other):
19145 
    return not (self == other)
19146 
 
5481 phani.kuma 19147 
class getAllReturnOrders_args:
19148 
  """
19149 
  Attributes:
19150 
   - onlyNotProcessed
19151 
   - fromDate
19152 
   - toDate
19153 
  """
19154 
 
19155 
  thrift_spec = (
19156 
    None, # 0
19157 
    (1, TType.BOOL, 'onlyNotProcessed', None, None, ), # 1
19158 
    (2, TType.I64, 'fromDate', None, None, ), # 2
19159 
    (3, TType.I64, 'toDate', None, None, ), # 3
19160 
  )
19161 
 
19162 
  def __init__(self, onlyNotProcessed=None, fromDate=None, toDate=None,):
19163 
    self.onlyNotProcessed = onlyNotProcessed
19164 
    self.fromDate = fromDate
19165 
    self.toDate = toDate
19166 
 
19167 
  def read(self, iprot):
19168 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19169 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19170 
      return
19171 
    iprot.readStructBegin()
19172 
    while True:
19173 
      (fname, ftype, fid) = iprot.readFieldBegin()
19174 
      if ftype == TType.STOP:
19175 
        break
19176 
      if fid == 1:
19177 
        if ftype == TType.BOOL:
19178 
          self.onlyNotProcessed = iprot.readBool();
19179 
        else:
19180 
          iprot.skip(ftype)
19181 
      elif fid == 2:
19182 
        if ftype == TType.I64:
19183 
          self.fromDate = iprot.readI64();
19184 
        else:
19185 
          iprot.skip(ftype)
19186 
      elif fid == 3:
19187 
        if ftype == TType.I64:
19188 
          self.toDate = iprot.readI64();
19189 
        else:
19190 
          iprot.skip(ftype)
19191 
      else:
19192 
        iprot.skip(ftype)
19193 
      iprot.readFieldEnd()
19194 
    iprot.readStructEnd()
19195 
 
19196 
  def write(self, oprot):
19197 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19198 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19199 
      return
19200 
    oprot.writeStructBegin('getAllReturnOrders_args')
19201 
    if self.onlyNotProcessed is not None:
19202 
      oprot.writeFieldBegin('onlyNotProcessed', TType.BOOL, 1)
19203 
      oprot.writeBool(self.onlyNotProcessed)
19204 
      oprot.writeFieldEnd()
19205 
    if self.fromDate is not None:
19206 
      oprot.writeFieldBegin('fromDate', TType.I64, 2)
19207 
      oprot.writeI64(self.fromDate)
19208 
      oprot.writeFieldEnd()
19209 
    if self.toDate is not None:
19210 
      oprot.writeFieldBegin('toDate', TType.I64, 3)
19211 
      oprot.writeI64(self.toDate)
19212 
      oprot.writeFieldEnd()
19213 
    oprot.writeFieldStop()
19214 
    oprot.writeStructEnd()
19215 
 
19216 
  def validate(self):
19217 
    return
19218 
 
19219 
 
19220 
  def __repr__(self):
19221 
    L = ['%s=%r' % (key, value)
19222 
      for key, value in self.__dict__.iteritems()]
19223 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19224 
 
19225 
  def __eq__(self, other):
19226 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19227 
 
19228 
  def __ne__(self, other):
19229 
    return not (self == other)
19230 
 
19231 
class getAllReturnOrders_result:
19232 
  """
19233 
  Attributes:
19234 
   - success
19235 
  """
19236 
 
19237 
  thrift_spec = (
19238 
    (0, TType.LIST, 'success', (TType.STRUCT,(ReturnOrder, ReturnOrder.thrift_spec)), None, ), # 0
19239 
  )
19240 
 
19241 
  def __init__(self, success=None,):
19242 
    self.success = success
19243 
 
19244 
  def read(self, iprot):
19245 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19246 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19247 
      return
19248 
    iprot.readStructBegin()
19249 
    while True:
19250 
      (fname, ftype, fid) = iprot.readFieldBegin()
19251 
      if ftype == TType.STOP:
19252 
        break
19253 
      if fid == 0:
19254 
        if ftype == TType.LIST:
19255 
          self.success = []
6188 rajveer 19256 
          (_etype449, _size446) = iprot.readListBegin()
19257 
          for _i450 in xrange(_size446):
19258 
            _elem451 = ReturnOrder()
19259 
            _elem451.read(iprot)
19260 
            self.success.append(_elem451)
5481 phani.kuma 19261 
          iprot.readListEnd()
19262 
        else:
19263 
          iprot.skip(ftype)
19264 
      else:
19265 
        iprot.skip(ftype)
19266 
      iprot.readFieldEnd()
19267 
    iprot.readStructEnd()
19268 
 
19269 
  def write(self, oprot):
19270 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19271 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19272 
      return
19273 
    oprot.writeStructBegin('getAllReturnOrders_result')
19274 
    if self.success is not None:
19275 
      oprot.writeFieldBegin('success', TType.LIST, 0)
19276 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 19277 
      for iter452 in self.success:
19278 
        iter452.write(oprot)
5481 phani.kuma 19279 
      oprot.writeListEnd()
19280 
      oprot.writeFieldEnd()
19281 
    oprot.writeFieldStop()
19282 
    oprot.writeStructEnd()
19283 
 
19284 
  def validate(self):
19285 
    return
19286 
 
19287 
 
19288 
  def __repr__(self):
19289 
    L = ['%s=%r' % (key, value)
19290 
      for key, value in self.__dict__.iteritems()]
19291 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19292 
 
19293 
  def __eq__(self, other):
19294 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19295 
 
19296 
  def __ne__(self, other):
19297 
    return not (self == other)
19298 
 
2700 chandransh 19299 
class getReturnOrder_args:
19300 
  """
19301 
  Attributes:
19302 
   - id
19303 
  """
19304 
 
19305 
  thrift_spec = (
19306 
    None, # 0
19307 
    (1, TType.I64, 'id', None, None, ), # 1
19308 
  )
19309 
 
19310 
  def __init__(self, id=None,):
19311 
    self.id = id
19312 
 
19313 
  def read(self, iprot):
19314 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19315 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19316 
      return
19317 
    iprot.readStructBegin()
19318 
    while True:
19319 
      (fname, ftype, fid) = iprot.readFieldBegin()
19320 
      if ftype == TType.STOP:
19321 
        break
19322 
      if fid == 1:
19323 
        if ftype == TType.I64:
19324 
          self.id = iprot.readI64();
19325 
        else:
19326 
          iprot.skip(ftype)
19327 
      else:
19328 
        iprot.skip(ftype)
19329 
      iprot.readFieldEnd()
19330 
    iprot.readStructEnd()
19331 
 
19332 
  def write(self, oprot):
19333 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19334 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19335 
      return
19336 
    oprot.writeStructBegin('getReturnOrder_args')
3431 rajveer 19337 
    if self.id is not None:
2700 chandransh 19338 
      oprot.writeFieldBegin('id', TType.I64, 1)
19339 
      oprot.writeI64(self.id)
19340 
      oprot.writeFieldEnd()
19341 
    oprot.writeFieldStop()
19342 
    oprot.writeStructEnd()
19343 
 
3431 rajveer 19344 
  def validate(self):
19345 
    return
19346 
 
19347 
 
2700 chandransh 19348 
  def __repr__(self):
19349 
    L = ['%s=%r' % (key, value)
19350 
      for key, value in self.__dict__.iteritems()]
19351 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19352 
 
19353 
  def __eq__(self, other):
19354 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19355 
 
19356 
  def __ne__(self, other):
19357 
    return not (self == other)
19358 
 
19359 
class getReturnOrder_result:
19360 
  """
19361 
  Attributes:
19362 
   - success
19363 
   - ex
19364 
  """
19365 
 
19366 
  thrift_spec = (
19367 
    (0, TType.STRUCT, 'success', (ReturnOrder, ReturnOrder.thrift_spec), None, ), # 0
19368 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
19369 
  )
19370 
 
19371 
  def __init__(self, success=None, ex=None,):
19372 
    self.success = success
19373 
    self.ex = ex
19374 
 
19375 
  def read(self, iprot):
19376 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19377 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19378 
      return
19379 
    iprot.readStructBegin()
19380 
    while True:
19381 
      (fname, ftype, fid) = iprot.readFieldBegin()
19382 
      if ftype == TType.STOP:
19383 
        break
19384 
      if fid == 0:
19385 
        if ftype == TType.STRUCT:
19386 
          self.success = ReturnOrder()
19387 
          self.success.read(iprot)
19388 
        else:
19389 
          iprot.skip(ftype)
19390 
      elif fid == 1:
19391 
        if ftype == TType.STRUCT:
19392 
          self.ex = TransactionServiceException()
19393 
          self.ex.read(iprot)
19394 
        else:
19395 
          iprot.skip(ftype)
19396 
      else:
19397 
        iprot.skip(ftype)
19398 
      iprot.readFieldEnd()
19399 
    iprot.readStructEnd()
19400 
 
19401 
  def write(self, oprot):
19402 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19403 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19404 
      return
19405 
    oprot.writeStructBegin('getReturnOrder_result')
3431 rajveer 19406 
    if self.success is not None:
2700 chandransh 19407 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
19408 
      self.success.write(oprot)
19409 
      oprot.writeFieldEnd()
3431 rajveer 19410 
    if self.ex is not None:
2700 chandransh 19411 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
19412 
      self.ex.write(oprot)
19413 
      oprot.writeFieldEnd()
19414 
    oprot.writeFieldStop()
19415 
    oprot.writeStructEnd()
19416 
 
3431 rajveer 19417 
  def validate(self):
19418 
    return
19419 
 
19420 
 
2700 chandransh 19421 
  def __repr__(self):
19422 
    L = ['%s=%r' % (key, value)
19423 
      for key, value in self.__dict__.iteritems()]
19424 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19425 
 
19426 
  def __eq__(self, other):
19427 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19428 
 
19429 
  def __ne__(self, other):
19430 
    return not (self == other)
19431 
 
2690 chandransh 19432 
class processReturn_args:
19433 
  """
19434 
  Attributes:
19435 
   - returnOrderId
19436 
  """
19437 
 
19438 
  thrift_spec = (
19439 
    None, # 0
19440 
    (1, TType.I64, 'returnOrderId', None, None, ), # 1
19441 
  )
19442 
 
19443 
  def __init__(self, returnOrderId=None,):
19444 
    self.returnOrderId = returnOrderId
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 == 1:
19456 
        if ftype == TType.I64:
19457 
          self.returnOrderId = iprot.readI64();
19458 
        else:
19459 
          iprot.skip(ftype)
19460 
      else:
19461 
        iprot.skip(ftype)
19462 
      iprot.readFieldEnd()
19463 
    iprot.readStructEnd()
19464 
 
19465 
  def write(self, oprot):
19466 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19467 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19468 
      return
19469 
    oprot.writeStructBegin('processReturn_args')
3431 rajveer 19470 
    if self.returnOrderId is not None:
2690 chandransh 19471 
      oprot.writeFieldBegin('returnOrderId', TType.I64, 1)
19472 
      oprot.writeI64(self.returnOrderId)
19473 
      oprot.writeFieldEnd()
19474 
    oprot.writeFieldStop()
19475 
    oprot.writeStructEnd()
19476 
 
3431 rajveer 19477 
  def validate(self):
19478 
    return
19479 
 
19480 
 
2690 chandransh 19481 
  def __repr__(self):
19482 
    L = ['%s=%r' % (key, value)
19483 
      for key, value in self.__dict__.iteritems()]
19484 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19485 
 
19486 
  def __eq__(self, other):
19487 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19488 
 
19489 
  def __ne__(self, other):
19490 
    return not (self == other)
19491 
 
19492 
class processReturn_result:
19493 
  """
19494 
  Attributes:
19495 
   - ex
19496 
  """
19497 
 
19498 
  thrift_spec = (
19499 
    None, # 0
19500 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
19501 
  )
19502 
 
19503 
  def __init__(self, ex=None,):
19504 
    self.ex = ex
19505 
 
19506 
  def read(self, iprot):
19507 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19508 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19509 
      return
19510 
    iprot.readStructBegin()
19511 
    while True:
19512 
      (fname, ftype, fid) = iprot.readFieldBegin()
19513 
      if ftype == TType.STOP:
19514 
        break
19515 
      if fid == 1:
19516 
        if ftype == TType.STRUCT:
19517 
          self.ex = TransactionServiceException()
19518 
          self.ex.read(iprot)
19519 
        else:
19520 
          iprot.skip(ftype)
19521 
      else:
19522 
        iprot.skip(ftype)
19523 
      iprot.readFieldEnd()
19524 
    iprot.readStructEnd()
19525 
 
19526 
  def write(self, oprot):
19527 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19528 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19529 
      return
19530 
    oprot.writeStructBegin('processReturn_result')
3431 rajveer 19531 
    if self.ex is not None:
2690 chandransh 19532 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
19533 
      self.ex.write(oprot)
19534 
      oprot.writeFieldEnd()
19535 
    oprot.writeFieldStop()
19536 
    oprot.writeStructEnd()
19537 
 
3431 rajveer 19538 
  def validate(self):
19539 
    return
19540 
 
19541 
 
2690 chandransh 19542 
  def __repr__(self):
19543 
    L = ['%s=%r' % (key, value)
19544 
      for key, value in self.__dict__.iteritems()]
19545 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19546 
 
19547 
  def __eq__(self, other):
19548 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19549 
 
19550 
  def __ne__(self, other):
19551 
    return not (self == other)
19552 
 
3451 chandransh 19553 
class updateWeight_args:
19554 
  """
19555 
  Attributes:
19556 
   - orderId
19557 
   - weight
19558 
  """
19559 
 
19560 
  thrift_spec = (
19561 
    None, # 0
19562 
    (1, TType.I64, 'orderId', None, None, ), # 1
19563 
    (2, TType.DOUBLE, 'weight', None, None, ), # 2
19564 
  )
19565 
 
19566 
  def __init__(self, orderId=None, weight=None,):
19567 
    self.orderId = orderId
19568 
    self.weight = weight
19569 
 
19570 
  def read(self, iprot):
19571 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19572 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19573 
      return
19574 
    iprot.readStructBegin()
19575 
    while True:
19576 
      (fname, ftype, fid) = iprot.readFieldBegin()
19577 
      if ftype == TType.STOP:
19578 
        break
19579 
      if fid == 1:
19580 
        if ftype == TType.I64:
19581 
          self.orderId = iprot.readI64();
19582 
        else:
19583 
          iprot.skip(ftype)
19584 
      elif fid == 2:
19585 
        if ftype == TType.DOUBLE:
19586 
          self.weight = iprot.readDouble();
19587 
        else:
19588 
          iprot.skip(ftype)
19589 
      else:
19590 
        iprot.skip(ftype)
19591 
      iprot.readFieldEnd()
19592 
    iprot.readStructEnd()
19593 
 
19594 
  def write(self, oprot):
19595 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19596 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19597 
      return
19598 
    oprot.writeStructBegin('updateWeight_args')
19599 
    if self.orderId is not None:
19600 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
19601 
      oprot.writeI64(self.orderId)
19602 
      oprot.writeFieldEnd()
19603 
    if self.weight is not None:
19604 
      oprot.writeFieldBegin('weight', TType.DOUBLE, 2)
19605 
      oprot.writeDouble(self.weight)
19606 
      oprot.writeFieldEnd()
19607 
    oprot.writeFieldStop()
19608 
    oprot.writeStructEnd()
19609 
 
19610 
  def validate(self):
19611 
    return
19612 
 
19613 
 
19614 
  def __repr__(self):
19615 
    L = ['%s=%r' % (key, value)
19616 
      for key, value in self.__dict__.iteritems()]
19617 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19618 
 
19619 
  def __eq__(self, other):
19620 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19621 
 
19622 
  def __ne__(self, other):
19623 
    return not (self == other)
19624 
 
19625 
class updateWeight_result:
19626 
  """
19627 
  Attributes:
19628 
   - success
19629 
   - ex
19630 
  """
19631 
 
19632 
  thrift_spec = (
19633 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
19634 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
19635 
  )
19636 
 
19637 
  def __init__(self, success=None, ex=None,):
19638 
    self.success = success
19639 
    self.ex = ex
19640 
 
19641 
  def read(self, iprot):
19642 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19643 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19644 
      return
19645 
    iprot.readStructBegin()
19646 
    while True:
19647 
      (fname, ftype, fid) = iprot.readFieldBegin()
19648 
      if ftype == TType.STOP:
19649 
        break
19650 
      if fid == 0:
19651 
        if ftype == TType.STRUCT:
19652 
          self.success = Order()
19653 
          self.success.read(iprot)
19654 
        else:
19655 
          iprot.skip(ftype)
19656 
      elif fid == 1:
19657 
        if ftype == TType.STRUCT:
19658 
          self.ex = TransactionServiceException()
19659 
          self.ex.read(iprot)
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('updateWeight_result')
19672 
    if self.success is not None:
19673 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
19674 
      self.success.write(oprot)
19675 
      oprot.writeFieldEnd()
19676 
    if self.ex is not None:
19677 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
19678 
      self.ex.write(oprot)
19679 
      oprot.writeFieldEnd()
19680 
    oprot.writeFieldStop()
19681 
    oprot.writeStructEnd()
19682 
 
19683 
  def validate(self):
19684 
    return
19685 
 
19686 
 
19687 
  def __repr__(self):
19688 
    L = ['%s=%r' % (key, value)
19689 
      for key, value in self.__dict__.iteritems()]
19690 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19691 
 
19692 
  def __eq__(self, other):
19693 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19694 
 
19695 
  def __ne__(self, other):
19696 
    return not (self == other)
3469 chandransh 19697 
 
19698 
class changeItem_args:
19699 
  """
19700 
  Attributes:
19701 
   - orderId
19702 
   - itemId
19703 
  """
19704 
 
19705 
  thrift_spec = (
19706 
    None, # 0
19707 
    (1, TType.I64, 'orderId', None, None, ), # 1
19708 
    (2, TType.I64, 'itemId', None, None, ), # 2
19709 
  )
19710 
 
19711 
  def __init__(self, orderId=None, itemId=None,):
19712 
    self.orderId = orderId
19713 
    self.itemId = itemId
19714 
 
19715 
  def read(self, iprot):
19716 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19717 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19718 
      return
19719 
    iprot.readStructBegin()
19720 
    while True:
19721 
      (fname, ftype, fid) = iprot.readFieldBegin()
19722 
      if ftype == TType.STOP:
19723 
        break
19724 
      if fid == 1:
19725 
        if ftype == TType.I64:
19726 
          self.orderId = iprot.readI64();
19727 
        else:
19728 
          iprot.skip(ftype)
19729 
      elif fid == 2:
19730 
        if ftype == TType.I64:
19731 
          self.itemId = iprot.readI64();
19732 
        else:
19733 
          iprot.skip(ftype)
19734 
      else:
19735 
        iprot.skip(ftype)
19736 
      iprot.readFieldEnd()
19737 
    iprot.readStructEnd()
19738 
 
19739 
  def write(self, oprot):
19740 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19741 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19742 
      return
19743 
    oprot.writeStructBegin('changeItem_args')
19744 
    if self.orderId is not None:
19745 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
19746 
      oprot.writeI64(self.orderId)
19747 
      oprot.writeFieldEnd()
19748 
    if self.itemId is not None:
19749 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
19750 
      oprot.writeI64(self.itemId)
19751 
      oprot.writeFieldEnd()
19752 
    oprot.writeFieldStop()
19753 
    oprot.writeStructEnd()
19754 
 
19755 
  def validate(self):
19756 
    return
19757 
 
19758 
 
19759 
  def __repr__(self):
19760 
    L = ['%s=%r' % (key, value)
19761 
      for key, value in self.__dict__.iteritems()]
19762 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19763 
 
19764 
  def __eq__(self, other):
19765 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19766 
 
19767 
  def __ne__(self, other):
19768 
    return not (self == other)
19769 
 
19770 
class changeItem_result:
19771 
  """
19772 
  Attributes:
19773 
   - success
19774 
   - ex
19775 
  """
19776 
 
19777 
  thrift_spec = (
19778 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
19779 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
19780 
  )
19781 
 
19782 
  def __init__(self, success=None, ex=None,):
19783 
    self.success = success
19784 
    self.ex = ex
19785 
 
19786 
  def read(self, iprot):
19787 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19788 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19789 
      return
19790 
    iprot.readStructBegin()
19791 
    while True:
19792 
      (fname, ftype, fid) = iprot.readFieldBegin()
19793 
      if ftype == TType.STOP:
19794 
        break
19795 
      if fid == 0:
19796 
        if ftype == TType.STRUCT:
19797 
          self.success = Order()
19798 
          self.success.read(iprot)
19799 
        else:
19800 
          iprot.skip(ftype)
19801 
      elif fid == 1:
19802 
        if ftype == TType.STRUCT:
19803 
          self.ex = TransactionServiceException()
19804 
          self.ex.read(iprot)
19805 
        else:
19806 
          iprot.skip(ftype)
19807 
      else:
19808 
        iprot.skip(ftype)
19809 
      iprot.readFieldEnd()
19810 
    iprot.readStructEnd()
19811 
 
19812 
  def write(self, oprot):
19813 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19814 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19815 
      return
19816 
    oprot.writeStructBegin('changeItem_result')
19817 
    if self.success is not None:
19818 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
19819 
      self.success.write(oprot)
19820 
      oprot.writeFieldEnd()
19821 
    if self.ex is not None:
19822 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
19823 
      self.ex.write(oprot)
19824 
      oprot.writeFieldEnd()
19825 
    oprot.writeFieldStop()
19826 
    oprot.writeStructEnd()
19827 
 
19828 
  def validate(self):
19829 
    return
19830 
 
19831 
 
19832 
  def __repr__(self):
19833 
    L = ['%s=%r' % (key, value)
19834 
      for key, value in self.__dict__.iteritems()]
19835 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19836 
 
19837 
  def __eq__(self, other):
19838 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19839 
 
19840 
  def __ne__(self, other):
19841 
    return not (self == other)
19842 
 
19843 
class shiftToWarehouse_args:
19844 
  """
19845 
  Attributes:
19846 
   - orderId
19847 
   - warehouseId
19848 
  """
19849 
 
19850 
  thrift_spec = (
19851 
    None, # 0
19852 
    (1, TType.I64, 'orderId', None, None, ), # 1
19853 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
19854 
  )
19855 
 
19856 
  def __init__(self, orderId=None, warehouseId=None,):
19857 
    self.orderId = orderId
19858 
    self.warehouseId = warehouseId
19859 
 
19860 
  def read(self, iprot):
19861 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19862 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19863 
      return
19864 
    iprot.readStructBegin()
19865 
    while True:
19866 
      (fname, ftype, fid) = iprot.readFieldBegin()
19867 
      if ftype == TType.STOP:
19868 
        break
19869 
      if fid == 1:
19870 
        if ftype == TType.I64:
19871 
          self.orderId = iprot.readI64();
19872 
        else:
19873 
          iprot.skip(ftype)
19874 
      elif fid == 2:
19875 
        if ftype == TType.I64:
19876 
          self.warehouseId = iprot.readI64();
19877 
        else:
19878 
          iprot.skip(ftype)
19879 
      else:
19880 
        iprot.skip(ftype)
19881 
      iprot.readFieldEnd()
19882 
    iprot.readStructEnd()
19883 
 
19884 
  def write(self, oprot):
19885 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19886 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19887 
      return
19888 
    oprot.writeStructBegin('shiftToWarehouse_args')
19889 
    if self.orderId is not None:
19890 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
19891 
      oprot.writeI64(self.orderId)
19892 
      oprot.writeFieldEnd()
19893 
    if self.warehouseId is not None:
19894 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
19895 
      oprot.writeI64(self.warehouseId)
19896 
      oprot.writeFieldEnd()
19897 
    oprot.writeFieldStop()
19898 
    oprot.writeStructEnd()
19899 
 
19900 
  def validate(self):
19901 
    return
19902 
 
19903 
 
19904 
  def __repr__(self):
19905 
    L = ['%s=%r' % (key, value)
19906 
      for key, value in self.__dict__.iteritems()]
19907 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19908 
 
19909 
  def __eq__(self, other):
19910 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19911 
 
19912 
  def __ne__(self, other):
19913 
    return not (self == other)
19914 
 
19915 
class shiftToWarehouse_result:
19916 
  """
19917 
  Attributes:
19918 
   - success
19919 
   - ex
19920 
  """
19921 
 
19922 
  thrift_spec = (
19923 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
19924 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
19925 
  )
19926 
 
19927 
  def __init__(self, success=None, ex=None,):
19928 
    self.success = success
19929 
    self.ex = ex
19930 
 
19931 
  def read(self, iprot):
19932 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19933 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19934 
      return
19935 
    iprot.readStructBegin()
19936 
    while True:
19937 
      (fname, ftype, fid) = iprot.readFieldBegin()
19938 
      if ftype == TType.STOP:
19939 
        break
19940 
      if fid == 0:
19941 
        if ftype == TType.STRUCT:
19942 
          self.success = Order()
19943 
          self.success.read(iprot)
19944 
        else:
19945 
          iprot.skip(ftype)
19946 
      elif fid == 1:
19947 
        if ftype == TType.STRUCT:
19948 
          self.ex = TransactionServiceException()
19949 
          self.ex.read(iprot)
19950 
        else:
19951 
          iprot.skip(ftype)
19952 
      else:
19953 
        iprot.skip(ftype)
19954 
      iprot.readFieldEnd()
19955 
    iprot.readStructEnd()
19956 
 
19957 
  def write(self, oprot):
19958 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19959 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19960 
      return
19961 
    oprot.writeStructBegin('shiftToWarehouse_result')
19962 
    if self.success is not None:
19963 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
19964 
      self.success.write(oprot)
19965 
      oprot.writeFieldEnd()
19966 
    if self.ex is not None:
19967 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
19968 
      self.ex.write(oprot)
19969 
      oprot.writeFieldEnd()
19970 
    oprot.writeFieldStop()
19971 
    oprot.writeStructEnd()
19972 
 
19973 
  def validate(self):
19974 
    return
19975 
 
19976 
 
19977 
  def __repr__(self):
19978 
    L = ['%s=%r' % (key, value)
19979 
      for key, value in self.__dict__.iteritems()]
19980 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19981 
 
19982 
  def __eq__(self, other):
19983 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19984 
 
19985 
  def __ne__(self, other):
19986 
    return not (self == other)
3553 chandransh 19987 
 
19988 
class addDelayReason_args:
19989 
  """
19990 
  Attributes:
19991 
   - orderId
19992 
   - delayReason
3986 chandransh 19993 
   - furtherDelay
4647 rajveer 19994 
   - delayReasonText
3553 chandransh 19995 
  """
19996 
 
19997 
  thrift_spec = (
19998 
    None, # 0
19999 
    (1, TType.I64, 'orderId', None, None, ), # 1
20000 
    (2, TType.I32, 'delayReason', None, None, ), # 2
3986 chandransh 20001 
    (3, TType.I64, 'furtherDelay', None, None, ), # 3
4647 rajveer 20002 
    (4, TType.STRING, 'delayReasonText', None, None, ), # 4
3553 chandransh 20003 
  )
20004 
 
4647 rajveer 20005 
  def __init__(self, orderId=None, delayReason=None, furtherDelay=None, delayReasonText=None,):
3553 chandransh 20006 
    self.orderId = orderId
20007 
    self.delayReason = delayReason
3986 chandransh 20008 
    self.furtherDelay = furtherDelay
4647 rajveer 20009 
    self.delayReasonText = delayReasonText
3553 chandransh 20010 
 
20011 
  def read(self, iprot):
20012 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20013 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20014 
      return
20015 
    iprot.readStructBegin()
20016 
    while True:
20017 
      (fname, ftype, fid) = iprot.readFieldBegin()
20018 
      if ftype == TType.STOP:
20019 
        break
20020 
      if fid == 1:
20021 
        if ftype == TType.I64:
20022 
          self.orderId = iprot.readI64();
20023 
        else:
20024 
          iprot.skip(ftype)
20025 
      elif fid == 2:
20026 
        if ftype == TType.I32:
20027 
          self.delayReason = iprot.readI32();
20028 
        else:
20029 
          iprot.skip(ftype)
3986 chandransh 20030 
      elif fid == 3:
20031 
        if ftype == TType.I64:
20032 
          self.furtherDelay = iprot.readI64();
20033 
        else:
20034 
          iprot.skip(ftype)
4647 rajveer 20035 
      elif fid == 4:
20036 
        if ftype == TType.STRING:
20037 
          self.delayReasonText = iprot.readString();
20038 
        else:
20039 
          iprot.skip(ftype)
3553 chandransh 20040 
      else:
20041 
        iprot.skip(ftype)
20042 
      iprot.readFieldEnd()
20043 
    iprot.readStructEnd()
20044 
 
20045 
  def write(self, oprot):
20046 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20047 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20048 
      return
20049 
    oprot.writeStructBegin('addDelayReason_args')
20050 
    if self.orderId is not None:
20051 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
20052 
      oprot.writeI64(self.orderId)
20053 
      oprot.writeFieldEnd()
20054 
    if self.delayReason is not None:
20055 
      oprot.writeFieldBegin('delayReason', TType.I32, 2)
20056 
      oprot.writeI32(self.delayReason)
20057 
      oprot.writeFieldEnd()
3986 chandransh 20058 
    if self.furtherDelay is not None:
20059 
      oprot.writeFieldBegin('furtherDelay', TType.I64, 3)
20060 
      oprot.writeI64(self.furtherDelay)
20061 
      oprot.writeFieldEnd()
4647 rajveer 20062 
    if self.delayReasonText is not None:
20063 
      oprot.writeFieldBegin('delayReasonText', TType.STRING, 4)
20064 
      oprot.writeString(self.delayReasonText)
20065 
      oprot.writeFieldEnd()
3553 chandransh 20066 
    oprot.writeFieldStop()
20067 
    oprot.writeStructEnd()
20068 
 
20069 
  def validate(self):
20070 
    return
20071 
 
20072 
 
20073 
  def __repr__(self):
20074 
    L = ['%s=%r' % (key, value)
20075 
      for key, value in self.__dict__.iteritems()]
20076 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20077 
 
20078 
  def __eq__(self, other):
20079 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20080 
 
20081 
  def __ne__(self, other):
20082 
    return not (self == other)
20083 
 
20084 
class addDelayReason_result:
20085 
  """
20086 
  Attributes:
20087 
   - success
20088 
   - ex
20089 
  """
20090 
 
20091 
  thrift_spec = (
20092 
    (0, TType.BOOL, 'success', None, None, ), # 0
20093 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
20094 
  )
20095 
 
20096 
  def __init__(self, success=None, ex=None,):
20097 
    self.success = success
20098 
    self.ex = ex
20099 
 
20100 
  def read(self, iprot):
20101 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20102 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20103 
      return
20104 
    iprot.readStructBegin()
20105 
    while True:
20106 
      (fname, ftype, fid) = iprot.readFieldBegin()
20107 
      if ftype == TType.STOP:
20108 
        break
20109 
      if fid == 0:
20110 
        if ftype == TType.BOOL:
20111 
          self.success = iprot.readBool();
20112 
        else:
20113 
          iprot.skip(ftype)
20114 
      elif fid == 1:
20115 
        if ftype == TType.STRUCT:
20116 
          self.ex = TransactionServiceException()
20117 
          self.ex.read(iprot)
20118 
        else:
20119 
          iprot.skip(ftype)
20120 
      else:
20121 
        iprot.skip(ftype)
20122 
      iprot.readFieldEnd()
20123 
    iprot.readStructEnd()
20124 
 
20125 
  def write(self, oprot):
20126 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20127 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20128 
      return
20129 
    oprot.writeStructBegin('addDelayReason_result')
20130 
    if self.success is not None:
20131 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
20132 
      oprot.writeBool(self.success)
20133 
      oprot.writeFieldEnd()
20134 
    if self.ex is not None:
20135 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
20136 
      self.ex.write(oprot)
20137 
      oprot.writeFieldEnd()
20138 
    oprot.writeFieldStop()
20139 
    oprot.writeStructEnd()
20140 
 
20141 
  def validate(self):
20142 
    return
20143 
 
20144 
 
20145 
  def __repr__(self):
20146 
    L = ['%s=%r' % (key, value)
20147 
      for key, value in self.__dict__.iteritems()]
20148 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20149 
 
20150 
  def __eq__(self, other):
20151 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20152 
 
20153 
  def __ne__(self, other):
20154 
    return not (self == other)
3956 chandransh 20155 
 
20156 
class reconcileCodCollection_args:
20157 
  """
20158 
  Attributes:
20159 
   - collectedAmountMap
20160 
   - xferBy
20161 
   - xferTxnId
20162 
   - xferDate
20163 
  """
20164 
 
20165 
  thrift_spec = (
20166 
    None, # 0
20167 
    (1, TType.MAP, 'collectedAmountMap', (TType.STRING,None,TType.DOUBLE,None), None, ), # 1
20168 
    (2, TType.STRING, 'xferBy', None, None, ), # 2
20169 
    (3, TType.STRING, 'xferTxnId', None, None, ), # 3
20170 
    (4, TType.I64, 'xferDate', None, None, ), # 4
20171 
  )
20172 
 
20173 
  def __init__(self, collectedAmountMap=None, xferBy=None, xferTxnId=None, xferDate=None,):
20174 
    self.collectedAmountMap = collectedAmountMap
20175 
    self.xferBy = xferBy
20176 
    self.xferTxnId = xferTxnId
20177 
    self.xferDate = xferDate
20178 
 
20179 
  def read(self, iprot):
20180 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20181 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20182 
      return
20183 
    iprot.readStructBegin()
20184 
    while True:
20185 
      (fname, ftype, fid) = iprot.readFieldBegin()
20186 
      if ftype == TType.STOP:
20187 
        break
20188 
      if fid == 1:
20189 
        if ftype == TType.MAP:
20190 
          self.collectedAmountMap = {}
6188 rajveer 20191 
          (_ktype454, _vtype455, _size453 ) = iprot.readMapBegin()
20192 
          for _i457 in xrange(_size453):
20193 
            _key458 = iprot.readString();
20194 
            _val459 = iprot.readDouble();
20195 
            self.collectedAmountMap[_key458] = _val459
3956 chandransh 20196 
          iprot.readMapEnd()
20197 
        else:
20198 
          iprot.skip(ftype)
20199 
      elif fid == 2:
20200 
        if ftype == TType.STRING:
20201 
          self.xferBy = iprot.readString();
20202 
        else:
20203 
          iprot.skip(ftype)
20204 
      elif fid == 3:
20205 
        if ftype == TType.STRING:
20206 
          self.xferTxnId = iprot.readString();
20207 
        else:
20208 
          iprot.skip(ftype)
20209 
      elif fid == 4:
20210 
        if ftype == TType.I64:
20211 
          self.xferDate = iprot.readI64();
20212 
        else:
20213 
          iprot.skip(ftype)
20214 
      else:
20215 
        iprot.skip(ftype)
20216 
      iprot.readFieldEnd()
20217 
    iprot.readStructEnd()
20218 
 
20219 
  def write(self, oprot):
20220 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20221 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20222 
      return
20223 
    oprot.writeStructBegin('reconcileCodCollection_args')
20224 
    if self.collectedAmountMap is not None:
20225 
      oprot.writeFieldBegin('collectedAmountMap', TType.MAP, 1)
20226 
      oprot.writeMapBegin(TType.STRING, TType.DOUBLE, len(self.collectedAmountMap))
6188 rajveer 20227 
      for kiter460,viter461 in self.collectedAmountMap.items():
20228 
        oprot.writeString(kiter460)
20229 
        oprot.writeDouble(viter461)
3956 chandransh 20230 
      oprot.writeMapEnd()
20231 
      oprot.writeFieldEnd()
20232 
    if self.xferBy is not None:
20233 
      oprot.writeFieldBegin('xferBy', TType.STRING, 2)
20234 
      oprot.writeString(self.xferBy)
20235 
      oprot.writeFieldEnd()
20236 
    if self.xferTxnId is not None:
20237 
      oprot.writeFieldBegin('xferTxnId', TType.STRING, 3)
20238 
      oprot.writeString(self.xferTxnId)
20239 
      oprot.writeFieldEnd()
20240 
    if self.xferDate is not None:
20241 
      oprot.writeFieldBegin('xferDate', TType.I64, 4)
20242 
      oprot.writeI64(self.xferDate)
20243 
      oprot.writeFieldEnd()
20244 
    oprot.writeFieldStop()
20245 
    oprot.writeStructEnd()
20246 
 
20247 
  def validate(self):
20248 
    return
20249 
 
20250 
 
20251 
  def __repr__(self):
20252 
    L = ['%s=%r' % (key, value)
20253 
      for key, value in self.__dict__.iteritems()]
20254 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20255 
 
20256 
  def __eq__(self, other):
20257 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20258 
 
20259 
  def __ne__(self, other):
20260 
    return not (self == other)
20261 
 
20262 
class reconcileCodCollection_result:
20263 
  """
20264 
  Attributes:
20265 
   - success
20266 
   - ex
20267 
  """
20268 
 
20269 
  thrift_spec = (
20270 
    (0, TType.MAP, 'success', (TType.STRING,None,TType.STRING,None), None, ), # 0
20271 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
20272 
  )
20273 
 
20274 
  def __init__(self, success=None, ex=None,):
20275 
    self.success = success
20276 
    self.ex = ex
20277 
 
20278 
  def read(self, iprot):
20279 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20280 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20281 
      return
20282 
    iprot.readStructBegin()
20283 
    while True:
20284 
      (fname, ftype, fid) = iprot.readFieldBegin()
20285 
      if ftype == TType.STOP:
20286 
        break
20287 
      if fid == 0:
20288 
        if ftype == TType.MAP:
20289 
          self.success = {}
6188 rajveer 20290 
          (_ktype463, _vtype464, _size462 ) = iprot.readMapBegin()
20291 
          for _i466 in xrange(_size462):
20292 
            _key467 = iprot.readString();
20293 
            _val468 = iprot.readString();
20294 
            self.success[_key467] = _val468
3956 chandransh 20295 
          iprot.readMapEnd()
20296 
        else:
20297 
          iprot.skip(ftype)
20298 
      elif fid == 1:
20299 
        if ftype == TType.STRUCT:
20300 
          self.ex = TransactionServiceException()
20301 
          self.ex.read(iprot)
20302 
        else:
20303 
          iprot.skip(ftype)
20304 
      else:
20305 
        iprot.skip(ftype)
20306 
      iprot.readFieldEnd()
20307 
    iprot.readStructEnd()
20308 
 
20309 
  def write(self, oprot):
20310 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20311 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20312 
      return
20313 
    oprot.writeStructBegin('reconcileCodCollection_result')
20314 
    if self.success is not None:
20315 
      oprot.writeFieldBegin('success', TType.MAP, 0)
20316 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.success))
6188 rajveer 20317 
      for kiter469,viter470 in self.success.items():
20318 
        oprot.writeString(kiter469)
20319 
        oprot.writeString(viter470)
3956 chandransh 20320 
      oprot.writeMapEnd()
20321 
      oprot.writeFieldEnd()
20322 
    if self.ex is not None:
20323 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
20324 
      self.ex.write(oprot)
20325 
      oprot.writeFieldEnd()
20326 
    oprot.writeFieldStop()
20327 
    oprot.writeStructEnd()
20328 
 
20329 
  def validate(self):
20330 
    return
20331 
 
20332 
 
20333 
  def __repr__(self):
20334 
    L = ['%s=%r' % (key, value)
20335 
      for key, value in self.__dict__.iteritems()]
20336 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20337 
 
20338 
  def __eq__(self, other):
20339 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20340 
 
20341 
  def __ne__(self, other):
20342 
    return not (self == other)
4008 mandeep.dh 20343 
 
20344 
class getTransactionsRequiringExtraProcessing_args:
20345 
  """
20346 
  Attributes:
20347 
   - category
20348 
  """
20349 
 
20350 
  thrift_spec = (
20351 
    None, # 0
20352 
    (1, TType.I32, 'category', None, None, ), # 1
20353 
  )
20354 
 
20355 
  def __init__(self, category=None,):
20356 
    self.category = category
20357 
 
20358 
  def read(self, iprot):
20359 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20360 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20361 
      return
20362 
    iprot.readStructBegin()
20363 
    while True:
20364 
      (fname, ftype, fid) = iprot.readFieldBegin()
20365 
      if ftype == TType.STOP:
20366 
        break
20367 
      if fid == 1:
20368 
        if ftype == TType.I32:
20369 
          self.category = iprot.readI32();
20370 
        else:
20371 
          iprot.skip(ftype)
20372 
      else:
20373 
        iprot.skip(ftype)
20374 
      iprot.readFieldEnd()
20375 
    iprot.readStructEnd()
20376 
 
20377 
  def write(self, oprot):
20378 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20379 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20380 
      return
20381 
    oprot.writeStructBegin('getTransactionsRequiringExtraProcessing_args')
20382 
    if self.category is not None:
20383 
      oprot.writeFieldBegin('category', TType.I32, 1)
20384 
      oprot.writeI32(self.category)
20385 
      oprot.writeFieldEnd()
20386 
    oprot.writeFieldStop()
20387 
    oprot.writeStructEnd()
20388 
 
20389 
  def validate(self):
20390 
    return
20391 
 
20392 
 
20393 
  def __repr__(self):
20394 
    L = ['%s=%r' % (key, value)
20395 
      for key, value in self.__dict__.iteritems()]
20396 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20397 
 
20398 
  def __eq__(self, other):
20399 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20400 
 
20401 
  def __ne__(self, other):
20402 
    return not (self == other)
20403 
 
20404 
class getTransactionsRequiringExtraProcessing_result:
20405 
  """
20406 
  Attributes:
20407 
   - success
20408 
  """
20409 
 
20410 
  thrift_spec = (
20411 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
20412 
  )
20413 
 
20414 
  def __init__(self, success=None,):
20415 
    self.success = success
20416 
 
20417 
  def read(self, iprot):
20418 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20419 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20420 
      return
20421 
    iprot.readStructBegin()
20422 
    while True:
20423 
      (fname, ftype, fid) = iprot.readFieldBegin()
20424 
      if ftype == TType.STOP:
20425 
        break
20426 
      if fid == 0:
20427 
        if ftype == TType.LIST:
20428 
          self.success = []
6188 rajveer 20429 
          (_etype474, _size471) = iprot.readListBegin()
20430 
          for _i475 in xrange(_size471):
20431 
            _elem476 = iprot.readI64();
20432 
            self.success.append(_elem476)
4008 mandeep.dh 20433 
          iprot.readListEnd()
20434 
        else:
20435 
          iprot.skip(ftype)
20436 
      else:
20437 
        iprot.skip(ftype)
20438 
      iprot.readFieldEnd()
20439 
    iprot.readStructEnd()
20440 
 
20441 
  def write(self, oprot):
20442 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20443 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20444 
      return
20445 
    oprot.writeStructBegin('getTransactionsRequiringExtraProcessing_result')
20446 
    if self.success is not None:
20447 
      oprot.writeFieldBegin('success', TType.LIST, 0)
20448 
      oprot.writeListBegin(TType.I64, len(self.success))
6188 rajveer 20449 
      for iter477 in self.success:
20450 
        oprot.writeI64(iter477)
4008 mandeep.dh 20451 
      oprot.writeListEnd()
20452 
      oprot.writeFieldEnd()
20453 
    oprot.writeFieldStop()
20454 
    oprot.writeStructEnd()
20455 
 
20456 
  def validate(self):
20457 
    return
20458 
 
20459 
 
20460 
  def __repr__(self):
20461 
    L = ['%s=%r' % (key, value)
20462 
      for key, value in self.__dict__.iteritems()]
20463 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20464 
 
20465 
  def __eq__(self, other):
20466 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20467 
 
20468 
  def __ne__(self, other):
20469 
    return not (self == other)
20470 
 
20471 
class markTransactionAsProcessed_args:
20472 
  """
20473 
  Attributes:
20474 
   - transactionId
20475 
   - category
20476 
  """
20477 
 
20478 
  thrift_spec = (
20479 
    None, # 0
20480 
    (1, TType.I64, 'transactionId', None, None, ), # 1
20481 
    (2, TType.I32, 'category', None, None, ), # 2
20482 
  )
20483 
 
20484 
  def __init__(self, transactionId=None, category=None,):
20485 
    self.transactionId = transactionId
20486 
    self.category = category
20487 
 
20488 
  def read(self, iprot):
20489 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20490 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20491 
      return
20492 
    iprot.readStructBegin()
20493 
    while True:
20494 
      (fname, ftype, fid) = iprot.readFieldBegin()
20495 
      if ftype == TType.STOP:
20496 
        break
20497 
      if fid == 1:
20498 
        if ftype == TType.I64:
20499 
          self.transactionId = iprot.readI64();
20500 
        else:
20501 
          iprot.skip(ftype)
20502 
      elif fid == 2:
20503 
        if ftype == TType.I32:
20504 
          self.category = iprot.readI32();
20505 
        else:
20506 
          iprot.skip(ftype)
20507 
      else:
20508 
        iprot.skip(ftype)
20509 
      iprot.readFieldEnd()
20510 
    iprot.readStructEnd()
20511 
 
20512 
  def write(self, oprot):
20513 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20514 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20515 
      return
20516 
    oprot.writeStructBegin('markTransactionAsProcessed_args')
20517 
    if self.transactionId is not None:
20518 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
20519 
      oprot.writeI64(self.transactionId)
20520 
      oprot.writeFieldEnd()
20521 
    if self.category is not None:
20522 
      oprot.writeFieldBegin('category', TType.I32, 2)
20523 
      oprot.writeI32(self.category)
20524 
      oprot.writeFieldEnd()
20525 
    oprot.writeFieldStop()
20526 
    oprot.writeStructEnd()
20527 
 
20528 
  def validate(self):
20529 
    return
20530 
 
20531 
 
20532 
  def __repr__(self):
20533 
    L = ['%s=%r' % (key, value)
20534 
      for key, value in self.__dict__.iteritems()]
20535 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20536 
 
20537 
  def __eq__(self, other):
20538 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20539 
 
20540 
  def __ne__(self, other):
20541 
    return not (self == other)
20542 
 
20543 
class markTransactionAsProcessed_result:
20544 
 
20545 
  thrift_spec = (
20546 
  )
20547 
 
20548 
  def read(self, iprot):
20549 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20550 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20551 
      return
20552 
    iprot.readStructBegin()
20553 
    while True:
20554 
      (fname, ftype, fid) = iprot.readFieldBegin()
20555 
      if ftype == TType.STOP:
20556 
        break
20557 
      else:
20558 
        iprot.skip(ftype)
20559 
      iprot.readFieldEnd()
20560 
    iprot.readStructEnd()
20561 
 
20562 
  def write(self, oprot):
20563 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20564 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20565 
      return
20566 
    oprot.writeStructBegin('markTransactionAsProcessed_result')
20567 
    oprot.writeFieldStop()
20568 
    oprot.writeStructEnd()
20569 
 
20570 
  def validate(self):
20571 
    return
20572 
 
20573 
 
20574 
  def __repr__(self):
20575 
    L = ['%s=%r' % (key, value)
20576 
      for key, value in self.__dict__.iteritems()]
20577 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20578 
 
20579 
  def __eq__(self, other):
20580 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20581 
 
20582 
  def __ne__(self, other):
20583 
    return not (self == other)
4018 chandransh 20584 
 
20585 
class getItemWiseRiskyOrdersCount_args:
20586 
 
20587 
  thrift_spec = (
20588 
  )
20589 
 
20590 
  def read(self, iprot):
20591 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20592 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20593 
      return
20594 
    iprot.readStructBegin()
20595 
    while True:
20596 
      (fname, ftype, fid) = iprot.readFieldBegin()
20597 
      if ftype == TType.STOP:
20598 
        break
20599 
      else:
20600 
        iprot.skip(ftype)
20601 
      iprot.readFieldEnd()
20602 
    iprot.readStructEnd()
20603 
 
20604 
  def write(self, oprot):
20605 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20606 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20607 
      return
20608 
    oprot.writeStructBegin('getItemWiseRiskyOrdersCount_args')
20609 
    oprot.writeFieldStop()
20610 
    oprot.writeStructEnd()
20611 
 
20612 
  def validate(self):
20613 
    return
20614 
 
20615 
 
20616 
  def __repr__(self):
20617 
    L = ['%s=%r' % (key, value)
20618 
      for key, value in self.__dict__.iteritems()]
20619 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20620 
 
20621 
  def __eq__(self, other):
20622 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20623 
 
20624 
  def __ne__(self, other):
20625 
    return not (self == other)
20626 
 
20627 
class getItemWiseRiskyOrdersCount_result:
20628 
  """
20629 
  Attributes:
20630 
   - success
20631 
  """
20632 
 
20633 
  thrift_spec = (
20634 
    (0, TType.MAP, 'success', (TType.I64,None,TType.I64,None), None, ), # 0
20635 
  )
20636 
 
20637 
  def __init__(self, success=None,):
20638 
    self.success = success
20639 
 
20640 
  def read(self, iprot):
20641 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20642 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20643 
      return
20644 
    iprot.readStructBegin()
20645 
    while True:
20646 
      (fname, ftype, fid) = iprot.readFieldBegin()
20647 
      if ftype == TType.STOP:
20648 
        break
20649 
      if fid == 0:
20650 
        if ftype == TType.MAP:
20651 
          self.success = {}
6188 rajveer 20652 
          (_ktype479, _vtype480, _size478 ) = iprot.readMapBegin()
20653 
          for _i482 in xrange(_size478):
20654 
            _key483 = iprot.readI64();
20655 
            _val484 = iprot.readI64();
20656 
            self.success[_key483] = _val484
4018 chandransh 20657 
          iprot.readMapEnd()
20658 
        else:
20659 
          iprot.skip(ftype)
20660 
      else:
20661 
        iprot.skip(ftype)
20662 
      iprot.readFieldEnd()
20663 
    iprot.readStructEnd()
20664 
 
20665 
  def write(self, oprot):
20666 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20667 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20668 
      return
20669 
    oprot.writeStructBegin('getItemWiseRiskyOrdersCount_result')
20670 
    if self.success is not None:
20671 
      oprot.writeFieldBegin('success', TType.MAP, 0)
20672 
      oprot.writeMapBegin(TType.I64, TType.I64, len(self.success))
6188 rajveer 20673 
      for kiter485,viter486 in self.success.items():
20674 
        oprot.writeI64(kiter485)
20675 
        oprot.writeI64(viter486)
4018 chandransh 20676 
      oprot.writeMapEnd()
20677 
      oprot.writeFieldEnd()
20678 
    oprot.writeFieldStop()
20679 
    oprot.writeStructEnd()
20680 
 
20681 
  def validate(self):
20682 
    return
20683 
 
20684 
 
20685 
  def __repr__(self):
20686 
    L = ['%s=%r' % (key, value)
20687 
      for key, value in self.__dict__.iteritems()]
20688 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20689 
 
20690 
  def __eq__(self, other):
20691 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20692 
 
20693 
  def __ne__(self, other):
20694 
    return not (self == other)
4247 rajveer 20695 
 
4295 varun.gupt 20696 
class getOrdersForItemIds_args:
20697 
  """
20698 
  Attributes:
20699 
   - itemIds
20700 
  """
20701 
 
20702 
  thrift_spec = (
20703 
    None, # 0
20704 
    (1, TType.LIST, 'itemIds', (TType.I64,None), None, ), # 1
20705 
  )
20706 
 
20707 
  def __init__(self, itemIds=None,):
20708 
    self.itemIds = itemIds
20709 
 
20710 
  def read(self, iprot):
20711 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20712 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20713 
      return
20714 
    iprot.readStructBegin()
20715 
    while True:
20716 
      (fname, ftype, fid) = iprot.readFieldBegin()
20717 
      if ftype == TType.STOP:
20718 
        break
20719 
      if fid == 1:
20720 
        if ftype == TType.LIST:
20721 
          self.itemIds = []
6188 rajveer 20722 
          (_etype490, _size487) = iprot.readListBegin()
20723 
          for _i491 in xrange(_size487):
20724 
            _elem492 = iprot.readI64();
20725 
            self.itemIds.append(_elem492)
4295 varun.gupt 20726 
          iprot.readListEnd()
20727 
        else:
20728 
          iprot.skip(ftype)
20729 
      else:
20730 
        iprot.skip(ftype)
20731 
      iprot.readFieldEnd()
20732 
    iprot.readStructEnd()
20733 
 
20734 
  def write(self, oprot):
20735 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20736 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20737 
      return
20738 
    oprot.writeStructBegin('getOrdersForItemIds_args')
20739 
    if self.itemIds is not None:
20740 
      oprot.writeFieldBegin('itemIds', TType.LIST, 1)
20741 
      oprot.writeListBegin(TType.I64, len(self.itemIds))
6188 rajveer 20742 
      for iter493 in self.itemIds:
20743 
        oprot.writeI64(iter493)
4295 varun.gupt 20744 
      oprot.writeListEnd()
20745 
      oprot.writeFieldEnd()
20746 
    oprot.writeFieldStop()
20747 
    oprot.writeStructEnd()
20748 
 
20749 
  def validate(self):
20750 
    return
20751 
 
20752 
 
20753 
  def __repr__(self):
20754 
    L = ['%s=%r' % (key, value)
20755 
      for key, value in self.__dict__.iteritems()]
20756 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20757 
 
20758 
  def __eq__(self, other):
20759 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20760 
 
20761 
  def __ne__(self, other):
20762 
    return not (self == other)
20763 
 
20764 
class getOrdersForItemIds_result:
20765 
  """
20766 
  Attributes:
20767 
   - success
20768 
  """
20769 
 
20770 
  thrift_spec = (
20771 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
20772 
  )
20773 
 
20774 
  def __init__(self, success=None,):
20775 
    self.success = success
20776 
 
20777 
  def read(self, iprot):
20778 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20779 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20780 
      return
20781 
    iprot.readStructBegin()
20782 
    while True:
20783 
      (fname, ftype, fid) = iprot.readFieldBegin()
20784 
      if ftype == TType.STOP:
20785 
        break
20786 
      if fid == 0:
20787 
        if ftype == TType.LIST:
20788 
          self.success = []
6188 rajveer 20789 
          (_etype497, _size494) = iprot.readListBegin()
20790 
          for _i498 in xrange(_size494):
20791 
            _elem499 = Order()
20792 
            _elem499.read(iprot)
20793 
            self.success.append(_elem499)
4295 varun.gupt 20794 
          iprot.readListEnd()
20795 
        else:
20796 
          iprot.skip(ftype)
20797 
      else:
20798 
        iprot.skip(ftype)
20799 
      iprot.readFieldEnd()
20800 
    iprot.readStructEnd()
20801 
 
20802 
  def write(self, oprot):
20803 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20804 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20805 
      return
20806 
    oprot.writeStructBegin('getOrdersForItemIds_result')
20807 
    if self.success is not None:
20808 
      oprot.writeFieldBegin('success', TType.LIST, 0)
20809 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 20810 
      for iter500 in self.success:
20811 
        iter500.write(oprot)
4295 varun.gupt 20812 
      oprot.writeListEnd()
20813 
      oprot.writeFieldEnd()
20814 
    oprot.writeFieldStop()
20815 
    oprot.writeStructEnd()
20816 
 
20817 
  def validate(self):
20818 
    return
20819 
 
20820 
 
20821 
  def __repr__(self):
20822 
    L = ['%s=%r' % (key, value)
20823 
      for key, value in self.__dict__.iteritems()]
20824 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20825 
 
20826 
  def __eq__(self, other):
20827 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20828 
 
20829 
  def __ne__(self, other):
20830 
    return not (self == other)
20831 
 
4247 rajveer 20832 
class markOrderCancellationRequestReceived_args:
20833 
  """
20834 
  Attributes:
20835 
   - orderId
20836 
  """
20837 
 
20838 
  thrift_spec = (
20839 
    None, # 0
20840 
    (1, TType.I64, 'orderId', None, None, ), # 1
20841 
  )
20842 
 
20843 
  def __init__(self, orderId=None,):
20844 
    self.orderId = orderId
20845 
 
20846 
  def read(self, iprot):
20847 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20848 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20849 
      return
20850 
    iprot.readStructBegin()
20851 
    while True:
20852 
      (fname, ftype, fid) = iprot.readFieldBegin()
20853 
      if ftype == TType.STOP:
20854 
        break
20855 
      if fid == 1:
20856 
        if ftype == TType.I64:
20857 
          self.orderId = iprot.readI64();
20858 
        else:
20859 
          iprot.skip(ftype)
20860 
      else:
20861 
        iprot.skip(ftype)
20862 
      iprot.readFieldEnd()
20863 
    iprot.readStructEnd()
20864 
 
20865 
  def write(self, oprot):
20866 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20867 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20868 
      return
20869 
    oprot.writeStructBegin('markOrderCancellationRequestReceived_args')
20870 
    if self.orderId is not None:
20871 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
20872 
      oprot.writeI64(self.orderId)
20873 
      oprot.writeFieldEnd()
20874 
    oprot.writeFieldStop()
20875 
    oprot.writeStructEnd()
20876 
 
20877 
  def validate(self):
20878 
    return
20879 
 
20880 
 
20881 
  def __repr__(self):
20882 
    L = ['%s=%r' % (key, value)
20883 
      for key, value in self.__dict__.iteritems()]
20884 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20885 
 
20886 
  def __eq__(self, other):
20887 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20888 
 
20889 
  def __ne__(self, other):
20890 
    return not (self == other)
20891 
 
20892 
class markOrderCancellationRequestReceived_result:
20893 
  """
20894 
  Attributes:
20895 
   - ex
20896 
  """
20897 
 
20898 
  thrift_spec = (
20899 
    None, # 0
20900 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
20901 
  )
20902 
 
20903 
  def __init__(self, ex=None,):
20904 
    self.ex = ex
20905 
 
20906 
  def read(self, iprot):
20907 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20908 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20909 
      return
20910 
    iprot.readStructBegin()
20911 
    while True:
20912 
      (fname, ftype, fid) = iprot.readFieldBegin()
20913 
      if ftype == TType.STOP:
20914 
        break
20915 
      if fid == 1:
20916 
        if ftype == TType.STRUCT:
20917 
          self.ex = TransactionServiceException()
20918 
          self.ex.read(iprot)
20919 
        else:
20920 
          iprot.skip(ftype)
20921 
      else:
20922 
        iprot.skip(ftype)
20923 
      iprot.readFieldEnd()
20924 
    iprot.readStructEnd()
20925 
 
20926 
  def write(self, oprot):
20927 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20928 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20929 
      return
20930 
    oprot.writeStructBegin('markOrderCancellationRequestReceived_result')
20931 
    if self.ex is not None:
20932 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
20933 
      self.ex.write(oprot)
20934 
      oprot.writeFieldEnd()
20935 
    oprot.writeFieldStop()
20936 
    oprot.writeStructEnd()
20937 
 
20938 
  def validate(self):
20939 
    return
20940 
 
20941 
 
20942 
  def __repr__(self):
20943 
    L = ['%s=%r' % (key, value)
20944 
      for key, value in self.__dict__.iteritems()]
20945 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20946 
 
20947 
  def __eq__(self, other):
20948 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20949 
 
20950 
  def __ne__(self, other):
20951 
    return not (self == other)
20952 
 
20953 
class markOrderCancellationRequestConfirmed_args:
20954 
  """
20955 
  Attributes:
20956 
   - orderId
20957 
  """
20958 
 
20959 
  thrift_spec = (
20960 
    None, # 0
20961 
    (1, TType.I64, 'orderId', None, None, ), # 1
20962 
  )
20963 
 
20964 
  def __init__(self, orderId=None,):
20965 
    self.orderId = orderId
20966 
 
20967 
  def read(self, iprot):
20968 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20969 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20970 
      return
20971 
    iprot.readStructBegin()
20972 
    while True:
20973 
      (fname, ftype, fid) = iprot.readFieldBegin()
20974 
      if ftype == TType.STOP:
20975 
        break
20976 
      if fid == 1:
20977 
        if ftype == TType.I64:
20978 
          self.orderId = iprot.readI64();
20979 
        else:
20980 
          iprot.skip(ftype)
20981 
      else:
20982 
        iprot.skip(ftype)
20983 
      iprot.readFieldEnd()
20984 
    iprot.readStructEnd()
20985 
 
20986 
  def write(self, oprot):
20987 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20988 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20989 
      return
20990 
    oprot.writeStructBegin('markOrderCancellationRequestConfirmed_args')
20991 
    if self.orderId is not None:
20992 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
20993 
      oprot.writeI64(self.orderId)
20994 
      oprot.writeFieldEnd()
20995 
    oprot.writeFieldStop()
20996 
    oprot.writeStructEnd()
20997 
 
20998 
  def validate(self):
20999 
    return
21000 
 
21001 
 
21002 
  def __repr__(self):
21003 
    L = ['%s=%r' % (key, value)
21004 
      for key, value in self.__dict__.iteritems()]
21005 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21006 
 
21007 
  def __eq__(self, other):
21008 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21009 
 
21010 
  def __ne__(self, other):
21011 
    return not (self == other)
21012 
 
21013 
class markOrderCancellationRequestConfirmed_result:
21014 
  """
21015 
  Attributes:
21016 
   - ex
21017 
  """
21018 
 
21019 
  thrift_spec = (
21020 
    None, # 0
21021 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
21022 
  )
21023 
 
21024 
  def __init__(self, ex=None,):
21025 
    self.ex = ex
21026 
 
21027 
  def read(self, iprot):
21028 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21029 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21030 
      return
21031 
    iprot.readStructBegin()
21032 
    while True:
21033 
      (fname, ftype, fid) = iprot.readFieldBegin()
21034 
      if ftype == TType.STOP:
21035 
        break
21036 
      if fid == 1:
21037 
        if ftype == TType.STRUCT:
21038 
          self.ex = TransactionServiceException()
21039 
          self.ex.read(iprot)
21040 
        else:
21041 
          iprot.skip(ftype)
21042 
      else:
21043 
        iprot.skip(ftype)
21044 
      iprot.readFieldEnd()
21045 
    iprot.readStructEnd()
21046 
 
21047 
  def write(self, oprot):
21048 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21049 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21050 
      return
21051 
    oprot.writeStructBegin('markOrderCancellationRequestConfirmed_result')
21052 
    if self.ex is not None:
21053 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
21054 
      self.ex.write(oprot)
21055 
      oprot.writeFieldEnd()
21056 
    oprot.writeFieldStop()
21057 
    oprot.writeStructEnd()
21058 
 
21059 
  def validate(self):
21060 
    return
21061 
 
21062 
 
21063 
  def __repr__(self):
21064 
    L = ['%s=%r' % (key, value)
21065 
      for key, value in self.__dict__.iteritems()]
21066 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21067 
 
21068 
  def __eq__(self, other):
21069 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21070 
 
21071 
  def __ne__(self, other):
21072 
    return not (self == other)
21073 
 
21074 
class markOrderCancellationRequestDenied_args:
21075 
  """
21076 
  Attributes:
21077 
   - orderId
21078 
  """
21079 
 
21080 
  thrift_spec = (
21081 
    None, # 0
21082 
    (1, TType.I64, 'orderId', None, None, ), # 1
21083 
  )
21084 
 
21085 
  def __init__(self, orderId=None,):
21086 
    self.orderId = orderId
21087 
 
21088 
  def read(self, iprot):
21089 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21090 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21091 
      return
21092 
    iprot.readStructBegin()
21093 
    while True:
21094 
      (fname, ftype, fid) = iprot.readFieldBegin()
21095 
      if ftype == TType.STOP:
21096 
        break
21097 
      if fid == 1:
21098 
        if ftype == TType.I64:
21099 
          self.orderId = iprot.readI64();
21100 
        else:
21101 
          iprot.skip(ftype)
21102 
      else:
21103 
        iprot.skip(ftype)
21104 
      iprot.readFieldEnd()
21105 
    iprot.readStructEnd()
21106 
 
21107 
  def write(self, oprot):
21108 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21109 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21110 
      return
21111 
    oprot.writeStructBegin('markOrderCancellationRequestDenied_args')
21112 
    if self.orderId is not None:
21113 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
21114 
      oprot.writeI64(self.orderId)
21115 
      oprot.writeFieldEnd()
21116 
    oprot.writeFieldStop()
21117 
    oprot.writeStructEnd()
21118 
 
21119 
  def validate(self):
21120 
    return
21121 
 
21122 
 
21123 
  def __repr__(self):
21124 
    L = ['%s=%r' % (key, value)
21125 
      for key, value in self.__dict__.iteritems()]
21126 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21127 
 
21128 
  def __eq__(self, other):
21129 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21130 
 
21131 
  def __ne__(self, other):
21132 
    return not (self == other)
21133 
 
21134 
class markOrderCancellationRequestDenied_result:
21135 
  """
21136 
  Attributes:
21137 
   - ex
21138 
  """
21139 
 
21140 
  thrift_spec = (
21141 
    None, # 0
21142 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
21143 
  )
21144 
 
21145 
  def __init__(self, ex=None,):
21146 
    self.ex = ex
21147 
 
21148 
  def read(self, iprot):
21149 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21150 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21151 
      return
21152 
    iprot.readStructBegin()
21153 
    while True:
21154 
      (fname, ftype, fid) = iprot.readFieldBegin()
21155 
      if ftype == TType.STOP:
21156 
        break
21157 
      if fid == 1:
21158 
        if ftype == TType.STRUCT:
21159 
          self.ex = TransactionServiceException()
21160 
          self.ex.read(iprot)
21161 
        else:
21162 
          iprot.skip(ftype)
21163 
      else:
21164 
        iprot.skip(ftype)
21165 
      iprot.readFieldEnd()
21166 
    iprot.readStructEnd()
21167 
 
21168 
  def write(self, oprot):
21169 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21170 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21171 
      return
21172 
    oprot.writeStructBegin('markOrderCancellationRequestDenied_result')
21173 
    if self.ex is not None:
21174 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
21175 
      self.ex.write(oprot)
21176 
      oprot.writeFieldEnd()
21177 
    oprot.writeFieldStop()
21178 
    oprot.writeStructEnd()
21179 
 
21180 
  def validate(self):
21181 
    return
21182 
 
21183 
 
21184 
  def __repr__(self):
21185 
    L = ['%s=%r' % (key, value)
21186 
      for key, value in self.__dict__.iteritems()]
21187 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21188 
 
21189 
  def __eq__(self, other):
21190 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21191 
 
21192 
  def __ne__(self, other):
21193 
    return not (self == other)
21194 
 
4258 rajveer 21195 
class markTransactionAsPaymentFlagRemoved_args:
4247 rajveer 21196 
  """
21197 
  Attributes:
4258 rajveer 21198 
   - transactionId
4247 rajveer 21199 
  """
21200 
 
21201 
  thrift_spec = (
21202 
    None, # 0
4258 rajveer 21203 
    (1, TType.I64, 'transactionId', None, None, ), # 1
4247 rajveer 21204 
  )
21205 
 
4258 rajveer 21206 
  def __init__(self, transactionId=None,):
21207 
    self.transactionId = transactionId
4247 rajveer 21208 
 
21209 
  def read(self, iprot):
21210 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21211 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21212 
      return
21213 
    iprot.readStructBegin()
21214 
    while True:
21215 
      (fname, ftype, fid) = iprot.readFieldBegin()
21216 
      if ftype == TType.STOP:
21217 
        break
21218 
      if fid == 1:
21219 
        if ftype == TType.I64:
4258 rajveer 21220 
          self.transactionId = iprot.readI64();
4247 rajveer 21221 
        else:
21222 
          iprot.skip(ftype)
21223 
      else:
21224 
        iprot.skip(ftype)
21225 
      iprot.readFieldEnd()
21226 
    iprot.readStructEnd()
21227 
 
21228 
  def write(self, oprot):
21229 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21230 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21231 
      return
4258 rajveer 21232 
    oprot.writeStructBegin('markTransactionAsPaymentFlagRemoved_args')
21233 
    if self.transactionId is not None:
21234 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
21235 
      oprot.writeI64(self.transactionId)
4247 rajveer 21236 
      oprot.writeFieldEnd()
21237 
    oprot.writeFieldStop()
21238 
    oprot.writeStructEnd()
21239 
 
21240 
  def validate(self):
21241 
    return
21242 
 
21243 
 
21244 
  def __repr__(self):
21245 
    L = ['%s=%r' % (key, value)
21246 
      for key, value in self.__dict__.iteritems()]
21247 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21248 
 
21249 
  def __eq__(self, other):
21250 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21251 
 
21252 
  def __ne__(self, other):
21253 
    return not (self == other)
21254 
 
4258 rajveer 21255 
class markTransactionAsPaymentFlagRemoved_result:
4247 rajveer 21256 
  """
21257 
  Attributes:
21258 
   - ex
21259 
  """
21260 
 
21261 
  thrift_spec = (
21262 
    None, # 0
21263 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
21264 
  )
21265 
 
21266 
  def __init__(self, ex=None,):
21267 
    self.ex = ex
21268 
 
21269 
  def read(self, iprot):
21270 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21271 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21272 
      return
21273 
    iprot.readStructBegin()
21274 
    while True:
21275 
      (fname, ftype, fid) = iprot.readFieldBegin()
21276 
      if ftype == TType.STOP:
21277 
        break
21278 
      if fid == 1:
21279 
        if ftype == TType.STRUCT:
21280 
          self.ex = TransactionServiceException()
21281 
          self.ex.read(iprot)
21282 
        else:
21283 
          iprot.skip(ftype)
21284 
      else:
21285 
        iprot.skip(ftype)
21286 
      iprot.readFieldEnd()
21287 
    iprot.readStructEnd()
21288 
 
21289 
  def write(self, oprot):
21290 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21291 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21292 
      return
4258 rajveer 21293 
    oprot.writeStructBegin('markTransactionAsPaymentFlagRemoved_result')
4247 rajveer 21294 
    if self.ex is not None:
21295 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
21296 
      self.ex.write(oprot)
21297 
      oprot.writeFieldEnd()
21298 
    oprot.writeFieldStop()
21299 
    oprot.writeStructEnd()
21300 
 
21301 
  def validate(self):
21302 
    return
21303 
 
21304 
 
21305 
  def __repr__(self):
21306 
    L = ['%s=%r' % (key, value)
21307 
      for key, value in self.__dict__.iteritems()]
21308 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21309 
 
21310 
  def __eq__(self, other):
21311 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21312 
 
21313 
  def __ne__(self, other):
21314 
    return not (self == other)
4259 anupam.sin 21315 
 
21316 
class refundTransaction_args:
21317 
  """
21318 
  Attributes:
21319 
   - transactionId
21320 
   - refundedBy
21321 
   - reason
21322 
  """
21323 
 
21324 
  thrift_spec = (
21325 
    None, # 0
21326 
    (1, TType.I64, 'transactionId', None, None, ), # 1
21327 
    (2, TType.STRING, 'refundedBy', None, None, ), # 2
21328 
    (3, TType.STRING, 'reason', None, None, ), # 3
21329 
  )
21330 
 
21331 
  def __init__(self, transactionId=None, refundedBy=None, reason=None,):
21332 
    self.transactionId = transactionId
21333 
    self.refundedBy = refundedBy
21334 
    self.reason = reason
21335 
 
21336 
  def read(self, iprot):
21337 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21338 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21339 
      return
21340 
    iprot.readStructBegin()
21341 
    while True:
21342 
      (fname, ftype, fid) = iprot.readFieldBegin()
21343 
      if ftype == TType.STOP:
21344 
        break
21345 
      if fid == 1:
21346 
        if ftype == TType.I64:
21347 
          self.transactionId = iprot.readI64();
21348 
        else:
21349 
          iprot.skip(ftype)
21350 
      elif fid == 2:
21351 
        if ftype == TType.STRING:
21352 
          self.refundedBy = iprot.readString();
21353 
        else:
21354 
          iprot.skip(ftype)
21355 
      elif fid == 3:
21356 
        if ftype == TType.STRING:
21357 
          self.reason = iprot.readString();
21358 
        else:
21359 
          iprot.skip(ftype)
21360 
      else:
21361 
        iprot.skip(ftype)
21362 
      iprot.readFieldEnd()
21363 
    iprot.readStructEnd()
21364 
 
21365 
  def write(self, oprot):
21366 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21367 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21368 
      return
21369 
    oprot.writeStructBegin('refundTransaction_args')
21370 
    if self.transactionId is not None:
21371 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
21372 
      oprot.writeI64(self.transactionId)
21373 
      oprot.writeFieldEnd()
21374 
    if self.refundedBy is not None:
21375 
      oprot.writeFieldBegin('refundedBy', TType.STRING, 2)
21376 
      oprot.writeString(self.refundedBy)
21377 
      oprot.writeFieldEnd()
21378 
    if self.reason is not None:
21379 
      oprot.writeFieldBegin('reason', TType.STRING, 3)
21380 
      oprot.writeString(self.reason)
21381 
      oprot.writeFieldEnd()
21382 
    oprot.writeFieldStop()
21383 
    oprot.writeStructEnd()
21384 
 
21385 
  def validate(self):
21386 
    return
21387 
 
21388 
 
21389 
  def __repr__(self):
21390 
    L = ['%s=%r' % (key, value)
21391 
      for key, value in self.__dict__.iteritems()]
21392 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21393 
 
21394 
  def __eq__(self, other):
21395 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21396 
 
21397 
  def __ne__(self, other):
21398 
    return not (self == other)
21399 
 
21400 
class refundTransaction_result:
21401 
  """
21402 
  Attributes:
21403 
   - ex
21404 
  """
21405 
 
21406 
  thrift_spec = (
21407 
    None, # 0
21408 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
21409 
  )
21410 
 
21411 
  def __init__(self, ex=None,):
21412 
    self.ex = ex
21413 
 
21414 
  def read(self, iprot):
21415 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21416 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21417 
      return
21418 
    iprot.readStructBegin()
21419 
    while True:
21420 
      (fname, ftype, fid) = iprot.readFieldBegin()
21421 
      if ftype == TType.STOP:
21422 
        break
21423 
      if fid == 1:
21424 
        if ftype == TType.STRUCT:
21425 
          self.ex = TransactionServiceException()
21426 
          self.ex.read(iprot)
21427 
        else:
21428 
          iprot.skip(ftype)
21429 
      else:
21430 
        iprot.skip(ftype)
21431 
      iprot.readFieldEnd()
21432 
    iprot.readStructEnd()
21433 
 
21434 
  def write(self, oprot):
21435 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21436 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21437 
      return
21438 
    oprot.writeStructBegin('refundTransaction_result')
21439 
    if self.ex is not None:
21440 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
21441 
      self.ex.write(oprot)
21442 
      oprot.writeFieldEnd()
21443 
    oprot.writeFieldStop()
21444 
    oprot.writeStructEnd()
21445 
 
21446 
  def validate(self):
21447 
    return
21448 
 
21449 
 
21450 
  def __repr__(self):
21451 
    L = ['%s=%r' % (key, value)
21452 
      for key, value in self.__dict__.iteritems()]
21453 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21454 
 
21455 
  def __eq__(self, other):
21456 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21457 
 
21458 
  def __ne__(self, other):
21459 
    return not (self == other)
4285 rajveer 21460 
 
4324 mandeep.dh 21461 
class updateShipmentAddress_args:
21462 
  """
21463 
  Attributes:
21464 
   - orderId
21465 
   - addressId
21466 
  """
21467 
 
21468 
  thrift_spec = (
21469 
    None, # 0
21470 
    (1, TType.I64, 'orderId', None, None, ), # 1
21471 
    (2, TType.I64, 'addressId', None, None, ), # 2
21472 
  )
21473 
 
21474 
  def __init__(self, orderId=None, addressId=None,):
21475 
    self.orderId = orderId
21476 
    self.addressId = addressId
21477 
 
21478 
  def read(self, iprot):
21479 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21480 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21481 
      return
21482 
    iprot.readStructBegin()
21483 
    while True:
21484 
      (fname, ftype, fid) = iprot.readFieldBegin()
21485 
      if ftype == TType.STOP:
21486 
        break
21487 
      if fid == 1:
21488 
        if ftype == TType.I64:
21489 
          self.orderId = iprot.readI64();
21490 
        else:
21491 
          iprot.skip(ftype)
21492 
      elif fid == 2:
21493 
        if ftype == TType.I64:
21494 
          self.addressId = iprot.readI64();
21495 
        else:
21496 
          iprot.skip(ftype)
21497 
      else:
21498 
        iprot.skip(ftype)
21499 
      iprot.readFieldEnd()
21500 
    iprot.readStructEnd()
21501 
 
21502 
  def write(self, oprot):
21503 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21504 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21505 
      return
21506 
    oprot.writeStructBegin('updateShipmentAddress_args')
21507 
    if self.orderId is not None:
21508 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
21509 
      oprot.writeI64(self.orderId)
21510 
      oprot.writeFieldEnd()
21511 
    if self.addressId is not None:
21512 
      oprot.writeFieldBegin('addressId', TType.I64, 2)
21513 
      oprot.writeI64(self.addressId)
21514 
      oprot.writeFieldEnd()
21515 
    oprot.writeFieldStop()
21516 
    oprot.writeStructEnd()
21517 
 
21518 
  def validate(self):
21519 
    return
21520 
 
21521 
 
21522 
  def __repr__(self):
21523 
    L = ['%s=%r' % (key, value)
21524 
      for key, value in self.__dict__.iteritems()]
21525 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21526 
 
21527 
  def __eq__(self, other):
21528 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21529 
 
21530 
  def __ne__(self, other):
21531 
    return not (self == other)
21532 
 
21533 
class updateShipmentAddress_result:
21534 
  """
21535 
  Attributes:
21536 
   - ex
21537 
  """
21538 
 
21539 
  thrift_spec = (
21540 
    None, # 0
21541 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
21542 
  )
21543 
 
21544 
  def __init__(self, ex=None,):
21545 
    self.ex = ex
21546 
 
21547 
  def read(self, iprot):
21548 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21549 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21550 
      return
21551 
    iprot.readStructBegin()
21552 
    while True:
21553 
      (fname, ftype, fid) = iprot.readFieldBegin()
21554 
      if ftype == TType.STOP:
21555 
        break
21556 
      if fid == 1:
21557 
        if ftype == TType.STRUCT:
21558 
          self.ex = TransactionServiceException()
21559 
          self.ex.read(iprot)
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('updateShipmentAddress_result')
21572 
    if self.ex is not None:
21573 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
21574 
      self.ex.write(oprot)
21575 
      oprot.writeFieldEnd()
21576 
    oprot.writeFieldStop()
21577 
    oprot.writeStructEnd()
21578 
 
21579 
  def validate(self):
21580 
    return
21581 
 
21582 
 
21583 
  def __repr__(self):
21584 
    L = ['%s=%r' % (key, value)
21585 
      for key, value in self.__dict__.iteritems()]
21586 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21587 
 
21588 
  def __eq__(self, other):
21589 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21590 
 
21591 
  def __ne__(self, other):
21592 
    return not (self == other)
21593 
 
4285 rajveer 21594 
class acceptOrdersForItemId_args:
21595 
  """
21596 
  Attributes:
21597 
   - itemId
21598 
   - inventory
21599 
  """
21600 
 
21601 
  thrift_spec = (
21602 
    None, # 0
21603 
    (1, TType.I64, 'itemId', None, None, ), # 1
21604 
    (2, TType.I64, 'inventory', None, None, ), # 2
21605 
  )
21606 
 
21607 
  def __init__(self, itemId=None, inventory=None,):
21608 
    self.itemId = itemId
21609 
    self.inventory = inventory
21610 
 
21611 
  def read(self, iprot):
21612 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21613 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21614 
      return
21615 
    iprot.readStructBegin()
21616 
    while True:
21617 
      (fname, ftype, fid) = iprot.readFieldBegin()
21618 
      if ftype == TType.STOP:
21619 
        break
21620 
      if fid == 1:
21621 
        if ftype == TType.I64:
21622 
          self.itemId = iprot.readI64();
21623 
        else:
21624 
          iprot.skip(ftype)
21625 
      elif fid == 2:
21626 
        if ftype == TType.I64:
21627 
          self.inventory = iprot.readI64();
21628 
        else:
21629 
          iprot.skip(ftype)
21630 
      else:
21631 
        iprot.skip(ftype)
21632 
      iprot.readFieldEnd()
21633 
    iprot.readStructEnd()
21634 
 
21635 
  def write(self, oprot):
21636 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21637 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21638 
      return
21639 
    oprot.writeStructBegin('acceptOrdersForItemId_args')
21640 
    if self.itemId is not None:
21641 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
21642 
      oprot.writeI64(self.itemId)
21643 
      oprot.writeFieldEnd()
21644 
    if self.inventory is not None:
21645 
      oprot.writeFieldBegin('inventory', TType.I64, 2)
21646 
      oprot.writeI64(self.inventory)
21647 
      oprot.writeFieldEnd()
21648 
    oprot.writeFieldStop()
21649 
    oprot.writeStructEnd()
21650 
 
21651 
  def validate(self):
21652 
    return
21653 
 
21654 
 
21655 
  def __repr__(self):
21656 
    L = ['%s=%r' % (key, value)
21657 
      for key, value in self.__dict__.iteritems()]
21658 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21659 
 
21660 
  def __eq__(self, other):
21661 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21662 
 
21663 
  def __ne__(self, other):
21664 
    return not (self == other)
21665 
 
21666 
class acceptOrdersForItemId_result:
21667 
  """
21668 
  Attributes:
21669 
   - success
21670 
   - ex
21671 
  """
21672 
 
21673 
  thrift_spec = (
21674 
    (0, TType.BOOL, 'success', None, None, ), # 0
21675 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
21676 
  )
21677 
 
21678 
  def __init__(self, success=None, ex=None,):
21679 
    self.success = success
21680 
    self.ex = ex
21681 
 
21682 
  def read(self, iprot):
21683 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21684 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21685 
      return
21686 
    iprot.readStructBegin()
21687 
    while True:
21688 
      (fname, ftype, fid) = iprot.readFieldBegin()
21689 
      if ftype == TType.STOP:
21690 
        break
21691 
      if fid == 0:
21692 
        if ftype == TType.BOOL:
21693 
          self.success = iprot.readBool();
21694 
        else:
21695 
          iprot.skip(ftype)
21696 
      elif fid == 1:
21697 
        if ftype == TType.STRUCT:
21698 
          self.ex = TransactionServiceException()
21699 
          self.ex.read(iprot)
21700 
        else:
21701 
          iprot.skip(ftype)
21702 
      else:
21703 
        iprot.skip(ftype)
21704 
      iprot.readFieldEnd()
21705 
    iprot.readStructEnd()
21706 
 
21707 
  def write(self, oprot):
21708 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21709 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21710 
      return
21711 
    oprot.writeStructBegin('acceptOrdersForItemId_result')
21712 
    if self.success is not None:
21713 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
21714 
      oprot.writeBool(self.success)
21715 
      oprot.writeFieldEnd()
21716 
    if self.ex is not None:
21717 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
21718 
      self.ex.write(oprot)
21719 
      oprot.writeFieldEnd()
21720 
    oprot.writeFieldStop()
21721 
    oprot.writeStructEnd()
21722 
 
21723 
  def validate(self):
21724 
    return
21725 
 
21726 
 
21727 
  def __repr__(self):
21728 
    L = ['%s=%r' % (key, value)
21729 
      for key, value in self.__dict__.iteritems()]
21730 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21731 
 
21732 
  def __eq__(self, other):
21733 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21734 
 
21735 
  def __ne__(self, other):
21736 
    return not (self == other)
4303 rajveer 21737 
 
21738 
class markOrdersAsPORaised_args:
21739 
  """
21740 
  Attributes:
21741 
   - vendorId
21742 
   - itemId
21743 
   - quantity
21744 
   - estimate
4369 rajveer 21745 
   - isReminder
4303 rajveer 21746 
  """
21747 
 
21748 
  thrift_spec = (
21749 
    None, # 0
21750 
    (1, TType.I64, 'vendorId', None, None, ), # 1
21751 
    (2, TType.I64, 'itemId', None, None, ), # 2
21752 
    (3, TType.I64, 'quantity', None, None, ), # 3
21753 
    (4, TType.I64, 'estimate', None, None, ), # 4
4369 rajveer 21754 
    (5, TType.BOOL, 'isReminder', None, None, ), # 5
4303 rajveer 21755 
  )
21756 
 
4369 rajveer 21757 
  def __init__(self, vendorId=None, itemId=None, quantity=None, estimate=None, isReminder=None,):
4303 rajveer 21758 
    self.vendorId = vendorId
21759 
    self.itemId = itemId
21760 
    self.quantity = quantity
21761 
    self.estimate = estimate
4369 rajveer 21762 
    self.isReminder = isReminder
4303 rajveer 21763 
 
21764 
  def read(self, iprot):
21765 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21766 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21767 
      return
21768 
    iprot.readStructBegin()
21769 
    while True:
21770 
      (fname, ftype, fid) = iprot.readFieldBegin()
21771 
      if ftype == TType.STOP:
21772 
        break
21773 
      if fid == 1:
21774 
        if ftype == TType.I64:
21775 
          self.vendorId = iprot.readI64();
21776 
        else:
21777 
          iprot.skip(ftype)
21778 
      elif fid == 2:
21779 
        if ftype == TType.I64:
21780 
          self.itemId = iprot.readI64();
21781 
        else:
21782 
          iprot.skip(ftype)
21783 
      elif fid == 3:
21784 
        if ftype == TType.I64:
21785 
          self.quantity = iprot.readI64();
21786 
        else:
21787 
          iprot.skip(ftype)
21788 
      elif fid == 4:
21789 
        if ftype == TType.I64:
21790 
          self.estimate = iprot.readI64();
21791 
        else:
21792 
          iprot.skip(ftype)
4369 rajveer 21793 
      elif fid == 5:
21794 
        if ftype == TType.BOOL:
21795 
          self.isReminder = iprot.readBool();
21796 
        else:
21797 
          iprot.skip(ftype)
4303 rajveer 21798 
      else:
21799 
        iprot.skip(ftype)
21800 
      iprot.readFieldEnd()
21801 
    iprot.readStructEnd()
21802 
 
21803 
  def write(self, oprot):
21804 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21805 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21806 
      return
21807 
    oprot.writeStructBegin('markOrdersAsPORaised_args')
21808 
    if self.vendorId is not None:
21809 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
21810 
      oprot.writeI64(self.vendorId)
21811 
      oprot.writeFieldEnd()
21812 
    if self.itemId is not None:
21813 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
21814 
      oprot.writeI64(self.itemId)
21815 
      oprot.writeFieldEnd()
21816 
    if self.quantity is not None:
21817 
      oprot.writeFieldBegin('quantity', TType.I64, 3)
21818 
      oprot.writeI64(self.quantity)
21819 
      oprot.writeFieldEnd()
21820 
    if self.estimate is not None:
21821 
      oprot.writeFieldBegin('estimate', TType.I64, 4)
21822 
      oprot.writeI64(self.estimate)
21823 
      oprot.writeFieldEnd()
4369 rajveer 21824 
    if self.isReminder is not None:
21825 
      oprot.writeFieldBegin('isReminder', TType.BOOL, 5)
21826 
      oprot.writeBool(self.isReminder)
21827 
      oprot.writeFieldEnd()
4303 rajveer 21828 
    oprot.writeFieldStop()
21829 
    oprot.writeStructEnd()
21830 
 
21831 
  def validate(self):
21832 
    return
21833 
 
21834 
 
21835 
  def __repr__(self):
21836 
    L = ['%s=%r' % (key, value)
21837 
      for key, value in self.__dict__.iteritems()]
21838 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21839 
 
21840 
  def __eq__(self, other):
21841 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21842 
 
21843 
  def __ne__(self, other):
21844 
    return not (self == other)
21845 
 
21846 
class markOrdersAsPORaised_result:
21847 
  """
21848 
  Attributes:
21849 
   - ex
21850 
  """
21851 
 
21852 
  thrift_spec = (
21853 
    None, # 0
21854 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
21855 
  )
21856 
 
21857 
  def __init__(self, ex=None,):
21858 
    self.ex = ex
21859 
 
21860 
  def read(self, iprot):
21861 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21862 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21863 
      return
21864 
    iprot.readStructBegin()
21865 
    while True:
21866 
      (fname, ftype, fid) = iprot.readFieldBegin()
21867 
      if ftype == TType.STOP:
21868 
        break
21869 
      if fid == 1:
21870 
        if ftype == TType.STRUCT:
21871 
          self.ex = TransactionServiceException()
21872 
          self.ex.read(iprot)
21873 
        else:
21874 
          iprot.skip(ftype)
21875 
      else:
21876 
        iprot.skip(ftype)
21877 
      iprot.readFieldEnd()
21878 
    iprot.readStructEnd()
21879 
 
21880 
  def write(self, oprot):
21881 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21882 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21883 
      return
21884 
    oprot.writeStructBegin('markOrdersAsPORaised_result')
21885 
    if self.ex is not None:
21886 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
21887 
      self.ex.write(oprot)
21888 
      oprot.writeFieldEnd()
21889 
    oprot.writeFieldStop()
21890 
    oprot.writeStructEnd()
21891 
 
21892 
  def validate(self):
21893 
    return
21894 
 
21895 
 
21896 
  def __repr__(self):
21897 
    L = ['%s=%r' % (key, value)
21898 
      for key, value in self.__dict__.iteritems()]
21899 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21900 
 
21901 
  def __eq__(self, other):
21902 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21903 
 
21904 
  def __ne__(self, other):
21905 
    return not (self == other)
21906 
 
21907 
class markOrdersAsReversalInitiated_args:
21908 
  """
21909 
  Attributes:
21910 
   - vendorId
21911 
   - itemId
21912 
   - quantity
21913 
   - estimate
4369 rajveer 21914 
   - isReminder
4303 rajveer 21915 
  """
21916 
 
21917 
  thrift_spec = (
21918 
    None, # 0
21919 
    (1, TType.I64, 'vendorId', None, None, ), # 1
21920 
    (2, TType.I64, 'itemId', None, None, ), # 2
21921 
    (3, TType.I64, 'quantity', None, None, ), # 3
21922 
    (4, TType.I64, 'estimate', None, None, ), # 4
4369 rajveer 21923 
    (5, TType.BOOL, 'isReminder', None, None, ), # 5
4303 rajveer 21924 
  )
21925 
 
4369 rajveer 21926 
  def __init__(self, vendorId=None, itemId=None, quantity=None, estimate=None, isReminder=None,):
4303 rajveer 21927 
    self.vendorId = vendorId
21928 
    self.itemId = itemId
21929 
    self.quantity = quantity
21930 
    self.estimate = estimate
4369 rajveer 21931 
    self.isReminder = isReminder
4303 rajveer 21932 
 
21933 
  def read(self, iprot):
21934 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21935 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21936 
      return
21937 
    iprot.readStructBegin()
21938 
    while True:
21939 
      (fname, ftype, fid) = iprot.readFieldBegin()
21940 
      if ftype == TType.STOP:
21941 
        break
21942 
      if fid == 1:
21943 
        if ftype == TType.I64:
21944 
          self.vendorId = iprot.readI64();
21945 
        else:
21946 
          iprot.skip(ftype)
21947 
      elif fid == 2:
21948 
        if ftype == TType.I64:
21949 
          self.itemId = iprot.readI64();
21950 
        else:
21951 
          iprot.skip(ftype)
21952 
      elif fid == 3:
21953 
        if ftype == TType.I64:
21954 
          self.quantity = iprot.readI64();
21955 
        else:
21956 
          iprot.skip(ftype)
21957 
      elif fid == 4:
21958 
        if ftype == TType.I64:
21959 
          self.estimate = iprot.readI64();
21960 
        else:
21961 
          iprot.skip(ftype)
4369 rajveer 21962 
      elif fid == 5:
21963 
        if ftype == TType.BOOL:
21964 
          self.isReminder = iprot.readBool();
21965 
        else:
21966 
          iprot.skip(ftype)
4303 rajveer 21967 
      else:
21968 
        iprot.skip(ftype)
21969 
      iprot.readFieldEnd()
21970 
    iprot.readStructEnd()
21971 
 
21972 
  def write(self, oprot):
21973 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21974 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21975 
      return
21976 
    oprot.writeStructBegin('markOrdersAsReversalInitiated_args')
21977 
    if self.vendorId is not None:
21978 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
21979 
      oprot.writeI64(self.vendorId)
21980 
      oprot.writeFieldEnd()
21981 
    if self.itemId is not None:
21982 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
21983 
      oprot.writeI64(self.itemId)
21984 
      oprot.writeFieldEnd()
21985 
    if self.quantity is not None:
21986 
      oprot.writeFieldBegin('quantity', TType.I64, 3)
21987 
      oprot.writeI64(self.quantity)
21988 
      oprot.writeFieldEnd()
21989 
    if self.estimate is not None:
21990 
      oprot.writeFieldBegin('estimate', TType.I64, 4)
21991 
      oprot.writeI64(self.estimate)
21992 
      oprot.writeFieldEnd()
4369 rajveer 21993 
    if self.isReminder is not None:
21994 
      oprot.writeFieldBegin('isReminder', TType.BOOL, 5)
21995 
      oprot.writeBool(self.isReminder)
21996 
      oprot.writeFieldEnd()
4303 rajveer 21997 
    oprot.writeFieldStop()
21998 
    oprot.writeStructEnd()
21999 
 
22000 
  def validate(self):
22001 
    return
22002 
 
22003 
 
22004 
  def __repr__(self):
22005 
    L = ['%s=%r' % (key, value)
22006 
      for key, value in self.__dict__.iteritems()]
22007 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22008 
 
22009 
  def __eq__(self, other):
22010 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22011 
 
22012 
  def __ne__(self, other):
22013 
    return not (self == other)
22014 
 
22015 
class markOrdersAsReversalInitiated_result:
22016 
  """
22017 
  Attributes:
22018 
   - ex
22019 
  """
22020 
 
22021 
  thrift_spec = (
22022 
    None, # 0
22023 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
22024 
  )
22025 
 
22026 
  def __init__(self, ex=None,):
22027 
    self.ex = ex
22028 
 
22029 
  def read(self, iprot):
22030 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22031 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22032 
      return
22033 
    iprot.readStructBegin()
22034 
    while True:
22035 
      (fname, ftype, fid) = iprot.readFieldBegin()
22036 
      if ftype == TType.STOP:
22037 
        break
22038 
      if fid == 1:
22039 
        if ftype == TType.STRUCT:
22040 
          self.ex = TransactionServiceException()
22041 
          self.ex.read(iprot)
22042 
        else:
22043 
          iprot.skip(ftype)
22044 
      else:
22045 
        iprot.skip(ftype)
22046 
      iprot.readFieldEnd()
22047 
    iprot.readStructEnd()
22048 
 
22049 
  def write(self, oprot):
22050 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22051 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22052 
      return
22053 
    oprot.writeStructBegin('markOrdersAsReversalInitiated_result')
22054 
    if self.ex is not None:
22055 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
22056 
      self.ex.write(oprot)
22057 
      oprot.writeFieldEnd()
22058 
    oprot.writeFieldStop()
22059 
    oprot.writeStructEnd()
22060 
 
22061 
  def validate(self):
22062 
    return
22063 
 
22064 
 
22065 
  def __repr__(self):
22066 
    L = ['%s=%r' % (key, value)
22067 
      for key, value in self.__dict__.iteritems()]
22068 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22069 
 
22070 
  def __eq__(self, other):
22071 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22072 
 
22073 
  def __ne__(self, other):
22074 
    return not (self == other)
22075 
 
22076 
class markOrdersAsNotAvailabke_args:
22077 
  """
22078 
  Attributes:
22079 
   - vendorId
22080 
   - itemId
22081 
   - quantity
22082 
   - estimate
4369 rajveer 22083 
   - isReminder
4303 rajveer 22084 
  """
22085 
 
22086 
  thrift_spec = (
22087 
    None, # 0
22088 
    (1, TType.I64, 'vendorId', None, None, ), # 1
22089 
    (2, TType.I64, 'itemId', None, None, ), # 2
22090 
    (3, TType.I64, 'quantity', None, None, ), # 3
22091 
    (4, TType.I64, 'estimate', None, None, ), # 4
4369 rajveer 22092 
    (5, TType.BOOL, 'isReminder', None, None, ), # 5
4303 rajveer 22093 
  )
22094 
 
4369 rajveer 22095 
  def __init__(self, vendorId=None, itemId=None, quantity=None, estimate=None, isReminder=None,):
4303 rajveer 22096 
    self.vendorId = vendorId
22097 
    self.itemId = itemId
22098 
    self.quantity = quantity
22099 
    self.estimate = estimate
4369 rajveer 22100 
    self.isReminder = isReminder
4303 rajveer 22101 
 
22102 
  def read(self, iprot):
22103 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22104 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22105 
      return
22106 
    iprot.readStructBegin()
22107 
    while True:
22108 
      (fname, ftype, fid) = iprot.readFieldBegin()
22109 
      if ftype == TType.STOP:
22110 
        break
22111 
      if fid == 1:
22112 
        if ftype == TType.I64:
22113 
          self.vendorId = iprot.readI64();
22114 
        else:
22115 
          iprot.skip(ftype)
22116 
      elif fid == 2:
22117 
        if ftype == TType.I64:
22118 
          self.itemId = iprot.readI64();
22119 
        else:
22120 
          iprot.skip(ftype)
22121 
      elif fid == 3:
22122 
        if ftype == TType.I64:
22123 
          self.quantity = iprot.readI64();
22124 
        else:
22125 
          iprot.skip(ftype)
22126 
      elif fid == 4:
22127 
        if ftype == TType.I64:
22128 
          self.estimate = iprot.readI64();
22129 
        else:
22130 
          iprot.skip(ftype)
4369 rajveer 22131 
      elif fid == 5:
22132 
        if ftype == TType.BOOL:
22133 
          self.isReminder = iprot.readBool();
22134 
        else:
22135 
          iprot.skip(ftype)
4303 rajveer 22136 
      else:
22137 
        iprot.skip(ftype)
22138 
      iprot.readFieldEnd()
22139 
    iprot.readStructEnd()
22140 
 
22141 
  def write(self, oprot):
22142 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22143 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22144 
      return
22145 
    oprot.writeStructBegin('markOrdersAsNotAvailabke_args')
22146 
    if self.vendorId is not None:
22147 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
22148 
      oprot.writeI64(self.vendorId)
22149 
      oprot.writeFieldEnd()
22150 
    if self.itemId is not None:
22151 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
22152 
      oprot.writeI64(self.itemId)
22153 
      oprot.writeFieldEnd()
22154 
    if self.quantity is not None:
22155 
      oprot.writeFieldBegin('quantity', TType.I64, 3)
22156 
      oprot.writeI64(self.quantity)
22157 
      oprot.writeFieldEnd()
22158 
    if self.estimate is not None:
22159 
      oprot.writeFieldBegin('estimate', TType.I64, 4)
22160 
      oprot.writeI64(self.estimate)
22161 
      oprot.writeFieldEnd()
4369 rajveer 22162 
    if self.isReminder is not None:
22163 
      oprot.writeFieldBegin('isReminder', TType.BOOL, 5)
22164 
      oprot.writeBool(self.isReminder)
22165 
      oprot.writeFieldEnd()
4303 rajveer 22166 
    oprot.writeFieldStop()
22167 
    oprot.writeStructEnd()
22168 
 
22169 
  def validate(self):
22170 
    return
22171 
 
22172 
 
22173 
  def __repr__(self):
22174 
    L = ['%s=%r' % (key, value)
22175 
      for key, value in self.__dict__.iteritems()]
22176 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22177 
 
22178 
  def __eq__(self, other):
22179 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22180 
 
22181 
  def __ne__(self, other):
22182 
    return not (self == other)
22183 
 
22184 
class markOrdersAsNotAvailabke_result:
22185 
  """
22186 
  Attributes:
22187 
   - ex
22188 
  """
22189 
 
22190 
  thrift_spec = (
22191 
    None, # 0
22192 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
22193 
  )
22194 
 
22195 
  def __init__(self, ex=None,):
22196 
    self.ex = ex
22197 
 
22198 
  def read(self, iprot):
22199 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22200 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22201 
      return
22202 
    iprot.readStructBegin()
22203 
    while True:
22204 
      (fname, ftype, fid) = iprot.readFieldBegin()
22205 
      if ftype == TType.STOP:
22206 
        break
22207 
      if fid == 1:
22208 
        if ftype == TType.STRUCT:
22209 
          self.ex = TransactionServiceException()
22210 
          self.ex.read(iprot)
22211 
        else:
22212 
          iprot.skip(ftype)
22213 
      else:
22214 
        iprot.skip(ftype)
22215 
      iprot.readFieldEnd()
22216 
    iprot.readStructEnd()
22217 
 
22218 
  def write(self, oprot):
22219 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22220 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22221 
      return
22222 
    oprot.writeStructBegin('markOrdersAsNotAvailabke_result')
22223 
    if self.ex is not None:
22224 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
22225 
      self.ex.write(oprot)
22226 
      oprot.writeFieldEnd()
22227 
    oprot.writeFieldStop()
22228 
    oprot.writeStructEnd()
22229 
 
22230 
  def validate(self):
22231 
    return
22232 
 
22233 
 
22234 
  def __repr__(self):
22235 
    L = ['%s=%r' % (key, value)
22236 
      for key, value in self.__dict__.iteritems()]
22237 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22238 
 
22239 
  def __eq__(self, other):
22240 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22241 
 
22242 
  def __ne__(self, other):
22243 
    return not (self == other)
4369 rajveer 22244 
 
22245 
class markOrdersAsTimeout_args:
22246 
  """
22247 
  Attributes:
22248 
   - vendorId
22249 
  """
22250 
 
22251 
  thrift_spec = (
22252 
    None, # 0
22253 
    (1, TType.I64, 'vendorId', None, None, ), # 1
22254 
  )
22255 
 
22256 
  def __init__(self, vendorId=None,):
22257 
    self.vendorId = vendorId
22258 
 
22259 
  def read(self, iprot):
22260 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22261 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22262 
      return
22263 
    iprot.readStructBegin()
22264 
    while True:
22265 
      (fname, ftype, fid) = iprot.readFieldBegin()
22266 
      if ftype == TType.STOP:
22267 
        break
22268 
      if fid == 1:
22269 
        if ftype == TType.I64:
22270 
          self.vendorId = iprot.readI64();
22271 
        else:
22272 
          iprot.skip(ftype)
22273 
      else:
22274 
        iprot.skip(ftype)
22275 
      iprot.readFieldEnd()
22276 
    iprot.readStructEnd()
22277 
 
22278 
  def write(self, oprot):
22279 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22280 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22281 
      return
22282 
    oprot.writeStructBegin('markOrdersAsTimeout_args')
22283 
    if self.vendorId is not None:
22284 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
22285 
      oprot.writeI64(self.vendorId)
22286 
      oprot.writeFieldEnd()
22287 
    oprot.writeFieldStop()
22288 
    oprot.writeStructEnd()
22289 
 
22290 
  def validate(self):
22291 
    return
22292 
 
22293 
 
22294 
  def __repr__(self):
22295 
    L = ['%s=%r' % (key, value)
22296 
      for key, value in self.__dict__.iteritems()]
22297 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22298 
 
22299 
  def __eq__(self, other):
22300 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22301 
 
22302 
  def __ne__(self, other):
22303 
    return not (self == other)
22304 
 
22305 
class markOrdersAsTimeout_result:
22306 
  """
22307 
  Attributes:
22308 
   - success
22309 
   - ex
22310 
  """
22311 
 
22312 
  thrift_spec = (
22313 
    (0, TType.MAP, 'success', (TType.I32,None,TType.STRUCT,(TimeoutSummary, TimeoutSummary.thrift_spec)), None, ), # 0
22314 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
22315 
  )
22316 
 
22317 
  def __init__(self, success=None, ex=None,):
22318 
    self.success = success
22319 
    self.ex = ex
22320 
 
22321 
  def read(self, iprot):
22322 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22323 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22324 
      return
22325 
    iprot.readStructBegin()
22326 
    while True:
22327 
      (fname, ftype, fid) = iprot.readFieldBegin()
22328 
      if ftype == TType.STOP:
22329 
        break
22330 
      if fid == 0:
22331 
        if ftype == TType.MAP:
22332 
          self.success = {}
6188 rajveer 22333 
          (_ktype502, _vtype503, _size501 ) = iprot.readMapBegin()
22334 
          for _i505 in xrange(_size501):
22335 
            _key506 = iprot.readI32();
22336 
            _val507 = TimeoutSummary()
22337 
            _val507.read(iprot)
22338 
            self.success[_key506] = _val507
4369 rajveer 22339 
          iprot.readMapEnd()
22340 
        else:
22341 
          iprot.skip(ftype)
22342 
      elif fid == 1:
22343 
        if ftype == TType.STRUCT:
22344 
          self.ex = TransactionServiceException()
22345 
          self.ex.read(iprot)
22346 
        else:
22347 
          iprot.skip(ftype)
22348 
      else:
22349 
        iprot.skip(ftype)
22350 
      iprot.readFieldEnd()
22351 
    iprot.readStructEnd()
22352 
 
22353 
  def write(self, oprot):
22354 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22355 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22356 
      return
22357 
    oprot.writeStructBegin('markOrdersAsTimeout_result')
22358 
    if self.success is not None:
22359 
      oprot.writeFieldBegin('success', TType.MAP, 0)
22360 
      oprot.writeMapBegin(TType.I32, TType.STRUCT, len(self.success))
6188 rajveer 22361 
      for kiter508,viter509 in self.success.items():
22362 
        oprot.writeI32(kiter508)
22363 
        viter509.write(oprot)
4369 rajveer 22364 
      oprot.writeMapEnd()
22365 
      oprot.writeFieldEnd()
22366 
    if self.ex is not None:
22367 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
22368 
      self.ex.write(oprot)
22369 
      oprot.writeFieldEnd()
22370 
    oprot.writeFieldStop()
22371 
    oprot.writeStructEnd()
22372 
 
22373 
  def validate(self):
22374 
    return
22375 
 
22376 
 
22377 
  def __repr__(self):
22378 
    L = ['%s=%r' % (key, value)
22379 
      for key, value in self.__dict__.iteritems()]
22380 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22381 
 
22382 
  def __eq__(self, other):
22383 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22384 
 
22385 
  def __ne__(self, other):
22386 
    return not (self == other)
4386 anupam.sin 22387 
 
4662 rajveer 22388 
class markOrderAsLostInTransit_args:
22389 
  """
22390 
  Attributes:
22391 
   - orderId
22392 
  """
22393 
 
22394 
  thrift_spec = (
22395 
    None, # 0
22396 
    (1, TType.I64, 'orderId', None, None, ), # 1
22397 
  )
22398 
 
22399 
  def __init__(self, orderId=None,):
22400 
    self.orderId = orderId
22401 
 
22402 
  def read(self, iprot):
22403 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22404 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22405 
      return
22406 
    iprot.readStructBegin()
22407 
    while True:
22408 
      (fname, ftype, fid) = iprot.readFieldBegin()
22409 
      if ftype == TType.STOP:
22410 
        break
22411 
      if fid == 1:
22412 
        if ftype == TType.I64:
22413 
          self.orderId = iprot.readI64();
22414 
        else:
22415 
          iprot.skip(ftype)
22416 
      else:
22417 
        iprot.skip(ftype)
22418 
      iprot.readFieldEnd()
22419 
    iprot.readStructEnd()
22420 
 
22421 
  def write(self, oprot):
22422 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22423 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22424 
      return
22425 
    oprot.writeStructBegin('markOrderAsLostInTransit_args')
22426 
    if self.orderId is not None:
22427 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
22428 
      oprot.writeI64(self.orderId)
22429 
      oprot.writeFieldEnd()
22430 
    oprot.writeFieldStop()
22431 
    oprot.writeStructEnd()
22432 
 
22433 
  def validate(self):
22434 
    return
22435 
 
22436 
 
22437 
  def __repr__(self):
22438 
    L = ['%s=%r' % (key, value)
22439 
      for key, value in self.__dict__.iteritems()]
22440 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22441 
 
22442 
  def __eq__(self, other):
22443 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22444 
 
22445 
  def __ne__(self, other):
22446 
    return not (self == other)
22447 
 
22448 
class markOrderAsLostInTransit_result:
22449 
  """
22450 
  Attributes:
22451 
   - success
22452 
   - ex
22453 
  """
22454 
 
22455 
  thrift_spec = (
22456 
    (0, TType.BOOL, 'success', None, None, ), # 0
22457 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
22458 
  )
22459 
 
22460 
  def __init__(self, success=None, ex=None,):
22461 
    self.success = success
22462 
    self.ex = ex
22463 
 
22464 
  def read(self, iprot):
22465 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22466 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22467 
      return
22468 
    iprot.readStructBegin()
22469 
    while True:
22470 
      (fname, ftype, fid) = iprot.readFieldBegin()
22471 
      if ftype == TType.STOP:
22472 
        break
22473 
      if fid == 0:
22474 
        if ftype == TType.BOOL:
22475 
          self.success = iprot.readBool();
22476 
        else:
22477 
          iprot.skip(ftype)
22478 
      elif fid == 1:
22479 
        if ftype == TType.STRUCT:
22480 
          self.ex = TransactionServiceException()
22481 
          self.ex.read(iprot)
22482 
        else:
22483 
          iprot.skip(ftype)
22484 
      else:
22485 
        iprot.skip(ftype)
22486 
      iprot.readFieldEnd()
22487 
    iprot.readStructEnd()
22488 
 
22489 
  def write(self, oprot):
22490 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22491 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22492 
      return
22493 
    oprot.writeStructBegin('markOrderAsLostInTransit_result')
22494 
    if self.success is not None:
22495 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
22496 
      oprot.writeBool(self.success)
22497 
      oprot.writeFieldEnd()
22498 
    if self.ex is not None:
22499 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
22500 
      self.ex.write(oprot)
22501 
      oprot.writeFieldEnd()
22502 
    oprot.writeFieldStop()
22503 
    oprot.writeStructEnd()
22504 
 
22505 
  def validate(self):
22506 
    return
22507 
 
22508 
 
22509 
  def __repr__(self):
22510 
    L = ['%s=%r' % (key, value)
22511 
      for key, value in self.__dict__.iteritems()]
22512 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22513 
 
22514 
  def __eq__(self, other):
22515 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22516 
 
22517 
  def __ne__(self, other):
22518 
    return not (self == other)
22519 
 
4386 anupam.sin 22520 
class getOrderForAwb_args:
22521 
  """
22522 
  Attributes:
22523 
   - awb
22524 
  """
22525 
 
22526 
  thrift_spec = (
22527 
    None, # 0
22528 
    (1, TType.STRING, 'awb', None, None, ), # 1
22529 
  )
22530 
 
22531 
  def __init__(self, awb=None,):
22532 
    self.awb = awb
22533 
 
22534 
  def read(self, iprot):
22535 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22536 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22537 
      return
22538 
    iprot.readStructBegin()
22539 
    while True:
22540 
      (fname, ftype, fid) = iprot.readFieldBegin()
22541 
      if ftype == TType.STOP:
22542 
        break
22543 
      if fid == 1:
22544 
        if ftype == TType.STRING:
22545 
          self.awb = iprot.readString();
22546 
        else:
22547 
          iprot.skip(ftype)
22548 
      else:
22549 
        iprot.skip(ftype)
22550 
      iprot.readFieldEnd()
22551 
    iprot.readStructEnd()
22552 
 
22553 
  def write(self, oprot):
22554 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22555 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22556 
      return
22557 
    oprot.writeStructBegin('getOrderForAwb_args')
22558 
    if self.awb is not None:
22559 
      oprot.writeFieldBegin('awb', TType.STRING, 1)
22560 
      oprot.writeString(self.awb)
22561 
      oprot.writeFieldEnd()
22562 
    oprot.writeFieldStop()
22563 
    oprot.writeStructEnd()
22564 
 
22565 
  def validate(self):
22566 
    return
22567 
 
22568 
 
22569 
  def __repr__(self):
22570 
    L = ['%s=%r' % (key, value)
22571 
      for key, value in self.__dict__.iteritems()]
22572 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22573 
 
22574 
  def __eq__(self, other):
22575 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22576 
 
22577 
  def __ne__(self, other):
22578 
    return not (self == other)
22579 
 
22580 
class getOrderForAwb_result:
22581 
  """
22582 
  Attributes:
22583 
   - success
22584 
   - ex
22585 
  """
22586 
 
22587 
  thrift_spec = (
22588 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
22589 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
22590 
  )
22591 
 
22592 
  def __init__(self, success=None, ex=None,):
22593 
    self.success = success
22594 
    self.ex = ex
22595 
 
22596 
  def read(self, iprot):
22597 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22598 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22599 
      return
22600 
    iprot.readStructBegin()
22601 
    while True:
22602 
      (fname, ftype, fid) = iprot.readFieldBegin()
22603 
      if ftype == TType.STOP:
22604 
        break
22605 
      if fid == 0:
22606 
        if ftype == TType.STRUCT:
22607 
          self.success = Order()
22608 
          self.success.read(iprot)
22609 
        else:
22610 
          iprot.skip(ftype)
22611 
      elif fid == 1:
22612 
        if ftype == TType.STRUCT:
22613 
          self.ex = TransactionServiceException()
22614 
          self.ex.read(iprot)
22615 
        else:
22616 
          iprot.skip(ftype)
22617 
      else:
22618 
        iprot.skip(ftype)
22619 
      iprot.readFieldEnd()
22620 
    iprot.readStructEnd()
22621 
 
22622 
  def write(self, oprot):
22623 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22624 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22625 
      return
22626 
    oprot.writeStructBegin('getOrderForAwb_result')
22627 
    if self.success is not None:
22628 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
22629 
      self.success.write(oprot)
22630 
      oprot.writeFieldEnd()
22631 
    if self.ex is not None:
22632 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
22633 
      self.ex.write(oprot)
22634 
      oprot.writeFieldEnd()
22635 
    oprot.writeFieldStop()
22636 
    oprot.writeStructEnd()
22637 
 
22638 
  def validate(self):
22639 
    return
22640 
 
22641 
 
22642 
  def __repr__(self):
22643 
    L = ['%s=%r' % (key, value)
22644 
      for key, value in self.__dict__.iteritems()]
22645 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22646 
 
22647 
  def __eq__(self, other):
22648 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22649 
 
22650 
  def __ne__(self, other):
22651 
    return not (self == other)
4506 phani.kuma 22652 
 
22653 
class getOrdersForProviderForStatus_args:
22654 
  """
22655 
  Attributes:
22656 
   - logistics_provider_id
4910 phani.kuma 22657 
   - order_status_list
4506 phani.kuma 22658 
  """
22659 
 
22660 
  thrift_spec = (
22661 
    None, # 0
22662 
    (1, TType.I64, 'logistics_provider_id', None, None, ), # 1
4910 phani.kuma 22663 
    (2, TType.LIST, 'order_status_list', (TType.I32,None), None, ), # 2
4506 phani.kuma 22664 
  )
22665 
 
4910 phani.kuma 22666 
  def __init__(self, logistics_provider_id=None, order_status_list=None,):
4506 phani.kuma 22667 
    self.logistics_provider_id = logistics_provider_id
4910 phani.kuma 22668 
    self.order_status_list = order_status_list
4506 phani.kuma 22669 
 
22670 
  def read(self, iprot):
22671 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22672 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22673 
      return
22674 
    iprot.readStructBegin()
22675 
    while True:
22676 
      (fname, ftype, fid) = iprot.readFieldBegin()
22677 
      if ftype == TType.STOP:
22678 
        break
22679 
      if fid == 1:
22680 
        if ftype == TType.I64:
22681 
          self.logistics_provider_id = iprot.readI64();
22682 
        else:
22683 
          iprot.skip(ftype)
22684 
      elif fid == 2:
4910 phani.kuma 22685 
        if ftype == TType.LIST:
22686 
          self.order_status_list = []
6188 rajveer 22687 
          (_etype513, _size510) = iprot.readListBegin()
22688 
          for _i514 in xrange(_size510):
22689 
            _elem515 = iprot.readI32();
22690 
            self.order_status_list.append(_elem515)
4910 phani.kuma 22691 
          iprot.readListEnd()
4506 phani.kuma 22692 
        else:
22693 
          iprot.skip(ftype)
22694 
      else:
22695 
        iprot.skip(ftype)
22696 
      iprot.readFieldEnd()
22697 
    iprot.readStructEnd()
22698 
 
22699 
  def write(self, oprot):
22700 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22701 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22702 
      return
22703 
    oprot.writeStructBegin('getOrdersForProviderForStatus_args')
22704 
    if self.logistics_provider_id is not None:
22705 
      oprot.writeFieldBegin('logistics_provider_id', TType.I64, 1)
22706 
      oprot.writeI64(self.logistics_provider_id)
22707 
      oprot.writeFieldEnd()
4910 phani.kuma 22708 
    if self.order_status_list is not None:
22709 
      oprot.writeFieldBegin('order_status_list', TType.LIST, 2)
22710 
      oprot.writeListBegin(TType.I32, len(self.order_status_list))
6188 rajveer 22711 
      for iter516 in self.order_status_list:
22712 
        oprot.writeI32(iter516)
4910 phani.kuma 22713 
      oprot.writeListEnd()
4506 phani.kuma 22714 
      oprot.writeFieldEnd()
22715 
    oprot.writeFieldStop()
22716 
    oprot.writeStructEnd()
22717 
 
22718 
  def validate(self):
22719 
    return
22720 
 
22721 
 
22722 
  def __repr__(self):
22723 
    L = ['%s=%r' % (key, value)
22724 
      for key, value in self.__dict__.iteritems()]
22725 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22726 
 
22727 
  def __eq__(self, other):
22728 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22729 
 
22730 
  def __ne__(self, other):
22731 
    return not (self == other)
22732 
 
22733 
class getOrdersForProviderForStatus_result:
22734 
  """
22735 
  Attributes:
22736 
   - success
22737 
   - ex
22738 
  """
22739 
 
22740 
  thrift_spec = (
22741 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
22742 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
22743 
  )
22744 
 
22745 
  def __init__(self, success=None, ex=None,):
22746 
    self.success = success
22747 
    self.ex = ex
22748 
 
22749 
  def read(self, iprot):
22750 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22751 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22752 
      return
22753 
    iprot.readStructBegin()
22754 
    while True:
22755 
      (fname, ftype, fid) = iprot.readFieldBegin()
22756 
      if ftype == TType.STOP:
22757 
        break
22758 
      if fid == 0:
22759 
        if ftype == TType.LIST:
22760 
          self.success = []
6188 rajveer 22761 
          (_etype520, _size517) = iprot.readListBegin()
22762 
          for _i521 in xrange(_size517):
22763 
            _elem522 = Order()
22764 
            _elem522.read(iprot)
22765 
            self.success.append(_elem522)
4506 phani.kuma 22766 
          iprot.readListEnd()
22767 
        else:
22768 
          iprot.skip(ftype)
22769 
      elif fid == 1:
22770 
        if ftype == TType.STRUCT:
22771 
          self.ex = TransactionServiceException()
22772 
          self.ex.read(iprot)
22773 
        else:
22774 
          iprot.skip(ftype)
22775 
      else:
22776 
        iprot.skip(ftype)
22777 
      iprot.readFieldEnd()
22778 
    iprot.readStructEnd()
22779 
 
22780 
  def write(self, oprot):
22781 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22782 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22783 
      return
22784 
    oprot.writeStructBegin('getOrdersForProviderForStatus_result')
22785 
    if self.success is not None:
22786 
      oprot.writeFieldBegin('success', TType.LIST, 0)
22787 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 22788 
      for iter523 in self.success:
22789 
        iter523.write(oprot)
4506 phani.kuma 22790 
      oprot.writeListEnd()
22791 
      oprot.writeFieldEnd()
22792 
    if self.ex is not None:
22793 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
22794 
      self.ex.write(oprot)
22795 
      oprot.writeFieldEnd()
22796 
    oprot.writeFieldStop()
22797 
    oprot.writeStructEnd()
22798 
 
22799 
  def validate(self):
22800 
    return
22801 
 
22802 
 
22803 
  def __repr__(self):
22804 
    L = ['%s=%r' % (key, value)
22805 
      for key, value in self.__dict__.iteritems()]
22806 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22807 
 
22808 
  def __eq__(self, other):
22809 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22810 
 
22811 
  def __ne__(self, other):
22812 
    return not (self == other)
4600 varun.gupt 22813 
 
22814 
class getBilledOrdersForVendor_args:
22815 
  """
22816 
  Attributes:
22817 
   - vendorId
22818 
   - billingDateFrom
22819 
   - billingDateTo
22820 
  """
22821 
 
22822 
  thrift_spec = (
22823 
    None, # 0
22824 
    (1, TType.I64, 'vendorId', None, None, ), # 1
22825 
    (2, TType.I64, 'billingDateFrom', None, None, ), # 2
22826 
    (3, TType.I64, 'billingDateTo', None, None, ), # 3
22827 
  )
22828 
 
22829 
  def __init__(self, vendorId=None, billingDateFrom=None, billingDateTo=None,):
22830 
    self.vendorId = vendorId
22831 
    self.billingDateFrom = billingDateFrom
22832 
    self.billingDateTo = billingDateTo
22833 
 
22834 
  def read(self, iprot):
22835 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22836 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22837 
      return
22838 
    iprot.readStructBegin()
22839 
    while True:
22840 
      (fname, ftype, fid) = iprot.readFieldBegin()
22841 
      if ftype == TType.STOP:
22842 
        break
22843 
      if fid == 1:
22844 
        if ftype == TType.I64:
22845 
          self.vendorId = iprot.readI64();
22846 
        else:
22847 
          iprot.skip(ftype)
22848 
      elif fid == 2:
22849 
        if ftype == TType.I64:
22850 
          self.billingDateFrom = iprot.readI64();
22851 
        else:
22852 
          iprot.skip(ftype)
22853 
      elif fid == 3:
22854 
        if ftype == TType.I64:
22855 
          self.billingDateTo = iprot.readI64();
22856 
        else:
22857 
          iprot.skip(ftype)
22858 
      else:
22859 
        iprot.skip(ftype)
22860 
      iprot.readFieldEnd()
22861 
    iprot.readStructEnd()
22862 
 
22863 
  def write(self, oprot):
22864 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22865 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22866 
      return
22867 
    oprot.writeStructBegin('getBilledOrdersForVendor_args')
22868 
    if self.vendorId is not None:
22869 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
22870 
      oprot.writeI64(self.vendorId)
22871 
      oprot.writeFieldEnd()
22872 
    if self.billingDateFrom is not None:
22873 
      oprot.writeFieldBegin('billingDateFrom', TType.I64, 2)
22874 
      oprot.writeI64(self.billingDateFrom)
22875 
      oprot.writeFieldEnd()
22876 
    if self.billingDateTo is not None:
22877 
      oprot.writeFieldBegin('billingDateTo', TType.I64, 3)
22878 
      oprot.writeI64(self.billingDateTo)
22879 
      oprot.writeFieldEnd()
22880 
    oprot.writeFieldStop()
22881 
    oprot.writeStructEnd()
22882 
 
22883 
  def validate(self):
22884 
    return
22885 
 
22886 
 
22887 
  def __repr__(self):
22888 
    L = ['%s=%r' % (key, value)
22889 
      for key, value in self.__dict__.iteritems()]
22890 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22891 
 
22892 
  def __eq__(self, other):
22893 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22894 
 
22895 
  def __ne__(self, other):
22896 
    return not (self == other)
22897 
 
22898 
class getBilledOrdersForVendor_result:
22899 
  """
22900 
  Attributes:
22901 
   - success
22902 
   - ex
22903 
  """
22904 
 
22905 
  thrift_spec = (
22906 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
22907 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
22908 
  )
22909 
 
22910 
  def __init__(self, success=None, ex=None,):
22911 
    self.success = success
22912 
    self.ex = ex
22913 
 
22914 
  def read(self, iprot):
22915 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22916 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22917 
      return
22918 
    iprot.readStructBegin()
22919 
    while True:
22920 
      (fname, ftype, fid) = iprot.readFieldBegin()
22921 
      if ftype == TType.STOP:
22922 
        break
22923 
      if fid == 0:
22924 
        if ftype == TType.LIST:
22925 
          self.success = []
6188 rajveer 22926 
          (_etype527, _size524) = iprot.readListBegin()
22927 
          for _i528 in xrange(_size524):
22928 
            _elem529 = Order()
22929 
            _elem529.read(iprot)
22930 
            self.success.append(_elem529)
4600 varun.gupt 22931 
          iprot.readListEnd()
22932 
        else:
22933 
          iprot.skip(ftype)
22934 
      elif fid == 1:
22935 
        if ftype == TType.STRUCT:
22936 
          self.ex = TransactionServiceException()
22937 
          self.ex.read(iprot)
22938 
        else:
22939 
          iprot.skip(ftype)
22940 
      else:
22941 
        iprot.skip(ftype)
22942 
      iprot.readFieldEnd()
22943 
    iprot.readStructEnd()
22944 
 
22945 
  def write(self, oprot):
22946 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22947 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22948 
      return
22949 
    oprot.writeStructBegin('getBilledOrdersForVendor_result')
22950 
    if self.success is not None:
22951 
      oprot.writeFieldBegin('success', TType.LIST, 0)
22952 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 22953 
      for iter530 in self.success:
22954 
        iter530.write(oprot)
4600 varun.gupt 22955 
      oprot.writeListEnd()
22956 
      oprot.writeFieldEnd()
22957 
    if self.ex is not None:
22958 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
22959 
      self.ex.write(oprot)
22960 
      oprot.writeFieldEnd()
22961 
    oprot.writeFieldStop()
22962 
    oprot.writeStructEnd()
22963 
 
22964 
  def validate(self):
22965 
    return
22966 
 
22967 
 
22968 
  def __repr__(self):
22969 
    L = ['%s=%r' % (key, value)
22970 
      for key, value in self.__dict__.iteritems()]
22971 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22972 
 
22973 
  def __eq__(self, other):
22974 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22975 
 
22976 
  def __ne__(self, other):
22977 
    return not (self == other)
22978 
 
4607 rajveer 22979 
class getSlippedSippingDateOrders_args:
22980 
 
22981 
  thrift_spec = (
22982 
  )
22983 
 
22984 
  def read(self, iprot):
22985 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22986 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22987 
      return
22988 
    iprot.readStructBegin()
22989 
    while True:
22990 
      (fname, ftype, fid) = iprot.readFieldBegin()
22991 
      if ftype == TType.STOP:
22992 
        break
22993 
      else:
22994 
        iprot.skip(ftype)
22995 
      iprot.readFieldEnd()
22996 
    iprot.readStructEnd()
22997 
 
22998 
  def write(self, oprot):
22999 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23000 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23001 
      return
23002 
    oprot.writeStructBegin('getSlippedSippingDateOrders_args')
23003 
    oprot.writeFieldStop()
23004 
    oprot.writeStructEnd()
23005 
 
23006 
  def validate(self):
23007 
    return
23008 
 
23009 
 
23010 
  def __repr__(self):
23011 
    L = ['%s=%r' % (key, value)
23012 
      for key, value in self.__dict__.iteritems()]
23013 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23014 
 
23015 
  def __eq__(self, other):
23016 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23017 
 
23018 
  def __ne__(self, other):
23019 
    return not (self == other)
23020 
 
23021 
class getSlippedSippingDateOrders_result:
23022 
  """
23023 
  Attributes:
23024 
   - success
23025 
   - ex
23026 
  """
23027 
 
23028 
  thrift_spec = (
23029 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
23030 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
23031 
  )
23032 
 
23033 
  def __init__(self, success=None, ex=None,):
23034 
    self.success = success
23035 
    self.ex = ex
23036 
 
23037 
  def read(self, iprot):
23038 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23039 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23040 
      return
23041 
    iprot.readStructBegin()
23042 
    while True:
23043 
      (fname, ftype, fid) = iprot.readFieldBegin()
23044 
      if ftype == TType.STOP:
23045 
        break
23046 
      if fid == 0:
23047 
        if ftype == TType.LIST:
23048 
          self.success = []
6188 rajveer 23049 
          (_etype534, _size531) = iprot.readListBegin()
23050 
          for _i535 in xrange(_size531):
23051 
            _elem536 = Order()
23052 
            _elem536.read(iprot)
23053 
            self.success.append(_elem536)
4607 rajveer 23054 
          iprot.readListEnd()
23055 
        else:
23056 
          iprot.skip(ftype)
23057 
      elif fid == 1:
23058 
        if ftype == TType.STRUCT:
23059 
          self.ex = TransactionServiceException()
23060 
          self.ex.read(iprot)
23061 
        else:
23062 
          iprot.skip(ftype)
23063 
      else:
23064 
        iprot.skip(ftype)
23065 
      iprot.readFieldEnd()
23066 
    iprot.readStructEnd()
23067 
 
23068 
  def write(self, oprot):
23069 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23070 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23071 
      return
23072 
    oprot.writeStructBegin('getSlippedSippingDateOrders_result')
23073 
    if self.success is not None:
23074 
      oprot.writeFieldBegin('success', TType.LIST, 0)
23075 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 23076 
      for iter537 in self.success:
23077 
        iter537.write(oprot)
4607 rajveer 23078 
      oprot.writeListEnd()
23079 
      oprot.writeFieldEnd()
23080 
    if self.ex is not None:
23081 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
23082 
      self.ex.write(oprot)
23083 
      oprot.writeFieldEnd()
23084 
    oprot.writeFieldStop()
23085 
    oprot.writeStructEnd()
23086 
 
23087 
  def validate(self):
23088 
    return
23089 
 
23090 
 
23091 
  def __repr__(self):
23092 
    L = ['%s=%r' % (key, value)
23093 
      for key, value in self.__dict__.iteritems()]
23094 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23095 
 
23096 
  def __eq__(self, other):
23097 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23098 
 
23099 
  def __ne__(self, other):
23100 
    return not (self == other)
23101 
 
4709 rajveer 23102 
class getCancelledOrders_args:
23103 
  """
23104 
  Attributes:
23105 
   - cancelDateFrom
23106 
   - cancelDateTo
23107 
  """
23108 
 
23109 
  thrift_spec = (
23110 
    None, # 0
23111 
    (1, TType.I64, 'cancelDateFrom', None, None, ), # 1
23112 
    (2, TType.I64, 'cancelDateTo', None, None, ), # 2
23113 
  )
23114 
 
23115 
  def __init__(self, cancelDateFrom=None, cancelDateTo=None,):
23116 
    self.cancelDateFrom = cancelDateFrom
23117 
    self.cancelDateTo = cancelDateTo
23118 
 
23119 
  def read(self, iprot):
23120 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23121 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23122 
      return
23123 
    iprot.readStructBegin()
23124 
    while True:
23125 
      (fname, ftype, fid) = iprot.readFieldBegin()
23126 
      if ftype == TType.STOP:
23127 
        break
23128 
      if fid == 1:
23129 
        if ftype == TType.I64:
23130 
          self.cancelDateFrom = iprot.readI64();
23131 
        else:
23132 
          iprot.skip(ftype)
23133 
      elif fid == 2:
23134 
        if ftype == TType.I64:
23135 
          self.cancelDateTo = iprot.readI64();
23136 
        else:
23137 
          iprot.skip(ftype)
23138 
      else:
23139 
        iprot.skip(ftype)
23140 
      iprot.readFieldEnd()
23141 
    iprot.readStructEnd()
23142 
 
23143 
  def write(self, oprot):
23144 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23145 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23146 
      return
23147 
    oprot.writeStructBegin('getCancelledOrders_args')
23148 
    if self.cancelDateFrom is not None:
23149 
      oprot.writeFieldBegin('cancelDateFrom', TType.I64, 1)
23150 
      oprot.writeI64(self.cancelDateFrom)
23151 
      oprot.writeFieldEnd()
23152 
    if self.cancelDateTo is not None:
23153 
      oprot.writeFieldBegin('cancelDateTo', TType.I64, 2)
23154 
      oprot.writeI64(self.cancelDateTo)
23155 
      oprot.writeFieldEnd()
23156 
    oprot.writeFieldStop()
23157 
    oprot.writeStructEnd()
23158 
 
23159 
  def validate(self):
23160 
    return
23161 
 
23162 
 
23163 
  def __repr__(self):
23164 
    L = ['%s=%r' % (key, value)
23165 
      for key, value in self.__dict__.iteritems()]
23166 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23167 
 
23168 
  def __eq__(self, other):
23169 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23170 
 
23171 
  def __ne__(self, other):
23172 
    return not (self == other)
23173 
 
23174 
class getCancelledOrders_result:
23175 
  """
23176 
  Attributes:
23177 
   - success
23178 
   - ex
23179 
  """
23180 
 
23181 
  thrift_spec = (
23182 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
23183 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
23184 
  )
23185 
 
23186 
  def __init__(self, success=None, ex=None,):
23187 
    self.success = success
23188 
    self.ex = ex
23189 
 
23190 
  def read(self, iprot):
23191 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23192 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23193 
      return
23194 
    iprot.readStructBegin()
23195 
    while True:
23196 
      (fname, ftype, fid) = iprot.readFieldBegin()
23197 
      if ftype == TType.STOP:
23198 
        break
23199 
      if fid == 0:
23200 
        if ftype == TType.LIST:
23201 
          self.success = []
6188 rajveer 23202 
          (_etype541, _size538) = iprot.readListBegin()
23203 
          for _i542 in xrange(_size538):
23204 
            _elem543 = Order()
23205 
            _elem543.read(iprot)
23206 
            self.success.append(_elem543)
4709 rajveer 23207 
          iprot.readListEnd()
23208 
        else:
23209 
          iprot.skip(ftype)
23210 
      elif fid == 1:
23211 
        if ftype == TType.STRUCT:
23212 
          self.ex = TransactionServiceException()
23213 
          self.ex.read(iprot)
23214 
        else:
23215 
          iprot.skip(ftype)
23216 
      else:
23217 
        iprot.skip(ftype)
23218 
      iprot.readFieldEnd()
23219 
    iprot.readStructEnd()
23220 
 
23221 
  def write(self, oprot):
23222 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23223 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23224 
      return
23225 
    oprot.writeStructBegin('getCancelledOrders_result')
23226 
    if self.success is not None:
23227 
      oprot.writeFieldBegin('success', TType.LIST, 0)
23228 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 23229 
      for iter544 in self.success:
23230 
        iter544.write(oprot)
4709 rajveer 23231 
      oprot.writeListEnd()
23232 
      oprot.writeFieldEnd()
23233 
    if self.ex is not None:
23234 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
23235 
      self.ex.write(oprot)
23236 
      oprot.writeFieldEnd()
23237 
    oprot.writeFieldStop()
23238 
    oprot.writeStructEnd()
23239 
 
23240 
  def validate(self):
23241 
    return
23242 
 
23243 
 
23244 
  def __repr__(self):
23245 
    L = ['%s=%r' % (key, value)
23246 
      for key, value in self.__dict__.iteritems()]
23247 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23248 
 
23249 
  def __eq__(self, other):
23250 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23251 
 
23252 
  def __ne__(self, other):
23253 
    return not (self == other)
23254 
 
4600 varun.gupt 23255 
class saveBluedartSettlements_args:
23256 
  """
23257 
  Attributes:
23258 
   - mapAWBAndAmount
23259 
  """
23260 
 
23261 
  thrift_spec = (
23262 
    None, # 0
23263 
    (1, TType.MAP, 'mapAWBAndAmount', (TType.I64,None,TType.DOUBLE,None), None, ), # 1
23264 
  )
23265 
 
23266 
  def __init__(self, mapAWBAndAmount=None,):
23267 
    self.mapAWBAndAmount = mapAWBAndAmount
23268 
 
23269 
  def read(self, iprot):
23270 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23271 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23272 
      return
23273 
    iprot.readStructBegin()
23274 
    while True:
23275 
      (fname, ftype, fid) = iprot.readFieldBegin()
23276 
      if ftype == TType.STOP:
23277 
        break
23278 
      if fid == 1:
23279 
        if ftype == TType.MAP:
23280 
          self.mapAWBAndAmount = {}
6188 rajveer 23281 
          (_ktype546, _vtype547, _size545 ) = iprot.readMapBegin()
23282 
          for _i549 in xrange(_size545):
23283 
            _key550 = iprot.readI64();
23284 
            _val551 = iprot.readDouble();
23285 
            self.mapAWBAndAmount[_key550] = _val551
4600 varun.gupt 23286 
          iprot.readMapEnd()
23287 
        else:
23288 
          iprot.skip(ftype)
23289 
      else:
23290 
        iprot.skip(ftype)
23291 
      iprot.readFieldEnd()
23292 
    iprot.readStructEnd()
23293 
 
23294 
  def write(self, oprot):
23295 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23296 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23297 
      return
23298 
    oprot.writeStructBegin('saveBluedartSettlements_args')
23299 
    if self.mapAWBAndAmount is not None:
23300 
      oprot.writeFieldBegin('mapAWBAndAmount', TType.MAP, 1)
23301 
      oprot.writeMapBegin(TType.I64, TType.DOUBLE, len(self.mapAWBAndAmount))
6188 rajveer 23302 
      for kiter552,viter553 in self.mapAWBAndAmount.items():
23303 
        oprot.writeI64(kiter552)
23304 
        oprot.writeDouble(viter553)
4600 varun.gupt 23305 
      oprot.writeMapEnd()
23306 
      oprot.writeFieldEnd()
23307 
    oprot.writeFieldStop()
23308 
    oprot.writeStructEnd()
23309 
 
23310 
  def validate(self):
23311 
    return
23312 
 
23313 
 
23314 
  def __repr__(self):
23315 
    L = ['%s=%r' % (key, value)
23316 
      for key, value in self.__dict__.iteritems()]
23317 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23318 
 
23319 
  def __eq__(self, other):
23320 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23321 
 
23322 
  def __ne__(self, other):
23323 
    return not (self == other)
23324 
 
23325 
class saveBluedartSettlements_result:
23326 
  """
23327 
  Attributes:
23328 
   - ex
23329 
  """
23330 
 
23331 
  thrift_spec = (
23332 
    None, # 0
23333 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
23334 
  )
23335 
 
23336 
  def __init__(self, ex=None,):
23337 
    self.ex = ex
23338 
 
23339 
  def read(self, iprot):
23340 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23341 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23342 
      return
23343 
    iprot.readStructBegin()
23344 
    while True:
23345 
      (fname, ftype, fid) = iprot.readFieldBegin()
23346 
      if ftype == TType.STOP:
23347 
        break
23348 
      if fid == 1:
23349 
        if ftype == TType.STRUCT:
23350 
          self.ex = TransactionServiceException()
23351 
          self.ex.read(iprot)
23352 
        else:
23353 
          iprot.skip(ftype)
23354 
      else:
23355 
        iprot.skip(ftype)
23356 
      iprot.readFieldEnd()
23357 
    iprot.readStructEnd()
23358 
 
23359 
  def write(self, oprot):
23360 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23361 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23362 
      return
23363 
    oprot.writeStructBegin('saveBluedartSettlements_result')
23364 
    if self.ex is not None:
23365 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
23366 
      self.ex.write(oprot)
23367 
      oprot.writeFieldEnd()
23368 
    oprot.writeFieldStop()
23369 
    oprot.writeStructEnd()
23370 
 
23371 
  def validate(self):
23372 
    return
23373 
 
23374 
 
23375 
  def __repr__(self):
23376 
    L = ['%s=%r' % (key, value)
23377 
      for key, value in self.__dict__.iteritems()]
23378 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23379 
 
23380 
  def __eq__(self, other):
23381 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23382 
 
23383 
  def __ne__(self, other):
23384 
    return not (self == other)
23385 
 
23386 
class savePaymentSettlements_args:
23387 
  """
23388 
  Attributes:
23389 
   - settlementDate
23390 
   - paymentGatewayId
4905 varun.gupt 23391 
   - referenceId
4600 varun.gupt 23392 
   - serviceTax
23393 
   - otherCharges
23394 
   - netCollection
23395 
  """
23396 
 
23397 
  thrift_spec = (
23398 
    None, # 0
23399 
    (1, TType.I64, 'settlementDate', None, None, ), # 1
23400 
    (2, TType.I64, 'paymentGatewayId', None, None, ), # 2
4905 varun.gupt 23401 
    (3, TType.I64, 'referenceId', None, None, ), # 3
4600 varun.gupt 23402 
    (4, TType.DOUBLE, 'serviceTax', None, None, ), # 4
23403 
    (5, TType.DOUBLE, 'otherCharges', None, None, ), # 5
23404 
    (6, TType.DOUBLE, 'netCollection', None, None, ), # 6
23405 
  )
23406 
 
4905 varun.gupt 23407 
  def __init__(self, settlementDate=None, paymentGatewayId=None, referenceId=None, serviceTax=None, otherCharges=None, netCollection=None,):
4600 varun.gupt 23408 
    self.settlementDate = settlementDate
23409 
    self.paymentGatewayId = paymentGatewayId
4905 varun.gupt 23410 
    self.referenceId = referenceId
4600 varun.gupt 23411 
    self.serviceTax = serviceTax
23412 
    self.otherCharges = otherCharges
23413 
    self.netCollection = netCollection
23414 
 
23415 
  def read(self, iprot):
23416 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23417 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23418 
      return
23419 
    iprot.readStructBegin()
23420 
    while True:
23421 
      (fname, ftype, fid) = iprot.readFieldBegin()
23422 
      if ftype == TType.STOP:
23423 
        break
23424 
      if fid == 1:
23425 
        if ftype == TType.I64:
23426 
          self.settlementDate = iprot.readI64();
23427 
        else:
23428 
          iprot.skip(ftype)
23429 
      elif fid == 2:
23430 
        if ftype == TType.I64:
23431 
          self.paymentGatewayId = iprot.readI64();
23432 
        else:
23433 
          iprot.skip(ftype)
23434 
      elif fid == 3:
23435 
        if ftype == TType.I64:
4905 varun.gupt 23436 
          self.referenceId = iprot.readI64();
4600 varun.gupt 23437 
        else:
23438 
          iprot.skip(ftype)
23439 
      elif fid == 4:
23440 
        if ftype == TType.DOUBLE:
23441 
          self.serviceTax = iprot.readDouble();
23442 
        else:
23443 
          iprot.skip(ftype)
23444 
      elif fid == 5:
23445 
        if ftype == TType.DOUBLE:
23446 
          self.otherCharges = iprot.readDouble();
23447 
        else:
23448 
          iprot.skip(ftype)
23449 
      elif fid == 6:
23450 
        if ftype == TType.DOUBLE:
23451 
          self.netCollection = iprot.readDouble();
23452 
        else:
23453 
          iprot.skip(ftype)
23454 
      else:
23455 
        iprot.skip(ftype)
23456 
      iprot.readFieldEnd()
23457 
    iprot.readStructEnd()
23458 
 
23459 
  def write(self, oprot):
23460 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23461 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23462 
      return
23463 
    oprot.writeStructBegin('savePaymentSettlements_args')
23464 
    if self.settlementDate is not None:
23465 
      oprot.writeFieldBegin('settlementDate', TType.I64, 1)
23466 
      oprot.writeI64(self.settlementDate)
23467 
      oprot.writeFieldEnd()
23468 
    if self.paymentGatewayId is not None:
23469 
      oprot.writeFieldBegin('paymentGatewayId', TType.I64, 2)
23470 
      oprot.writeI64(self.paymentGatewayId)
23471 
      oprot.writeFieldEnd()
4905 varun.gupt 23472 
    if self.referenceId is not None:
23473 
      oprot.writeFieldBegin('referenceId', TType.I64, 3)
23474 
      oprot.writeI64(self.referenceId)
4600 varun.gupt 23475 
      oprot.writeFieldEnd()
23476 
    if self.serviceTax is not None:
23477 
      oprot.writeFieldBegin('serviceTax', TType.DOUBLE, 4)
23478 
      oprot.writeDouble(self.serviceTax)
23479 
      oprot.writeFieldEnd()
23480 
    if self.otherCharges is not None:
23481 
      oprot.writeFieldBegin('otherCharges', TType.DOUBLE, 5)
23482 
      oprot.writeDouble(self.otherCharges)
23483 
      oprot.writeFieldEnd()
23484 
    if self.netCollection is not None:
23485 
      oprot.writeFieldBegin('netCollection', TType.DOUBLE, 6)
23486 
      oprot.writeDouble(self.netCollection)
23487 
      oprot.writeFieldEnd()
23488 
    oprot.writeFieldStop()
23489 
    oprot.writeStructEnd()
23490 
 
23491 
  def validate(self):
23492 
    return
23493 
 
23494 
 
23495 
  def __repr__(self):
23496 
    L = ['%s=%r' % (key, value)
23497 
      for key, value in self.__dict__.iteritems()]
23498 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23499 
 
23500 
  def __eq__(self, other):
23501 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23502 
 
23503 
  def __ne__(self, other):
23504 
    return not (self == other)
23505 
 
23506 
class savePaymentSettlements_result:
23507 
  """
23508 
  Attributes:
23509 
   - ex
23510 
  """
23511 
 
23512 
  thrift_spec = (
23513 
    None, # 0
23514 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
23515 
  )
23516 
 
23517 
  def __init__(self, ex=None,):
23518 
    self.ex = ex
23519 
 
23520 
  def read(self, iprot):
23521 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23522 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23523 
      return
23524 
    iprot.readStructBegin()
23525 
    while True:
23526 
      (fname, ftype, fid) = iprot.readFieldBegin()
23527 
      if ftype == TType.STOP:
23528 
        break
23529 
      if fid == 1:
23530 
        if ftype == TType.STRUCT:
23531 
          self.ex = TransactionServiceException()
23532 
          self.ex.read(iprot)
23533 
        else:
23534 
          iprot.skip(ftype)
23535 
      else:
23536 
        iprot.skip(ftype)
23537 
      iprot.readFieldEnd()
23538 
    iprot.readStructEnd()
23539 
 
23540 
  def write(self, oprot):
23541 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23542 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23543 
      return
23544 
    oprot.writeStructBegin('savePaymentSettlements_result')
23545 
    if self.ex is not None:
23546 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
23547 
      self.ex.write(oprot)
23548 
      oprot.writeFieldEnd()
23549 
    oprot.writeFieldStop()
23550 
    oprot.writeStructEnd()
23551 
 
23552 
  def validate(self):
23553 
    return
23554 
 
23555 
 
23556 
  def __repr__(self):
23557 
    L = ['%s=%r' % (key, value)
23558 
      for key, value in self.__dict__.iteritems()]
23559 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23560 
 
23561 
  def __eq__(self, other):
23562 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23563 
 
23564 
  def __ne__(self, other):
23565 
    return not (self == other)
23566 
 
23567 
class saveEBSSettlementSummary_args:
23568 
  """
23569 
  Attributes:
23570 
   - settlementId
23571 
   - settlementDate
23572 
   - transactionDateFrom
23573 
   - transactionDateTo
23574 
   - amount
23575 
  """
23576 
 
23577 
  thrift_spec = (
23578 
    None, # 0
23579 
    (1, TType.I64, 'settlementId', None, None, ), # 1
23580 
    (2, TType.I64, 'settlementDate', None, None, ), # 2
23581 
    (3, TType.I64, 'transactionDateFrom', None, None, ), # 3
23582 
    (4, TType.I64, 'transactionDateTo', None, None, ), # 4
23583 
    (5, TType.DOUBLE, 'amount', None, None, ), # 5
23584 
  )
23585 
 
23586 
  def __init__(self, settlementId=None, settlementDate=None, transactionDateFrom=None, transactionDateTo=None, amount=None,):
23587 
    self.settlementId = settlementId
23588 
    self.settlementDate = settlementDate
23589 
    self.transactionDateFrom = transactionDateFrom
23590 
    self.transactionDateTo = transactionDateTo
23591 
    self.amount = amount
23592 
 
23593 
  def read(self, iprot):
23594 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23595 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23596 
      return
23597 
    iprot.readStructBegin()
23598 
    while True:
23599 
      (fname, ftype, fid) = iprot.readFieldBegin()
23600 
      if ftype == TType.STOP:
23601 
        break
23602 
      if fid == 1:
23603 
        if ftype == TType.I64:
23604 
          self.settlementId = iprot.readI64();
23605 
        else:
23606 
          iprot.skip(ftype)
23607 
      elif fid == 2:
23608 
        if ftype == TType.I64:
23609 
          self.settlementDate = iprot.readI64();
23610 
        else:
23611 
          iprot.skip(ftype)
23612 
      elif fid == 3:
23613 
        if ftype == TType.I64:
23614 
          self.transactionDateFrom = iprot.readI64();
23615 
        else:
23616 
          iprot.skip(ftype)
23617 
      elif fid == 4:
23618 
        if ftype == TType.I64:
23619 
          self.transactionDateTo = iprot.readI64();
23620 
        else:
23621 
          iprot.skip(ftype)
23622 
      elif fid == 5:
23623 
        if ftype == TType.DOUBLE:
23624 
          self.amount = iprot.readDouble();
23625 
        else:
23626 
          iprot.skip(ftype)
23627 
      else:
23628 
        iprot.skip(ftype)
23629 
      iprot.readFieldEnd()
23630 
    iprot.readStructEnd()
23631 
 
23632 
  def write(self, oprot):
23633 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23634 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23635 
      return
23636 
    oprot.writeStructBegin('saveEBSSettlementSummary_args')
23637 
    if self.settlementId is not None:
23638 
      oprot.writeFieldBegin('settlementId', TType.I64, 1)
23639 
      oprot.writeI64(self.settlementId)
23640 
      oprot.writeFieldEnd()
23641 
    if self.settlementDate is not None:
23642 
      oprot.writeFieldBegin('settlementDate', TType.I64, 2)
23643 
      oprot.writeI64(self.settlementDate)
23644 
      oprot.writeFieldEnd()
23645 
    if self.transactionDateFrom is not None:
23646 
      oprot.writeFieldBegin('transactionDateFrom', TType.I64, 3)
23647 
      oprot.writeI64(self.transactionDateFrom)
23648 
      oprot.writeFieldEnd()
23649 
    if self.transactionDateTo is not None:
23650 
      oprot.writeFieldBegin('transactionDateTo', TType.I64, 4)
23651 
      oprot.writeI64(self.transactionDateTo)
23652 
      oprot.writeFieldEnd()
23653 
    if self.amount is not None:
23654 
      oprot.writeFieldBegin('amount', TType.DOUBLE, 5)
23655 
      oprot.writeDouble(self.amount)
23656 
      oprot.writeFieldEnd()
23657 
    oprot.writeFieldStop()
23658 
    oprot.writeStructEnd()
23659 
 
23660 
  def validate(self):
23661 
    return
23662 
 
23663 
 
23664 
  def __repr__(self):
23665 
    L = ['%s=%r' % (key, value)
23666 
      for key, value in self.__dict__.iteritems()]
23667 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23668 
 
23669 
  def __eq__(self, other):
23670 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23671 
 
23672 
  def __ne__(self, other):
23673 
    return not (self == other)
23674 
 
23675 
class saveEBSSettlementSummary_result:
23676 
  """
23677 
  Attributes:
23678 
   - ex
23679 
  """
23680 
 
23681 
  thrift_spec = (
23682 
    None, # 0
23683 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
23684 
  )
23685 
 
23686 
  def __init__(self, ex=None,):
23687 
    self.ex = ex
23688 
 
23689 
  def read(self, iprot):
23690 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23691 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23692 
      return
23693 
    iprot.readStructBegin()
23694 
    while True:
23695 
      (fname, ftype, fid) = iprot.readFieldBegin()
23696 
      if ftype == TType.STOP:
23697 
        break
23698 
      if fid == 1:
23699 
        if ftype == TType.STRUCT:
23700 
          self.ex = TransactionServiceException()
23701 
          self.ex.read(iprot)
23702 
        else:
23703 
          iprot.skip(ftype)
23704 
      else:
23705 
        iprot.skip(ftype)
23706 
      iprot.readFieldEnd()
23707 
    iprot.readStructEnd()
23708 
 
23709 
  def write(self, oprot):
23710 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23711 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23712 
      return
23713 
    oprot.writeStructBegin('saveEBSSettlementSummary_result')
23714 
    if self.ex is not None:
23715 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
23716 
      self.ex.write(oprot)
23717 
      oprot.writeFieldEnd()
23718 
    oprot.writeFieldStop()
23719 
    oprot.writeStructEnd()
23720 
 
23721 
  def validate(self):
23722 
    return
23723 
 
23724 
 
23725 
  def __repr__(self):
23726 
    L = ['%s=%r' % (key, value)
23727 
      for key, value in self.__dict__.iteritems()]
23728 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23729 
 
23730 
  def __eq__(self, other):
23731 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23732 
 
23733 
  def __ne__(self, other):
23734 
    return not (self == other)
23735 
 
5386 phani.kuma 23736 
class getSettlementForPrepaid_args:
4600 varun.gupt 23737 
  """
23738 
  Attributes:
5189 varun.gupt 23739 
   - referenceId
23740 
   - isRefund
4600 varun.gupt 23741 
  """
23742 
 
23743 
  thrift_spec = (
23744 
    None, # 0
5189 varun.gupt 23745 
    (1, TType.I64, 'referenceId', None, None, ), # 1
5386 phani.kuma 23746 
    (2, TType.BOOL, 'isRefund', None, None, ), # 2
4600 varun.gupt 23747 
  )
23748 
 
5386 phani.kuma 23749 
  def __init__(self, referenceId=None, isRefund=None,):
5189 varun.gupt 23750 
    self.referenceId = referenceId
23751 
    self.isRefund = isRefund
4600 varun.gupt 23752 
 
23753 
  def read(self, iprot):
23754 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23755 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23756 
      return
23757 
    iprot.readStructBegin()
23758 
    while True:
23759 
      (fname, ftype, fid) = iprot.readFieldBegin()
23760 
      if ftype == TType.STOP:
23761 
        break
23762 
      if fid == 1:
23763 
        if ftype == TType.I64:
5189 varun.gupt 23764 
          self.referenceId = iprot.readI64();
4600 varun.gupt 23765 
        else:
23766 
          iprot.skip(ftype)
5189 varun.gupt 23767 
      elif fid == 2:
23768 
        if ftype == TType.BOOL:
23769 
          self.isRefund = iprot.readBool();
23770 
        else:
23771 
          iprot.skip(ftype)
4600 varun.gupt 23772 
      else:
23773 
        iprot.skip(ftype)
23774 
      iprot.readFieldEnd()
23775 
    iprot.readStructEnd()
23776 
 
23777 
  def write(self, oprot):
23778 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23779 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23780 
      return
5386 phani.kuma 23781 
    oprot.writeStructBegin('getSettlementForPrepaid_args')
5189 varun.gupt 23782 
    if self.referenceId is not None:
23783 
      oprot.writeFieldBegin('referenceId', TType.I64, 1)
23784 
      oprot.writeI64(self.referenceId)
4600 varun.gupt 23785 
      oprot.writeFieldEnd()
5386 phani.kuma 23786 
    if self.isRefund is not None:
23787 
      oprot.writeFieldBegin('isRefund', TType.BOOL, 2)
23788 
      oprot.writeBool(self.isRefund)
5382 varun.gupt 23789 
      oprot.writeFieldEnd()
5386 phani.kuma 23790 
    oprot.writeFieldStop()
23791 
    oprot.writeStructEnd()
23792 
 
23793 
  def validate(self):
23794 
    return
23795 
 
23796 
 
23797 
  def __repr__(self):
23798 
    L = ['%s=%r' % (key, value)
23799 
      for key, value in self.__dict__.iteritems()]
23800 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23801 
 
23802 
  def __eq__(self, other):
23803 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23804 
 
23805 
  def __ne__(self, other):
23806 
    return not (self == other)
23807 
 
23808 
class getSettlementForPrepaid_result:
23809 
  """
23810 
  Attributes:
23811 
   - success
23812 
   - ex
23813 
  """
23814 
 
23815 
  thrift_spec = (
23816 
    (0, TType.STRUCT, 'success', (PaymentSettlement, PaymentSettlement.thrift_spec), None, ), # 0
23817 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
23818 
  )
23819 
 
23820 
  def __init__(self, success=None, ex=None,):
23821 
    self.success = success
23822 
    self.ex = ex
23823 
 
23824 
  def read(self, iprot):
23825 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23826 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23827 
      return
23828 
    iprot.readStructBegin()
23829 
    while True:
23830 
      (fname, ftype, fid) = iprot.readFieldBegin()
23831 
      if ftype == TType.STOP:
23832 
        break
23833 
      if fid == 0:
23834 
        if ftype == TType.STRUCT:
23835 
          self.success = PaymentSettlement()
23836 
          self.success.read(iprot)
23837 
        else:
23838 
          iprot.skip(ftype)
23839 
      elif fid == 1:
23840 
        if ftype == TType.STRUCT:
23841 
          self.ex = TransactionServiceException()
23842 
          self.ex.read(iprot)
23843 
        else:
23844 
          iprot.skip(ftype)
23845 
      else:
23846 
        iprot.skip(ftype)
23847 
      iprot.readFieldEnd()
23848 
    iprot.readStructEnd()
23849 
 
23850 
  def write(self, oprot):
23851 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23852 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23853 
      return
23854 
    oprot.writeStructBegin('getSettlementForPrepaid_result')
23855 
    if self.success is not None:
23856 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
23857 
      self.success.write(oprot)
23858 
      oprot.writeFieldEnd()
23859 
    if self.ex is not None:
23860 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
23861 
      self.ex.write(oprot)
23862 
      oprot.writeFieldEnd()
23863 
    oprot.writeFieldStop()
23864 
    oprot.writeStructEnd()
23865 
 
23866 
  def validate(self):
23867 
    return
23868 
 
23869 
 
23870 
  def __repr__(self):
23871 
    L = ['%s=%r' % (key, value)
23872 
      for key, value in self.__dict__.iteritems()]
23873 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23874 
 
23875 
  def __eq__(self, other):
23876 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23877 
 
23878 
  def __ne__(self, other):
23879 
    return not (self == other)
23880 
 
23881 
class getSettlementForCod_args:
23882 
  """
23883 
  Attributes:
23884 
   - orderId
23885 
   - isRefund
23886 
  """
23887 
 
23888 
  thrift_spec = (
23889 
    None, # 0
23890 
    (1, TType.I64, 'orderId', None, None, ), # 1
23891 
    (2, TType.BOOL, 'isRefund', None, None, ), # 2
23892 
  )
23893 
 
23894 
  def __init__(self, orderId=None, isRefund=None,):
23895 
    self.orderId = orderId
23896 
    self.isRefund = isRefund
23897 
 
23898 
  def read(self, iprot):
23899 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23900 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23901 
      return
23902 
    iprot.readStructBegin()
23903 
    while True:
23904 
      (fname, ftype, fid) = iprot.readFieldBegin()
23905 
      if ftype == TType.STOP:
23906 
        break
23907 
      if fid == 1:
23908 
        if ftype == TType.I64:
23909 
          self.orderId = iprot.readI64();
23910 
        else:
23911 
          iprot.skip(ftype)
23912 
      elif fid == 2:
23913 
        if ftype == TType.BOOL:
23914 
          self.isRefund = iprot.readBool();
23915 
        else:
23916 
          iprot.skip(ftype)
23917 
      else:
23918 
        iprot.skip(ftype)
23919 
      iprot.readFieldEnd()
23920 
    iprot.readStructEnd()
23921 
 
23922 
  def write(self, oprot):
23923 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23924 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23925 
      return
23926 
    oprot.writeStructBegin('getSettlementForCod_args')
23927 
    if self.orderId is not None:
23928 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
23929 
      oprot.writeI64(self.orderId)
23930 
      oprot.writeFieldEnd()
5189 varun.gupt 23931 
    if self.isRefund is not None:
5386 phani.kuma 23932 
      oprot.writeFieldBegin('isRefund', TType.BOOL, 2)
5189 varun.gupt 23933 
      oprot.writeBool(self.isRefund)
23934 
      oprot.writeFieldEnd()
4600 varun.gupt 23935 
    oprot.writeFieldStop()
23936 
    oprot.writeStructEnd()
23937 
 
23938 
  def validate(self):
23939 
    return
23940 
 
23941 
 
23942 
  def __repr__(self):
23943 
    L = ['%s=%r' % (key, value)
23944 
      for key, value in self.__dict__.iteritems()]
23945 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23946 
 
23947 
  def __eq__(self, other):
23948 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23949 
 
23950 
  def __ne__(self, other):
23951 
    return not (self == other)
23952 
 
5386 phani.kuma 23953 
class getSettlementForCod_result:
4600 varun.gupt 23954 
  """
23955 
  Attributes:
23956 
   - success
23957 
   - ex
23958 
  """
23959 
 
23960 
  thrift_spec = (
23961 
    (0, TType.STRUCT, 'success', (PaymentSettlement, PaymentSettlement.thrift_spec), None, ), # 0
23962 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
23963 
  )
23964 
 
23965 
  def __init__(self, success=None, ex=None,):
23966 
    self.success = success
23967 
    self.ex = ex
23968 
 
23969 
  def read(self, iprot):
23970 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23971 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23972 
      return
23973 
    iprot.readStructBegin()
23974 
    while True:
23975 
      (fname, ftype, fid) = iprot.readFieldBegin()
23976 
      if ftype == TType.STOP:
23977 
        break
23978 
      if fid == 0:
23979 
        if ftype == TType.STRUCT:
23980 
          self.success = PaymentSettlement()
23981 
          self.success.read(iprot)
23982 
        else:
23983 
          iprot.skip(ftype)
23984 
      elif fid == 1:
23985 
        if ftype == TType.STRUCT:
23986 
          self.ex = TransactionServiceException()
23987 
          self.ex.read(iprot)
23988 
        else:
23989 
          iprot.skip(ftype)
23990 
      else:
23991 
        iprot.skip(ftype)
23992 
      iprot.readFieldEnd()
23993 
    iprot.readStructEnd()
23994 
 
23995 
  def write(self, oprot):
23996 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23997 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23998 
      return
5386 phani.kuma 23999 
    oprot.writeStructBegin('getSettlementForCod_result')
4600 varun.gupt 24000 
    if self.success is not None:
24001 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
24002 
      self.success.write(oprot)
24003 
      oprot.writeFieldEnd()
24004 
    if self.ex is not None:
24005 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
24006 
      self.ex.write(oprot)
24007 
      oprot.writeFieldEnd()
24008 
    oprot.writeFieldStop()
24009 
    oprot.writeStructEnd()
24010 
 
24011 
  def validate(self):
24012 
    return
24013 
 
24014 
 
24015 
  def __repr__(self):
24016 
    L = ['%s=%r' % (key, value)
24017 
      for key, value in self.__dict__.iteritems()]
24018 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24019 
 
24020 
  def __eq__(self, other):
24021 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24022 
 
24023 
  def __ne__(self, other):
24024 
    return not (self == other)
24025 
 
24026 
class getEBSSettlementSummaries_args:
24027 
 
24028 
  thrift_spec = (
24029 
  )
24030 
 
24031 
  def read(self, iprot):
24032 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24033 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24034 
      return
24035 
    iprot.readStructBegin()
24036 
    while True:
24037 
      (fname, ftype, fid) = iprot.readFieldBegin()
24038 
      if ftype == TType.STOP:
24039 
        break
24040 
      else:
24041 
        iprot.skip(ftype)
24042 
      iprot.readFieldEnd()
24043 
    iprot.readStructEnd()
24044 
 
24045 
  def write(self, oprot):
24046 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24047 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24048 
      return
24049 
    oprot.writeStructBegin('getEBSSettlementSummaries_args')
24050 
    oprot.writeFieldStop()
24051 
    oprot.writeStructEnd()
24052 
 
24053 
  def validate(self):
24054 
    return
24055 
 
24056 
 
24057 
  def __repr__(self):
24058 
    L = ['%s=%r' % (key, value)
24059 
      for key, value in self.__dict__.iteritems()]
24060 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24061 
 
24062 
  def __eq__(self, other):
24063 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24064 
 
24065 
  def __ne__(self, other):
24066 
    return not (self == other)
24067 
 
24068 
class getEBSSettlementSummaries_result:
24069 
  """
24070 
  Attributes:
24071 
   - success
24072 
   - ex
24073 
  """
24074 
 
24075 
  thrift_spec = (
24076 
    (0, TType.MAP, 'success', (TType.I64,None,TType.STRING,None), None, ), # 0
24077 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
24078 
  )
24079 
 
24080 
  def __init__(self, success=None, ex=None,):
24081 
    self.success = success
24082 
    self.ex = ex
24083 
 
24084 
  def read(self, iprot):
24085 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24086 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24087 
      return
24088 
    iprot.readStructBegin()
24089 
    while True:
24090 
      (fname, ftype, fid) = iprot.readFieldBegin()
24091 
      if ftype == TType.STOP:
24092 
        break
24093 
      if fid == 0:
24094 
        if ftype == TType.MAP:
24095 
          self.success = {}
6188 rajveer 24096 
          (_ktype555, _vtype556, _size554 ) = iprot.readMapBegin()
24097 
          for _i558 in xrange(_size554):
24098 
            _key559 = iprot.readI64();
24099 
            _val560 = iprot.readString();
24100 
            self.success[_key559] = _val560
4600 varun.gupt 24101 
          iprot.readMapEnd()
24102 
        else:
24103 
          iprot.skip(ftype)
24104 
      elif fid == 1:
24105 
        if ftype == TType.STRUCT:
24106 
          self.ex = TransactionServiceException()
24107 
          self.ex.read(iprot)
24108 
        else:
24109 
          iprot.skip(ftype)
24110 
      else:
24111 
        iprot.skip(ftype)
24112 
      iprot.readFieldEnd()
24113 
    iprot.readStructEnd()
24114 
 
24115 
  def write(self, oprot):
24116 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24117 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24118 
      return
24119 
    oprot.writeStructBegin('getEBSSettlementSummaries_result')
24120 
    if self.success is not None:
24121 
      oprot.writeFieldBegin('success', TType.MAP, 0)
24122 
      oprot.writeMapBegin(TType.I64, TType.STRING, len(self.success))
6188 rajveer 24123 
      for kiter561,viter562 in self.success.items():
24124 
        oprot.writeI64(kiter561)
24125 
        oprot.writeString(viter562)
4600 varun.gupt 24126 
      oprot.writeMapEnd()
24127 
      oprot.writeFieldEnd()
24128 
    if self.ex is not None:
24129 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
24130 
      self.ex.write(oprot)
24131 
      oprot.writeFieldEnd()
24132 
    oprot.writeFieldStop()
24133 
    oprot.writeStructEnd()
24134 
 
24135 
  def validate(self):
24136 
    return
24137 
 
24138 
 
24139 
  def __repr__(self):
24140 
    L = ['%s=%r' % (key, value)
24141 
      for key, value in self.__dict__.iteritems()]
24142 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24143 
 
24144 
  def __eq__(self, other):
24145 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24146 
 
24147 
  def __ne__(self, other):
24148 
    return not (self == other)
24149 
 
24150 
class markEBSSettlementUploaded_args:
24151 
  """
24152 
  Attributes:
24153 
   - settlementId
24154 
  """
24155 
 
24156 
  thrift_spec = (
24157 
    None, # 0
24158 
    (1, TType.I64, 'settlementId', None, None, ), # 1
24159 
  )
24160 
 
24161 
  def __init__(self, settlementId=None,):
24162 
    self.settlementId = settlementId
24163 
 
24164 
  def read(self, iprot):
24165 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24166 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24167 
      return
24168 
    iprot.readStructBegin()
24169 
    while True:
24170 
      (fname, ftype, fid) = iprot.readFieldBegin()
24171 
      if ftype == TType.STOP:
24172 
        break
24173 
      if fid == 1:
24174 
        if ftype == TType.I64:
24175 
          self.settlementId = iprot.readI64();
24176 
        else:
24177 
          iprot.skip(ftype)
24178 
      else:
24179 
        iprot.skip(ftype)
24180 
      iprot.readFieldEnd()
24181 
    iprot.readStructEnd()
24182 
 
24183 
  def write(self, oprot):
24184 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24185 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24186 
      return
24187 
    oprot.writeStructBegin('markEBSSettlementUploaded_args')
24188 
    if self.settlementId is not None:
24189 
      oprot.writeFieldBegin('settlementId', TType.I64, 1)
24190 
      oprot.writeI64(self.settlementId)
24191 
      oprot.writeFieldEnd()
24192 
    oprot.writeFieldStop()
24193 
    oprot.writeStructEnd()
24194 
 
24195 
  def validate(self):
24196 
    return
24197 
 
24198 
 
24199 
  def __repr__(self):
24200 
    L = ['%s=%r' % (key, value)
24201 
      for key, value in self.__dict__.iteritems()]
24202 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24203 
 
24204 
  def __eq__(self, other):
24205 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24206 
 
24207 
  def __ne__(self, other):
24208 
    return not (self == other)
24209 
 
24210 
class markEBSSettlementUploaded_result:
24211 
  """
24212 
  Attributes:
24213 
   - ex
24214 
  """
24215 
 
24216 
  thrift_spec = (
24217 
    None, # 0
24218 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
24219 
  )
24220 
 
24221 
  def __init__(self, ex=None,):
24222 
    self.ex = ex
24223 
 
24224 
  def read(self, iprot):
24225 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24226 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24227 
      return
24228 
    iprot.readStructBegin()
24229 
    while True:
24230 
      (fname, ftype, fid) = iprot.readFieldBegin()
24231 
      if ftype == TType.STOP:
24232 
        break
24233 
      if fid == 1:
24234 
        if ftype == TType.STRUCT:
24235 
          self.ex = TransactionServiceException()
24236 
          self.ex.read(iprot)
24237 
        else:
24238 
          iprot.skip(ftype)
24239 
      else:
24240 
        iprot.skip(ftype)
24241 
      iprot.readFieldEnd()
24242 
    iprot.readStructEnd()
24243 
 
24244 
  def write(self, oprot):
24245 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24246 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24247 
      return
24248 
    oprot.writeStructBegin('markEBSSettlementUploaded_result')
24249 
    if self.ex is not None:
24250 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
24251 
      self.ex.write(oprot)
24252 
      oprot.writeFieldEnd()
24253 
    oprot.writeFieldStop()
24254 
    oprot.writeStructEnd()
24255 
 
24256 
  def validate(self):
24257 
    return
24258 
 
24259 
 
24260 
  def __repr__(self):
24261 
    L = ['%s=%r' % (key, value)
24262 
      for key, value in self.__dict__.iteritems()]
24263 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24264 
 
24265 
  def __eq__(self, other):
24266 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24267 
 
24268 
  def __ne__(self, other):
24269 
    return not (self == other)
24270 
 
24271 
class getEBSSettlementDate_args:
24272 
  """
24273 
  Attributes:
24274 
   - settlementId
24275 
  """
24276 
 
24277 
  thrift_spec = (
24278 
    None, # 0
24279 
    (1, TType.I64, 'settlementId', None, None, ), # 1
24280 
  )
24281 
 
24282 
  def __init__(self, settlementId=None,):
24283 
    self.settlementId = settlementId
24284 
 
24285 
  def read(self, iprot):
24286 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24287 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24288 
      return
24289 
    iprot.readStructBegin()
24290 
    while True:
24291 
      (fname, ftype, fid) = iprot.readFieldBegin()
24292 
      if ftype == TType.STOP:
24293 
        break
24294 
      if fid == 1:
24295 
        if ftype == TType.I64:
24296 
          self.settlementId = iprot.readI64();
24297 
        else:
24298 
          iprot.skip(ftype)
24299 
      else:
24300 
        iprot.skip(ftype)
24301 
      iprot.readFieldEnd()
24302 
    iprot.readStructEnd()
24303 
 
24304 
  def write(self, oprot):
24305 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24306 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24307 
      return
24308 
    oprot.writeStructBegin('getEBSSettlementDate_args')
24309 
    if self.settlementId is not None:
24310 
      oprot.writeFieldBegin('settlementId', TType.I64, 1)
24311 
      oprot.writeI64(self.settlementId)
24312 
      oprot.writeFieldEnd()
24313 
    oprot.writeFieldStop()
24314 
    oprot.writeStructEnd()
24315 
 
24316 
  def validate(self):
24317 
    return
24318 
 
24319 
 
24320 
  def __repr__(self):
24321 
    L = ['%s=%r' % (key, value)
24322 
      for key, value in self.__dict__.iteritems()]
24323 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24324 
 
24325 
  def __eq__(self, other):
24326 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24327 
 
24328 
  def __ne__(self, other):
24329 
    return not (self == other)
24330 
 
24331 
class getEBSSettlementDate_result:
24332 
  """
24333 
  Attributes:
24334 
   - success
24335 
   - ex
24336 
  """
24337 
 
24338 
  thrift_spec = (
24339 
    (0, TType.I64, 'success', None, None, ), # 0
24340 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
24341 
  )
24342 
 
24343 
  def __init__(self, success=None, ex=None,):
24344 
    self.success = success
24345 
    self.ex = ex
24346 
 
24347 
  def read(self, iprot):
24348 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24349 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24350 
      return
24351 
    iprot.readStructBegin()
24352 
    while True:
24353 
      (fname, ftype, fid) = iprot.readFieldBegin()
24354 
      if ftype == TType.STOP:
24355 
        break
24356 
      if fid == 0:
24357 
        if ftype == TType.I64:
24358 
          self.success = iprot.readI64();
24359 
        else:
24360 
          iprot.skip(ftype)
24361 
      elif fid == 1:
24362 
        if ftype == TType.STRUCT:
24363 
          self.ex = TransactionServiceException()
24364 
          self.ex.read(iprot)
24365 
        else:
24366 
          iprot.skip(ftype)
24367 
      else:
24368 
        iprot.skip(ftype)
24369 
      iprot.readFieldEnd()
24370 
    iprot.readStructEnd()
24371 
 
24372 
  def write(self, oprot):
24373 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24374 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24375 
      return
24376 
    oprot.writeStructBegin('getEBSSettlementDate_result')
24377 
    if self.success is not None:
24378 
      oprot.writeFieldBegin('success', TType.I64, 0)
24379 
      oprot.writeI64(self.success)
24380 
      oprot.writeFieldEnd()
24381 
    if self.ex is not None:
24382 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
24383 
      self.ex.write(oprot)
24384 
      oprot.writeFieldEnd()
24385 
    oprot.writeFieldStop()
24386 
    oprot.writeStructEnd()
24387 
 
24388 
  def validate(self):
24389 
    return
24390 
 
24391 
 
24392 
  def __repr__(self):
24393 
    L = ['%s=%r' % (key, value)
24394 
      for key, value in self.__dict__.iteritems()]
24395 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24396 
 
24397 
  def __eq__(self, other):
24398 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24399 
 
24400 
  def __ne__(self, other):
24401 
    return not (self == other)
4715 varun.gupt 24402 
 
24403 
class getSettlementsByDate_args:
24404 
  """
24405 
  Attributes:
24406 
   - settlementDateFrom
24407 
   - settlementDateTo
24408 
   - isRefund
24409 
  """
24410 
 
24411 
  thrift_spec = (
24412 
    None, # 0
24413 
    (1, TType.I64, 'settlementDateFrom', None, None, ), # 1
24414 
    (2, TType.I64, 'settlementDateTo', None, None, ), # 2
24415 
    (3, TType.BOOL, 'isRefund', None, None, ), # 3
24416 
  )
24417 
 
24418 
  def __init__(self, settlementDateFrom=None, settlementDateTo=None, isRefund=None,):
24419 
    self.settlementDateFrom = settlementDateFrom
24420 
    self.settlementDateTo = settlementDateTo
24421 
    self.isRefund = isRefund
24422 
 
24423 
  def read(self, iprot):
24424 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24425 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24426 
      return
24427 
    iprot.readStructBegin()
24428 
    while True:
24429 
      (fname, ftype, fid) = iprot.readFieldBegin()
24430 
      if ftype == TType.STOP:
24431 
        break
24432 
      if fid == 1:
24433 
        if ftype == TType.I64:
24434 
          self.settlementDateFrom = iprot.readI64();
24435 
        else:
24436 
          iprot.skip(ftype)
24437 
      elif fid == 2:
24438 
        if ftype == TType.I64:
24439 
          self.settlementDateTo = iprot.readI64();
24440 
        else:
24441 
          iprot.skip(ftype)
24442 
      elif fid == 3:
24443 
        if ftype == TType.BOOL:
24444 
          self.isRefund = iprot.readBool();
24445 
        else:
24446 
          iprot.skip(ftype)
24447 
      else:
24448 
        iprot.skip(ftype)
24449 
      iprot.readFieldEnd()
24450 
    iprot.readStructEnd()
24451 
 
24452 
  def write(self, oprot):
24453 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24454 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24455 
      return
24456 
    oprot.writeStructBegin('getSettlementsByDate_args')
24457 
    if self.settlementDateFrom is not None:
24458 
      oprot.writeFieldBegin('settlementDateFrom', TType.I64, 1)
24459 
      oprot.writeI64(self.settlementDateFrom)
24460 
      oprot.writeFieldEnd()
24461 
    if self.settlementDateTo is not None:
24462 
      oprot.writeFieldBegin('settlementDateTo', TType.I64, 2)
24463 
      oprot.writeI64(self.settlementDateTo)
24464 
      oprot.writeFieldEnd()
24465 
    if self.isRefund is not None:
24466 
      oprot.writeFieldBegin('isRefund', TType.BOOL, 3)
24467 
      oprot.writeBool(self.isRefund)
24468 
      oprot.writeFieldEnd()
24469 
    oprot.writeFieldStop()
24470 
    oprot.writeStructEnd()
24471 
 
24472 
  def validate(self):
24473 
    return
24474 
 
24475 
 
24476 
  def __repr__(self):
24477 
    L = ['%s=%r' % (key, value)
24478 
      for key, value in self.__dict__.iteritems()]
24479 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24480 
 
24481 
  def __eq__(self, other):
24482 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24483 
 
24484 
  def __ne__(self, other):
24485 
    return not (self == other)
24486 
 
24487 
class getSettlementsByDate_result:
24488 
  """
24489 
  Attributes:
24490 
   - success
24491 
   - ex
24492 
  """
24493 
 
24494 
  thrift_spec = (
24495 
    (0, TType.LIST, 'success', (TType.STRUCT,(PaymentSettlement, PaymentSettlement.thrift_spec)), None, ), # 0
24496 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
24497 
  )
24498 
 
24499 
  def __init__(self, success=None, ex=None,):
24500 
    self.success = success
24501 
    self.ex = ex
24502 
 
24503 
  def read(self, iprot):
24504 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24505 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24506 
      return
24507 
    iprot.readStructBegin()
24508 
    while True:
24509 
      (fname, ftype, fid) = iprot.readFieldBegin()
24510 
      if ftype == TType.STOP:
24511 
        break
24512 
      if fid == 0:
24513 
        if ftype == TType.LIST:
24514 
          self.success = []
6188 rajveer 24515 
          (_etype566, _size563) = iprot.readListBegin()
24516 
          for _i567 in xrange(_size563):
24517 
            _elem568 = PaymentSettlement()
24518 
            _elem568.read(iprot)
24519 
            self.success.append(_elem568)
4715 varun.gupt 24520 
          iprot.readListEnd()
24521 
        else:
24522 
          iprot.skip(ftype)
24523 
      elif fid == 1:
24524 
        if ftype == TType.STRUCT:
24525 
          self.ex = TransactionServiceException()
24526 
          self.ex.read(iprot)
24527 
        else:
24528 
          iprot.skip(ftype)
24529 
      else:
24530 
        iprot.skip(ftype)
24531 
      iprot.readFieldEnd()
24532 
    iprot.readStructEnd()
24533 
 
24534 
  def write(self, oprot):
24535 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24536 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24537 
      return
24538 
    oprot.writeStructBegin('getSettlementsByDate_result')
24539 
    if self.success is not None:
24540 
      oprot.writeFieldBegin('success', TType.LIST, 0)
24541 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 24542 
      for iter569 in self.success:
24543 
        iter569.write(oprot)
4715 varun.gupt 24544 
      oprot.writeListEnd()
24545 
      oprot.writeFieldEnd()
24546 
    if self.ex is not None:
24547 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
24548 
      self.ex.write(oprot)
24549 
      oprot.writeFieldEnd()
24550 
    oprot.writeFieldStop()
24551 
    oprot.writeStructEnd()
24552 
 
24553 
  def validate(self):
24554 
    return
24555 
 
24556 
 
24557 
  def __repr__(self):
24558 
    L = ['%s=%r' % (key, value)
24559 
      for key, value in self.__dict__.iteritems()]
24560 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24561 
 
24562 
  def __eq__(self, other):
24563 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24564 
 
24565 
  def __ne__(self, other):
24566 
    return not (self == other)
24567 
 
24568 
class getReshippedOrderIds_args:
24569 
  """
24570 
  Attributes:
24571 
   - orderIds
24572 
  """
24573 
 
24574 
  thrift_spec = (
24575 
    None, # 0
24576 
    (1, TType.LIST, 'orderIds', (TType.I64,None), None, ), # 1
24577 
  )
24578 
 
24579 
  def __init__(self, orderIds=None,):
24580 
    self.orderIds = orderIds
24581 
 
24582 
  def read(self, iprot):
24583 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24584 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24585 
      return
24586 
    iprot.readStructBegin()
24587 
    while True:
24588 
      (fname, ftype, fid) = iprot.readFieldBegin()
24589 
      if ftype == TType.STOP:
24590 
        break
24591 
      if fid == 1:
24592 
        if ftype == TType.LIST:
24593 
          self.orderIds = []
6188 rajveer 24594 
          (_etype573, _size570) = iprot.readListBegin()
24595 
          for _i574 in xrange(_size570):
24596 
            _elem575 = iprot.readI64();
24597 
            self.orderIds.append(_elem575)
4715 varun.gupt 24598 
          iprot.readListEnd()
24599 
        else:
24600 
          iprot.skip(ftype)
24601 
      else:
24602 
        iprot.skip(ftype)
24603 
      iprot.readFieldEnd()
24604 
    iprot.readStructEnd()
24605 
 
24606 
  def write(self, oprot):
24607 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24608 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24609 
      return
24610 
    oprot.writeStructBegin('getReshippedOrderIds_args')
24611 
    if self.orderIds is not None:
24612 
      oprot.writeFieldBegin('orderIds', TType.LIST, 1)
24613 
      oprot.writeListBegin(TType.I64, len(self.orderIds))
6188 rajveer 24614 
      for iter576 in self.orderIds:
24615 
        oprot.writeI64(iter576)
4715 varun.gupt 24616 
      oprot.writeListEnd()
24617 
      oprot.writeFieldEnd()
24618 
    oprot.writeFieldStop()
24619 
    oprot.writeStructEnd()
24620 
 
24621 
  def validate(self):
24622 
    return
24623 
 
24624 
 
24625 
  def __repr__(self):
24626 
    L = ['%s=%r' % (key, value)
24627 
      for key, value in self.__dict__.iteritems()]
24628 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24629 
 
24630 
  def __eq__(self, other):
24631 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24632 
 
24633 
  def __ne__(self, other):
24634 
    return not (self == other)
24635 
 
24636 
class getReshippedOrderIds_result:
24637 
  """
24638 
  Attributes:
24639 
   - success
24640 
   - ex
24641 
  """
24642 
 
24643 
  thrift_spec = (
24644 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
24645 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
24646 
  )
24647 
 
24648 
  def __init__(self, success=None, ex=None,):
24649 
    self.success = success
24650 
    self.ex = ex
24651 
 
24652 
  def read(self, iprot):
24653 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24654 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24655 
      return
24656 
    iprot.readStructBegin()
24657 
    while True:
24658 
      (fname, ftype, fid) = iprot.readFieldBegin()
24659 
      if ftype == TType.STOP:
24660 
        break
24661 
      if fid == 0:
24662 
        if ftype == TType.LIST:
24663 
          self.success = []
6188 rajveer 24664 
          (_etype580, _size577) = iprot.readListBegin()
24665 
          for _i581 in xrange(_size577):
24666 
            _elem582 = iprot.readI64();
24667 
            self.success.append(_elem582)
4715 varun.gupt 24668 
          iprot.readListEnd()
24669 
        else:
24670 
          iprot.skip(ftype)
24671 
      elif fid == 1:
24672 
        if ftype == TType.STRUCT:
24673 
          self.ex = TransactionServiceException()
24674 
          self.ex.read(iprot)
24675 
        else:
24676 
          iprot.skip(ftype)
24677 
      else:
24678 
        iprot.skip(ftype)
24679 
      iprot.readFieldEnd()
24680 
    iprot.readStructEnd()
24681 
 
24682 
  def write(self, oprot):
24683 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24684 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24685 
      return
24686 
    oprot.writeStructBegin('getReshippedOrderIds_result')
24687 
    if self.success is not None:
24688 
      oprot.writeFieldBegin('success', TType.LIST, 0)
24689 
      oprot.writeListBegin(TType.I64, len(self.success))
6188 rajveer 24690 
      for iter583 in self.success:
24691 
        oprot.writeI64(iter583)
4715 varun.gupt 24692 
      oprot.writeListEnd()
24693 
      oprot.writeFieldEnd()
24694 
    if self.ex is not None:
24695 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
24696 
      self.ex.write(oprot)
24697 
      oprot.writeFieldEnd()
24698 
    oprot.writeFieldStop()
24699 
    oprot.writeStructEnd()
24700 
 
24701 
  def validate(self):
24702 
    return
24703 
 
24704 
 
24705 
  def __repr__(self):
24706 
    L = ['%s=%r' % (key, value)
24707 
      for key, value in self.__dict__.iteritems()]
24708 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24709 
 
24710 
  def __eq__(self, other):
24711 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24712 
 
24713 
  def __ne__(self, other):
24714 
    return not (self == other)
4757 mandeep.dh 24715 
 
5481 phani.kuma 24716 
class getBilledOrders_args:
4875 varun.gupt 24717 
  """
24718 
  Attributes:
24719 
   - vendorId
5481 phani.kuma 24720 
   - onlyVendorNotPaid
24721 
   - billingDateFrom
24722 
   - billingDateTo
4875 varun.gupt 24723 
  """
24724 
 
24725 
  thrift_spec = (
24726 
    None, # 0
24727 
    (1, TType.I64, 'vendorId', None, None, ), # 1
5481 phani.kuma 24728 
    (2, TType.BOOL, 'onlyVendorNotPaid', None, None, ), # 2
24729 
    (3, TType.I64, 'billingDateFrom', None, None, ), # 3
24730 
    (4, TType.I64, 'billingDateTo', None, None, ), # 4
4875 varun.gupt 24731 
  )
24732 
 
5481 phani.kuma 24733 
  def __init__(self, vendorId=None, onlyVendorNotPaid=None, billingDateFrom=None, billingDateTo=None,):
4875 varun.gupt 24734 
    self.vendorId = vendorId
5481 phani.kuma 24735 
    self.onlyVendorNotPaid = onlyVendorNotPaid
24736 
    self.billingDateFrom = billingDateFrom
24737 
    self.billingDateTo = billingDateTo
4875 varun.gupt 24738 
 
24739 
  def read(self, iprot):
24740 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24741 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24742 
      return
24743 
    iprot.readStructBegin()
24744 
    while True:
24745 
      (fname, ftype, fid) = iprot.readFieldBegin()
24746 
      if ftype == TType.STOP:
24747 
        break
24748 
      if fid == 1:
24749 
        if ftype == TType.I64:
24750 
          self.vendorId = iprot.readI64();
24751 
        else:
24752 
          iprot.skip(ftype)
5481 phani.kuma 24753 
      elif fid == 2:
24754 
        if ftype == TType.BOOL:
24755 
          self.onlyVendorNotPaid = iprot.readBool();
24756 
        else:
24757 
          iprot.skip(ftype)
24758 
      elif fid == 3:
24759 
        if ftype == TType.I64:
24760 
          self.billingDateFrom = iprot.readI64();
24761 
        else:
24762 
          iprot.skip(ftype)
24763 
      elif fid == 4:
24764 
        if ftype == TType.I64:
24765 
          self.billingDateTo = iprot.readI64();
24766 
        else:
24767 
          iprot.skip(ftype)
4875 varun.gupt 24768 
      else:
24769 
        iprot.skip(ftype)
24770 
      iprot.readFieldEnd()
24771 
    iprot.readStructEnd()
24772 
 
24773 
  def write(self, oprot):
24774 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24775 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24776 
      return
5481 phani.kuma 24777 
    oprot.writeStructBegin('getBilledOrders_args')
4875 varun.gupt 24778 
    if self.vendorId is not None:
24779 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
24780 
      oprot.writeI64(self.vendorId)
24781 
      oprot.writeFieldEnd()
5481 phani.kuma 24782 
    if self.onlyVendorNotPaid is not None:
24783 
      oprot.writeFieldBegin('onlyVendorNotPaid', TType.BOOL, 2)
24784 
      oprot.writeBool(self.onlyVendorNotPaid)
24785 
      oprot.writeFieldEnd()
24786 
    if self.billingDateFrom is not None:
24787 
      oprot.writeFieldBegin('billingDateFrom', TType.I64, 3)
24788 
      oprot.writeI64(self.billingDateFrom)
24789 
      oprot.writeFieldEnd()
24790 
    if self.billingDateTo is not None:
24791 
      oprot.writeFieldBegin('billingDateTo', TType.I64, 4)
24792 
      oprot.writeI64(self.billingDateTo)
24793 
      oprot.writeFieldEnd()
4875 varun.gupt 24794 
    oprot.writeFieldStop()
24795 
    oprot.writeStructEnd()
24796 
 
24797 
  def validate(self):
24798 
    return
24799 
 
24800 
 
24801 
  def __repr__(self):
24802 
    L = ['%s=%r' % (key, value)
24803 
      for key, value in self.__dict__.iteritems()]
24804 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24805 
 
24806 
  def __eq__(self, other):
24807 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24808 
 
24809 
  def __ne__(self, other):
24810 
    return not (self == other)
24811 
 
5481 phani.kuma 24812 
class getBilledOrders_result:
4875 varun.gupt 24813 
  """
24814 
  Attributes:
24815 
   - success
24816 
   - ex
24817 
  """
24818 
 
24819 
  thrift_spec = (
24820 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
24821 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
24822 
  )
24823 
 
24824 
  def __init__(self, success=None, ex=None,):
24825 
    self.success = success
24826 
    self.ex = ex
24827 
 
24828 
  def read(self, iprot):
24829 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24830 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24831 
      return
24832 
    iprot.readStructBegin()
24833 
    while True:
24834 
      (fname, ftype, fid) = iprot.readFieldBegin()
24835 
      if ftype == TType.STOP:
24836 
        break
24837 
      if fid == 0:
24838 
        if ftype == TType.LIST:
24839 
          self.success = []
6188 rajveer 24840 
          (_etype587, _size584) = iprot.readListBegin()
24841 
          for _i588 in xrange(_size584):
24842 
            _elem589 = Order()
24843 
            _elem589.read(iprot)
24844 
            self.success.append(_elem589)
4875 varun.gupt 24845 
          iprot.readListEnd()
24846 
        else:
24847 
          iprot.skip(ftype)
24848 
      elif fid == 1:
24849 
        if ftype == TType.STRUCT:
24850 
          self.ex = TransactionServiceException()
24851 
          self.ex.read(iprot)
24852 
        else:
24853 
          iprot.skip(ftype)
24854 
      else:
24855 
        iprot.skip(ftype)
24856 
      iprot.readFieldEnd()
24857 
    iprot.readStructEnd()
24858 
 
24859 
  def write(self, oprot):
24860 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24861 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24862 
      return
5481 phani.kuma 24863 
    oprot.writeStructBegin('getBilledOrders_result')
4875 varun.gupt 24864 
    if self.success is not None:
24865 
      oprot.writeFieldBegin('success', TType.LIST, 0)
24866 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 24867 
      for iter590 in self.success:
24868 
        iter590.write(oprot)
4875 varun.gupt 24869 
      oprot.writeListEnd()
24870 
      oprot.writeFieldEnd()
24871 
    if self.ex is not None:
24872 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
24873 
      self.ex.write(oprot)
24874 
      oprot.writeFieldEnd()
24875 
    oprot.writeFieldStop()
24876 
    oprot.writeStructEnd()
24877 
 
24878 
  def validate(self):
24879 
    return
24880 
 
24881 
 
24882 
  def __repr__(self):
24883 
    L = ['%s=%r' % (key, value)
24884 
      for key, value in self.__dict__.iteritems()]
24885 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24886 
 
24887 
  def __eq__(self, other):
24888 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24889 
 
24890 
  def __ne__(self, other):
24891 
    return not (self == other)
5031 varun.gupt 24892 
 
24893 
class getStatusDistributionOfOrders_args:
24894 
  """
24895 
  Attributes:
24896 
   - startDate
24897 
   - endDate
24898 
  """
24899 
 
24900 
  thrift_spec = (
24901 
    None, # 0
24902 
    (1, TType.I64, 'startDate', None, None, ), # 1
24903 
    (2, TType.I64, 'endDate', None, None, ), # 2
24904 
  )
24905 
 
24906 
  def __init__(self, startDate=None, endDate=None,):
24907 
    self.startDate = startDate
24908 
    self.endDate = endDate
24909 
 
24910 
  def read(self, iprot):
24911 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24912 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24913 
      return
24914 
    iprot.readStructBegin()
24915 
    while True:
24916 
      (fname, ftype, fid) = iprot.readFieldBegin()
24917 
      if ftype == TType.STOP:
24918 
        break
24919 
      if fid == 1:
24920 
        if ftype == TType.I64:
24921 
          self.startDate = iprot.readI64();
24922 
        else:
24923 
          iprot.skip(ftype)
24924 
      elif fid == 2:
24925 
        if ftype == TType.I64:
24926 
          self.endDate = iprot.readI64();
24927 
        else:
24928 
          iprot.skip(ftype)
24929 
      else:
24930 
        iprot.skip(ftype)
24931 
      iprot.readFieldEnd()
24932 
    iprot.readStructEnd()
24933 
 
24934 
  def write(self, oprot):
24935 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24936 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24937 
      return
24938 
    oprot.writeStructBegin('getStatusDistributionOfOrders_args')
24939 
    if self.startDate is not None:
24940 
      oprot.writeFieldBegin('startDate', TType.I64, 1)
24941 
      oprot.writeI64(self.startDate)
24942 
      oprot.writeFieldEnd()
24943 
    if self.endDate is not None:
24944 
      oprot.writeFieldBegin('endDate', TType.I64, 2)
24945 
      oprot.writeI64(self.endDate)
24946 
      oprot.writeFieldEnd()
24947 
    oprot.writeFieldStop()
24948 
    oprot.writeStructEnd()
24949 
 
24950 
  def validate(self):
24951 
    return
24952 
 
24953 
 
24954 
  def __repr__(self):
24955 
    L = ['%s=%r' % (key, value)
24956 
      for key, value in self.__dict__.iteritems()]
24957 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24958 
 
24959 
  def __eq__(self, other):
24960 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24961 
 
24962 
  def __ne__(self, other):
24963 
    return not (self == other)
24964 
 
24965 
class getStatusDistributionOfOrders_result:
24966 
  """
24967 
  Attributes:
24968 
   - success
24969 
   - ex
24970 
  """
24971 
 
24972 
  thrift_spec = (
24973 
    (0, TType.MAP, 'success', (TType.I64,None,TType.I64,None), None, ), # 0
24974 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
24975 
  )
24976 
 
24977 
  def __init__(self, success=None, ex=None,):
24978 
    self.success = success
24979 
    self.ex = ex
24980 
 
24981 
  def read(self, iprot):
24982 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24983 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24984 
      return
24985 
    iprot.readStructBegin()
24986 
    while True:
24987 
      (fname, ftype, fid) = iprot.readFieldBegin()
24988 
      if ftype == TType.STOP:
24989 
        break
24990 
      if fid == 0:
24991 
        if ftype == TType.MAP:
24992 
          self.success = {}
6188 rajveer 24993 
          (_ktype592, _vtype593, _size591 ) = iprot.readMapBegin()
24994 
          for _i595 in xrange(_size591):
24995 
            _key596 = iprot.readI64();
24996 
            _val597 = iprot.readI64();
24997 
            self.success[_key596] = _val597
5031 varun.gupt 24998 
          iprot.readMapEnd()
24999 
        else:
25000 
          iprot.skip(ftype)
25001 
      elif fid == 1:
25002 
        if ftype == TType.STRUCT:
25003 
          self.ex = TransactionServiceException()
25004 
          self.ex.read(iprot)
25005 
        else:
25006 
          iprot.skip(ftype)
25007 
      else:
25008 
        iprot.skip(ftype)
25009 
      iprot.readFieldEnd()
25010 
    iprot.readStructEnd()
25011 
 
25012 
  def write(self, oprot):
25013 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25014 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25015 
      return
25016 
    oprot.writeStructBegin('getStatusDistributionOfOrders_result')
25017 
    if self.success is not None:
25018 
      oprot.writeFieldBegin('success', TType.MAP, 0)
25019 
      oprot.writeMapBegin(TType.I64, TType.I64, len(self.success))
6188 rajveer 25020 
      for kiter598,viter599 in self.success.items():
25021 
        oprot.writeI64(kiter598)
25022 
        oprot.writeI64(viter599)
5031 varun.gupt 25023 
      oprot.writeMapEnd()
25024 
      oprot.writeFieldEnd()
25025 
    if self.ex is not None:
25026 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
25027 
      self.ex.write(oprot)
25028 
      oprot.writeFieldEnd()
25029 
    oprot.writeFieldStop()
25030 
    oprot.writeStructEnd()
25031 
 
25032 
  def validate(self):
25033 
    return
25034 
 
25035 
 
25036 
  def __repr__(self):
25037 
    L = ['%s=%r' % (key, value)
25038 
      for key, value in self.__dict__.iteritems()]
25039 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25040 
 
25041 
  def __eq__(self, other):
25042 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25043 
 
25044 
  def __ne__(self, other):
25045 
    return not (self == other)
5067 varun.gupt 25046 
 
25047 
class getOrderIdsForStatus_args:
25048 
  """
25049 
  Attributes:
25050 
   - status
25051 
   - startDatetime
25052 
   - endDatetime
25053 
  """
25054 
 
25055 
  thrift_spec = (
25056 
    None, # 0
25057 
    (1, TType.I64, 'status', None, None, ), # 1
25058 
    (2, TType.I64, 'startDatetime', None, None, ), # 2
25059 
    (3, TType.I64, 'endDatetime', None, None, ), # 3
25060 
  )
25061 
 
25062 
  def __init__(self, status=None, startDatetime=None, endDatetime=None,):
25063 
    self.status = status
25064 
    self.startDatetime = startDatetime
25065 
    self.endDatetime = endDatetime
25066 
 
25067 
  def read(self, iprot):
25068 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25069 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25070 
      return
25071 
    iprot.readStructBegin()
25072 
    while True:
25073 
      (fname, ftype, fid) = iprot.readFieldBegin()
25074 
      if ftype == TType.STOP:
25075 
        break
25076 
      if fid == 1:
25077 
        if ftype == TType.I64:
25078 
          self.status = iprot.readI64();
25079 
        else:
25080 
          iprot.skip(ftype)
25081 
      elif fid == 2:
25082 
        if ftype == TType.I64:
25083 
          self.startDatetime = iprot.readI64();
25084 
        else:
25085 
          iprot.skip(ftype)
25086 
      elif fid == 3:
25087 
        if ftype == TType.I64:
25088 
          self.endDatetime = iprot.readI64();
25089 
        else:
25090 
          iprot.skip(ftype)
25091 
      else:
25092 
        iprot.skip(ftype)
25093 
      iprot.readFieldEnd()
25094 
    iprot.readStructEnd()
25095 
 
25096 
  def write(self, oprot):
25097 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25098 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25099 
      return
25100 
    oprot.writeStructBegin('getOrderIdsForStatus_args')
25101 
    if self.status is not None:
25102 
      oprot.writeFieldBegin('status', TType.I64, 1)
25103 
      oprot.writeI64(self.status)
25104 
      oprot.writeFieldEnd()
25105 
    if self.startDatetime is not None:
25106 
      oprot.writeFieldBegin('startDatetime', TType.I64, 2)
25107 
      oprot.writeI64(self.startDatetime)
25108 
      oprot.writeFieldEnd()
25109 
    if self.endDatetime is not None:
25110 
      oprot.writeFieldBegin('endDatetime', TType.I64, 3)
25111 
      oprot.writeI64(self.endDatetime)
25112 
      oprot.writeFieldEnd()
25113 
    oprot.writeFieldStop()
25114 
    oprot.writeStructEnd()
25115 
 
25116 
  def validate(self):
25117 
    return
25118 
 
25119 
 
25120 
  def __repr__(self):
25121 
    L = ['%s=%r' % (key, value)
25122 
      for key, value in self.__dict__.iteritems()]
25123 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25124 
 
25125 
  def __eq__(self, other):
25126 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25127 
 
25128 
  def __ne__(self, other):
25129 
    return not (self == other)
25130 
 
25131 
class getOrderIdsForStatus_result:
25132 
  """
25133 
  Attributes:
25134 
   - success
25135 
   - ex
25136 
  """
25137 
 
25138 
  thrift_spec = (
25139 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
25140 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
25141 
  )
25142 
 
25143 
  def __init__(self, success=None, ex=None,):
25144 
    self.success = success
25145 
    self.ex = ex
25146 
 
25147 
  def read(self, iprot):
25148 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25149 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25150 
      return
25151 
    iprot.readStructBegin()
25152 
    while True:
25153 
      (fname, ftype, fid) = iprot.readFieldBegin()
25154 
      if ftype == TType.STOP:
25155 
        break
25156 
      if fid == 0:
25157 
        if ftype == TType.LIST:
25158 
          self.success = []
6188 rajveer 25159 
          (_etype603, _size600) = iprot.readListBegin()
25160 
          for _i604 in xrange(_size600):
25161 
            _elem605 = iprot.readI64();
25162 
            self.success.append(_elem605)
5067 varun.gupt 25163 
          iprot.readListEnd()
25164 
        else:
25165 
          iprot.skip(ftype)
25166 
      elif fid == 1:
25167 
        if ftype == TType.STRUCT:
25168 
          self.ex = TransactionServiceException()
25169 
          self.ex.read(iprot)
25170 
        else:
25171 
          iprot.skip(ftype)
25172 
      else:
25173 
        iprot.skip(ftype)
25174 
      iprot.readFieldEnd()
25175 
    iprot.readStructEnd()
25176 
 
25177 
  def write(self, oprot):
25178 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25179 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25180 
      return
25181 
    oprot.writeStructBegin('getOrderIdsForStatus_result')
25182 
    if self.success is not None:
25183 
      oprot.writeFieldBegin('success', TType.LIST, 0)
25184 
      oprot.writeListBegin(TType.I64, len(self.success))
6188 rajveer 25185 
      for iter606 in self.success:
25186 
        oprot.writeI64(iter606)
5067 varun.gupt 25187 
      oprot.writeListEnd()
25188 
      oprot.writeFieldEnd()
25189 
    if self.ex is not None:
25190 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
25191 
      self.ex.write(oprot)
25192 
      oprot.writeFieldEnd()
25193 
    oprot.writeFieldStop()
25194 
    oprot.writeStructEnd()
25195 
 
25196 
  def validate(self):
25197 
    return
25198 
 
25199 
 
25200 
  def __repr__(self):
25201 
    L = ['%s=%r' % (key, value)
25202 
      for key, value in self.__dict__.iteritems()]
25203 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25204 
 
25205 
  def __eq__(self, other):
25206 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25207 
 
25208 
  def __ne__(self, other):
25209 
    return not (self == other)
5099 varun.gupt 25210 
 
5348 anupam.sin 25211 
class updateCODAgent_args:
25212 
  """
25213 
  Attributes:
25214 
   - agent
25215 
   - orderId
25216 
  """
25217 
 
25218 
  thrift_spec = (
25219 
    None, # 0
25220 
    (1, TType.STRING, 'agent', None, None, ), # 1
25221 
    (2, TType.I64, 'orderId', None, None, ), # 2
25222 
  )
25223 
 
25224 
  def __init__(self, agent=None, orderId=None,):
25225 
    self.agent = agent
25226 
    self.orderId = orderId
25227 
 
25228 
  def read(self, iprot):
25229 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25230 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25231 
      return
25232 
    iprot.readStructBegin()
25233 
    while True:
25234 
      (fname, ftype, fid) = iprot.readFieldBegin()
25235 
      if ftype == TType.STOP:
25236 
        break
25237 
      if fid == 1:
25238 
        if ftype == TType.STRING:
25239 
          self.agent = iprot.readString();
25240 
        else:
25241 
          iprot.skip(ftype)
25242 
      elif fid == 2:
25243 
        if ftype == TType.I64:
25244 
          self.orderId = iprot.readI64();
25245 
        else:
25246 
          iprot.skip(ftype)
25247 
      else:
25248 
        iprot.skip(ftype)
25249 
      iprot.readFieldEnd()
25250 
    iprot.readStructEnd()
25251 
 
25252 
  def write(self, oprot):
25253 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25254 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25255 
      return
25256 
    oprot.writeStructBegin('updateCODAgent_args')
25257 
    if self.agent is not None:
25258 
      oprot.writeFieldBegin('agent', TType.STRING, 1)
25259 
      oprot.writeString(self.agent)
25260 
      oprot.writeFieldEnd()
25261 
    if self.orderId is not None:
25262 
      oprot.writeFieldBegin('orderId', TType.I64, 2)
25263 
      oprot.writeI64(self.orderId)
25264 
      oprot.writeFieldEnd()
25265 
    oprot.writeFieldStop()
25266 
    oprot.writeStructEnd()
25267 
 
25268 
  def validate(self):
25269 
    return
25270 
 
25271 
 
25272 
  def __repr__(self):
25273 
    L = ['%s=%r' % (key, value)
25274 
      for key, value in self.__dict__.iteritems()]
25275 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25276 
 
25277 
  def __eq__(self, other):
25278 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25279 
 
25280 
  def __ne__(self, other):
25281 
    return not (self == other)
25282 
 
25283 
class updateCODAgent_result:
25284 
  """
25285 
  Attributes:
25286 
   - ex
25287 
  """
25288 
 
25289 
  thrift_spec = (
25290 
    None, # 0
25291 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
25292 
  )
25293 
 
25294 
  def __init__(self, ex=None,):
25295 
    self.ex = ex
25296 
 
25297 
  def read(self, iprot):
25298 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25299 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25300 
      return
25301 
    iprot.readStructBegin()
25302 
    while True:
25303 
      (fname, ftype, fid) = iprot.readFieldBegin()
25304 
      if ftype == TType.STOP:
25305 
        break
25306 
      if fid == 1:
25307 
        if ftype == TType.STRUCT:
25308 
          self.ex = TransactionServiceException()
25309 
          self.ex.read(iprot)
25310 
        else:
25311 
          iprot.skip(ftype)
25312 
      else:
25313 
        iprot.skip(ftype)
25314 
      iprot.readFieldEnd()
25315 
    iprot.readStructEnd()
25316 
 
25317 
  def write(self, oprot):
25318 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25319 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25320 
      return
25321 
    oprot.writeStructBegin('updateCODAgent_result')
25322 
    if self.ex is not None:
25323 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
25324 
      self.ex.write(oprot)
25325 
      oprot.writeFieldEnd()
25326 
    oprot.writeFieldStop()
25327 
    oprot.writeStructEnd()
25328 
 
25329 
  def validate(self):
25330 
    return
25331 
 
25332 
 
25333 
  def __repr__(self):
25334 
    L = ['%s=%r' % (key, value)
25335 
      for key, value in self.__dict__.iteritems()]
25336 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25337 
 
25338 
  def __eq__(self, other):
25339 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25340 
 
25341 
  def __ne__(self, other):
25342 
    return not (self == other)
25343 
 
5099 varun.gupt 25344 
class updateOrderAsPaidToVendor_args:
25345 
  """
25346 
  Attributes:
25347 
   - orderId
25348 
  """
25349 
 
25350 
  thrift_spec = (
25351 
    None, # 0
25352 
    (1, TType.I64, 'orderId', None, None, ), # 1
25353 
  )
25354 
 
25355 
  def __init__(self, orderId=None,):
25356 
    self.orderId = orderId
25357 
 
25358 
  def read(self, iprot):
25359 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25360 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25361 
      return
25362 
    iprot.readStructBegin()
25363 
    while True:
25364 
      (fname, ftype, fid) = iprot.readFieldBegin()
25365 
      if ftype == TType.STOP:
25366 
        break
25367 
      if fid == 1:
25368 
        if ftype == TType.I64:
25369 
          self.orderId = iprot.readI64();
25370 
        else:
25371 
          iprot.skip(ftype)
25372 
      else:
25373 
        iprot.skip(ftype)
25374 
      iprot.readFieldEnd()
25375 
    iprot.readStructEnd()
25376 
 
25377 
  def write(self, oprot):
25378 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25379 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25380 
      return
25381 
    oprot.writeStructBegin('updateOrderAsPaidToVendor_args')
25382 
    if self.orderId is not None:
25383 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
25384 
      oprot.writeI64(self.orderId)
25385 
      oprot.writeFieldEnd()
25386 
    oprot.writeFieldStop()
25387 
    oprot.writeStructEnd()
25388 
 
25389 
  def validate(self):
25390 
    return
25391 
 
25392 
 
25393 
  def __repr__(self):
25394 
    L = ['%s=%r' % (key, value)
25395 
      for key, value in self.__dict__.iteritems()]
25396 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25397 
 
25398 
  def __eq__(self, other):
25399 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25400 
 
25401 
  def __ne__(self, other):
25402 
    return not (self == other)
25403 
 
25404 
class updateOrderAsPaidToVendor_result:
25405 
  """
25406 
  Attributes:
25407 
   - ex
25408 
  """
25409 
 
25410 
  thrift_spec = (
25411 
    None, # 0
25412 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
25413 
  )
25414 
 
25415 
  def __init__(self, ex=None,):
25416 
    self.ex = ex
25417 
 
25418 
  def read(self, iprot):
25419 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25420 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25421 
      return
25422 
    iprot.readStructBegin()
25423 
    while True:
25424 
      (fname, ftype, fid) = iprot.readFieldBegin()
25425 
      if ftype == TType.STOP:
25426 
        break
25427 
      if fid == 1:
25428 
        if ftype == TType.STRUCT:
25429 
          self.ex = TransactionServiceException()
25430 
          self.ex.read(iprot)
25431 
        else:
25432 
          iprot.skip(ftype)
25433 
      else:
25434 
        iprot.skip(ftype)
25435 
      iprot.readFieldEnd()
25436 
    iprot.readStructEnd()
25437 
 
25438 
  def write(self, oprot):
25439 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25440 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25441 
      return
25442 
    oprot.writeStructBegin('updateOrderAsPaidToVendor_result')
25443 
    if self.ex is not None:
25444 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
25445 
      self.ex.write(oprot)
25446 
      oprot.writeFieldEnd()
25447 
    oprot.writeFieldStop()
25448 
    oprot.writeStructEnd()
25449 
 
25450 
  def validate(self):
25451 
    return
25452 
 
25453 
 
25454 
  def __repr__(self):
25455 
    L = ['%s=%r' % (key, value)
25456 
      for key, value in self.__dict__.iteritems()]
25457 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25458 
 
25459 
  def __eq__(self, other):
25460 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25461 
 
25462 
  def __ne__(self, other):
25463 
    return not (self == other)
5208 varun.gupt 25464 
 
5386 phani.kuma 25465 
class updateOrderOnlyAsPaidToVendor_args:
25466 
  """
25467 
  Attributes:
25468 
   - orderId
25469 
  """
25470 
 
25471 
  thrift_spec = (
25472 
    None, # 0
25473 
    (1, TType.I64, 'orderId', None, None, ), # 1
25474 
  )
25475 
 
25476 
  def __init__(self, orderId=None,):
25477 
    self.orderId = orderId
25478 
 
25479 
  def read(self, iprot):
25480 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25481 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25482 
      return
25483 
    iprot.readStructBegin()
25484 
    while True:
25485 
      (fname, ftype, fid) = iprot.readFieldBegin()
25486 
      if ftype == TType.STOP:
25487 
        break
25488 
      if fid == 1:
25489 
        if ftype == TType.I64:
25490 
          self.orderId = iprot.readI64();
25491 
        else:
25492 
          iprot.skip(ftype)
25493 
      else:
25494 
        iprot.skip(ftype)
25495 
      iprot.readFieldEnd()
25496 
    iprot.readStructEnd()
25497 
 
25498 
  def write(self, oprot):
25499 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25500 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25501 
      return
25502 
    oprot.writeStructBegin('updateOrderOnlyAsPaidToVendor_args')
25503 
    if self.orderId is not None:
25504 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
25505 
      oprot.writeI64(self.orderId)
25506 
      oprot.writeFieldEnd()
25507 
    oprot.writeFieldStop()
25508 
    oprot.writeStructEnd()
25509 
 
25510 
  def validate(self):
25511 
    return
25512 
 
25513 
 
25514 
  def __repr__(self):
25515 
    L = ['%s=%r' % (key, value)
25516 
      for key, value in self.__dict__.iteritems()]
25517 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25518 
 
25519 
  def __eq__(self, other):
25520 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25521 
 
25522 
  def __ne__(self, other):
25523 
    return not (self == other)
25524 
 
25525 
class updateOrderOnlyAsPaidToVendor_result:
25526 
  """
25527 
  Attributes:
25528 
   - ex
25529 
  """
25530 
 
25531 
  thrift_spec = (
25532 
    None, # 0
25533 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
25534 
  )
25535 
 
25536 
  def __init__(self, ex=None,):
25537 
    self.ex = ex
25538 
 
25539 
  def read(self, iprot):
25540 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25541 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25542 
      return
25543 
    iprot.readStructBegin()
25544 
    while True:
25545 
      (fname, ftype, fid) = iprot.readFieldBegin()
25546 
      if ftype == TType.STOP:
25547 
        break
25548 
      if fid == 1:
25549 
        if ftype == TType.STRUCT:
25550 
          self.ex = TransactionServiceException()
25551 
          self.ex.read(iprot)
25552 
        else:
25553 
          iprot.skip(ftype)
25554 
      else:
25555 
        iprot.skip(ftype)
25556 
      iprot.readFieldEnd()
25557 
    iprot.readStructEnd()
25558 
 
25559 
  def write(self, oprot):
25560 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25561 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25562 
      return
25563 
    oprot.writeStructBegin('updateOrderOnlyAsPaidToVendor_result')
25564 
    if self.ex is not None:
25565 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
25566 
      self.ex.write(oprot)
25567 
      oprot.writeFieldEnd()
25568 
    oprot.writeFieldStop()
25569 
    oprot.writeStructEnd()
25570 
 
25571 
  def validate(self):
25572 
    return
25573 
 
25574 
 
25575 
  def __repr__(self):
25576 
    L = ['%s=%r' % (key, value)
25577 
      for key, value in self.__dict__.iteritems()]
25578 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25579 
 
25580 
  def __eq__(self, other):
25581 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25582 
 
25583 
  def __ne__(self, other):
25584 
    return not (self == other)
25585 
 
5208 varun.gupt 25586 
class getRefundedOrdersMarkedPaid_args:
25587 
 
25588 
  thrift_spec = (
25589 
  )
25590 
 
25591 
  def read(self, iprot):
25592 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25593 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25594 
      return
25595 
    iprot.readStructBegin()
25596 
    while True:
25597 
      (fname, ftype, fid) = iprot.readFieldBegin()
25598 
      if ftype == TType.STOP:
25599 
        break
25600 
      else:
25601 
        iprot.skip(ftype)
25602 
      iprot.readFieldEnd()
25603 
    iprot.readStructEnd()
25604 
 
25605 
  def write(self, oprot):
25606 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25607 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25608 
      return
25609 
    oprot.writeStructBegin('getRefundedOrdersMarkedPaid_args')
25610 
    oprot.writeFieldStop()
25611 
    oprot.writeStructEnd()
25612 
 
25613 
  def validate(self):
25614 
    return
25615 
 
25616 
 
25617 
  def __repr__(self):
25618 
    L = ['%s=%r' % (key, value)
25619 
      for key, value in self.__dict__.iteritems()]
25620 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25621 
 
25622 
  def __eq__(self, other):
25623 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25624 
 
25625 
  def __ne__(self, other):
25626 
    return not (self == other)
25627 
 
25628 
class getRefundedOrdersMarkedPaid_result:
25629 
  """
25630 
  Attributes:
25631 
   - success
25632 
   - ex
25633 
  """
25634 
 
25635 
  thrift_spec = (
25636 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
25637 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
25638 
  )
25639 
 
25640 
  def __init__(self, success=None, ex=None,):
25641 
    self.success = success
25642 
    self.ex = ex
25643 
 
25644 
  def read(self, iprot):
25645 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25646 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25647 
      return
25648 
    iprot.readStructBegin()
25649 
    while True:
25650 
      (fname, ftype, fid) = iprot.readFieldBegin()
25651 
      if ftype == TType.STOP:
25652 
        break
25653 
      if fid == 0:
25654 
        if ftype == TType.LIST:
25655 
          self.success = []
6188 rajveer 25656 
          (_etype610, _size607) = iprot.readListBegin()
25657 
          for _i611 in xrange(_size607):
25658 
            _elem612 = Order()
25659 
            _elem612.read(iprot)
25660 
            self.success.append(_elem612)
5208 varun.gupt 25661 
          iprot.readListEnd()
25662 
        else:
25663 
          iprot.skip(ftype)
25664 
      elif fid == 1:
25665 
        if ftype == TType.STRUCT:
25666 
          self.ex = TransactionServiceException()
25667 
          self.ex.read(iprot)
25668 
        else:
25669 
          iprot.skip(ftype)
25670 
      else:
25671 
        iprot.skip(ftype)
25672 
      iprot.readFieldEnd()
25673 
    iprot.readStructEnd()
25674 
 
25675 
  def write(self, oprot):
25676 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25677 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25678 
      return
25679 
    oprot.writeStructBegin('getRefundedOrdersMarkedPaid_result')
25680 
    if self.success is not None:
25681 
      oprot.writeFieldBegin('success', TType.LIST, 0)
25682 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 25683 
      for iter613 in self.success:
25684 
        iter613.write(oprot)
5208 varun.gupt 25685 
      oprot.writeListEnd()
25686 
      oprot.writeFieldEnd()
25687 
    if self.ex is not None:
25688 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
25689 
      self.ex.write(oprot)
25690 
      oprot.writeFieldEnd()
25691 
    oprot.writeFieldStop()
25692 
    oprot.writeStructEnd()
25693 
 
25694 
  def validate(self):
25695 
    return
25696 
 
25697 
 
25698 
  def __repr__(self):
25699 
    L = ['%s=%r' % (key, value)
25700 
      for key, value in self.__dict__.iteritems()]
25701 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25702 
 
25703 
  def __eq__(self, other):
25704 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25705 
 
25706 
  def __ne__(self, other):
25707 
    return not (self == other)
5447 anupam.sin 25708 
 
25709 
class getAllVerificationAgents_args:
25710 
  """
25711 
  Attributes:
25712 
   - minOrderId
25713 
   - maxOrderId
25714 
  """
25715 
 
25716 
  thrift_spec = (
25717 
    None, # 0
25718 
    (1, TType.I64, 'minOrderId', None, None, ), # 1
25719 
    (2, TType.I64, 'maxOrderId', None, None, ), # 2
25720 
  )
25721 
 
25722 
  def __init__(self, minOrderId=None, maxOrderId=None,):
25723 
    self.minOrderId = minOrderId
25724 
    self.maxOrderId = maxOrderId
25725 
 
25726 
  def read(self, iprot):
25727 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25728 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25729 
      return
25730 
    iprot.readStructBegin()
25731 
    while True:
25732 
      (fname, ftype, fid) = iprot.readFieldBegin()
25733 
      if ftype == TType.STOP:
25734 
        break
25735 
      if fid == 1:
25736 
        if ftype == TType.I64:
25737 
          self.minOrderId = iprot.readI64();
25738 
        else:
25739 
          iprot.skip(ftype)
25740 
      elif fid == 2:
25741 
        if ftype == TType.I64:
25742 
          self.maxOrderId = iprot.readI64();
25743 
        else:
25744 
          iprot.skip(ftype)
25745 
      else:
25746 
        iprot.skip(ftype)
25747 
      iprot.readFieldEnd()
25748 
    iprot.readStructEnd()
25749 
 
25750 
  def write(self, oprot):
25751 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25752 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25753 
      return
25754 
    oprot.writeStructBegin('getAllVerificationAgents_args')
25755 
    if self.minOrderId is not None:
25756 
      oprot.writeFieldBegin('minOrderId', TType.I64, 1)
25757 
      oprot.writeI64(self.minOrderId)
25758 
      oprot.writeFieldEnd()
25759 
    if self.maxOrderId is not None:
25760 
      oprot.writeFieldBegin('maxOrderId', TType.I64, 2)
25761 
      oprot.writeI64(self.maxOrderId)
25762 
      oprot.writeFieldEnd()
25763 
    oprot.writeFieldStop()
25764 
    oprot.writeStructEnd()
25765 
 
25766 
  def validate(self):
25767 
    return
25768 
 
25769 
 
25770 
  def __repr__(self):
25771 
    L = ['%s=%r' % (key, value)
25772 
      for key, value in self.__dict__.iteritems()]
25773 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25774 
 
25775 
  def __eq__(self, other):
25776 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25777 
 
25778 
  def __ne__(self, other):
25779 
    return not (self == other)
25780 
 
25781 
class getAllVerificationAgents_result:
25782 
  """
25783 
  Attributes:
25784 
   - success
25785 
  """
25786 
 
25787 
  thrift_spec = (
25788 
    (0, TType.LIST, 'success', (TType.STRUCT,(CODVerificationAgent, CODVerificationAgent.thrift_spec)), None, ), # 0
25789 
  )
25790 
 
25791 
  def __init__(self, success=None,):
25792 
    self.success = success
25793 
 
25794 
  def read(self, iprot):
25795 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25796 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25797 
      return
25798 
    iprot.readStructBegin()
25799 
    while True:
25800 
      (fname, ftype, fid) = iprot.readFieldBegin()
25801 
      if ftype == TType.STOP:
25802 
        break
25803 
      if fid == 0:
25804 
        if ftype == TType.LIST:
25805 
          self.success = []
6188 rajveer 25806 
          (_etype617, _size614) = iprot.readListBegin()
25807 
          for _i618 in xrange(_size614):
25808 
            _elem619 = CODVerificationAgent()
25809 
            _elem619.read(iprot)
25810 
            self.success.append(_elem619)
5447 anupam.sin 25811 
          iprot.readListEnd()
25812 
        else:
25813 
          iprot.skip(ftype)
25814 
      else:
25815 
        iprot.skip(ftype)
25816 
      iprot.readFieldEnd()
25817 
    iprot.readStructEnd()
25818 
 
25819 
  def write(self, oprot):
25820 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25821 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25822 
      return
25823 
    oprot.writeStructBegin('getAllVerificationAgents_result')
25824 
    if self.success is not None:
25825 
      oprot.writeFieldBegin('success', TType.LIST, 0)
25826 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 25827 
      for iter620 in self.success:
25828 
        iter620.write(oprot)
5447 anupam.sin 25829 
      oprot.writeListEnd()
25830 
      oprot.writeFieldEnd()
25831 
    oprot.writeFieldStop()
25832 
    oprot.writeStructEnd()
25833 
 
25834 
  def validate(self):
25835 
    return
25836 
 
25837 
 
25838 
  def __repr__(self):
25839 
    L = ['%s=%r' % (key, value)
25840 
      for key, value in self.__dict__.iteritems()]
25841 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25842 
 
25843 
  def __eq__(self, other):
25844 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25845 
 
25846 
  def __ne__(self, other):
25847 
    return not (self == other)
5527 anupam.sin 25848 
 
25849 
class getAllAttributesForOrderId_args:
25850 
  """
25851 
  Attributes:
25852 
   - orderId
25853 
  """
25854 
 
25855 
  thrift_spec = (
25856 
    None, # 0
25857 
    (1, TType.I64, 'orderId', None, None, ), # 1
25858 
  )
25859 
 
25860 
  def __init__(self, orderId=None,):
25861 
    self.orderId = orderId
25862 
 
25863 
  def read(self, iprot):
25864 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25865 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25866 
      return
25867 
    iprot.readStructBegin()
25868 
    while True:
25869 
      (fname, ftype, fid) = iprot.readFieldBegin()
25870 
      if ftype == TType.STOP:
25871 
        break
25872 
      if fid == 1:
25873 
        if ftype == TType.I64:
25874 
          self.orderId = iprot.readI64();
25875 
        else:
25876 
          iprot.skip(ftype)
25877 
      else:
25878 
        iprot.skip(ftype)
25879 
      iprot.readFieldEnd()
25880 
    iprot.readStructEnd()
25881 
 
25882 
  def write(self, oprot):
25883 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25884 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25885 
      return
25886 
    oprot.writeStructBegin('getAllAttributesForOrderId_args')
25887 
    if self.orderId is not None:
25888 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
25889 
      oprot.writeI64(self.orderId)
25890 
      oprot.writeFieldEnd()
25891 
    oprot.writeFieldStop()
25892 
    oprot.writeStructEnd()
25893 
 
25894 
  def validate(self):
25895 
    return
25896 
 
25897 
 
25898 
  def __repr__(self):
25899 
    L = ['%s=%r' % (key, value)
25900 
      for key, value in self.__dict__.iteritems()]
25901 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25902 
 
25903 
  def __eq__(self, other):
25904 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25905 
 
25906 
  def __ne__(self, other):
25907 
    return not (self == other)
25908 
 
25909 
class getAllAttributesForOrderId_result:
25910 
  """
25911 
  Attributes:
25912 
   - success
25913 
  """
25914 
 
25915 
  thrift_spec = (
25916 
    (0, TType.LIST, 'success', (TType.STRUCT,(Attribute, Attribute.thrift_spec)), None, ), # 0
25917 
  )
25918 
 
25919 
  def __init__(self, success=None,):
25920 
    self.success = success
25921 
 
25922 
  def read(self, iprot):
25923 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25924 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25925 
      return
25926 
    iprot.readStructBegin()
25927 
    while True:
25928 
      (fname, ftype, fid) = iprot.readFieldBegin()
25929 
      if ftype == TType.STOP:
25930 
        break
25931 
      if fid == 0:
25932 
        if ftype == TType.LIST:
25933 
          self.success = []
6188 rajveer 25934 
          (_etype624, _size621) = iprot.readListBegin()
25935 
          for _i625 in xrange(_size621):
25936 
            _elem626 = Attribute()
25937 
            _elem626.read(iprot)
25938 
            self.success.append(_elem626)
5527 anupam.sin 25939 
          iprot.readListEnd()
25940 
        else:
25941 
          iprot.skip(ftype)
25942 
      else:
25943 
        iprot.skip(ftype)
25944 
      iprot.readFieldEnd()
25945 
    iprot.readStructEnd()
25946 
 
25947 
  def write(self, oprot):
25948 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25949 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25950 
      return
25951 
    oprot.writeStructBegin('getAllAttributesForOrderId_result')
25952 
    if self.success is not None:
25953 
      oprot.writeFieldBegin('success', TType.LIST, 0)
25954 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 25955 
      for iter627 in self.success:
25956 
        iter627.write(oprot)
5527 anupam.sin 25957 
      oprot.writeListEnd()
25958 
      oprot.writeFieldEnd()
25959 
    oprot.writeFieldStop()
25960 
    oprot.writeStructEnd()
25961 
 
25962 
  def validate(self):
25963 
    return
25964 
 
25965 
 
25966 
  def __repr__(self):
25967 
    L = ['%s=%r' % (key, value)
25968 
      for key, value in self.__dict__.iteritems()]
25969 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25970 
 
25971 
  def __eq__(self, other):
25972 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25973 
 
25974 
  def __ne__(self, other):
25975 
    return not (self == other)
25976 
 
5676 rajveer 25977 
class setOrderAttributes_args:
25978 
  """
25979 
  Attributes:
25980 
   - orderId
25981 
   - attributes
25982 
  """
25983 
 
25984 
  thrift_spec = None
25985 
  def __init__(self, orderId=None, attributes=None,):
25986 
    self.orderId = orderId
25987 
    self.attributes = attributes
25988 
 
25989 
  def read(self, iprot):
25990 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25991 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25992 
      return
25993 
    iprot.readStructBegin()
25994 
    while True:
25995 
      (fname, ftype, fid) = iprot.readFieldBegin()
25996 
      if ftype == TType.STOP:
25997 
        break
25998 
      if fid == 1:
25999 
        if ftype == TType.I64:
26000 
          self.orderId = iprot.readI64();
26001 
        else:
26002 
          iprot.skip(ftype)
26003 
      elif fid == -1:
26004 
        if ftype == TType.LIST:
26005 
          self.attributes = []
6188 rajveer 26006 
          (_etype631, _size628) = iprot.readListBegin()
26007 
          for _i632 in xrange(_size628):
26008 
            _elem633 = Attribute()
26009 
            _elem633.read(iprot)
26010 
            self.attributes.append(_elem633)
5676 rajveer 26011 
          iprot.readListEnd()
26012 
        else:
26013 
          iprot.skip(ftype)
26014 
      else:
26015 
        iprot.skip(ftype)
26016 
      iprot.readFieldEnd()
26017 
    iprot.readStructEnd()
26018 
 
26019 
  def write(self, oprot):
26020 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26021 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26022 
      return
26023 
    oprot.writeStructBegin('setOrderAttributes_args')
26024 
    if self.attributes is not None:
26025 
      oprot.writeFieldBegin('attributes', TType.LIST, -1)
26026 
      oprot.writeListBegin(TType.STRUCT, len(self.attributes))
6188 rajveer 26027 
      for iter634 in self.attributes:
26028 
        iter634.write(oprot)
5676 rajveer 26029 
      oprot.writeListEnd()
26030 
      oprot.writeFieldEnd()
26031 
    if self.orderId is not None:
26032 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
26033 
      oprot.writeI64(self.orderId)
26034 
      oprot.writeFieldEnd()
26035 
    oprot.writeFieldStop()
26036 
    oprot.writeStructEnd()
26037 
 
26038 
  def validate(self):
26039 
    return
26040 
 
26041 
 
26042 
  def __repr__(self):
26043 
    L = ['%s=%r' % (key, value)
26044 
      for key, value in self.__dict__.iteritems()]
26045 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26046 
 
26047 
  def __eq__(self, other):
26048 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26049 
 
26050 
  def __ne__(self, other):
26051 
    return not (self == other)
26052 
 
26053 
class setOrderAttributes_result:
26054 
 
26055 
  thrift_spec = (
26056 
  )
26057 
 
26058 
  def read(self, iprot):
26059 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26060 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26061 
      return
26062 
    iprot.readStructBegin()
26063 
    while True:
26064 
      (fname, ftype, fid) = iprot.readFieldBegin()
26065 
      if ftype == TType.STOP:
26066 
        break
26067 
      else:
26068 
        iprot.skip(ftype)
26069 
      iprot.readFieldEnd()
26070 
    iprot.readStructEnd()
26071 
 
26072 
  def write(self, oprot):
26073 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26074 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26075 
      return
26076 
    oprot.writeStructBegin('setOrderAttributes_result')
26077 
    oprot.writeFieldStop()
26078 
    oprot.writeStructEnd()
26079 
 
26080 
  def validate(self):
26081 
    return
26082 
 
26083 
 
26084 
  def __repr__(self):
26085 
    L = ['%s=%r' % (key, value)
26086 
      for key, value in self.__dict__.iteritems()]
26087 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26088 
 
26089 
  def __eq__(self, other):
26090 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26091 
 
26092 
  def __ne__(self, other):
26093 
    return not (self == other)
26094 
 
5527 anupam.sin 26095 
class setOrderAttributeForTransaction_args:
26096 
  """
26097 
  Attributes:
26098 
   - transactionId
26099 
   - attribute
26100 
  """
26101 
 
26102 
  thrift_spec = None
26103 
  def __init__(self, transactionId=None, attribute=None,):
26104 
    self.transactionId = transactionId
26105 
    self.attribute = attribute
26106 
 
26107 
  def read(self, iprot):
26108 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26109 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26110 
      return
26111 
    iprot.readStructBegin()
26112 
    while True:
26113 
      (fname, ftype, fid) = iprot.readFieldBegin()
26114 
      if ftype == TType.STOP:
26115 
        break
26116 
      if fid == 1:
26117 
        if ftype == TType.I64:
26118 
          self.transactionId = iprot.readI64();
26119 
        else:
26120 
          iprot.skip(ftype)
26121 
      elif fid == -1:
26122 
        if ftype == TType.STRUCT:
26123 
          self.attribute = Attribute()
26124 
          self.attribute.read(iprot)
26125 
        else:
26126 
          iprot.skip(ftype)
26127 
      else:
26128 
        iprot.skip(ftype)
26129 
      iprot.readFieldEnd()
26130 
    iprot.readStructEnd()
26131 
 
26132 
  def write(self, oprot):
26133 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26134 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26135 
      return
26136 
    oprot.writeStructBegin('setOrderAttributeForTransaction_args')
26137 
    if self.attribute is not None:
26138 
      oprot.writeFieldBegin('attribute', TType.STRUCT, -1)
26139 
      self.attribute.write(oprot)
26140 
      oprot.writeFieldEnd()
26141 
    if self.transactionId is not None:
26142 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
26143 
      oprot.writeI64(self.transactionId)
26144 
      oprot.writeFieldEnd()
26145 
    oprot.writeFieldStop()
26146 
    oprot.writeStructEnd()
26147 
 
26148 
  def validate(self):
26149 
    return
26150 
 
26151 
 
26152 
  def __repr__(self):
26153 
    L = ['%s=%r' % (key, value)
26154 
      for key, value in self.__dict__.iteritems()]
26155 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26156 
 
26157 
  def __eq__(self, other):
26158 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26159 
 
26160 
  def __ne__(self, other):
26161 
    return not (self == other)
26162 
 
26163 
class setOrderAttributeForTransaction_result:
26164 
 
26165 
  thrift_spec = (
26166 
  )
26167 
 
26168 
  def read(self, iprot):
26169 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26170 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26171 
      return
26172 
    iprot.readStructBegin()
26173 
    while True:
26174 
      (fname, ftype, fid) = iprot.readFieldBegin()
26175 
      if ftype == TType.STOP:
26176 
        break
26177 
      else:
26178 
        iprot.skip(ftype)
26179 
      iprot.readFieldEnd()
26180 
    iprot.readStructEnd()
26181 
 
26182 
  def write(self, oprot):
26183 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26184 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26185 
      return
26186 
    oprot.writeStructBegin('setOrderAttributeForTransaction_result')
26187 
    oprot.writeFieldStop()
26188 
    oprot.writeStructEnd()
26189 
 
26190 
  def validate(self):
26191 
    return
26192 
 
26193 
 
26194 
  def __repr__(self):
26195 
    L = ['%s=%r' % (key, value)
26196 
      for key, value in self.__dict__.iteritems()]
26197 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26198 
 
26199 
  def __eq__(self, other):
26200 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26201 
 
26202 
  def __ne__(self, other):
26203 
    return not (self == other)
5553 rajveer 26204 
 
26205 
class getReceivePendingOrders_args:
26206 
  """
26207 
  Attributes:
26208 
   - storeId
26209 
  """
26210 
 
26211 
  thrift_spec = (
26212 
    None, # 0
26213 
    (1, TType.I64, 'storeId', None, None, ), # 1
26214 
  )
26215 
 
26216 
  def __init__(self, storeId=None,):
26217 
    self.storeId = storeId
26218 
 
26219 
  def read(self, iprot):
26220 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26221 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26222 
      return
26223 
    iprot.readStructBegin()
26224 
    while True:
26225 
      (fname, ftype, fid) = iprot.readFieldBegin()
26226 
      if ftype == TType.STOP:
26227 
        break
26228 
      if fid == 1:
26229 
        if ftype == TType.I64:
26230 
          self.storeId = iprot.readI64();
26231 
        else:
26232 
          iprot.skip(ftype)
26233 
      else:
26234 
        iprot.skip(ftype)
26235 
      iprot.readFieldEnd()
26236 
    iprot.readStructEnd()
26237 
 
26238 
  def write(self, oprot):
26239 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26240 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26241 
      return
26242 
    oprot.writeStructBegin('getReceivePendingOrders_args')
26243 
    if self.storeId is not None:
26244 
      oprot.writeFieldBegin('storeId', TType.I64, 1)
26245 
      oprot.writeI64(self.storeId)
26246 
      oprot.writeFieldEnd()
26247 
    oprot.writeFieldStop()
26248 
    oprot.writeStructEnd()
26249 
 
26250 
  def validate(self):
26251 
    return
26252 
 
26253 
 
26254 
  def __repr__(self):
26255 
    L = ['%s=%r' % (key, value)
26256 
      for key, value in self.__dict__.iteritems()]
26257 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26258 
 
26259 
  def __eq__(self, other):
26260 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26261 
 
26262 
  def __ne__(self, other):
26263 
    return not (self == other)
26264 
 
26265 
class getReceivePendingOrders_result:
26266 
  """
26267 
  Attributes:
26268 
   - success
26269 
  """
26270 
 
26271 
  thrift_spec = (
26272 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
26273 
  )
26274 
 
26275 
  def __init__(self, success=None,):
26276 
    self.success = success
26277 
 
26278 
  def read(self, iprot):
26279 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26280 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26281 
      return
26282 
    iprot.readStructBegin()
26283 
    while True:
26284 
      (fname, ftype, fid) = iprot.readFieldBegin()
26285 
      if ftype == TType.STOP:
26286 
        break
26287 
      if fid == 0:
26288 
        if ftype == TType.LIST:
26289 
          self.success = []
6188 rajveer 26290 
          (_etype638, _size635) = iprot.readListBegin()
26291 
          for _i639 in xrange(_size635):
26292 
            _elem640 = Order()
26293 
            _elem640.read(iprot)
26294 
            self.success.append(_elem640)
5553 rajveer 26295 
          iprot.readListEnd()
26296 
        else:
26297 
          iprot.skip(ftype)
26298 
      else:
26299 
        iprot.skip(ftype)
26300 
      iprot.readFieldEnd()
26301 
    iprot.readStructEnd()
26302 
 
26303 
  def write(self, oprot):
26304 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26305 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26306 
      return
26307 
    oprot.writeStructBegin('getReceivePendingOrders_result')
26308 
    if self.success is not None:
26309 
      oprot.writeFieldBegin('success', TType.LIST, 0)
26310 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 26311 
      for iter641 in self.success:
26312 
        iter641.write(oprot)
5553 rajveer 26313 
      oprot.writeListEnd()
26314 
      oprot.writeFieldEnd()
26315 
    oprot.writeFieldStop()
26316 
    oprot.writeStructEnd()
26317 
 
26318 
  def validate(self):
26319 
    return
26320 
 
26321 
 
26322 
  def __repr__(self):
26323 
    L = ['%s=%r' % (key, value)
26324 
      for key, value in self.__dict__.iteritems()]
26325 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26326 
 
26327 
  def __eq__(self, other):
26328 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26329 
 
26330 
  def __ne__(self, other):
26331 
    return not (self == other)
26332 
 
26333 
class getReceivedAtStoreOrders_args:
26334 
  """
26335 
  Attributes:
26336 
   - storeId
26337 
  """
26338 
 
26339 
  thrift_spec = (
26340 
    None, # 0
26341 
    (1, TType.I64, 'storeId', None, None, ), # 1
26342 
  )
26343 
 
26344 
  def __init__(self, storeId=None,):
26345 
    self.storeId = storeId
26346 
 
26347 
  def read(self, iprot):
26348 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26349 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26350 
      return
26351 
    iprot.readStructBegin()
26352 
    while True:
26353 
      (fname, ftype, fid) = iprot.readFieldBegin()
26354 
      if ftype == TType.STOP:
26355 
        break
26356 
      if fid == 1:
26357 
        if ftype == TType.I64:
26358 
          self.storeId = iprot.readI64();
26359 
        else:
26360 
          iprot.skip(ftype)
26361 
      else:
26362 
        iprot.skip(ftype)
26363 
      iprot.readFieldEnd()
26364 
    iprot.readStructEnd()
26365 
 
26366 
  def write(self, oprot):
26367 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26368 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26369 
      return
26370 
    oprot.writeStructBegin('getReceivedAtStoreOrders_args')
26371 
    if self.storeId is not None:
26372 
      oprot.writeFieldBegin('storeId', TType.I64, 1)
26373 
      oprot.writeI64(self.storeId)
26374 
      oprot.writeFieldEnd()
26375 
    oprot.writeFieldStop()
26376 
    oprot.writeStructEnd()
26377 
 
26378 
  def validate(self):
26379 
    return
26380 
 
26381 
 
26382 
  def __repr__(self):
26383 
    L = ['%s=%r' % (key, value)
26384 
      for key, value in self.__dict__.iteritems()]
26385 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26386 
 
26387 
  def __eq__(self, other):
26388 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26389 
 
26390 
  def __ne__(self, other):
26391 
    return not (self == other)
26392 
 
26393 
class getReceivedAtStoreOrders_result:
26394 
  """
26395 
  Attributes:
26396 
   - success
26397 
  """
26398 
 
26399 
  thrift_spec = (
26400 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
26401 
  )
26402 
 
26403 
  def __init__(self, success=None,):
26404 
    self.success = success
26405 
 
26406 
  def read(self, iprot):
26407 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26408 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26409 
      return
26410 
    iprot.readStructBegin()
26411 
    while True:
26412 
      (fname, ftype, fid) = iprot.readFieldBegin()
26413 
      if ftype == TType.STOP:
26414 
        break
26415 
      if fid == 0:
26416 
        if ftype == TType.LIST:
26417 
          self.success = []
6188 rajveer 26418 
          (_etype645, _size642) = iprot.readListBegin()
26419 
          for _i646 in xrange(_size642):
26420 
            _elem647 = Order()
26421 
            _elem647.read(iprot)
26422 
            self.success.append(_elem647)
5553 rajveer 26423 
          iprot.readListEnd()
26424 
        else:
26425 
          iprot.skip(ftype)
26426 
      else:
26427 
        iprot.skip(ftype)
26428 
      iprot.readFieldEnd()
26429 
    iprot.readStructEnd()
26430 
 
26431 
  def write(self, oprot):
26432 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26433 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26434 
      return
26435 
    oprot.writeStructBegin('getReceivedAtStoreOrders_result')
26436 
    if self.success is not None:
26437 
      oprot.writeFieldBegin('success', TType.LIST, 0)
26438 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 26439 
      for iter648 in self.success:
26440 
        iter648.write(oprot)
5553 rajveer 26441 
      oprot.writeListEnd()
26442 
      oprot.writeFieldEnd()
26443 
    oprot.writeFieldStop()
26444 
    oprot.writeStructEnd()
26445 
 
26446 
  def validate(self):
26447 
    return
26448 
 
26449 
 
26450 
  def __repr__(self):
26451 
    L = ['%s=%r' % (key, value)
26452 
      for key, value in self.__dict__.iteritems()]
26453 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26454 
 
26455 
  def __eq__(self, other):
26456 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26457 
 
26458 
  def __ne__(self, other):
26459 
    return not (self == other)
5593 mandeep.dh 26460 
 
5713 rajveer 26461 
class getOrdersCollectionAtStore_args:
26462 
  """
26463 
  Attributes:
26464 
   - storeId
26465 
   - fromDate
26466 
   - toDate
26467 
   - onlyCod
26468 
  """
26469 
 
26470 
  thrift_spec = (
26471 
    None, # 0
26472 
    (1, TType.I64, 'storeId', None, None, ), # 1
26473 
    (2, TType.I64, 'fromDate', None, None, ), # 2
26474 
    (3, TType.I64, 'toDate', None, None, ), # 3
26475 
    (4, TType.BOOL, 'onlyCod', None, None, ), # 4
26476 
  )
26477 
 
26478 
  def __init__(self, storeId=None, fromDate=None, toDate=None, onlyCod=None,):
26479 
    self.storeId = storeId
26480 
    self.fromDate = fromDate
26481 
    self.toDate = toDate
26482 
    self.onlyCod = onlyCod
26483 
 
26484 
  def read(self, iprot):
26485 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26486 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26487 
      return
26488 
    iprot.readStructBegin()
26489 
    while True:
26490 
      (fname, ftype, fid) = iprot.readFieldBegin()
26491 
      if ftype == TType.STOP:
26492 
        break
26493 
      if fid == 1:
26494 
        if ftype == TType.I64:
26495 
          self.storeId = iprot.readI64();
26496 
        else:
26497 
          iprot.skip(ftype)
26498 
      elif fid == 2:
26499 
        if ftype == TType.I64:
26500 
          self.fromDate = iprot.readI64();
26501 
        else:
26502 
          iprot.skip(ftype)
26503 
      elif fid == 3:
26504 
        if ftype == TType.I64:
26505 
          self.toDate = iprot.readI64();
26506 
        else:
26507 
          iprot.skip(ftype)
26508 
      elif fid == 4:
26509 
        if ftype == TType.BOOL:
26510 
          self.onlyCod = iprot.readBool();
26511 
        else:
26512 
          iprot.skip(ftype)
26513 
      else:
26514 
        iprot.skip(ftype)
26515 
      iprot.readFieldEnd()
26516 
    iprot.readStructEnd()
26517 
 
26518 
  def write(self, oprot):
26519 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26520 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26521 
      return
26522 
    oprot.writeStructBegin('getOrdersCollectionAtStore_args')
26523 
    if self.storeId is not None:
26524 
      oprot.writeFieldBegin('storeId', TType.I64, 1)
26525 
      oprot.writeI64(self.storeId)
26526 
      oprot.writeFieldEnd()
26527 
    if self.fromDate is not None:
26528 
      oprot.writeFieldBegin('fromDate', TType.I64, 2)
26529 
      oprot.writeI64(self.fromDate)
26530 
      oprot.writeFieldEnd()
26531 
    if self.toDate is not None:
26532 
      oprot.writeFieldBegin('toDate', TType.I64, 3)
26533 
      oprot.writeI64(self.toDate)
26534 
      oprot.writeFieldEnd()
26535 
    if self.onlyCod is not None:
26536 
      oprot.writeFieldBegin('onlyCod', TType.BOOL, 4)
26537 
      oprot.writeBool(self.onlyCod)
26538 
      oprot.writeFieldEnd()
26539 
    oprot.writeFieldStop()
26540 
    oprot.writeStructEnd()
26541 
 
26542 
  def validate(self):
26543 
    return
26544 
 
26545 
 
26546 
  def __repr__(self):
26547 
    L = ['%s=%r' % (key, value)
26548 
      for key, value in self.__dict__.iteritems()]
26549 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26550 
 
26551 
  def __eq__(self, other):
26552 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26553 
 
26554 
  def __ne__(self, other):
26555 
    return not (self == other)
26556 
 
26557 
class getOrdersCollectionAtStore_result:
26558 
  """
26559 
  Attributes:
26560 
   - success
26561 
  """
26562 
 
26563 
  thrift_spec = (
26564 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
26565 
  )
26566 
 
26567 
  def __init__(self, success=None,):
26568 
    self.success = success
26569 
 
26570 
  def read(self, iprot):
26571 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26572 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26573 
      return
26574 
    iprot.readStructBegin()
26575 
    while True:
26576 
      (fname, ftype, fid) = iprot.readFieldBegin()
26577 
      if ftype == TType.STOP:
26578 
        break
26579 
      if fid == 0:
26580 
        if ftype == TType.LIST:
26581 
          self.success = []
6188 rajveer 26582 
          (_etype652, _size649) = iprot.readListBegin()
26583 
          for _i653 in xrange(_size649):
26584 
            _elem654 = Order()
26585 
            _elem654.read(iprot)
26586 
            self.success.append(_elem654)
5713 rajveer 26587 
          iprot.readListEnd()
26588 
        else:
26589 
          iprot.skip(ftype)
26590 
      else:
26591 
        iprot.skip(ftype)
26592 
      iprot.readFieldEnd()
26593 
    iprot.readStructEnd()
26594 
 
26595 
  def write(self, oprot):
26596 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26597 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26598 
      return
26599 
    oprot.writeStructBegin('getOrdersCollectionAtStore_result')
26600 
    if self.success is not None:
26601 
      oprot.writeFieldBegin('success', TType.LIST, 0)
26602 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 26603 
      for iter655 in self.success:
26604 
        iter655.write(oprot)
5713 rajveer 26605 
      oprot.writeListEnd()
26606 
      oprot.writeFieldEnd()
26607 
    oprot.writeFieldStop()
26608 
    oprot.writeStructEnd()
26609 
 
26610 
  def validate(self):
26611 
    return
26612 
 
26613 
 
26614 
  def __repr__(self):
26615 
    L = ['%s=%r' % (key, value)
26616 
      for key, value in self.__dict__.iteritems()]
26617 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26618 
 
26619 
  def __eq__(self, other):
26620 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26621 
 
26622 
  def __ne__(self, other):
26623 
    return not (self == other)
26624 
 
5833 rajveer 26625 
class getOrderAttributeValue_args:
26626 
  """
26627 
  Attributes:
26628 
   - orderId
26629 
   - attributeName
26630 
  """
26631 
 
26632 
  thrift_spec = None
26633 
  def __init__(self, orderId=None, attributeName=None,):
26634 
    self.orderId = orderId
26635 
    self.attributeName = attributeName
26636 
 
26637 
  def read(self, iprot):
26638 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26639 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26640 
      return
26641 
    iprot.readStructBegin()
26642 
    while True:
26643 
      (fname, ftype, fid) = iprot.readFieldBegin()
26644 
      if ftype == TType.STOP:
26645 
        break
26646 
      if fid == 1:
26647 
        if ftype == TType.I64:
26648 
          self.orderId = iprot.readI64();
26649 
        else:
26650 
          iprot.skip(ftype)
26651 
      elif fid == -1:
26652 
        if ftype == TType.STRING:
26653 
          self.attributeName = iprot.readString();
26654 
        else:
26655 
          iprot.skip(ftype)
26656 
      else:
26657 
        iprot.skip(ftype)
26658 
      iprot.readFieldEnd()
26659 
    iprot.readStructEnd()
26660 
 
26661 
  def write(self, oprot):
26662 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26663 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26664 
      return
26665 
    oprot.writeStructBegin('getOrderAttributeValue_args')
26666 
    if self.attributeName is not None:
26667 
      oprot.writeFieldBegin('attributeName', TType.STRING, -1)
26668 
      oprot.writeString(self.attributeName)
26669 
      oprot.writeFieldEnd()
26670 
    if self.orderId is not None:
26671 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
26672 
      oprot.writeI64(self.orderId)
26673 
      oprot.writeFieldEnd()
26674 
    oprot.writeFieldStop()
26675 
    oprot.writeStructEnd()
26676 
 
26677 
  def validate(self):
26678 
    return
26679 
 
26680 
 
26681 
  def __repr__(self):
26682 
    L = ['%s=%r' % (key, value)
26683 
      for key, value in self.__dict__.iteritems()]
26684 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26685 
 
26686 
  def __eq__(self, other):
26687 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26688 
 
26689 
  def __ne__(self, other):
26690 
    return not (self == other)
26691 
 
26692 
class getOrderAttributeValue_result:
26693 
  """
26694 
  Attributes:
26695 
   - success
26696 
  """
26697 
 
26698 
  thrift_spec = (
26699 
    (0, TType.STRING, 'success', None, None, ), # 0
26700 
  )
26701 
 
26702 
  def __init__(self, success=None,):
26703 
    self.success = success
26704 
 
26705 
  def read(self, iprot):
26706 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26707 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26708 
      return
26709 
    iprot.readStructBegin()
26710 
    while True:
26711 
      (fname, ftype, fid) = iprot.readFieldBegin()
26712 
      if ftype == TType.STOP:
26713 
        break
26714 
      if fid == 0:
26715 
        if ftype == TType.STRING:
26716 
          self.success = iprot.readString();
26717 
        else:
26718 
          iprot.skip(ftype)
26719 
      else:
26720 
        iprot.skip(ftype)
26721 
      iprot.readFieldEnd()
26722 
    iprot.readStructEnd()
26723 
 
26724 
  def write(self, oprot):
26725 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26726 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26727 
      return
26728 
    oprot.writeStructBegin('getOrderAttributeValue_result')
26729 
    if self.success is not None:
26730 
      oprot.writeFieldBegin('success', TType.STRING, 0)
26731 
      oprot.writeString(self.success)
26732 
      oprot.writeFieldEnd()
26733 
    oprot.writeFieldStop()
26734 
    oprot.writeStructEnd()
26735 
 
26736 
  def validate(self):
26737 
    return
26738 
 
26739 
 
26740 
  def __repr__(self):
26741 
    L = ['%s=%r' % (key, value)
26742 
      for key, value in self.__dict__.iteritems()]
26743 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26744 
 
26745 
  def __eq__(self, other):
26746 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26747 
 
26748 
  def __ne__(self, other):
26749 
    return not (self == other)
26750 
 
6019 rajveer 26751 
class changeJacketNumber_args:
26752 
  """
26753 
  Attributes:
26754 
   - orderId
26755 
   - jacketNumber
26756 
  """
26757 
 
26758 
  thrift_spec = (
26759 
    None, # 0
26760 
    (1, TType.I64, 'orderId', None, None, ), # 1
26761 
    (2, TType.I64, 'jacketNumber', None, None, ), # 2
26762 
  )
26763 
 
26764 
  def __init__(self, orderId=None, jacketNumber=None,):
26765 
    self.orderId = orderId
26766 
    self.jacketNumber = jacketNumber
26767 
 
26768 
  def read(self, iprot):
26769 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26770 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26771 
      return
26772 
    iprot.readStructBegin()
26773 
    while True:
26774 
      (fname, ftype, fid) = iprot.readFieldBegin()
26775 
      if ftype == TType.STOP:
26776 
        break
26777 
      if fid == 1:
26778 
        if ftype == TType.I64:
26779 
          self.orderId = iprot.readI64();
26780 
        else:
26781 
          iprot.skip(ftype)
26782 
      elif fid == 2:
26783 
        if ftype == TType.I64:
26784 
          self.jacketNumber = iprot.readI64();
26785 
        else:
26786 
          iprot.skip(ftype)
26787 
      else:
26788 
        iprot.skip(ftype)
26789 
      iprot.readFieldEnd()
26790 
    iprot.readStructEnd()
26791 
 
26792 
  def write(self, oprot):
26793 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26794 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26795 
      return
26796 
    oprot.writeStructBegin('changeJacketNumber_args')
26797 
    if self.orderId is not None:
26798 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
26799 
      oprot.writeI64(self.orderId)
26800 
      oprot.writeFieldEnd()
26801 
    if self.jacketNumber is not None:
26802 
      oprot.writeFieldBegin('jacketNumber', TType.I64, 2)
26803 
      oprot.writeI64(self.jacketNumber)
26804 
      oprot.writeFieldEnd()
26805 
    oprot.writeFieldStop()
26806 
    oprot.writeStructEnd()
26807 
 
26808 
  def validate(self):
26809 
    return
26810 
 
26811 
 
26812 
  def __repr__(self):
26813 
    L = ['%s=%r' % (key, value)
26814 
      for key, value in self.__dict__.iteritems()]
26815 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26816 
 
26817 
  def __eq__(self, other):
26818 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26819 
 
26820 
  def __ne__(self, other):
26821 
    return not (self == other)
26822 
 
26823 
class changeJacketNumber_result:
26824 
  """
26825 
  Attributes:
26826 
   - success
26827 
  """
26828 
 
26829 
  thrift_spec = (
26830 
    (0, TType.BOOL, 'success', None, None, ), # 0
26831 
  )
26832 
 
26833 
  def __init__(self, success=None,):
26834 
    self.success = success
26835 
 
26836 
  def read(self, iprot):
26837 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26838 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26839 
      return
26840 
    iprot.readStructBegin()
26841 
    while True:
26842 
      (fname, ftype, fid) = iprot.readFieldBegin()
26843 
      if ftype == TType.STOP:
26844 
        break
26845 
      if fid == 0:
26846 
        if ftype == TType.BOOL:
26847 
          self.success = iprot.readBool();
26848 
        else:
26849 
          iprot.skip(ftype)
26850 
      else:
26851 
        iprot.skip(ftype)
26852 
      iprot.readFieldEnd()
26853 
    iprot.readStructEnd()
26854 
 
26855 
  def write(self, oprot):
26856 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26857 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26858 
      return
26859 
    oprot.writeStructBegin('changeJacketNumber_result')
26860 
    if self.success is not None:
26861 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
26862 
      oprot.writeBool(self.success)
26863 
      oprot.writeFieldEnd()
26864 
    oprot.writeFieldStop()
26865 
    oprot.writeStructEnd()
26866 
 
26867 
  def validate(self):
26868 
    return
26869 
 
26870 
 
26871 
  def __repr__(self):
26872 
    L = ['%s=%r' % (key, value)
26873 
      for key, value in self.__dict__.iteritems()]
26874 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26875 
 
26876 
  def __eq__(self, other):
26877 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26878 
 
26879 
  def __ne__(self, other):
26880 
    return not (self == other)
26881 
 
26882 
class markOrderAsRtoInTransit_args:
26883 
  """
26884 
  Attributes:
26885 
   - orderId
26886 
  """
26887 
 
26888 
  thrift_spec = (
26889 
    None, # 0
26890 
    (1, TType.I64, 'orderId', None, None, ), # 1
26891 
  )
26892 
 
26893 
  def __init__(self, orderId=None,):
26894 
    self.orderId = orderId
26895 
 
26896 
  def read(self, iprot):
26897 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26898 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26899 
      return
26900 
    iprot.readStructBegin()
26901 
    while True:
26902 
      (fname, ftype, fid) = iprot.readFieldBegin()
26903 
      if ftype == TType.STOP:
26904 
        break
26905 
      if fid == 1:
26906 
        if ftype == TType.I64:
26907 
          self.orderId = iprot.readI64();
26908 
        else:
26909 
          iprot.skip(ftype)
26910 
      else:
26911 
        iprot.skip(ftype)
26912 
      iprot.readFieldEnd()
26913 
    iprot.readStructEnd()
26914 
 
26915 
  def write(self, oprot):
26916 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26917 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26918 
      return
26919 
    oprot.writeStructBegin('markOrderAsRtoInTransit_args')
26920 
    if self.orderId is not None:
26921 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
26922 
      oprot.writeI64(self.orderId)
26923 
      oprot.writeFieldEnd()
26924 
    oprot.writeFieldStop()
26925 
    oprot.writeStructEnd()
26926 
 
26927 
  def validate(self):
26928 
    return
26929 
 
26930 
 
26931 
  def __repr__(self):
26932 
    L = ['%s=%r' % (key, value)
26933 
      for key, value in self.__dict__.iteritems()]
26934 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26935 
 
26936 
  def __eq__(self, other):
26937 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26938 
 
26939 
  def __ne__(self, other):
26940 
    return not (self == other)
26941 
 
26942 
class markOrderAsRtoInTransit_result:
26943 
  """
26944 
  Attributes:
26945 
   - success
26946 
  """
26947 
 
26948 
  thrift_spec = (
26949 
    (0, TType.BOOL, 'success', None, None, ), # 0
26950 
  )
26951 
 
26952 
  def __init__(self, success=None,):
26953 
    self.success = success
26954 
 
26955 
  def read(self, iprot):
26956 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26957 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26958 
      return
26959 
    iprot.readStructBegin()
26960 
    while True:
26961 
      (fname, ftype, fid) = iprot.readFieldBegin()
26962 
      if ftype == TType.STOP:
26963 
        break
26964 
      if fid == 0:
26965 
        if ftype == TType.BOOL:
26966 
          self.success = iprot.readBool();
26967 
        else:
26968 
          iprot.skip(ftype)
26969 
      else:
26970 
        iprot.skip(ftype)
26971 
      iprot.readFieldEnd()
26972 
    iprot.readStructEnd()
26973 
 
26974 
  def write(self, oprot):
26975 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26976 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26977 
      return
26978 
    oprot.writeStructBegin('markOrderAsRtoInTransit_result')
26979 
    if self.success is not None:
26980 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
26981 
      oprot.writeBool(self.success)
26982 
      oprot.writeFieldEnd()
26983 
    oprot.writeFieldStop()
26984 
    oprot.writeStructEnd()
26985 
 
26986 
  def validate(self):
26987 
    return
26988 
 
26989 
 
26990 
  def __repr__(self):
26991 
    L = ['%s=%r' % (key, value)
26992 
      for key, value in self.__dict__.iteritems()]
26993 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26994 
 
26995 
  def __eq__(self, other):
26996 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26997 
 
26998 
  def __ne__(self, other):
26999 
    return not (self == other)
27000 
 
5593 mandeep.dh 27001 
class acceptOrderForItem_args:
27002 
  """
27003 
  Attributes:
27004 
   - itemId
27005 
   - quantity
27006 
   - fulfilmentWarehouseId
27007 
   - billingWarehouseId
27008 
  """
27009 
 
27010 
  thrift_spec = (
27011 
    None, # 0
27012 
    (1, TType.I64, 'itemId', None, None, ), # 1
27013 
    (2, TType.I64, 'quantity', None, None, ), # 2
27014 
    (3, TType.I64, 'fulfilmentWarehouseId', None, None, ), # 3
27015 
    (4, TType.I64, 'billingWarehouseId', None, None, ), # 4
27016 
  )
27017 
 
27018 
  def __init__(self, itemId=None, quantity=None, fulfilmentWarehouseId=None, billingWarehouseId=None,):
27019 
    self.itemId = itemId
27020 
    self.quantity = quantity
27021 
    self.fulfilmentWarehouseId = fulfilmentWarehouseId
27022 
    self.billingWarehouseId = billingWarehouseId
27023 
 
27024 
  def read(self, iprot):
27025 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27026 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27027 
      return
27028 
    iprot.readStructBegin()
27029 
    while True:
27030 
      (fname, ftype, fid) = iprot.readFieldBegin()
27031 
      if ftype == TType.STOP:
27032 
        break
27033 
      if fid == 1:
27034 
        if ftype == TType.I64:
27035 
          self.itemId = iprot.readI64();
27036 
        else:
27037 
          iprot.skip(ftype)
27038 
      elif fid == 2:
27039 
        if ftype == TType.I64:
27040 
          self.quantity = iprot.readI64();
27041 
        else:
27042 
          iprot.skip(ftype)
27043 
      elif fid == 3:
27044 
        if ftype == TType.I64:
27045 
          self.fulfilmentWarehouseId = iprot.readI64();
27046 
        else:
27047 
          iprot.skip(ftype)
27048 
      elif fid == 4:
27049 
        if ftype == TType.I64:
27050 
          self.billingWarehouseId = iprot.readI64();
27051 
        else:
27052 
          iprot.skip(ftype)
27053 
      else:
27054 
        iprot.skip(ftype)
27055 
      iprot.readFieldEnd()
27056 
    iprot.readStructEnd()
27057 
 
27058 
  def write(self, oprot):
27059 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27060 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27061 
      return
27062 
    oprot.writeStructBegin('acceptOrderForItem_args')
27063 
    if self.itemId is not None:
27064 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
27065 
      oprot.writeI64(self.itemId)
27066 
      oprot.writeFieldEnd()
27067 
    if self.quantity is not None:
27068 
      oprot.writeFieldBegin('quantity', TType.I64, 2)
27069 
      oprot.writeI64(self.quantity)
27070 
      oprot.writeFieldEnd()
27071 
    if self.fulfilmentWarehouseId is not None:
27072 
      oprot.writeFieldBegin('fulfilmentWarehouseId', TType.I64, 3)
27073 
      oprot.writeI64(self.fulfilmentWarehouseId)
27074 
      oprot.writeFieldEnd()
27075 
    if self.billingWarehouseId is not None:
27076 
      oprot.writeFieldBegin('billingWarehouseId', TType.I64, 4)
27077 
      oprot.writeI64(self.billingWarehouseId)
27078 
      oprot.writeFieldEnd()
27079 
    oprot.writeFieldStop()
27080 
    oprot.writeStructEnd()
27081 
 
27082 
  def validate(self):
27083 
    return
27084 
 
27085 
 
27086 
  def __repr__(self):
27087 
    L = ['%s=%r' % (key, value)
27088 
      for key, value in self.__dict__.iteritems()]
27089 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27090 
 
27091 
  def __eq__(self, other):
27092 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27093 
 
27094 
  def __ne__(self, other):
27095 
    return not (self == other)
27096 
 
27097 
class acceptOrderForItem_result:
27098 
 
27099 
  thrift_spec = (
27100 
  )
27101 
 
27102 
  def read(self, iprot):
27103 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27104 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27105 
      return
27106 
    iprot.readStructBegin()
27107 
    while True:
27108 
      (fname, ftype, fid) = iprot.readFieldBegin()
27109 
      if ftype == TType.STOP:
27110 
        break
27111 
      else:
27112 
        iprot.skip(ftype)
27113 
      iprot.readFieldEnd()
27114 
    iprot.readStructEnd()
27115 
 
27116 
  def write(self, oprot):
27117 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27118 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27119 
      return
27120 
    oprot.writeStructBegin('acceptOrderForItem_result')
27121 
    oprot.writeFieldStop()
27122 
    oprot.writeStructEnd()
27123 
 
27124 
  def validate(self):
27125 
    return
27126 
 
27127 
 
27128 
  def __repr__(self):
27129 
    L = ['%s=%r' % (key, value)
27130 
      for key, value in self.__dict__.iteritems()]
27131 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27132 
 
27133 
  def __eq__(self, other):
27134 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27135 
 
27136 
  def __ne__(self, other):
27137 
    return not (self == other)
6000 mandeep.dh 27138 
 
27139 
class createRechargeOrder_args:
27140 
  """
27141 
  Attributes:
27142 
   - rechargeOrder
27143 
  """
27144 
 
27145 
  thrift_spec = (
27146 
    None, # 0
27147 
    (1, TType.STRUCT, 'rechargeOrder', (RechargeOrder, RechargeOrder.thrift_spec), None, ), # 1
27148 
  )
27149 
 
27150 
  def __init__(self, rechargeOrder=None,):
27151 
    self.rechargeOrder = rechargeOrder
27152 
 
27153 
  def read(self, iprot):
27154 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27155 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27156 
      return
27157 
    iprot.readStructBegin()
27158 
    while True:
27159 
      (fname, ftype, fid) = iprot.readFieldBegin()
27160 
      if ftype == TType.STOP:
27161 
        break
27162 
      if fid == 1:
27163 
        if ftype == TType.STRUCT:
27164 
          self.rechargeOrder = RechargeOrder()
27165 
          self.rechargeOrder.read(iprot)
27166 
        else:
27167 
          iprot.skip(ftype)
27168 
      else:
27169 
        iprot.skip(ftype)
27170 
      iprot.readFieldEnd()
27171 
    iprot.readStructEnd()
27172 
 
27173 
  def write(self, oprot):
27174 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27175 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27176 
      return
27177 
    oprot.writeStructBegin('createRechargeOrder_args')
27178 
    if self.rechargeOrder is not None:
27179 
      oprot.writeFieldBegin('rechargeOrder', TType.STRUCT, 1)
27180 
      self.rechargeOrder.write(oprot)
27181 
      oprot.writeFieldEnd()
27182 
    oprot.writeFieldStop()
27183 
    oprot.writeStructEnd()
27184 
 
27185 
  def validate(self):
27186 
    return
27187 
 
27188 
 
27189 
  def __repr__(self):
27190 
    L = ['%s=%r' % (key, value)
27191 
      for key, value in self.__dict__.iteritems()]
27192 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27193 
 
27194 
  def __eq__(self, other):
27195 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27196 
 
27197 
  def __ne__(self, other):
27198 
    return not (self == other)
27199 
 
27200 
class createRechargeOrder_result:
27201 
  """
27202 
  Attributes:
27203 
   - success
27204 
   - ex
27205 
  """
27206 
 
27207 
  thrift_spec = (
27208 
    (0, TType.STRUCT, 'success', (RechargeOrder, RechargeOrder.thrift_spec), None, ), # 0
27209 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
27210 
  )
27211 
 
27212 
  def __init__(self, success=None, ex=None,):
27213 
    self.success = success
27214 
    self.ex = ex
27215 
 
27216 
  def read(self, iprot):
27217 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27218 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27219 
      return
27220 
    iprot.readStructBegin()
27221 
    while True:
27222 
      (fname, ftype, fid) = iprot.readFieldBegin()
27223 
      if ftype == TType.STOP:
27224 
        break
27225 
      if fid == 0:
27226 
        if ftype == TType.STRUCT:
27227 
          self.success = RechargeOrder()
27228 
          self.success.read(iprot)
27229 
        else:
27230 
          iprot.skip(ftype)
27231 
      elif fid == 1:
27232 
        if ftype == TType.STRUCT:
27233 
          self.ex = TransactionServiceException()
27234 
          self.ex.read(iprot)
27235 
        else:
27236 
          iprot.skip(ftype)
27237 
      else:
27238 
        iprot.skip(ftype)
27239 
      iprot.readFieldEnd()
27240 
    iprot.readStructEnd()
27241 
 
27242 
  def write(self, oprot):
27243 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27244 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27245 
      return
27246 
    oprot.writeStructBegin('createRechargeOrder_result')
27247 
    if self.success is not None:
27248 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
27249 
      self.success.write(oprot)
27250 
      oprot.writeFieldEnd()
27251 
    if self.ex is not None:
27252 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
27253 
      self.ex.write(oprot)
27254 
      oprot.writeFieldEnd()
27255 
    oprot.writeFieldStop()
27256 
    oprot.writeStructEnd()
27257 
 
27258 
  def validate(self):
27259 
    return
27260 
 
27261 
 
27262 
  def __repr__(self):
27263 
    L = ['%s=%r' % (key, value)
27264 
      for key, value in self.__dict__.iteritems()]
27265 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27266 
 
27267 
  def __eq__(self, other):
27268 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27269 
 
27270 
  def __ne__(self, other):
27271 
    return not (self == other)
27272 
 
6031 rajveer 27273 
class getRechargeOrder_args:
27274 
  """
27275 
  Attributes:
27276 
   - rechargeRrderId
27277 
  """
27278 
 
27279 
  thrift_spec = (
27280 
    None, # 0
27281 
    (1, TType.I64, 'rechargeRrderId', None, None, ), # 1
27282 
  )
27283 
 
27284 
  def __init__(self, rechargeRrderId=None,):
27285 
    self.rechargeRrderId = rechargeRrderId
27286 
 
27287 
  def read(self, iprot):
27288 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27289 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27290 
      return
27291 
    iprot.readStructBegin()
27292 
    while True:
27293 
      (fname, ftype, fid) = iprot.readFieldBegin()
27294 
      if ftype == TType.STOP:
27295 
        break
27296 
      if fid == 1:
27297 
        if ftype == TType.I64:
27298 
          self.rechargeRrderId = iprot.readI64();
27299 
        else:
27300 
          iprot.skip(ftype)
27301 
      else:
27302 
        iprot.skip(ftype)
27303 
      iprot.readFieldEnd()
27304 
    iprot.readStructEnd()
27305 
 
27306 
  def write(self, oprot):
27307 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27308 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27309 
      return
27310 
    oprot.writeStructBegin('getRechargeOrder_args')
27311 
    if self.rechargeRrderId is not None:
27312 
      oprot.writeFieldBegin('rechargeRrderId', TType.I64, 1)
27313 
      oprot.writeI64(self.rechargeRrderId)
27314 
      oprot.writeFieldEnd()
27315 
    oprot.writeFieldStop()
27316 
    oprot.writeStructEnd()
27317 
 
27318 
  def validate(self):
27319 
    return
27320 
 
27321 
 
27322 
  def __repr__(self):
27323 
    L = ['%s=%r' % (key, value)
27324 
      for key, value in self.__dict__.iteritems()]
27325 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27326 
 
27327 
  def __eq__(self, other):
27328 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27329 
 
27330 
  def __ne__(self, other):
27331 
    return not (self == other)
27332 
 
27333 
class getRechargeOrder_result:
27334 
  """
27335 
  Attributes:
27336 
   - success
27337 
   - ex
27338 
  """
27339 
 
27340 
  thrift_spec = (
27341 
    (0, TType.STRUCT, 'success', (RechargeOrder, RechargeOrder.thrift_spec), None, ), # 0
27342 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
27343 
  )
27344 
 
27345 
  def __init__(self, success=None, ex=None,):
27346 
    self.success = success
27347 
    self.ex = ex
27348 
 
27349 
  def read(self, iprot):
27350 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27351 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27352 
      return
27353 
    iprot.readStructBegin()
27354 
    while True:
27355 
      (fname, ftype, fid) = iprot.readFieldBegin()
27356 
      if ftype == TType.STOP:
27357 
        break
27358 
      if fid == 0:
27359 
        if ftype == TType.STRUCT:
27360 
          self.success = RechargeOrder()
27361 
          self.success.read(iprot)
27362 
        else:
27363 
          iprot.skip(ftype)
27364 
      elif fid == 1:
27365 
        if ftype == TType.STRUCT:
27366 
          self.ex = TransactionServiceException()
27367 
          self.ex.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('getRechargeOrder_result')
27380 
    if self.success is not None:
27381 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
27382 
      self.success.write(oprot)
27383 
      oprot.writeFieldEnd()
27384 
    if self.ex is not None:
27385 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
27386 
      self.ex.write(oprot)
27387 
      oprot.writeFieldEnd()
27388 
    oprot.writeFieldStop()
27389 
    oprot.writeStructEnd()
27390 
 
27391 
  def validate(self):
27392 
    return
27393 
 
27394 
 
27395 
  def __repr__(self):
27396 
    L = ['%s=%r' % (key, value)
27397 
      for key, value in self.__dict__.iteritems()]
27398 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27399 
 
27400 
  def __eq__(self, other):
27401 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27402 
 
27403 
  def __ne__(self, other):
27404 
    return not (self == other)
27405 
 
27406 
class getRechargeOrders_args:
27407 
  """
27408 
  Attributes:
27409 
   - userId
27410 
  """
27411 
 
27412 
  thrift_spec = (
27413 
    None, # 0
27414 
    (1, TType.I64, 'userId', None, None, ), # 1
27415 
  )
27416 
 
27417 
  def __init__(self, userId=None,):
27418 
    self.userId = userId
27419 
 
27420 
  def read(self, iprot):
27421 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27422 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27423 
      return
27424 
    iprot.readStructBegin()
27425 
    while True:
27426 
      (fname, ftype, fid) = iprot.readFieldBegin()
27427 
      if ftype == TType.STOP:
27428 
        break
27429 
      if fid == 1:
27430 
        if ftype == TType.I64:
27431 
          self.userId = iprot.readI64();
27432 
        else:
27433 
          iprot.skip(ftype)
27434 
      else:
27435 
        iprot.skip(ftype)
27436 
      iprot.readFieldEnd()
27437 
    iprot.readStructEnd()
27438 
 
27439 
  def write(self, oprot):
27440 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27441 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27442 
      return
27443 
    oprot.writeStructBegin('getRechargeOrders_args')
27444 
    if self.userId is not None:
27445 
      oprot.writeFieldBegin('userId', TType.I64, 1)
27446 
      oprot.writeI64(self.userId)
27447 
      oprot.writeFieldEnd()
27448 
    oprot.writeFieldStop()
27449 
    oprot.writeStructEnd()
27450 
 
27451 
  def validate(self):
27452 
    return
27453 
 
27454 
 
27455 
  def __repr__(self):
27456 
    L = ['%s=%r' % (key, value)
27457 
      for key, value in self.__dict__.iteritems()]
27458 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27459 
 
27460 
  def __eq__(self, other):
27461 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27462 
 
27463 
  def __ne__(self, other):
27464 
    return not (self == other)
27465 
 
27466 
class getRechargeOrders_result:
27467 
  """
27468 
  Attributes:
27469 
   - success
27470 
  """
27471 
 
27472 
  thrift_spec = (
27473 
    (0, TType.LIST, 'success', (TType.STRUCT,(RechargeOrder, RechargeOrder.thrift_spec)), None, ), # 0
27474 
  )
27475 
 
27476 
  def __init__(self, success=None,):
27477 
    self.success = success
27478 
 
27479 
  def read(self, iprot):
27480 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27481 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27482 
      return
27483 
    iprot.readStructBegin()
27484 
    while True:
27485 
      (fname, ftype, fid) = iprot.readFieldBegin()
27486 
      if ftype == TType.STOP:
27487 
        break
27488 
      if fid == 0:
27489 
        if ftype == TType.LIST:
27490 
          self.success = []
6188 rajveer 27491 
          (_etype659, _size656) = iprot.readListBegin()
27492 
          for _i660 in xrange(_size656):
27493 
            _elem661 = RechargeOrder()
27494 
            _elem661.read(iprot)
27495 
            self.success.append(_elem661)
6031 rajveer 27496 
          iprot.readListEnd()
27497 
        else:
27498 
          iprot.skip(ftype)
27499 
      else:
27500 
        iprot.skip(ftype)
27501 
      iprot.readFieldEnd()
27502 
    iprot.readStructEnd()
27503 
 
27504 
  def write(self, oprot):
27505 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27506 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27507 
      return
27508 
    oprot.writeStructBegin('getRechargeOrders_result')
27509 
    if self.success is not None:
27510 
      oprot.writeFieldBegin('success', TType.LIST, 0)
27511 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 27512 
      for iter662 in self.success:
27513 
        iter662.write(oprot)
6031 rajveer 27514 
      oprot.writeListEnd()
27515 
      oprot.writeFieldEnd()
27516 
    oprot.writeFieldStop()
27517 
    oprot.writeStructEnd()
27518 
 
27519 
  def validate(self):
27520 
    return
27521 
 
27522 
 
27523 
  def __repr__(self):
27524 
    L = ['%s=%r' % (key, value)
27525 
      for key, value in self.__dict__.iteritems()]
27526 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27527 
 
27528 
  def __eq__(self, other):
27529 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27530 
 
27531 
  def __ne__(self, other):
27532 
    return not (self == other)
27533 
 
6000 mandeep.dh 27534 
class updateRechargeOrderStatus_args:
27535 
  """
27536 
  Attributes:
27537 
   - rechargeOrderId
27538 
   - rechargeOrderStatus
27539 
  """
27540 
 
27541 
  thrift_spec = (
27542 
    None, # 0
27543 
    (1, TType.I64, 'rechargeOrderId', None, None, ), # 1
27544 
    (2, TType.I32, 'rechargeOrderStatus', None, None, ), # 2
27545 
  )
27546 
 
27547 
  def __init__(self, rechargeOrderId=None, rechargeOrderStatus=None,):
27548 
    self.rechargeOrderId = rechargeOrderId
27549 
    self.rechargeOrderStatus = rechargeOrderStatus
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 == 1:
27561 
        if ftype == TType.I64:
27562 
          self.rechargeOrderId = iprot.readI64();
27563 
        else:
27564 
          iprot.skip(ftype)
27565 
      elif fid == 2:
27566 
        if ftype == TType.I32:
27567 
          self.rechargeOrderStatus = iprot.readI32();
27568 
        else:
27569 
          iprot.skip(ftype)
27570 
      else:
27571 
        iprot.skip(ftype)
27572 
      iprot.readFieldEnd()
27573 
    iprot.readStructEnd()
27574 
 
27575 
  def write(self, oprot):
27576 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27577 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27578 
      return
27579 
    oprot.writeStructBegin('updateRechargeOrderStatus_args')
27580 
    if self.rechargeOrderId is not None:
27581 
      oprot.writeFieldBegin('rechargeOrderId', TType.I64, 1)
27582 
      oprot.writeI64(self.rechargeOrderId)
27583 
      oprot.writeFieldEnd()
27584 
    if self.rechargeOrderStatus is not None:
27585 
      oprot.writeFieldBegin('rechargeOrderStatus', TType.I32, 2)
27586 
      oprot.writeI32(self.rechargeOrderStatus)
27587 
      oprot.writeFieldEnd()
27588 
    oprot.writeFieldStop()
27589 
    oprot.writeStructEnd()
27590 
 
27591 
  def validate(self):
27592 
    return
27593 
 
27594 
 
27595 
  def __repr__(self):
27596 
    L = ['%s=%r' % (key, value)
27597 
      for key, value in self.__dict__.iteritems()]
27598 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27599 
 
27600 
  def __eq__(self, other):
27601 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27602 
 
27603 
  def __ne__(self, other):
27604 
    return not (self == other)
27605 
 
27606 
class updateRechargeOrderStatus_result:
27607 
  """
27608 
  Attributes:
6031 rajveer 27609 
   - success
6000 mandeep.dh 27610 
   - ex
27611 
  """
27612 
 
27613 
  thrift_spec = (
6031 rajveer 27614 
    (0, TType.BOOL, 'success', None, None, ), # 0
6000 mandeep.dh 27615 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
27616 
  )
27617 
 
6031 rajveer 27618 
  def __init__(self, success=None, ex=None,):
27619 
    self.success = success
6000 mandeep.dh 27620 
    self.ex = ex
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
6031 rajveer 27631 
      if fid == 0:
27632 
        if ftype == TType.BOOL:
27633 
          self.success = iprot.readBool();
27634 
        else:
27635 
          iprot.skip(ftype)
27636 
      elif fid == 1:
6000 mandeep.dh 27637 
        if ftype == TType.STRUCT:
27638 
          self.ex = TransactionServiceException()
27639 
          self.ex.read(iprot)
27640 
        else:
27641 
          iprot.skip(ftype)
27642 
      else:
27643 
        iprot.skip(ftype)
27644 
      iprot.readFieldEnd()
27645 
    iprot.readStructEnd()
27646 
 
27647 
  def write(self, oprot):
27648 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27649 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27650 
      return
27651 
    oprot.writeStructBegin('updateRechargeOrderStatus_result')
6031 rajveer 27652 
    if self.success is not None:
27653 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
27654 
      oprot.writeBool(self.success)
27655 
      oprot.writeFieldEnd()
6000 mandeep.dh 27656 
    if self.ex is not None:
27657 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
27658 
      self.ex.write(oprot)
27659 
      oprot.writeFieldEnd()
27660 
    oprot.writeFieldStop()
27661 
    oprot.writeStructEnd()
27662 
 
27663 
  def validate(self):
27664 
    return
27665 
 
27666 
 
27667 
  def __repr__(self):
27668 
    L = ['%s=%r' % (key, value)
27669 
      for key, value in self.__dict__.iteritems()]
27670 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27671 
 
27672 
  def __eq__(self, other):
27673 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27674 
 
27675 
  def __ne__(self, other):
27676 
    return not (self == other)
27677 
 
27678 
class activateRechargeTxn_args:
27679 
  """
27680 
  Attributes:
6031 rajveer 27681 
   - rechargeOrderId
6000 mandeep.dh 27682 
  """
27683 
 
27684 
  thrift_spec = (
27685 
    None, # 0
6031 rajveer 27686 
    (1, TType.I64, 'rechargeOrderId', None, None, ), # 1
6000 mandeep.dh 27687 
  )
27688 
 
6031 rajveer 27689 
  def __init__(self, rechargeOrderId=None,):
27690 
    self.rechargeOrderId = rechargeOrderId
6000 mandeep.dh 27691 
 
27692 
  def read(self, iprot):
27693 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27694 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27695 
      return
27696 
    iprot.readStructBegin()
27697 
    while True:
27698 
      (fname, ftype, fid) = iprot.readFieldBegin()
27699 
      if ftype == TType.STOP:
27700 
        break
27701 
      if fid == 1:
6031 rajveer 27702 
        if ftype == TType.I64:
27703 
          self.rechargeOrderId = iprot.readI64();
6000 mandeep.dh 27704 
        else:
27705 
          iprot.skip(ftype)
27706 
      else:
27707 
        iprot.skip(ftype)
27708 
      iprot.readFieldEnd()
27709 
    iprot.readStructEnd()
27710 
 
27711 
  def write(self, oprot):
27712 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27713 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27714 
      return
27715 
    oprot.writeStructBegin('activateRechargeTxn_args')
6031 rajveer 27716 
    if self.rechargeOrderId is not None:
27717 
      oprot.writeFieldBegin('rechargeOrderId', TType.I64, 1)
27718 
      oprot.writeI64(self.rechargeOrderId)
6000 mandeep.dh 27719 
      oprot.writeFieldEnd()
27720 
    oprot.writeFieldStop()
27721 
    oprot.writeStructEnd()
27722 
 
27723 
  def validate(self):
27724 
    return
27725 
 
27726 
 
27727 
  def __repr__(self):
27728 
    L = ['%s=%r' % (key, value)
27729 
      for key, value in self.__dict__.iteritems()]
27730 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27731 
 
27732 
  def __eq__(self, other):
27733 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27734 
 
27735 
  def __ne__(self, other):
27736 
    return not (self == other)
27737 
 
27738 
class activateRechargeTxn_result:
27739 
  """
27740 
  Attributes:
27741 
   - success
27742 
   - ex
27743 
  """
27744 
 
27745 
  thrift_spec = (
6031 rajveer 27746 
    (0, TType.BOOL, 'success', None, None, ), # 0
6000 mandeep.dh 27747 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
27748 
  )
27749 
 
27750 
  def __init__(self, success=None, ex=None,):
27751 
    self.success = success
27752 
    self.ex = ex
27753 
 
27754 
  def read(self, iprot):
27755 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27756 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27757 
      return
27758 
    iprot.readStructBegin()
27759 
    while True:
27760 
      (fname, ftype, fid) = iprot.readFieldBegin()
27761 
      if ftype == TType.STOP:
27762 
        break
27763 
      if fid == 0:
6031 rajveer 27764 
        if ftype == TType.BOOL:
27765 
          self.success = iprot.readBool();
6000 mandeep.dh 27766 
        else:
27767 
          iprot.skip(ftype)
27768 
      elif fid == 1:
27769 
        if ftype == TType.STRUCT:
27770 
          self.ex = TransactionServiceException()
27771 
          self.ex.read(iprot)
27772 
        else:
27773 
          iprot.skip(ftype)
27774 
      else:
27775 
        iprot.skip(ftype)
27776 
      iprot.readFieldEnd()
27777 
    iprot.readStructEnd()
27778 
 
27779 
  def write(self, oprot):
27780 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27781 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27782 
      return
27783 
    oprot.writeStructBegin('activateRechargeTxn_result')
27784 
    if self.success is not None:
6031 rajveer 27785 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
27786 
      oprot.writeBool(self.success)
6000 mandeep.dh 27787 
      oprot.writeFieldEnd()
27788 
    if self.ex is not None:
27789 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
27790 
      self.ex.write(oprot)
27791 
      oprot.writeFieldEnd()
27792 
    oprot.writeFieldStop()
27793 
    oprot.writeStructEnd()
27794 
 
27795 
  def validate(self):
27796 
    return
27797 
 
27798 
 
27799 
  def __repr__(self):
27800 
    L = ['%s=%r' % (key, value)
27801 
      for key, value in self.__dict__.iteritems()]
27802 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27803 
 
27804 
  def __eq__(self, other):
27805 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27806 
 
27807 
  def __ne__(self, other):
27808 
    return not (self == other)
27809 
 
6031 rajveer 27810 
class getUserWallet_args:
6000 mandeep.dh 27811 
  """
27812 
  Attributes:
6031 rajveer 27813 
   - userId
6000 mandeep.dh 27814 
  """
27815 
 
27816 
  thrift_spec = (
27817 
    None, # 0
6031 rajveer 27818 
    (1, TType.I64, 'userId', None, None, ), # 1
6000 mandeep.dh 27819 
  )
27820 
 
6031 rajveer 27821 
  def __init__(self, userId=None,):
27822 
    self.userId = userId
6000 mandeep.dh 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
27833 
      if fid == 1:
27834 
        if ftype == TType.I64:
6031 rajveer 27835 
          self.userId = iprot.readI64();
6000 mandeep.dh 27836 
        else:
27837 
          iprot.skip(ftype)
27838 
      else:
27839 
        iprot.skip(ftype)
27840 
      iprot.readFieldEnd()
27841 
    iprot.readStructEnd()
27842 
 
27843 
  def write(self, oprot):
27844 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27845 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27846 
      return
6031 rajveer 27847 
    oprot.writeStructBegin('getUserWallet_args')
27848 
    if self.userId is not None:
27849 
      oprot.writeFieldBegin('userId', TType.I64, 1)
27850 
      oprot.writeI64(self.userId)
6000 mandeep.dh 27851 
      oprot.writeFieldEnd()
27852 
    oprot.writeFieldStop()
27853 
    oprot.writeStructEnd()
27854 
 
27855 
  def validate(self):
27856 
    return
27857 
 
27858 
 
27859 
  def __repr__(self):
27860 
    L = ['%s=%r' % (key, value)
27861 
      for key, value in self.__dict__.iteritems()]
27862 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27863 
 
27864 
  def __eq__(self, other):
27865 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27866 
 
27867 
  def __ne__(self, other):
27868 
    return not (self == other)
27869 
 
6031 rajveer 27870 
class getUserWallet_result:
6000 mandeep.dh 27871 
  """
27872 
  Attributes:
27873 
   - success
27874 
  """
27875 
 
27876 
  thrift_spec = (
6031 rajveer 27877 
    (0, TType.STRUCT, 'success', (UserWallet, UserWallet.thrift_spec), None, ), # 0
6000 mandeep.dh 27878 
  )
27879 
 
27880 
  def __init__(self, success=None,):
27881 
    self.success = success
27882 
 
27883 
  def read(self, iprot):
27884 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27885 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27886 
      return
27887 
    iprot.readStructBegin()
27888 
    while True:
27889 
      (fname, ftype, fid) = iprot.readFieldBegin()
27890 
      if ftype == TType.STOP:
27891 
        break
27892 
      if fid == 0:
6031 rajveer 27893 
        if ftype == TType.STRUCT:
27894 
          self.success = UserWallet()
27895 
          self.success.read(iprot)
6000 mandeep.dh 27896 
        else:
27897 
          iprot.skip(ftype)
27898 
      else:
27899 
        iprot.skip(ftype)
27900 
      iprot.readFieldEnd()
27901 
    iprot.readStructEnd()
27902 
 
27903 
  def write(self, oprot):
27904 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27905 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27906 
      return
6031 rajveer 27907 
    oprot.writeStructBegin('getUserWallet_result')
6000 mandeep.dh 27908 
    if self.success is not None:
6031 rajveer 27909 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
27910 
      self.success.write(oprot)
6000 mandeep.dh 27911 
      oprot.writeFieldEnd()
27912 
    oprot.writeFieldStop()
27913 
    oprot.writeStructEnd()
27914 
 
27915 
  def validate(self):
27916 
    return
27917 
 
27918 
 
27919 
  def __repr__(self):
27920 
    L = ['%s=%r' % (key, value)
27921 
      for key, value in self.__dict__.iteritems()]
27922 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27923 
 
27924 
  def __eq__(self, other):
27925 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27926 
 
27927 
  def __ne__(self, other):
27928 
    return not (self == other)
27929 
 
6031 rajveer 27930 
class getUserWalletHistory_args:
6000 mandeep.dh 27931 
  """
27932 
  Attributes:
6031 rajveer 27933 
   - userId
6000 mandeep.dh 27934 
  """
27935 
 
27936 
  thrift_spec = (
27937 
    None, # 0
6031 rajveer 27938 
    (1, TType.I64, 'userId', None, None, ), # 1
6000 mandeep.dh 27939 
  )
27940 
 
6031 rajveer 27941 
  def __init__(self, userId=None,):
27942 
    self.userId = userId
6000 mandeep.dh 27943 
 
27944 
  def read(self, iprot):
27945 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27946 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27947 
      return
27948 
    iprot.readStructBegin()
27949 
    while True:
27950 
      (fname, ftype, fid) = iprot.readFieldBegin()
27951 
      if ftype == TType.STOP:
27952 
        break
27953 
      if fid == 1:
27954 
        if ftype == TType.I64:
6031 rajveer 27955 
          self.userId = iprot.readI64();
6000 mandeep.dh 27956 
        else:
27957 
          iprot.skip(ftype)
27958 
      else:
27959 
        iprot.skip(ftype)
27960 
      iprot.readFieldEnd()
27961 
    iprot.readStructEnd()
27962 
 
27963 
  def write(self, oprot):
27964 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27965 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27966 
      return
6031 rajveer 27967 
    oprot.writeStructBegin('getUserWalletHistory_args')
27968 
    if self.userId is not None:
27969 
      oprot.writeFieldBegin('userId', TType.I64, 1)
27970 
      oprot.writeI64(self.userId)
6000 mandeep.dh 27971 
      oprot.writeFieldEnd()
27972 
    oprot.writeFieldStop()
27973 
    oprot.writeStructEnd()
27974 
 
27975 
  def validate(self):
27976 
    return
27977 
 
27978 
 
27979 
  def __repr__(self):
27980 
    L = ['%s=%r' % (key, value)
27981 
      for key, value in self.__dict__.iteritems()]
27982 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27983 
 
27984 
  def __eq__(self, other):
27985 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27986 
 
27987 
  def __ne__(self, other):
27988 
    return not (self == other)
27989 
 
6031 rajveer 27990 
class getUserWalletHistory_result:
6000 mandeep.dh 27991 
  """
27992 
  Attributes:
27993 
   - success
27994 
  """
27995 
 
27996 
  thrift_spec = (
6031 rajveer 27997 
    (0, TType.LIST, 'success', (TType.STRUCT,(UserWalletHistory, UserWalletHistory.thrift_spec)), None, ), # 0
6000 mandeep.dh 27998 
  )
27999 
 
28000 
  def __init__(self, success=None,):
28001 
    self.success = success
28002 
 
28003 
  def read(self, iprot):
28004 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28005 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28006 
      return
28007 
    iprot.readStructBegin()
28008 
    while True:
28009 
      (fname, ftype, fid) = iprot.readFieldBegin()
28010 
      if ftype == TType.STOP:
28011 
        break
28012 
      if fid == 0:
28013 
        if ftype == TType.LIST:
28014 
          self.success = []
6188 rajveer 28015 
          (_etype666, _size663) = iprot.readListBegin()
28016 
          for _i667 in xrange(_size663):
28017 
            _elem668 = UserWalletHistory()
28018 
            _elem668.read(iprot)
28019 
            self.success.append(_elem668)
6000 mandeep.dh 28020 
          iprot.readListEnd()
28021 
        else:
28022 
          iprot.skip(ftype)
28023 
      else:
28024 
        iprot.skip(ftype)
28025 
      iprot.readFieldEnd()
28026 
    iprot.readStructEnd()
28027 
 
28028 
  def write(self, oprot):
28029 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28030 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28031 
      return
6031 rajveer 28032 
    oprot.writeStructBegin('getUserWalletHistory_result')
6000 mandeep.dh 28033 
    if self.success is not None:
28034 
      oprot.writeFieldBegin('success', TType.LIST, 0)
28035 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 28036 
      for iter669 in self.success:
28037 
        iter669.write(oprot)
6000 mandeep.dh 28038 
      oprot.writeListEnd()
28039 
      oprot.writeFieldEnd()
28040 
    oprot.writeFieldStop()
28041 
    oprot.writeStructEnd()
28042 
 
28043 
  def validate(self):
28044 
    return
28045 
 
28046 
 
28047 
  def __repr__(self):
28048 
    L = ['%s=%r' % (key, value)
28049 
      for key, value in self.__dict__.iteritems()]
28050 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28051 
 
28052 
  def __eq__(self, other):
28053 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28054 
 
28055 
  def __ne__(self, other):
28056 
    return not (self == other)
6048 rajveer 28057 
 
6050 anupam.sin 28058 
class getRechargeOrdersForTransaction_args:
28059 
  """
28060 
  Attributes:
28061 
   - txnId
28062 
  """
28063 
 
28064 
  thrift_spec = (
28065 
    None, # 0
28066 
    (1, TType.I64, 'txnId', None, None, ), # 1
28067 
  )
28068 
 
28069 
  def __init__(self, txnId=None,):
28070 
    self.txnId = txnId
28071 
 
28072 
  def read(self, iprot):
28073 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28074 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28075 
      return
28076 
    iprot.readStructBegin()
28077 
    while True:
28078 
      (fname, ftype, fid) = iprot.readFieldBegin()
28079 
      if ftype == TType.STOP:
28080 
        break
28081 
      if fid == 1:
28082 
        if ftype == TType.I64:
28083 
          self.txnId = iprot.readI64();
28084 
        else:
28085 
          iprot.skip(ftype)
28086 
      else:
28087 
        iprot.skip(ftype)
28088 
      iprot.readFieldEnd()
28089 
    iprot.readStructEnd()
28090 
 
28091 
  def write(self, oprot):
28092 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28093 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28094 
      return
28095 
    oprot.writeStructBegin('getRechargeOrdersForTransaction_args')
28096 
    if self.txnId is not None:
28097 
      oprot.writeFieldBegin('txnId', TType.I64, 1)
28098 
      oprot.writeI64(self.txnId)
28099 
      oprot.writeFieldEnd()
28100 
    oprot.writeFieldStop()
28101 
    oprot.writeStructEnd()
28102 
 
28103 
  def validate(self):
28104 
    return
28105 
 
28106 
 
28107 
  def __repr__(self):
28108 
    L = ['%s=%r' % (key, value)
28109 
      for key, value in self.__dict__.iteritems()]
28110 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28111 
 
28112 
  def __eq__(self, other):
28113 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28114 
 
28115 
  def __ne__(self, other):
28116 
    return not (self == other)
28117 
 
28118 
class getRechargeOrdersForTransaction_result:
28119 
  """
28120 
  Attributes:
28121 
   - success
28122 
   - ex
28123 
  """
28124 
 
28125 
  thrift_spec = (
28126 
    (0, TType.STRUCT, 'success', (RechargeOrder, RechargeOrder.thrift_spec), None, ), # 0
28127 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
28128 
  )
28129 
 
28130 
  def __init__(self, success=None, ex=None,):
28131 
    self.success = success
28132 
    self.ex = ex
28133 
 
28134 
  def read(self, iprot):
28135 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28136 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28137 
      return
28138 
    iprot.readStructBegin()
28139 
    while True:
28140 
      (fname, ftype, fid) = iprot.readFieldBegin()
28141 
      if ftype == TType.STOP:
28142 
        break
28143 
      if fid == 0:
28144 
        if ftype == TType.STRUCT:
28145 
          self.success = RechargeOrder()
28146 
          self.success.read(iprot)
28147 
        else:
28148 
          iprot.skip(ftype)
28149 
      elif fid == 1:
28150 
        if ftype == TType.STRUCT:
28151 
          self.ex = TransactionServiceException()
28152 
          self.ex.read(iprot)
28153 
        else:
28154 
          iprot.skip(ftype)
28155 
      else:
28156 
        iprot.skip(ftype)
28157 
      iprot.readFieldEnd()
28158 
    iprot.readStructEnd()
28159 
 
28160 
  def write(self, oprot):
28161 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28162 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28163 
      return
28164 
    oprot.writeStructBegin('getRechargeOrdersForTransaction_result')
28165 
    if self.success is not None:
28166 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
28167 
      self.success.write(oprot)
28168 
      oprot.writeFieldEnd()
28169 
    if self.ex is not None:
28170 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
28171 
      self.ex.write(oprot)
28172 
      oprot.writeFieldEnd()
28173 
    oprot.writeFieldStop()
28174 
    oprot.writeStructEnd()
28175 
 
28176 
  def validate(self):
28177 
    return
28178 
 
28179 
 
28180 
  def __repr__(self):
28181 
    L = ['%s=%r' % (key, value)
28182 
      for key, value in self.__dict__.iteritems()]
28183 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28184 
 
28185 
  def __eq__(self, other):
28186 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28187 
 
28188 
  def __ne__(self, other):
28189 
    return not (self == other)
28190 
 
6048 rajveer 28191 
class getServiceProviders_args:
28192 
  """
28193 
  Attributes:
28194 
   - rechargeType
6206 rajveer 28195 
   - onlyActive
6048 rajveer 28196 
  """
28197 
 
28198 
  thrift_spec = (
28199 
    None, # 0
28200 
    (1, TType.I32, 'rechargeType', None, None, ), # 1
6206 rajveer 28201 
    (2, TType.BOOL, 'onlyActive', None, None, ), # 2
6048 rajveer 28202 
  )
28203 
 
6206 rajveer 28204 
  def __init__(self, rechargeType=None, onlyActive=None,):
6048 rajveer 28205 
    self.rechargeType = rechargeType
6206 rajveer 28206 
    self.onlyActive = onlyActive
6048 rajveer 28207 
 
28208 
  def read(self, iprot):
28209 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28210 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28211 
      return
28212 
    iprot.readStructBegin()
28213 
    while True:
28214 
      (fname, ftype, fid) = iprot.readFieldBegin()
28215 
      if ftype == TType.STOP:
28216 
        break
28217 
      if fid == 1:
28218 
        if ftype == TType.I32:
28219 
          self.rechargeType = iprot.readI32();
28220 
        else:
28221 
          iprot.skip(ftype)
6206 rajveer 28222 
      elif fid == 2:
28223 
        if ftype == TType.BOOL:
28224 
          self.onlyActive = iprot.readBool();
28225 
        else:
28226 
          iprot.skip(ftype)
6048 rajveer 28227 
      else:
28228 
        iprot.skip(ftype)
28229 
      iprot.readFieldEnd()
28230 
    iprot.readStructEnd()
28231 
 
28232 
  def write(self, oprot):
28233 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28234 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28235 
      return
28236 
    oprot.writeStructBegin('getServiceProviders_args')
28237 
    if self.rechargeType is not None:
28238 
      oprot.writeFieldBegin('rechargeType', TType.I32, 1)
28239 
      oprot.writeI32(self.rechargeType)
28240 
      oprot.writeFieldEnd()
6206 rajveer 28241 
    if self.onlyActive is not None:
28242 
      oprot.writeFieldBegin('onlyActive', TType.BOOL, 2)
28243 
      oprot.writeBool(self.onlyActive)
28244 
      oprot.writeFieldEnd()
6048 rajveer 28245 
    oprot.writeFieldStop()
28246 
    oprot.writeStructEnd()
28247 
 
28248 
  def validate(self):
28249 
    return
28250 
 
28251 
 
28252 
  def __repr__(self):
28253 
    L = ['%s=%r' % (key, value)
28254 
      for key, value in self.__dict__.iteritems()]
28255 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28256 
 
28257 
  def __eq__(self, other):
28258 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28259 
 
28260 
  def __ne__(self, other):
28261 
    return not (self == other)
28262 
 
28263 
class getServiceProviders_result:
28264 
  """
28265 
  Attributes:
28266 
   - success
28267 
  """
28268 
 
28269 
  thrift_spec = (
28270 
    (0, TType.MAP, 'success', (TType.I64,None,TType.STRING,None), None, ), # 0
28271 
  )
28272 
 
28273 
  def __init__(self, success=None,):
28274 
    self.success = success
28275 
 
28276 
  def read(self, iprot):
28277 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28278 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28279 
      return
28280 
    iprot.readStructBegin()
28281 
    while True:
28282 
      (fname, ftype, fid) = iprot.readFieldBegin()
28283 
      if ftype == TType.STOP:
28284 
        break
28285 
      if fid == 0:
28286 
        if ftype == TType.MAP:
28287 
          self.success = {}
6188 rajveer 28288 
          (_ktype671, _vtype672, _size670 ) = iprot.readMapBegin()
28289 
          for _i674 in xrange(_size670):
28290 
            _key675 = iprot.readI64();
28291 
            _val676 = iprot.readString();
28292 
            self.success[_key675] = _val676
6048 rajveer 28293 
          iprot.readMapEnd()
28294 
        else:
28295 
          iprot.skip(ftype)
28296 
      else:
28297 
        iprot.skip(ftype)
28298 
      iprot.readFieldEnd()
28299 
    iprot.readStructEnd()
28300 
 
28301 
  def write(self, oprot):
28302 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28303 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28304 
      return
28305 
    oprot.writeStructBegin('getServiceProviders_result')
28306 
    if self.success is not None:
28307 
      oprot.writeFieldBegin('success', TType.MAP, 0)
28308 
      oprot.writeMapBegin(TType.I64, TType.STRING, len(self.success))
6188 rajveer 28309 
      for kiter677,viter678 in self.success.items():
28310 
        oprot.writeI64(kiter677)
28311 
        oprot.writeString(viter678)
6048 rajveer 28312 
      oprot.writeMapEnd()
28313 
      oprot.writeFieldEnd()
28314 
    oprot.writeFieldStop()
28315 
    oprot.writeStructEnd()
28316 
 
28317 
  def validate(self):
28318 
    return
28319 
 
28320 
 
28321 
  def __repr__(self):
28322 
    L = ['%s=%r' % (key, value)
28323 
      for key, value in self.__dict__.iteritems()]
28324 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28325 
 
28326 
  def __eq__(self, other):
28327 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28328 
 
28329 
  def __ne__(self, other):
28330 
    return not (self == other)
28331 
 
28332 
class getServiceProviderForDevice_args:
28333 
  """
28334 
  Attributes:
6049 rajveer 28335 
   - rechargeType
6048 rajveer 28336 
   - deviceNumber
28337 
  """
28338 
 
28339 
  thrift_spec = (
28340 
    None, # 0
6049 rajveer 28341 
    (1, TType.I32, 'rechargeType', None, None, ), # 1
28342 
    (2, TType.STRING, 'deviceNumber', None, None, ), # 2
6048 rajveer 28343 
  )
28344 
 
6049 rajveer 28345 
  def __init__(self, rechargeType=None, deviceNumber=None,):
28346 
    self.rechargeType = rechargeType
6048 rajveer 28347 
    self.deviceNumber = deviceNumber
28348 
 
28349 
  def read(self, iprot):
28350 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28351 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28352 
      return
28353 
    iprot.readStructBegin()
28354 
    while True:
28355 
      (fname, ftype, fid) = iprot.readFieldBegin()
28356 
      if ftype == TType.STOP:
28357 
        break
28358 
      if fid == 1:
6049 rajveer 28359 
        if ftype == TType.I32:
28360 
          self.rechargeType = iprot.readI32();
28361 
        else:
28362 
          iprot.skip(ftype)
28363 
      elif fid == 2:
6048 rajveer 28364 
        if ftype == TType.STRING:
28365 
          self.deviceNumber = iprot.readString();
28366 
        else:
28367 
          iprot.skip(ftype)
28368 
      else:
28369 
        iprot.skip(ftype)
28370 
      iprot.readFieldEnd()
28371 
    iprot.readStructEnd()
28372 
 
28373 
  def write(self, oprot):
28374 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28375 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28376 
      return
28377 
    oprot.writeStructBegin('getServiceProviderForDevice_args')
6049 rajveer 28378 
    if self.rechargeType is not None:
28379 
      oprot.writeFieldBegin('rechargeType', TType.I32, 1)
28380 
      oprot.writeI32(self.rechargeType)
28381 
      oprot.writeFieldEnd()
6048 rajveer 28382 
    if self.deviceNumber is not None:
6049 rajveer 28383 
      oprot.writeFieldBegin('deviceNumber', TType.STRING, 2)
6048 rajveer 28384 
      oprot.writeString(self.deviceNumber)
28385 
      oprot.writeFieldEnd()
28386 
    oprot.writeFieldStop()
28387 
    oprot.writeStructEnd()
28388 
 
28389 
  def validate(self):
28390 
    return
28391 
 
28392 
 
28393 
  def __repr__(self):
28394 
    L = ['%s=%r' % (key, value)
28395 
      for key, value in self.__dict__.iteritems()]
28396 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28397 
 
28398 
  def __eq__(self, other):
28399 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28400 
 
28401 
  def __ne__(self, other):
28402 
    return not (self == other)
28403 
 
28404 
class getServiceProviderForDevice_result:
28405 
  """
28406 
  Attributes:
28407 
   - success
28408 
  """
28409 
 
28410 
  thrift_spec = (
6289 anupam.sin 28411 
    (0, TType.STRUCT, 'success', (DeviceNumberInfo, DeviceNumberInfo.thrift_spec), None, ), # 0
6048 rajveer 28412 
  )
28413 
 
28414 
  def __init__(self, success=None,):
28415 
    self.success = success
28416 
 
28417 
  def read(self, iprot):
28418 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28419 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28420 
      return
28421 
    iprot.readStructBegin()
28422 
    while True:
28423 
      (fname, ftype, fid) = iprot.readFieldBegin()
28424 
      if ftype == TType.STOP:
28425 
        break
28426 
      if fid == 0:
6289 anupam.sin 28427 
        if ftype == TType.STRUCT:
28428 
          self.success = DeviceNumberInfo()
28429 
          self.success.read(iprot)
6048 rajveer 28430 
        else:
28431 
          iprot.skip(ftype)
28432 
      else:
28433 
        iprot.skip(ftype)
28434 
      iprot.readFieldEnd()
28435 
    iprot.readStructEnd()
28436 
 
28437 
  def write(self, oprot):
28438 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28439 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28440 
      return
28441 
    oprot.writeStructBegin('getServiceProviderForDevice_result')
28442 
    if self.success is not None:
6289 anupam.sin 28443 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
28444 
      self.success.write(oprot)
6048 rajveer 28445 
      oprot.writeFieldEnd()
28446 
    oprot.writeFieldStop()
28447 
    oprot.writeStructEnd()
28448 
 
28449 
  def validate(self):
28450 
    return
28451 
 
28452 
 
28453 
  def __repr__(self):
28454 
    L = ['%s=%r' % (key, value)
28455 
      for key, value in self.__dict__.iteritems()]
28456 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28457 
 
28458 
  def __eq__(self, other):
28459 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28460 
 
28461 
  def __ne__(self, other):
28462 
    return not (self == other)
6094 rajveer 28463 
 
6269 rajveer 28464 
class validateRecharge_args:
28465 
  """
28466 
  Attributes:
28467 
   - rechargeType
28468 
   - deviceNumber
6307 anupam.sin 28469 
   - userSelectedProviderId
6591 anupam.sin 28470 
   - clientAddress
6269 rajveer 28471 
  """
28472 
 
28473 
  thrift_spec = (
28474 
    None, # 0
28475 
    (1, TType.I32, 'rechargeType', None, None, ), # 1
28476 
    (2, TType.STRING, 'deviceNumber', None, None, ), # 2
6336 anupam.sin 28477 
    (3, TType.I64, 'userSelectedProviderId', None, None, ), # 3
6591 anupam.sin 28478 
    (4, TType.STRING, 'clientAddress', None, None, ), # 4
6269 rajveer 28479 
  )
28480 
 
6591 anupam.sin 28481 
  def __init__(self, rechargeType=None, deviceNumber=None, userSelectedProviderId=None, clientAddress=None,):
6269 rajveer 28482 
    self.rechargeType = rechargeType
28483 
    self.deviceNumber = deviceNumber
6307 anupam.sin 28484 
    self.userSelectedProviderId = userSelectedProviderId
6591 anupam.sin 28485 
    self.clientAddress = clientAddress
6269 rajveer 28486 
 
28487 
  def read(self, iprot):
28488 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28489 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28490 
      return
28491 
    iprot.readStructBegin()
28492 
    while True:
28493 
      (fname, ftype, fid) = iprot.readFieldBegin()
28494 
      if ftype == TType.STOP:
28495 
        break
28496 
      if fid == 1:
28497 
        if ftype == TType.I32:
28498 
          self.rechargeType = iprot.readI32();
28499 
        else:
28500 
          iprot.skip(ftype)
28501 
      elif fid == 2:
28502 
        if ftype == TType.STRING:
28503 
          self.deviceNumber = iprot.readString();
28504 
        else:
28505 
          iprot.skip(ftype)
6307 anupam.sin 28506 
      elif fid == 3:
28507 
        if ftype == TType.I64:
28508 
          self.userSelectedProviderId = iprot.readI64();
28509 
        else:
28510 
          iprot.skip(ftype)
6591 anupam.sin 28511 
      elif fid == 4:
28512 
        if ftype == TType.STRING:
28513 
          self.clientAddress = iprot.readString();
28514 
        else:
28515 
          iprot.skip(ftype)
6269 rajveer 28516 
      else:
28517 
        iprot.skip(ftype)
28518 
      iprot.readFieldEnd()
28519 
    iprot.readStructEnd()
28520 
 
28521 
  def write(self, oprot):
28522 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28523 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28524 
      return
28525 
    oprot.writeStructBegin('validateRecharge_args')
28526 
    if self.rechargeType is not None:
28527 
      oprot.writeFieldBegin('rechargeType', TType.I32, 1)
28528 
      oprot.writeI32(self.rechargeType)
28529 
      oprot.writeFieldEnd()
28530 
    if self.deviceNumber is not None:
28531 
      oprot.writeFieldBegin('deviceNumber', TType.STRING, 2)
28532 
      oprot.writeString(self.deviceNumber)
28533 
      oprot.writeFieldEnd()
6307 anupam.sin 28534 
    if self.userSelectedProviderId is not None:
6336 anupam.sin 28535 
      oprot.writeFieldBegin('userSelectedProviderId', TType.I64, 3)
6307 anupam.sin 28536 
      oprot.writeI64(self.userSelectedProviderId)
28537 
      oprot.writeFieldEnd()
6591 anupam.sin 28538 
    if self.clientAddress is not None:
28539 
      oprot.writeFieldBegin('clientAddress', TType.STRING, 4)
28540 
      oprot.writeString(self.clientAddress)
28541 
      oprot.writeFieldEnd()
6269 rajveer 28542 
    oprot.writeFieldStop()
28543 
    oprot.writeStructEnd()
28544 
 
28545 
  def validate(self):
28546 
    return
28547 
 
28548 
 
28549 
  def __repr__(self):
28550 
    L = ['%s=%r' % (key, value)
28551 
      for key, value in self.__dict__.iteritems()]
28552 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28553 
 
28554 
  def __eq__(self, other):
28555 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28556 
 
28557 
  def __ne__(self, other):
28558 
    return not (self == other)
28559 
 
28560 
class validateRecharge_result:
28561 
  """
28562 
  Attributes:
28563 
   - success
28564 
  """
28565 
 
28566 
  thrift_spec = (
28567 
    (0, TType.STRING, 'success', None, None, ), # 0
28568 
  )
28569 
 
28570 
  def __init__(self, success=None,):
28571 
    self.success = success
28572 
 
28573 
  def read(self, iprot):
28574 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28575 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28576 
      return
28577 
    iprot.readStructBegin()
28578 
    while True:
28579 
      (fname, ftype, fid) = iprot.readFieldBegin()
28580 
      if ftype == TType.STOP:
28581 
        break
28582 
      if fid == 0:
28583 
        if ftype == TType.STRING:
28584 
          self.success = iprot.readString();
28585 
        else:
28586 
          iprot.skip(ftype)
28587 
      else:
28588 
        iprot.skip(ftype)
28589 
      iprot.readFieldEnd()
28590 
    iprot.readStructEnd()
28591 
 
28592 
  def write(self, oprot):
28593 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28594 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28595 
      return
28596 
    oprot.writeStructBegin('validateRecharge_result')
28597 
    if self.success is not None:
28598 
      oprot.writeFieldBegin('success', TType.STRING, 0)
28599 
      oprot.writeString(self.success)
28600 
      oprot.writeFieldEnd()
28601 
    oprot.writeFieldStop()
28602 
    oprot.writeStructEnd()
28603 
 
28604 
  def validate(self):
28605 
    return
28606 
 
28607 
 
28608 
  def __repr__(self):
28609 
    L = ['%s=%r' % (key, value)
28610 
      for key, value in self.__dict__.iteritems()]
28611 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28612 
 
28613 
  def __eq__(self, other):
28614 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28615 
 
28616 
  def __ne__(self, other):
28617 
    return not (self == other)
28618 
 
6094 rajveer 28619 
class getRechargeOrdersForDevice_args:
28620 
  """
28621 
  Attributes:
28622 
   - deviceNumber
28623 
  """
28624 
 
28625 
  thrift_spec = (
28626 
    None, # 0
28627 
    (1, TType.STRING, 'deviceNumber', None, None, ), # 1
28628 
  )
28629 
 
28630 
  def __init__(self, deviceNumber=None,):
28631 
    self.deviceNumber = deviceNumber
28632 
 
28633 
  def read(self, iprot):
28634 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28635 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28636 
      return
28637 
    iprot.readStructBegin()
28638 
    while True:
28639 
      (fname, ftype, fid) = iprot.readFieldBegin()
28640 
      if ftype == TType.STOP:
28641 
        break
28642 
      if fid == 1:
28643 
        if ftype == TType.STRING:
28644 
          self.deviceNumber = iprot.readString();
28645 
        else:
28646 
          iprot.skip(ftype)
28647 
      else:
28648 
        iprot.skip(ftype)
28649 
      iprot.readFieldEnd()
28650 
    iprot.readStructEnd()
28651 
 
28652 
  def write(self, oprot):
28653 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28654 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28655 
      return
28656 
    oprot.writeStructBegin('getRechargeOrdersForDevice_args')
28657 
    if self.deviceNumber is not None:
28658 
      oprot.writeFieldBegin('deviceNumber', TType.STRING, 1)
28659 
      oprot.writeString(self.deviceNumber)
28660 
      oprot.writeFieldEnd()
28661 
    oprot.writeFieldStop()
28662 
    oprot.writeStructEnd()
28663 
 
28664 
  def validate(self):
28665 
    return
28666 
 
28667 
 
28668 
  def __repr__(self):
28669 
    L = ['%s=%r' % (key, value)
28670 
      for key, value in self.__dict__.iteritems()]
28671 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28672 
 
28673 
  def __eq__(self, other):
28674 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28675 
 
28676 
  def __ne__(self, other):
28677 
    return not (self == other)
28678 
 
28679 
class getRechargeOrdersForDevice_result:
28680 
  """
28681 
  Attributes:
28682 
   - success
28683 
  """
28684 
 
28685 
  thrift_spec = (
28686 
    (0, TType.LIST, 'success', (TType.STRUCT,(RechargeOrder, RechargeOrder.thrift_spec)), None, ), # 0
28687 
  )
28688 
 
28689 
  def __init__(self, success=None,):
28690 
    self.success = success
28691 
 
28692 
  def read(self, iprot):
28693 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28694 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28695 
      return
28696 
    iprot.readStructBegin()
28697 
    while True:
28698 
      (fname, ftype, fid) = iprot.readFieldBegin()
28699 
      if ftype == TType.STOP:
28700 
        break
28701 
      if fid == 0:
28702 
        if ftype == TType.LIST:
28703 
          self.success = []
6188 rajveer 28704 
          (_etype682, _size679) = iprot.readListBegin()
28705 
          for _i683 in xrange(_size679):
28706 
            _elem684 = RechargeOrder()
28707 
            _elem684.read(iprot)
28708 
            self.success.append(_elem684)
6094 rajveer 28709 
          iprot.readListEnd()
28710 
        else:
28711 
          iprot.skip(ftype)
28712 
      else:
28713 
        iprot.skip(ftype)
28714 
      iprot.readFieldEnd()
28715 
    iprot.readStructEnd()
28716 
 
28717 
  def write(self, oprot):
28718 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28719 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28720 
      return
28721 
    oprot.writeStructBegin('getRechargeOrdersForDevice_result')
28722 
    if self.success is not None:
28723 
      oprot.writeFieldBegin('success', TType.LIST, 0)
28724 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 28725 
      for iter685 in self.success:
28726 
        iter685.write(oprot)
6094 rajveer 28727 
      oprot.writeListEnd()
28728 
      oprot.writeFieldEnd()
28729 
    oprot.writeFieldStop()
28730 
    oprot.writeStructEnd()
28731 
 
28732 
  def validate(self):
28733 
    return
28734 
 
28735 
 
28736 
  def __repr__(self):
28737 
    L = ['%s=%r' % (key, value)
28738 
      for key, value in self.__dict__.iteritems()]
28739 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28740 
 
28741 
  def __eq__(self, other):
28742 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28743 
 
28744 
  def __ne__(self, other):
28745 
    return not (self == other)
28746 
 
28747 
class addAmountToWallet_args:
28748 
  """
28749 
  Attributes:
28750 
   - userId
28751 
   - orderId
28752 
   - amount
28753 
  """
28754 
 
28755 
  thrift_spec = (
28756 
    None, # 0
28757 
    (1, TType.I64, 'userId', None, None, ), # 1
28758 
    (2, TType.I64, 'orderId', None, None, ), # 2
28759 
    (3, TType.I64, 'amount', None, None, ), # 3
28760 
  )
28761 
 
28762 
  def __init__(self, userId=None, orderId=None, amount=None,):
28763 
    self.userId = userId
28764 
    self.orderId = orderId
28765 
    self.amount = amount
28766 
 
28767 
  def read(self, iprot):
28768 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28769 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28770 
      return
28771 
    iprot.readStructBegin()
28772 
    while True:
28773 
      (fname, ftype, fid) = iprot.readFieldBegin()
28774 
      if ftype == TType.STOP:
28775 
        break
28776 
      if fid == 1:
28777 
        if ftype == TType.I64:
28778 
          self.userId = iprot.readI64();
28779 
        else:
28780 
          iprot.skip(ftype)
28781 
      elif fid == 2:
28782 
        if ftype == TType.I64:
28783 
          self.orderId = iprot.readI64();
28784 
        else:
28785 
          iprot.skip(ftype)
28786 
      elif fid == 3:
28787 
        if ftype == TType.I64:
28788 
          self.amount = iprot.readI64();
28789 
        else:
28790 
          iprot.skip(ftype)
28791 
      else:
28792 
        iprot.skip(ftype)
28793 
      iprot.readFieldEnd()
28794 
    iprot.readStructEnd()
28795 
 
28796 
  def write(self, oprot):
28797 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28798 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28799 
      return
28800 
    oprot.writeStructBegin('addAmountToWallet_args')
28801 
    if self.userId is not None:
28802 
      oprot.writeFieldBegin('userId', TType.I64, 1)
28803 
      oprot.writeI64(self.userId)
28804 
      oprot.writeFieldEnd()
28805 
    if self.orderId is not None:
28806 
      oprot.writeFieldBegin('orderId', TType.I64, 2)
28807 
      oprot.writeI64(self.orderId)
28808 
      oprot.writeFieldEnd()
28809 
    if self.amount is not None:
28810 
      oprot.writeFieldBegin('amount', TType.I64, 3)
28811 
      oprot.writeI64(self.amount)
28812 
      oprot.writeFieldEnd()
28813 
    oprot.writeFieldStop()
28814 
    oprot.writeStructEnd()
28815 
 
28816 
  def validate(self):
28817 
    return
28818 
 
28819 
 
28820 
  def __repr__(self):
28821 
    L = ['%s=%r' % (key, value)
28822 
      for key, value in self.__dict__.iteritems()]
28823 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28824 
 
28825 
  def __eq__(self, other):
28826 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28827 
 
28828 
  def __ne__(self, other):
28829 
    return not (self == other)
28830 
 
28831 
class addAmountToWallet_result:
28832 
 
28833 
  thrift_spec = (
28834 
  )
28835 
 
28836 
  def read(self, iprot):
28837 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28838 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28839 
      return
28840 
    iprot.readStructBegin()
28841 
    while True:
28842 
      (fname, ftype, fid) = iprot.readFieldBegin()
28843 
      if ftype == TType.STOP:
28844 
        break
28845 
      else:
28846 
        iprot.skip(ftype)
28847 
      iprot.readFieldEnd()
28848 
    iprot.readStructEnd()
28849 
 
28850 
  def write(self, oprot):
28851 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28852 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28853 
      return
28854 
    oprot.writeStructBegin('addAmountToWallet_result')
28855 
    oprot.writeFieldStop()
28856 
    oprot.writeStructEnd()
28857 
 
28858 
  def validate(self):
28859 
    return
28860 
 
28861 
 
28862 
  def __repr__(self):
28863 
    L = ['%s=%r' % (key, value)
28864 
      for key, value in self.__dict__.iteritems()]
28865 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28866 
 
28867 
  def __eq__(self, other):
28868 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28869 
 
28870 
  def __ne__(self, other):
28871 
    return not (self == other)
6154 rajveer 28872 
 
6188 rajveer 28873 
class getRechargeStatistics_args:
28874 
 
28875 
  thrift_spec = (
28876 
  )
28877 
 
28878 
  def read(self, iprot):
28879 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28880 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28881 
      return
28882 
    iprot.readStructBegin()
28883 
    while True:
28884 
      (fname, ftype, fid) = iprot.readFieldBegin()
28885 
      if ftype == TType.STOP:
28886 
        break
28887 
      else:
28888 
        iprot.skip(ftype)
28889 
      iprot.readFieldEnd()
28890 
    iprot.readStructEnd()
28891 
 
28892 
  def write(self, oprot):
28893 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28894 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28895 
      return
28896 
    oprot.writeStructBegin('getRechargeStatistics_args')
28897 
    oprot.writeFieldStop()
28898 
    oprot.writeStructEnd()
28899 
 
28900 
  def validate(self):
28901 
    return
28902 
 
28903 
 
28904 
  def __repr__(self):
28905 
    L = ['%s=%r' % (key, value)
28906 
      for key, value in self.__dict__.iteritems()]
28907 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28908 
 
28909 
  def __eq__(self, other):
28910 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28911 
 
28912 
  def __ne__(self, other):
28913 
    return not (self == other)
28914 
 
28915 
class getRechargeStatistics_result:
28916 
  """
28917 
  Attributes:
28918 
   - success
28919 
  """
28920 
 
28921 
  thrift_spec = (
28922 
    (0, TType.STRUCT, 'success', (RechargeStatistics, RechargeStatistics.thrift_spec), None, ), # 0
28923 
  )
28924 
 
28925 
  def __init__(self, success=None,):
28926 
    self.success = success
28927 
 
28928 
  def read(self, iprot):
28929 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28930 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28931 
      return
28932 
    iprot.readStructBegin()
28933 
    while True:
28934 
      (fname, ftype, fid) = iprot.readFieldBegin()
28935 
      if ftype == TType.STOP:
28936 
        break
28937 
      if fid == 0:
28938 
        if ftype == TType.STRUCT:
28939 
          self.success = RechargeStatistics()
28940 
          self.success.read(iprot)
28941 
        else:
28942 
          iprot.skip(ftype)
28943 
      else:
28944 
        iprot.skip(ftype)
28945 
      iprot.readFieldEnd()
28946 
    iprot.readStructEnd()
28947 
 
28948 
  def write(self, oprot):
28949 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28950 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28951 
      return
28952 
    oprot.writeStructBegin('getRechargeStatistics_result')
28953 
    if self.success is not None:
28954 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
28955 
      self.success.write(oprot)
28956 
      oprot.writeFieldEnd()
28957 
    oprot.writeFieldStop()
28958 
    oprot.writeStructEnd()
28959 
 
28960 
  def validate(self):
28961 
    return
28962 
 
28963 
 
28964 
  def __repr__(self):
28965 
    L = ['%s=%r' % (key, value)
28966 
      for key, value in self.__dict__.iteritems()]
28967 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28968 
 
28969 
  def __eq__(self, other):
28970 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28971 
 
28972 
  def __ne__(self, other):
28973 
    return not (self == other)
28974 
 
6154 rajveer 28975 
class getRechargeOrdersForStatus_args:
28976 
  """
28977 
  Attributes:
28978 
   - status
28979 
  """
28980 
 
28981 
  thrift_spec = (
28982 
    None, # 0
28983 
    (1, TType.I64, 'status', None, None, ), # 1
28984 
  )
28985 
 
28986 
  def __init__(self, status=None,):
28987 
    self.status = status
28988 
 
28989 
  def read(self, iprot):
28990 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28991 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28992 
      return
28993 
    iprot.readStructBegin()
28994 
    while True:
28995 
      (fname, ftype, fid) = iprot.readFieldBegin()
28996 
      if ftype == TType.STOP:
28997 
        break
28998 
      if fid == 1:
28999 
        if ftype == TType.I64:
29000 
          self.status = iprot.readI64();
29001 
        else:
29002 
          iprot.skip(ftype)
29003 
      else:
29004 
        iprot.skip(ftype)
29005 
      iprot.readFieldEnd()
29006 
    iprot.readStructEnd()
29007 
 
29008 
  def write(self, oprot):
29009 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
29010 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
29011 
      return
29012 
    oprot.writeStructBegin('getRechargeOrdersForStatus_args')
29013 
    if self.status is not None:
29014 
      oprot.writeFieldBegin('status', TType.I64, 1)
29015 
      oprot.writeI64(self.status)
29016 
      oprot.writeFieldEnd()
29017 
    oprot.writeFieldStop()
29018 
    oprot.writeStructEnd()
29019 
 
29020 
  def validate(self):
29021 
    return
29022 
 
29023 
 
29024 
  def __repr__(self):
29025 
    L = ['%s=%r' % (key, value)
29026 
      for key, value in self.__dict__.iteritems()]
29027 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
29028 
 
29029 
  def __eq__(self, other):
29030 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
29031 
 
29032 
  def __ne__(self, other):
29033 
    return not (self == other)
29034 
 
29035 
class getRechargeOrdersForStatus_result:
29036 
  """
29037 
  Attributes:
29038 
   - success
29039 
  """
29040 
 
29041 
  thrift_spec = (
29042 
    (0, TType.LIST, 'success', (TType.STRUCT,(RechargeOrder, RechargeOrder.thrift_spec)), None, ), # 0
29043 
  )
29044 
 
29045 
  def __init__(self, success=None,):
29046 
    self.success = success
29047 
 
29048 
  def read(self, iprot):
29049 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
29050 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
29051 
      return
29052 
    iprot.readStructBegin()
29053 
    while True:
29054 
      (fname, ftype, fid) = iprot.readFieldBegin()
29055 
      if ftype == TType.STOP:
29056 
        break
29057 
      if fid == 0:
29058 
        if ftype == TType.LIST:
29059 
          self.success = []
6188 rajveer 29060 
          (_etype689, _size686) = iprot.readListBegin()
29061 
          for _i690 in xrange(_size686):
29062 
            _elem691 = RechargeOrder()
29063 
            _elem691.read(iprot)
29064 
            self.success.append(_elem691)
6154 rajveer 29065 
          iprot.readListEnd()
29066 
        else:
29067 
          iprot.skip(ftype)
29068 
      else:
29069 
        iprot.skip(ftype)
29070 
      iprot.readFieldEnd()
29071 
    iprot.readStructEnd()
29072 
 
29073 
  def write(self, oprot):
29074 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
29075 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
29076 
      return
29077 
    oprot.writeStructBegin('getRechargeOrdersForStatus_result')
29078 
    if self.success is not None:
29079 
      oprot.writeFieldBegin('success', TType.LIST, 0)
29080 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 29081 
      for iter692 in self.success:
29082 
        iter692.write(oprot)
6154 rajveer 29083 
      oprot.writeListEnd()
29084 
      oprot.writeFieldEnd()
29085 
    oprot.writeFieldStop()
29086 
    oprot.writeStructEnd()
29087 
 
29088 
  def validate(self):
29089 
    return
29090 
 
29091 
 
29092 
  def __repr__(self):
29093 
    L = ['%s=%r' % (key, value)
29094 
      for key, value in self.__dict__.iteritems()]
29095 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
29096 
 
29097 
  def __eq__(self, other):
29098 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
29099 
 
29100 
  def __ne__(self, other):
29101 
    return not (self == other)
6159 rajveer 29102 
 
29103 
class getPlansForOperator_args:
29104 
  """
29105 
  Attributes:
29106 
   - operatorId
29107 
  """
29108 
 
29109 
  thrift_spec = (
29110 
    None, # 0
29111 
    (1, TType.I64, 'operatorId', None, None, ), # 1
29112 
  )
29113 
 
29114 
  def __init__(self, operatorId=None,):
29115 
    self.operatorId = operatorId
29116 
 
29117 
  def read(self, iprot):
29118 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
29119 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
29120 
      return
29121 
    iprot.readStructBegin()
29122 
    while True:
29123 
      (fname, ftype, fid) = iprot.readFieldBegin()
29124 
      if ftype == TType.STOP:
29125 
        break
29126 
      if fid == 1:
29127 
        if ftype == TType.I64:
29128 
          self.operatorId = iprot.readI64();
29129 
        else:
29130 
          iprot.skip(ftype)
29131 
      else:
29132 
        iprot.skip(ftype)
29133 
      iprot.readFieldEnd()
29134 
    iprot.readStructEnd()
29135 
 
29136 
  def write(self, oprot):
29137 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
29138 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
29139 
      return
29140 
    oprot.writeStructBegin('getPlansForOperator_args')
29141 
    if self.operatorId is not None:
29142 
      oprot.writeFieldBegin('operatorId', TType.I64, 1)
29143 
      oprot.writeI64(self.operatorId)
29144 
      oprot.writeFieldEnd()
29145 
    oprot.writeFieldStop()
29146 
    oprot.writeStructEnd()
29147 
 
29148 
  def validate(self):
29149 
    return
29150 
 
29151 
 
29152 
  def __repr__(self):
29153 
    L = ['%s=%r' % (key, value)
29154 
      for key, value in self.__dict__.iteritems()]
29155 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
29156 
 
29157 
  def __eq__(self, other):
29158 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
29159 
 
29160 
  def __ne__(self, other):
29161 
    return not (self == other)
29162 
 
29163 
class getPlansForOperator_result:
29164 
  """
29165 
  Attributes:
29166 
   - success
29167 
  """
29168 
 
29169 
  thrift_spec = (
29170 
    (0, TType.LIST, 'success', (TType.STRUCT,(RechargePlan, RechargePlan.thrift_spec)), None, ), # 0
29171 
  )
29172 
 
29173 
  def __init__(self, success=None,):
29174 
    self.success = success
29175 
 
29176 
  def read(self, iprot):
29177 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
29178 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
29179 
      return
29180 
    iprot.readStructBegin()
29181 
    while True:
29182 
      (fname, ftype, fid) = iprot.readFieldBegin()
29183 
      if ftype == TType.STOP:
29184 
        break
29185 
      if fid == 0:
29186 
        if ftype == TType.LIST:
29187 
          self.success = []
6188 rajveer 29188 
          (_etype696, _size693) = iprot.readListBegin()
29189 
          for _i697 in xrange(_size693):
29190 
            _elem698 = RechargePlan()
29191 
            _elem698.read(iprot)
29192 
            self.success.append(_elem698)
6159 rajveer 29193 
          iprot.readListEnd()
29194 
        else:
29195 
          iprot.skip(ftype)
29196 
      else:
29197 
        iprot.skip(ftype)
29198 
      iprot.readFieldEnd()
29199 
    iprot.readStructEnd()
29200 
 
29201 
  def write(self, oprot):
29202 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
29203 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
29204 
      return
29205 
    oprot.writeStructBegin('getPlansForOperator_result')
29206 
    if self.success is not None:
29207 
      oprot.writeFieldBegin('success', TType.LIST, 0)
29208 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 29209 
      for iter699 in self.success:
29210 
        iter699.write(oprot)
6159 rajveer 29211 
      oprot.writeListEnd()
29212 
      oprot.writeFieldEnd()
29213 
    oprot.writeFieldStop()
29214 
    oprot.writeStructEnd()
29215 
 
29216 
  def validate(self):
29217 
    return
29218 
 
29219 
 
29220 
  def __repr__(self):
29221 
    L = ['%s=%r' % (key, value)
29222 
      for key, value in self.__dict__.iteritems()]
29223 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
29224 
 
29225 
  def __eq__(self, other):
29226 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
29227 
 
29228 
  def __ne__(self, other):
29229 
    return not (self == other)
6289 anupam.sin 29230 
 
29231 
class getRechargeDenominations_args:
29232 
  """
29233 
  Attributes:
29234 
   - operatorId
6307 anupam.sin 29235 
   - circleCode
6289 anupam.sin 29236 
   - denominationType
29237 
  """
29238 
 
29239 
  thrift_spec = (
29240 
    None, # 0
29241 
    (1, TType.I64, 'operatorId', None, None, ), # 1
6307 anupam.sin 29242 
    (2, TType.STRING, 'circleCode', None, None, ), # 2
6289 anupam.sin 29243 
    (3, TType.I32, 'denominationType', None, None, ), # 3
29244 
  )
29245 
 
6307 anupam.sin 29246 
  def __init__(self, operatorId=None, circleCode=None, denominationType=None,):
6289 anupam.sin 29247 
    self.operatorId = operatorId
6307 anupam.sin 29248 
    self.circleCode = circleCode
6289 anupam.sin 29249 
    self.denominationType = denominationType
29250 
 
29251 
  def read(self, iprot):
29252 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
29253 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
29254 
      return
29255 
    iprot.readStructBegin()
29256 
    while True:
29257 
      (fname, ftype, fid) = iprot.readFieldBegin()
29258 
      if ftype == TType.STOP:
29259 
        break
29260 
      if fid == 1:
29261 
        if ftype == TType.I64:
29262 
          self.operatorId = iprot.readI64();
29263 
        else:
29264 
          iprot.skip(ftype)
29265 
      elif fid == 2:
29266 
        if ftype == TType.STRING:
6307 anupam.sin 29267 
          self.circleCode = iprot.readString();
6289 anupam.sin 29268 
        else:
29269 
          iprot.skip(ftype)
29270 
      elif fid == 3:
29271 
        if ftype == TType.I32:
29272 
          self.denominationType = iprot.readI32();
29273 
        else:
29274 
          iprot.skip(ftype)
29275 
      else:
29276 
        iprot.skip(ftype)
29277 
      iprot.readFieldEnd()
29278 
    iprot.readStructEnd()
29279 
 
29280 
  def write(self, oprot):
29281 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
29282 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
29283 
      return
29284 
    oprot.writeStructBegin('getRechargeDenominations_args')
29285 
    if self.operatorId is not None:
29286 
      oprot.writeFieldBegin('operatorId', TType.I64, 1)
29287 
      oprot.writeI64(self.operatorId)
29288 
      oprot.writeFieldEnd()
6307 anupam.sin 29289 
    if self.circleCode is not None:
29290 
      oprot.writeFieldBegin('circleCode', TType.STRING, 2)
29291 
      oprot.writeString(self.circleCode)
6289 anupam.sin 29292 
      oprot.writeFieldEnd()
29293 
    if self.denominationType is not None:
29294 
      oprot.writeFieldBegin('denominationType', TType.I32, 3)
29295 
      oprot.writeI32(self.denominationType)
29296 
      oprot.writeFieldEnd()
29297 
    oprot.writeFieldStop()
29298 
    oprot.writeStructEnd()
29299 
 
29300 
  def validate(self):
29301 
    return
29302 
 
29303 
 
29304 
  def __repr__(self):
29305 
    L = ['%s=%r' % (key, value)
29306 
      for key, value in self.__dict__.iteritems()]
29307 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
29308 
 
29309 
  def __eq__(self, other):
29310 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
29311 
 
29312 
  def __ne__(self, other):
29313 
    return not (self == other)
29314 
 
29315 
class getRechargeDenominations_result:
29316 
  """
29317 
  Attributes:
29318 
   - success
29319 
   - ex
29320 
  """
29321 
 
29322 
  thrift_spec = (
29323 
    (0, TType.LIST, 'success', (TType.STRUCT,(RechargeDenomination, RechargeDenomination.thrift_spec)), None, ), # 0
29324 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
29325 
  )
29326 
 
29327 
  def __init__(self, success=None, ex=None,):
29328 
    self.success = success
29329 
    self.ex = ex
29330 
 
29331 
  def read(self, iprot):
29332 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
29333 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
29334 
      return
29335 
    iprot.readStructBegin()
29336 
    while True:
29337 
      (fname, ftype, fid) = iprot.readFieldBegin()
29338 
      if ftype == TType.STOP:
29339 
        break
29340 
      if fid == 0:
29341 
        if ftype == TType.LIST:
29342 
          self.success = []
29343 
          (_etype703, _size700) = iprot.readListBegin()
29344 
          for _i704 in xrange(_size700):
29345 
            _elem705 = RechargeDenomination()
29346 
            _elem705.read(iprot)
29347 
            self.success.append(_elem705)
29348 
          iprot.readListEnd()
29349 
        else:
29350 
          iprot.skip(ftype)
29351 
      elif fid == 1:
29352 
        if ftype == TType.STRUCT:
29353 
          self.ex = TransactionServiceException()
29354 
          self.ex.read(iprot)
29355 
        else:
29356 
          iprot.skip(ftype)
29357 
      else:
29358 
        iprot.skip(ftype)
29359 
      iprot.readFieldEnd()
29360 
    iprot.readStructEnd()
29361 
 
29362 
  def write(self, oprot):
29363 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
29364 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
29365 
      return
29366 
    oprot.writeStructBegin('getRechargeDenominations_result')
29367 
    if self.success is not None:
29368 
      oprot.writeFieldBegin('success', TType.LIST, 0)
29369 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
29370 
      for iter706 in self.success:
29371 
        iter706.write(oprot)
29372 
      oprot.writeListEnd()
29373 
      oprot.writeFieldEnd()
29374 
    if self.ex is not None:
29375 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
29376 
      self.ex.write(oprot)
29377 
      oprot.writeFieldEnd()
29378 
    oprot.writeFieldStop()
29379 
    oprot.writeStructEnd()
29380 
 
29381 
  def validate(self):
29382 
    return
29383 
 
29384 
 
29385 
  def __repr__(self):
29386 
    L = ['%s=%r' % (key, value)
29387 
      for key, value in self.__dict__.iteritems()]
29388 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
29389 
 
29390 
  def __eq__(self, other):
29391 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
29392 
 
29393 
  def __ne__(self, other):
29394 
    return not (self == other)
6371 rajveer 29395 
 
29396 
class updateAvailabilityStatus_args:
29397 
  """
29398 
  Attributes:
29399 
   - operatorId
29400 
   - circleId
29401 
   - isAvailable
29402 
  """
29403 
 
29404 
  thrift_spec = (
29405 
    None, # 0
29406 
    (1, TType.I64, 'operatorId', None, None, ), # 1
29407 
    (2, TType.I64, 'circleId', None, None, ), # 2
29408 
    (3, TType.BOOL, 'isAvailable', None, None, ), # 3
29409 
  )
29410 
 
29411 
  def __init__(self, operatorId=None, circleId=None, isAvailable=None,):
29412 
    self.operatorId = operatorId
29413 
    self.circleId = circleId
29414 
    self.isAvailable = isAvailable
29415 
 
29416 
  def read(self, iprot):
29417 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
29418 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
29419 
      return
29420 
    iprot.readStructBegin()
29421 
    while True:
29422 
      (fname, ftype, fid) = iprot.readFieldBegin()
29423 
      if ftype == TType.STOP:
29424 
        break
29425 
      if fid == 1:
29426 
        if ftype == TType.I64:
29427 
          self.operatorId = iprot.readI64();
29428 
        else:
29429 
          iprot.skip(ftype)
29430 
      elif fid == 2:
29431 
        if ftype == TType.I64:
29432 
          self.circleId = iprot.readI64();
29433 
        else:
29434 
          iprot.skip(ftype)
29435 
      elif fid == 3:
29436 
        if ftype == TType.BOOL:
29437 
          self.isAvailable = iprot.readBool();
29438 
        else:
29439 
          iprot.skip(ftype)
29440 
      else:
29441 
        iprot.skip(ftype)
29442 
      iprot.readFieldEnd()
29443 
    iprot.readStructEnd()
29444 
 
29445 
  def write(self, oprot):
29446 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
29447 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
29448 
      return
29449 
    oprot.writeStructBegin('updateAvailabilityStatus_args')
29450 
    if self.operatorId is not None:
29451 
      oprot.writeFieldBegin('operatorId', TType.I64, 1)
29452 
      oprot.writeI64(self.operatorId)
29453 
      oprot.writeFieldEnd()
29454 
    if self.circleId is not None:
29455 
      oprot.writeFieldBegin('circleId', TType.I64, 2)
29456 
      oprot.writeI64(self.circleId)
29457 
      oprot.writeFieldEnd()
29458 
    if self.isAvailable is not None:
29459 
      oprot.writeFieldBegin('isAvailable', TType.BOOL, 3)
29460 
      oprot.writeBool(self.isAvailable)
29461 
      oprot.writeFieldEnd()
29462 
    oprot.writeFieldStop()
29463 
    oprot.writeStructEnd()
29464 
 
29465 
  def validate(self):
29466 
    return
29467 
 
29468 
 
29469 
  def __repr__(self):
29470 
    L = ['%s=%r' % (key, value)
29471 
      for key, value in self.__dict__.iteritems()]
29472 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
29473 
 
29474 
  def __eq__(self, other):
29475 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
29476 
 
29477 
  def __ne__(self, other):
29478 
    return not (self == other)
29479 
 
29480 
class updateAvailabilityStatus_result:
29481 
 
29482 
  thrift_spec = (
29483 
  )
29484 
 
29485 
  def read(self, iprot):
29486 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
29487 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
29488 
      return
29489 
    iprot.readStructBegin()
29490 
    while True:
29491 
      (fname, ftype, fid) = iprot.readFieldBegin()
29492 
      if ftype == TType.STOP:
29493 
        break
29494 
      else:
29495 
        iprot.skip(ftype)
29496 
      iprot.readFieldEnd()
29497 
    iprot.readStructEnd()
29498 
 
29499 
  def write(self, oprot):
29500 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
29501 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
29502 
      return
29503 
    oprot.writeStructBegin('updateAvailabilityStatus_result')
29504 
    oprot.writeFieldStop()
29505 
    oprot.writeStructEnd()
29506 
 
29507 
  def validate(self):
29508 
    return
29509 
 
29510 
 
29511 
  def __repr__(self):
29512 
    L = ['%s=%r' % (key, value)
29513 
      for key, value in self.__dict__.iteritems()]
29514 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
29515 
 
29516 
  def __eq__(self, other):
29517 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
29518 
 
29519 
  def __ne__(self, other):
29520 
    return not (self == other)
6389 rajveer 29521 
 
29522 
class getAvailableEmiSchemes_args:
29523 
 
29524 
  thrift_spec = (
29525 
  )
29526 
 
29527 
  def read(self, iprot):
29528 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
29529 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
29530 
      return
29531 
    iprot.readStructBegin()
29532 
    while True:
29533 
      (fname, ftype, fid) = iprot.readFieldBegin()
29534 
      if ftype == TType.STOP:
29535 
        break
29536 
      else:
29537 
        iprot.skip(ftype)
29538 
      iprot.readFieldEnd()
29539 
    iprot.readStructEnd()
29540 
 
29541 
  def write(self, oprot):
29542 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
29543 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
29544 
      return
29545 
    oprot.writeStructBegin('getAvailableEmiSchemes_args')
29546 
    oprot.writeFieldStop()
29547 
    oprot.writeStructEnd()
29548 
 
29549 
  def validate(self):
29550 
    return
29551 
 
29552 
 
29553 
  def __repr__(self):
29554 
    L = ['%s=%r' % (key, value)
29555 
      for key, value in self.__dict__.iteritems()]
29556 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
29557 
 
29558 
  def __eq__(self, other):
29559 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
29560 
 
29561 
  def __ne__(self, other):
29562 
    return not (self == other)
29563 
 
29564 
class getAvailableEmiSchemes_result:
29565 
  """
29566 
  Attributes:
29567 
   - success
29568 
  """
29569 
 
29570 
  thrift_spec = (
29571 
    (0, TType.LIST, 'success', (TType.STRUCT,(EmiScheme, EmiScheme.thrift_spec)), None, ), # 0
29572 
  )
29573 
 
29574 
  def __init__(self, success=None,):
29575 
    self.success = success
29576 
 
29577 
  def read(self, iprot):
29578 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
29579 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
29580 
      return
29581 
    iprot.readStructBegin()
29582 
    while True:
29583 
      (fname, ftype, fid) = iprot.readFieldBegin()
29584 
      if ftype == TType.STOP:
29585 
        break
29586 
      if fid == 0:
29587 
        if ftype == TType.LIST:
29588 
          self.success = []
29589 
          (_etype710, _size707) = iprot.readListBegin()
29590 
          for _i711 in xrange(_size707):
29591 
            _elem712 = EmiScheme()
29592 
            _elem712.read(iprot)
29593 
            self.success.append(_elem712)
29594 
          iprot.readListEnd()
29595 
        else:
29596 
          iprot.skip(ftype)
29597 
      else:
29598 
        iprot.skip(ftype)
29599 
      iprot.readFieldEnd()
29600 
    iprot.readStructEnd()
29601 
 
29602 
  def write(self, oprot):
29603 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
29604 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
29605 
      return
29606 
    oprot.writeStructBegin('getAvailableEmiSchemes_result')
29607 
    if self.success is not None:
29608 
      oprot.writeFieldBegin('success', TType.LIST, 0)
29609 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
29610 
      for iter713 in self.success:
29611 
        iter713.write(oprot)
29612 
      oprot.writeListEnd()
29613 
      oprot.writeFieldEnd()
29614 
    oprot.writeFieldStop()
29615 
    oprot.writeStructEnd()
29616 
 
29617 
  def validate(self):
29618 
    return
29619 
 
29620 
 
29621 
  def __repr__(self):
29622 
    L = ['%s=%r' % (key, value)
29623 
      for key, value in self.__dict__.iteritems()]
29624 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
29625 
 
29626 
  def __eq__(self, other):
29627 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
29628 
 
29629 
  def __ne__(self, other):
29630 
    return not (self == other)
29631 
 
29632 
class getMiscCharges_args:
29633 
  """
29634 
  Attributes:
29635 
   - transactionId
29636 
  """
29637 
 
29638 
  thrift_spec = (
29639 
    None, # 0
29640 
    (1, TType.I64, 'transactionId', None, None, ), # 1
29641 
  )
29642 
 
29643 
  def __init__(self, transactionId=None,):
29644 
    self.transactionId = transactionId
29645 
 
29646 
  def read(self, iprot):
29647 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
29648 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
29649 
      return
29650 
    iprot.readStructBegin()
29651 
    while True:
29652 
      (fname, ftype, fid) = iprot.readFieldBegin()
29653 
      if ftype == TType.STOP:
29654 
        break
29655 
      if fid == 1:
29656 
        if ftype == TType.I64:
29657 
          self.transactionId = iprot.readI64();
29658 
        else:
29659 
          iprot.skip(ftype)
29660 
      else:
29661 
        iprot.skip(ftype)
29662 
      iprot.readFieldEnd()
29663 
    iprot.readStructEnd()
29664 
 
29665 
  def write(self, oprot):
29666 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
29667 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
29668 
      return
29669 
    oprot.writeStructBegin('getMiscCharges_args')
29670 
    if self.transactionId is not None:
29671 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
29672 
      oprot.writeI64(self.transactionId)
29673 
      oprot.writeFieldEnd()
29674 
    oprot.writeFieldStop()
29675 
    oprot.writeStructEnd()
29676 
 
29677 
  def validate(self):
29678 
    return
29679 
 
29680 
 
29681 
  def __repr__(self):
29682 
    L = ['%s=%r' % (key, value)
29683 
      for key, value in self.__dict__.iteritems()]
29684 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
29685 
 
29686 
  def __eq__(self, other):
29687 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
29688 
 
29689 
  def __ne__(self, other):
29690 
    return not (self == other)
29691 
 
29692 
class getMiscCharges_result:
29693 
  """
29694 
  Attributes:
29695 
   - success
29696 
  """
29697 
 
29698 
  thrift_spec = (
6412 rajveer 29699 
    (0, TType.MAP, 'success', (TType.I64,None,TType.DOUBLE,None), None, ), # 0
6389 rajveer 29700 
  )
29701 
 
29702 
  def __init__(self, success=None,):
29703 
    self.success = success
29704 
 
29705 
  def read(self, iprot):
29706 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
29707 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
29708 
      return
29709 
    iprot.readStructBegin()
29710 
    while True:
29711 
      (fname, ftype, fid) = iprot.readFieldBegin()
29712 
      if ftype == TType.STOP:
29713 
        break
29714 
      if fid == 0:
29715 
        if ftype == TType.MAP:
29716 
          self.success = {}
29717 
          (_ktype715, _vtype716, _size714 ) = iprot.readMapBegin()
29718 
          for _i718 in xrange(_size714):
29719 
            _key719 = iprot.readI64();
6412 rajveer 29720 
            _val720 = iprot.readDouble();
6389 rajveer 29721 
            self.success[_key719] = _val720
29722 
          iprot.readMapEnd()
29723 
        else:
29724 
          iprot.skip(ftype)
29725 
      else:
29726 
        iprot.skip(ftype)
29727 
      iprot.readFieldEnd()
29728 
    iprot.readStructEnd()
29729 
 
29730 
  def write(self, oprot):
29731 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
29732 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
29733 
      return
29734 
    oprot.writeStructBegin('getMiscCharges_result')
29735 
    if self.success is not None:
29736 
      oprot.writeFieldBegin('success', TType.MAP, 0)
6412 rajveer 29737 
      oprot.writeMapBegin(TType.I64, TType.DOUBLE, len(self.success))
6389 rajveer 29738 
      for kiter721,viter722 in self.success.items():
29739 
        oprot.writeI64(kiter721)
6412 rajveer 29740 
        oprot.writeDouble(viter722)
6389 rajveer 29741 
      oprot.writeMapEnd()
29742 
      oprot.writeFieldEnd()
29743 
    oprot.writeFieldStop()
29744 
    oprot.writeStructEnd()
29745 
 
29746 
  def validate(self):
29747 
    return
29748 
 
29749 
 
29750 
  def __repr__(self):
29751 
    L = ['%s=%r' % (key, value)
29752 
      for key, value in self.__dict__.iteritems()]
29753 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
29754 
 
29755 
  def __eq__(self, other):
29756 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
29757 
 
29758 
  def __ne__(self, other):
29759 
    return not (self == other)
6507 anupam.sin 29760 
 
29761 
class refundRechargeOrder_args:
29762 
  """
29763 
  Attributes:
29764 
   - rechargeOrderId
29765 
  """
29766 
 
29767 
  thrift_spec = (
29768 
    None, # 0
29769 
    (1, TType.I64, 'rechargeOrderId', None, None, ), # 1
29770 
  )
29771 
 
29772 
  def __init__(self, rechargeOrderId=None,):
29773 
    self.rechargeOrderId = rechargeOrderId
29774 
 
29775 
  def read(self, iprot):
29776 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
29777 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
29778 
      return
29779 
    iprot.readStructBegin()
29780 
    while True:
29781 
      (fname, ftype, fid) = iprot.readFieldBegin()
29782 
      if ftype == TType.STOP:
29783 
        break
29784 
      if fid == 1:
29785 
        if ftype == TType.I64:
29786 
          self.rechargeOrderId = iprot.readI64();
29787 
        else:
29788 
          iprot.skip(ftype)
29789 
      else:
29790 
        iprot.skip(ftype)
29791 
      iprot.readFieldEnd()
29792 
    iprot.readStructEnd()
29793 
 
29794 
  def write(self, oprot):
29795 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
29796 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
29797 
      return
29798 
    oprot.writeStructBegin('refundRechargeOrder_args')
29799 
    if self.rechargeOrderId is not None:
29800 
      oprot.writeFieldBegin('rechargeOrderId', TType.I64, 1)
29801 
      oprot.writeI64(self.rechargeOrderId)
29802 
      oprot.writeFieldEnd()
29803 
    oprot.writeFieldStop()
29804 
    oprot.writeStructEnd()
29805 
 
29806 
  def validate(self):
29807 
    return
29808 
 
29809 
 
29810 
  def __repr__(self):
29811 
    L = ['%s=%r' % (key, value)
29812 
      for key, value in self.__dict__.iteritems()]
29813 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
29814 
 
29815 
  def __eq__(self, other):
29816 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
29817 
 
29818 
  def __ne__(self, other):
29819 
    return not (self == other)
29820 
 
29821 
class refundRechargeOrder_result:
29822 
  """
29823 
  Attributes:
29824 
   - success
29825 
   - ex
29826 
  """
29827 
 
29828 
  thrift_spec = (
29829 
    (0, TType.BOOL, 'success', None, None, ), # 0
29830 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
29831 
  )
29832 
 
29833 
  def __init__(self, success=None, ex=None,):
29834 
    self.success = success
29835 
    self.ex = ex
29836 
 
29837 
  def read(self, iprot):
29838 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
29839 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
29840 
      return
29841 
    iprot.readStructBegin()
29842 
    while True:
29843 
      (fname, ftype, fid) = iprot.readFieldBegin()
29844 
      if ftype == TType.STOP:
29845 
        break
29846 
      if fid == 0:
29847 
        if ftype == TType.BOOL:
29848 
          self.success = iprot.readBool();
29849 
        else:
29850 
          iprot.skip(ftype)
29851 
      elif fid == 1:
29852 
        if ftype == TType.STRUCT:
29853 
          self.ex = TransactionServiceException()
29854 
          self.ex.read(iprot)
29855 
        else:
29856 
          iprot.skip(ftype)
29857 
      else:
29858 
        iprot.skip(ftype)
29859 
      iprot.readFieldEnd()
29860 
    iprot.readStructEnd()
29861 
 
29862 
  def write(self, oprot):
29863 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
29864 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
29865 
      return
29866 
    oprot.writeStructBegin('refundRechargeOrder_result')
29867 
    if self.success is not None:
29868 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
29869 
      oprot.writeBool(self.success)
29870 
      oprot.writeFieldEnd()
29871 
    if self.ex is not None:
29872 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
29873 
      self.ex.write(oprot)
29874 
      oprot.writeFieldEnd()
29875 
    oprot.writeFieldStop()
29876 
    oprot.writeStructEnd()
29877 
 
29878 
  def validate(self):
29879 
    return
29880 
 
29881 
 
29882 
  def __repr__(self):
29883 
    L = ['%s=%r' % (key, value)
29884 
      for key, value in self.__dict__.iteritems()]
29885 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
29886 
 
29887 
  def __eq__(self, other):
29888 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
29889 
 
29890 
  def __ne__(self, other):
29891 
    return not (self == other)
6821 amar.kumar 29892 
 
29893 
class getPhysicalOrders_args:
29894 
  """
29895 
  Attributes:
29896 
   - fromDate
29897 
   - toDate
29898 
  """
29899 
 
29900 
  thrift_spec = (
29901 
    None, # 0
29902 
    (1, TType.I64, 'fromDate', None, None, ), # 1
29903 
    (2, TType.I64, 'toDate', None, None, ), # 2
29904 
  )
29905 
 
29906 
  def __init__(self, fromDate=None, toDate=None,):
29907 
    self.fromDate = fromDate
29908 
    self.toDate = toDate
29909 
 
29910 
  def read(self, iprot):
29911 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
29912 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
29913 
      return
29914 
    iprot.readStructBegin()
29915 
    while True:
29916 
      (fname, ftype, fid) = iprot.readFieldBegin()
29917 
      if ftype == TType.STOP:
29918 
        break
29919 
      if fid == 1:
29920 
        if ftype == TType.I64:
29921 
          self.fromDate = iprot.readI64();
29922 
        else:
29923 
          iprot.skip(ftype)
29924 
      elif fid == 2:
29925 
        if ftype == TType.I64:
29926 
          self.toDate = iprot.readI64();
29927 
        else:
29928 
          iprot.skip(ftype)
29929 
      else:
29930 
        iprot.skip(ftype)
29931 
      iprot.readFieldEnd()
29932 
    iprot.readStructEnd()
29933 
 
29934 
  def write(self, oprot):
29935 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
29936 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
29937 
      return
29938 
    oprot.writeStructBegin('getPhysicalOrders_args')
29939 
    if self.fromDate is not None:
29940 
      oprot.writeFieldBegin('fromDate', TType.I64, 1)
29941 
      oprot.writeI64(self.fromDate)
29942 
      oprot.writeFieldEnd()
29943 
    if self.toDate is not None:
29944 
      oprot.writeFieldBegin('toDate', TType.I64, 2)
29945 
      oprot.writeI64(self.toDate)
29946 
      oprot.writeFieldEnd()
29947 
    oprot.writeFieldStop()
29948 
    oprot.writeStructEnd()
29949 
 
29950 
  def validate(self):
29951 
    return
29952 
 
29953 
 
29954 
  def __repr__(self):
29955 
    L = ['%s=%r' % (key, value)
29956 
      for key, value in self.__dict__.iteritems()]
29957 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
29958 
 
29959 
  def __eq__(self, other):
29960 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
29961 
 
29962 
  def __ne__(self, other):
29963 
    return not (self == other)
29964 
 
29965 
class getPhysicalOrders_result:
29966 
  """
29967 
  Attributes:
29968 
   - success
29969 
  """
29970 
 
29971 
  thrift_spec = (
29972 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
29973 
  )
29974 
 
29975 
  def __init__(self, success=None,):
29976 
    self.success = success
29977 
 
29978 
  def read(self, iprot):
29979 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
29980 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
29981 
      return
29982 
    iprot.readStructBegin()
29983 
    while True:
29984 
      (fname, ftype, fid) = iprot.readFieldBegin()
29985 
      if ftype == TType.STOP:
29986 
        break
29987 
      if fid == 0:
29988 
        if ftype == TType.LIST:
29989 
          self.success = []
29990 
          (_etype726, _size723) = iprot.readListBegin()
29991 
          for _i727 in xrange(_size723):
29992 
            _elem728 = Order()
29993 
            _elem728.read(iprot)
29994 
            self.success.append(_elem728)
29995 
          iprot.readListEnd()
29996 
        else:
29997 
          iprot.skip(ftype)
29998 
      else:
29999 
        iprot.skip(ftype)
30000 
      iprot.readFieldEnd()
30001 
    iprot.readStructEnd()
30002 
 
30003 
  def write(self, oprot):
30004 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
30005 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
30006 
      return
30007 
    oprot.writeStructBegin('getPhysicalOrders_result')
30008 
    if self.success is not None:
30009 
      oprot.writeFieldBegin('success', TType.LIST, 0)
30010 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
30011 
      for iter729 in self.success:
30012 
        iter729.write(oprot)
30013 
      oprot.writeListEnd()
30014 
      oprot.writeFieldEnd()
30015 
    oprot.writeFieldStop()
30016 
    oprot.writeStructEnd()
30017 
 
30018 
  def validate(self):
30019 
    return
30020 
 
30021 
 
30022 
  def __repr__(self):
30023 
    L = ['%s=%r' % (key, value)
30024 
      for key, value in self.__dict__.iteritems()]
30025 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
30026 
 
30027 
  def __eq__(self, other):
30028 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
30029 
 
30030 
  def __ne__(self, other):
30031 
    return not (self == other)
6906 rajveer 30032 
 
30033 
class getDocument_args:
30034 
  """
30035 
  Attributes:
30036 
   - docType
30037 
   - docSource
30038 
  """
30039 
 
30040 
  thrift_spec = (
30041 
    None, # 0
30042 
    (1, TType.I64, 'docType', None, None, ), # 1
30043 
    (2, TType.I64, 'docSource', None, None, ), # 2
30044 
  )
30045 
 
30046 
  def __init__(self, docType=None, docSource=None,):
30047 
    self.docType = docType
30048 
    self.docSource = docSource
30049 
 
30050 
  def read(self, iprot):
30051 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
30052 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
30053 
      return
30054 
    iprot.readStructBegin()
30055 
    while True:
30056 
      (fname, ftype, fid) = iprot.readFieldBegin()
30057 
      if ftype == TType.STOP:
30058 
        break
30059 
      if fid == 1:
30060 
        if ftype == TType.I64:
30061 
          self.docType = iprot.readI64();
30062 
        else:
30063 
          iprot.skip(ftype)
30064 
      elif fid == 2:
30065 
        if ftype == TType.I64:
30066 
          self.docSource = iprot.readI64();
30067 
        else:
30068 
          iprot.skip(ftype)
30069 
      else:
30070 
        iprot.skip(ftype)
30071 
      iprot.readFieldEnd()
30072 
    iprot.readStructEnd()
30073 
 
30074 
  def write(self, oprot):
30075 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
30076 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
30077 
      return
30078 
    oprot.writeStructBegin('getDocument_args')
30079 
    if self.docType is not None:
30080 
      oprot.writeFieldBegin('docType', TType.I64, 1)
30081 
      oprot.writeI64(self.docType)
30082 
      oprot.writeFieldEnd()
30083 
    if self.docSource is not None:
30084 
      oprot.writeFieldBegin('docSource', TType.I64, 2)
30085 
      oprot.writeI64(self.docSource)
30086 
      oprot.writeFieldEnd()
30087 
    oprot.writeFieldStop()
30088 
    oprot.writeStructEnd()
30089 
 
30090 
  def validate(self):
30091 
    return
30092 
 
30093 
 
30094 
  def __repr__(self):
30095 
    L = ['%s=%r' % (key, value)
30096 
      for key, value in self.__dict__.iteritems()]
30097 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
30098 
 
30099 
  def __eq__(self, other):
30100 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
30101 
 
30102 
  def __ne__(self, other):
30103 
    return not (self == other)
30104 
 
30105 
class getDocument_result:
30106 
  """
30107 
  Attributes:
30108 
   - success
30109 
  """
30110 
 
30111 
  thrift_spec = (
30112 
    (0, TType.STRING, 'success', None, None, ), # 0
30113 
  )
30114 
 
30115 
  def __init__(self, success=None,):
30116 
    self.success = success
30117 
 
30118 
  def read(self, iprot):
30119 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
30120 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
30121 
      return
30122 
    iprot.readStructBegin()
30123 
    while True:
30124 
      (fname, ftype, fid) = iprot.readFieldBegin()
30125 
      if ftype == TType.STOP:
30126 
        break
30127 
      if fid == 0:
30128 
        if ftype == TType.STRING:
30129 
          self.success = iprot.readString();
30130 
        else:
30131 
          iprot.skip(ftype)
30132 
      else:
30133 
        iprot.skip(ftype)
30134 
      iprot.readFieldEnd()
30135 
    iprot.readStructEnd()
30136 
 
30137 
  def write(self, oprot):
30138 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
30139 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
30140 
      return
30141 
    oprot.writeStructBegin('getDocument_result')
30142 
    if self.success is not None:
30143 
      oprot.writeFieldBegin('success', TType.STRING, 0)
30144 
      oprot.writeString(self.success)
30145 
      oprot.writeFieldEnd()
30146 
    oprot.writeFieldStop()
30147 
    oprot.writeStructEnd()
30148 
 
30149 
  def validate(self):
30150 
    return
30151 
 
30152 
 
30153 
  def __repr__(self):
30154 
    L = ['%s=%r' % (key, value)
30155 
      for key, value in self.__dict__.iteritems()]
30156 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
30157 
 
30158 
  def __eq__(self, other):
30159 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
30160 
 
30161 
  def __ne__(self, other):
30162 
    return not (self == other)
6985 anupam.sin 30163 
 
30164 
class changeShippingAddress_args:
30165 
  """
30166 
  Attributes:
30167 
   - orderId
30168 
   - line1
30169 
   - line2
30170 
   - city
30171 
   - state
30172 
   - pin
30173 
  """
30174 
 
30175 
  thrift_spec = (
30176 
    None, # 0
30177 
    (1, TType.I64, 'orderId', None, None, ), # 1
30178 
    (2, TType.STRING, 'line1', None, None, ), # 2
30179 
    (3, TType.STRING, 'line2', None, None, ), # 3
30180 
    (4, TType.STRING, 'city', None, None, ), # 4
30181 
    (5, TType.STRING, 'state', None, None, ), # 5
30182 
    (6, TType.STRING, 'pin', None, None, ), # 6
30183 
  )
30184 
 
30185 
  def __init__(self, orderId=None, line1=None, line2=None, city=None, state=None, pin=None,):
30186 
    self.orderId = orderId
30187 
    self.line1 = line1
30188 
    self.line2 = line2
30189 
    self.city = city
30190 
    self.state = state
30191 
    self.pin = pin
30192 
 
30193 
  def read(self, iprot):
30194 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
30195 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
30196 
      return
30197 
    iprot.readStructBegin()
30198 
    while True:
30199 
      (fname, ftype, fid) = iprot.readFieldBegin()
30200 
      if ftype == TType.STOP:
30201 
        break
30202 
      if fid == 1:
30203 
        if ftype == TType.I64:
30204 
          self.orderId = iprot.readI64();
30205 
        else:
30206 
          iprot.skip(ftype)
30207 
      elif fid == 2:
30208 
        if ftype == TType.STRING:
30209 
          self.line1 = iprot.readString();
30210 
        else:
30211 
          iprot.skip(ftype)
30212 
      elif fid == 3:
30213 
        if ftype == TType.STRING:
30214 
          self.line2 = iprot.readString();
30215 
        else:
30216 
          iprot.skip(ftype)
30217 
      elif fid == 4:
30218 
        if ftype == TType.STRING:
30219 
          self.city = iprot.readString();
30220 
        else:
30221 
          iprot.skip(ftype)
30222 
      elif fid == 5:
30223 
        if ftype == TType.STRING:
30224 
          self.state = iprot.readString();
30225 
        else:
30226 
          iprot.skip(ftype)
30227 
      elif fid == 6:
30228 
        if ftype == TType.STRING:
30229 
          self.pin = iprot.readString();
30230 
        else:
30231 
          iprot.skip(ftype)
30232 
      else:
30233 
        iprot.skip(ftype)
30234 
      iprot.readFieldEnd()
30235 
    iprot.readStructEnd()
30236 
 
30237 
  def write(self, oprot):
30238 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
30239 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
30240 
      return
30241 
    oprot.writeStructBegin('changeShippingAddress_args')
30242 
    if self.orderId is not None:
30243 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
30244 
      oprot.writeI64(self.orderId)
30245 
      oprot.writeFieldEnd()
30246 
    if self.line1 is not None:
30247 
      oprot.writeFieldBegin('line1', TType.STRING, 2)
30248 
      oprot.writeString(self.line1)
30249 
      oprot.writeFieldEnd()
30250 
    if self.line2 is not None:
30251 
      oprot.writeFieldBegin('line2', TType.STRING, 3)
30252 
      oprot.writeString(self.line2)
30253 
      oprot.writeFieldEnd()
30254 
    if self.city is not None:
30255 
      oprot.writeFieldBegin('city', TType.STRING, 4)
30256 
      oprot.writeString(self.city)
30257 
      oprot.writeFieldEnd()
30258 
    if self.state is not None:
30259 
      oprot.writeFieldBegin('state', TType.STRING, 5)
30260 
      oprot.writeString(self.state)
30261 
      oprot.writeFieldEnd()
30262 
    if self.pin is not None:
30263 
      oprot.writeFieldBegin('pin', TType.STRING, 6)
30264 
      oprot.writeString(self.pin)
30265 
      oprot.writeFieldEnd()
30266 
    oprot.writeFieldStop()
30267 
    oprot.writeStructEnd()
30268 
 
30269 
  def validate(self):
30270 
    return
30271 
 
30272 
 
30273 
  def __repr__(self):
30274 
    L = ['%s=%r' % (key, value)
30275 
      for key, value in self.__dict__.iteritems()]
30276 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
30277 
 
30278 
  def __eq__(self, other):
30279 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
30280 
 
30281 
  def __ne__(self, other):
30282 
    return not (self == other)
30283 
 
30284 
class changeShippingAddress_result:
30285 
  """
30286 
  Attributes:
30287 
   - success
30288 
  """
30289 
 
30290 
  thrift_spec = (
30291 
    (0, TType.BOOL, 'success', None, None, ), # 0
30292 
  )
30293 
 
30294 
  def __init__(self, success=None,):
30295 
    self.success = success
30296 
 
30297 
  def read(self, iprot):
30298 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
30299 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
30300 
      return
30301 
    iprot.readStructBegin()
30302 
    while True:
30303 
      (fname, ftype, fid) = iprot.readFieldBegin()
30304 
      if ftype == TType.STOP:
30305 
        break
30306 
      if fid == 0:
30307 
        if ftype == TType.BOOL:
30308 
          self.success = iprot.readBool();
30309 
        else:
30310 
          iprot.skip(ftype)
30311 
      else:
30312 
        iprot.skip(ftype)
30313 
      iprot.readFieldEnd()
30314 
    iprot.readStructEnd()
30315 
 
30316 
  def write(self, oprot):
30317 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
30318 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
30319 
      return
30320 
    oprot.writeStructBegin('changeShippingAddress_result')
30321 
    if self.success is not None:
30322 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
30323 
      oprot.writeBool(self.success)
30324 
      oprot.writeFieldEnd()
30325 
    oprot.writeFieldStop()
30326 
    oprot.writeStructEnd()
30327 
 
30328 
  def validate(self):
30329 
    return
30330 
 
30331 
 
30332 
  def __repr__(self):
30333 
    L = ['%s=%r' % (key, value)
30334 
      for key, value in self.__dict__.iteritems()]
30335 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
30336 
 
30337 
  def __eq__(self, other):
30338 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
30339 
 
30340 
  def __ne__(self, other):
30341 
    return not (self == other)
6988 rajveer 30342 
 
30343 
class retrieveInvoice_args:
30344 
  """
30345 
  Attributes:
30346 
   - orderId
7075 rajveer 30347 
   - userId
6988 rajveer 30348 
  """
30349 
 
30350 
  thrift_spec = (
30351 
    None, # 0
30352 
    (1, TType.I64, 'orderId', None, None, ), # 1
7075 rajveer 30353 
    (2, TType.I64, 'userId', None, None, ), # 2
6988 rajveer 30354 
  )
30355 
 
7075 rajveer 30356 
  def __init__(self, orderId=None, userId=None,):
6988 rajveer 30357 
    self.orderId = orderId
7075 rajveer 30358 
    self.userId = userId
6988 rajveer 30359 
 
30360 
  def read(self, iprot):
30361 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
30362 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
30363 
      return
30364 
    iprot.readStructBegin()
30365 
    while True:
30366 
      (fname, ftype, fid) = iprot.readFieldBegin()
30367 
      if ftype == TType.STOP:
30368 
        break
30369 
      if fid == 1:
30370 
        if ftype == TType.I64:
30371 
          self.orderId = iprot.readI64();
30372 
        else:
30373 
          iprot.skip(ftype)
7075 rajveer 30374 
      elif fid == 2:
30375 
        if ftype == TType.I64:
30376 
          self.userId = iprot.readI64();
30377 
        else:
30378 
          iprot.skip(ftype)
6988 rajveer 30379 
      else:
30380 
        iprot.skip(ftype)
30381 
      iprot.readFieldEnd()
30382 
    iprot.readStructEnd()
30383 
 
30384 
  def write(self, oprot):
30385 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
30386 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
30387 
      return
30388 
    oprot.writeStructBegin('retrieveInvoice_args')
30389 
    if self.orderId is not None:
30390 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
30391 
      oprot.writeI64(self.orderId)
30392 
      oprot.writeFieldEnd()
7075 rajveer 30393 
    if self.userId is not None:
30394 
      oprot.writeFieldBegin('userId', TType.I64, 2)
30395 
      oprot.writeI64(self.userId)
30396 
      oprot.writeFieldEnd()
6988 rajveer 30397 
    oprot.writeFieldStop()
30398 
    oprot.writeStructEnd()
30399 
 
30400 
  def validate(self):
30401 
    return
30402 
 
30403 
 
30404 
  def __repr__(self):
30405 
    L = ['%s=%r' % (key, value)
30406 
      for key, value in self.__dict__.iteritems()]
30407 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
30408 
 
30409 
  def __eq__(self, other):
30410 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
30411 
 
30412 
  def __ne__(self, other):
30413 
    return not (self == other)
30414 
 
30415 
class retrieveInvoice_result:
30416 
  """
30417 
  Attributes:
30418 
   - success
30419 
  """
30420 
 
30421 
  thrift_spec = (
30422 
    (0, TType.STRING, 'success', None, None, ), # 0
30423 
  )
30424 
 
30425 
  def __init__(self, success=None,):
30426 
    self.success = success
30427 
 
30428 
  def read(self, iprot):
30429 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
30430 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
30431 
      return
30432 
    iprot.readStructBegin()
30433 
    while True:
30434 
      (fname, ftype, fid) = iprot.readFieldBegin()
30435 
      if ftype == TType.STOP:
30436 
        break
30437 
      if fid == 0:
30438 
        if ftype == TType.STRING:
30439 
          self.success = iprot.readString();
30440 
        else:
30441 
          iprot.skip(ftype)
30442 
      else:
30443 
        iprot.skip(ftype)
30444 
      iprot.readFieldEnd()
30445 
    iprot.readStructEnd()
30446 
 
30447 
  def write(self, oprot):
30448 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
30449 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
30450 
      return
30451 
    oprot.writeStructBegin('retrieveInvoice_result')
30452 
    if self.success is not None:
30453 
      oprot.writeFieldBegin('success', TType.STRING, 0)
30454 
      oprot.writeString(self.success)
30455 
      oprot.writeFieldEnd()
30456 
    oprot.writeFieldStop()
30457 
    oprot.writeStructEnd()
30458 
 
30459 
  def validate(self):
30460 
    return
30461 
 
30462 
 
30463 
  def __repr__(self):
30464 
    L = ['%s=%r' % (key, value)
30465 
      for key, value in self.__dict__.iteritems()]
30466 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
30467 
 
30468 
  def __eq__(self, other):
30469 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
30470 
 
30471 
  def __ne__(self, other):
30472 
    return not (self == other)
7026 rajveer 30473 
 
30474 
class receiveUpdatesForRedExpress_args:
30475 
  """
30476 
  Attributes:
30477 
   - awbNumber
30478 
  """
30479 
 
30480 
  thrift_spec = (
30481 
    None, # 0
30482 
    (1, TType.STRING, 'awbNumber', None, None, ), # 1
30483 
  )
30484 
 
30485 
  def __init__(self, awbNumber=None,):
30486 
    self.awbNumber = awbNumber
30487 
 
30488 
  def read(self, iprot):
30489 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
30490 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
30491 
      return
30492 
    iprot.readStructBegin()
30493 
    while True:
30494 
      (fname, ftype, fid) = iprot.readFieldBegin()
30495 
      if ftype == TType.STOP:
30496 
        break
30497 
      if fid == 1:
30498 
        if ftype == TType.STRING:
30499 
          self.awbNumber = iprot.readString();
30500 
        else:
30501 
          iprot.skip(ftype)
30502 
      else:
30503 
        iprot.skip(ftype)
30504 
      iprot.readFieldEnd()
30505 
    iprot.readStructEnd()
30506 
 
30507 
  def write(self, oprot):
30508 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
30509 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
30510 
      return
30511 
    oprot.writeStructBegin('receiveUpdatesForRedExpress_args')
30512 
    if self.awbNumber is not None:
30513 
      oprot.writeFieldBegin('awbNumber', TType.STRING, 1)
30514 
      oprot.writeString(self.awbNumber)
30515 
      oprot.writeFieldEnd()
30516 
    oprot.writeFieldStop()
30517 
    oprot.writeStructEnd()
30518 
 
30519 
  def validate(self):
30520 
    return
30521 
 
30522 
 
30523 
  def __repr__(self):
30524 
    L = ['%s=%r' % (key, value)
30525 
      for key, value in self.__dict__.iteritems()]
30526 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
30527 
 
30528 
  def __eq__(self, other):
30529 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
30530 
 
30531 
  def __ne__(self, other):
30532 
    return not (self == other)
30533 
 
30534 
class receiveUpdatesForRedExpress_result:
30535 
  """
30536 
  Attributes:
30537 
   - success
30538 
  """
30539 
 
30540 
  thrift_spec = (
30541 
    (0, TType.LIST, 'success', (TType.STRING,None), None, ), # 0
30542 
  )
30543 
 
30544 
  def __init__(self, success=None,):
30545 
    self.success = success
30546 
 
30547 
  def read(self, iprot):
30548 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
30549 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
30550 
      return
30551 
    iprot.readStructBegin()
30552 
    while True:
30553 
      (fname, ftype, fid) = iprot.readFieldBegin()
30554 
      if ftype == TType.STOP:
30555 
        break
30556 
      if fid == 0:
30557 
        if ftype == TType.LIST:
30558 
          self.success = []
30559 
          (_etype733, _size730) = iprot.readListBegin()
30560 
          for _i734 in xrange(_size730):
30561 
            _elem735 = iprot.readString();
30562 
            self.success.append(_elem735)
30563 
          iprot.readListEnd()
30564 
        else:
30565 
          iprot.skip(ftype)
30566 
      else:
30567 
        iprot.skip(ftype)
30568 
      iprot.readFieldEnd()
30569 
    iprot.readStructEnd()
30570 
 
30571 
  def write(self, oprot):
30572 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
30573 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
30574 
      return
30575 
    oprot.writeStructBegin('receiveUpdatesForRedExpress_result')
30576 
    if self.success is not None:
30577 
      oprot.writeFieldBegin('success', TType.LIST, 0)
30578 
      oprot.writeListBegin(TType.STRING, len(self.success))
30579 
      for iter736 in self.success:
30580 
        oprot.writeString(iter736)
30581 
      oprot.writeListEnd()
30582 
      oprot.writeFieldEnd()
30583 
    oprot.writeFieldStop()
30584 
    oprot.writeStructEnd()
30585 
 
30586 
  def validate(self):
30587 
    return
30588 
 
30589 
 
30590 
  def __repr__(self):
30591 
    L = ['%s=%r' % (key, value)
30592 
      for key, value in self.__dict__.iteritems()]
30593 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
30594 
 
30595 
  def __eq__(self, other):
30596 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
30597 
 
30598 
  def __ne__(self, other):
30599 
    return not (self == other)
7073 anupam.sin 30600 
 
30601 
class createRechargeTransaction_args:
30602 
  """
30603 
  Attributes:
30604 
   - thriftRechargeTransaction
30605 
  """
30606 
 
30607 
  thrift_spec = (
30608 
    None, # 0
30609 
    (1, TType.STRUCT, 'thriftRechargeTransaction', (RechargeTransaction, RechargeTransaction.thrift_spec), None, ), # 1
30610 
  )
30611 
 
30612 
  def __init__(self, thriftRechargeTransaction=None,):
30613 
    self.thriftRechargeTransaction = thriftRechargeTransaction
30614 
 
30615 
  def read(self, iprot):
30616 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
30617 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
30618 
      return
30619 
    iprot.readStructBegin()
30620 
    while True:
30621 
      (fname, ftype, fid) = iprot.readFieldBegin()
30622 
      if ftype == TType.STOP:
30623 
        break
30624 
      if fid == 1:
30625 
        if ftype == TType.STRUCT:
30626 
          self.thriftRechargeTransaction = RechargeTransaction()
30627 
          self.thriftRechargeTransaction.read(iprot)
30628 
        else:
30629 
          iprot.skip(ftype)
30630 
      else:
30631 
        iprot.skip(ftype)
30632 
      iprot.readFieldEnd()
30633 
    iprot.readStructEnd()
30634 
 
30635 
  def write(self, oprot):
30636 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
30637 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
30638 
      return
30639 
    oprot.writeStructBegin('createRechargeTransaction_args')
30640 
    if self.thriftRechargeTransaction is not None:
30641 
      oprot.writeFieldBegin('thriftRechargeTransaction', TType.STRUCT, 1)
30642 
      self.thriftRechargeTransaction.write(oprot)
30643 
      oprot.writeFieldEnd()
30644 
    oprot.writeFieldStop()
30645 
    oprot.writeStructEnd()
30646 
 
30647 
  def validate(self):
30648 
    return
30649 
 
30650 
 
30651 
  def __repr__(self):
30652 
    L = ['%s=%r' % (key, value)
30653 
      for key, value in self.__dict__.iteritems()]
30654 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
30655 
 
30656 
  def __eq__(self, other):
30657 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
30658 
 
30659 
  def __ne__(self, other):
30660 
    return not (self == other)
30661 
 
30662 
class createRechargeTransaction_result:
30663 
  """
30664 
  Attributes:
30665 
   - success
30666 
  """
30667 
 
30668 
  thrift_spec = (
30669 
    (0, TType.STRUCT, 'success', (RechargeTransaction, RechargeTransaction.thrift_spec), None, ), # 0
30670 
  )
30671 
 
30672 
  def __init__(self, success=None,):
30673 
    self.success = success
30674 
 
30675 
  def read(self, iprot):
30676 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
30677 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
30678 
      return
30679 
    iprot.readStructBegin()
30680 
    while True:
30681 
      (fname, ftype, fid) = iprot.readFieldBegin()
30682 
      if ftype == TType.STOP:
30683 
        break
30684 
      if fid == 0:
30685 
        if ftype == TType.STRUCT:
30686 
          self.success = RechargeTransaction()
30687 
          self.success.read(iprot)
30688 
        else:
30689 
          iprot.skip(ftype)
30690 
      else:
30691 
        iprot.skip(ftype)
30692 
      iprot.readFieldEnd()
30693 
    iprot.readStructEnd()
30694 
 
30695 
  def write(self, oprot):
30696 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
30697 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
30698 
      return
30699 
    oprot.writeStructBegin('createRechargeTransaction_result')
30700 
    if self.success is not None:
30701 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
30702 
      self.success.write(oprot)
30703 
      oprot.writeFieldEnd()
30704 
    oprot.writeFieldStop()
30705 
    oprot.writeStructEnd()
30706 
 
30707 
  def validate(self):
30708 
    return
30709 
 
30710 
 
30711 
  def __repr__(self):
30712 
    L = ['%s=%r' % (key, value)
30713 
      for key, value in self.__dict__.iteritems()]
30714 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
30715 
 
30716 
  def __eq__(self, other):
30717 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
30718 
 
30719 
  def __ne__(self, other):
30720 
    return not (self == other)
7080 anupam.sin 30721 
 
30722 
class getRechargeTransaction_args:
30723 
  """
30724 
  Attributes:
30725 
   - rechargeId
30726 
  """
30727 
 
30728 
  thrift_spec = (
30729 
    None, # 0
30730 
    (1, TType.I64, 'rechargeId', None, None, ), # 1
30731 
  )
30732 
 
30733 
  def __init__(self, rechargeId=None,):
30734 
    self.rechargeId = rechargeId
30735 
 
30736 
  def read(self, iprot):
30737 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
30738 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
30739 
      return
30740 
    iprot.readStructBegin()
30741 
    while True:
30742 
      (fname, ftype, fid) = iprot.readFieldBegin()
30743 
      if ftype == TType.STOP:
30744 
        break
30745 
      if fid == 1:
30746 
        if ftype == TType.I64:
30747 
          self.rechargeId = iprot.readI64();
30748 
        else:
30749 
          iprot.skip(ftype)
30750 
      else:
30751 
        iprot.skip(ftype)
30752 
      iprot.readFieldEnd()
30753 
    iprot.readStructEnd()
30754 
 
30755 
  def write(self, oprot):
30756 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
30757 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
30758 
      return
30759 
    oprot.writeStructBegin('getRechargeTransaction_args')
30760 
    if self.rechargeId is not None:
30761 
      oprot.writeFieldBegin('rechargeId', TType.I64, 1)
30762 
      oprot.writeI64(self.rechargeId)
30763 
      oprot.writeFieldEnd()
30764 
    oprot.writeFieldStop()
30765 
    oprot.writeStructEnd()
30766 
 
30767 
  def validate(self):
30768 
    return
30769 
 
30770 
 
30771 
  def __repr__(self):
30772 
    L = ['%s=%r' % (key, value)
30773 
      for key, value in self.__dict__.iteritems()]
30774 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
30775 
 
30776 
  def __eq__(self, other):
30777 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
30778 
 
30779 
  def __ne__(self, other):
30780 
    return not (self == other)
30781 
 
30782 
class getRechargeTransaction_result:
30783 
  """
30784 
  Attributes:
30785 
   - success
30786 
  """
30787 
 
30788 
  thrift_spec = (
30789 
    (0, TType.STRUCT, 'success', (RechargeTransaction, RechargeTransaction.thrift_spec), None, ), # 0
30790 
  )
30791 
 
30792 
  def __init__(self, success=None,):
30793 
    self.success = success
30794 
 
30795 
  def read(self, iprot):
30796 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
30797 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
30798 
      return
30799 
    iprot.readStructBegin()
30800 
    while True:
30801 
      (fname, ftype, fid) = iprot.readFieldBegin()
30802 
      if ftype == TType.STOP:
30803 
        break
30804 
      if fid == 0:
30805 
        if ftype == TType.STRUCT:
30806 
          self.success = RechargeTransaction()
30807 
          self.success.read(iprot)
30808 
        else:
30809 
          iprot.skip(ftype)
30810 
      else:
30811 
        iprot.skip(ftype)
30812 
      iprot.readFieldEnd()
30813 
    iprot.readStructEnd()
30814 
 
30815 
  def write(self, oprot):
30816 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
30817 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
30818 
      return
30819 
    oprot.writeStructBegin('getRechargeTransaction_result')
30820 
    if self.success is not None:
30821 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
30822 
      self.success.write(oprot)
30823 
      oprot.writeFieldEnd()
30824 
    oprot.writeFieldStop()
30825 
    oprot.writeStructEnd()
30826 
 
30827 
  def validate(self):
30828 
    return
30829 
 
30830 
 
30831 
  def __repr__(self):
30832 
    L = ['%s=%r' % (key, value)
30833 
      for key, value in self.__dict__.iteritems()]
30834 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
30835 
 
30836 
  def __eq__(self, other):
30837 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
30838 
 
30839 
  def __ne__(self, other):
30840 
    return not (self == other)
30841 
 
30842 
class getFRCs_args:
30843 
  """
30844 
  Attributes:
30845 
   - circleId
30846 
   - operatorId
30847 
  """
30848 
 
30849 
  thrift_spec = (
30850 
    None, # 0
30851 
    (1, TType.I64, 'circleId', None, None, ), # 1
30852 
    (2, TType.I64, 'operatorId', None, None, ), # 2
30853 
  )
30854 
 
30855 
  def __init__(self, circleId=None, operatorId=None,):
30856 
    self.circleId = circleId
30857 
    self.operatorId = operatorId
30858 
 
30859 
  def read(self, iprot):
30860 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
30861 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
30862 
      return
30863 
    iprot.readStructBegin()
30864 
    while True:
30865 
      (fname, ftype, fid) = iprot.readFieldBegin()
30866 
      if ftype == TType.STOP:
30867 
        break
30868 
      if fid == 1:
30869 
        if ftype == TType.I64:
30870 
          self.circleId = iprot.readI64();
30871 
        else:
30872 
          iprot.skip(ftype)
30873 
      elif fid == 2:
30874 
        if ftype == TType.I64:
30875 
          self.operatorId = iprot.readI64();
30876 
        else:
30877 
          iprot.skip(ftype)
30878 
      else:
30879 
        iprot.skip(ftype)
30880 
      iprot.readFieldEnd()
30881 
    iprot.readStructEnd()
30882 
 
30883 
  def write(self, oprot):
30884 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
30885 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
30886 
      return
30887 
    oprot.writeStructBegin('getFRCs_args')
30888 
    if self.circleId is not None:
30889 
      oprot.writeFieldBegin('circleId', TType.I64, 1)
30890 
      oprot.writeI64(self.circleId)
30891 
      oprot.writeFieldEnd()
30892 
    if self.operatorId is not None:
30893 
      oprot.writeFieldBegin('operatorId', TType.I64, 2)
30894 
      oprot.writeI64(self.operatorId)
30895 
      oprot.writeFieldEnd()
30896 
    oprot.writeFieldStop()
30897 
    oprot.writeStructEnd()
30898 
 
30899 
  def validate(self):
30900 
    return
30901 
 
30902 
 
30903 
  def __repr__(self):
30904 
    L = ['%s=%r' % (key, value)
30905 
      for key, value in self.__dict__.iteritems()]
30906 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
30907 
 
30908 
  def __eq__(self, other):
30909 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
30910 
 
30911 
  def __ne__(self, other):
30912 
    return not (self == other)
30913 
 
30914 
class getFRCs_result:
30915 
  """
30916 
  Attributes:
30917 
   - success
30918 
  """
30919 
 
30920 
  thrift_spec = (
30921 
    (0, TType.LIST, 'success', (TType.STRUCT,(FRC, FRC.thrift_spec)), None, ), # 0
30922 
  )
30923 
 
30924 
  def __init__(self, success=None,):
30925 
    self.success = success
30926 
 
30927 
  def read(self, iprot):
30928 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
30929 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
30930 
      return
30931 
    iprot.readStructBegin()
30932 
    while True:
30933 
      (fname, ftype, fid) = iprot.readFieldBegin()
30934 
      if ftype == TType.STOP:
30935 
        break
30936 
      if fid == 0:
30937 
        if ftype == TType.LIST:
30938 
          self.success = []
30939 
          (_etype740, _size737) = iprot.readListBegin()
30940 
          for _i741 in xrange(_size737):
30941 
            _elem742 = FRC()
30942 
            _elem742.read(iprot)
30943 
            self.success.append(_elem742)
30944 
          iprot.readListEnd()
30945 
        else:
30946 
          iprot.skip(ftype)
30947 
      else:
30948 
        iprot.skip(ftype)
30949 
      iprot.readFieldEnd()
30950 
    iprot.readStructEnd()
30951 
 
30952 
  def write(self, oprot):
30953 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
30954 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
30955 
      return
30956 
    oprot.writeStructBegin('getFRCs_result')
30957 
    if self.success is not None:
30958 
      oprot.writeFieldBegin('success', TType.LIST, 0)
30959 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
30960 
      for iter743 in self.success:
30961 
        iter743.write(oprot)
30962 
      oprot.writeListEnd()
30963 
      oprot.writeFieldEnd()
30964 
    oprot.writeFieldStop()
30965 
    oprot.writeStructEnd()
30966 
 
30967 
  def validate(self):
30968 
    return
30969 
 
30970 
 
30971 
  def __repr__(self):
30972 
    L = ['%s=%r' % (key, value)
30973 
      for key, value in self.__dict__.iteritems()]
30974 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
30975 
 
30976 
  def __eq__(self, other):
30977 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
30978 
 
30979 
  def __ne__(self, other):
30980 
    return not (self == other)